diff --git a/extension/content/frame-speed-snapshot.js b/extension/content/frame-speed-snapshot.js
index af921cd..fe765e6 100644
--- a/extension/content/frame-speed-snapshot.js
+++ b/extension/content/frame-speed-snapshot.js
@@ -8,7 +8,15 @@
     if (!v) return null;
     return {
       speed: v.playbackRate,
-      preferred: !v.paused
+      preferred: !v.paused,
+      forceLastSavedSpeed: Boolean(
+        typeof tc === "object" && tc.settings && tc.settings.forceLastSavedSpeed
+      ),
+      forceLastSavedSpeedControlledBySiteRule: Boolean(
+        typeof tc === "object" &&
+          tc.activeSiteRule &&
+          tc.activeSiteRule.forceLastSavedSpeed !== undefined
+      )
     };
   } catch (e) {
     return null;
diff --git a/extension/content/inject.css b/extension/content/inject.css
index fe76a0c..2acdfed 100644
--- a/extension/content/inject.css
+++ b/extension/content/inject.css
@@ -12,6 +12,24 @@
   overflow: visible !important;
 }
 
+/* Native media controls can fullscreen the replaced <video> element without
+   calling the page's requestFullscreen method. A manual popover keeps the
+   controller in the browser top layer without nesting it inside <video>. */
+.vsc-controller.vsc-fullscreen-popover {
+  position: fixed !important;
+  inset: auto !important;
+  margin: 0 !important;
+  padding: 0 !important;
+  border: 0 !important;
+  background: transparent !important;
+  overflow: visible !important;
+}
+
+.vsc-controller.vsc-fullscreen-popover::backdrop {
+  pointer-events: none !important;
+  background: transparent !important;
+}
+
 .vsc-nosource {
   display: none !important;
 }
diff --git a/extension/content/inject.js b/extension/content/inject.js
index a8052e3..83952ac 100644
--- a/extension/content/inject.js
+++ b/extension/content/inject.js
@@ -5,52 +5,154 @@ var speederShared =
 var controllerUtils = speederShared.controllerUtils || {};
 var keyBindingUtils = speederShared.keyBindings || {};
 var siteRuleUtils = speederShared.siteRules || {};
+var sharedSettingsDefaults =
+  typeof vscGetSettingsDefaults === "function"
+    ? vscGetSettingsDefaults()
+    : null;
 
-function getPrimaryVideoElement() {
-  if (!tc.mediaElements || tc.mediaElements.length === 0) return null;
-  for (var i = 0; i < tc.mediaElements.length; i++) {
-    var el = tc.mediaElements[i];
-    if (el && !el.paused) return el;
+function getSharedDefault(key, fallback) {
+  if (
+    sharedSettingsDefaults &&
+    Object.prototype.hasOwnProperty.call(sharedSettingsDefaults, key)
+  ) {
+    var value = sharedSettingsDefaults[key];
+    if (Array.isArray(value)) {
+      return value.map(function(item) {
+        return item && typeof item === "object"
+          ? Object.assign({}, item)
+          : item;
+      });
+    }
+    return value;
   }
-  return tc.mediaElements[0];
+  return fallback;
+}
+
+function getPrimaryVideoElement(mediaElements) {
+  var candidates = Array.isArray(mediaElements)
+    ? mediaElements
+    : tc.mediaElements;
+  if (!candidates || candidates.length === 0) return null;
+
+  var best = null;
+  var bestScore = -Infinity;
+  candidates.forEach(function(el, index) {
+    if (!el || !el.vsc || !el.isConnected) return;
+
+    var rect = null;
+    try {
+      rect = el.getBoundingClientRect();
+    } catch (_error) {}
+
+    var width = rect && Number(rect.width) > 0 ? Number(rect.width) : 0;
+    var height = rect && Number(rect.height) > 0 ? Number(rect.height) : 0;
+    var win = el.ownerDocument && el.ownerDocument.defaultView;
+    var viewportWidth = (win && win.innerWidth) || width;
+    var viewportHeight = (win && win.innerHeight) || height;
+    var visibleWidth = rect
+      ? Math.max(0, Math.min(rect.right, viewportWidth) - Math.max(rect.left, 0))
+      : 0;
+    var visibleHeight = rect
+      ? Math.max(0, Math.min(rect.bottom, viewportHeight) - Math.max(rect.top, 0))
+      : 0;
+    var visibleArea = visibleWidth * visibleHeight;
+    var visuallyAvailable = visibleArea > 0;
+    try {
+      var computed = win && win.getComputedStyle(el);
+      if (
+        computed &&
+        (computed.display === "none" ||
+          computed.visibility === "hidden" ||
+          Number(computed.opacity) === 0)
+      ) {
+        visuallyAvailable = false;
+      }
+    } catch (_error) {}
+
+    var score = visibleArea;
+    if (visuallyAvailable) score += 1e12;
+    if (!el.paused && !el.ended) {
+      score += visuallyAvailable ? 1e11 : 1e6;
+    }
+    if (el.vsc.lastActivityAt) {
+      score += Math.max(0, 1e9 - (Date.now() - el.vsc.lastActivityAt));
+    }
+    if (el.ended) score -= 1e11;
+    // Stable tie-break: prefer the most recently registered media element.
+    score += index / 1000;
+
+    if (score > bestScore) {
+      best = el;
+      bestScore = score;
+    }
+  });
+
+  return best;
 }
 
 var tc = {
   settings: {
-    lastSpeed: 1.0,
-    enabled: true,
+    lastSpeed: getSharedDefault("lastSpeed", 1.0),
+    enabled: getSharedDefault("enabled", true),
     speeds: {},
-    rememberSpeed: false,
-    forceLastSavedSpeed: false,
-    audioBoolean: false,
-    startHidden: false,
-    hideWithYouTubeControls: false,
-    hideWithControls: false,
-    hideWithControlsTimer: 2.0,
-    controllerLocation: "top-left",
-    controllerOpacity: 0.3,
-    controllerMarginTop: 0,
-    controllerMarginRight: 0,
-    controllerMarginBottom: 65,
-    controllerMarginLeft: 0,
-    keyBindings: [],
-    siteRules: [],
-    controllerButtons: ["rewind", "slower", "faster", "advance", "display"],
+    rememberSpeed: getSharedDefault("rememberSpeed", false),
+    forceLastSavedSpeed: getSharedDefault("forceLastSavedSpeed", false),
+    audioBoolean: getSharedDefault("audioBoolean", false),
+    startHidden: getSharedDefault("startHidden", false),
+    hideWithYouTubeControls: getSharedDefault(
+      "hideWithYouTubeControls",
+      false
+    ),
+    hideWithControls: getSharedDefault("hideWithControls", false),
+    hideWithControlsTimer: getSharedDefault("hideWithControlsTimer", 2.0),
+    controllerLocation: getSharedDefault("controllerLocation", "top-left"),
+    controllerOpacity: getSharedDefault("controllerOpacity", 0.3),
+    controllerMarginTop: getSharedDefault("controllerMarginTop", 0),
+    controllerMarginRight: getSharedDefault("controllerMarginRight", 0),
+    controllerMarginBottom: getSharedDefault("controllerMarginBottom", 65),
+    controllerMarginLeft: getSharedDefault("controllerMarginLeft", 0),
+    shortcutTargetMode: getSharedDefault("shortcutTargetMode", "closest"),
+    keyBindings: getSharedDefault("keyBindings", []),
+    siteRules: getSharedDefault("siteRules", []),
+    controllerButtons: getSharedDefault("controllerButtons", [
+      "rewind",
+      "slower",
+      "faster",
+      "advance",
+      "display"
+    ]),
     defaultLogLevel: 3,
     logLevel: 3,
-    enableSubtitleNudge: false,
-    subtitleNudgeEnabledByDefault: true,
-    subtitleNudgeInterval: 50, // Default 50ms balances subtitle tracking with CPU cost
-    subtitleNudgeAmount: 0.001,
+    enableSubtitleNudge: getSharedDefault("enableSubtitleNudge", false),
+    subtitleNudgeEnabledByDefault: getSharedDefault(
+      "subtitleNudgeEnabledByDefault",
+      true
+    ),
+    subtitleNudgeInterval: getSharedDefault("subtitleNudgeInterval", 50),
+    subtitleNudgeAmount: getSharedDefault("subtitleNudgeAmount", 0.001),
     customButtonIcons: {}
   },
   mediaElements: [],
   isNudging: false,
   pendingLastSpeedSave: null,
   pendingLastSpeedValue: null,
+  lastSpeedSaveRetries: 0,
+  lastSpeedWriteInFlight: false,
+  lastSpeedWriteValue: null,
+  pendingRememberedSpeedsSave: null,
+  rememberedSpeedsSaveRetries: 0,
+  rememberedSpeedsWriteEpoch: 0,
+  rememberedSpeedsWriteInFlight: null,
+  rememberedSpeedsResetAt: 0,
+  speedAccessTimes: {},
   persistedLastSpeed: 1.0,
   activeSiteRule: null,
-  siteRuleBase: null
+  siteRuleBase: null,
+  runtimeSettingsHydrated: false,
+  pendingMediaCandidates: [],
+  settingsReloadRetries: 0,
+  lastPointerPosition: null,
+  lastInteractedMedia: null
 };
 
 var MIN_SPEED = 0.0625;
@@ -60,7 +162,9 @@ var YT_NATIVE_MAX = 2.0;
 var YT_NATIVE_STEP = 0.05;
 var vscObservedRoots = new WeakSet();
 var vscConnectedScannedRoots = new WeakSet();
-var vscInitializedDocuments = new Set();
+var vscInitializedDocuments = new WeakSet();
+var vscSourceObjectIds = new WeakMap();
+var vscNextSourceObjectId = 1;
 var requestIdle =
   typeof window.requestIdleCallback === "function"
     ? window.requestIdleCallback.bind(window)
@@ -386,6 +490,7 @@ function captureSiteRuleBase() {
     controllerOpacity: tc.settings.controllerOpacity,
     controllerMarginTop: tc.settings.controllerMarginTop,
     controllerMarginBottom: tc.settings.controllerMarginBottom,
+    shortcutTargetMode: tc.settings.shortcutTargetMode,
     enableSubtitleNudge: tc.settings.enableSubtitleNudge,
     subtitleNudgeEnabledByDefault: tc.settings.subtitleNudgeEnabledByDefault,
     subtitleNudgeInterval: tc.settings.subtitleNudgeInterval,
@@ -413,6 +518,7 @@ function resetSettingsFromSiteRuleBase() {
   tc.settings.controllerOpacity = base.controllerOpacity;
   tc.settings.controllerMarginTop = base.controllerMarginTop;
   tc.settings.controllerMarginBottom = base.controllerMarginBottom;
+  tc.settings.shortcutTargetMode = base.shortcutTargetMode;
   tc.settings.enableSubtitleNudge = base.enableSubtitleNudge;
   tc.settings.subtitleNudgeEnabledByDefault = base.subtitleNudgeEnabledByDefault;
   tc.settings.subtitleNudgeInterval = base.subtitleNudgeInterval;
@@ -521,7 +627,11 @@ function normalizeStoredBinding(binding, fallbackCode) {
       action: binding.action,
       code: null,
       disabled: true,
-      value: Number(binding.value),
+      value: keyBindingUtils.sanitizeActionValue(
+        binding.action,
+        binding.value,
+        0
+      ),
       force: String(binding.force) === "true" ? "true" : "false",
       predefined: Boolean(binding.predefined)
     };
@@ -536,7 +646,11 @@ function normalizeStoredBinding(binding, fallbackCode) {
     action: binding.action,
     code: normalizedCode,
     disabled: false,
-    value: Number(binding.value),
+    value: keyBindingUtils.sanitizeActionValue(
+      binding.action,
+      binding.value,
+      0
+    ),
     force: String(binding.force) === "true" ? "true" : "false",
     predefined: Boolean(binding.predefined)
   };
@@ -554,7 +668,20 @@ function sanitizeSpeed(speed, fallback) {
 }
 
 function getVideoSourceKey(video) {
-  return (video && (video.currentSrc || video.src)) || "unknown_src";
+  if (!video) return "unknown_src";
+
+  var sourceObject = video.srcObject;
+  if (
+    sourceObject &&
+    (typeof sourceObject === "object" || typeof sourceObject === "function")
+  ) {
+    if (!vscSourceObjectIds.has(sourceObject)) {
+      vscSourceObjectIds.set(sourceObject, vscNextSourceObjectId++);
+    }
+    return "src_object:" + vscSourceObjectIds.get(sourceObject);
+  }
+
+  return video.currentSrc || video.src || "unknown_src";
 }
 
 function getControllerTargetSpeed(video) {
@@ -589,21 +716,23 @@ function getRememberedSpeed(video) {
     return null;
   }
 
+  // Force is deliberately global and must outrank stale per-source memory.
+  if (tc.settings.forceLastSavedSpeed && isValidSpeed(tc.settings.lastSpeed)) {
+    return tc.settings.lastSpeed;
+  }
+
   var sourceKey = getVideoSourceKey(video);
   if (sourceKey !== "unknown_src") {
     var videoSpeed = tc.settings.speeds[sourceKey];
     if (isValidSpeed(videoSpeed)) return videoSpeed;
   }
-  if (tc.settings.forceLastSavedSpeed && isValidSpeed(tc.settings.lastSpeed)) {
-    return tc.settings.lastSpeed;
-  }
-  if (tc.settings.rememberSpeed && isValidSpeed(tc.settings.lastSpeed)) {
-    return tc.settings.lastSpeed;
-  }
   return null;
 }
 
 function getDesiredSpeed(video) {
+  if (tc.settings.forceLastSavedSpeed && isValidSpeed(tc.settings.lastSpeed)) {
+    return tc.settings.lastSpeed;
+  }
   return getControllerTargetSpeed(video) || getRememberedSpeed(video) || 1.0;
 }
 
@@ -774,24 +903,227 @@ function updateSubtitleNudgeIndicator(video) {
   }
 }
 
+function flushPendingLastSpeed() {
+  tc.pendingLastSpeedSave = null;
+  if (tc.lastSpeedWriteInFlight) return;
+
+  var speedToPersist = tc.pendingLastSpeedValue;
+  tc.pendingLastSpeedValue = null;
+
+  if (!isValidSpeed(speedToPersist) || tc.persistedLastSpeed === speedToPersist) {
+    return;
+  }
+
+  tc.lastSpeedWriteInFlight = true;
+  tc.lastSpeedWriteValue = speedToPersist;
+  chrome.storage.sync.set({ lastSpeed: speedToPersist }, function() {
+    tc.lastSpeedWriteInFlight = false;
+    tc.lastSpeedWriteValue = null;
+    var retryDelay = 250;
+    if (chrome.runtime.lastError) {
+      if (tc.lastSpeedSaveRetries < 3) {
+        tc.lastSpeedSaveRetries += 1;
+        if (!isValidSpeed(tc.pendingLastSpeedValue)) {
+          tc.pendingLastSpeedValue = speedToPersist;
+        }
+        retryDelay = 500 * tc.lastSpeedSaveRetries;
+      }
+    } else {
+      tc.lastSpeedSaveRetries = 0;
+      tc.persistedLastSpeed = speedToPersist;
+    }
+
+    if (
+      isValidSpeed(tc.pendingLastSpeedValue) &&
+      tc.pendingLastSpeedValue !== tc.persistedLastSpeed &&
+      tc.pendingLastSpeedSave === null
+    ) {
+      tc.pendingLastSpeedSave = setTimeout(
+        flushPendingLastSpeed,
+        retryDelay
+      );
+    } else if (tc.pendingLastSpeedValue === tc.persistedLastSpeed) {
+      tc.pendingLastSpeedValue = null;
+    }
+  });
+}
+
 function schedulePersistLastSpeed(speed) {
   if (!isValidSpeed(speed)) return;
 
   tc.pendingLastSpeedValue = speed;
-  if (tc.pendingLastSpeedSave !== null) return;
+  if (tc.pendingLastSpeedSave !== null || tc.lastSpeedWriteInFlight) return;
+  tc.pendingLastSpeedSave = setTimeout(flushPendingLastSpeed, 250);
+}
 
-  tc.pendingLastSpeedSave = setTimeout(function() {
-    var speedToPersist = tc.pendingLastSpeedValue;
-    tc.pendingLastSpeedSave = null;
+var MAX_PERSISTED_SOURCE_SPEEDS = 200;
 
-    if (!isValidSpeed(speedToPersist) || tc.persistedLastSpeed === speedToPersist) {
+function isPersistableSourceKey(sourceKey) {
+  return Boolean(
+    sourceKey &&
+      sourceKey !== "unknown_src" &&
+      sourceKey.indexOf("src_object:") !== 0 &&
+      sourceKey.indexOf("blob:") !== 0 &&
+      sourceKey.length <= 2048
+  );
+}
+
+function buildRememberedSpeedsPayload() {
+  var entries = Object.keys(tc.settings.speeds)
+    .filter(function(sourceKey) {
+      return (
+        isPersistableSourceKey(sourceKey) &&
+        isValidSpeed(Number(tc.settings.speeds[sourceKey]))
+      );
+    })
+    .map(function(sourceKey) {
+      return {
+        sourceKey: sourceKey,
+        speed: Number(tc.settings.speeds[sourceKey]),
+        updatedAt: Number(tc.speedAccessTimes[sourceKey]) || 0
+      };
+    })
+    .sort(function(a, b) {
+      return b.updatedAt - a.updatedAt;
+    })
+    .slice(0, MAX_PERSISTED_SOURCE_SPEEDS);
+
+  var payload = {};
+  entries.forEach(function(entry) {
+    payload[entry.sourceKey] = {
+      speed: entry.speed,
+      updatedAt: entry.updatedAt
+    };
+  });
+  return payload;
+}
+
+function reconcileRememberedSpeedsAfterStaleWrite() {
+  var repairEpoch = tc.rememberedSpeedsWriteEpoch;
+  chrome.storage.local.get({ rememberedSpeeds: {} }, function(localStorage) {
+    if (
+      chrome.runtime.lastError ||
+      repairEpoch !== tc.rememberedSpeedsWriteEpoch
+    ) {
       return;
     }
+    mergeRememberedSpeeds(localStorage && localStorage.rememberedSpeeds);
+    var repairedPayload = buildRememberedSpeedsPayload();
+    chrome.storage.local.set({ rememberedSpeeds: repairedPayload });
+  });
+}
 
-    chrome.storage.sync.set({ lastSpeed: speedToPersist }, function() {
+function schedulePersistRememberedSpeeds(forceSave) {
+  if (!tc.settings.rememberSpeed && forceSave !== true) return;
+  if (tc.pendingRememberedSpeedsSave !== null) return;
+  if (tc.rememberedSpeedsWriteInFlight) {
+    tc.pendingRememberedSpeedsSave = setTimeout(function() {
+      tc.pendingRememberedSpeedsSave = null;
+      schedulePersistRememberedSpeeds(true);
+    }, 100);
+    return;
+  }
+
+  tc.pendingRememberedSpeedsSave = setTimeout(function() {
+    tc.pendingRememberedSpeedsSave = null;
+    var currentPayload = buildRememberedSpeedsPayload();
+    var writeEpoch = tc.rememberedSpeedsWriteEpoch;
+    tc.rememberedSpeedsWriteInFlight = {
+      epoch: writeEpoch,
+      payload: null
+    };
+
+    // Merge at write time so independent frame content scripts do not erase
+    // each other's more recent source entries.
+    chrome.storage.local.get({ rememberedSpeeds: {} }, function(localStorage) {
+      if (writeEpoch !== tc.rememberedSpeedsWriteEpoch) {
+        tc.rememberedSpeedsWriteInFlight = null;
+        return;
+      }
+      if (chrome.runtime.lastError) {
+        tc.rememberedSpeedsWriteInFlight = null;
+        if (tc.rememberedSpeedsSaveRetries < 3) {
+          tc.rememberedSpeedsSaveRetries += 1;
+          schedulePersistRememberedSpeeds(true);
+        }
+        return;
+      }
+      var merged = {};
+      var existing =
+        localStorage &&
+        localStorage.rememberedSpeeds &&
+        typeof localStorage.rememberedSpeeds === "object"
+          ? localStorage.rememberedSpeeds
+          : {};
+
+      [existing, currentPayload].forEach(function(sourceMap) {
+        Object.keys(sourceMap).forEach(function(sourceKey) {
+          var entry = sourceMap[sourceKey];
+          if (
+            !isPersistableSourceKey(sourceKey) ||
+            !entry ||
+            !isValidSpeed(Number(entry.speed)) ||
+            (tc.rememberedSpeedsResetAt > 0 &&
+              (Number(entry.updatedAt) || 0) <= tc.rememberedSpeedsResetAt)
+          ) {
+            return;
+          }
+          var previous = merged[sourceKey];
+          if (
+            !previous ||
+            Number(entry.updatedAt) >= Number(previous.updatedAt)
+          ) {
+            merged[sourceKey] = {
+              speed: Number(entry.speed),
+              updatedAt: Number(entry.updatedAt) || 0
+            };
+          }
+        });
+      });
+
+      var pruned = {};
+      Object.keys(merged)
+        .sort(function(a, b) {
+          return merged[b].updatedAt - merged[a].updatedAt;
+        })
+        .slice(0, MAX_PERSISTED_SOURCE_SPEEDS)
+        .forEach(function(sourceKey) {
+          pruned[sourceKey] = merged[sourceKey];
+        });
+      tc.rememberedSpeedsWriteInFlight.payload = pruned;
+      chrome.storage.local.set({ rememberedSpeeds: pruned }, function() {
+        var writeBecameStale =
+          writeEpoch !== tc.rememberedSpeedsWriteEpoch;
+        tc.rememberedSpeedsWriteInFlight = null;
+        if (writeBecameStale) {
+          reconcileRememberedSpeedsAfterStaleWrite();
+          return;
+        }
+        if (chrome.runtime.lastError) {
+          if (tc.rememberedSpeedsSaveRetries < 3) {
+            tc.rememberedSpeedsSaveRetries += 1;
+            schedulePersistRememberedSpeeds(true);
+          }
+          return;
+        }
+        tc.rememberedSpeedsSaveRetries = 0;
+      });
     });
-    tc.persistedLastSpeed = speedToPersist;
-  }, 250);
+  }, 500);
+}
+
+function rememberSourceSpeed(video, speed) {
+  if (!tc.settings.rememberSpeed || !isValidSpeed(speed)) return;
+  var sourceKey = getVideoSourceKey(video);
+  if (sourceKey === "unknown_src") return;
+  tc.settings.speeds[sourceKey] = Number(speed);
+  tc.speedAccessTimes[sourceKey] = Math.max(
+    Date.now(),
+    tc.rememberedSpeedsResetAt + 1
+  );
+  if (isPersistableSourceKey(sourceKey)) {
+    schedulePersistRememberedSpeeds();
+  }
 }
 
 function suppressNextNudgeRateChanges(controller, count) {
@@ -829,29 +1161,34 @@ function resolveTargetSpeed(video) {
 function applySourceTransitionPolicy(video, forceUpdate) {
   if (!video || !video.vsc) return;
 
+  // A same-document navigation can change the applicable playback rule before
+  // or after the player swaps its source. Always resolve the URL first.
+  if (!reapplySiteRulesAndControllerGeometry()) return;
+  if (!video.vsc) return;
+
   var sourceKey = getVideoSourceKey(video);
   if (!forceUpdate && video.vsc.mediaSourceKey === sourceKey) return;
 
   video.vsc.mediaSourceKey = sourceKey;
 
-  var desiredSpeed =
-    tc.settings.rememberSpeed || tc.settings.forceLastSavedSpeed
-      ? sanitizeSpeed(tc.settings.lastSpeed, 1.0)
-      : 1.0;
+  var rememberedSpeed = getRememberedSpeed(video);
+  var desiredSpeed = isValidSpeed(rememberedSpeed) ? rememberedSpeed : 1.0;
 
   video.vsc.targetSpeed = desiredSpeed;
   video.vsc.targetSpeedSourceKey = sourceKey;
+  video.vsc.targetSpeedOrigin = isValidSpeed(rememberedSpeed)
+    ? "policy"
+    : "source-reset";
   if (video.vsc.speedIndicator) {
     video.vsc.speedIndicator.textContent = desiredSpeed.toFixed(2);
   }
 
+  if (isValidSpeed(rememberedSpeed)) {
+    extendSpeedRestoreWindow(video);
+  }
   if (Math.abs(video.playbackRate - desiredSpeed) > 0.01) {
     setSpeed(video, desiredSpeed, false, false);
   }
-
-  // Same-tab SPA (e.g. YouTube watch → Shorts): URL can change while remember-speed
-  // already ran on src mutation — re-apply margins / location / opacity for new rules.
-  reapplySiteRulesAndControllerGeometry();
 }
 
 function extendSpeedRestoreWindow(video, duration) {
@@ -864,6 +1201,91 @@ function extendSpeedRestoreWindow(video, duration) {
   video.vsc.speedRestoreUntil = Math.max(currentUntil, restoreUntil);
 }
 
+function clearAllSpeedRestoreEnforcement() {
+  tc.mediaElements.slice().forEach(function(video) {
+    if (!video || !video.vsc) return;
+    video.vsc.speedRestoreUntil = 0;
+    if (video.vsc.restoreSpeedTimer) {
+      clearTimeout(video.vsc.restoreSpeedTimer);
+      video.vsc.restoreSpeedTimer = null;
+    }
+    clearSpeedVerification(video.vsc);
+    if (video.vsc.targetSpeedOrigin === "policy") {
+      video.vsc.targetSpeed = null;
+      video.vsc.targetSpeedSourceKey = null;
+      video.vsc.targetSpeedOrigin = null;
+      video.vsc.stopSubtitleNudge();
+    }
+  });
+}
+
+function clearSpeedVerification(controller) {
+  if (!controller) return;
+  if (controller.speedVerificationTimer) {
+    clearTimeout(controller.speedVerificationTimer);
+  }
+  controller.speedVerificationTimer = null;
+  controller.speedVerificationTarget = null;
+  controller.speedVerificationAttempts = 0;
+}
+
+function scheduleSpeedVerification(video, desiredSpeed, resetAttempts) {
+  if (!video || !video.vsc || !isValidSpeed(desiredSpeed)) return;
+  var controller = video.vsc;
+  if (
+    resetAttempts === true ||
+    controller.speedVerificationTarget !== desiredSpeed
+  ) {
+    controller.speedVerificationAttempts = 0;
+  }
+  controller.speedVerificationTarget = desiredSpeed;
+  if (controller.speedVerificationTimer) {
+    clearTimeout(controller.speedVerificationTimer);
+  }
+
+  controller.speedVerificationTimer = setTimeout(function verifySpeed() {
+    if (!video.vsc || video.vsc !== controller) return;
+    controller.speedVerificationTimer = null;
+    var actualSpeed;
+    try {
+      actualSpeed = Number(video.playbackRate);
+    } catch (error) {
+      actualSpeed = NaN;
+    }
+    if (isValidSpeed(actualSpeed) && Math.abs(actualSpeed - desiredSpeed) <= 0.01) {
+      clearSpeedVerification(controller);
+      return;
+    }
+
+    var restoreIsActive =
+      Number(controller.speedRestoreUntil) > Date.now();
+    var policyIsActive =
+      tc.settings.forceLastSavedSpeed ||
+      (tc.settings.rememberSpeed && controller.targetSpeedOrigin === "policy");
+    if (
+      (!restoreIsActive && !policyIsActive) ||
+      controller.speedVerificationAttempts >= 3
+    ) {
+      clearSpeedVerification(controller);
+      log(
+        `Player rejected playbackRate ${desiredSpeed.toFixed(2)} after verification`,
+        3
+      );
+      return;
+    }
+
+    controller.speedVerificationAttempts += 1;
+    rememberPendingRateChange(video, desiredSpeed, false);
+    try {
+      video.playbackRate = desiredSpeed;
+    } catch (error) {
+      controller.pendingRateChange = null;
+      log(`Playback speed verification failed: ${error.message}`, 3);
+    }
+    scheduleSpeedVerification(video, desiredSpeed, false);
+  }, 125 * (Number(controller.speedVerificationAttempts) + 1));
+}
+
 function scheduleSpeedRestore(video, desiredSpeed, reason) {
   if (!video || !video.vsc || !isValidSpeed(desiredSpeed)) return;
 
@@ -888,11 +1310,12 @@ function scheduleSpeedRestore(video, desiredSpeed, reason) {
   }, 0);
 }
 
-function rememberPendingRateChange(video, speed) {
+function rememberPendingRateChange(video, speed, shouldPersist) {
   if (!video || !video.vsc || !isValidSpeed(speed)) return;
 
   video.vsc.pendingRateChange = {
     speed: Number(speed),
+    shouldPersist: shouldPersist === true,
     expiresAt: Date.now() + 1000
   };
 }
@@ -940,6 +1363,18 @@ function isMediaElement(node) {
   );
 }
 
+function isAmbientLoopMedia(node) {
+  return Boolean(
+    node &&
+      node.nodeName === "VIDEO" &&
+      node.autoplay === true &&
+      (node.muted === true || node.defaultMuted === true) &&
+      node.loop === true &&
+      node.playsInline === true &&
+      node.controls !== true
+  );
+}
+
 function hasUsableMediaSource(node) {
   if (!isMediaElement(node) || !node.isConnected) return false;
   if (node.currentSrc || node.src || node.srcObject) return true;
@@ -965,8 +1400,80 @@ function hasUsableMediaSource(node) {
   return false;
 }
 
+function getControllerStructureSignature() {
+  return JSON.stringify({
+    buttons: Array.isArray(tc.settings.controllerButtons)
+      ? tc.settings.controllerButtons
+      : [],
+    startHidden: tc.settings.startHidden === true
+  });
+}
+
 function ensureController(node, parent) {
-  if (!isMediaElement(node) || node.vsc) return node && node.vsc;
+  if (!tc.runtimeSettingsHydrated) {
+    if (
+      node &&
+      (node.nodeName === "VIDEO" || node.nodeName === "AUDIO") &&
+      !tc.pendingMediaCandidates.some(function(candidate) {
+        return candidate.node === node;
+      })
+    ) {
+      tc.pendingMediaCandidates.push({ node: node, parent: parent });
+    }
+    return null;
+  }
+  if (!isMediaElement(node)) return null;
+  if (isAmbientLoopMedia(node)) {
+    if (node.vsc) removeController(node);
+    return null;
+  }
+  if (typeof tc.videoController === "undefined") defineVideoController();
+
+  // href selects site rules; re-run on every new/usable media so all runtime
+  // paths agree on activation and effective settings.
+  applySiteRuleOverrides();
+  if (!siteRuleUtils.isSpeederActiveForSite(tc.settings.enabled, tc.activeSiteRule)) {
+    if (node.vsc) removeController(node);
+    return null;
+  }
+
+  if (
+    node.vsc &&
+    (
+      !node.vsc.div ||
+      typeof node.vsc.remove !== "function" ||
+      node.vsc.structureSignature !== getControllerStructureSignature()
+    )
+  ) {
+    removeController(node);
+  }
+
+  if (node.vsc) {
+    var existingController = node.vsc;
+    var hasSource = hasUsableMediaSource(node);
+    if (existingController.div) {
+      existingController.div.classList.toggle("vsc-nosource", !hasSource);
+    }
+
+    var fullscreenElement = getFullscreenElement(node.ownerDocument);
+    var normalMount = getControllerMount(node) || parent || node.parentNode;
+    if (normalMount) existingController.normalControllerMount = normalMount;
+    if (
+      fullscreenElement &&
+      (fullscreenElement === node ||
+        isComposedDescendant(node, fullscreenElement))
+    ) {
+      syncControllerFullscreenMount(existingController);
+    } else if (normalMount) {
+      remountControllerHost(existingController, normalMount);
+    }
+
+    if (hasSource) {
+      applySourceTransitionPolicy(node, false);
+    }
+    return existingController;
+  }
+
   if (!hasUsableMediaSource(node)) {
     log(
       `Deferring controller creation for ${node.tagName}: no usable source yet`,
@@ -975,24 +1482,48 @@ function ensureController(node, parent) {
     return null;
   }
 
-  // href selects site rules; re-run on every new/usable media so margins/opacity match current URL.
-  applySiteRuleOverrides();
-  if (!siteRuleUtils.isSpeederActiveForSite(tc.settings.enabled, tc.activeSiteRule)) {
-    return null;
-  }
   refreshAllControllerGeometry();
 
   log(
     `Creating controller for ${node.tagName}: ${node.src || node.currentSrc || "no src"}`,
     4
   );
-  node.vsc = new tc.videoController(
-    node,
-    parent || node.parentElement || node.parentNode
-  );
+  try {
+    node.vsc = new tc.videoController(
+      node,
+      parent || node.parentElement || node.parentNode
+    );
+  } catch (error) {
+    log(`Unable to create media controller: ${error.message}`, 2);
+    removeController(node);
+    return null;
+  }
+  if (!node.vsc || !node.vsc.div) {
+    log("Controller initialization returned without a control host", 3);
+    removeController(node);
+    return null;
+  }
+  if (
+    node.vsc &&
+    (tc.settings.rememberSpeed || tc.settings.forceLastSavedSpeed)
+  ) {
+    scheduleSpeedVerification(node, node.vsc.targetSpeed, true);
+  }
+  if (node.vsc) syncControllerFullscreenMount(node.vsc);
   return node.vsc;
 }
 
+function flushPendingMediaCandidates() {
+  var pending = tc.pendingMediaCandidates.splice(0);
+  pending.forEach(function(candidate) {
+    if (!candidate.node || !candidate.node.isConnected) return;
+    ensureController(
+      candidate.node,
+      candidate.node.parentElement || candidate.parent || candidate.node.parentNode
+    );
+  });
+}
+
 function ensureControllerForMediaChild(node) {
   if (!node || node.nodeType !== Node.ELEMENT_NODE) return null;
   if (node.nodeName !== "SOURCE") return null;
@@ -1003,7 +1534,22 @@ function ensureControllerForMediaChild(node) {
 }
 
 function removeController(node) {
-  if (node && node.vsc) node.vsc.remove();
+  if (!node || !node.vsc) return;
+  var controller = node.vsc;
+  if (typeof controller.remove === "function") {
+    try {
+      controller.remove();
+      return;
+    } catch (error) {
+      log(`Partial controller cleanup failed: ${error.message}`, 3);
+    }
+  }
+  if (controller.div && typeof controller.div.remove === "function") {
+    controller.div.remove();
+  }
+  var index = tc.mediaElements.indexOf(node);
+  if (index !== -1) tc.mediaElements.splice(index, 1);
+  delete node.vsc;
 }
 
 function scanNodeForMedia(node, parent, added) {
@@ -1028,10 +1574,17 @@ function scanNodeForMedia(node, parent, added) {
   if (isMediaElement(node)) {
     if (added) ensureController(node, parent);
     else removeController(node);
-  } else if (added) {
+  } else if (node.nodeName === "SOURCE") {
     // Players such as Vidstack often connect an empty <video> and append its
     // <source> later. Retry the owning video when that source becomes usable.
-    ensureControllerForMediaChild(node);
+    var owningMedia = isMediaElement(parent)
+      ? parent
+      : node.parentElement;
+    if (owningMedia) {
+      ensureController(owningMedia, owningMedia.parentNode);
+    } else if (added) {
+      ensureControllerForMediaChild(node);
+    }
   }
 
   // Use querySelectorAll instead of recursive child walking — the browser's
@@ -1099,9 +1652,35 @@ function scanRootForMedia(root) {
   var scanRoot = getScanNodeForRoot(root);
   if (!scanRoot) return;
   scanNodeForMedia(scanRoot, root.host || scanRoot.parentNode || scanRoot, true);
-  if (root.nodeType === Node.DOCUMENT_NODE) {
-    attachIframeListeners(root);
+}
+
+function rescanOpenShadowRoots(root, visited, rescanObserved) {
+  var scanRoot = getScanNodeForRoot(root);
+  if (!scanRoot || typeof scanRoot.querySelectorAll !== "function") return;
+  var seen = visited || new WeakSet();
+  var hosts = [];
+
+  if (scanRoot.nodeType === Node.ELEMENT_NODE && scanRoot.shadowRoot) {
+    hosts.push(scanRoot);
   }
+  try {
+    var elements = scanRoot.querySelectorAll("*");
+    for (var i = 0; i < elements.length; i++) {
+      if (elements[i].shadowRoot) hosts.push(elements[i]);
+    }
+  } catch (_error) {
+    return;
+  }
+
+  hosts.forEach(function(host) {
+    var shadowRoot = host.shadowRoot;
+    if (!shadowRoot || seen.has(shadowRoot)) return;
+    seen.add(shadowRoot);
+    if (rescanObserved !== false || !vscObservedRoots.has(shadowRoot)) {
+      observeRoot(shadowRoot);
+    }
+    rescanOpenShadowRoots(shadowRoot, seen, rescanObserved);
+  });
 }
 
 function observeRoot(root) {
@@ -1124,7 +1703,10 @@ function observeRoot(root) {
     attachMediaDetectionListeners(root);
   }
 
-  if (isConnected && !vscConnectedScannedRoots.has(root)) {
+  if (
+    isConnected &&
+    (!vscConnectedScannedRoots.has(root) || isShadowRootNode(root))
+  ) {
     vscConnectedScannedRoots.add(root);
     if (rootMayContainMedia(root)) {
       scanRootForMedia(root);
@@ -1156,6 +1738,100 @@ function patchAttachShadow() {
   window.vscAttachShadowPatched = true;
 }
 
+function installPageShadowBridge() {
+  if (window.vscPageShadowBridgeRequested) return;
+
+  if (!window.vscPageBridgeListenersAttached) {
+    window.vscPageBridgeListenersAttached = true;
+    document.addEventListener(
+      "speeder-shadow-root-attached",
+      function(event) {
+        var host = event.target;
+        if (!host || !host.shadowRoot) return;
+        try {
+          observeRoot(host.shadowRoot);
+        } catch (error) {
+          log(`Unable to observe page-created shadow root: ${error.message}`, 3);
+        }
+      },
+      true
+    );
+    document.addEventListener(
+      "speeder-location-changed",
+      function() {
+        scheduleNavigationRescan();
+      },
+      true
+    );
+  }
+
+  function startPersistentShadowFallback() {
+    if (window.vscPersistentShadowFallbackTimer) return;
+    window.vscPersistentShadowFallbackTimer = setInterval(function() {
+      requestIdle(
+        function() {
+          if (!document.body) return;
+          rescanOpenShadowRoots(document, undefined, false);
+        },
+        { timeout: 2000 }
+      );
+    }, 30000);
+  }
+
+  function handleBridgeFailure() {
+    window.vscPageShadowBridgeRequested = false;
+    window.vscPageShadowBridgeRetries =
+      (Number(window.vscPageShadowBridgeRetries) || 0) + 1;
+    startPersistentShadowFallback();
+    if (window.vscPageShadowBridgeRetries > 3) return;
+    clearTimeout(window.vscPageShadowBridgeRetryTimer);
+    window.vscPageShadowBridgeRetryTimer = setTimeout(function() {
+      installPageShadowBridge();
+    }, 250 * window.vscPageShadowBridgeRetries);
+  }
+
+  var parent = document.documentElement || document.head;
+  if (!parent) {
+    if (!window.vscPageShadowBridgeRetryAttached) {
+      window.vscPageShadowBridgeRetryAttached = true;
+      var retryBridgeInstall = function() {
+        if (document.documentElement || document.head) {
+          document.removeEventListener("readystatechange", retryBridgeInstall);
+          document.removeEventListener("DOMContentLoaded", retryBridgeInstall);
+          installPageShadowBridge();
+        }
+      };
+      document.addEventListener("readystatechange", retryBridgeInstall);
+      document.addEventListener("DOMContentLoaded", retryBridgeInstall);
+    }
+    return;
+  }
+  try {
+    var bridge = document.createElement("script");
+    bridge.src = chrome.runtime.getURL("content/shadow-bridge.js");
+    bridge.async = false;
+    bridge.addEventListener("load", function() {
+      bridge.remove();
+      window.vscPageShadowBridgeLoaded = true;
+      window.vscPageShadowBridgeRetries = 0;
+      clearTimeout(window.vscPageShadowBridgeRetryTimer);
+      if (window.vscPersistentShadowFallbackTimer) {
+        clearInterval(window.vscPersistentShadowFallbackTimer);
+        window.vscPersistentShadowFallbackTimer = null;
+      }
+    });
+    bridge.addEventListener("error", function() {
+      bridge.remove();
+      handleBridgeFailure();
+    });
+    window.vscPageShadowBridgeRequested = true;
+    parent.appendChild(bridge);
+  } catch (error) {
+    handleBridgeFailure();
+    log(`Unable to install page shadow bridge: ${error.message}`, 3);
+  }
+}
+
 /* Log levels */
 function log(message, level) {
   verbosity = tc.settings.logLevel;
@@ -1173,117 +1849,378 @@ function log(message, level) {
   }
 }
 
-// Patch attachShadow immediately — before any async operations — so we
-// catch shadow roots created while chrome.storage.sync.get is pending.
-// Sites like archive.org create Lit/LitElement shadow DOMs during page load;
-// waiting for the storage callback would miss them entirely.
-patchAttachShadow();
-
-chrome.storage.sync.get(tc.settings, function(storage) {
+function hydrateRuntimeSettings(rawStorage, options) {
+  var config = options || {};
+  var storage =
+    typeof vscExpandStoredSettings === "function"
+      ? vscExpandStoredSettings(rawStorage || {})
+      : Object.assign({}, tc.settings, rawStorage || {});
   var storedBindings = Array.isArray(storage.keyBindings)
     ? storage.keyBindings
     : [];
 
   tc.settings.keyBindings = storedBindings
-    .map((binding) => normalizeStoredBinding(binding))
+    .map(function(binding) {
+      return normalizeStoredBinding(binding);
+    })
     .filter(Boolean);
 
   if (tc.settings.keyBindings.length === 0) {
     tc.settings.keyBindings = defaultKeyBindings(storage);
-    tc.settings.version = "0.5.3";
-    chrome.storage.sync.set({
-      keyBindings: tc.settings.keyBindings,
-      version: tc.settings.version,
-      rememberSpeed: tc.settings.rememberSpeed,
-      forceLastSavedSpeed: tc.settings.forceLastSavedSpeed,
-      audioBoolean: tc.settings.audioBoolean,
-      startHidden: tc.settings.startHidden,
-      enabled: tc.settings.enabled,
-      controllerLocation: tc.settings.controllerLocation,
-      controllerOpacity: tc.settings.controllerOpacity
-    });
   }
-  tc.settings.lastSpeed = Number(storage.lastSpeed);
-  if (!isValidSpeed(tc.settings.lastSpeed) && tc.settings.lastSpeed !== 1.0) {
+
+  var unsavedLastSpeed = isValidSpeed(tc.pendingLastSpeedValue)
+    ? Number(tc.pendingLastSpeedValue)
+    : tc.lastSpeedWriteInFlight && isValidSpeed(tc.lastSpeedWriteValue)
+      ? Number(tc.lastSpeedWriteValue)
+      : null;
+  var hasPendingLastSpeed = Boolean(
+    config.preservePendingLastSpeed && isValidSpeed(unsavedLastSpeed)
+  );
+  var storedLastSpeed = Number(storage.lastSpeed);
+  var nextLastSpeed = hasPendingLastSpeed
+    ? unsavedLastSpeed
+    : storedLastSpeed;
+
+  if (!isValidSpeed(nextLastSpeed)) {
     log(`Invalid lastSpeed detected: ${storage.lastSpeed}, resetting to 1.0`, 3);
-    tc.settings.lastSpeed = 1.0;
-    tc.persistedLastSpeed = 1.0;
-    chrome.storage.sync.set({ lastSpeed: 1.0 });
-  } else if (!isValidSpeed(tc.settings.lastSpeed)) {
-    tc.settings.lastSpeed = 1.0;
+    nextLastSpeed = 1.0;
+    if (!hasPendingLastSpeed) {
+      chrome.storage.sync.set({ lastSpeed: 1.0 });
+    }
   }
-  tc.persistedLastSpeed = tc.settings.lastSpeed;
-  tc.settings.rememberSpeed = Boolean(storage.rememberSpeed);
-  tc.settings.forceLastSavedSpeed = Boolean(storage.forceLastSavedSpeed);
-  tc.settings.audioBoolean = Boolean(storage.audioBoolean);
-  tc.settings.enabled = Boolean(storage.enabled);
-  tc.settings.startHidden = Boolean(storage.startHidden);
+  tc.settings.lastSpeed = nextLastSpeed;
+  if (isValidSpeed(storedLastSpeed)) {
+    tc.persistedLastSpeed = storedLastSpeed;
+  } else if (!hasPendingLastSpeed) {
+    tc.persistedLastSpeed = nextLastSpeed;
+  }
+
+  tc.settings.rememberSpeed = storage.rememberSpeed === true;
+  tc.settings.forceLastSavedSpeed = storage.forceLastSavedSpeed === true;
+  tc.settings.audioBoolean = storage.audioBoolean === true;
+  tc.settings.enabled = storage.enabled !== false;
+  tc.settings.startHidden = storage.startHidden === true;
   tc.settings.hideWithControls =
     typeof storage.hideWithControls !== "undefined"
       ? Boolean(storage.hideWithControls)
       : Boolean(storage.hideWithYouTubeControls);
-  tc.settings.hideWithControlsTimer =
-    Math.min(15, Math.max(0.1, Number(storage.hideWithControlsTimer) || 2.0));
+  tc.settings.hideWithControlsTimer = Math.min(
+    15,
+    Math.max(0.1, Number(storage.hideWithControlsTimer) || 2.0)
+  );
   tc.settings.hideWithYouTubeControls = tc.settings.hideWithControls;
   tc.settings.controllerLocation = normalizeControllerLocation(
     storage.controllerLocation
   );
   tc.settings.controllerOpacity = Number(storage.controllerOpacity);
+  if (!Number.isFinite(tc.settings.controllerOpacity)) {
+    tc.settings.controllerOpacity = getSharedDefault("controllerOpacity", 0.3);
+  }
   tc.settings.controllerMarginTop = normalizeControllerMarginPx(
     storage.controllerMarginTop,
-    0
+    getSharedDefault("controllerMarginTop", 0)
   );
   tc.settings.controllerMarginRight = normalizeControllerMarginPx(
-    0,
-    0
+    storage.controllerMarginRight,
+    getSharedDefault("controllerMarginRight", 0)
   );
   tc.settings.controllerMarginBottom = normalizeControllerMarginPx(
     storage.controllerMarginBottom,
-    typeof storage.controllerMarginBottom !== "undefined" ? 0 : 65
+    getSharedDefault("controllerMarginBottom", 65)
   );
   tc.settings.controllerMarginLeft = normalizeControllerMarginPx(
-    0,
-    0
+    storage.controllerMarginLeft,
+    getSharedDefault("controllerMarginLeft", 0)
   );
+  tc.settings.shortcutTargetMode =
+    storage.shortcutTargetMode === "all" ? "all" : "closest";
   tc.settings.siteRules = Array.isArray(storage.siteRules)
-    ? storage.siteRules
-    : [];
-
+    ? storage.siteRules.map(function(rule) {
+      return rule && typeof rule === "object" ? Object.assign({}, rule) : rule;
+    })
+    : getSharedDefault("siteRules", []);
   tc.settings.controllerButtons = Array.isArray(storage.controllerButtons)
-    ? storage.controllerButtons
-    : tc.settings.controllerButtons;
-
-  tc.settings.enableSubtitleNudge =
-    typeof storage.enableSubtitleNudge !== "undefined"
-      ? Boolean(storage.enableSubtitleNudge)
-      : tc.settings.enableSubtitleNudge;
+    ? storage.controllerButtons.slice()
+    : getSharedDefault("controllerButtons", [
+      "rewind",
+      "slower",
+      "faster",
+      "advance",
+      "display"
+    ]);
+  tc.settings.enableSubtitleNudge = Boolean(storage.enableSubtitleNudge);
   tc.settings.subtitleNudgeEnabledByDefault =
     typeof storage.subtitleNudgeEnabledByDefault !== "undefined"
       ? Boolean(storage.subtitleNudgeEnabledByDefault)
-      : tc.settings.subtitleNudgeEnabledByDefault;
+      : getSharedDefault("subtitleNudgeEnabledByDefault", true);
   tc.settings.subtitleNudgeInterval = Math.min(
     1000,
     Math.max(10, Number(storage.subtitleNudgeInterval) || 50)
   );
   tc.settings.subtitleNudgeAmount =
-    Number(storage.subtitleNudgeAmount) || tc.settings.subtitleNudgeAmount;
+    Number(storage.subtitleNudgeAmount) ||
+    getSharedDefault("subtitleNudgeAmount", 0.001);
+
   var addedDefaultBinding = false;
   addedDefaultBinding =
-    ensureDefaultKeyBinding(
-      "display",
-      "KeyV",
-      0
-    ) || addedDefaultBinding;
+    ensureDefaultKeyBinding("display", "KeyV", 0) || addedDefaultBinding;
   addedDefaultBinding =
     ensureDefaultKeyBinding("move", "KeyP", 0) || addedDefaultBinding;
   addedDefaultBinding =
     ensureDefaultKeyBinding("toggleSubtitleNudge", "KeyN", 0) ||
     addedDefaultBinding;
 
-  if (addedDefaultBinding) {
+  if (addedDefaultBinding && config.persistMissingBindings !== false) {
     chrome.storage.sync.set({ keyBindings: tc.settings.keyBindings });
   }
+
+  // Capture only freshly hydrated global values. Calling this while a current
+  // route's overrides are still applied would promote those overrides into the
+  // global base and leak them into the next SPA route.
   captureSiteRuleBase();
+  return storage;
+}
+
+function replaceRememberedSpeeds(rememberedSpeeds) {
+  Object.keys(tc.settings.speeds).forEach(function(sourceKey) {
+    if (isPersistableSourceKey(sourceKey)) {
+      delete tc.settings.speeds[sourceKey];
+      delete tc.speedAccessTimes[sourceKey];
+    }
+  });
+
+  var sourceMap =
+    rememberedSpeeds && typeof rememberedSpeeds === "object"
+      ? rememberedSpeeds
+      : {};
+  Object.keys(sourceMap).forEach(function(sourceKey) {
+    var storedEntry = sourceMap[sourceKey];
+    var storedSpeed =
+      storedEntry && typeof storedEntry === "object"
+        ? Number(storedEntry.speed)
+        : Number(storedEntry);
+    var storedUpdatedAt =
+      storedEntry && typeof storedEntry === "object"
+        ? Number(storedEntry.updatedAt) || 0
+        : 0;
+    if (
+      !isPersistableSourceKey(sourceKey) ||
+      !isValidSpeed(storedSpeed) ||
+      (tc.rememberedSpeedsResetAt > 0 &&
+        storedUpdatedAt <= tc.rememberedSpeedsResetAt)
+    ) {
+      return;
+    }
+    tc.settings.speeds[sourceKey] = storedSpeed;
+    tc.speedAccessTimes[sourceKey] = storedUpdatedAt;
+  });
+}
+
+function mergeRememberedSpeeds(rememberedSpeeds) {
+  var sourceMap =
+    rememberedSpeeds && typeof rememberedSpeeds === "object"
+      ? rememberedSpeeds
+      : {};
+  Object.keys(sourceMap).forEach(function(sourceKey) {
+    var storedEntry = sourceMap[sourceKey];
+    var storedSpeed =
+      storedEntry && typeof storedEntry === "object"
+        ? Number(storedEntry.speed)
+        : Number(storedEntry);
+    var storedUpdatedAt =
+      storedEntry && typeof storedEntry === "object"
+        ? Number(storedEntry.updatedAt) || 0
+        : 0;
+    if (
+      !isPersistableSourceKey(sourceKey) ||
+      !isValidSpeed(storedSpeed) ||
+      (tc.rememberedSpeedsResetAt > 0 &&
+        storedUpdatedAt <= tc.rememberedSpeedsResetAt)
+    ) {
+      return;
+    }
+
+    var currentUpdatedAt = Number(tc.speedAccessTimes[sourceKey]) || 0;
+    if (
+      !isValidSpeed(Number(tc.settings.speeds[sourceKey])) ||
+      storedUpdatedAt >= currentUpdatedAt
+    ) {
+      tc.settings.speeds[sourceKey] = storedSpeed;
+      tc.speedAccessTimes[sourceKey] = storedUpdatedAt;
+    }
+  });
+}
+
+function rememberedSpeedsPayloadMatches(sourceMap, expectedPayload) {
+  var actual = sourceMap && typeof sourceMap === "object" ? sourceMap : {};
+  var expected =
+    expectedPayload && typeof expectedPayload === "object"
+      ? expectedPayload
+      : {};
+  var actualKeys = Object.keys(actual).filter(function(sourceKey) {
+    return isPersistableSourceKey(sourceKey);
+  });
+  var expectedKeys = Object.keys(expected);
+  if (actualKeys.length !== expectedKeys.length) return false;
+
+  return expectedKeys.every(function(sourceKey) {
+    var actualEntry = actual[sourceKey];
+    var expectedEntry = expected[sourceKey];
+    return Boolean(
+      actualEntry &&
+        expectedEntry &&
+        Number(actualEntry.speed) === Number(expectedEntry.speed) &&
+        (Number(actualEntry.updatedAt) || 0) ===
+          (Number(expectedEntry.updatedAt) || 0)
+    );
+  });
+}
+
+function clearRememberedSpeedsInMemory(resetAt) {
+  tc.rememberedSpeedsWriteEpoch += 1;
+  if (tc.pendingRememberedSpeedsSave !== null) {
+    clearTimeout(tc.pendingRememberedSpeedsSave);
+    tc.pendingRememberedSpeedsSave = null;
+  }
+  tc.rememberedSpeedsSaveRetries = 0;
+  var preserveAfter = Number(resetAt) || 0;
+  Object.keys(tc.settings.speeds).forEach(function(sourceKey) {
+    if (!isPersistableSourceKey(sourceKey)) return;
+    if (
+      preserveAfter > 0 &&
+      (Number(tc.speedAccessTimes[sourceKey]) || 0) > preserveAfter
+    ) {
+      return;
+    }
+    delete tc.settings.speeds[sourceKey];
+    delete tc.speedAccessTimes[sourceKey];
+  });
+}
+
+function applyRememberedSpeedsResetMarker(value) {
+  var resetAt = Number(value) || 0;
+  if (resetAt <= tc.rememberedSpeedsResetAt) return false;
+  tc.rememberedSpeedsResetAt = resetAt;
+  clearRememberedSpeedsInMemory(resetAt);
+  return true;
+}
+
+function applyCustomButtonIcons(customButtonIcons) {
+  tc.settings.customButtonIcons =
+    customButtonIcons && typeof customButtonIcons === "object"
+      ? customButtonIcons
+      : {};
+  if (!tc.mediaElements || !tc.mediaElements.length) return;
+
+  tc.mediaElements.forEach(function(video) {
+    if (!video.vsc || !video.vsc.div) return;
+    var doc = video.ownerDocument;
+    var shadow = video.vsc.div.shadowRoot;
+    if (!shadow) return;
+    shadow.querySelectorAll("button[data-action]").forEach(function(btn) {
+      var act = btn.dataset.action;
+      if (!act) return;
+      var svg =
+        tc.settings.customButtonIcons &&
+        tc.settings.customButtonIcons[act] &&
+        tc.settings.customButtonIcons[act].svg;
+      vscClearElement(btn);
+      if (svg) {
+        var customWrap = vscCreateSvgWrap(doc, svg, "vsc-btn-icon");
+        if (customWrap) {
+          btn.appendChild(customWrap);
+        } else {
+          var customDef = controllerButtonDefs[act];
+          btn.textContent = (customDef && customDef.label) || "?";
+        }
+      } else if (typeof vscIconWrap === "function") {
+        var wrap = vscIconWrap(doc, act, 14);
+        if (wrap) {
+          btn.appendChild(wrap);
+        } else {
+          var defaultDef = controllerButtonDefs[act];
+          btn.textContent = (defaultDef && defaultDef.label) || "?";
+        }
+      } else {
+        var fallbackDef = controllerButtonDefs[act];
+        btn.textContent = (fallbackDef && fallbackDef.label) || "?";
+      }
+    });
+    updateSubtitleNudgeIndicator(video);
+  });
+}
+
+function scheduleRuntimeSettingsReload() {
+  var reloadGeneration =
+    (Number(window.vscSettingsReloadGeneration) || 0) + 1;
+  window.vscSettingsReloadGeneration = reloadGeneration;
+  clearTimeout(window.vscSettingsReloadTimer);
+  clearTimeout(window.vscSettingsReloadRetryTimer);
+  window.vscSettingsReloadTimer = setTimeout(function() {
+    chrome.storage.sync.get(null, function(rawStorage) {
+      if (reloadGeneration !== window.vscSettingsReloadGeneration) return;
+      if (chrome.runtime.lastError) {
+        if (tc.settingsReloadRetries < 3) {
+          tc.settingsReloadRetries += 1;
+          window.vscSettingsReloadRetryTimer = setTimeout(function() {
+            if (reloadGeneration === window.vscSettingsReloadGeneration) {
+              scheduleRuntimeSettingsReload();
+            }
+          }, 250 * tc.settingsReloadRetries);
+        }
+        return;
+      }
+      tc.settingsReloadRetries = 0;
+      var wasForceEnabled = tc.settings.forceLastSavedSpeed === true;
+      var wasRememberEnabled = tc.settings.rememberSpeed === true;
+      hydrateRuntimeSettings(rawStorage || {}, {
+        preservePendingLastSpeed: true,
+        persistMissingBindings: false
+      });
+      applySiteRuleOverrides();
+      if (
+        (wasForceEnabled && !tc.settings.forceLastSavedSpeed) ||
+        (wasRememberEnabled && !tc.settings.rememberSpeed)
+      ) {
+        clearAllSpeedRestoreEnforcement();
+      }
+      initializeWhenReady(document, true);
+    });
+  }, 75);
+}
+
+function loadInitialLocalSettings(attempt, callback) {
+  chrome.storage.local.get(
+    ["customButtonIcons", "rememberedSpeeds", "rememberedSpeedsResetAt"],
+    function(localStorage) {
+      if (chrome.runtime.lastError && attempt < 3) {
+        setTimeout(function() {
+          loadInitialLocalSettings(attempt + 1, callback);
+        }, 100 * (attempt + 1));
+        return;
+      }
+      callback(chrome.runtime.lastError ? {} : localStorage || {});
+    }
+  );
+}
+
+// Patch attachShadow immediately — before any async operations — so we
+// catch shadow roots created while chrome.storage.sync.get is pending.
+// Sites like archive.org create Lit/LitElement shadow DOMs during page load;
+// waiting for the storage callback would miss them entirely.
+patchAttachShadow();
+installPageShadowBridge();
+
+function loadInitialRuntimeSettings(attempt) {
+  chrome.storage.sync.get(null, function(rawStorage) {
+  if (chrome.runtime.lastError && attempt < 3) {
+    setTimeout(function() {
+      loadInitialRuntimeSettings(attempt + 1);
+    }, 100 * (attempt + 1));
+    return;
+  }
+  hydrateRuntimeSettings(rawStorage || {});
   // patchAttachShadow() is now called at top-level before this callback
   // Add a listener for messages from the popup.
   // We use a global flag to ensure the listener is only attached once.
@@ -1302,7 +2239,12 @@ chrome.storage.sync.get(tc.settings, function(storage) {
           var videoGs = getPrimaryVideoElement();
           if (!videoGs) return false;
           sendResponse({
-            speed: videoGs.playbackRate
+            speed: videoGs.playbackRate,
+            forceLastSavedSpeed: tc.settings.forceLastSavedSpeed === true,
+            forceLastSavedSpeedControlledBySiteRule: Boolean(
+              tc.activeSiteRule &&
+                tc.activeSiteRule.forceLastSavedSpeed !== undefined
+            )
           });
           return false;
         }
@@ -1311,26 +2253,37 @@ chrome.storage.sync.get(tc.settings, function(storage) {
           return false;
         }
         if (request.action === "set_force_last_saved_speed") {
-          tc.settings.forceLastSavedSpeed = Boolean(request.enabled);
-          if (isValidSpeed(Number(request.speed))) {
-            tc.settings.lastSpeed = Number(request.speed);
+          var forceEnabled = Boolean(request.enabled);
+          if (tc.siteRuleBase) {
+            tc.siteRuleBase.forceLastSavedSpeed = forceEnabled;
           }
+          // Site rules own the effective per-page value. The popup changes the
+          // global base, then this reapplication keeps both paths consistent.
+          applySiteRuleOverrides();
           var forceVideo = getPrimaryVideoElement();
-          if (!forceVideo) return false;
           if (tc.settings.forceLastSavedSpeed) {
             tc.mediaElements.forEach(function(video) {
               if (!video || !video.vsc) return;
-              setSpeed(video, tc.settings.lastSpeed, false, true);
+              setSpeed(video, tc.settings.lastSpeed, false, false);
+              video.vsc.targetSpeedOrigin = "policy";
               extendSpeedRestoreWindow(video);
             });
           }
           sendResponse({
             enabled: tc.settings.forceLastSavedSpeed,
-            speed: forceVideo.playbackRate
+            speed: forceVideo ? forceVideo.playbackRate : null
           });
           return false;
         }
         if (request.action === "run_action") {
+          if (
+            !siteRuleUtils.isSpeederActiveForSite(
+              tc.settings.enabled,
+              tc.activeSiteRule
+            )
+          ) {
+            return false;
+          }
           var value = request.value;
           if (value === undefined || value === null) {
             value = getKeyBindings(request.actionName, "value");
@@ -1350,64 +2303,175 @@ chrome.storage.sync.get(tc.settings, function(storage) {
     // Set the flag to prevent adding the listener again.
     window.vscMessageListener = true;
   }
-  chrome.storage.local.get(["customButtonIcons"], function(loc) {
-    tc.settings.customButtonIcons =
-      loc &&
-      loc.customButtonIcons &&
-      typeof loc.customButtonIcons === "object"
-        ? loc.customButtonIcons
-        : {};
+  loadInitialLocalSettings(0, function(loc) {
+      applyCustomButtonIcons(loc && loc.customButtonIcons);
+
+      applyRememberedSpeedsResetMarker(
+        loc && loc.rememberedSpeedsResetAt
+      );
+      replaceRememberedSpeeds(loc && loc.rememberedSpeeds);
 
     if (!window.vscCustomIconListener) {
       window.vscCustomIconListener = true;
       chrome.storage.onChanged.addListener(function(changes, area) {
-        if (area !== "local" || !changes.customButtonIcons) return;
-        var nv = changes.customButtonIcons.newValue;
-        tc.settings.customButtonIcons =
-          nv && typeof nv === "object" ? nv : {};
-        if (tc.mediaElements && tc.mediaElements.length) {
-          tc.mediaElements.forEach(function(video) {
-            if (!video.vsc || !video.vsc.div) return;
-            var doc = video.ownerDocument;
-            var shadow = video.vsc.div.shadowRoot;
-            if (!shadow) return;
-            shadow.querySelectorAll("button[data-action]").forEach(function(btn) {
-              var act = btn.dataset.action;
-              if (!act) return;
-              var svg =
-                tc.settings.customButtonIcons &&
-                tc.settings.customButtonIcons[act] &&
-                tc.settings.customButtonIcons[act].svg;
-              vscClearElement(btn);
-              if (svg) {
-                var cw = vscCreateSvgWrap(doc, svg, "vsc-btn-icon");
-                if (cw) {
-                  btn.appendChild(cw);
-                } else {
-                  var cdf = controllerButtonDefs[act];
-                  btn.textContent = (cdf && cdf.label) || "?";
-                }
-              } else if (typeof vscIconWrap === "function") {
-                var wrap = vscIconWrap(doc, act, 14);
-                if (wrap) {
-                  btn.appendChild(wrap);
-                } else {
-                  var cdf = controllerButtonDefs[act];
-                  btn.textContent = (cdf && cdf.label) || "?";
-                }
-              } else {
-                var cdf2 = controllerButtonDefs[act];
-                btn.textContent = (cdf2 && cdf2.label) || "?";
+        if (area === "sync") {
+          var changedKeys = Object.keys(changes || {});
+          var isLastSpeedOnly =
+            changedKeys.length === 1 && changedKeys[0] === "lastSpeed";
+          if (isLastSpeedOnly) {
+            var changedLastSpeed = Number(changes.lastSpeed.newValue);
+            if (isValidSpeed(changedLastSpeed)) {
+              tc.persistedLastSpeed = changedLastSpeed;
+              var newerLocalLastSpeed = isValidSpeed(tc.pendingLastSpeedValue)
+                ? Number(tc.pendingLastSpeedValue)
+                : tc.lastSpeedWriteInFlight &&
+                    isValidSpeed(tc.lastSpeedWriteValue)
+                  ? Number(tc.lastSpeedWriteValue)
+                  : null;
+              if (
+                isValidSpeed(newerLocalLastSpeed) &&
+                newerLocalLastSpeed !== changedLastSpeed
+              ) {
+                return;
               }
-            });
-            updateSubtitleNudgeIndicator(video);
-          });
+              tc.settings.lastSpeed = changedLastSpeed;
+              if (tc.settings.forceLastSavedSpeed) {
+                tc.mediaElements.slice().forEach(applyRememberedSpeedPolicy);
+              }
+            }
+            return;
+          }
+
+          var managedKeys =
+            typeof vscGetManagedSyncKeys === "function"
+              ? vscGetManagedSyncKeys()
+              : [
+                "enabled",
+                "rememberSpeed",
+                "forceLastSavedSpeed",
+                "siteRules"
+              ];
+          if (
+            changedKeys.some(function(key) {
+              return managedKeys.indexOf(key) !== -1;
+            })
+          ) {
+            // Options persistence may emit a set followed by a remove. Re-read
+            // the final sparse state after the burst instead of reconstructing
+            // settings from partial change records.
+            scheduleRuntimeSettingsReload();
+          }
+          return;
         }
+
+        if (area !== "local") return;
+        if (changes.rememberedSpeedsResetAt) {
+          window.vscRememberedSpeedsGeneration =
+            (Number(window.vscRememberedSpeedsGeneration) || 0) + 1;
+          applyRememberedSpeedsResetMarker(
+            changes.rememberedSpeedsResetAt.newValue
+          );
+        }
+        if (changes.rememberedSpeeds) {
+          window.vscRememberedSpeedsGeneration =
+            (Number(window.vscRememberedSpeedsGeneration) || 0) + 1;
+          var changedRememberedSpeeds = changes.rememberedSpeeds.newValue;
+          var inFlightRememberedSpeedsWrite =
+            tc.rememberedSpeedsWriteInFlight;
+          if (
+            inFlightRememberedSpeedsWrite &&
+            inFlightRememberedSpeedsWrite.epoch !==
+              tc.rememberedSpeedsWriteEpoch &&
+            inFlightRememberedSpeedsWrite.payload &&
+            rememberedSpeedsPayloadMatches(
+              changedRememberedSpeeds,
+              inFlightRememberedSpeedsWrite.payload
+            )
+          ) {
+            return;
+          }
+          if (
+            !changedRememberedSpeeds ||
+            typeof changedRememberedSpeeds !== "object" ||
+            Object.keys(changedRememberedSpeeds).length === 0
+          ) {
+            clearRememberedSpeedsInMemory(tc.rememberedSpeedsResetAt);
+            if (Object.keys(buildRememberedSpeedsPayload()).length > 0) {
+              schedulePersistRememberedSpeeds(true);
+            }
+          } else {
+            // Merge rather than replace: another frame can write while this
+            // frame still has a newer per-source speed queued. If the storage
+            // snapshot is missing one of our newer entries, self-heal it with a
+            // merged write instead of silently losing either frame's intent.
+            mergeRememberedSpeeds(changedRememberedSpeeds);
+            var expectedRememberedSpeeds = buildRememberedSpeedsPayload();
+            if (
+              !rememberedSpeedsPayloadMatches(
+                changedRememberedSpeeds,
+                expectedRememberedSpeeds
+              )
+            ) {
+              schedulePersistRememberedSpeeds(true);
+            }
+          }
+        }
+        if (!changes.customButtonIcons) return;
+        window.vscCustomIconGeneration =
+          (Number(window.vscCustomIconGeneration) || 0) + 1;
+        var nv = changes.customButtonIcons.newValue;
+        applyCustomButtonIcons(nv);
       });
     }
-    initializeWhenReady(document);
+      // Close the small gap between the initial sync/local reads and listener
+      // registration. A final read also converges if Options saved while this
+      // content script was starting.
+      scheduleRuntimeSettingsReload();
+      var customIconGeneration =
+        Number(window.vscCustomIconGeneration) || 0;
+      var rememberedSpeedsGeneration =
+        Number(window.vscRememberedSpeedsGeneration) || 0;
+      chrome.storage.local.get(
+        ["customButtonIcons", "rememberedSpeeds", "rememberedSpeedsResetAt"],
+        function(latestLocal) {
+          if (chrome.runtime.lastError) return;
+          if (
+            customIconGeneration ===
+            (Number(window.vscCustomIconGeneration) || 0)
+          ) {
+            applyCustomButtonIcons(latestLocal && latestLocal.customButtonIcons);
+          }
+          if (
+            rememberedSpeedsGeneration ===
+            (Number(window.vscRememberedSpeedsGeneration) || 0)
+          ) {
+            applyRememberedSpeedsResetMarker(
+              latestLocal && latestLocal.rememberedSpeedsResetAt
+            );
+            mergeRememberedSpeeds(latestLocal && latestLocal.rememberedSpeeds);
+            var latestRememberedSpeeds =
+              latestLocal && latestLocal.rememberedSpeeds;
+            if (
+              !rememberedSpeedsPayloadMatches(
+                latestRememberedSpeeds,
+                buildRememberedSpeedsPayload()
+              )
+            ) {
+              schedulePersistRememberedSpeeds(true);
+            }
+            if (tc.settings.rememberSpeed || tc.settings.forceLastSavedSpeed) {
+              tc.mediaElements.slice().forEach(applyRememberedSpeedPolicy);
+            }
+          }
+        }
+      );
+      tc.runtimeSettingsHydrated = true;
+      initializeWhenReady(document);
+    });
   });
-});
+}
+
+loadInitialRuntimeSettings(0);
 
 function getKeyBindings(action, what = "value") {
   try {
@@ -1418,8 +2482,12 @@ function getKeyBindings(action, what = "value") {
 }
 
 function setKeyBindings(action, value) {
-  tc.settings.keyBindings.find((item) => item.action === action)["value"] =
-    value;
+  var binding = tc.settings.keyBindings.find(function(item) {
+    return item.action === action;
+  });
+  if (!binding) return false;
+  binding.value = value;
+  return true;
 }
 
 function createControllerButton(doc, action, label, className) {
@@ -1478,22 +2546,99 @@ function createsControllerStackingContext(element) {
   );
 }
 
-function getControllerMount(video, boundary) {
-  if (!video || !video.parentElement) return null;
+function isShadowRootNode(node) {
+  return Boolean(
+    node &&
+      node.nodeType === Node.DOCUMENT_FRAGMENT_NODE &&
+      node.host &&
+      node.host.nodeType === Node.ELEMENT_NODE
+  );
+}
 
-  var mountBoundary =
+function isComposedDescendant(node, ancestor) {
+  if (!node || !ancestor) return false;
+  if (node === ancestor) return true;
+  if (typeof ancestor.contains === "function" && ancestor.contains(node)) {
+    return true;
+  }
+
+  var current = node;
+  var depth = 0;
+  while (current && depth < 20) {
+    if (current === ancestor) return true;
+    if (current.parentElement) {
+      current = current.parentElement;
+    } else {
+      var root =
+        typeof current.getRootNode === "function" ? current.getRootNode() : null;
+      current = root && root.host ? root.host : null;
+    }
+    depth += 1;
+  }
+  return false;
+}
+
+function getControllerGeometryMount(mount) {
+  return isShadowRootNode(mount) ? mount.host : mount;
+}
+
+function getControllerMount(video, boundary) {
+  if (!video) return null;
+
+  // In fullscreen, mount at the promoted top-layer boundary. The normal size
+  // heuristic is intentionally skipped: letterboxed/portrait video providers
+  // can be much smaller than a full-player gesture pane sibling.
+  if (
     boundary &&
-    boundary !== video &&
-    typeof boundary.contains === "function" &&
-    boundary.contains(video)
-      ? boundary
-      : null;
+    (boundary === video || isComposedDescendant(video, boundary))
+  ) {
+    // A VIDEO is a replaced element; author children appended inside it are
+    // fallback content and are not painted. Direct-media fullscreen uses a
+    // top-layer popover instead, while this function keeps a renderable DOM
+    // mount as its ownership/geometry anchor.
+    if (boundary === video) {
+      return video.vsc && video.vsc.normalControllerMount
+        ? video.vsc.normalControllerMount
+        : getControllerMount(video);
+    }
+    if (
+      boundary.shadowRoot &&
+      isComposedDescendant(video, boundary.shadowRoot)
+    ) {
+      return boundary.shadowRoot;
+    }
+    return boundary;
+  }
+
+  // YouTube's .html5-video-container is often absolutely laid out and can
+  // report a zero-height box even while its video is visibly playing. The
+  // surrounding .html5-video-player is the real player/overlay boundary for
+  // watch pages, Shorts, and hover-preview #inline-preview-player instances.
+  // Keep every subsequent remount on that canonical boundary; otherwise an
+  // event-driven ensureController call can undo the constructor's YouTube
+  // mount and hide the controller in the zero-height inner container.
+  if (isOnYouTube() && typeof video.closest === "function") {
+    var youTubePlayerMount = video.closest(".html5-video-player");
+    if (youTubePlayerMount) return youTubePlayerMount;
+  }
+
+  if (!video.parentElement) {
+    var directRoot =
+      typeof video.getRootNode === "function" ? video.getRootNode() : null;
+    return isShadowRootNode(directRoot) ? directRoot : null;
+  }
+
+  var mountBoundary = null;
 
   var videoRect = video.getBoundingClientRect();
   var mount = video.parentElement;
   var candidate = mount;
   var depth = 0;
 
+  // Do not escape the player's immediate local stacking boundary. This is the
+  // line that keeps a max-z-index overlay below page-level sticky headers.
+  if (createsControllerStackingContext(mount)) return mount;
+
   // Player click-catchers are often siblings of the video's immediate parent.
   // Climb through tightly-sized wrappers so our host shares their stacking
   // context, but stop before broad page-layout containers.
@@ -1556,24 +2701,56 @@ function getFullscreenElement(doc) {
 function positionControllerHost(wrapper, video, mount) {
   if (!wrapper || !video || !mount || !wrapper.isConnected) return;
 
+  var geometryMount = getControllerGeometryMount(mount);
+  if (!geometryMount || typeof geometryMount.getBoundingClientRect !== "function") {
+    return;
+  }
   var videoRect = video.getBoundingClientRect();
-  var mountRect = mount.getBoundingClientRect();
-  if (videoRect.width <= 0 || videoRect.height <= 0) return;
+  if (wrapper.classList.contains("vsc-fullscreen-popover")) {
+    if (videoRect.width <= 0 || videoRect.height <= 0) {
+      wrapper.classList.add("vsc-geometry-hidden");
+      wrapper.style.setProperty("display", "none", "important");
+      return;
+    }
+    wrapper.classList.remove("vsc-geometry-hidden");
+    wrapper.style.removeProperty("display");
+    wrapper.style.setProperty("left", videoRect.left + "px", "important");
+    wrapper.style.setProperty("top", videoRect.top + "px", "important");
+    wrapper.style.setProperty("width", videoRect.width + "px", "important");
+    wrapper.style.setProperty("height", videoRect.height + "px", "important");
+    return;
+  }
+  var mountRect = geometryMount.getBoundingClientRect();
+  if (
+    videoRect.width <= 0 ||
+    videoRect.height <= 0 ||
+    mountRect.width <= 0 ||
+    mountRect.height <= 0
+  ) {
+    wrapper.classList.add("vsc-geometry-hidden");
+    wrapper.style.setProperty("display", "none", "important");
+    wrapper.style.setProperty("width", "0px", "important");
+    wrapper.style.setProperty("height", "0px", "important");
+    return;
+  }
+
+  wrapper.classList.remove("vsc-geometry-hidden");
+  wrapper.style.removeProperty("display");
 
   // Convert viewport pixels back into the mount's CSS pixel space. This keeps
   // the overlay aligned even when a player or ancestor is scaled.
-  var mountWidth = mount.offsetWidth || mountRect.width || 1;
-  var mountHeight = mount.offsetHeight || mountRect.height || 1;
+  var mountWidth = geometryMount.offsetWidth || mountRect.width || 1;
+  var mountHeight = geometryMount.offsetHeight || mountRect.height || 1;
   var scaleX = mountRect.width > 0 ? mountRect.width / mountWidth : 1;
   var scaleY = mountRect.height > 0 ? mountRect.height / mountHeight : 1;
   var left =
     (videoRect.left - mountRect.left) / scaleX -
-    (mount.clientLeft || 0) +
-    (mount.scrollLeft || 0);
+    (geometryMount.clientLeft || 0) +
+    (geometryMount.scrollLeft || 0);
   var top =
     (videoRect.top - mountRect.top) / scaleY -
-    (mount.clientTop || 0) +
-    (mount.scrollTop || 0);
+    (geometryMount.clientTop || 0) +
+    (geometryMount.scrollTop || 0);
 
   wrapper.style.setProperty("left", left + "px", "important");
   wrapper.style.setProperty("top", top + "px", "important");
@@ -1589,57 +2766,127 @@ function positionControllerHost(wrapper, video, mount) {
   );
 }
 
+function configureControllerAutoHide(videoController, wrapper, force) {
+  if (!videoController || !wrapper) return;
+  var signature = JSON.stringify([
+    tc.settings.hideWithControls === true,
+    Number(tc.settings.hideWithControlsTimer) || 2
+  ]);
+  if (force !== true && videoController.autoHideSettingsSignature === signature) {
+    return;
+  }
+
+  if (videoController.youTubeAutoHideObserver) {
+    videoController.youTubeAutoHideObserver.disconnect();
+    videoController.youTubeAutoHideObserver = null;
+  }
+  if (videoController.youTubeAutoHideCleanup) {
+    videoController.youTubeAutoHideCleanup();
+    videoController.youTubeAutoHideCleanup = null;
+  }
+  if (videoController.genericAutoHideCleanup) {
+    videoController.genericAutoHideCleanup();
+    videoController.genericAutoHideCleanup = null;
+  }
+
+  wrapper.classList.remove("ytp-autohide", "vsc-idle-hidden");
+  videoController.autoHideSettingsSignature = signature;
+  if (!tc.settings.hideWithControls) return;
+
+  if (isOnYouTube()) {
+    videoController.setupYouTubeAutoHide(wrapper);
+  } else {
+    videoController.setupGenericAutoHide(wrapper);
+  }
+}
+
 function setupControllerHostTracking(videoController, wrapper, mount) {
   if (!videoController || !wrapper || !mount) return;
 
   var doc = videoController.video.ownerDocument;
   var win = doc.defaultView || window;
+  var geometryMount = getControllerGeometryMount(mount);
+  if (!geometryMount || !geometryMount.style) return;
   var frameId = null;
+  var geometryRetryTimer = null;
+  var geometryRetryAttempts = 0;
+  var maxGeometryRetryAttempts = 40;
   var update = function() {
     frameId = null;
     positionControllerHost(wrapper, videoController.video, mount);
+
+    // Content scripts run at document_start, so a connected player can still
+    // report a 0x0 rect while its stylesheet, route, or custom element is
+    // settling. ResizeObserver normally repairs this, but it is not guaranteed
+    // to exist (and some players only change ancestor layout). Keep a bounded
+    // fallback alive long enough for those players instead of leaving the
+    // inline display:none geometry guard stuck forever.
+    if (
+      wrapper.classList.contains("vsc-geometry-hidden") &&
+      wrapper.isConnected &&
+      videoController.video.isConnected &&
+      geometryRetryAttempts < maxGeometryRetryAttempts
+    ) {
+      geometryRetryAttempts += 1;
+      if (geometryRetryTimer === null) {
+        geometryRetryTimer = win.setTimeout(function() {
+          geometryRetryTimer = null;
+          schedule();
+        }, Math.min(500, 25 * geometryRetryAttempts));
+      }
+    } else if (!wrapper.classList.contains("vsc-geometry-hidden")) {
+      geometryRetryAttempts = 0;
+      if (geometryRetryTimer !== null) {
+        win.clearTimeout(geometryRetryTimer);
+        geometryRetryTimer = null;
+      }
+    }
   };
   var schedule = function() {
     if (frameId !== null) return;
     frameId = win.requestAnimationFrame(update);
   };
 
-  if (win.getComputedStyle(mount).position === "static") {
-    mount.dataset.vscPositionOwner = "true";
-    mount.dataset.vscOriginalPosition = mount.style.getPropertyValue("position");
-    mount.dataset.vscOriginalPositionPriority =
-      mount.style.getPropertyPriority("position");
-    mount.style.setProperty("position", "relative");
+  if (win.getComputedStyle(geometryMount).position === "static") {
+    geometryMount.dataset.vscPositionOwner = "true";
+    geometryMount.dataset.vscOriginalPosition =
+      geometryMount.style.getPropertyValue("position");
+    geometryMount.dataset.vscOriginalPositionPriority =
+      geometryMount.style.getPropertyPriority("position");
+    geometryMount.dataset.vscAppliedPosition = "relative";
+    geometryMount.style.setProperty("position", "relative");
   }
 
-  if (!createsControllerStackingContext(mount)) {
-    mount.dataset.vscIsolationOwner = "true";
-    mount.dataset.vscOriginalIsolation =
-      mount.style.getPropertyValue("isolation");
-    mount.dataset.vscOriginalIsolationPriority =
-      mount.style.getPropertyPriority("isolation");
-    mount.style.setProperty("isolation", "isolate");
+  if (!createsControllerStackingContext(geometryMount)) {
+    geometryMount.dataset.vscIsolationOwner = "true";
+    geometryMount.dataset.vscOriginalIsolation =
+      geometryMount.style.getPropertyValue("isolation");
+    geometryMount.dataset.vscOriginalIsolationPriority =
+      geometryMount.style.getPropertyPriority("isolation");
+    geometryMount.dataset.vscAppliedIsolation = "isolate";
+    geometryMount.style.setProperty("isolation", "isolate");
   }
 
   var resizeObserver = null;
   if (typeof win.ResizeObserver === "function") {
     resizeObserver = new win.ResizeObserver(schedule);
     resizeObserver.observe(videoController.video);
-    resizeObserver.observe(mount);
+    resizeObserver.observe(geometryMount);
   }
 
   win.addEventListener("resize", schedule, { passive: true });
   doc.addEventListener("fullscreenchange", schedule, { passive: true });
-  mount.addEventListener("scroll", schedule, { passive: true });
+  geometryMount.addEventListener("scroll", schedule, { passive: true });
   update();
 
   videoController.controllerHostMount = mount;
   videoController.controllerHostCleanup = function(forceRestore) {
     if (resizeObserver) resizeObserver.disconnect();
     if (frameId !== null) win.cancelAnimationFrame(frameId);
+    if (geometryRetryTimer !== null) win.clearTimeout(geometryRetryTimer);
     win.removeEventListener("resize", schedule);
     doc.removeEventListener("fullscreenchange", schedule);
-    mount.removeEventListener("scroll", schedule);
+    geometryMount.removeEventListener("scroll", schedule);
     var hasOtherController = false;
     try {
       hasOtherController = Array.from(
@@ -1649,42 +2896,58 @@ function setupControllerHostTracking(videoController, wrapper, mount) {
       });
     } catch (e) {}
     if (
-      mount.dataset.vscPositionOwner === "true" &&
+      geometryMount.dataset.vscPositionOwner === "true" &&
       !hasOtherController &&
       (forceRestore === true || !wrapper.isConnected)
     ) {
-      if (mount.dataset.vscOriginalPosition) {
-        mount.style.setProperty(
-          "position",
-          mount.dataset.vscOriginalPosition,
-          mount.dataset.vscOriginalPositionPriority || ""
-        );
-      } else {
-        mount.style.removeProperty("position");
+      if (
+        geometryMount.style.getPropertyValue("position") ===
+          geometryMount.dataset.vscAppliedPosition &&
+        geometryMount.style.getPropertyPriority("position") === ""
+      ) {
+        if (geometryMount.dataset.vscOriginalPosition) {
+          geometryMount.style.setProperty(
+            "position",
+            geometryMount.dataset.vscOriginalPosition,
+            geometryMount.dataset.vscOriginalPositionPriority || ""
+          );
+        } else {
+          geometryMount.style.removeProperty("position");
+        }
       }
-      delete mount.dataset.vscPositionOwner;
-      delete mount.dataset.vscOriginalPosition;
-      delete mount.dataset.vscOriginalPositionPriority;
+      delete geometryMount.dataset.vscPositionOwner;
+      delete geometryMount.dataset.vscOriginalPosition;
+      delete geometryMount.dataset.vscOriginalPositionPriority;
+      delete geometryMount.dataset.vscAppliedPosition;
     }
     if (
-      mount.dataset.vscIsolationOwner === "true" &&
+      geometryMount.dataset.vscIsolationOwner === "true" &&
       !hasOtherController &&
       (forceRestore === true || !wrapper.isConnected)
     ) {
-      if (mount.dataset.vscOriginalIsolation) {
-        mount.style.setProperty(
-          "isolation",
-          mount.dataset.vscOriginalIsolation,
-          mount.dataset.vscOriginalIsolationPriority || ""
-        );
-      } else {
-        mount.style.removeProperty("isolation");
+      if (
+        geometryMount.style.getPropertyValue("isolation") ===
+          geometryMount.dataset.vscAppliedIsolation &&
+        geometryMount.style.getPropertyPriority("isolation") === ""
+      ) {
+        if (geometryMount.dataset.vscOriginalIsolation) {
+          geometryMount.style.setProperty(
+            "isolation",
+            geometryMount.dataset.vscOriginalIsolation,
+            geometryMount.dataset.vscOriginalIsolationPriority || ""
+          );
+        } else {
+          geometryMount.style.removeProperty("isolation");
+        }
       }
-      delete mount.dataset.vscIsolationOwner;
-      delete mount.dataset.vscOriginalIsolation;
-      delete mount.dataset.vscOriginalIsolationPriority;
+      delete geometryMount.dataset.vscIsolationOwner;
+      delete geometryMount.dataset.vscOriginalIsolation;
+      delete geometryMount.dataset.vscOriginalIsolationPriority;
+      delete geometryMount.dataset.vscAppliedIsolation;
     }
   };
+
+  configureControllerAutoHide(videoController, wrapper, true);
 }
 
 function remountControllerHost(videoController, mount) {
@@ -1692,22 +2955,96 @@ function remountControllerHost(videoController, mount) {
     !videoController ||
     !videoController.div ||
     !mount ||
-    !mount.isConnected ||
-    mount === videoController.controllerHostMount
+    !(mount.isConnected || (isShadowRootNode(mount) && mount.host.isConnected))
   ) {
     return false;
   }
 
+  if (
+    mount === videoController.controllerHostMount &&
+    videoController.div.isConnected &&
+    videoController.div.parentNode === mount
+  ) {
+    // Keep the max-z-index host last among equal-z-index player overlays.
+    if (videoController.div.nextSibling) {
+      mount.appendChild(videoController.div);
+      return true;
+    }
+    positionControllerHost(
+      videoController.div,
+      videoController.video,
+      mount
+    );
+    return false;
+  }
+
   if (videoController.controllerHostCleanup) {
     videoController.controllerHostCleanup(true);
     videoController.controllerHostCleanup = null;
   }
 
-  mount.insertBefore(videoController.div, mount.firstChild);
+  mount.appendChild(videoController.div);
   setupControllerHostTracking(videoController, videoController.div, mount);
   return true;
 }
 
+function disableDirectFullscreenPopover(videoController) {
+  if (!videoController || !videoController.div) return;
+  var wrapper = videoController.div;
+  if (
+    !wrapper.vscFullscreenPopoverOpen &&
+    !wrapper.classList.contains("vsc-fullscreen-popover")
+  ) {
+    return;
+  }
+  if (typeof wrapper.hidePopover === "function") {
+    try {
+      wrapper.hidePopover();
+    } catch (_error) {}
+  }
+  wrapper.vscFullscreenPopoverOpen = false;
+  wrapper.classList.remove("vsc-fullscreen-popover");
+  wrapper.removeAttribute("popover");
+}
+
+function enableDirectFullscreenPopover(videoController) {
+  if (!videoController || !videoController.video || !videoController.div) {
+    return false;
+  }
+  var wrapper = videoController.div;
+  if (typeof wrapper.showPopover !== "function") return false;
+
+  var normalMount = videoController.normalControllerMount;
+  var normalMountIsConnected = Boolean(
+    normalMount &&
+      (normalMount.isConnected ||
+        (isShadowRootNode(normalMount) && normalMount.host.isConnected))
+  );
+  if (!normalMountIsConnected) {
+    normalMount = getControllerMount(videoController.video);
+    videoController.normalControllerMount = normalMount;
+  }
+  if (!normalMount) return false;
+  if (wrapper.parentNode !== normalMount) {
+    remountControllerHost(videoController, normalMount);
+  }
+
+  wrapper.setAttribute("popover", "manual");
+  wrapper.classList.add("vsc-fullscreen-popover");
+  if (!wrapper.vscFullscreenPopoverOpen) {
+    try {
+      wrapper.showPopover();
+      wrapper.vscFullscreenPopoverOpen = true;
+    } catch (_error) {
+      wrapper.classList.remove("vsc-fullscreen-popover");
+      wrapper.removeAttribute("popover");
+      return false;
+    }
+  }
+  positionControllerHost(wrapper, videoController.video, normalMount);
+  return true;
+}
+
 function syncControllerFullscreenMount(videoController) {
   if (!videoController || !videoController.video || !videoController.div) {
     return false;
@@ -1718,11 +3055,16 @@ function syncControllerFullscreenMount(videoController) {
   var fullscreenElement = getFullscreenElement(doc);
   var targetMount = videoController.normalControllerMount;
 
+  if (fullscreenElement === video) {
+    if (enableDirectFullscreenPopover(videoController)) return true;
+  } else {
+    disableDirectFullscreenPopover(videoController);
+  }
+
   if (
     fullscreenElement &&
-    fullscreenElement !== video &&
-    typeof fullscreenElement.contains === "function" &&
-    fullscreenElement.contains(video)
+    (fullscreenElement === video ||
+      isComposedDescendant(video, fullscreenElement))
   ) {
     targetMount = getControllerMount(video, fullscreenElement);
   } else if (!fullscreenElement && (!targetMount || !targetMount.isConnected)) {
@@ -1745,6 +3087,9 @@ function defineVideoController() {
     this.restoreSpeedTimer = null;
     this.pendingRateChange = null;
     this.speedRestoreUntil = 0;
+    this.speedVerificationTimer = null;
+    this.speedVerificationTarget = null;
+    this.speedVerificationAttempts = 0;
     this.subtitleNudgeEnabledOverride = null;
     this.suppressedRateChangeCount = 0;
     this.suppressedRateChangeUntil = 0;
@@ -1754,19 +3099,28 @@ function defineVideoController() {
     this.controllerLocation = normalizeControllerLocation(
       tc.settings.controllerLocation
     );
+    this.structureSignature = getControllerStructureSignature();
 
     log(`Creating video controller for ${target.tagName} with src: ${target.src || target.currentSrc || "none"}`, 4);
 
     let storedSpeed = sanitizeSpeed(resolveTargetSpeed(target), 1.0);
     this.targetSpeed = storedSpeed;
     this.targetSpeedSourceKey = getVideoSourceKey(target);
+    this.targetSpeedOrigin =
+      tc.settings.rememberSpeed || tc.settings.forceLastSavedSpeed
+        ? "policy"
+        : "initial";
     this.mediaSourceKey = getVideoSourceKey(target);
     if (!tc.settings.rememberSpeed && !tc.settings.forceLastSavedSpeed) {
       setKeyBindings("reset", getKeyBindings("fast"));
     }
 
     log("Explicitly setting playbackRate to: " + storedSpeed, 5);
-    target.playbackRate = storedSpeed;
+    try {
+      target.playbackRate = storedSpeed;
+    } catch (error) {
+      log(`Unable to set initial playbackRate: ${error.message}`, 3);
+    }
 
     this.div = this.initializeControls();
 
@@ -1778,6 +3132,33 @@ function defineVideoController() {
     log(`Controller created and attached to DOM. Hidden: ${this.div.classList.contains("vsc-hidden")}`, 4);
 
     var mediaEventAction = function(event) {
+      this.lastActivityAt = Date.now();
+      if (event.type === "emptied") {
+        var sourceAvailable = hasUsableMediaSource(event.target);
+        if (this.div) {
+          this.div.classList.toggle("vsc-nosource", !sourceAvailable);
+        }
+        this.stopSubtitleNudge();
+        if (!sourceAvailable) {
+          this.mediaSourceKey = "unknown_src";
+          this.targetSpeedSourceKey = "unknown_src";
+          return;
+        }
+        applySourceTransitionPolicy(event.target, true);
+      }
+
+      if (event.type === "loadstart") {
+        if (this.div) {
+          this.div.classList.toggle(
+            "vsc-nosource",
+            !hasUsableMediaSource(event.target)
+          );
+        }
+        if (hasUsableMediaSource(event.target)) {
+          applySourceTransitionPolicy(event.target, true);
+        }
+      }
+
       if (
         event.type === "loadedmetadata" ||
         event.type === "loadeddata" ||
@@ -1835,6 +3216,14 @@ function defineVideoController() {
       }
     };
 
+    target.addEventListener(
+      "loadstart",
+      (this.handleLoadStart = mediaEventAction.bind(this))
+    );
+    target.addEventListener(
+      "emptied",
+      (this.handleEmptied = mediaEventAction.bind(this))
+    );
     target.addEventListener(
       "loadedmetadata",
       (this.handleLoadedMetadata = mediaEventAction.bind(this))
@@ -1901,6 +3290,19 @@ function defineVideoController() {
 
   tc.videoController.prototype.remove = function() {
     this.stopSubtitleNudge();
+    disableDirectFullscreenPopover(this);
+    if (
+      this.visibilityResumeHandler &&
+      this.video &&
+      this.video.ownerDocument
+    ) {
+      this.video.ownerDocument.removeEventListener(
+        "visibilitychange",
+        this.visibilityResumeHandler,
+        true
+      );
+      this.visibilityResumeHandler = null;
+    }
     if (this.youTubeAutoHideObserver) {
       this.youTubeAutoHideObserver.disconnect();
       this.youTubeAutoHideObserver = null;
@@ -1919,7 +3321,10 @@ function defineVideoController() {
       this.controllerHostCleanup = null;
     }
     if (this.restoreSpeedTimer) clearTimeout(this.restoreSpeedTimer);
+    clearSpeedVerification(this);
     if (this.video) {
+      this.video.removeEventListener("loadstart", this.handleLoadStart);
+      this.video.removeEventListener("emptied", this.handleEmptied);
       this.video.removeEventListener("loadedmetadata", this.handleLoadedMetadata);
       this.video.removeEventListener("loadeddata", this.handleLoadedData);
       this.video.removeEventListener("canplay", this.handleCanPlay);
@@ -1986,17 +3391,35 @@ function defineVideoController() {
 
       // Cache values to avoid repeated property access
       const targetSpeed = this.targetSpeed;
-      const nudgeAmount = tc.settings.subtitleNudgeAmount;
+      const nudgeAmount = Math.min(
+        0.1,
+        Math.max(0.000001, Number(tc.settings.subtitleNudgeAmount) || 0.001)
+      );
 
       // Apply nudge from the stored target speed (not current rate)
-      this.video.playbackRate = targetSpeed + nudgeAmount;
+      try {
+        this.video.playbackRate = targetSpeed + nudgeAmount;
+      } catch (error) {
+        tc.isNudging = false;
+        this.suppressedRateChangeCount = 0;
+        this.stopSubtitleNudge();
+        log(`Subtitle nudge failed: ${error.message}`, 3);
+        return;
+      }
 
       // Revert synchronously after a microtask to ensure it happens immediately
       Promise.resolve().then(() => {
-        if (this.video && targetSpeed) {
-          this.video.playbackRate = targetSpeed;
+        try {
+          if (this.video && targetSpeed) {
+            this.video.playbackRate = targetSpeed;
+          }
+        } catch (error) {
+          this.suppressedRateChangeCount = 0;
+          this.stopSubtitleNudge();
+          log(`Subtitle nudge restore failed: ${error.message}`, 3);
+        } finally {
+          tc.isNudging = false;
         }
-        tc.isNudging = false;
       });
 
       // Schedule next nudge
@@ -2039,18 +3462,34 @@ function defineVideoController() {
     }
 
     const targetRate = this.targetSpeed || this.video.playbackRate;
-    const nudgeAmount = tc.settings.subtitleNudgeAmount;
+    const nudgeAmount = Math.min(
+      0.1,
+      Math.max(0.000001, Number(tc.settings.subtitleNudgeAmount) || 0.001)
+    );
 
     tc.isNudging = true;
     suppressNextNudgeRateChanges(this, 2);
-    this.video.playbackRate = targetRate + nudgeAmount;
+    try {
+      this.video.playbackRate = targetRate + nudgeAmount;
+    } catch (error) {
+      tc.isNudging = false;
+      this.suppressedRateChangeCount = 0;
+      log(`Immediate subtitle nudge failed: ${error.message}`, 3);
+      return;
+    }
 
     // Revert synchronously via microtask
     Promise.resolve().then(() => {
-      if (this.video) {
-        this.video.playbackRate = targetRate;
+      try {
+        if (this.video) {
+          this.video.playbackRate = targetRate;
+        }
+      } catch (error) {
+        this.suppressedRateChangeCount = 0;
+        log(`Immediate subtitle nudge restore failed: ${error.message}`, 3);
+      } finally {
+        tc.isNudging = false;
       }
-      tc.isNudging = false;
     });
 
     log(`Immediate nudge performed at rate ${targetRate.toFixed(2)}`, 5);
@@ -2161,7 +3600,9 @@ function defineVideoController() {
     // The wrapper covers the player area on most sites due to inject.css styles,
     // but we listen on both the video and the wrapper for maximum coverage.
     const activityEvents = ["mousemove", "mousedown", "keydown", "touchstart"];
-    const parentEl = video.parentElement;
+    const parentEl =
+      getControllerGeometryMount(this.controllerHostMount) ||
+      video.parentElement;
     activityEvents.forEach((type) => {
       video.addEventListener(type, resetTimer, { passive: true });
       wrapper.addEventListener(type, resetTimer, { passive: true });
@@ -2318,21 +3759,17 @@ function defineVideoController() {
     controller.addEventListener("click", (e) => e.stopPropagation(), false);
     controller.addEventListener("mousedown", (e) => e.stopPropagation(), false);
 
-    // Setup auto-hide observers if enabled
-    if (tc.settings.hideWithControls) {
-      if (isOnYouTube()) {
-        this.setupYouTubeAutoHide(wrapper);
-      } else {
-        this.setupGenericAutoHide(wrapper);
-      }
-    }
-
-    const parentEl = this.parent || this.video.parentElement;
+    const parentEl =
+      this.parent || this.video.parentElement || this.video.parentNode;
     var mountEl = getControllerMount(this.video) || parentEl;
 
-    log(`Inserting controller: parentEl=${!!parentEl}, parentNode=${!!parentEl?.parentNode}, hostname=${location.hostname}`, 4);
+    log(`Inserting controller: parentEl=${!!parentEl}, hostname=${location.hostname}`, 4);
 
-    if (!parentEl || !parentEl.parentNode) {
+    if (
+      !mountEl ||
+      !(mountEl.isConnected ||
+        (isShadowRootNode(mountEl) && mountEl.host.isConnected))
+    ) {
       log("No suitable parent found, appending to body", 4);
       doc.body.appendChild(wrapper);
       this.normalControllerMount = doc.body;
@@ -2366,10 +3803,12 @@ function defineVideoController() {
         case location.hostname === "www.youtube.com":
         case location.hostname === "m.youtube.com":
         case location.hostname === "music.youtube.com":
-          mountEl = parentEl.closest(".html5-video-player") || mountEl;
+          mountEl =
+            (parentEl.closest && parentEl.closest(".html5-video-player")) ||
+            mountEl;
           break;
       }
-      mountEl.insertBefore(wrapper, mountEl.firstChild);
+      mountEl.appendChild(wrapper);
       this.normalControllerMount = mountEl;
       setupControllerHostTracking(this, wrapper, mountEl);
       log("Controller successfully inserted into DOM", 4);
@@ -2386,18 +3825,31 @@ function defineVideoController() {
 }
 
 function applySiteRuleOverrides() {
+  var wasForceEnabled = tc.settings.forceLastSavedSpeed === true;
+  var wasRememberEnabled = tc.settings.rememberSpeed === true;
+
+  function finishSiteRuleApplication(result) {
+    if (
+      (wasForceEnabled && !tc.settings.forceLastSavedSpeed) ||
+      (wasRememberEnabled && !tc.settings.rememberSpeed)
+    ) {
+      clearAllSpeedRestoreEnforcement();
+    }
+    return result;
+  }
+
   resetSettingsFromSiteRuleBase();
   tc.activeSiteRule = null;
 
   if (!Array.isArray(tc.settings.siteRules) || tc.settings.siteRules.length === 0) {
-    return false;
+    return finishSiteRuleApplication(false);
   }
 
   var currentUrl = location.href;
   var matchedRule = siteRuleUtils.matchSiteRule(currentUrl, tc.settings.siteRules);
 
   if (!matchedRule) {
-    return false;
+    return finishSiteRuleApplication(false);
   }
 
   tc.activeSiteRule = matchedRule;
@@ -2406,7 +3858,7 @@ function applySiteRuleOverrides() {
   // Check if extension should be enabled/disabled on this site
   if (siteRuleUtils.isSiteRuleDisabled(matchedRule)) {
     log(`Extension disabled for site: ${currentUrl}`, 4);
-    return true;
+    return finishSiteRuleApplication(true);
   }
 
   // Override general settings with site-specific overrides
@@ -2421,6 +3873,7 @@ function applySiteRuleOverrides() {
     "controllerOpacity",
     "controllerMarginTop",
     "controllerMarginBottom",
+    "shortcutTargetMode",
     "enableSubtitleNudge",
     "subtitleNudgeEnabledByDefault",
     "subtitleNudgeInterval"
@@ -2462,7 +3915,16 @@ function applySiteRuleOverrides() {
       );
   }
 
-  return false;
+  return finishSiteRuleApplication(false);
+}
+
+function removeIneligibleMediaControllers() {
+  if (tc.settings.audioBoolean) return;
+  tc.mediaElements.slice().forEach(function(media) {
+    if (media && media.nodeName === "AUDIO") {
+      removeController(media);
+    }
+  });
 }
 
 /** Apply current tc.settings controller layout/opacity to every attached controller (after site rules). */
@@ -2474,6 +3936,7 @@ function refreshAllControllerGeometry() {
     if (controllerEl) {
       controllerEl.style.opacity = String(tc.settings.controllerOpacity);
     }
+    configureControllerAutoHide(video.vsc, video.vsc.div, false);
   });
 }
 
@@ -2481,9 +3944,32 @@ function refreshAllControllerGeometry() {
 function reapplySiteRulesAndControllerGeometry() {
   applySiteRuleOverrides();
   if (!siteRuleUtils.isSpeederActiveForSite(tc.settings.enabled, tc.activeSiteRule)) {
-    return;
+    tc.mediaElements.slice().forEach(function(video) {
+      removeController(video);
+    });
+    return false;
   }
+  removeIneligibleMediaControllers();
   refreshAllControllerGeometry();
+  return true;
+}
+
+function applyRememberedSpeedPolicy(video) {
+  if (!video || !video.vsc) return false;
+  var rememberedSpeed = getRememberedSpeed(video);
+  if (!isValidSpeed(rememberedSpeed)) return false;
+
+  video.vsc.targetSpeed = rememberedSpeed;
+  video.vsc.targetSpeedSourceKey = getVideoSourceKey(video);
+  video.vsc.targetSpeedOrigin = "policy";
+  if (video.vsc.speedIndicator) {
+    video.vsc.speedIndicator.textContent = rememberedSpeed.toFixed(2);
+  }
+  extendSpeedRestoreWindow(video);
+  if (Math.abs(video.playbackRate - rememberedSpeed) > 0.01) {
+    setSpeed(video, rememberedSpeed, false, false);
+  }
+  return true;
 }
 
 function shouldPreserveDesiredSpeed(video, speed) {
@@ -2493,8 +3979,13 @@ function shouldPreserveDesiredSpeed(video, speed) {
     return false;
   }
 
+  var preservesPausedTarget =
+    video.paused === true &&
+    (video.vsc.targetSpeedOrigin === "user" ||
+      video.vsc.targetSpeedOrigin === "policy");
+
   return (
-    video.paused === true ||
+    preservesPausedTarget ||
     (typeof video.vsc.speedRestoreUntil === "number" &&
       video.vsc.speedRestoreUntil > Date.now())
   );
@@ -2504,21 +3995,30 @@ function setupListener(root) {
   root = root || document;
   if (root.vscRateListenerAttached) return;
 
-  function updateSpeedFromEvent(video, skipResetDisarm) {
+  function updateSpeedFromEvent(video, options) {
     if (!video.vsc || !video.vsc.speedIndicator) return;
-    if (!skipResetDisarm) {
+    var config = options || {};
+    if (config.skipResetDisarm !== true) {
       video.vsc.resetToggleArmed = false;
     }
     var speed = video.playbackRate; // Preserve full precision (e.g. 0.0625)
     video.vsc.speedIndicator.textContent = speed.toFixed(2);
     video.vsc.targetSpeed = speed;
     video.vsc.targetSpeedSourceKey = getVideoSourceKey(video);
-    var sourceKey = getVideoSourceKey(video);
-    if (sourceKey !== "unknown_src") {
-      tc.settings.speeds[sourceKey] = speed;
+
+    // A native ratechange has no trustworthy user-origin signal; sites emit the
+    // same event when they clamp/reset speed. Durable intent is recorded only
+    // by explicit Speeder actions (which pass shouldPersist).
+    var shouldPersist = config.shouldPersist === true;
+    if (config.preserveTargetOrigin !== true) {
+      video.vsc.targetSpeedOrigin = shouldPersist ? "user" : "external";
     }
-    tc.settings.lastSpeed = speed;
-    schedulePersistLastSpeed(speed);
+    if (shouldPersist) {
+      rememberSourceSpeed(video, speed);
+      tc.settings.lastSpeed = speed;
+      schedulePersistLastSpeed(speed);
+    }
+
     if (video.vsc) {
       if (speed === 1.0 || video.paused) video.vsc.stopSubtitleNudge();
       else video.vsc.startSubtitleNudge();
@@ -2533,21 +4033,36 @@ function setupListener(root) {
       if (!video || typeof video.playbackRate === "undefined" || !video.vsc)
         return;
       if (shouldIgnoreSuppressedRateChange(video)) return;
+      var currentSpeed = video.playbackRate; // Preserve full precision (e.g. 0.0625)
+      var pendingRateChange = takePendingRateChange(video, currentSpeed);
       if (tc.settings.forceLastSavedSpeed) {
-        if (event.detail && event.detail.origin === "videoSpeed") {
-          video.playbackRate = event.detail.speed;
-          updateSpeedFromEvent(video, true);
+        if (pendingRateChange) {
+          updateSpeedFromEvent(video, {
+            skipResetDisarm: true,
+            shouldPersist: pendingRateChange.shouldPersist === true,
+            preserveTargetOrigin: true
+          });
         } else {
-          video.playbackRate = sanitizeSpeed(tc.settings.lastSpeed, 1.0);
+          var forcedSpeed = sanitizeSpeed(tc.settings.lastSpeed, 1.0);
+          if (Math.abs(currentSpeed - forcedSpeed) > 0.001) {
+            setSpeed(video, forcedSpeed, false, false);
+          } else {
+            updateSpeedFromEvent(video, {
+              shouldPersist: false,
+              preserveTargetOrigin: true
+            });
+          }
         }
         event.stopImmediatePropagation();
       } else {
-        var currentSpeed = video.playbackRate; // Preserve full precision (e.g. 0.0625)
         var desiredSpeed = getDesiredSpeed(video);
-        var pendingRateChange = takePendingRateChange(video, currentSpeed);
 
         if (pendingRateChange) {
-          updateSpeedFromEvent(video, true);
+          updateSpeedFromEvent(video, {
+            skipResetDisarm: true,
+            shouldPersist: pendingRateChange.shouldPersist === true,
+            preserveTargetOrigin: true
+          });
           return;
         }
 
@@ -2562,7 +4077,7 @@ function setupListener(root) {
           return;
         }
 
-        updateSpeedFromEvent(video);
+        updateSpeedFromEvent(video, { shouldPersist: false });
       }
     },
     true
@@ -2631,11 +4146,9 @@ function inIframe() {
 }
 
 function attachKeydownListeners(doc) {
+  // Content scripts already run in every frame. Keeping each listener scoped
+  // to its own document avoids duplicate shortcuts and stale iframe ownership.
   var docs = [doc];
-  try {
-    if (inIframe() && window.top.document !== doc) docs.push(window.top.document);
-  } catch (e) {
-  }
 
   docs.forEach(function(keyDoc) {
     if (keyDoc.vscKeydownListenerAttached) return;
@@ -2662,6 +4175,15 @@ function attachKeydownListeners(doc) {
           return;
         }
 
+        if (
+          !siteRuleUtils.isSpeederActiveForSite(
+            tc.settings.enabled,
+            tc.activeSiteRule
+          )
+        ) {
+          return;
+        }
+
         if (!tc.mediaElements.length) return;
 
         var item = tc.settings.keyBindings.find(function(binding) {
@@ -2671,10 +4193,13 @@ function attachKeydownListeners(doc) {
         if (item) {
           runAction(item.action, item.value, event);
 
-          // Always prevent default and stop propagation for Speeder shortcuts
-          // to prevent the website (e.g. YouTube) from reacting to these keys.
-          event.preventDefault();
-          event.stopPropagation();
+          // The per-site "Block site from capturing keypress" option owns
+          // propagation. Speeder still runs unblocked shortcuts, but the page
+          // can receive them too when the user left that option off.
+          if (item.force === true || item.force === "true") {
+            event.preventDefault();
+            event.stopImmediatePropagation();
+          }
         }
       },
       true
@@ -2683,6 +4208,25 @@ function attachKeydownListeners(doc) {
   });
 }
 
+function attachMediaTargetTracking(doc) {
+  if (!doc || doc.vscMediaTargetTrackingAttached) return;
+  doc.addEventListener(
+    "mousemove",
+    function(event) {
+      if (!Number.isFinite(event.clientX) || !Number.isFinite(event.clientY)) {
+        return;
+      }
+      tc.lastPointerPosition = {
+        document: doc,
+        x: event.clientX,
+        y: event.clientY
+      };
+    },
+    { capture: true, passive: true }
+  );
+  doc.vscMediaTargetTrackingAttached = true;
+}
+
 function attachMutationObserver(root) {
   if (root.vscMutationObserverAttached) return;
 
@@ -2709,6 +4253,15 @@ function attachMutationObserver(root) {
               if (node.nodeType !== Node.ELEMENT_NODE) return;
               scanNodeForMedia(node, node.parentNode || mutation.target, false);
             });
+
+            // Player gesture/click panes are frequently inserted after the
+            // video. Keep equal-z-index controller hosts last, and repair a
+            // host that the site removed independently of its media element.
+            tc.mediaElements.slice().forEach(function(video) {
+              if (!video || !video.vsc || !video.vsc.div) return;
+              if (video.vsc.controllerHostMount !== mutation.target) return;
+              remountControllerHost(video.vsc, mutation.target);
+            });
             return;
           }
 
@@ -2745,6 +4298,15 @@ function attachMutationObserver(root) {
             );
           }
         });
+
+        // Document selectors do not cross shadow boundaries. A detached
+        // custom-element host can therefore hide connected-looking media from
+        // the removed subtree scan; prune by composed connectivity as a final
+        // reconciliation step for every mutation batch.
+        tc.mediaElements.slice().forEach(function(video) {
+          if (!video || video.isConnected) return;
+          removeController(video);
+        });
       },
       { timeout: 1000 }
     );
@@ -2782,54 +4344,40 @@ function attachMediaDetectionListeners(root) {
   root.vscMediaEventListenersAttached = true;
 }
 
-function attachIframeListeners(doc) {
-  Array.from(doc.getElementsByTagName("iframe")).forEach(function(frame) {
-    if (!frame.vscLoadListenerAttached) {
-      frame.addEventListener("load", function() {
-        try {
-          if (frame.contentDocument) {
-            initializeWhenReady(frame.contentDocument, true);
-          }
-        } catch (e) {
-        }
-      });
-      frame.vscLoadListenerAttached = true;
-    }
-
-    try {
-      if (frame.contentDocument) {
-        initializeWhenReady(frame.contentDocument);
-      }
-    } catch (e) {
-    }
-  });
+function scheduleNavigationRescan() {
+  window.vscLastObservedHref = location.href;
+  clearTimeout(window.vscNavigationRescanTimer);
+  window.vscNavigationRescanTimer = setTimeout(function() {
+    initializeWhenReady(document, true);
+  }, 300);
 }
 
 function attachNavigationListeners() {
   if (window.vscNavigationListenersAttached) return;
 
-  var scheduleRescan = function() {
-    clearTimeout(window.vscNavigationRescanTimer);
-    window.vscNavigationRescanTimer = setTimeout(function() {
-      initializeWhenReady(document, true);
-    }, 300);
-  };
-
   ["pushState", "replaceState"].forEach(function(method) {
     if (typeof history[method] !== "function") return;
     var original = history[method];
     history[method] = function() {
       var result = original.apply(this, arguments);
-      scheduleRescan();
+      scheduleNavigationRescan();
       return result;
     };
   });
 
-  window.addEventListener("popstate", scheduleRescan);
-  window.addEventListener("hashchange", scheduleRescan);
+  window.addEventListener("popstate", scheduleNavigationRescan);
+  window.addEventListener("hashchange", scheduleNavigationRescan);
   /* YouTube often navigates without a history API call the extension can see first */
   if (typeof document !== "undefined" && isOnYouTube()) {
-    document.addEventListener("yt-navigate-finish", scheduleRescan);
+    document.addEventListener("yt-navigate-finish", scheduleNavigationRescan);
+  }
+  window.vscLastObservedHref = location.href;
+  if (!window.vscLocationWatchTimer) {
+    window.vscLocationWatchTimer = setInterval(function() {
+      if (window.vscLastObservedHref !== location.href) {
+        scheduleNavigationRescan();
+      }
+    }, 1000);
   }
   window.vscNavigationListenersAttached = true;
 }
@@ -2837,35 +4385,47 @@ function attachNavigationListeners() {
 function initializeNow(doc, forceReinit = false) {
   if ((!forceReinit && vscInitializedDocuments.has(doc)) || !doc.body) return;
 
+  // Navigation must remain observable even while this URL is disabled, or a
+  // later whitelisted SPA route can never reactivate the extension.
+  attachNavigationListeners();
+  if (typeof tc.videoController === "undefined") defineVideoController();
   applySiteRuleOverrides();
-  if (!siteRuleUtils.isSpeederActiveForSite(tc.settings.enabled, tc.activeSiteRule)) {
+  var isActive = siteRuleUtils.isSpeederActiveForSite(
+    tc.settings.enabled,
+    tc.activeSiteRule
+  );
+
+  // Keep observing while inactive so dynamically-created media/shadow roots
+  // are available to the next forced SPA rescan, but remove stale controls.
+  observeRoot(doc);
+  if (!isActive) {
+    tc.mediaElements.slice().forEach(function(video) {
+      removeController(video);
+    });
+    vscInitializedDocuments.add(doc);
     return;
   }
 
+  removeIneligibleMediaControllers();
+
   if (!doc.body.classList.contains("vsc-initialized")) {
     doc.body.classList.add("vsc-initialized");
   }
-  if (typeof tc.videoController === "undefined") defineVideoController();
   attachKeydownListeners(doc);
-  attachNavigationListeners();
-  observeRoot(doc);
+  attachMediaTargetTracking(doc);
 
-  // Delayed rescan to catch custom elements whose shadow roots were created
-  // before our attachShadow patch was installed (e.g. archive.org's <play-av>
-  // Lit component, or any site that lazily creates shadow DOM video players).
+  // Bounded fallback scans catch open page-world roots if a site's CSP blocked
+  // the bridge script. The event bridge handles the normal ongoing path.
   if (!doc.vscDelayedShadowScanDone) {
     doc.vscDelayedShadowScanDone = true;
-    setTimeout(function() {
-      if (!doc.body) return;
-      try {
-        var els = doc.body.querySelectorAll("*");
-        for (var i = 0; i < els.length; i++) {
-          if (els[i].shadowRoot && !vscObservedRoots.has(els[i].shadowRoot)) {
-            observeRoot(els[i].shadowRoot);
-          }
-        }
-      } catch (e) {}
-    }, 3000);
+    [3000, 10000, 30000].forEach(function(delay) {
+      setTimeout(function() {
+        if (!doc.body) return;
+        try {
+          rescanOpenShadowRoots(doc);
+        } catch (e) {}
+      }, delay);
+    });
   }
 
   if (forceReinit) {
@@ -2873,10 +4433,15 @@ function initializeNow(doc, forceReinit = false) {
     // A root is normally scanned only once. A user-requested rescan must also
     // revisit media that was present but source-less during the initial scan.
     scanRootForMedia(doc);
+    rescanOpenShadowRoots(doc);
     refreshAllControllerGeometry();
+    if (tc.settings.rememberSpeed || tc.settings.forceLastSavedSpeed) {
+      tc.mediaElements.slice().forEach(applyRememberedSpeedPolicy);
+    }
   }
 
   vscInitializedDocuments.add(doc);
+  flushPendingMediaCandidates();
 }
 
 function setSpeed(
@@ -2906,12 +4471,20 @@ function setSpeed(
     `setSpeed: Target ${numericSpeed.toFixed(2)}. Initial: ${isInitialCall}. UserKeyPress: ${isUserKeyPress}`,
     4
   );
-  tc.settings.lastSpeed = numericSpeed;
   video.vsc.speedIndicator.textContent = numericSpeed.toFixed(2);
 
+  if (isUserKeyPress) {
+    tc.settings.lastSpeed = numericSpeed;
+    rememberSourceSpeed(video, numericSpeed);
+    schedulePersistLastSpeed(numericSpeed);
+  }
+
   // Update the target speed for nudge so it knows what to revert to
   video.vsc.targetSpeed = numericSpeed;
   video.vsc.targetSpeedSourceKey = getVideoSourceKey(video);
+  if (isUserKeyPress) {
+    video.vsc.targetSpeedOrigin = "user";
+  }
 
   if (isUserKeyPress && !isInitialCall && video.vsc && video.vsc.div) {
     runAction("blink", 1000, null, video); // Pass video to blink
@@ -2920,25 +4493,35 @@ function setSpeed(
 
   // Try YouTube's native speed API first — keeps subtitles in sync without nudge
   var usedNativeSpeed = false;
-  if (tc.settings.forceLastSavedSpeed) {
-    video.dispatchEvent(
-      new CustomEvent("ratechange", {
-        detail: {
-          origin: "videoSpeed",
-          speed: numericSpeed.toFixed(2),
-          fromUserInput: isUserKeyPress
-        }
-      })
-    );
-  } else {
-    if (Math.abs(video.playbackRate - numericSpeed) > 0.001) {
-      rememberPendingRateChange(video, numericSpeed);
+  if (Math.abs(video.playbackRate - numericSpeed) > 0.001) {
+    rememberPendingRateChange(video, numericSpeed, isUserKeyPress);
+    if (!tc.settings.forceLastSavedSpeed) {
       usedNativeSpeed = tryYouTubeNativeSpeed(video, numericSpeed);
-      if (!usedNativeSpeed) {
+    }
+    if (!usedNativeSpeed) {
+      try {
         video.playbackRate = numericSpeed;
+      } catch (error) {
+        if (video.vsc) video.vsc.pendingRateChange = null;
+        log(`Unable to set playbackRate to ${numericSpeed}: ${error.message}`, 2);
+        if (
+          tc.settings.forceLastSavedSpeed ||
+          (tc.settings.rememberSpeed && video.vsc.targetSpeedOrigin === "policy") ||
+          Number(video.vsc.speedRestoreUntil) > Date.now()
+        ) {
+          scheduleSpeedVerification(video, numericSpeed, true);
+        }
+        return false;
       }
     }
   }
+  if (
+    tc.settings.forceLastSavedSpeed ||
+    (tc.settings.rememberSpeed && video.vsc.targetSpeedOrigin === "policy") ||
+    Number(video.vsc.speedRestoreUntil) > Date.now()
+  ) {
+    scheduleSpeedVerification(video, numericSpeed, true);
+  }
   if (video.vsc) {
     if (numericSpeed === 1.0 || video.paused) {
       video.vsc.stopSubtitleNudge();
@@ -2949,33 +4532,109 @@ function setSpeed(
       video.vsc.startSubtitleNudge();
     }
   }
+  return true;
+}
+
+function getMediaFromControllerEvent(event, candidates) {
+  if (!event || !event.target || !event.target.getRootNode) return null;
+  var root = event.target.getRootNode();
+  var controllerHost = root && root.host;
+  if (!controllerHost) return null;
+  return candidates.find(function(video) {
+    return video.vsc && video.vsc.div === controllerHost;
+  }) || null;
+}
+
+function distanceSquaredToRect(x, y, rect) {
+  if (!rect) return Infinity;
+  var dx = x < rect.left ? rect.left - x : x > rect.right ? x - rect.right : 0;
+  var dy = y < rect.top ? rect.top - y : y > rect.bottom ? y - rect.bottom : 0;
+  return dx * dx + dy * dy;
+}
+
+function getClosestMediaToPointer(candidates, pointerPosition) {
+  if (!pointerPosition || !Array.isArray(candidates)) return null;
+  var best = null;
+  var bestDistance = Infinity;
+
+  candidates.forEach(function(video) {
+    if (!video || !video.vsc || !video.isConnected) return;
+    var target = getControllerElement(video.vsc) || video;
+    var rect = null;
+    try {
+      rect = target.getBoundingClientRect();
+      if (!rect || rect.width <= 0 || rect.height <= 0) {
+        rect = video.getBoundingClientRect();
+      }
+    } catch (_error) {
+      return;
+    }
+    if (!rect || rect.width <= 0 || rect.height <= 0) return;
+    var distance = distanceSquaredToRect(
+      pointerPosition.x,
+      pointerPosition.y,
+      rect
+    );
+    if (distance < bestDistance) {
+      best = video;
+      bestDistance = distance;
+    }
+  });
+
+  return best;
+}
+
+function resolveActionMediaTargets(event, specificVideo) {
+  if (specificVideo && specificVideo.vsc) return [specificVideo];
+
+  var docContext =
+    event && event.target && event.target.ownerDocument
+      ? event.target.ownerDocument
+      : document;
+  var candidates = tc.mediaElements.filter(function(video) {
+    return Boolean(
+      video &&
+        video.vsc &&
+        video.isConnected &&
+        video.ownerDocument === docContext
+    );
+  });
+  if (candidates.length <= 1) return candidates;
+
+  var controllerMedia = getMediaFromControllerEvent(event, candidates);
+  if (controllerMedia) {
+    tc.lastInteractedMedia = controllerMedia;
+    return [controllerMedia];
+  }
+
+  if (tc.settings.shortcutTargetMode === "all") return candidates;
+
+  var pointer =
+    tc.lastPointerPosition && tc.lastPointerPosition.document === docContext
+      ? tc.lastPointerPosition
+      : null;
+  var closest = getClosestMediaToPointer(candidates, pointer);
+  if (closest) {
+    tc.lastInteractedMedia = closest;
+    return [closest];
+  }
+
+  if (
+    tc.lastInteractedMedia &&
+    candidates.indexOf(tc.lastInteractedMedia) !== -1
+  ) {
+    return [tc.lastInteractedMedia];
+  }
+
+  var primary = getPrimaryVideoElement(candidates);
+  return primary ? [primary] : [];
 }
 
 function runAction(action, value, e) {
   log("runAction Begin", 5);
-  var mediaTagsToProcess;
   const specificVideo = arguments[3] || null;
   var subtitleNudgeToggleValue = null;
-
-  if (specificVideo) {
-    mediaTagsToProcess = [specificVideo];
-  } else if (e && e.target && e.target.getRootNode) {
-    // Event-driven action
-    const docContext = e.target.ownerDocument || document;
-    mediaTagsToProcess = tc.mediaElements.filter(
-      (v) => v.ownerDocument === docContext
-    );
-    const targetController = e.target.getRootNode().host;
-    if (targetController) {
-      // If it's a click on a controller, only use that one video
-      const videoFromController = tc.mediaElements.find(
-        (v) => v.vsc && v.vsc.div === targetController
-      );
-      if (videoFromController) mediaTagsToProcess = [videoFromController];
-    }
-  } else {
-    mediaTagsToProcess = tc.mediaElements;
-  }
+  var mediaTagsToProcess = resolveActionMediaTargets(e, specificVideo);
   if (action === "settings") {
     chrome.runtime.sendMessage({ action: "openOptions" });
     return;
@@ -3021,7 +4680,11 @@ function runAction(action, value, e) {
       showController(controller, 2000, true);
     }
     if (v.classList.contains("vsc-cancelled")) return;
-    const numValue = parseFloat(value);
+    const numValue = keyBindingUtils.sanitizeActionValue(
+      action,
+      value,
+      getKeyBindings(action, "value")
+    );
     switch (action) {
       case "rewind":
         isUserSeek = true;
@@ -3057,8 +4720,12 @@ function runAction(action, value, e) {
       case "fast":
         var preferredSpeed = numValue;
         // Apply site-specific preferred speed override if available
-        if (tc.activeSiteRule && typeof tc.activeSiteRule.preferredSpeed === "number") {
-          preferredSpeed = tc.activeSiteRule.preferredSpeed;
+        if (tc.activeSiteRule && tc.activeSiteRule.preferredSpeed !== undefined) {
+          preferredSpeed = keyBindingUtils.sanitizeActionValue(
+            "fast",
+            tc.activeSiteRule.preferredSpeed,
+            preferredSpeed
+          );
         }
         resetSpeed(v, preferredSpeed, true);
         break;
@@ -3250,13 +4917,20 @@ function handleDrag(video, e) {
   const c = video.vsc.div;
   const sC = convertControllerToManualPosition(video.vsc);
   if (!sC) return;
-  var pE = c.parentElement;
+  var pE =
+    getControllerGeometryMount(video.vsc.controllerHostMount) ||
+    c.parentElement ||
+    (c.parentNode && c.parentNode.host);
+  if (!pE || typeof pE.addEventListener !== "function") return;
+  var nextParent = pE.parentElement;
   while (
-    pE.parentNode &&
-    pE.parentNode.offsetHeight === pE.offsetHeight &&
-    pE.parentNode.offsetWidth === pE.offsetWidth
-    )
-    pE = pE.parentNode;
+    nextParent &&
+    nextParent.offsetHeight === pE.offsetHeight &&
+    nextParent.offsetWidth === pE.offsetWidth
+  ) {
+    pE = nextParent;
+    nextParent = pE.parentElement;
+  }
   video.classList.add("vcs-dragging");
   sC.classList.add("dragging");
   const iXY = [e.clientX, e.clientY],
diff --git a/extension/content/shadow-bridge.js b/extension/content/shadow-bridge.js
new file mode 100644
index 0000000..753ae68
--- /dev/null
+++ b/extension/content/shadow-bridge.js
@@ -0,0 +1,49 @@
+(function() {
+  "use strict";
+
+  if (window.__speederPageShadowBridgeInstalled) return;
+
+  window.__speederPageShadowBridgeInstalled = true;
+
+  function notifyLocationChanged() {
+    try {
+      document.dispatchEvent(
+        new Event("speeder-location-changed", {
+          bubbles: true,
+          composed: true
+        })
+      );
+    } catch (_error) {}
+  }
+
+  if (
+    typeof Element !== "undefined" &&
+    typeof Element.prototype.attachShadow === "function"
+  ) {
+    var originalAttachShadow = Element.prototype.attachShadow;
+    Element.prototype.attachShadow = function() {
+      var shadowRoot = originalAttachShadow.apply(this, arguments);
+      try {
+        this.dispatchEvent(
+          new Event("speeder-shadow-root-attached", {
+            bubbles: true,
+            composed: true
+          })
+        );
+      } catch (_error) {}
+      return shadowRoot;
+    };
+  }
+
+  ["pushState", "replaceState"].forEach(function(method) {
+    if (typeof history === "undefined" || typeof history[method] !== "function") {
+      return;
+    }
+    var original = history[method];
+    history[method] = function() {
+      var result = original.apply(this, arguments);
+      notifyLocationChanged();
+      return result;
+    };
+  });
+})();
diff --git a/extension/manifest.json b/extension/manifest.json
index 2543ca1..0ea48b0 100644
--- a/extension/manifest.json
+++ b/extension/manifest.json
@@ -26,6 +26,7 @@
     ]
   },
   "permissions": [
+    "activeTab",
     "storage",
     "https://cdn.jsdelivr.net/*"
   ],
@@ -50,6 +51,7 @@
         "file:///*"
       ],
       "match_about_blank": true,
+      "run_at": "document_start",
       "exclude_matches": [
         "https://plus.google.com/hangouts/*",
         "https://hangouts.google.com/*",
@@ -61,6 +63,7 @@
       "js": [
         "shared/controller-utils.js",
         "shared/key-bindings.js",
+        "shared/settings-core.js",
         "shared/site-rules.js",
         "shared/ui-icons.js",
         "content/inject.js"
@@ -69,6 +72,7 @@
   ],
   "web_accessible_resources": [
     "content/inject.css",
+    "content/shadow-bridge.js",
     "content/shadow.css"
   ]
 }
diff --git a/extension/options/import-export.js b/extension/options/import-export.js
index f63c899..1fdd276 100644
--- a/extension/options/import-export.js
+++ b/extension/options/import-export.js
@@ -7,11 +7,87 @@ function generateBackupFilename() {
   return importExportUtils.generateBackupFilename(new Date());
 }
 
+function normalizedSettingsForExport(rawStorage) {
+  var raw = rawStorage && typeof rawStorage === "object" ? rawStorage : {};
+  var expanded = vscExpandStoredSettings(raw);
+  var normalized = vscBuildStoredSettingsDiff(expanded);
+
+  // Backups should remain readable outside the extension too. Storage stays
+  // sparse, but explicitly include built-in rule titles in the exported v2
+  // patches. Custom rule titles are already part of their normal patches.
+  var titledRulePatches = Array.isArray(normalized.siteRules)
+    ? normalized.siteRules.slice()
+    : [];
+  var orderedRulePatches = [];
+  var claimedRulePatches = new Set();
+  vscGetSettingsDefaults().siteRules.forEach(function(defaultRule) {
+    var expandedRule = expanded.siteRules.find(function(rule) {
+      return rule && rule.pattern === defaultRule.pattern;
+    });
+    if (!expandedRule) return;
+    var patch = titledRulePatches.find(function(candidate) {
+      return (
+        candidate &&
+        candidate.pattern === defaultRule.pattern &&
+        !claimedRulePatches.has(candidate)
+      );
+    });
+    if (!patch && typeof expandedRule.title === "string") {
+      patch = { pattern: defaultRule.pattern };
+      titledRulePatches.push(patch);
+    }
+    if (!patch) return;
+    if (typeof expandedRule.title === "string") {
+      patch.title = expandedRule.title;
+    }
+    claimedRulePatches.add(patch);
+    orderedRulePatches.push(patch);
+  });
+  titledRulePatches.forEach(function(patch) {
+    if (!claimedRulePatches.has(patch)) orderedRulePatches.push(patch);
+  });
+  if (orderedRulePatches.length > 0) {
+    normalized.siteRules = orderedRulePatches;
+    normalized.siteRulesFormat = vscGetSiteRulesDiffFormat();
+  }
+
+  // lastSpeed is useful user data, but it is intentionally outside the
+  // managed options diff because content scripts update it at runtime.
+  if (Object.prototype.hasOwnProperty.call(raw, "lastSpeed")) {
+    if (
+      Number.isFinite(expanded.lastSpeed) &&
+      expanded.lastSpeed >= 0.0625 &&
+      expanded.lastSpeed <= 16
+    ) {
+      normalized.lastSpeed = expanded.lastSpeed;
+    }
+  }
+
+  return normalized;
+}
+
 function exportSettings() {
   chrome.storage.sync.get(null, function (storage) {
+    if (chrome.runtime.lastError) {
+      showStatus(
+        "Error: Failed to read settings - " + chrome.runtime.lastError.message,
+        true
+      );
+      return;
+    }
+
     chrome.storage.local.get(null, function (localStorage) {
+      if (chrome.runtime.lastError) {
+        showStatus(
+          "Error: Failed to read local extension data - " +
+            chrome.runtime.lastError.message,
+          true
+        );
+        return;
+      }
+
       const backup = importExportUtils.buildBackupPayload(
-        storage,
+        normalizedSettingsForExport(storage),
         importExportUtils.filterLocalSettingsForExport(localStorage),
         new Date()
       );
@@ -33,6 +109,70 @@ function exportSettings() {
   });
 }
 
+function persistImportedSyncSettings(currentRaw, importedRaw, callback) {
+  var expanded = vscExpandStoredSettings(importedRaw || {});
+  var mutation = vscBuildManagedStorageMutation(currentRaw || {}, expanded);
+
+  if (
+    importedRaw &&
+    Object.prototype.hasOwnProperty.call(importedRaw, "lastSpeed")
+  ) {
+    if (
+      Number.isFinite(expanded.lastSpeed) &&
+      expanded.lastSpeed >= 0.0625 &&
+      expanded.lastSpeed <= 16
+    ) {
+      mutation.set.lastSpeed = expanded.lastSpeed;
+    }
+  }
+
+  function removeStaleSettings() {
+    if (!mutation.remove.length) {
+      callback(null);
+      return;
+    }
+    chrome.storage.sync.remove(mutation.remove, function () {
+      callback(chrome.runtime.lastError || null);
+    });
+  }
+
+  if (!Object.keys(mutation.set).length) {
+    removeStaleSettings();
+    return;
+  }
+
+  // Write the replacement first. A failed write must not leave the user with
+  // their old managed settings already deleted.
+  chrome.storage.sync.set(mutation.set, function () {
+    if (chrome.runtime.lastError) {
+      callback(chrome.runtime.lastError);
+      return;
+    }
+    removeStaleSettings();
+  });
+}
+
+function importLocalSettings(localToImport, callback) {
+  if (localToImport === null) {
+    callback(null);
+    return;
+  }
+
+  var icons = localToImport.customButtonIcons;
+  if (icons && typeof icons === "object" && !Array.isArray(icons)) {
+    chrome.storage.local.set({ customButtonIcons: icons }, function () {
+      callback(chrome.runtime.lastError || null);
+    });
+    return;
+  }
+
+  // Backups only own customButtonIcons. Keep Lucide caches, remembered speed
+  // history, and any future local runtime data private to the current install.
+  chrome.storage.local.remove("customButtonIcons", function () {
+    callback(chrome.runtime.lastError || null);
+  });
+}
+
 function importSettings() {
   const input = document.createElement("input");
   input.type = "file";
@@ -55,65 +195,53 @@ function importSettings() {
         var settingsToImport = parsedBackup.settings;
         var localToImport = parsedBackup.localSettings;
 
-        function importLocalSettings(callback) {
-          if (parsedBackup.isWrappedBackup !== true) {
-            callback();
+        chrome.storage.sync.get(null, function (currentRaw) {
+          if (chrome.runtime.lastError) {
+            showStatus(
+              "Error: Failed to read current settings - " +
+                chrome.runtime.lastError.message,
+              true
+            );
             return;
           }
 
-          chrome.storage.local.clear(function () {
-            if (chrome.runtime.lastError) {
-              showStatus(
-                "Error: Failed to clear local extension data - " +
-                  chrome.runtime.lastError.message,
-                true
-              );
-              return;
-            }
-
-            if (localToImport && Object.keys(localToImport).length > 0) {
-              chrome.storage.local.set(localToImport, function () {
-                if (chrome.runtime.lastError) {
-                  showStatus(
-                    "Error: Failed to save local extension data - " +
-                      chrome.runtime.lastError.message,
-                    true
-                  );
-                  return;
-                }
-                callback();
-              });
-              return;
-            }
-
-            callback();
-          });
-        }
-
-        function afterLocalImport() {
-          chrome.storage.sync.clear(function () {
-            chrome.storage.sync.set(settingsToImport, function () {
-              if (chrome.runtime.lastError) {
+          persistImportedSyncSettings(
+            currentRaw || {},
+            settingsToImport,
+            function (syncError) {
+              if (syncError) {
                 showStatus(
                   "Error: Failed to save imported settings - " +
-                    chrome.runtime.lastError.message,
+                    syncError.message,
                   true
                 );
                 return;
               }
-              showStatus("Settings imported successfully. Reloading...");
-              setTimeout(function () {
-                if (typeof restore_options === "function") {
-                  restore_options();
-                } else {
-                  location.reload();
-                }
-              }, 500);
-            });
-          });
-        }
 
-        importLocalSettings(afterLocalImport);
+              var scopedLocalSettings =
+                parsedBackup.isWrappedBackup === true ? localToImport : null;
+              importLocalSettings(scopedLocalSettings, function (localError) {
+                if (localError) {
+                  showStatus(
+                    "Error: Failed to save local extension data - " +
+                      localError.message,
+                    true
+                  );
+                  return;
+                }
+
+                showStatus("Settings imported successfully. Reloading...");
+                setTimeout(function () {
+                  if (typeof restore_options === "function") {
+                    restore_options();
+                  } else {
+                    location.reload();
+                  }
+                }, 500);
+              });
+            }
+          );
+        });
       } catch (err) {
         showStatus("Error: Failed to parse backup file - " + err.message, true);
       }
diff --git a/extension/options/options.css b/extension/options/options.css
index 411cd2d..75a7fed 100644
--- a/extension/options/options.css
+++ b/extension/options/options.css
@@ -905,8 +905,19 @@ button.lucide-result-tile.lucide-picked {
   align-items: center;
 }
 
+.site-rule-identity {
+  display: grid;
+  grid-template-columns: minmax(140px, 0.45fr) minmax(220px, 1fr);
+  gap: 8px;
+  min-width: 0;
+}
+
+.site-title,
 .site-pattern {
   min-width: 0;
+}
+
+.site-pattern {
   font-family: "SFMono-Regular", Menlo, Consolas, monospace;
 }
 
@@ -1173,6 +1184,10 @@ button.lucide-result-tile.lucide-picked {
     grid-template-columns: 36px minmax(0, 1fr);
   }
 
+  .site-rule-identity {
+    grid-template-columns: 1fr;
+  }
+
   .remove-site-rule {
     grid-column: 1 / -1;
   }
@@ -1198,6 +1213,10 @@ button.lucide-result-tile.lucide-picked {
   .site-rule-header {
     grid-template-columns: 1fr;
   }
+
+  .site-rule-identity {
+    grid-template-columns: 1fr;
+  }
 }
 
 @media (prefers-color-scheme: dark) {
diff --git a/extension/options/options.html b/extension/options/options.html
index 053c157..3794b21 100644
--- a/extension/options/options.html
+++ b/extension/options/options.html
@@ -7,6 +7,7 @@
     <link rel="stylesheet" href="options.css" />
     <script src="../shared/controller-utils.js"></script>
     <script src="../shared/key-bindings.js"></script>
+    <script src="../shared/settings-core.js"></script>
     <script src="../shared/popup-controls.js"></script>
     <script src="../shared/ui-icons.js"></script>
     <script src="lucide-client.js"></script>
@@ -289,9 +290,9 @@
             <label for="rememberSpeed"
               >Remember playback speed<br />
               <em
-                >Stores speed per source so revisiting the same media can restore
-                it. Separate from &ldquo;Force last saved speed,&rdquo; which
-                fights players that reset rate.</em
+                >Stores speeds you set with Speeder per source so revisiting the
+                same media can restore them. Separate from &ldquo;Force last
+                saved speed,&rdquo; which fights players that reset rate.</em
               >
             </label>
             <input id="rememberSpeed" type="checkbox" />
@@ -306,6 +307,20 @@
             </label>
             <input id="forceLastSavedSpeed" type="checkbox" />
           </div>
+          <div class="row">
+            <label for="shortcutTargetMode"
+              >Keyboard shortcut target<br />
+              <em
+                >Closest changes the video nearest the pointer (falling back to
+                the most visible active player). Change all keeps the legacy
+                behavior on pages with multiple players.</em
+              >
+            </label>
+            <select id="shortcutTargetMode">
+              <option value="closest">Closest active video</option>
+              <option value="all">All videos on the page</option>
+            </select>
+          </div>
 
           <div class="defaults-divider"></div>
           <h4 class="defaults-sub-heading">Controller</h4>
@@ -607,7 +622,9 @@
               >
               patterns like <code>/(.+)youtube\.com(\/*)$/gi</code>. Turn on a
               row only when you want that group to override the general defaults
-              above.
+              above. Regex and plain-path rules test both the literal URL and a
+              safely decoded path, query, and hash, so readable text can match
+              <code>%xx</code>-encoded URLs too.
             </p>
           </div>
           <div id="siteRulesContainer"></div>
@@ -626,11 +643,20 @@
               >
                 <span class="site-rule-toggle-icon" aria-hidden="true">&hellip;</span>
               </button>
-              <input
-                type="text"
-                class="site-pattern"
-                placeholder="e.g., youtube.com or /regex/gi"
-              />
+              <div class="site-rule-identity">
+                <input
+                  type="text"
+                  class="site-title"
+                  placeholder="Rule title (optional)"
+                  aria-label="Site rule title"
+                />
+                <input
+                  type="text"
+                  class="site-pattern"
+                  placeholder="e.g., youtube.com or /regex/gi"
+                  aria-label="Site rule URL pattern"
+                />
+              </div>
               <button type="button" class="remove-site-rule">Remove</button>
             </div>
             <div class="site-rule-body">
@@ -697,6 +723,26 @@
                     </div>
                   </div>
                 </div>
+                <div class="site-rule-override-section">
+                  <label class="site-override-lead">
+                    <span
+                      >Override shortcut target for this site<br /><em
+                        >Choose whether keyboard and popup control-bar actions
+                        affect the closest active video or every video.</em
+                      ></span
+                    >
+                    <input type="checkbox" class="override-shortcut-target" />
+                  </label>
+                  <div class="site-shortcut-target-container">
+                    <div class="site-rule-option site-rule-option-field">
+                      <label>Shortcut target:</label>
+                      <select class="site-shortcutTargetMode">
+                        <option value="closest">Closest active video</option>
+                        <option value="all">All videos on the page</option>
+                      </select>
+                    </div>
+                  </div>
+                </div>
                 <div class="site-rule-override-section">
                   <label class="site-override-lead">
                     <span
@@ -767,10 +813,10 @@
                     <div class="site-rule-option site-rule-option-checkbox">
                       <label
                         >Remember playback speed:<br /><em
-                          >Stores speed per source so revisiting the same media
-                          can restore it. Separate from &ldquo;Force last saved
-                          speed,&rdquo; which fights players that reset
-                          rate.</em
+                          >Stores speeds you set with Speeder per source so
+                          revisiting the same media can restore them. Separate
+                          from &ldquo;Force last saved speed,&rdquo; which fights
+                          players that reset rate.</em
                         ></label
                       >
                       <input type="checkbox" class="site-rememberSpeed" />
@@ -784,6 +830,21 @@
                       >
                       <input type="checkbox" class="site-forceLastSavedSpeed" />
                     </div>
+                    <div class="site-rule-option site-rule-option-field">
+                      <label
+                        >Preferred speed (0.0625&ndash;16):<br /><em
+                          >Overrides the Preferred speed action for matching
+                          URLs. It does not force every video to start at this
+                          speed.</em
+                        ></label
+                      >
+                      <input
+                        type="text"
+                        inputmode="decimal"
+                        class="site-preferredSpeed"
+                        placeholder="1.80"
+                      />
+                    </div>
                     <div class="site-rule-option site-rule-option-checkbox">
                       <label
                         >Work on audio:<br /><em
diff --git a/extension/options/options.js b/extension/options/options.js
index b995b11..3ce9d8d 100644
--- a/extension/options/options.js
+++ b/extension/options/options.js
@@ -162,58 +162,72 @@ function createDefaultBinding(action, code, value) {
   };
 }
 
-var tcDefaults = {
-  speed: 1.0,
-  lastSpeed: 1.0,
-  rememberSpeed: false,
-  audioBoolean: false,
-  startHidden: false,
-  hideWithYouTubeControls: false,
-  hideWithControls: false,
-  hideWithControlsTimer: 2.0,
-  controllerLocation: "top-left",
-  forceLastSavedSpeed: false,
-  enabled: true,
-  controllerOpacity: 0.3,
-  controllerMarginTop: 0,
-  controllerMarginRight: 0,
-  controllerMarginBottom: 65,
-  controllerMarginLeft: 0,
-  keyBindings: [
-    createDefaultBinding("display", "KeyV", 0),
-    createDefaultBinding("move", "KeyP", 0),
-    createDefaultBinding("slower", "KeyS", 0.1),
-    createDefaultBinding("faster", "KeyD", 0.1),
-    createDefaultBinding("rewind", "KeyZ", 10),
-    createDefaultBinding("advance", "KeyX", 10),
-    createDefaultBinding("reset", "KeyR", 1),
-    createDefaultBinding("fast", "KeyG", 1.8),
-    createDefaultBinding("toggleSubtitleNudge", "KeyN", 0)
-  ],
-  siteRules: [
-    {
-      pattern: "/^https:\\/\\/(www\\.)?youtube\\.com\\/(?!shorts\\/).*/",
-      enabled: true,
-      enableSubtitleNudge: true,
-      subtitleNudgeInterval: 50
-    },
-    {
-      pattern: "/^https:\\/\\/(www\\.)?youtube\\.com\\/shorts\\/.*/",
-      enabled: true,
-      rememberSpeed: true,
-      controllerMarginTop: 60,
-      controllerMarginBottom: 85
+var tcDefaults = vscGetSettingsDefaults();
+var optionsSyncSettingsLoaded = false;
+
+function setOptionsSyncSettingsLoaded(loaded) {
+  optionsSyncSettingsLoaded = loaded === true;
+  var saveButton = document.getElementById("save");
+  if (saveButton) {
+    saveButton.disabled = !optionsSyncSettingsLoaded;
+    saveButton.setAttribute(
+      "aria-busy",
+      optionsSyncSettingsLoaded ? "false" : "true"
+    );
+  }
+}
+
+function persistManagedSyncSettings(settings, callback, existingStorage) {
+  function persistFromRaw(rawStorage) {
+    // Preserve canonical values that this version of the Options UI does not
+    // expose (for example legacy left/right placement margins). A caller can
+    // still reset every managed value by passing the complete defaults object.
+    var completeSettings = vscDeepMergeDefaults(
+      vscExpandStoredSettings(rawStorage || {}),
+      settings || {}
+    );
+    var mutation = vscBuildManagedStorageMutation(
+      rawStorage,
+      completeSettings
+    );
+
+    function removeStaleKeys() {
+      if (!mutation.remove.length) {
+        callback(null);
+        return;
+      }
+      chrome.storage.sync.remove(mutation.remove, function () {
+        callback(chrome.runtime.lastError || null);
+      });
     }
-  ],
-  controllerButtons: ["rewind", "slower", "faster", "advance", "display"],
-  showPopupControlBar: true,
-  popupMatchHoverControls: true,
-  popupControllerButtons: ["rewind", "slower", "faster", "advance", "display"],
-  enableSubtitleNudge: false,
-  subtitleNudgeEnabledByDefault: true,
-  subtitleNudgeInterval: 50,
-  subtitleNudgeAmount: 0.001
-};
+
+    if (Object.keys(mutation.set).length === 0) {
+      removeStaleKeys();
+      return;
+    }
+
+    chrome.storage.sync.set(mutation.set, function () {
+      if (chrome.runtime.lastError) {
+        callback(chrome.runtime.lastError);
+        return;
+      }
+      removeStaleKeys();
+    });
+  }
+
+  if (existingStorage && typeof existingStorage === "object") {
+    persistFromRaw(existingStorage);
+    return;
+  }
+
+  chrome.storage.sync.get(null, function (rawStorage) {
+    if (chrome.runtime.lastError) {
+      callback(chrome.runtime.lastError);
+      return;
+    }
+    persistFromRaw(rawStorage || {});
+  });
+}
 
 const actionLabels = {
   display: "Show/hide controller",
@@ -261,14 +275,11 @@ function getDefaultShortcutValue(action) {
 }
 
 function resolveShortcutValue(action, value) {
-  if (value === undefined || value === null) {
-    return getDefaultShortcutValue(action);
-  }
-  var numericValue = Number(value);
-  if (Number.isFinite(numericValue)) {
-    return numericValue;
-  }
-  return 0;
+  return keyBindingUtils.sanitizeActionValue(
+    action,
+    value,
+    getDefaultShortcutValue(action)
+  );
 }
 
 const customActionsNoValues = [
@@ -406,6 +417,16 @@ function parseFiniteNumberOrFallback(value, fallback) {
   return Number.isFinite(numericValue) ? numericValue : fallback;
 }
 
+function readOptionalPreferredSpeedInput(input) {
+  var rawValue = input && typeof input.value === "string"
+    ? input.value.trim()
+    : "";
+  if (!rawValue) return undefined;
+  var parsed = Number(rawValue);
+  if (!Number.isFinite(parsed)) return undefined;
+  return Math.min(16, Math.max(0.0625, parsed));
+}
+
 function updateSiteRuleToggleIcon(toggleButton, action) {
   if (!toggleButton) return;
   var iconEl = toggleButton.querySelector(".site-rule-toggle-icon");
@@ -726,13 +747,31 @@ function createKeyBindings(item) {
     };
   }
 
+  var bindingValue = 0;
+  if (!customActionsNoValues.includes(action)) {
+    var valueError = keyBindingUtils.getActionValueError(
+      action,
+      valueInput.value
+    );
+    if (valueError) {
+      return {
+        valid: false,
+        message:
+          "Error: Value for " +
+          (actionLabels[action] || action) +
+          " " +
+          valueError +
+          ". Unable to save"
+      };
+    }
+    bindingValue = Number(valueInput.value);
+  }
+
   keyBindings.push({
     action: action,
     code: binding.code,
     disabled: binding.disabled === true,
-    value: customActionsNoValues.includes(action)
-      ? 0
-      : Number(valueInput.value),
+    value: bindingValue,
     force: false,
     predefined: predefined
   });
@@ -768,10 +807,15 @@ function validate() {
 }
 
 function save_options() {
+  var status = document.getElementById("status");
+  if (!optionsSyncSettingsLoaded) {
+    status.textContent =
+      "Error: Settings have not loaded. Retry before saving.";
+    return;
+  }
   if (validate() === false) return;
 
   keyBindings = [];
-  var status = document.getElementById("status");
   var saveError = null;
 
   // Collect shortcuts from the main shortcuts section (both default and custom)
@@ -793,6 +837,10 @@ function save_options() {
   settings.audioBoolean = document.getElementById("audioBoolean").checked;
   settings.enabled = document.getElementById("enabled").checked;
   settings.startHidden = document.getElementById("startHidden").checked;
+  settings.shortcutTargetMode =
+    document.getElementById("shortcutTargetMode").value === "all"
+      ? "all"
+      : "closest";
   settings.hideWithControls = document.getElementById("hideWithControls").checked;
   settings.hideWithControlsTimer =
     Math.min(15, Math.max(0.1, parseFloat(document.getElementById("hideWithControlsTimer").value) || tcDefaults.hideWithControlsTimer));
@@ -829,7 +877,6 @@ function save_options() {
   settings.subtitleNudgeInterval =
     parseInt(document.getElementById("subtitleNudgeInterval").value, 10) ||
     tcDefaults.subtitleNudgeInterval;
-  settings.subtitleNudgeAmount = tcDefaults.subtitleNudgeAmount;
 
   if (settings.subtitleNudgeInterval < 10) {
     settings.subtitleNudgeInterval = 10;
@@ -851,11 +898,25 @@ function save_options() {
     var pattern = ruleEl.querySelector(".site-pattern").value.trim();
     if (pattern.length === 0) return;
 
-    var rule = { pattern: pattern };
+    var rule = vscClonePlainData(ruleEl.vscOriginalRule) || {};
+    rule.pattern = pattern;
+    var title = ruleEl.querySelector(".site-title").value.trim();
+    if (title) rule.title = title;
+    else delete rule.title;
+    delete rule.disableExtension;
 
     // Handle Enable toggle
     rule.enabled = ruleEl.querySelector(".site-enabled").checked;
 
+    if (ruleEl.querySelector(".override-shortcut-target").checked) {
+      rule.shortcutTargetMode =
+        ruleEl.querySelector(".site-shortcutTargetMode").value === "all"
+          ? "all"
+          : "closest";
+    } else {
+      delete rule.shortcutTargetMode;
+    }
+
     if (ruleEl.querySelector(".override-placement").checked) {
       rule.controllerLocation = normalizeControllerLocation(
         ruleEl.querySelector(".site-controllerLocation").value
@@ -874,10 +935,16 @@ function save_options() {
           tcDefaults.controllerMarginBottom
         )
       );
+    } else {
+      delete rule.controllerLocation;
+      delete rule.controllerMarginTop;
+      delete rule.controllerMarginBottom;
     }
 
     if (ruleEl.querySelector(".override-visibility").checked) {
       rule.startHidden = ruleEl.querySelector(".site-startHidden").checked;
+    } else {
+      delete rule.startHidden;
     }
 
     if (ruleEl.querySelector(".override-autohide").checked) {
@@ -889,13 +956,29 @@ function save_options() {
         15,
         Math.max(0.1, Number.isFinite(st) ? st : settings.hideWithControlsTimer)
       );
+    } else {
+      delete rule.hideWithControls;
+      delete rule.hideWithControlsTimer;
     }
 
     if (ruleEl.querySelector(".override-playback").checked) {
       rule.rememberSpeed = ruleEl.querySelector(".site-rememberSpeed").checked;
       rule.forceLastSavedSpeed =
         ruleEl.querySelector(".site-forceLastSavedSpeed").checked;
+      var preferredSpeed = readOptionalPreferredSpeedInput(
+        ruleEl.querySelector(".site-preferredSpeed")
+      );
+      if (preferredSpeed === undefined) {
+        delete rule.preferredSpeed;
+      } else {
+        rule.preferredSpeed = preferredSpeed;
+      }
       rule.audioBoolean = ruleEl.querySelector(".site-audioBoolean").checked;
+    } else {
+      delete rule.rememberSpeed;
+      delete rule.forceLastSavedSpeed;
+      delete rule.preferredSpeed;
+      delete rule.audioBoolean;
     }
 
     if (ruleEl.querySelector(".override-opacity").checked) {
@@ -904,6 +987,8 @@ function save_options() {
           ruleEl.querySelector(".site-controllerOpacity").value,
           settings.controllerOpacity
         );
+    } else {
+      delete rule.controllerOpacity;
     }
 
     if (ruleEl.querySelector(".override-subtitleNudge").checked) {
@@ -922,6 +1007,10 @@ function save_options() {
           Number.isFinite(nudgeIv) ? nudgeIv : settings.subtitleNudgeInterval
         )
       );
+    } else {
+      delete rule.enableSubtitleNudge;
+      delete rule.subtitleNudgeEnabledByDefault;
+      delete rule.subtitleNudgeInterval;
     }
 
     if (ruleEl.querySelector(".override-controlbar").checked) {
@@ -929,6 +1018,8 @@ function save_options() {
       if (activeZone) {
         rule.controllerButtons = readControlBarOrder(activeZone);
       }
+    } else {
+      delete rule.controllerButtons;
     }
 
     if (ruleEl.querySelector(".override-popup-controlbar").checked) {
@@ -940,6 +1031,9 @@ function save_options() {
           readControlBarOrder(popupActiveZone)
         );
       }
+    } else {
+      delete rule.showPopupControlBar;
+      delete rule.popupControllerButtons;
     }
 
     if (ruleEl.querySelector(".override-shortcuts").checked) {
@@ -971,37 +1065,56 @@ function save_options() {
           return;
         }
 
+        var shortcutValue = 0;
+        if (!customActionsNoValues.includes(action)) {
+          var shortcutValueError = keyBindingUtils.getActionValueError(
+            action,
+            valueInput.value
+          );
+          if (shortcutValueError) {
+            saveError =
+              "Error: Site rule value for " +
+              (actionLabels[action] || action) +
+              " " +
+              shortcutValueError +
+              ". Unable to save";
+            return;
+          }
+          shortcutValue = Number(valueInput.value);
+        }
+
         shortcuts.push({
           action: action,
           code: binding.code,
           disabled: binding.disabled === true,
-          value: customActionsNoValues.includes(action)
-            ? 0
-            : Number(valueInput.value),
+          value: shortcutValue,
           force: forceCheckbox ? forceCheckbox.checked : false
         });
       });
       if (saveError) return;
       if (shortcuts.length > 0) rule.shortcuts = shortcuts;
+      else delete rule.shortcuts;
+    } else {
+      delete rule.shortcuts;
     }
 
     settings.siteRules.push(rule);
   });
 
-  // Legacy keys to remove
-  const legacyKeys = [
-    "resetSpeed", "speedStep", "fastSpeed", "rewindTime", "advanceTime",
-    "resetKeyCode", "slowerKeyCode", "fasterKeyCode", "rewindKeyCode",
-    "advanceKeyCode", "fastKeyCode", "blacklist"
-  ];
+  if (saveError) {
+    status.textContent = saveError;
+    return;
+  }
 
-  chrome.storage.sync.remove(legacyKeys, function () {
-    chrome.storage.sync.set(settings, function () {
-      status.textContent = "Options saved";
-      setTimeout(function () {
-        status.textContent = "";
-      }, 1000);
-    });
+  persistManagedSyncSettings(settings, function (error) {
+    if (error) {
+      status.textContent = "Error: Unable to save options - " + error.message;
+      return;
+    }
+    status.textContent = "Options saved";
+    setTimeout(function () {
+      status.textContent = "";
+    }, 1000);
   });
 }
 
@@ -1084,9 +1197,12 @@ function createSiteRule(rule) {
   var template = document.getElementById("siteRuleTemplate");
   var clone = template.content.cloneNode(true);
   var ruleEl = clone.querySelector(".site-rule");
+  ruleEl.vscOriginalRule = vscClonePlainData(rule) || {};
 
   var pattern = rule && rule.pattern ? rule.pattern : "";
   ruleEl.querySelector(".site-pattern").value = pattern;
+  ruleEl.querySelector(".site-title").value =
+    rule && typeof rule.title === "string" ? rule.title : "";
 
   // Make the rule body collapsed by default
   setSiteRuleExpandedState(ruleEl, false);
@@ -1117,6 +1233,17 @@ function createSiteRule(rule) {
   }
   updateDisabledState();
 
+  ruleEl.querySelector(".override-shortcut-target").checked = Boolean(
+    rule && rule.shortcutTargetMode !== undefined
+  );
+  ruleEl.querySelector(".site-shortcutTargetMode").value =
+    rule && rule.shortcutTargetMode === "all" ? "all" : "closest";
+  applySiteRuleOverrideState(
+    ruleEl,
+    "override-shortcut-target",
+    "site-shortcut-target-container"
+  );
+
   var placementKeys = [
     "controllerLocation",
     "controllerMarginTop",
@@ -1150,11 +1277,16 @@ function createSiteRule(rule) {
     rule &&
     (rule.rememberSpeed !== undefined ||
       rule.forceLastSavedSpeed !== undefined ||
+      rule.preferredSpeed !== undefined ||
       rule.audioBoolean !== undefined)
   );
   ruleEl.querySelector(".override-playback").checked = hasPlaybackOverride;
   syncSiteRuleField(ruleEl, rule, "rememberSpeed", true);
   syncSiteRuleField(ruleEl, rule, "forceLastSavedSpeed", true);
+  ruleEl.querySelector(".site-preferredSpeed").value =
+    rule && Number.isFinite(Number(rule.preferredSpeed))
+      ? String(rule.preferredSpeed)
+      : "";
   syncSiteRuleField(ruleEl, rule, "audioBoolean", true);
   applySiteRuleOverrideState(ruleEl, "override-playback", "site-playback-container");
 
@@ -1621,11 +1753,26 @@ function initLucideButtonIconsUI() {
   }
 }
 
-function restore_options() {
-  chrome.storage.sync.get(tcDefaults, function (storage) {
+function restore_options(callback) {
+  var done = typeof callback === "function" ? callback : function () {};
+  var status = document.getElementById("status");
+  setOptionsSyncSettingsLoaded(false);
+  chrome.storage.sync.get(null, function (rawStorage) {
+    var syncError = chrome.runtime.lastError;
+    if (syncError) {
+      status.textContent =
+        "Error: Unable to load options - " + syncError.message;
+      done(syncError);
+      return;
+    }
+    var storage = vscExpandStoredSettings(rawStorage || {});
     chrome.storage.local.get(["customButtonIcons"], function (loc) {
+      var localError = chrome.runtime.lastError;
       customButtonIconsLive =
-        loc && loc.customButtonIcons && typeof loc.customButtonIcons === "object"
+        !localError &&
+        loc &&
+        loc.customButtonIcons &&
+        typeof loc.customButtonIcons === "object"
           ? loc.customButtonIcons
           : {};
 
@@ -1635,13 +1782,11 @@ function restore_options() {
     document.getElementById("audioBoolean").checked = storage.audioBoolean;
     document.getElementById("enabled").checked = storage.enabled;
     document.getElementById("startHidden").checked = storage.startHidden;
+    document.getElementById("shortcutTargetMode").value =
+      storage.shortcutTargetMode === "all" ? "all" : "closest";
 
-    // Migration/Normalization for hideWithControls
-    const hideWithControls = typeof storage.hideWithControls !== "undefined"
-      ? storage.hideWithControls
-      : storage.hideWithYouTubeControls;
-    
-    document.getElementById("hideWithControls").checked = hideWithControls;
+    document.getElementById("hideWithControls").checked =
+      storage.hideWithControls;
     document.getElementById("hideWithControlsTimer").value = 
       storage.hideWithControlsTimer || tcDefaults.hideWithControlsTimer;
 
@@ -1699,11 +1844,7 @@ function restore_options() {
 
     refreshAddShortcutSelector();
 
-    // Load site rules (use defaults if none in storage or empty array)
-    var siteRules =
-      Array.isArray(storage.siteRules) && storage.siteRules.length > 0
-        ? storage.siteRules
-        : tcDefaults.siteRules || [];
+    var siteRules = Array.isArray(storage.siteRules) ? storage.siteRules : [];
 
     vscClearElement(document.getElementById("siteRulesContainer"));
     if (siteRules.length > 0) {
@@ -1729,25 +1870,87 @@ function restore_options() {
     updatePopupEditorDisabledState();
 
     initLucideButtonIconsUI();
+    setOptionsSyncSettingsLoaded(true);
+    if (localError) {
+      status.textContent =
+        "Warning: Options loaded, but custom icons could not be read - " +
+        localError.message;
+    }
+    done(localError || null);
     });
   });
 }
 
 function restore_defaults() {
-  document.querySelectorAll(".customs:not([id])").forEach((el) => el.remove());
+  var status = document.getElementById("status");
+  var restoreButton = document.getElementById("restore");
+  setOptionsSyncSettingsLoaded(false);
+  if (restoreButton) restoreButton.disabled = true;
 
-  chrome.storage.local.remove(
-    ["customButtonIcons", "lucideTagsCacheV1", "lucideTagsCacheV1At"],
-    function () {}
-  );
+  function finishRestore(error) {
+    // Leave the storage callback before rereading. Besides avoiding nested API
+    // calls, this prevents a callback-scoped runtime.lastError from being
+    // mistaken for an error from the fresh read.
+    Promise.resolve().then(function () {
+      restore_options(function (reloadError) {
+        if (restoreButton) restoreButton.disabled = false;
+        if (error) {
+          status.textContent =
+            "Error: Unable to restore all defaults - " + error.message;
+          return;
+        }
+        if (reloadError) {
+          status.textContent =
+            "Defaults restored, but the options page could not reload - " +
+            reloadError.message;
+          return;
+        }
+        status.textContent = "Default options restored";
+        setTimeout(function () {
+          status.textContent = "";
+        }, 1000);
+      });
+    });
+  }
 
-  chrome.storage.sync.set(tcDefaults, function () {
-    restore_options();
-    var status = document.getElementById("status");
-    status.textContent = "Default options restored";
-    setTimeout(function () {
-      status.textContent = "";
-    }, 1000);
+  persistManagedSyncSettings(tcDefaults, function (error) {
+    if (error) {
+      finishRestore(error);
+      return;
+    }
+
+    chrome.storage.sync.set({ lastSpeed: tcDefaults.lastSpeed }, function () {
+      var lastSpeedError = chrome.runtime.lastError;
+      if (lastSpeedError) {
+        finishRestore(lastSpeedError);
+        return;
+      }
+
+      chrome.storage.local.set(
+        {
+          rememberedSpeeds: {},
+          rememberedSpeedsResetAt: Date.now()
+        },
+        function () {
+          var speedResetError = chrome.runtime.lastError;
+          if (speedResetError) {
+            finishRestore(speedResetError);
+            return;
+          }
+          chrome.storage.local.remove(
+            [
+              "customButtonIcons",
+              "lucideTagsCacheV1",
+              "lucideTagsCacheV1At",
+              "rememberedSpeeds"
+            ],
+            function () {
+              finishRestore(chrome.runtime.lastError || null);
+            }
+          );
+        }
+      );
+    });
   });
 }
 
diff --git a/extension/popup/popup.html b/extension/popup/popup.html
index 53043c5..8f3dfc9 100644
--- a/extension/popup/popup.html
+++ b/extension/popup/popup.html
@@ -4,6 +4,7 @@
     <meta charset="utf-8" />
     <title>Speeder</title>
     <link rel="stylesheet" href="popup.css" />
+    <script src="../shared/settings-core.js"></script>
     <script src="../shared/site-rules.js"></script>
     <script src="../shared/popup-controls.js"></script>
     <script src="../shared/ui-icons.js"></script>
diff --git a/extension/popup/popup.js b/extension/popup/popup.js
index f229c5a..b9a1210 100644
--- a/extension/popup/popup.js
+++ b/extension/popup/popup.js
@@ -25,17 +25,47 @@ document.addEventListener("DOMContentLoaded", function () {
 
   var defaultButtons = ["rewind", "slower", "faster", "advance", "display"];
   var popupExcludedButtonIds = new Set(["settings"]);
-  var storageDefaults = {
-    enabled: true,
-    lastSpeed: 1.0,
-    forceLastSavedSpeed: false,
-    showPopupControlBar: true,
-    controllerButtons: defaultButtons,
-    popupMatchHoverControls: true,
-    popupControllerButtons: defaultButtons,
-    siteRules: []
-  };
   var renderToken = 0;
+  var forceLastSavedSpeedControlledBySiteRule = null;
+
+  function persistExpandedSettings(rawStorage, settings, callback) {
+    var mutation = vscBuildManagedStorageMutation(rawStorage, settings);
+
+    function removeStaleKeys() {
+      if (!mutation.remove.length) {
+        callback(null);
+        return;
+      }
+      chrome.storage.sync.remove(mutation.remove, function () {
+        callback(chrome.runtime.lastError || null);
+      });
+    }
+
+    if (!Object.keys(mutation.set).length) {
+      removeStaleKeys();
+      return;
+    }
+
+    chrome.storage.sync.set(mutation.set, function () {
+      if (chrome.runtime.lastError) {
+        callback(chrome.runtime.lastError);
+        return;
+      }
+      removeStaleKeys();
+    });
+  }
+
+  function updateStoredSettings(update, callback) {
+    chrome.storage.sync.get(null, function (rawStorage) {
+      if (chrome.runtime.lastError) {
+        callback(chrome.runtime.lastError);
+        return;
+      }
+      var settings = vscExpandStoredSettings(rawStorage || {});
+      update(settings);
+      persistExpandedSettings(rawStorage || {}, settings, callback);
+    });
+  }
 
   function updateForceButton(enabled) {
     var button = document.getElementById("forceLastSavedSpeed");
@@ -46,6 +76,13 @@ document.addEventListener("DOMContentLoaded", function () {
       : "Keep this page at the last speed saved by Speeder";
   }
 
+  function setForceButtonLoading(loading) {
+    var button = document.getElementById("forceLastSavedSpeed");
+    if (!button) return;
+    button.disabled = loading === true;
+    button.setAttribute("aria-busy", loading ? "true" : "false");
+  }
+
   function matchSiteRule(url, siteRules) {
     return siteRuleUtils.matchSiteRule(url, siteRules);
   }
@@ -131,9 +168,10 @@ document.addEventListener("DOMContentLoaded", function () {
     return popupControlUtils.pickBestFrameSpeedResult(results);
   }
 
-  function querySpeed() {
+  function querySpeed(callback) {
     chrome.tabs.query({ active: true, currentWindow: true }, function (tabs) {
       if (!tabs[0] || tabs[0].id == null) {
+        if (callback) callback(null);
         return;
       }
       var tabId = tabs[0].id;
@@ -144,15 +182,18 @@ document.addEventListener("DOMContentLoaded", function () {
           if (chrome.runtime.lastError) {
             sendToActiveTab({ action: "get_speed" }, function (response) {
               applySpeedAndResetFromResponse(response || { speed: 1 });
+              if (callback) callback(response || null);
             });
             return;
           }
           var best = pickBestFrameSpeedResult(results);
           if (best) {
             applySpeedAndResetFromResponse(best);
+            if (callback) callback(best);
           } else {
             sendToActiveTab({ action: "get_speed" }, function (response) {
               applySpeedAndResetFromResponse(response || { speed: 1 });
+              if (callback) callback(response || null);
             });
           }
         }
@@ -269,39 +310,69 @@ document.addEventListener("DOMContentLoaded", function () {
   if (!forceLastSavedSpeedButton.dataset.listenerAttached) {
     forceLastSavedSpeedButton.dataset.listenerAttached = "true";
     forceLastSavedSpeedButton.addEventListener("click", function () {
+      if (forceLastSavedSpeedControlledBySiteRule === null) {
+        setStatusMessage("Loading page settings...");
+        return;
+      }
+      if (forceLastSavedSpeedControlledBySiteRule) {
+        setStatusMessage("Force setting is controlled by this site rule.");
+        return;
+      }
+
       var button = this;
       var enabled = button.getAttribute("aria-pressed") !== "true";
-      chrome.storage.sync.get({ lastSpeed: 1.0 }, function (storage) {
-        chrome.storage.sync.set({ forceLastSavedSpeed: enabled }, function () {
-          updateForceButton(enabled);
+      updateStoredSettings(
+        function (settings) {
+          settings.forceLastSavedSpeed = enabled;
+        },
+        function (error) {
+          if (error) {
+            setStatusMessage("Could not update speed forcing: " + error.message);
+            return;
+          }
           sendToActiveTab(
             {
               action: "set_force_last_saved_speed",
-              enabled: enabled,
-              speed: Number(storage.lastSpeed) || 1.0
+              enabled: enabled
             },
             function (response) {
+              var effectiveEnabled =
+                response && typeof response.enabled === "boolean"
+                  ? response.enabled
+                  : enabled;
+              updateForceButton(effectiveEnabled);
+              if (effectiveEnabled !== enabled) {
+                setStatusMessage("Force setting is controlled by this site rule.");
+                if (response && response.speed != null) {
+                  updateSpeedDisplay(response.speed);
+                }
+                return;
+              }
               if (response && response.speed != null) {
                 updateSpeedDisplay(response.speed);
                 setStatusMessage(
-                  enabled ? "Saved speed is now forced." : "Speed forcing is off."
+                  effectiveEnabled
+                    ? "Saved speed is now forced."
+                    : "Speed forcing is off."
                 );
               } else {
                 setStatusMessage(
-                  enabled
+                  effectiveEnabled
                     ? "Force enabled. No video found on this page."
                     : "Speed forcing is off."
                 );
               }
             }
           );
-        });
-      });
+        }
+      );
     });
   }
 
   function renderForActiveTab() {
     var currentRenderToken = ++renderToken;
+    forceLastSavedSpeedControlledBySiteRule = null;
+    setForceButtonLoading(true);
 
     chrome.storage.local.get(["customButtonIcons"], function (loc) {
       if (currentRenderToken !== renderToken) return;
@@ -310,46 +381,75 @@ document.addEventListener("DOMContentLoaded", function () {
           ? loc.customButtonIcons
           : {};
 
-      chrome.storage.sync.get(storageDefaults, function (storage) {
+      chrome.storage.sync.get(null, function (rawStorage) {
         if (currentRenderToken !== renderToken) return;
+        var storage = vscExpandStoredSettings(rawStorage || {});
 
-      getActiveTabContext(function (context) {
-        if (currentRenderToken !== renderToken) return;
+        getActiveTabContext(function (context) {
+          if (currentRenderToken !== renderToken) return;
 
-        var url = context && context.url ? context.url : "";
-        var siteRule = matchSiteRule(url, storage.siteRules);
-        var siteDisabled = isSiteRuleDisabled(siteRule);
-        var siteAvailable = siteRuleUtils.isSpeederActiveForSite(
-          storage.enabled,
-          siteRule
-        );
-        var showBar = storage.showPopupControlBar !== false;
+          var url = context && context.url ? context.url : "";
+          var siteRule = matchSiteRule(url, storage.siteRules);
+          var siteDisabled = isSiteRuleDisabled(siteRule);
+          var siteAvailable = siteRuleUtils.isSpeederActiveForSite(
+            storage.enabled,
+            siteRule
+          );
+          var showBar = storage.showPopupControlBar !== false;
+          forceLastSavedSpeedControlledBySiteRule = Boolean(
+            siteRule && siteRule.forceLastSavedSpeed !== undefined
+          );
+          var effectiveForceLastSavedSpeed =
+            forceLastSavedSpeedControlledBySiteRule
+              ? siteRule.forceLastSavedSpeed === true
+              : storage.forceLastSavedSpeed === true;
 
-        if (siteRule && siteRule.showPopupControlBar !== undefined) {
-          showBar = siteRule.showPopupControlBar;
-        }
+          if (siteRule && siteRule.showPopupControlBar !== undefined) {
+            showBar = siteRule.showPopupControlBar;
+          }
 
-        toggleEnabledUI(storage.enabled !== false);
-        updateForceButton(storage.forceLastSavedSpeed === true);
-        buildControlBar(
-          resolvePopupButtons(storage, siteRule),
-          customIconsMap
-        );
-        setControlBarVisible(siteAvailable && showBar);
+          toggleEnabledUI(storage.enabled !== false);
+          updateForceButton(effectiveForceLastSavedSpeed);
+          buildControlBar(
+            resolvePopupButtons(storage, siteRule),
+            customIconsMap
+          );
+          setControlBarVisible(siteAvailable && showBar);
 
-        if (siteDisabled) {
-          setStatusMessage("Speeder is disabled for this site.");
-          updateSpeedDisplay(1);
-          return;
-        }
+          if (siteDisabled) {
+            setForceButtonLoading(false);
+            setStatusMessage("Speeder is disabled for this site.");
+            updateSpeedDisplay(1);
+            return;
+          }
 
-        clearStatusMessage();
-        if (siteAvailable) {
-          querySpeed();
-        } else {
-          updateSpeedDisplay(1);
-        }
-      });
+          clearStatusMessage();
+          if (siteAvailable) {
+            querySpeed(function(frameContext) {
+              if (currentRenderToken !== renderToken) return;
+              if (
+                frameContext &&
+                typeof frameContext.forceLastSavedSpeed === "boolean"
+              ) {
+                effectiveForceLastSavedSpeed =
+                  frameContext.forceLastSavedSpeed;
+              }
+              if (
+                frameContext &&
+                typeof frameContext.forceLastSavedSpeedControlledBySiteRule ===
+                  "boolean"
+              ) {
+                forceLastSavedSpeedControlledBySiteRule =
+                  frameContext.forceLastSavedSpeedControlledBySiteRule;
+              }
+              updateForceButton(effectiveForceLastSavedSpeed);
+              setForceButtonLoading(false);
+            });
+          } else {
+            updateSpeedDisplay(1);
+            setForceButtonLoading(false);
+          }
+        });
       });
     });
   }
@@ -378,7 +478,9 @@ document.addEventListener("DOMContentLoaded", function () {
       changes.controllerButtons ||
       changes.popupMatchHoverControls ||
       changes.popupControllerButtons ||
-      changes.siteRules
+      changes.siteRules ||
+      changes.siteRulesMeta ||
+      changes.siteRulesFormat
     ) {
       renderForActiveTab();
     }
@@ -387,10 +489,19 @@ document.addEventListener("DOMContentLoaded", function () {
   renderForActiveTab();
 
   function toggleEnabled(enabled, callback) {
-    chrome.storage.sync.set({ enabled: enabled }, function () {
-      toggleEnabledUI(enabled);
-      if (callback) callback(enabled);
-    });
+    updateStoredSettings(
+      function (settings) {
+        settings.enabled = enabled;
+      },
+      function (error) {
+        if (error) {
+          setStatusMessage("Could not update Speeder: " + error.message);
+          return;
+        }
+        toggleEnabledUI(enabled);
+        if (callback) callback(enabled);
+      }
+    );
   }
 
   function toggleEnabledUI(enabled) {
diff --git a/extension/shared/import-export.js b/extension/shared/import-export.js
index 8df9a4b..509d72f 100644
--- a/extension/shared/import-export.js
+++ b/extension/shared/import-export.js
@@ -30,11 +30,26 @@
     "rememberSpeed",
     "showPopupControlBar",
     "siteRules",
+    "siteRulesFormat",
+    "siteRulesMeta",
     "speed",
     "startHidden",
     "subtitleNudgeAmount",
     "subtitleNudgeEnabledByDefault",
-    "subtitleNudgeInterval"
+    "subtitleNudgeInterval",
+    "resetSpeed",
+    "speedStep",
+    "fastSpeed",
+    "rewindTime",
+    "advanceTime",
+    "resetKeyCode",
+    "slowerKeyCode",
+    "fasterKeyCode",
+    "rewindKeyCode",
+    "advanceKeyCode",
+    "fastKeyCode",
+    "displayKeyCode",
+    "blacklist"
   ]);
 
   function isRecognizedRawSettingsObject(backup) {
@@ -48,24 +63,20 @@
   }
 
   /**
-   * Local-only keys excluded from backup JSON. These are disposable caches
-   * (e.g. Lucide tags.json) that bloat exports and are refetched when needed.
-   * Keep in sync with options/lucide-client.js (LUCIDE_TAGS_CACHE_KEY + "At").
+   * Only user-authored local settings belong in backups. Disposable caches,
+   * per-source speed history, and future runtime data stay installation-local.
    */
-  var localSettingsKeysOmittedFromExport = [
-    "lucideTagsCacheV1",
-    "lucideTagsCacheV1At"
-  ];
-
   function filterLocalSettingsForExport(local) {
     if (!local || typeof local !== "object" || Array.isArray(local)) {
       return {};
     }
     var out = {};
-    for (var key in local) {
-      if (!Object.prototype.hasOwnProperty.call(local, key)) continue;
-      if (localSettingsKeysOmittedFromExport.indexOf(key) !== -1) continue;
-      out[key] = local[key];
+    if (
+      local.customButtonIcons &&
+      typeof local.customButtonIcons === "object" &&
+      !Array.isArray(local.customButtonIcons)
+    ) {
+      out.customButtonIcons = local.customButtonIcons;
     }
     return out;
   }
@@ -108,27 +119,64 @@
   function extractImportSettings(backup) {
     var settingsToImport = null;
     var isWrappedBackup = false;
+    var backupIsObject =
+      backup && typeof backup === "object" && !Array.isArray(backup);
+    var hasWrappedSettings =
+      backupIsObject &&
+      Object.prototype.hasOwnProperty.call(backup, "settings");
 
-    if (backup && backup.settings && typeof backup.settings === "object") {
+    if (hasWrappedSettings) {
+      if (
+        !backup.settings ||
+        typeof backup.settings !== "object" ||
+        Array.isArray(backup.settings)
+      ) {
+        return null;
+      }
       settingsToImport = backup.settings;
       isWrappedBackup = true;
-    } else if (
-      backup &&
-      typeof backup === "object" &&
-      isRecognizedRawSettingsObject(backup)
-    ) {
+    } else if (backupIsObject && isRecognizedRawSettingsObject(backup)) {
       settingsToImport = backup;
     }
 
     if (!settingsToImport) return null;
 
+    if (
+      isWrappedBackup &&
+      Object.prototype.hasOwnProperty.call(backup, "localSettings") &&
+      (
+        !backup.localSettings ||
+        typeof backup.localSettings !== "object" ||
+        Array.isArray(backup.localSettings)
+      )
+    ) {
+      return null;
+    }
+
+    if (
+      isWrappedBackup &&
+      backup.localSettings &&
+      Object.prototype.hasOwnProperty.call(
+        backup.localSettings,
+        "customButtonIcons"
+      ) &&
+      (
+        !backup.localSettings.customButtonIcons ||
+        typeof backup.localSettings.customButtonIcons !== "object" ||
+        Array.isArray(backup.localSettings.customButtonIcons)
+      )
+    ) {
+      return null;
+    }
+
     return {
       isWrappedBackup: isWrappedBackup,
       settings: settingsToImport,
       localSettings:
         backup &&
         backup.localSettings &&
-        typeof backup.localSettings === "object"
+        typeof backup.localSettings === "object" &&
+        !Array.isArray(backup.localSettings)
           ? backup.localSettings
           : null
     };
diff --git a/extension/shared/key-bindings.js b/extension/shared/key-bindings.js
index ec4faf3..777627a 100644
--- a/extension/shared/key-bindings.js
+++ b/extension/shared/key-bindings.js
@@ -112,11 +112,62 @@
       : null;
   }
 
+  var defaultActionValues = {
+    slower: 0.1,
+    faster: 0.1,
+    rewind: 10,
+    advance: 10,
+    fast: 1.8,
+    louder: 0.1,
+    softer: 0.1
+  };
+
+  function getActionValueError(action, value) {
+    var numericValue = Number(value);
+    if (!Number.isFinite(numericValue)) return "must be a finite number";
+    if (
+      (action === "slower" || action === "faster") &&
+      (numericValue <= 0 || numericValue > 16)
+    ) {
+      return "must be greater than 0 and no more than 16";
+    }
+    if (
+      action === "fast" &&
+      (numericValue < 0.0625 || numericValue > 16)
+    ) {
+      return "must be between 0.0625 and 16";
+    }
+    if (
+      (action === "rewind" || action === "advance") &&
+      numericValue < 0
+    ) {
+      return "must be zero or greater";
+    }
+    if (
+      (action === "louder" || action === "softer") &&
+      (numericValue <= 0 || numericValue > 1)
+    ) {
+      return "must be greater than 0 and no more than 1";
+    }
+    return null;
+  }
+
+  function sanitizeActionValue(action, value, fallback) {
+    if (!getActionValueError(action, value)) return Number(value);
+    if (!getActionValueError(action, fallback)) return Number(fallback);
+    if (Object.prototype.hasOwnProperty.call(defaultActionValues, action)) {
+      return defaultActionValues[action];
+    }
+    return 0;
+  }
+
   return {
+    getActionValueError: getActionValueError,
     getLegacyKeyCode: getLegacyKeyCode,
     inferBindingCode: inferBindingCode,
     legacyBindingKeyToCode: legacyBindingKeyToCode,
     legacyKeyCodeToCode: legacyKeyCodeToCode,
-    normalizeBindingKey: normalizeBindingKey
+    normalizeBindingKey: normalizeBindingKey,
+    sanitizeActionValue: sanitizeActionValue
   };
 });
diff --git a/extension/shared/popup-controls.js b/extension/shared/popup-controls.js
index c85e4e5..cac3000 100644
--- a/extension/shared/popup-controls.js
+++ b/extension/shared/popup-controls.js
@@ -66,12 +66,26 @@
   function pickBestFrameSpeedResult(results) {
     if (!results || !results.length) return null;
 
+    function normalizeResult(result) {
+      var normalized = { speed: result.speed };
+      if (typeof result.forceLastSavedSpeed === "boolean") {
+        normalized.forceLastSavedSpeed = result.forceLastSavedSpeed;
+      }
+      if (
+        typeof result.forceLastSavedSpeedControlledBySiteRule === "boolean"
+      ) {
+        normalized.forceLastSavedSpeedControlledBySiteRule =
+          result.forceLastSavedSpeedControlledBySiteRule;
+      }
+      return normalized;
+    }
+
     var fallback = null;
     for (var i = 0; i < results.length; i++) {
       var result = results[i];
       if (!result || typeof result.speed !== "number") continue;
-      if (result.preferred) return { speed: result.speed };
-      if (!fallback) fallback = { speed: result.speed };
+      if (result.preferred) return normalizeResult(result);
+      if (!fallback) fallback = normalizeResult(result);
     }
 
     return fallback;
diff --git a/extension/shared/settings-core.js b/extension/shared/settings-core.js
index b9baf3b..01ce88f 100644
--- a/extension/shared/settings-core.js
+++ b/extension/shared/settings-core.js
@@ -1,27 +1,24 @@
 (function (global) {
   "use strict";
 
-  var SITE_RULES_DIFF_FORMAT = "defaults-diff-v1";
+  var LEGACY_SITE_RULES_DIFF_FORMAT = "defaults-diff-v1";
+  var SITE_RULES_DIFF_FORMAT = "defaults-diff-v2";
+  var REMOVED_DEFAULT_RULE_KEYS_META = "removedDefaultRuleKeys";
   var DEFAULT_BUTTONS = ["rewind", "slower", "faster", "advance", "display"];
-  var SITE_RULE_OVERRIDE_KEYS = [
-    "controllerLocation",
-    "controllerMarginTop",
-    "controllerMarginBottom",
-    "startHidden",
-    "hideWithControls",
-    "hideWithControlsTimer",
-    "rememberSpeed",
-    "forceLastSavedSpeed",
-    "audioBoolean",
-    "controllerOpacity",
-    "enableSubtitleNudge",
-    "subtitleNudgeEnabledByDefault",
-    "subtitleNudgeInterval",
-    "controllerButtons",
-    "showPopupControlBar",
-    "popupControllerButtons",
-    "shortcuts",
-    "preferredSpeed"
+  var LEGACY_SYNC_KEYS = [
+    "resetSpeed",
+    "speedStep",
+    "fastSpeed",
+    "rewindTime",
+    "advanceTime",
+    "resetKeyCode",
+    "slowerKeyCode",
+    "fasterKeyCode",
+    "rewindKeyCode",
+    "advanceKeyCode",
+    "fastKeyCode",
+    "displayKeyCode",
+    "blacklist"
   ];
   var DIFFABLE_OPTION_KEYS = [
     "rememberSpeed",
@@ -34,7 +31,10 @@
     "controllerLocation",
     "controllerOpacity",
     "controllerMarginTop",
+    "controllerMarginRight",
     "controllerMarginBottom",
+    "controllerMarginLeft",
+    "shortcutTargetMode",
     "keyBindings",
     "siteRules",
     "siteRulesMeta",
@@ -48,14 +48,14 @@
     "subtitleNudgeInterval",
     "subtitleNudgeAmount"
   ];
-  var MANAGED_SYNC_KEYS = DIFFABLE_OPTION_KEYS.concat([
-    "hideWithYouTubeControls"
-  ]);
+  var MANAGED_SYNC_KEYS = DIFFABLE_OPTION_KEYS.concat(
+    ["hideWithYouTubeControls"],
+    LEGACY_SYNC_KEYS
+  );
 
   var DEFAULT_SETTINGS = {
     speed: 1.0,
     lastSpeed: 1.0,
-    displayKeyCode: 86,
     rememberSpeed: false,
     audioBoolean: false,
     startHidden: false,
@@ -70,12 +70,11 @@
     controllerMarginRight: 0,
     controllerMarginBottom: 65,
     controllerMarginLeft: 0,
+    shortcutTargetMode: "closest",
     keyBindings: [
       {
         action: "display",
-        key: "V",
-        keyCode: 86,
-        code: null,
+        code: "KeyV",
         disabled: false,
         value: 0,
         force: false,
@@ -83,9 +82,7 @@
       },
       {
         action: "move",
-        key: "P",
-        keyCode: 80,
-        code: null,
+        code: "KeyP",
         disabled: false,
         value: 0,
         force: false,
@@ -93,9 +90,7 @@
       },
       {
         action: "slower",
-        key: "S",
-        keyCode: 83,
-        code: null,
+        code: "KeyS",
         disabled: false,
         value: 0.1,
         force: false,
@@ -103,9 +98,7 @@
       },
       {
         action: "faster",
-        key: "D",
-        keyCode: 68,
-        code: null,
+        code: "KeyD",
         disabled: false,
         value: 0.1,
         force: false,
@@ -113,9 +106,7 @@
       },
       {
         action: "rewind",
-        key: "Z",
-        keyCode: 90,
-        code: null,
+        code: "KeyZ",
         disabled: false,
         value: 10,
         force: false,
@@ -123,9 +114,7 @@
       },
       {
         action: "advance",
-        key: "X",
-        keyCode: 88,
-        code: null,
+        code: "KeyX",
         disabled: false,
         value: 10,
         force: false,
@@ -133,9 +122,7 @@
       },
       {
         action: "reset",
-        key: "R",
-        keyCode: 82,
-        code: null,
+        code: "KeyR",
         disabled: false,
         value: 0,
         force: false,
@@ -143,9 +130,7 @@
       },
       {
         action: "fast",
-        key: "G",
-        keyCode: 71,
-        code: null,
+        code: "KeyG",
         disabled: false,
         value: 1.8,
         force: false,
@@ -153,9 +138,7 @@
       },
       {
         action: "toggleSubtitleNudge",
-        key: "N",
-        keyCode: 78,
-        code: null,
+        code: "KeyN",
         disabled: false,
         value: 0,
         force: false,
@@ -164,17 +147,27 @@
     ],
     siteRules: [
       {
+        title: "YouTube videos",
         pattern: "/^https:\\/\\/(www\\.)?youtube\\.com\\/(?!shorts\\/).*/",
         enabled: true,
         enableSubtitleNudge: true,
         subtitleNudgeInterval: 50
       },
       {
+        title: "YouTube Shorts",
         pattern: "/^https:\\/\\/(www\\.)?youtube\\.com\\/shorts\\/.*/",
         enabled: true,
         rememberSpeed: true,
         controllerMarginTop: 60,
         controllerMarginBottom: 85
+      },
+      {
+        title: "YouTube Shorts (mobile)",
+        pattern: "/^https:\\/\\/m\\.youtube\\.com\\/shorts\\/.*/",
+        enabled: true,
+        rememberSpeed: true,
+        controllerMarginTop: 60,
+        controllerMarginBottom: 85
       }
     ],
     controllerButtons: DEFAULT_BUTTONS.slice(),
@@ -305,7 +298,83 @@
     return map;
   }
 
-  function normalizeSiteRuleForDiff(rule, baseSettings) {
+  function coerceBoolean(value, fallback) {
+    if (value === true || value === false) return value;
+    if (value === "true" || value === 1 || value === "1") return true;
+    if (value === "false" || value === 0 || value === "0") return false;
+    return fallback;
+  }
+
+  function clampFiniteNumber(value, minimum, maximum, fallback) {
+    if (
+      value === null ||
+      typeof value === "boolean" ||
+      (typeof value === "string" && value.trim() === "") ||
+      (typeof value !== "number" && typeof value !== "string")
+    ) {
+      return fallback;
+    }
+    var numericValue = Number(value);
+    if (!Number.isFinite(numericValue)) return fallback;
+    return Math.min(maximum, Math.max(minimum, numericValue));
+  }
+
+  var SITE_RULE_BOOLEAN_KEYS = new Set([
+    "enabled",
+    "startHidden",
+    "hideWithControls",
+    "rememberSpeed",
+    "forceLastSavedSpeed",
+    "audioBoolean",
+    "enableSubtitleNudge",
+    "subtitleNudgeEnabledByDefault",
+    "showPopupControlBar",
+    "popupMatchHoverControls"
+  ]);
+
+  function normalizeSiteRuleValue(key, value) {
+    if (key === "title") {
+      if (typeof value !== "string") return undefined;
+      var title = value.trim();
+      return title || undefined;
+    }
+    if (SITE_RULE_BOOLEAN_KEYS.has(key)) {
+      return coerceBoolean(value, undefined);
+    }
+    if (key === "shortcutTargetMode") {
+      return value === "all" || value === "closest" ? value : undefined;
+    }
+    if (key === "hideWithControlsTimer") {
+      return clampFiniteNumber(value, 0.1, 15, undefined);
+    }
+    if (key === "controllerOpacity") {
+      return clampFiniteNumber(value, 0, 1, undefined);
+    }
+    if (
+      key === "controllerMarginTop" ||
+      key === "controllerMarginRight" ||
+      key === "controllerMarginBottom" ||
+      key === "controllerMarginLeft"
+    ) {
+      return clampFiniteNumber(value, 0, 200, undefined);
+    }
+    if (key === "subtitleNudgeInterval") {
+      return clampFiniteNumber(value, 10, 1000, undefined);
+    }
+    if (key === "preferredSpeed") {
+      return clampFiniteNumber(value, 0.0625, 16, undefined);
+    }
+    if (key === "shortcuts" && Array.isArray(value)) {
+      return sanitizeStoredBindingValues(value).map(function(shortcut) {
+        shortcut.disabled = coerceBoolean(shortcut.disabled, false);
+        shortcut.force = coerceBoolean(shortcut.force, false);
+        return shortcut;
+      });
+    }
+    return clonePlainData(value);
+  }
+
+  function normalizeSiteRule(rule) {
     if (!rule || typeof rule !== "object" || Array.isArray(rule)) {
       return null;
     }
@@ -316,89 +385,83 @@
     }
 
     var normalized = { pattern: pattern };
-    var baseEnabled = hasOwn(baseSettings, "enabled")
-      ? Boolean(baseSettings.enabled)
-      : true;
-    var ruleEnabled = hasOwn(rule, "enabled")
-      ? Boolean(rule.enabled)
-      : hasOwn(rule, "disableExtension")
-        ? !Boolean(rule.disableExtension)
-        : baseEnabled;
-
-    if (!areComparableValuesEqual(ruleEnabled, baseEnabled)) {
-      normalized.enabled = ruleEnabled;
-    }
-
-    SITE_RULE_OVERRIDE_KEYS.forEach(function (key) {
-      var baseValue = clonePlainData(baseSettings[key]);
-      var effectiveValue = hasOwn(rule, key)
-        ? clonePlainData(rule[key])
-        : baseValue;
-
-      if (!areComparableValuesEqual(effectiveValue, baseValue)) {
-        normalized[key] = effectiveValue;
-      }
-    });
-
     Object.keys(rule).forEach(function (key) {
       if (
         key === "pattern" ||
-        key === "enabled" ||
         key === "disableExtension" ||
-        SITE_RULE_OVERRIDE_KEYS.indexOf(key) !== -1 ||
         rule[key] === undefined
       ) {
         return;
       }
 
-      normalized[key] = clonePlainData(rule[key]);
+      var normalizedValue = normalizeSiteRuleValue(key, rule[key]);
+      if (normalizedValue !== undefined) {
+        normalized[key] = normalizedValue;
+      }
     });
 
+    if (!hasOwn(normalized, "enabled") && hasOwn(rule, "disableExtension")) {
+      normalized.enabled = !coerceBoolean(rule.disableExtension, false);
+    }
+
     return normalized;
   }
 
-  function compressSiteRules(siteRules, baseSettings) {
+  function compressSiteRules(siteRules) {
     if (!Array.isArray(siteRules)) {
       return {};
     }
 
     var defaultRules = getDefaultSiteRules();
     var defaultRulesByPattern = getDefaultSiteRulesByPattern();
-    var currentPatterns = new Set();
+    var claimedDefaultPatterns = new Set();
     var exportRules = [];
+    var removedDefaultRuleKeys = [];
 
     siteRules.forEach(function (rule) {
-      if (!rule || typeof rule !== "object" || Array.isArray(rule)) {
-        return;
-      }
+      var normalizedRule = normalizeSiteRule(rule);
+      if (!normalizedRule) return;
 
-      var pattern = typeof rule.pattern === "string" ? rule.pattern.trim() : "";
-      if (pattern) {
-        currentPatterns.add(pattern);
-      }
+      var pattern = normalizedRule.pattern;
+      var defaultRule = defaultRulesByPattern[pattern];
+      if (defaultRule && !claimedDefaultPatterns.has(pattern)) {
+        claimedDefaultPatterns.add(pattern);
+        var normalizedDefaultRule = normalizeSiteRule(defaultRule);
+        var patch = { pattern: pattern };
+        var removedKeys = [];
 
-      var normalizedRule = normalizeSiteRuleForDiff(rule, baseSettings);
-      if (!normalizedRule || Object.keys(normalizedRule).length === 1) {
-        return;
-      }
+        Object.keys(normalizedRule).forEach(function (key) {
+          if (key === "pattern") return;
+          if (
+            !hasOwn(normalizedDefaultRule, key) ||
+            !areComparableValuesEqual(
+              normalizedRule[key],
+              normalizedDefaultRule[key]
+            )
+          ) {
+            patch[key] = clonePlainData(normalizedRule[key]);
+          }
+        });
 
-      var defaultRule = pattern ? defaultRulesByPattern[pattern] : null;
-      var normalizedDefaultRule = defaultRule
-        ? normalizeSiteRuleForDiff(defaultRule, baseSettings)
-        : null;
-      if (normalizedDefaultRule) {
-        if (areComparableValuesEqual(normalizedRule, normalizedDefaultRule)) {
-          return;
+        Object.keys(normalizedDefaultRule).forEach(function (key) {
+          if (key === "pattern" || hasOwn(normalizedRule, key)) return;
+          removedKeys.push(key);
+        });
+
+        if (Object.keys(patch).length > 1) {
+          exportRules.push(patch);
         }
-
-        var defaultRuleDiff = deepDiff(normalizedRule, normalizedDefaultRule);
-        if (defaultRuleDiff && Object.keys(defaultRuleDiff).length > 0) {
-          defaultRuleDiff.pattern = pattern;
-          exportRules.push(defaultRuleDiff);
+        if (removedKeys.length > 0) {
+          removedDefaultRuleKeys.push({
+            pattern: pattern,
+            keys: removedKeys.sort()
+          });
         }
         return;
       }
 
+      // A custom pattern-only rule is meaningful: it can whitelist a site while
+      // global Speeder is disabled. Never discard it as an "empty" rule.
       exportRules.push(normalizedRule);
     });
 
@@ -407,7 +470,7 @@
         return rule && typeof rule.pattern === "string" ? rule.pattern : "";
       })
       .filter(function (pattern) {
-        return pattern && !currentPatterns.has(pattern);
+        return pattern && !claimedDefaultPatterns.has(pattern);
       });
 
     var result = {};
@@ -415,17 +478,48 @@
       result.siteRules = exportRules;
       result.siteRulesFormat = SITE_RULES_DIFF_FORMAT;
     }
-    if (removedDefaultPatterns.length > 0) {
-      result.siteRulesMeta = {
-        removedDefaultPatterns: removedDefaultPatterns
-      };
+    if (
+      removedDefaultPatterns.length > 0 ||
+      removedDefaultRuleKeys.length > 0
+    ) {
+      result.siteRulesMeta = {};
+      if (removedDefaultPatterns.length > 0) {
+        result.siteRulesMeta.removedDefaultPatterns = removedDefaultPatterns;
+      }
+      if (removedDefaultRuleKeys.length > 0) {
+        result.siteRulesMeta[REMOVED_DEFAULT_RULE_KEYS_META] =
+          removedDefaultRuleKeys;
+      }
       result.siteRulesFormat = SITE_RULES_DIFF_FORMAT;
     }
 
     return result;
   }
 
-  function expandSiteRules(siteRules, siteRulesMeta) {
+  function getRemovedDefaultRuleKeysByPattern(siteRulesMeta) {
+    var byPattern = Object.create(null);
+    var entries =
+      siteRulesMeta &&
+      Array.isArray(siteRulesMeta[REMOVED_DEFAULT_RULE_KEYS_META])
+        ? siteRulesMeta[REMOVED_DEFAULT_RULE_KEYS_META]
+        : [];
+
+    entries.forEach(function (entry) {
+      if (
+        !entry ||
+        typeof entry.pattern !== "string" ||
+        !Array.isArray(entry.keys)
+      ) {
+        return;
+      }
+      byPattern[entry.pattern] = entry.keys.filter(function (key) {
+        return typeof key === "string" && key !== "pattern";
+      });
+    });
+    return byPattern;
+  }
+
+  function expandSiteRules(siteRules, siteRulesMeta, supportsRemovedKeys) {
     var defaultRules = getDefaultSiteRules();
     var defaultRulesByPattern = getDefaultSiteRulesByPattern();
     if (defaultRules.length === 0) {
@@ -437,7 +531,11 @@
         ? siteRulesMeta.removedDefaultPatterns
         : []
     );
+    var removedKeysByPattern = supportsRemovedKeys
+      ? getRemovedDefaultRuleKeysByPattern(siteRulesMeta)
+      : Object.create(null);
     var modifiedDefaultRules = Object.create(null);
+    var claimedDefaultPatterns = new Set();
     var customRules = [];
 
     if (Array.isArray(siteRules)) {
@@ -449,13 +547,16 @@
         var pattern = typeof rule.pattern === "string" ? rule.pattern.trim() : "";
         if (
           pattern &&
-          Object.prototype.hasOwnProperty.call(defaultRulesByPattern, pattern)
+          Object.prototype.hasOwnProperty.call(defaultRulesByPattern, pattern) &&
+          !claimedDefaultPatterns.has(pattern)
         ) {
-          modifiedDefaultRules[pattern] = clonePlainData(rule);
+          claimedDefaultPatterns.add(pattern);
+          modifiedDefaultRules[pattern] = normalizeSiteRule(rule);
           return;
         }
 
-        customRules.push(clonePlainData(rule));
+        var customRule = normalizeSiteRule(rule);
+        if (customRule) customRules.push(customRule);
       });
     }
 
@@ -468,17 +569,23 @@
       }
 
       if (modifiedDefaultRules[pattern]) {
-        mergedRules.push(
-          Object.assign(
-            {},
-            clonePlainData(rule),
-            clonePlainData(modifiedDefaultRules[pattern])
-          )
+        var mergedRule = Object.assign(
+          {},
+          clonePlainData(rule),
+          clonePlainData(modifiedDefaultRules[pattern])
         );
+        (removedKeysByPattern[pattern] || []).forEach(function (key) {
+          delete mergedRule[key];
+        });
+        mergedRules.push(mergedRule);
         return;
       }
 
-      mergedRules.push(clonePlainData(rule));
+      var unmodifiedRule = clonePlainData(rule);
+      (removedKeysByPattern[pattern] || []).forEach(function (key) {
+        delete unmodifiedRule[key];
+      });
+      mergedRules.push(unmodifiedRule);
     });
 
     customRules.forEach(function (rule) {
@@ -488,6 +595,49 @@
     return mergedRules;
   }
 
+  function migrateLegacyFullSiteRules(siteRules) {
+    var rules = clonePlainData(siteRules) || [];
+    var defaults = getDefaultSiteRules();
+    var mobileShortsDefault = defaults[2];
+    if (!mobileShortsDefault || !mobileShortsDefault.pattern) return rules;
+
+    // Full-rule backups from versions before rule titles should receive the
+    // labels now attached to the built-ins. New saves use the sparse format,
+    // where an intentionally removed title is represented by a tombstone.
+    defaults.forEach(function(defaultRule) {
+      var matchingRule = rules.find(function(rule) {
+        return rule && rule.pattern === defaultRule.pattern;
+      });
+      if (
+        matchingRule &&
+        !hasOwn(matchingRule, "title") &&
+        typeof defaultRule.title === "string"
+      ) {
+        matchingRule.title = defaultRule.title;
+      }
+    });
+
+    var alreadyHasMobileRule = rules.some(function(rule) {
+      return rule && rule.pattern === mobileShortsDefault.pattern;
+    });
+    if (alreadyHasMobileRule) return rules;
+
+    // Older Options versions persisted the entire then-default list without a
+    // format marker and sometimes filled in extra false/default-valued fields.
+    // Presence of both known old default patterns is therefore the reliable
+    // signal; the mobile rule did not exist yet, so it could not have been
+    // intentionally removed from one of those legacy lists.
+    var hasOldDefaultPatterns = defaults.slice(0, 2).every(function(defaultRule) {
+      return rules.some(function(rule) {
+        return rule && rule.pattern === defaultRule.pattern;
+      });
+    });
+    if (hasOldDefaultPatterns) {
+      rules.push(clonePlainData(mobileShortsDefault));
+    }
+    return rules;
+  }
+
   function buildStoredSettingsDiff(currentSettings) {
     var defaults = clonePlainData(DEFAULT_SETTINGS);
     var normalized = deepMergeDefaults(defaults, currentSettings || {});
@@ -526,25 +676,291 @@
     return diff;
   }
 
+  function legacyKeyCodeToCode(keyCode) {
+    var numericCode = Number(keyCode);
+    if (!Number.isInteger(numericCode)) return null;
+    if (numericCode >= 48 && numericCode <= 57) {
+      return "Digit" + String.fromCharCode(numericCode);
+    }
+    if (numericCode >= 65 && numericCode <= 90) {
+      return "Key" + String.fromCharCode(numericCode);
+    }
+    if (numericCode >= 96 && numericCode <= 105) {
+      return "Numpad" + (numericCode - 96);
+    }
+    if (numericCode >= 112 && numericCode <= 123) {
+      return "F" + (numericCode - 111);
+    }
+
+    var keyCodeMap = {
+      32: "Space",
+      37: "ArrowLeft",
+      38: "ArrowUp",
+      39: "ArrowRight",
+      40: "ArrowDown",
+      59: "Semicolon",
+      61: "Equal",
+      106: "NumpadMultiply",
+      107: "NumpadAdd",
+      109: "NumpadSubtract",
+      110: "NumpadDecimal",
+      111: "NumpadDivide",
+      173: "Minus",
+      186: "Semicolon",
+      187: "Equal",
+      188: "Comma",
+      189: "Minus",
+      190: "Period",
+      191: "Slash",
+      192: "Backquote",
+      219: "BracketLeft",
+      220: "Backslash",
+      221: "BracketRight",
+      222: "Quote"
+    };
+    return keyCodeMap[numericCode] || null;
+  }
+
+  function finiteNumberOr(value, fallback) {
+    var numericValue = Number(value);
+    return Number.isFinite(numericValue) ? numericValue : fallback;
+  }
+
+  function sanitizeStoredBindingValues(bindings) {
+    var defaultValues = Object.create(null);
+    DEFAULT_SETTINGS.keyBindings.forEach(function(binding) {
+      defaultValues[binding.action] = Number(binding.value) || 0;
+    });
+    defaultValues.louder = 0.1;
+    defaultValues.softer = 0.1;
+
+    return (Array.isArray(bindings) ? bindings : [])
+      .filter(function(binding) {
+        return (
+          isPlainObject(binding) &&
+          typeof binding.action === "string" &&
+          binding.action.length > 0
+        );
+      })
+      .map(function(binding) {
+      var normalized = clonePlainData(binding) || {};
+      var action = normalized.action;
+      var value = Number(normalized.value);
+      var invalid = !Number.isFinite(value);
+      if (action === "slower" || action === "faster") {
+        invalid = invalid || value <= 0 || value > 16;
+      } else if (action === "fast") {
+        invalid = invalid || value < 0.0625 || value > 16;
+      } else if (action === "rewind" || action === "advance") {
+        invalid = invalid || value < 0;
+      } else if (action === "louder" || action === "softer") {
+        invalid = invalid || value <= 0 || value > 1;
+      }
+      normalized.value = invalid
+        ? (hasOwn(defaultValues, action) ? defaultValues[action] : 0)
+        : value;
+      normalized.disabled = coerceBoolean(normalized.disabled, false);
+      normalized.force = coerceBoolean(normalized.force, false);
+      return normalized;
+      });
+  }
+
+  function hasLegacyShortcutSettings(raw) {
+    return [
+      "speedStep",
+      "fastSpeed",
+      "rewindTime",
+      "advanceTime",
+      "resetKeyCode",
+      "slowerKeyCode",
+      "fasterKeyCode",
+      "rewindKeyCode",
+      "advanceKeyCode",
+      "fastKeyCode",
+      "displayKeyCode"
+    ].some(function (key) {
+      return hasOwn(raw, key);
+    });
+  }
+
+  function migrateLegacyKeyBindings(raw) {
+    var bindings = clonePlainData(DEFAULT_SETTINGS.keyBindings);
+    var byAction = Object.create(null);
+    bindings.forEach(function (binding) {
+      byAction[binding.action] = binding;
+    });
+
+    var speedStep = finiteNumberOr(raw.speedStep, byAction.faster.value);
+    if (speedStep > 0) {
+      byAction.slower.value = speedStep;
+      byAction.faster.value = speedStep;
+    }
+    var rewindTime = finiteNumberOr(raw.rewindTime, byAction.rewind.value);
+    if (rewindTime >= 0) byAction.rewind.value = rewindTime;
+    var advanceTime = finiteNumberOr(raw.advanceTime, byAction.advance.value);
+    if (advanceTime >= 0) byAction.advance.value = advanceTime;
+    var fastSpeed = finiteNumberOr(raw.fastSpeed, byAction.fast.value);
+    if (fastSpeed > 0) byAction.fast.value = fastSpeed;
+
+    [
+      ["display", "displayKeyCode"],
+      ["reset", "resetKeyCode"],
+      ["slower", "slowerKeyCode"],
+      ["faster", "fasterKeyCode"],
+      ["rewind", "rewindKeyCode"],
+      ["advance", "advanceKeyCode"],
+      ["fast", "fastKeyCode"]
+    ].forEach(function (mapping) {
+      if (!hasOwn(raw, mapping[1])) return;
+      var code = legacyKeyCodeToCode(raw[mapping[1]]);
+      if (code) byAction[mapping[0]].code = code;
+    });
+
+    return bindings;
+  }
+
+  function migrateLegacyBlacklist(raw) {
+    if (typeof raw.blacklist !== "string") return [];
+    return raw.blacklist
+      .split("\n")
+      .map(function (line) {
+        return line.trim();
+      })
+      .filter(Boolean)
+      .map(function (pattern) {
+        return { pattern: pattern, enabled: false };
+      });
+  }
+
+  function buildManagedStorageMutation(currentStorage, currentSettings) {
+    var raw = isPlainObject(currentStorage) ? currentStorage : {};
+    var nextSettings = buildStoredSettingsDiff(currentSettings);
+    var removeKeys = [];
+
+    MANAGED_SYNC_KEYS.forEach(function (key) {
+      if (!hasOwn(nextSettings, key) && hasOwn(raw, key)) {
+        removeKeys.push(key);
+      }
+    });
+
+    return {
+      set: nextSettings,
+      remove: Array.from(new Set(removeKeys))
+    };
+  }
+
   function expandStoredSettings(storage) {
-    var raw = clonePlainData(storage) || {};
+    var raw = isPlainObject(storage) ? clonePlainData(storage) : {};
     var expanded = deepMergeDefaults(DEFAULT_SETTINGS, raw);
 
     if (
       !hasOwn(raw, "hideWithControls") &&
       hasOwn(raw, "hideWithYouTubeControls")
     ) {
-      expanded.hideWithControls = Boolean(raw.hideWithYouTubeControls);
+      expanded.hideWithControls = coerceBoolean(
+        raw.hideWithYouTubeControls,
+        DEFAULT_SETTINGS.hideWithControls
+      );
     }
+
+    [
+      "rememberSpeed",
+      "forceLastSavedSpeed",
+      "audioBoolean",
+      "enabled",
+      "startHidden",
+      "hideWithControls",
+      "showPopupControlBar",
+      "popupMatchHoverControls",
+      "enableSubtitleNudge",
+      "subtitleNudgeEnabledByDefault"
+    ].forEach(function(key) {
+      expanded[key] = coerceBoolean(expanded[key], DEFAULT_SETTINGS[key]);
+    });
     expanded.hideWithYouTubeControls = expanded.hideWithControls;
+    expanded.shortcutTargetMode =
+      expanded.shortcutTargetMode === "all" ? "all" : "closest";
+
+    expanded.lastSpeed = clampFiniteNumber(
+      expanded.lastSpeed,
+      0.0625,
+      16,
+      DEFAULT_SETTINGS.lastSpeed
+    );
+    expanded.hideWithControlsTimer = clampFiniteNumber(
+      expanded.hideWithControlsTimer,
+      0.1,
+      15,
+      DEFAULT_SETTINGS.hideWithControlsTimer
+    );
+    expanded.controllerOpacity = clampFiniteNumber(
+      expanded.controllerOpacity,
+      0,
+      1,
+      DEFAULT_SETTINGS.controllerOpacity
+    );
+    [
+      "controllerMarginTop",
+      "controllerMarginRight",
+      "controllerMarginBottom",
+      "controllerMarginLeft"
+    ].forEach(function(key) {
+      expanded[key] = clampFiniteNumber(
+        expanded[key],
+        0,
+        200,
+        DEFAULT_SETTINGS[key]
+      );
+    });
+    expanded.subtitleNudgeInterval = clampFiniteNumber(
+      expanded.subtitleNudgeInterval,
+      10,
+      1000,
+      DEFAULT_SETTINGS.subtitleNudgeInterval
+    );
+    expanded.subtitleNudgeAmount = clampFiniteNumber(
+      expanded.subtitleNudgeAmount,
+      0.000001,
+      0.1,
+      DEFAULT_SETTINGS.subtitleNudgeAmount
+    );
+
+    if (Array.isArray(raw.keyBindings) && raw.keyBindings.length > 0) {
+      expanded.keyBindings = clonePlainData(raw.keyBindings);
+    } else if (hasLegacyShortcutSettings(raw)) {
+      expanded.keyBindings = migrateLegacyKeyBindings(raw);
+    } else {
+      expanded.keyBindings = clonePlainData(DEFAULT_SETTINGS.keyBindings);
+    }
+    expanded.keyBindings = sanitizeStoredBindingValues(expanded.keyBindings);
+    if (expanded.keyBindings.length === 0) {
+      expanded.keyBindings = clonePlainData(DEFAULT_SETTINGS.keyBindings);
+    }
 
     if (raw.siteRulesFormat === SITE_RULES_DIFF_FORMAT) {
-      expanded.siteRules = expandSiteRules(raw.siteRules, raw.siteRulesMeta);
-    } else if (Array.isArray(raw.siteRules)) {
-      expanded.siteRules = clonePlainData(raw.siteRules);
+      expanded.siteRules = expandSiteRules(
+        raw.siteRules,
+        raw.siteRulesMeta,
+        true
+      );
+    } else if (raw.siteRulesFormat === LEGACY_SITE_RULES_DIFF_FORMAT) {
+      expanded.siteRules = expandSiteRules(
+        raw.siteRules,
+        raw.siteRulesMeta,
+        false
+      );
+    } else if (hasOwn(raw, "siteRules") && Array.isArray(raw.siteRules)) {
+      expanded.siteRules = migrateLegacyFullSiteRules(raw.siteRules);
+    } else if (hasOwn(raw, "blacklist")) {
+      expanded.siteRules = getDefaultSiteRules().concat(
+        migrateLegacyBlacklist(raw)
+      );
     } else {
       expanded.siteRules = getDefaultSiteRules();
     }
+    expanded.siteRules = expanded.siteRules
+      .map(normalizeSiteRule)
+      .filter(Boolean);
 
     return expanded;
   }
@@ -631,6 +1047,7 @@
   global.vscAreComparableValuesEqual = areComparableValuesEqual;
   global.vscDeepMergeDefaults = deepMergeDefaults;
   global.vscBuildStoredSettingsDiff = buildStoredSettingsDiff;
+  global.vscBuildManagedStorageMutation = buildManagedStorageMutation;
   global.vscExpandStoredSettings = expandStoredSettings;
   global.vscGetSettingsDefaults = function () {
     return clonePlainData(DEFAULT_SETTINGS);
@@ -641,7 +1058,25 @@
   global.vscGetSiteRulesDiffFormat = function () {
     return SITE_RULES_DIFF_FORMAT;
   };
-  global.vscMatchSiteRule = mergeMatchingSiteRules;
-  global.vscSiteRuleMatchesUrl = siteRuleMatchesUrl;
-  global.vscIsSiteRuleDisabled = isSiteRuleDisabled;
+  global.vscGetLegacySiteRulesDiffFormat = function () {
+    return LEGACY_SITE_RULES_DIFF_FORMAT;
+  };
+  global.vscMatchSiteRule = function (url, rules) {
+    var shared = global.SpeederShared && global.SpeederShared.siteRules;
+    return shared && typeof shared.matchSiteRule === "function"
+      ? shared.matchSiteRule(url, rules)
+      : mergeMatchingSiteRules(url, rules);
+  };
+  global.vscSiteRuleMatchesUrl = function (rule, url) {
+    var shared = global.SpeederShared && global.SpeederShared.siteRules;
+    return shared && typeof shared.siteRuleMatchesUrl === "function"
+      ? shared.siteRuleMatchesUrl(rule, url)
+      : siteRuleMatchesUrl(rule, url);
+  };
+  global.vscIsSiteRuleDisabled = function (rule) {
+    var shared = global.SpeederShared && global.SpeederShared.siteRules;
+    return shared && typeof shared.isSiteRuleDisabled === "function"
+      ? shared.isSiteRuleDisabled(rule)
+      : isSiteRuleDisabled(rule);
+  };
 })(typeof globalThis !== "undefined" ? globalThis : this);
diff --git a/extension/shared/site-rules.js b/extension/shared/site-rules.js
index 72e17cc..6aba9a6 100644
--- a/extension/shared/site-rules.js
+++ b/extension/shared/site-rules.js
@@ -14,6 +14,183 @@
     return String(str).replace(/[|\\{}()[\]^$+*?.]/g, "\\$&");
   }
 
+  // Decode valid percent-encoded runs without letting one malformed escape make
+  // the entire URL unusable. This also preserves incomplete UTF-8 bytes instead
+  // of replacing them with lossy placeholder characters.
+  function safelyDecodeUrlText(value) {
+    return String(value).replace(/(?:%[\da-f]{2})+/gi, function(encodedRun) {
+      var decoded = "";
+      var tripletCount = encodedRun.length / 3;
+      var tripletIndex = 0;
+
+      while (tripletIndex < tripletCount) {
+        var tripletOffset = tripletIndex * 3;
+        var firstByte = parseInt(
+          encodedRun.substring(tripletOffset + 1, tripletOffset + 3),
+          16
+        );
+        var sequenceLength = firstByte <= 0x7f
+          ? 1
+          : firstByte >= 0xc2 && firstByte <= 0xdf
+            ? 2
+            : firstByte >= 0xe0 && firstByte <= 0xef
+              ? 3
+              : firstByte >= 0xf0 && firstByte <= 0xf4
+                ? 4
+                : 0;
+        var encodedSequence = sequenceLength
+          ? encodedRun.substring(
+            tripletOffset,
+            tripletOffset + sequenceLength * 3
+          )
+          : "";
+
+        if (
+          sequenceLength &&
+          tripletIndex + sequenceLength <= tripletCount
+        ) {
+          try {
+            decoded += decodeURIComponent(encodedSequence);
+            tripletIndex += sequenceLength;
+            continue;
+          } catch (_error) {
+            // Preserve this byte below, then retry at the next triplet so a
+            // later valid character in the same run can still be decoded.
+          }
+        }
+
+        decoded += encodedRun.substring(tripletOffset, tripletOffset + 3);
+        tripletIndex += 1;
+      }
+
+      return decoded;
+    });
+  }
+
+  function decodedUrlMatchCandidate(url) {
+    var parsedUrl;
+    try {
+      parsedUrl = new URL(String(url));
+    } catch (_error) {
+      return null;
+    }
+
+    var authority = "";
+    if (parsedUrl.host || parsedUrl.protocol === "file:") {
+      authority = "//";
+      if (parsedUrl.username) {
+        authority += parsedUrl.username;
+        if (parsedUrl.password) authority += ":" + parsedUrl.password;
+        authority += "@";
+      }
+      authority += parsedUrl.host;
+    }
+
+    return (
+      parsedUrl.protocol +
+      authority +
+      safelyDecodeUrlText(parsedUrl.pathname || "") +
+      (parsedUrl.search
+        ? "?" + safelyDecodeUrlText(parsedUrl.search.substring(1))
+        : "") +
+      (parsedUrl.hash
+        ? "#" + safelyDecodeUrlText(parsedUrl.hash.substring(1))
+        : "")
+    );
+  }
+
+  function parsePlainSitePattern(pattern) {
+    var normalized = String(pattern).replace(regStrip, "");
+    if (!normalized) return null;
+
+    var hasScheme = /^[a-z][a-z\d+.-]*:\/\//i.test(normalized);
+    var wildcardSubdomains = false;
+    var parsed;
+
+    try {
+      if (hasScheme) {
+        parsed = new URL(normalized);
+      } else {
+        var slashIndex = normalized.indexOf("/");
+        var authority = slashIndex === -1
+          ? normalized
+          : normalized.substring(0, slashIndex);
+        var path = slashIndex === -1 ? "" : normalized.substring(slashIndex);
+        if (authority.indexOf("@") !== -1 || /[?#]/.test(authority)) return null;
+        if (authority.indexOf("*.") === 0) {
+          wildcardSubdomains = true;
+          authority = authority.substring(2);
+        }
+        parsed = new URL("http://" + authority + path);
+      }
+    } catch (_error) {
+      return null;
+    }
+
+    var hostname = String(parsed.hostname || "").toLowerCase().replace(/\.$/, "");
+    if (!hostname && parsed.protocol !== "file:") return null;
+
+    var pathPrefix = parsed.pathname || "";
+    if (!hasScheme && pathPrefix === "/") pathPrefix = "";
+    if (parsed.search) pathPrefix += parsed.search;
+    if (parsed.hash) pathPrefix += parsed.hash;
+
+    return {
+      protocol: hasScheme ? parsed.protocol : null,
+      hostname: hostname,
+      port: parsed.port || "",
+      pathPrefix: pathPrefix,
+      wildcardSubdomains: wildcardSubdomains
+    };
+  }
+
+  function plainSitePatternMatchesUrl(pattern, url) {
+    var parsedPattern = parsePlainSitePattern(pattern);
+    if (!parsedPattern) return false;
+
+    var parsedUrl;
+    try {
+      parsedUrl = new URL(String(url));
+    } catch (_error) {
+      return false;
+    }
+
+    if (parsedPattern.protocol && parsedPattern.protocol !== parsedUrl.protocol) {
+      return false;
+    }
+    if (parsedPattern.port && parsedPattern.port !== parsedUrl.port) {
+      return false;
+    }
+
+    var currentHost = String(parsedUrl.hostname || "").toLowerCase().replace(/\.$/, "");
+    var hostMatches =
+      currentHost === parsedPattern.hostname ||
+      currentHost.endsWith("." + parsedPattern.hostname);
+    if (!hostMatches) return false;
+    if (
+      parsedPattern.wildcardSubdomains &&
+      currentHost === parsedPattern.hostname
+    ) {
+      return false;
+    }
+
+    if (parsedPattern.pathPrefix) {
+      var currentPath =
+        (parsedUrl.pathname || "/") +
+        (parsedUrl.search || "") +
+        (parsedUrl.hash || "");
+      var decodedPatternPath = safelyDecodeUrlText(parsedPattern.pathPrefix);
+      if (
+        !currentPath.startsWith(parsedPattern.pathPrefix) &&
+        !safelyDecodeUrlText(currentPath).startsWith(decodedPatternPath)
+      ) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
   function compileSiteRulePattern(pattern) {
     if (typeof pattern !== "string") return null;
 
@@ -25,38 +202,85 @@
       normalizedPattern.lastIndexOf("/") > 0
     ) {
       var lastSlash = normalizedPattern.lastIndexOf("/");
-      return new RegExp(
+      var regularExpression = new RegExp(
         normalizedPattern.substring(1, lastSlash),
         normalizedPattern.substring(lastSlash + 1)
       );
+      return {
+        test: function(url) {
+          var rawUrl = String(url);
+          var decodedUrl = decodedUrlMatchCandidate(rawUrl);
+          var candidates = decodedUrl && decodedUrl !== rawUrl
+            ? [rawUrl, decodedUrl]
+            : [rawUrl];
+
+          for (var i = 0; i < candidates.length; i++) {
+            // Global and sticky expressions retain state between test() calls.
+            // Site matching must be deterministic across navigation checks.
+            regularExpression.lastIndex = 0;
+            if (regularExpression.test(candidates[i])) {
+              regularExpression.lastIndex = 0;
+              return true;
+            }
+          }
+          regularExpression.lastIndex = 0;
+          return false;
+        }
+      };
     }
 
-    return new RegExp(escapeStringRegExp(normalizedPattern));
+    return {
+      test: function(url) {
+        return plainSitePatternMatchesUrl(normalizedPattern, url);
+      }
+    };
+  }
+
+  function siteRuleMatchesUrl(rule, url) {
+    if (!rule || !rule.pattern || !url) return false;
+    try {
+      var matcher = compileSiteRulePattern(rule.pattern);
+      return Boolean(matcher && matcher.test(url));
+    } catch (_error) {
+      return false;
+    }
+  }
+
+  function cloneRuleValue(value) {
+    if (!value || typeof value !== "object") return value;
+    return JSON.parse(JSON.stringify(value));
   }
 
   function matchSiteRule(url, siteRules) {
     if (!url || !Array.isArray(siteRules)) return null;
 
+    var matches = [];
     for (var i = 0; i < siteRules.length; i++) {
       var rule = siteRules[i];
-      if (!rule || !rule.pattern) continue;
-
-      try {
-        var re = compileSiteRulePattern(rule.pattern);
-        if (re && re.test(url)) {
-          return rule;
-        }
-      } catch (e) {
-      }
+      if (siteRuleMatchesUrl(rule, url)) matches.push(rule);
     }
 
-    return null;
+    if (matches.length === 0) return null;
+    if (matches.length === 1) return matches[0];
+
+    var mergedRule = {};
+    matches.forEach(function(rule) {
+      Object.keys(rule).forEach(function(key) {
+        if (rule[key] !== undefined) {
+          mergedRule[key] = cloneRuleValue(rule[key]);
+        }
+      });
+    });
+    return mergedRule;
   }
 
   function isSiteRuleDisabled(rule) {
     return Boolean(
       rule &&
-      (rule.enabled === false || rule.disableExtension === true)
+      (
+        rule.enabled === false ||
+        (typeof rule.enabled === "undefined" && rule.disableExtension === true)
+      )
     );
   }
 
@@ -82,6 +306,9 @@
     escapeStringRegExp: escapeStringRegExp,
     isSiteRuleDisabled: isSiteRuleDisabled,
     isSpeederActiveForSite: isSpeederActiveForSite,
-    matchSiteRule: matchSiteRule
+    matchSiteRule: matchSiteRule,
+    plainSitePatternMatchesUrl: plainSitePatternMatchesUrl,
+    safelyDecodeUrlText: safelyDecodeUrlText,
+    siteRuleMatchesUrl: siteRuleMatchesUrl
   };
 });
diff --git a/tests/helpers/browser.js b/tests/helpers/browser.js
index 7359392..88c43e7 100644
--- a/tests/helpers/browser.js
+++ b/tests/helpers/browser.js
@@ -17,9 +17,9 @@ function readRepoFile(relPath) {
  * Parse HTML into a fresh JSDOM document so tests can reload scripts without
  * top-level `const` redeclaration errors (avoids document.write).
  */
-export function loadHtmlString(html) {
+export function loadHtmlString(html, options = {}) {
   const dom = new JSDOM(html, {
-    url: "https://example.org/",
+    url: options.url || "https://example.org/",
     pretendToBeVisual: true,
     runScripts: "dangerously"
   });
diff --git a/tests/helpers/extension-test-utils.js b/tests/helpers/extension-test-utils.js
index 9bda6ad..0a3181a 100644
--- a/tests/helpers/extension-test-utils.js
+++ b/tests/helpers/extension-test-utils.js
@@ -44,9 +44,10 @@ function applyJSDOMWindow(win) {
   win.close = vi.fn();
 }
 
-function loadHtmlString(html) {
+function loadHtmlString(html, options) {
+  const config = options || {};
   const dom = new JSDOM(html, {
-    url: "https://example.org/",
+    url: config.url || "https://example.org/",
     pretendToBeVisual: true,
     runScripts: "dangerously"
   });
diff --git a/tests/importExport.integration.test.js b/tests/importExport.integration.test.js
index a692cb9..d2fce5b 100644
--- a/tests/importExport.integration.test.js
+++ b/tests/importExport.integration.test.js
@@ -12,6 +12,7 @@ async function setupImportExport(overrides = {}) {
   const restoreSpy = vi.fn();
   globalThis.restore_options = restoreSpy;
   window.restore_options = restoreSpy;
+  loadScript("extension/shared/settings-core.js");
   loadScript("extension/shared/import-export.js");
   loadScript("extension/options/import-export.js");
   await flushAsyncWork();
@@ -19,11 +20,31 @@ async function setupImportExport(overrides = {}) {
 }
 
 describe("import/export flows", () => {
+  it("keeps editable rule titles in normalized exports", async () => {
+    await setupImportExport();
+    const settings = globalThis.vscGetSettingsDefaults();
+    settings.siteRules[1].title = "My Shorts rule";
+    settings.siteRules[1].shortcutTargetMode = "all";
+
+    const exported = globalThis.normalizedSettingsForExport(
+      globalThis.vscBuildStoredSettingsDiff(settings)
+    );
+    const restored = globalThis.vscExpandStoredSettings(exported);
+
+    expect(restored.siteRules[1].title).toBe("My Shorts rule");
+    expect(restored.siteRules[1].shortcutTargetMode).toBe("all");
+    expect(exported.siteRules.map((rule) => rule.title)).toEqual([
+      "YouTube videos",
+      "My Shorts rule",
+      "YouTube Shorts (mobile)"
+    ]);
+  });
+
   it("exports sync and local settings as a JSON download", async () => {
     vi.useFakeTimers();
     vi.setSystemTime(new Date(2026, 3, 4, 8, 9, 10));
     const chrome = await setupImportExport({
-      sync: { rememberSpeed: true },
+      sync: { rememberSpeed: true, shortcutTargetMode: "all" },
       local: { customButtonIcons: { faster: { slug: "rocket" } } }
     });
     const OriginalBlob = window.Blob;
@@ -67,7 +88,16 @@ describe("import/export flows", () => {
     expect(JSON.parse(blobText)).toEqual({
       version: "1.1",
       exportDate: "2026-04-04T12:09:10.000Z",
-      settings: { rememberSpeed: true },
+      settings: {
+        rememberSpeed: true,
+        shortcutTargetMode: "all",
+        siteRulesFormat: "defaults-diff-v2",
+        siteRules: [
+          expect.objectContaining({ title: "YouTube videos" }),
+          expect.objectContaining({ title: "YouTube Shorts" }),
+          expect.objectContaining({ title: "YouTube Shorts (mobile)" })
+        ]
+      },
       localSettings: { customButtonIcons: { faster: { slug: "rocket" } } }
     });
     expect(document.getElementById("status").textContent).toBe(
@@ -172,7 +202,7 @@ describe("import/export flows", () => {
       { customButtonIcons: { faster: { slug: "rocket" } } },
       expect.any(Function)
     );
-    expect(chrome.storage.sync.clear).toHaveBeenCalled();
+    expect(chrome.storage.sync.clear).not.toHaveBeenCalled();
     expect(chrome.storage.sync.set).toHaveBeenCalledWith(
       { rememberSpeed: true },
       expect.any(Function)
@@ -221,7 +251,13 @@ describe("import/export flows", () => {
           {
             __text: JSON.stringify({
               enabled: false,
-              siteRules: [{ pattern: "example.com", enabled: false }]
+              siteRules: [
+                {
+                  title: "Example videos",
+                  pattern: "example.com",
+                  enabled: false
+                }
+              ]
             })
           }
         ]
@@ -230,13 +266,17 @@ describe("import/export flows", () => {
 
     expect(chrome.storage.local.clear).not.toHaveBeenCalled();
     expect(chrome.storage.local.set).not.toHaveBeenCalled();
-    expect(chrome.storage.sync.set).toHaveBeenCalledWith(
-      {
-        enabled: false,
-        siteRules: [{ pattern: "example.com", enabled: false }]
-      },
-      expect.any(Function)
+    const imported = globalThis.vscExpandStoredSettings(
+      chrome.storage.sync.__state
     );
+    expect(imported.enabled).toBe(false);
+    expect(imported.siteRules).toEqual([
+      {
+        title: "Example videos",
+        pattern: "example.com",
+        enabled: false
+      }
+    ]);
   });
 
   it("clears stale local data when a wrapped backup has empty local settings", async () => {
@@ -285,8 +325,15 @@ describe("import/export flows", () => {
       }
     });
 
-    expect(chrome.storage.local.clear).toHaveBeenCalled();
+    expect(chrome.storage.local.clear).not.toHaveBeenCalled();
+    expect(chrome.storage.local.remove).toHaveBeenCalledWith(
+      "customButtonIcons",
+      expect.any(Function)
+    );
     expect(chrome.storage.local.set).not.toHaveBeenCalled();
+    expect(chrome.storage.local.__state.lucideTagsCacheV1).toEqual({
+      stale: true
+    });
     expect(chrome.storage.sync.set).toHaveBeenCalledWith(
       { rememberSpeed: true },
       expect.any(Function)
diff --git a/tests/importExport.spec.js b/tests/importExport.spec.js
index 7cf0dec..283c37f 100644
--- a/tests/importExport.spec.js
+++ b/tests/importExport.spec.js
@@ -51,6 +51,7 @@ function bootImportExport(options) {
   });
   global.URL = window.URL;
 
+  evaluateScript("extension/shared/settings-core.js");
   evaluateScript("extension/shared/import-export.js");
   evaluateScript("extension/options/import-export.js");
   fireDOMContentLoaded();
@@ -191,7 +192,7 @@ describe("options/import-export.js", () => {
       },
       expect.any(Function)
     );
-    expect(chrome.storage.sync.clear).toHaveBeenCalled();
+    expect(chrome.storage.sync.clear).not.toHaveBeenCalled();
     expect(chrome.storage.sync.set).toHaveBeenCalledWith(
       { rememberSpeed: true, enabled: false },
       expect.any(Function)
@@ -237,4 +238,63 @@ describe("options/import-export.js", () => {
       "Failed to parse backup file"
     );
   });
+
+  it("rejects malformed custom icons without changing stored settings", async () => {
+    const { chrome } = bootImportExport({
+      syncData: { rememberSpeed: false },
+      localData: {
+        customButtonIcons: {
+          faster: { slug: "rocket", svg: "<svg></svg>" }
+        }
+      }
+    });
+
+    const realCreateElement = document.createElement.bind(document);
+    const fakeInput = realCreateElement("input");
+    Object.defineProperty(fakeInput, "files", {
+      configurable: true,
+      value: [
+        {
+          __contents: JSON.stringify({
+            settings: { rememberSpeed: true },
+            localSettings: { customButtonIcons: "not-an-icon-map" }
+          })
+        }
+      ]
+    });
+    fakeInput.click = vi.fn(() => {
+      fakeInput.onchange({ target: fakeInput });
+    });
+
+    vi.spyOn(document, "createElement").mockImplementation((tagName) => {
+      if (String(tagName).toLowerCase() === "input") return fakeInput;
+      return realCreateElement(tagName);
+    });
+
+    class FakeFileReader {
+      readAsText(file) {
+        this.onload({ target: { result: file.__contents } });
+      }
+    }
+
+    vi.stubGlobal("FileReader", FakeFileReader);
+    window.FileReader = FakeFileReader;
+    chrome.storage.sync.set.mockClear();
+    chrome.storage.local.set.mockClear();
+    chrome.storage.local.remove.mockClear();
+
+    document.querySelector("#importSettings").click();
+    await flushAsyncWork();
+
+    expect(document.querySelector("#status").textContent).toContain(
+      "Invalid backup file format"
+    );
+    expect(chrome.storage.sync.set).not.toHaveBeenCalled();
+    expect(chrome.storage.local.set).not.toHaveBeenCalled();
+    expect(chrome.storage.local.remove).not.toHaveBeenCalled();
+    expect(chrome.storage.sync._dump().rememberSpeed).toBe(false);
+    expect(chrome.storage.local._dump().customButtonIcons).toEqual({
+      faster: { slug: "rocket", svg: "<svg></svg>" }
+    });
+  });
 });
diff --git a/tests/inject-lifecycle.regression.test.js b/tests/inject-lifecycle.regression.test.js
new file mode 100644
index 0000000..e58c583
--- /dev/null
+++ b/tests/inject-lifecycle.regression.test.js
@@ -0,0 +1,851 @@
+const {
+  createChromeMock,
+  evaluateScript,
+  flushAsyncWork,
+  loadHtmlString
+} = require("./helpers/extension-test-utils");
+
+function bootInject(options) {
+  const config = options || {};
+
+  loadHtmlString("<!doctype html><html><body></body></html>", {
+    url: config.url || "https://example.org/"
+  });
+  window.history.replaceState({}, "", config.path || "/");
+
+  const chrome = createChromeMock({
+    syncData: config.syncData,
+    localData: config.localData
+  });
+
+  if (config.syncGetDelayMs) {
+    chrome.storage.sync.get.mockImplementation((keys, callback) => {
+      setTimeout(() => {
+        callback(chrome.storage.sync._dump());
+      }, config.syncGetDelayMs);
+    });
+  }
+
+  global.chrome = chrome;
+  window.chrome = chrome;
+
+  // Keep extension timers under Vitest's clock when a test uses fake timers.
+  window.setTimeout = global.setTimeout.bind(global);
+  window.clearTimeout = global.clearTimeout.bind(global);
+  window.requestAnimationFrame = (callback) => setTimeout(callback, 0);
+  window.cancelAnimationFrame = (id) => clearTimeout(id);
+  window.requestIdleCallback = (callback) =>
+    setTimeout(
+      () =>
+        callback({
+          didTimeout: false,
+          timeRemaining() {
+            return 1;
+          }
+        }),
+      0
+    );
+  window.cancelIdleCallback = (id) => clearTimeout(id);
+
+  evaluateScript("extension/shared/controller-utils.js");
+  evaluateScript("extension/shared/key-bindings.js");
+  evaluateScript("extension/shared/settings-core.js");
+  evaluateScript("extension/shared/site-rules.js");
+  evaluateScript("extension/shared/ui-icons.js");
+  evaluateScript("extension/content/inject.js");
+
+  return chrome;
+}
+
+async function settleLifecycle(turns = 4) {
+  await flushAsyncWork(turns);
+  if (vi.isFakeTimers()) {
+    await vi.advanceTimersByTimeAsync(0);
+    await flushAsyncWork(2);
+  }
+}
+
+function makeRect(left, top, width, height) {
+  return {
+    left,
+    top,
+    right: left + width,
+    bottom: top + height,
+    width,
+    height,
+    x: left,
+    y: top,
+    toJSON() {
+      return this;
+    }
+  };
+}
+
+function setRect(element, rect) {
+  element.getBoundingClientRect = () => rect;
+}
+
+function setBoxMetrics(element, width, height) {
+  Object.defineProperties(element, {
+    offsetWidth: { configurable: true, value: width },
+    offsetHeight: { configurable: true, value: height },
+    clientLeft: { configurable: true, value: 0 },
+    clientTop: { configurable: true, value: 0 }
+  });
+}
+
+function createControlledVideo(options) {
+  const config = options || {};
+  const mount = config.mount || document.createElement("div");
+  const video = document.createElement("video");
+  const mountRect = config.mountRect || makeRect(0, 0, 640, 360);
+  const videoRect = config.videoRect || mountRect;
+
+  setRect(mount, mountRect);
+  setBoxMetrics(mount, mountRect.width, mountRect.height);
+  setRect(video, videoRect);
+  video.src = config.src || "https://example.org/video.mp4";
+  mount.appendChild(video);
+  if (!mount.isConnected) document.body.appendChild(mount);
+
+  window.ensureController(video, mount);
+  return { mount, video, controller: video.vsc, wrapper: video.vsc.div };
+}
+
+function hostIsGeometrySuppressed(host) {
+  const width = host.style.getPropertyValue("width");
+  const height = host.style.getPropertyValue("height");
+  return Boolean(
+    host.hidden ||
+      host.getAttribute("aria-hidden") === "true" ||
+      host.classList.contains("vsc-geometry-hidden") ||
+      host.style.display === "none" ||
+      host.style.visibility === "hidden" ||
+      ((width === "0" || width === "0px") &&
+        (height === "0" || height === "0px"))
+  );
+}
+
+describe("inject.js media/controller lifecycle regressions", () => {
+  afterEach(() => {
+    vi.useRealTimers();
+    vi.unstubAllGlobals();
+    delete global.chrome;
+  });
+
+  it("bridges page-world history and shadow creation events", () => {
+    loadHtmlString("<!doctype html><html><body></body></html>");
+    let locationEvents = 0;
+    let shadowEvents = 0;
+    document.addEventListener("speeder-location-changed", () => {
+      locationEvents += 1;
+    });
+    document.addEventListener("speeder-shadow-root-attached", () => {
+      shadowEvents += 1;
+    });
+    evaluateScript("extension/content/shadow-bridge.js");
+
+    window.history.pushState({}, "", "/new-route");
+    const bridgePlayer = document.createElement("bridge-player");
+    document.body.appendChild(bridgePlayer);
+    bridgePlayer.attachShadow({ mode: "open" });
+
+    expect(locationEvents).toBe(1);
+    expect(shadowEvents).toBe(1);
+  });
+
+  it("retries a blocked page bridge and keeps a persistent shadow fallback", async () => {
+    vi.useFakeTimers();
+    bootInject();
+    const firstBridge = document.querySelector(
+      'script[src$="content/shadow-bridge.js"]'
+    );
+    expect(firstBridge).not.toBeNull();
+
+    firstBridge.dispatchEvent(new Event("error"));
+
+    expect(window.vscPageShadowBridgeRequested).toBe(false);
+    expect(window.vscPersistentShadowFallbackTimer).not.toBeNull();
+    await vi.advanceTimersByTimeAsync(250);
+    expect(
+      document.querySelector('script[src$="content/shadow-bridge.js"]')
+    ).not.toBeNull();
+  });
+
+  it("stops at an immediate player stacking boundary", async () => {
+    bootInject();
+    await settleLifecycle();
+
+    const outside = document.createElement("section");
+    const isolatedPlayer = document.createElement("div");
+    const video = document.createElement("video");
+    const rect = makeRect(10, 70, 640, 360);
+
+    isolatedPlayer.style.isolation = "isolate";
+    isolatedPlayer.appendChild(video);
+    outside.appendChild(isolatedPlayer);
+    document.body.appendChild(outside);
+    [outside, isolatedPlayer, video].forEach((element) => setRect(element, rect));
+
+    expect(window.getControllerMount(video)).toBe(isolatedPlayer);
+  });
+
+  it("recovers a controller measured before the player receives layout", async () => {
+    vi.useFakeTimers();
+    bootInject();
+    await settleLifecycle();
+
+    const mount = document.createElement("div");
+    const video = document.createElement("video");
+    let mountRect = makeRect(0, 0, 0, 0);
+    let videoRect = makeRect(0, 0, 0, 0);
+
+    setBoxMetrics(mount, 640, 360);
+    mount.getBoundingClientRect = () => mountRect;
+    video.getBoundingClientRect = () => videoRect;
+    video.src = "https://example.org/late-layout.mp4";
+    mount.appendChild(video);
+    document.body.appendChild(mount);
+
+    window.ensureController(video, mount);
+    expect(video.vsc.div.classList.contains("vsc-geometry-hidden")).toBe(true);
+
+    mountRect = makeRect(20, 80, 640, 360);
+    videoRect = makeRect(20, 80, 640, 360);
+    await vi.advanceTimersByTimeAsync(100);
+
+    expect(video.vsc.div.classList.contains("vsc-geometry-hidden")).toBe(false);
+    expect(video.vsc.div.style.display).not.toBe("none");
+    expect(video.vsc.div.style.getPropertyValue("width")).toBe("640px");
+    expect(video.vsc.div.style.getPropertyValue("height")).toBe("360px");
+  });
+
+  it("keeps YouTube watch, Shorts, and hover controls on the real player boundary", async () => {
+    bootInject({ url: "https://www.youtube.com/" });
+    await settleLifecycle();
+
+    const player = document.createElement("div");
+    player.id = "inline-preview-player";
+    player.className = "html5-video-player";
+    const zeroHeightVideoContainer = document.createElement("div");
+    zeroHeightVideoContainer.className = "html5-video-container";
+    const video = document.createElement("video");
+    const playerRect = makeRect(40, 120, 402, 226);
+
+    setRect(player, playerRect);
+    setBoxMetrics(player, playerRect.width, playerRect.height);
+    setRect(zeroHeightVideoContainer, makeRect(40, 120, 402, 0));
+    setBoxMetrics(zeroHeightVideoContainer, 402, 0);
+    setRect(video, playerRect);
+    video.src = "blob:https://www.youtube.com/hover-preview";
+    zeroHeightVideoContainer.appendChild(video);
+    player.appendChild(zeroHeightVideoContainer);
+    document.body.appendChild(player);
+
+    window.ensureController(video, zeroHeightVideoContainer);
+    window.ensureController(video, zeroHeightVideoContainer);
+
+    expect(video.vsc.div.parentElement).toBe(player);
+    expect(video.vsc.controllerHostMount).toBe(player);
+    expect(video.vsc.div.classList.contains("vsc-geometry-hidden")).toBe(false);
+    expect(video.vsc.div.style.getPropertyValue("width")).toBe("402px");
+    expect(video.vsc.div.style.getPropertyValue("height")).toBe("226px");
+  });
+
+  it("targets the controller nearest the pointer unless change-all is selected", async () => {
+    bootInject();
+    await settleLifecycle();
+
+    const first = createControlledVideo({
+      src: "https://example.org/first.mp4",
+      mountRect: makeRect(0, 0, 320, 180)
+    });
+    const second = createControlledVideo({
+      src: "https://example.org/second.mp4",
+      mountRect: makeRect(500, 0, 320, 180)
+    });
+    setRect(window.getControllerElement(first.controller), makeRect(10, 10, 120, 30));
+    setRect(window.getControllerElement(second.controller), makeRect(510, 10, 120, 30));
+
+    document.dispatchEvent(
+      new MouseEvent("mousemove", { bubbles: true, clientX: 600, clientY: 20 })
+    );
+    window.runAction("faster", 0.1);
+
+    expect(first.video.playbackRate).toBe(1);
+    expect(second.video.playbackRate).toBe(1.1);
+
+    window.tc.settings.shortcutTargetMode = "all";
+    window.runAction("faster", 0.1);
+    expect(first.video.playbackRate).toBe(1.1);
+    expect(second.video.playbackRate).toBe(1.2);
+  });
+
+  it("skips GIF-like ambient loops but accepts them if they become real players", async () => {
+    bootInject();
+    await settleLifecycle();
+
+    const mount = document.createElement("div");
+    const video = document.createElement("video");
+    const rect = makeRect(0, 0, 480, 270);
+    video.autoplay = true;
+    video.defaultMuted = true;
+    video.muted = true;
+    video.loop = true;
+    video.playsInline = true;
+    video.controls = false;
+    video.src = "https://example.org/card-loop.mp4";
+    setRect(mount, rect);
+    setBoxMetrics(mount, rect.width, rect.height);
+    setRect(video, rect);
+    mount.appendChild(video);
+    document.body.appendChild(mount);
+
+    expect(window.ensureController(video, mount)).toBeNull();
+    expect(video.vsc).toBeUndefined();
+
+    video.loop = false;
+    video.controls = true;
+    expect(window.ensureController(video, mount)).toBeTruthy();
+    expect(video.vsc.div.isConnected).toBe(true);
+  });
+
+  it("moves the host into an ancestor fullscreen subtree and restores it", async () => {
+    bootInject();
+    await settleLifecycle();
+
+    const normalMount = document.createElement("div");
+    const fullscreenPlayer = document.createElement("media-player");
+    const provider = document.createElement("media-provider");
+    const video = document.createElement("video");
+    const wrapper = document.createElement("div");
+    const rect = makeRect(0, 0, 640, 360);
+
+    normalMount.style.isolation = "isolate";
+    provider.appendChild(video);
+    fullscreenPlayer.appendChild(provider);
+    normalMount.append(fullscreenPlayer, wrapper);
+    document.body.appendChild(normalMount);
+    [normalMount, fullscreenPlayer, provider, video].forEach((element) => {
+      setRect(element, rect);
+      setBoxMetrics(element, rect.width, rect.height);
+    });
+
+    const controller = {
+      video,
+      div: wrapper,
+      normalControllerMount: normalMount
+    };
+    window.setupControllerHostTracking(controller, wrapper, normalMount);
+    Object.defineProperty(document, "fullscreenElement", {
+      configurable: true,
+      value: fullscreenPlayer
+    });
+
+    window.syncControllerFullscreenMount(controller);
+    expect(fullscreenPlayer.contains(wrapper)).toBe(true);
+
+    Object.defineProperty(document, "fullscreenElement", {
+      configurable: true,
+      value: null
+    });
+    window.syncControllerFullscreenMount(controller);
+    expect(wrapper.parentElement).toBe(normalMount);
+
+    wrapper.remove();
+    controller.controllerHostCleanup();
+  });
+
+  it("preserves direct-video requestFullscreen semantics and overlays with a popover", async () => {
+    bootInject();
+    await settleLifecycle();
+
+    const fullscreenRequests = [];
+    Object.defineProperty(window.Element.prototype, "requestFullscreen", {
+      configurable: true,
+      value: function(options) {
+        fullscreenRequests.push({ target: this, options });
+        Object.defineProperty(document, "fullscreenElement", {
+          configurable: true,
+          value: this
+        });
+        return Promise.resolve();
+      }
+    });
+    evaluateScript("extension/content/shadow-bridge.js");
+
+    const { mount, video, controller, wrapper } = createControlledVideo();
+    wrapper.showPopover = vi.fn();
+    wrapper.hidePopover = vi.fn();
+    await video.requestFullscreen({ navigationUI: "hide" });
+    document.dispatchEvent(new Event("fullscreenchange"));
+
+    window.syncControllerFullscreenMount(controller);
+
+    expect(fullscreenRequests).toEqual([
+      {
+        target: video,
+        options: { navigationUI: "hide" }
+      }
+    ]);
+    expect(document.fullscreenElement).toBe(video);
+    expect(wrapper.showPopover).toHaveBeenCalledOnce();
+    expect(wrapper.parentNode).toBe(mount);
+    expect(video.contains(wrapper)).toBe(false);
+    expect(wrapper.isConnected).toBe(true);
+  });
+
+  it("uses a top-layer popover when native controls fullscreen the video element", async () => {
+    bootInject();
+    await settleLifecycle();
+
+    const { mount, video, controller, wrapper } = createControlledVideo();
+    wrapper.showPopover = vi.fn();
+    wrapper.hidePopover = vi.fn();
+    Object.defineProperty(document, "fullscreenElement", {
+      configurable: true,
+      value: video
+    });
+
+    expect(window.getControllerMount(video, video)).toBe(mount);
+    expect(window.syncControllerFullscreenMount(controller)).toBe(true);
+    expect(wrapper.showPopover).toHaveBeenCalledOnce();
+    expect(wrapper.parentNode).toBe(mount);
+    expect(video.contains(wrapper)).toBe(false);
+    expect(wrapper.getAttribute("popover")).toBe("manual");
+    expect(wrapper.classList.contains("vsc-fullscreen-popover")).toBe(true);
+
+    Object.defineProperty(document, "fullscreenElement", {
+      configurable: true,
+      value: null
+    });
+    window.syncControllerFullscreenMount(controller);
+
+    expect(wrapper.hidePopover).toHaveBeenCalledOnce();
+    expect(wrapper.hasAttribute("popover")).toBe(false);
+    expect(wrapper.classList.contains("vsc-fullscreen-popover")).toBe(false);
+  });
+
+  it("uses the fullscreen boundary for a portrait video beneath a gesture pane", async () => {
+    bootInject();
+    await settleLifecycle();
+
+    const fullscreenPlayer = document.createElement("media-player");
+    const provider = document.createElement("media-provider");
+    const video = document.createElement("video");
+    const gesturePane = document.createElement("div");
+    const playerRect = makeRect(0, 0, 1280, 720);
+    const portraitRect = makeRect(440, 10, 400, 700);
+
+    gesturePane.className = "gesture-pane";
+    provider.appendChild(video);
+    fullscreenPlayer.append(provider, gesturePane);
+    document.body.appendChild(fullscreenPlayer);
+    setRect(fullscreenPlayer, playerRect);
+    setRect(gesturePane, playerRect);
+    setRect(provider, portraitRect);
+    setRect(video, portraitRect);
+
+    expect(window.getControllerMount(video, fullscreenPlayer)).toBe(
+      fullscreenPlayer
+    );
+  });
+
+  it("repairs a controller host removed independently of its video", async () => {
+    bootInject();
+    await settleLifecycle();
+
+    const { mount, video, wrapper } = createControlledVideo();
+    wrapper.remove();
+    expect(video.isConnected).toBe(true);
+
+    window.ensureController(video, mount);
+
+    expect(video.vsc).toBeDefined();
+    expect(video.vsc.div.isConnected).toBe(true);
+    expect(video.vsc.div.parentElement).toBe(mount);
+  });
+
+  it("still creates controls when a custom player throws from playbackRate", async () => {
+    bootInject();
+    await settleLifecycle();
+    const mount = document.createElement("div");
+    const video = document.createElement("video");
+    video.src = "https://example.org/rejecting-player.mp4";
+    Object.defineProperty(video, "playbackRate", {
+      configurable: true,
+      get() {
+        return 1;
+      },
+      set() {
+        throw new Error("rate rejected");
+      }
+    });
+    mount.appendChild(video);
+    document.body.appendChild(mount);
+
+    expect(() => window.ensureController(video, mount)).not.toThrow();
+    expect(video.vsc).toBeDefined();
+    expect(video.vsc.div.isConnected).toBe(true);
+  });
+
+  it("remounts an existing controller when its video moves between players", async () => {
+    bootInject();
+    await settleLifecycle();
+
+    const mountA = document.createElement("div");
+    const mountB = document.createElement("div");
+    const rect = makeRect(0, 0, 640, 360);
+    [mountA, mountB].forEach((mount) => {
+      setRect(mount, rect);
+      setBoxMetrics(mount, rect.width, rect.height);
+      document.body.appendChild(mount);
+    });
+
+    const { video, wrapper } = createControlledVideo({ mount: mountA });
+    mountB.appendChild(video);
+
+    window.ensureController(video, mountB);
+
+    expect(video.vsc.div).toBe(wrapper);
+    expect(wrapper.parentElement).toBe(mountB);
+    expect(video.vsc.controllerHostMount).toBe(mountB);
+    expect(mountA.querySelector(".vsc-controller")).toBeNull();
+  });
+
+  it("suppresses a zero-size host and reveals it when the video becomes visible", async () => {
+    bootInject();
+    await settleLifecycle();
+
+    const mount = document.createElement("div");
+    const mountRect = makeRect(100, 50, 640, 360);
+    let videoRect = makeRect(100, 50, 0, 0);
+    setRect(mount, mountRect);
+    setBoxMetrics(mount, mountRect.width, mountRect.height);
+
+    const video = document.createElement("video");
+    video.src = "https://example.org/preload.mp4";
+    video.getBoundingClientRect = () => videoRect;
+    mount.appendChild(video);
+    document.body.appendChild(mount);
+    window.ensureController(video, mount);
+
+    const wrapper = video.vsc.div;
+    expect(hostIsGeometrySuppressed(wrapper)).toBe(true);
+
+    videoRect = makeRect(140, 80, 320, 180);
+    window.positionControllerHost(wrapper, video, mount);
+
+    expect(hostIsGeometrySuppressed(wrapper)).toBe(false);
+    expect(wrapper.style.getPropertyValue("width")).toBe("320px");
+    expect(wrapper.style.getPropertyValue("height")).toBe("180px");
+  });
+
+  it("chooses visible media over an offscreen player for popup actions", async () => {
+    bootInject();
+    await settleLifecycle();
+
+    const offscreen = createControlledVideo({
+      mountRect: makeRect(0, 2000, 1280, 720),
+      videoRect: makeRect(0, 2000, 1280, 720),
+      src: "https://example.org/offscreen.mp4"
+    }).video;
+    const visible = createControlledVideo({
+      mountRect: makeRect(40, 40, 640, 360),
+      videoRect: makeRect(40, 40, 640, 360),
+      src: "https://example.org/visible.mp4"
+    }).video;
+
+    expect(window.getPrimaryVideoElement()).toBe(visible);
+    expect(window.getPrimaryVideoElement()).not.toBe(offscreen);
+  });
+
+  it("mounts a controller locally for video directly under an open ShadowRoot", async () => {
+    bootInject();
+    await settleLifecycle();
+
+    const host = document.createElement("custom-player");
+    const shadow = host.attachShadow({ mode: "open" });
+    const video = document.createElement("video");
+    const rect = makeRect(20, 30, 640, 360);
+    video.src = "https://example.org/shadow.mp4";
+    setRect(host, rect);
+    setBoxMetrics(host, rect.width, rect.height);
+    setRect(video, rect);
+    shadow.appendChild(video);
+    document.body.appendChild(host);
+
+    window.observeRoot(shadow);
+    window.scanRootForMedia(shadow);
+
+    expect(video.vsc).toBeDefined();
+    expect(video.vsc.div.getRootNode()).toBe(shadow);
+    expect(shadow.contains(video.vsc.div)).toBe(true);
+  });
+
+  it("keeps a shadow player controller in its visible root during host fullscreen", async () => {
+    bootInject();
+    await settleLifecycle();
+
+    const host = document.createElement("fullscreen-shadow-player");
+    const shadow = host.attachShadow({ mode: "open" });
+    const video = document.createElement("video");
+    const rect = makeRect(0, 0, 640, 360);
+    video.src = "https://example.org/shadow-fullscreen.mp4";
+    setRect(host, rect);
+    setBoxMetrics(host, rect.width, rect.height);
+    setRect(video, rect);
+    shadow.appendChild(video);
+    document.body.appendChild(host);
+    window.observeRoot(shadow);
+    window.scanRootForMedia(shadow);
+
+    Object.defineProperty(document, "fullscreenElement", {
+      configurable: true,
+      value: host
+    });
+    window.syncControllerFullscreenMount(video.vsc);
+
+    expect(window.getControllerMount(video, host)).toBe(shadow);
+    expect(video.vsc.div.parentNode).toBe(shadow);
+    expect(host.contains(video.vsc.div)).toBe(false);
+  });
+
+  it("removes controllers when their open-shadow host is detached", async () => {
+    bootInject();
+    await settleLifecycle();
+
+    const host = document.createElement("detached-shadow-player");
+    const shadow = host.attachShadow({ mode: "open" });
+    const video = document.createElement("video");
+    video.src = "https://example.org/detached-shadow.mp4";
+    shadow.appendChild(video);
+    document.body.appendChild(host);
+    window.observeRoot(shadow);
+    window.scanRootForMedia(shadow);
+    const wrapper = video.vsc.div;
+
+    host.remove();
+    await settleLifecycle(6);
+
+    expect(video.vsc).toBeUndefined();
+    expect(window.tc.mediaElements).not.toContain(video);
+    expect(wrapper.isConnected).toBe(false);
+  });
+
+  it("starts and ends a controller drag mounted directly in an open ShadowRoot", async () => {
+    bootInject();
+    await settleLifecycle();
+
+    const host = document.createElement("drag-shadow-player");
+    const shadow = host.attachShadow({ mode: "open" });
+    const video = document.createElement("video");
+    const rect = makeRect(20, 30, 640, 360);
+    video.src = "https://example.org/drag-shadow.mp4";
+    setRect(host, rect);
+    setBoxMetrics(host, rect.width, rect.height);
+    setRect(video, rect);
+    shadow.appendChild(video);
+    document.body.appendChild(host);
+    window.observeRoot(shadow);
+    window.scanRootForMedia(shadow);
+
+    expect(() =>
+      window.handleDrag(video, { clientX: 30, clientY: 40 })
+    ).not.toThrow();
+    expect(video.classList.contains("vcs-dragging")).toBe(true);
+
+    host.dispatchEvent(new MouseEvent("mouseup", { bubbles: true }));
+    expect(video.classList.contains("vcs-dragging")).toBe(false);
+  });
+
+  it("queues early shadow media until async settings hydration completes", async () => {
+    vi.useFakeTimers();
+    bootInject({ syncGetDelayMs: 100 });
+
+    const host = document.createElement("early-player");
+    const shadow = host.attachShadow({ mode: "open" });
+    const video = document.createElement("video");
+    video.src = "https://example.org/early.mp4";
+    shadow.appendChild(video);
+    document.body.appendChild(host);
+    await settleLifecycle();
+
+    expect(video.vsc).toBeUndefined();
+    await vi.advanceTimersByTimeAsync(120);
+    await settleLifecycle();
+
+    expect(video.vsc).toBeDefined();
+    expect(video.vsc.div.isConnected).toBe(true);
+    expect(video.vsc.div.getRootNode()).toBe(shadow);
+  });
+
+  it("reconciles source children and the emptied lifecycle on an existing controller", async () => {
+    bootInject();
+    await settleLifecycle();
+
+    const { video, wrapper } = createControlledVideo();
+    video.preload = "none";
+    video.removeAttribute("src");
+    video.dispatchEvent(new Event("emptied"));
+    await settleLifecycle();
+    expect(wrapper.classList.contains("vsc-nosource")).toBe(true);
+
+    const source = document.createElement("source");
+    source.src = "https://example.org/later.mp4";
+    video.appendChild(source);
+    await settleLifecycle();
+    expect(wrapper.classList.contains("vsc-nosource")).toBe(false);
+
+    source.remove();
+    video.dispatchEvent(new Event("emptied"));
+    await settleLifecycle();
+    expect(wrapper.classList.contains("vsc-nosource")).toBe(true);
+  });
+
+  it("applies the newly matched SPA rule before choosing source-transition speed", async () => {
+    bootInject({
+      path: "/watch/one",
+      syncData: {
+        lastSpeed: 1.8,
+        rememberSpeed: false,
+        siteRules: [
+          {
+            pattern: "example.org/watch/",
+            enabled: true,
+            rememberSpeed: false
+          },
+          {
+            pattern: "example.org/shorts/",
+            enabled: true,
+            rememberSpeed: true
+          }
+        ]
+      },
+      localData: {
+        rememberedSpeeds: {
+          "https://example.org/short-two.mp4": {
+            speed: 1.8,
+            updatedAt: 100
+          }
+        }
+      }
+    });
+    await settleLifecycle();
+
+    const { video } = createControlledVideo({
+      src: "https://example.org/watch-one.mp4"
+    });
+    expect(video.playbackRate).toBe(1);
+
+    window.history.replaceState({}, "", "/shorts/two");
+    video.src = "https://example.org/short-two.mp4";
+    window.applySourceTransitionPolicy(video, true);
+
+    expect(window.tc.activeSiteRule.pattern).toBe("example.org/shorts/");
+    expect(window.tc.settings.rememberSpeed).toBe(true);
+    expect(video.vsc.targetSpeed).toBe(1.8);
+    expect(video.playbackRate).toBe(1.8);
+  });
+
+  it("activates after an initially disabled SPA route becomes enabled", async () => {
+    vi.useFakeTimers();
+    bootInject({
+      path: "/disabled",
+      syncData: {
+        siteRules: [
+          { pattern: "example.org/disabled", enabled: false },
+          { pattern: "example.org/enabled", enabled: true }
+        ]
+      }
+    });
+
+    const video = document.createElement("video");
+    video.src = "https://example.org/enabled.mp4";
+    document.body.appendChild(video);
+    expect(video.vsc).toBeUndefined();
+
+    window.history.pushState({}, "", "/enabled");
+    window.dispatchEvent(new window.PopStateEvent("popstate"));
+    await vi.advanceTimersByTimeAsync(350);
+    await settleLifecycle();
+
+    expect(video.vsc).toBeDefined();
+    expect(video.vsc.div.isConnected).toBe(true);
+  });
+
+  it("rescans an existing open-shadow player when an SPA route becomes enabled", async () => {
+    vi.useFakeTimers();
+    bootInject({
+      path: "/disabled",
+      syncData: {
+        siteRules: [
+          { pattern: "example.org/disabled", enabled: false },
+          { pattern: "example.org/enabled", enabled: true }
+        ]
+      }
+    });
+
+    const host = document.createElement("route-shadow-player");
+    const shadow = host.attachShadow({ mode: "open" });
+    const video = document.createElement("video");
+    video.src = "https://example.org/route-shadow.mp4";
+    shadow.appendChild(video);
+    document.body.appendChild(host);
+    window.observeRoot(shadow);
+    expect(video.vsc).toBeUndefined();
+
+    window.history.pushState({}, "", "/enabled");
+    window.dispatchEvent(new window.PopStateEvent("popstate"));
+    await vi.advanceTimersByTimeAsync(350);
+    await settleLifecycle();
+
+    expect(video.vsc).toBeDefined();
+    expect(video.vsc.div.getRootNode()).toBe(shadow);
+    expect(video.vsc.div.isConnected).toBe(true);
+  });
+
+  it("tears controllers down when an enabled SPA route becomes disabled", async () => {
+    vi.useFakeTimers();
+    bootInject({
+      path: "/enabled",
+      syncData: {
+        siteRules: [
+          { pattern: "example.org/enabled", enabled: true },
+          { pattern: "example.org/disabled", enabled: false }
+        ]
+      }
+    });
+
+    const { video } = createControlledVideo();
+    expect(video.vsc).toBeDefined();
+
+    window.history.pushState({}, "", "/disabled");
+    window.dispatchEvent(new window.PopStateEvent("popstate"));
+    await vi.advanceTimersByTimeAsync(350);
+    await settleLifecycle();
+
+    expect(video.vsc).toBeUndefined();
+    expect(document.querySelector(".vsc-controller")).toBeNull();
+  });
+
+  it("removes existing audio controllers when live settings disable audio", async () => {
+    vi.useFakeTimers();
+    const chrome = bootInject({ syncData: { audioBoolean: true } });
+    await settleLifecycle();
+
+    const mount = document.createElement("div");
+    const audio = document.createElement("audio");
+    audio.src = "https://example.org/podcast.mp3";
+    mount.appendChild(audio);
+    document.body.appendChild(mount);
+    window.ensureController(audio, mount);
+    expect(audio.vsc).toBeDefined();
+
+    chrome.storage.sync.set({ audioBoolean: false });
+    await vi.advanceTimersByTimeAsync(100);
+    await settleLifecycle();
+
+    expect(audio.vsc).toBeUndefined();
+  });
+});
diff --git a/tests/inject.spec.js b/tests/inject.spec.js
index 40926ed..c76a681 100644
--- a/tests/inject.spec.js
+++ b/tests/inject.spec.js
@@ -139,6 +139,15 @@ describe("inject.js helper logic", () => {
     expect(window.tc.settings.controllerMarginTop).toBe(200);
     expect(window.tc.settings.controllerMarginBottom).toBe(0);
     expect(window.tc.settings.rememberSpeed).toBe(true);
+
+    window.resetSettingsFromSiteRuleBase();
+    window.tc.settings.shortcutTargetMode = "closest";
+    window.tc.settings.siteRules = [
+      { pattern: "example.org", shortcutTargetMode: "all" }
+    ];
+    window.captureSiteRuleBase();
+    window.applySiteRuleOverrides();
+    expect(window.tc.settings.shortcutTargetMode).toBe("all");
   });
 
   it("sizes and positions the controller host to the video bounds", async () => {
@@ -316,4 +325,64 @@ describe("inject.js helper logic", () => {
     expect(video.vsc).toBeDefined();
     expect(video.vsc.div).toBeDefined();
   });
+
+  it("only blocks page key handlers when the shortcut force option is enabled", async () => {
+    bootInject({
+      syncData: {
+        keyBindings: [
+          {
+            action: "faster",
+            code: "KeyD",
+            value: 0.1,
+            force: false
+          }
+        ]
+      }
+    });
+    await flushAsyncWork(3);
+
+    const video = document.createElement("video");
+    video.src = "https://example.org/shortcut.mp4";
+    document.body.appendChild(video);
+    window.ensureController(video, document.body);
+    let pageKeydowns = 0;
+    let pageCaptureKeydowns = 0;
+    document.addEventListener(
+      "keydown",
+      function() {
+        pageCaptureKeydowns += 1;
+      },
+      true
+    );
+    document.body.addEventListener("keydown", function() {
+      pageKeydowns += 1;
+    });
+
+    const unblocked = new KeyboardEvent("keydown", {
+      key: "d",
+      code: "KeyD",
+      bubbles: true,
+      cancelable: true
+    });
+    video.dispatchEvent(unblocked);
+
+    expect(video.playbackRate).toBeCloseTo(1.1, 5);
+    expect(pageKeydowns).toBe(1);
+    expect(pageCaptureKeydowns).toBe(1);
+    expect(unblocked.defaultPrevented).toBe(false);
+
+    window.tc.settings.keyBindings[0].force = "true";
+    const blocked = new KeyboardEvent("keydown", {
+      key: "d",
+      code: "KeyD",
+      bubbles: true,
+      cancelable: true
+    });
+    video.dispatchEvent(blocked);
+
+    expect(video.playbackRate).toBeCloseTo(1.2, 5);
+    expect(pageKeydowns).toBe(1);
+    expect(pageCaptureKeydowns).toBe(1);
+    expect(blocked.defaultPrevented).toBe(true);
+  });
 });
diff --git a/tests/options.integration.test.js b/tests/options.integration.test.js
index e6a6a22..f36acfa 100644
--- a/tests/options.integration.test.js
+++ b/tests/options.integration.test.js
@@ -13,6 +13,7 @@ async function setupOptions(overrides = {}) {
   globalThis.fetch = vi.fn();
   loadScript("extension/shared/controller-utils.js");
   loadScript("extension/shared/key-bindings.js");
+  loadScript("extension/shared/settings-core.js");
   loadScript("extension/shared/popup-controls.js");
   loadScript("extension/shared/ui-icons.js");
   loadScript("extension/options/lucide-client.js");
@@ -29,6 +30,7 @@ describe("options page", () => {
       sync: {
         rememberSpeed: true,
         enabled: false,
+        shortcutTargetMode: "all",
         subtitleNudgeEnabledByDefault: false,
         popupMatchHoverControls: false,
         popupControllerButtons: ["rewind", "settings", "advance", "advance"],
@@ -38,8 +40,11 @@ describe("options page", () => {
         ],
         siteRules: [
           {
+            title: "YouTube testing",
             pattern: "youtube.com",
             enabled: true,
+            shortcutTargetMode: "all",
+            preferredSpeed: 2.4,
             subtitleNudgeEnabledByDefault: false,
             showPopupControlBar: false,
             popupControllerButtons: ["advance", "settings", "advance"]
@@ -51,6 +56,7 @@ describe("options page", () => {
     expect(document.getElementById("app-version").textContent).toBe("5.1.7.0");
     expect(document.getElementById("rememberSpeed").checked).toBe(true);
     expect(document.getElementById("enabled").checked).toBe(false);
+    expect(document.getElementById("shortcutTargetMode").value).toBe("all");
     expect(document.getElementById("subtitleNudgeEnabledByDefault").checked).toBe(
       false
     );
@@ -63,6 +69,15 @@ describe("options page", () => {
     expect(document.querySelector(".site-rule .override-subtitleNudge").checked).toBe(
       true
     );
+    expect(document.querySelector(".site-rule .site-preferredSpeed").value).toBe(
+      "2.4"
+    );
+    expect(
+      document.querySelector(".site-rule .site-shortcutTargetMode").value
+    ).toBe("all");
+    expect(document.querySelector(".site-rule .site-title").value).toBe(
+      "YouTube testing"
+    );
     expect(
       document.querySelector(".site-rule .site-subtitleNudgeEnabledByDefault")
         .checked
@@ -185,9 +200,13 @@ describe("options page", () => {
 
     globalThis.createSiteRule(null);
     const rule = document.querySelector(".site-rule");
+    rule.querySelector(".site-title").value = "My YouTube rule";
     rule.querySelector(".site-pattern").value = "youtube.com";
     rule.querySelector(".override-playback").checked = true;
     rule.querySelector(".site-rememberSpeed").checked = true;
+    rule.querySelector(".site-preferredSpeed").value = "2.4";
+    rule.querySelector(".override-shortcut-target").checked = true;
+    rule.querySelector(".site-shortcutTargetMode").value = "all";
     rule.querySelector(".override-opacity").checked = true;
     rule.querySelector(".site-controllerOpacity").value = "0";
     rule.querySelector(".override-subtitleNudge").checked = true;
@@ -207,11 +226,9 @@ describe("options page", () => {
 
     globalThis.save_options();
 
-    expect(chrome.storage.sync.remove).toHaveBeenCalled();
-    const savedSettings =
-      chrome.storage.sync.set.mock.calls[
-        chrome.storage.sync.set.mock.calls.length - 1
-      ][0];
+    const savedSettings = globalThis.vscExpandStoredSettings(
+      chrome.storage.sync.__state
+    );
 
     expect(savedSettings.rememberSpeed).toBe(true);
     expect(savedSettings.hideWithControlsTimer).toBe(15);
@@ -226,8 +243,11 @@ describe("options page", () => {
     expect(savedSettings.siteRules).toEqual(
       expect.arrayContaining([
         expect.objectContaining({
+        title: "My YouTube rule",
         pattern: "youtube.com",
         rememberSpeed: true,
+        shortcutTargetMode: "all",
+        preferredSpeed: 2.4,
         controllerOpacity: 0,
         enableSubtitleNudge: true,
         subtitleNudgeEnabledByDefault: false,
@@ -238,4 +258,38 @@ describe("options page", () => {
       ])
     );
   });
+
+  it("restores managed defaults and clears private local UI/runtime data", async () => {
+    const chrome = await setupOptions({
+      sync: {
+        rememberSpeed: true,
+        siteRules: [],
+        lastSpeed: 1.6,
+        futureRuntimeValue: "keep"
+      },
+      local: {
+        customButtonIcons: { faster: { slug: "rocket" } },
+        rememberedSpeeds: { "https://example.com/video.mp4": 1.75 },
+        unrelatedLocalValue: "keep"
+      }
+    });
+
+    globalThis.restore_defaults();
+    await flushAsyncWork();
+
+    const raw = chrome.storage.sync.__state;
+    const restored = globalThis.vscExpandStoredSettings(raw);
+    expect(restored.rememberSpeed).toBe(false);
+    expect(restored.siteRules).toEqual(
+      globalThis.vscGetSettingsDefaults().siteRules
+    );
+    expect(raw.lastSpeed).toBe(1);
+    expect(raw.futureRuntimeValue).toBe("keep");
+    expect(chrome.storage.local.__state.customButtonIcons).toBeUndefined();
+    expect(chrome.storage.local.__state.rememberedSpeeds).toBeUndefined();
+    expect(
+      chrome.storage.local.__state.rememberedSpeedsResetAt
+    ).toEqual(expect.any(Number));
+    expect(chrome.storage.local.__state.unrelatedLocalValue).toBe("keep");
+  });
 });
diff --git a/tests/options.spec.js b/tests/options.spec.js
index d34ec70..fd609d3 100644
--- a/tests/options.spec.js
+++ b/tests/options.spec.js
@@ -32,6 +32,7 @@ function bootOptions(options) {
 
   evaluateScript("extension/shared/controller-utils.js");
   evaluateScript("extension/shared/key-bindings.js");
+  evaluateScript("extension/shared/settings-core.js");
   evaluateScript("extension/shared/popup-controls.js");
   evaluateScript("extension/shared/ui-icons.js");
   evaluateScript("extension/options/lucide-client.js");
@@ -49,6 +50,217 @@ describe("options.js", () => {
     delete global.fetch;
   });
 
+  it("rejects invalid zero-valued speed steps instead of saving broken shortcuts", async () => {
+    const chrome = bootOptions();
+    await flushAsyncWork(3);
+    const fasterRow = Array.from(
+      document.querySelectorAll("#customs .shortcut-row")
+    ).find((row) => row.dataset.action === "faster");
+    fasterRow.querySelector(".customValue").value = "0";
+    chrome.storage.sync.set.mockClear();
+
+    window.save_options();
+
+    expect(document.getElementById("status").textContent).toContain(
+      "must be greater than 0"
+    );
+    expect(chrome.storage.sync.set).not.toHaveBeenCalled();
+  });
+
+  it("does not partially save options when a required site shortcut is invalid", async () => {
+    const chrome = bootOptions({ syncData: { rememberSpeed: false } });
+    await flushAsyncWork(3);
+    window.createSiteRule({
+      pattern: "example.org",
+      shortcuts: [
+        {
+          action: "faster",
+          code: "KeyD",
+          value: 0.1,
+          disabled: false
+        }
+      ]
+    });
+    const rule = document.getElementById("siteRulesContainer").lastElementChild;
+    rule.querySelector('.shortcut-row[data-action="faster"] .customKey').vscBinding =
+      null;
+    document.getElementById("rememberSpeed").checked = true;
+    chrome.storage.sync.set.mockClear();
+    chrome.storage.sync.remove.mockClear();
+
+    window.save_options();
+
+    expect(document.getElementById("status").textContent).toContain(
+      "cannot be empty"
+    );
+    expect(chrome.storage.sync.set).not.toHaveBeenCalled();
+    expect(chrome.storage.sync.remove).not.toHaveBeenCalled();
+    expect(chrome.storage.sync._dump().rememberSpeed).toBe(false);
+  });
+
+  it("preserves the supported unexposed subtitle nudge amount when saving", async () => {
+    const chrome = bootOptions({ syncData: { subtitleNudgeAmount: 0.004 } });
+    await flushAsyncWork(3);
+
+    window.save_options();
+
+    expect(
+      window.vscExpandStoredSettings(chrome.storage.sync._dump())
+        .subtitleNudgeAmount
+    ).toBe(0.004);
+  });
+
+  it("does not turn a blank per-site preferred speed into the 1.8 fast default", async () => {
+    const chrome = bootOptions();
+    await flushAsyncWork(3);
+    const shortsRule = Array.from(document.querySelectorAll(".site-rule")).find(
+      (rule) => rule.querySelector(".site-title").value === "YouTube Shorts"
+    );
+
+    expect(shortsRule).toBeTruthy();
+    expect(shortsRule.querySelector(".site-preferredSpeed").value).toBe("");
+    window.save_options();
+
+    const expanded = window.vscExpandStoredSettings(chrome.storage.sync._dump());
+    const savedShortsRule = expanded.siteRules.find(
+      (rule) => rule.title === "YouTube Shorts"
+    );
+    expect(savedShortsRule.preferredSpeed).toBeUndefined();
+  });
+
+  it("keeps the loaded UI and blocks saves when a settings reload fails", async () => {
+    const chrome = bootOptions({
+      syncData: {
+        rememberSpeed: true,
+        siteRules: [{ pattern: "example.org", enabled: true }]
+      }
+    });
+    await flushAsyncWork(3);
+    const originalRuleCount = document.querySelectorAll(".site-rule").length;
+
+    chrome.storage.sync.get.mockImplementationOnce(function (_keys, callback) {
+      chrome.runtime.lastError = { message: "temporary read failure" };
+      callback({});
+      chrome.runtime.lastError = null;
+    });
+    chrome.storage.sync.set.mockClear();
+    chrome.storage.sync.remove.mockClear();
+
+    window.restore_options();
+
+    expect(document.getElementById("rememberSpeed").checked).toBe(true);
+    expect(document.querySelectorAll(".site-rule")).toHaveLength(
+      originalRuleCount
+    );
+    expect(document.getElementById("save").disabled).toBe(true);
+    expect(document.getElementById("status").textContent).toContain(
+      "temporary read failure"
+    );
+
+    document.getElementById("rememberSpeed").checked = false;
+    window.save_options();
+
+    expect(chrome.storage.sync.set).not.toHaveBeenCalled();
+    expect(chrome.storage.sync.remove).not.toHaveBeenCalled();
+    expect(chrome.storage.sync._dump().rememberSpeed).toBe(true);
+    expect(document.getElementById("status").textContent).toContain(
+      "Settings have not loaded"
+    );
+  });
+
+  it("does not clear local data or live rows when the sync reset fails", async () => {
+    const chrome = bootOptions({
+      syncData: {
+        keyBindings: [
+          { action: "display", code: "KeyV", value: 0, predefined: true },
+          { action: "pause", code: "KeyQ", value: 0, predefined: false }
+        ]
+      },
+      localData: {
+        customButtonIcons: { faster: { slug: "rocket" } },
+        rememberedSpeeds: { "https://example.org/video.mp4": 1.5 }
+      }
+    });
+    await flushAsyncWork(3);
+    expect(
+      document.querySelector('.shortcut-row.customs[data-action="pause"]')
+    ).not.toBeNull();
+
+    chrome.storage.local.remove.mockClear();
+    chrome.storage.sync.remove.mockImplementationOnce(function (_keys, callback) {
+      chrome.runtime.lastError = { message: "sync reset failed" };
+      callback();
+      chrome.runtime.lastError = null;
+    });
+
+    window.restore_defaults();
+    await flushAsyncWork(3);
+
+    expect(chrome.storage.local.remove).not.toHaveBeenCalled();
+    expect(chrome.storage.local._dump().customButtonIcons).toBeDefined();
+    expect(chrome.storage.local._dump().rememberedSpeeds).toBeDefined();
+    expect(
+      document.querySelector('.shortcut-row.customs[data-action="pause"]')
+    ).not.toBeNull();
+    expect(document.getElementById("save").disabled).toBe(false);
+    expect(document.getElementById("status").textContent).toContain(
+      "sync reset failed"
+    );
+  });
+
+  it("reports a local reset failure after resetting sync defaults", async () => {
+    const chrome = bootOptions({
+      syncData: { rememberSpeed: true, lastSpeed: 1.75 },
+      localData: { customButtonIcons: { faster: { slug: "rocket" } } }
+    });
+    await flushAsyncWork(3);
+
+    chrome.storage.local.remove.mockImplementationOnce(function (_keys, callback) {
+      chrome.runtime.lastError = { message: "local reset failed" };
+      callback();
+      chrome.runtime.lastError = null;
+    });
+
+    window.restore_defaults();
+    await flushAsyncWork(3);
+
+    expect(
+      window.vscExpandStoredSettings(chrome.storage.sync._dump()).rememberSpeed
+    ).toBe(false);
+    expect(chrome.storage.sync._dump().lastSpeed).toBe(1);
+    expect(chrome.storage.local._dump().customButtonIcons).toBeDefined();
+    expect(document.getElementById("save").disabled).toBe(false);
+    expect(document.getElementById("status").textContent).toContain(
+      "local reset failed"
+    );
+  });
+
+  it("does not remove local data when the speed reset marker cannot be written", async () => {
+    const chrome = bootOptions({
+      localData: {
+        customButtonIcons: { faster: { slug: "rocket" } },
+        rememberedSpeeds: { "https://example.org/video.mp4": 1.5 }
+      }
+    });
+    await flushAsyncWork(3);
+    chrome.storage.local.remove.mockClear();
+    chrome.storage.local.set.mockImplementationOnce(function (_items, callback) {
+      chrome.runtime.lastError = { message: "reset marker failed" };
+      callback();
+      chrome.runtime.lastError = null;
+    });
+
+    window.restore_defaults();
+    await flushAsyncWork(3);
+
+    expect(chrome.storage.local.remove).not.toHaveBeenCalled();
+    expect(chrome.storage.local._dump().customButtonIcons).toBeDefined();
+    expect(chrome.storage.local._dump().rememberedSpeeds).toBeDefined();
+    expect(document.getElementById("status").textContent).toContain(
+      "reset marker failed"
+    );
+  });
+
   it("restores saved settings, bindings, site rules, and popup bar order", async () => {
     bootOptions({
       syncData: {
@@ -145,32 +357,16 @@ describe("options.js", () => {
 
     window.save_options();
 
-    expect(chrome.storage.sync.remove).toHaveBeenCalledWith(
-      [
-        "resetSpeed",
-        "speedStep",
-        "fastSpeed",
-        "rewindTime",
-        "advanceTime",
-        "resetKeyCode",
-        "slowerKeyCode",
-        "fasterKeyCode",
-        "rewindKeyCode",
-        "advanceKeyCode",
-        "fastKeyCode",
-        "blacklist"
-      ],
-      expect.any(Function)
+    const savedSettings = window.vscExpandStoredSettings(
+      chrome.storage.sync._dump()
     );
-
-    const savedSettings = chrome.storage.sync.set.mock.calls.at(-1)[0];
     expect(savedSettings.rememberSpeed).toBe(true);
     expect(savedSettings.hideWithControlsTimer).toBe(15);
     expect(savedSettings.controllerLocation).toBe("bottom-left");
     expect(savedSettings.controllerMarginTop).toBe(200);
     expect(savedSettings.controllerMarginBottom).toBe(0);
     expect(savedSettings.popupControllerButtons).toEqual(["advance", "rewind"]);
-    expect(savedSettings.siteRules).toHaveLength(3);
+    expect(savedSettings.siteRules).toHaveLength(4);
     expect(savedSettings.siteRules).toEqual(
       expect.arrayContaining([
         expect.objectContaining({
diff --git a/tests/popup.integration.test.js b/tests/popup.integration.test.js
index 027bf99..2aeb54f 100644
--- a/tests/popup.integration.test.js
+++ b/tests/popup.integration.test.js
@@ -10,6 +10,7 @@ async function setupPopup(overrides = {}) {
   loadHtml("extension/popup/popup.html");
   globalThis.chrome = createChromeMock(overrides);
   window.chrome = globalThis.chrome;
+  loadScript("extension/shared/settings-core.js");
   loadScript("extension/shared/site-rules.js");
   loadScript("extension/shared/popup-controls.js");
   loadScript("extension/shared/ui-icons.js");
@@ -152,10 +153,44 @@ describe("popup UI", () => {
       1,
       {
         action: "set_force_last_saved_speed",
-        enabled: true,
-        speed: 1.8
+        enabled: true
       },
       expect.any(Function)
     );
   });
+
+  it("keeps the global force setting unchanged when a site rule controls it", async () => {
+    const chrome = await setupPopup({
+      sync: {
+        forceLastSavedSpeed: false,
+        siteRules: [
+          {
+            pattern: "example.com",
+            enabled: true,
+            forceLastSavedSpeed: true
+          }
+        ]
+      }
+    });
+    const forceButton = document.getElementById("forceLastSavedSpeed");
+    expect(forceButton.getAttribute("aria-pressed")).toBe("true");
+    const storageBeforeClick = JSON.parse(
+      JSON.stringify(chrome.storage.sync.__state)
+    );
+    chrome.storage.sync.set.mockClear();
+    chrome.storage.sync.remove.mockClear();
+    chrome.tabs.sendMessage.mockClear();
+
+    forceButton.click();
+    await flushAsyncWork();
+
+    expect(chrome.storage.sync.__state).toEqual(storageBeforeClick);
+    expect(chrome.storage.sync.set).not.toHaveBeenCalled();
+    expect(chrome.storage.sync.remove).not.toHaveBeenCalled();
+    expect(chrome.tabs.sendMessage).not.toHaveBeenCalled();
+    expect(forceButton.getAttribute("aria-pressed")).toBe("true");
+    expect(document.getElementById("status").textContent).toBe(
+      "Force setting is controlled by this site rule."
+    );
+  });
 });
diff --git a/tests/popup.spec.js b/tests/popup.spec.js
index 2b461cd..4103175 100644
--- a/tests/popup.spec.js
+++ b/tests/popup.spec.js
@@ -6,6 +6,7 @@ const {
   installCommonWindowMocks,
   loadHtmlFile
 } = require("./helpers/extension-test-utils");
+const manifest = require("../extension/manifest.json");
 
 function bootPopup(options) {
   const config = options || {};
@@ -46,6 +47,7 @@ function bootPopup(options) {
   global.chrome = chrome;
   window.chrome = chrome;
 
+  evaluateScript("extension/shared/settings-core.js");
   evaluateScript("extension/shared/site-rules.js");
   evaluateScript("extension/shared/popup-controls.js");
   evaluateScript("extension/shared/ui-icons.js");
@@ -62,6 +64,10 @@ describe("popup.js", () => {
     delete global.chrome;
   });
 
+  it("declares activeTab for the popup all-frame speed snapshot", () => {
+    expect(manifest.permissions).toContain("activeTab");
+  });
+
   it("renders the popup disabled state when a site rule disables Speeder", async () => {
     bootPopup({
       syncData: {
@@ -152,10 +158,10 @@ describe("popup.js", () => {
     expect(document.querySelector("#disable").classList.contains("hide")).toBe(true);
 
     document.querySelector("#enable").click();
-    expect(chrome.storage.sync.set).toHaveBeenCalledWith(
-      { enabled: true },
-      expect.any(Function)
-    );
+    expect(chrome.storage.sync._dump()).not.toHaveProperty("enabled");
+    expect(
+      window.vscExpandStoredSettings(chrome.storage.sync._dump()).enabled
+    ).toBe(true);
     expect(chrome.browserAction.setIcon).toHaveBeenCalledWith({
       path: {
         19: "assets/icons/icon19.png",
diff --git a/tests/settings-core.spec.js b/tests/settings-core.spec.js
new file mode 100644
index 0000000..878e5e4
--- /dev/null
+++ b/tests/settings-core.spec.js
@@ -0,0 +1,370 @@
+const {
+  evaluateScript,
+  loadHtmlString
+} = require("./helpers/extension-test-utils");
+
+function bootSettingsCore() {
+  loadHtmlString("<!doctype html><html><head></head><body></body></html>");
+  evaluateScript("extension/shared/settings-core.js");
+  evaluateScript("extension/shared/site-rules.js");
+}
+
+function youtubeShortsRule(settings) {
+  return settings.siteRules.find(function (rule) {
+    return String(rule.pattern).includes("\\/shorts\\/");
+  });
+}
+
+describe("canonical settings storage", () => {
+  beforeEach(() => {
+    bootSettingsCore();
+  });
+
+  it("expands missing settings to the built-in Shorts remember-speed rule", () => {
+    const settings = window.vscExpandStoredSettings({});
+    const shortsRule = youtubeShortsRule(settings);
+
+    expect(shortsRule).toEqual(
+      expect.objectContaining({
+        title: "YouTube Shorts",
+        enabled: true,
+        rememberSpeed: true,
+        controllerMarginTop: 60,
+        controllerMarginBottom: 85
+      })
+    );
+    expect(settings.shortcutTargetMode).toBe("closest");
+  });
+
+  it("round-trips global and site-specific shortcut targeting", () => {
+    const settings = window.vscExpandStoredSettings({
+      shortcutTargetMode: "all",
+      siteRules: [
+        {
+          title: "One player at a time",
+          pattern: "example.org",
+          shortcutTargetMode: "closest"
+        }
+      ]
+    });
+    const stored = window.vscBuildStoredSettingsDiff(settings);
+    const restored = window.vscExpandStoredSettings(stored);
+
+    expect(restored.shortcutTargetMode).toBe("all");
+    expect(restored.siteRules).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          pattern: "example.org",
+          shortcutTargetMode: "closest"
+        })
+      ])
+    );
+  });
+
+  it("provides titles for built-in video rules and round-trips title edits sparsely", () => {
+    const settings = window.vscExpandStoredSettings({});
+    expect(settings.siteRules.map((rule) => rule.title)).toEqual([
+      "YouTube videos",
+      "YouTube Shorts",
+      "YouTube Shorts (mobile)"
+    ]);
+
+    settings.siteRules[1].title = "Short-form videos";
+    const stored = window.vscBuildStoredSettingsDiff(settings);
+    expect(stored.siteRules).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          pattern: settings.siteRules[1].pattern,
+          title: "Short-form videos"
+        })
+      ])
+    );
+    expect(window.vscExpandStoredSettings(stored).siteRules[1].title).toBe(
+      "Short-form videos"
+    );
+  });
+
+  it("keeps an intentionally cleared built-in title cleared", () => {
+    const settings = window.vscExpandStoredSettings({});
+    const pattern = settings.siteRules[0].pattern;
+    delete settings.siteRules[0].title;
+
+    const stored = window.vscBuildStoredSettingsDiff(settings);
+    const tombstone = stored.siteRulesMeta.removedDefaultRuleKeys.find(
+      (entry) => entry.pattern === pattern
+    );
+
+    expect(tombstone.keys).toContain("title");
+    expect(window.vscExpandStoredSettings(stored).siteRules[0]).not.toHaveProperty(
+      "title"
+    );
+  });
+
+  it("round-trips an intentionally empty site-rule list", () => {
+    const expanded = window.vscExpandStoredSettings({ siteRules: [] });
+    expect(expanded.siteRules).toEqual([]);
+
+    const stored = window.vscBuildStoredSettingsDiff(expanded);
+    expect(stored.siteRulesFormat).toBe("defaults-diff-v2");
+    expect(stored.siteRules).toBeUndefined();
+    expect(stored.siteRulesMeta.removedDefaultPatterns).toHaveLength(3);
+    expect(window.vscExpandStoredSettings(stored).siteRules).toEqual([]);
+  });
+
+  it("keeps removals from built-in rules through sparse persistence", () => {
+    const settings = window.vscExpandStoredSettings({});
+    const shortsRule = youtubeShortsRule(settings);
+    delete shortsRule.rememberSpeed;
+
+    const stored = window.vscBuildStoredSettingsDiff(settings);
+    const tombstone = stored.siteRulesMeta.removedDefaultRuleKeys.find(
+      function (entry) {
+        return entry.pattern === shortsRule.pattern;
+      }
+    );
+    expect(tombstone.keys).toContain("rememberSpeed");
+
+    const restoredRule = youtubeShortsRule(
+      window.vscExpandStoredSettings(stored)
+    );
+    expect(restoredRule).not.toHaveProperty("rememberSpeed");
+    expect(restoredRule.controllerMarginTop).toBe(60);
+    expect(restoredRule.controllerMarginBottom).toBe(85);
+  });
+
+  it("expands legacy defaults-diff-v1 site-rule patches", () => {
+    const defaults = window.vscGetSettingsDefaults();
+    const shortsPattern = youtubeShortsRule(defaults).pattern;
+    const settings = window.vscExpandStoredSettings({
+      siteRulesFormat: "defaults-diff-v1",
+      siteRules: [{ pattern: shortsPattern, controllerMarginTop: 72 }]
+    });
+    const shortsRule = youtubeShortsRule(settings);
+
+    expect(shortsRule.rememberSpeed).toBe(true);
+    expect(shortsRule.controllerMarginTop).toBe(72);
+    expect(shortsRule.controllerMarginBottom).toBe(85);
+  });
+
+  it("migrates legacy shortcut, hide, and blacklist values", () => {
+    const settings = window.vscExpandStoredSettings({
+      speedStep: 0.25,
+      rewindTime: 7,
+      advanceTime: 14,
+      fastSpeed: 2.25,
+      displayKeyCode: 81,
+      fasterKeyCode: 70,
+      hideWithYouTubeControls: true,
+      blacklist: "bad.test\nhttps://blocked.test/watch"
+    });
+    const bindings = Object.fromEntries(
+      settings.keyBindings.map(function (binding) {
+        return [binding.action, binding];
+      })
+    );
+
+    expect(bindings.slower.value).toBe(0.25);
+    expect(bindings.faster).toEqual(
+      expect.objectContaining({ code: "KeyF", value: 0.25 })
+    );
+    expect(bindings.rewind.value).toBe(7);
+    expect(bindings.advance.value).toBe(14);
+    expect(bindings.fast.value).toBe(2.25);
+    expect(bindings.display.code).toBe("KeyQ");
+    expect(settings.hideWithControls).toBe(true);
+    expect(settings.siteRules).toEqual(
+      expect.arrayContaining([
+        { pattern: "bad.test", enabled: false },
+        { pattern: "https://blocked.test/watch", enabled: false }
+      ])
+    );
+  });
+
+  it("adds the mobile Shorts default to legacy full default-rule lists", () => {
+    const defaults = window.vscGetSettingsDefaults();
+    const legacyRules = defaults.siteRules.slice(0, 2).map(function(rule) {
+      return Object.assign({}, rule, {
+        forceLastSavedSpeed: false,
+        audioBoolean: false
+      });
+    });
+
+    const expanded = window.vscExpandStoredSettings({ siteRules: legacyRules });
+
+    expect(
+      expanded.siteRules.some(function(rule) {
+        return String(rule.pattern).includes("m\\.youtube") &&
+          rule.rememberSpeed === true;
+      })
+    ).toBe(true);
+    expect(expanded.siteRules.map((rule) => rule.title)).toEqual([
+      "YouTube videos",
+      "YouTube Shorts",
+      "YouTube Shorts (mobile)"
+    ]);
+  });
+
+  it("normalizes imported rule types and unsafe numeric ranges", () => {
+    const expanded = window.vscExpandStoredSettings({
+      enabled: "false",
+      siteRules: [
+        {
+          title: "  Example videos  ",
+          pattern: "example.org",
+          enabled: "false",
+          rememberSpeed: "false",
+          forceLastSavedSpeed: "true",
+          controllerOpacity: 3,
+          subtitleNudgeInterval: -5,
+          preferredSpeed: 50
+        }
+      ]
+    });
+    const rule = expanded.siteRules[0];
+
+    expect(expanded.enabled).toBe(false);
+    expect(rule.title).toBe("Example videos");
+    expect(rule.enabled).toBe(false);
+    expect(rule.rememberSpeed).toBe(false);
+    expect(rule.forceLastSavedSpeed).toBe(true);
+    expect(rule.controllerOpacity).toBe(1);
+    expect(rule.subtitleNudgeInterval).toBe(10);
+    expect(rule.preferredSpeed).toBe(16);
+  });
+
+  it("falls back for null and blank numeric settings instead of coercing zero", () => {
+    const expanded = window.vscExpandStoredSettings({
+      lastSpeed: null,
+      controllerMarginBottom: "   ",
+      siteRules: [
+        {
+          pattern: "example.org",
+          preferredSpeed: "",
+          controllerMarginBottom: null
+        }
+      ]
+    });
+
+    expect(expanded.lastSpeed).toBe(1);
+    expect(expanded.controllerMarginBottom).toBe(65);
+    expect(expanded.siteRules[0].preferredSpeed).toBeUndefined();
+    expect(expanded.siteRules[0].controllerMarginBottom).toBeUndefined();
+  });
+
+  it("repairs invalid imported shortcut values to safe action defaults", () => {
+    const expanded = window.vscExpandStoredSettings({
+      keyBindings: [
+        { action: "faster", code: "KeyD", value: 0 },
+        { action: "fast", code: "KeyG", value: "not-a-number" },
+        { action: "rewind", code: "KeyZ", value: -2 }
+      ]
+    });
+
+    expect(expanded.keyBindings.map((binding) => binding.value)).toEqual([
+      0.1,
+      1.8,
+      10
+    ]);
+  });
+
+  it("drops malformed primitive shortcut entries instead of crashing hydration", () => {
+    expect(() =>
+      window.vscExpandStoredSettings({
+        keyBindings: [null, "bad", 7, { action: "faster", code: "KeyD", value: 0.2 }]
+      })
+    ).not.toThrow();
+
+    expect(
+      window.vscExpandStoredSettings({
+        keyBindings: [null, "bad", { action: "faster", code: "KeyD", value: 0.2 }]
+      }).keyBindings
+    ).toEqual([
+      expect.objectContaining({ action: "faster", value: 0.2 })
+    ]);
+  });
+
+  it("removes stale managed keys without touching runtime or future data", () => {
+    const raw = {
+      rememberSpeed: true,
+      speedStep: 0.2,
+      lastSpeed: 1.75,
+      futureRuntimeValue: { keep: true }
+    };
+    const settings = window.vscExpandStoredSettings(raw);
+    settings.rememberSpeed = false;
+
+    const mutation = window.vscBuildManagedStorageMutation(raw, settings);
+    expect(mutation.remove).toEqual(
+      expect.arrayContaining(["rememberSpeed", "speedStep"])
+    );
+    expect(mutation.remove).not.toContain("lastSpeed");
+    expect(mutation.remove).not.toContain("futureRuntimeValue");
+    expect(mutation.set.keyBindings).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ action: "faster", value: 0.2 })
+      ])
+    );
+  });
+});
+
+describe("site-rule matching", () => {
+  beforeEach(() => {
+    bootSettingsCore();
+  });
+
+  it("merges all matches in order so a later specific rule wins", () => {
+    const matched = window.vscMatchSiteRule(
+      "https://www.youtube.com/shorts/abc",
+      [
+        {
+          pattern: "youtube.com",
+          enabled: false,
+          rememberSpeed: false,
+          controllerOpacity: 0.2
+        },
+        {
+          pattern: "youtube.com/shorts",
+          enabled: true,
+          rememberSpeed: true
+        }
+      ]
+    );
+
+    expect(matched).toEqual(
+      expect.objectContaining({
+        enabled: true,
+        rememberSpeed: true,
+        controllerOpacity: 0.2
+      })
+    );
+  });
+
+  it("matches plain host patterns only on safe hostname boundaries", () => {
+    const matcher = window.SpeederShared.siteRules;
+
+    expect(
+      matcher.plainSitePatternMatchesUrl(
+        "example.com",
+        "https://media.example.com/watch"
+      )
+    ).toBe(true);
+    expect(
+      matcher.plainSitePatternMatchesUrl(
+        "example.com",
+        "https://notexample.com/watch"
+      )
+    ).toBe(false);
+    expect(
+      matcher.plainSitePatternMatchesUrl(
+        "example.com",
+        "https://example.com.evil.test/watch"
+      )
+    ).toBe(false);
+    expect(
+      matcher.plainSitePatternMatchesUrl(
+        "example.com",
+        "https://safe.test/watch?next=example.com"
+      )
+    ).toBe(false);
+  });
+});
diff --git a/tests/shared.test.js b/tests/shared.test.js
index 4924a3e..7f78a84 100644
--- a/tests/shared.test.js
+++ b/tests/shared.test.js
@@ -24,6 +24,53 @@ describe("shared helpers", () => {
     expect(siteRules.isSiteRuleDisabled({ enabled: false })).toBe(true);
   });
 
+  it("matches plain and regex rules against safely decoded URL text", () => {
+    expect(
+      siteRules.siteRuleMatchesUrl(
+        { pattern: "example.com/path?title=Hello World#part one" },
+        "https://example.com/%70ath?title=Hello%20World#part%20one"
+      )
+    ).toBe(true);
+    expect(
+      siteRules.siteRuleMatchesUrl(
+        { pattern: "/example\\.com\\/path\\?title=Hello World#part one/i" },
+        "https://example.com/%70ath?title=Hello%20World#part%20one"
+      )
+    ).toBe(true);
+
+    // Raw matching remains available for rules intentionally written against
+    // the encoded form.
+    expect(
+      siteRules.siteRuleMatchesUrl(
+        { pattern: "/%70ath\\?title=Hello%20World/" },
+        "https://example.com/%70ath?title=Hello%20World"
+      )
+    ).toBe(true);
+  });
+
+  it("tolerates malformed URL escapes and keeps regex matching deterministic", () => {
+    expect(siteRules.safelyDecodeUrlText("/%70%ZZ%E2/end")).toBe(
+      "/p%ZZ%E2/end"
+    );
+    expect(siteRules.safelyDecodeUrlText("/%E2%82%AC%FF%70")).toBe(
+      "/€%FFp"
+    );
+    expect(
+      siteRules.siteRuleMatchesUrl(
+        { pattern: "/example\\.com\\/p%ZZ%E2/" },
+        "https://example.com/%70%ZZ%E2"
+      )
+    ).toBe(true);
+
+    const globalRule = { pattern: "/example\\.com\\/watch/g" };
+    expect(
+      siteRules.siteRuleMatchesUrl(globalRule, "https://example.com/watch")
+    ).toBe(true);
+    expect(
+      siteRules.siteRuleMatchesUrl(globalRule, "https://example.com/watch")
+    ).toBe(true);
+  });
+
   it("combines global enabled with matched site rules (whitelist / blacklist)", () => {
     const allowSite = { pattern: "good.test", enabled: true };
     const blockSite = { pattern: "bad.test", enabled: false };
@@ -173,12 +220,36 @@ describe("shared helpers", () => {
     expect(importExportUtils.isRecognizedRawSettingsObject({ wat: true })).toBe(
       false
     );
+    expect(
+      importExportUtils.isRecognizedRawSettingsObject({
+        siteRulesFormat: "defaults-diff-v2"
+      })
+    ).toBe(true);
+    expect(
+      importExportUtils.extractImportSettings({ settings: [] })
+    ).toBeNull();
+    expect(
+      importExportUtils.extractImportSettings({
+        settings: { enabled: true },
+        localSettings: []
+      })
+    ).toBeNull();
+    [null, "bad", []].forEach((customButtonIcons) => {
+      expect(
+        importExportUtils.extractImportSettings({
+          settings: { enabled: true },
+          localSettings: { customButtonIcons }
+        })
+      ).toBeNull();
+    });
 
     expect(
       importExportUtils.filterLocalSettingsForExport({
         customButtonIcons: { faster: { slug: "zap" } },
         lucideTagsCacheV1: { "a-arrow-down": ["letter"] },
-        lucideTagsCacheV1At: 123
+        lucideTagsCacheV1At: 123,
+        rememberedSpeeds: { "https://example.com/video.mp4": 1.75 },
+        futureRuntimeData: true
       })
     ).toEqual({
       customButtonIcons: { faster: { slug: "zap" } }
diff --git a/tests/speed-persistence.regression.test.js b/tests/speed-persistence.regression.test.js
new file mode 100644
index 0000000..ee3bb1a
--- /dev/null
+++ b/tests/speed-persistence.regression.test.js
@@ -0,0 +1,501 @@
+const {
+  createChromeMock,
+  evaluateScript,
+  flushAsyncWork,
+  loadHtmlString
+} = require("./helpers/extension-test-utils");
+
+function bootInject(syncData, url, localData) {
+  loadHtmlString("<!doctype html><html><body></body></html>", {
+    url: url || "https://example.org/"
+  });
+  const chrome = createChromeMock({
+    syncData: syncData || {},
+    localData: localData || {}
+  });
+  global.chrome = chrome;
+  window.chrome = chrome;
+  window.requestAnimationFrame = (callback) => setTimeout(callback, 0);
+  window.cancelAnimationFrame = (id) => clearTimeout(id);
+  window.requestIdleCallback = (callback) =>
+    setTimeout(
+      () => callback({ didTimeout: false, timeRemaining: () => 1 }),
+      0
+    );
+  window.cancelIdleCallback = (id) => clearTimeout(id);
+
+  evaluateScript("extension/shared/settings-core.js");
+  evaluateScript("extension/shared/controller-utils.js");
+  evaluateScript("extension/shared/key-bindings.js");
+  evaluateScript("extension/shared/site-rules.js");
+  evaluateScript("extension/shared/ui-icons.js");
+  evaluateScript("extension/content/inject.js");
+  return chrome;
+}
+
+async function createVideo() {
+  await flushAsyncWork(4);
+  const mount = document.createElement("div");
+  const video = document.createElement("video");
+  video.src = "https://example.org/a.mp4";
+  mount.appendChild(video);
+  document.body.appendChild(mount);
+  window.ensureController(video, mount);
+  return video;
+}
+
+describe("durable playback-speed intent", () => {
+  afterEach(() => {
+    vi.useRealTimers();
+    vi.unstubAllGlobals();
+    delete global.chrome;
+  });
+
+  it("activates the built-in Shorts remember-speed rule on empty storage", async () => {
+    bootInject({}, "https://www.youtube.com/shorts/abc123");
+    await flushAsyncWork(4);
+
+    expect(window.tc.settings.siteRules).toHaveLength(3);
+    expect(window.tc.activeSiteRule).toEqual(
+      expect.objectContaining({ rememberSpeed: true })
+    );
+    expect(window.tc.settings.rememberSpeed).toBe(true);
+  });
+
+  it("also activates the built-in remember rule on mobile YouTube Shorts", async () => {
+    bootInject({}, "https://m.youtube.com/shorts/mobile123");
+    await flushAsyncWork(4);
+
+    expect(window.tc.activeSiteRule).toEqual(
+      expect.objectContaining({ rememberSpeed: true })
+    );
+    expect(window.tc.settings.rememberSpeed).toBe(true);
+  });
+
+  it("does not seed a brand-new Short from unrelated global lastSpeed", async () => {
+    bootInject(
+      { lastSpeed: 1.8 },
+      "https://www.youtube.com/shorts/new-source"
+    );
+    const video = await createVideo();
+
+    expect(window.tc.settings.rememberSpeed).toBe(true);
+    expect(window.getRememberedSpeed(video)).toBeNull();
+    expect(video.playbackRate).toBe(1);
+  });
+
+  it("does not let an automatic remember-off reset overwrite lastSpeed", async () => {
+    vi.useFakeTimers();
+    const chrome = bootInject({ lastSpeed: 1.8, rememberSpeed: false });
+    const video = await createVideo();
+
+    video.src = "https://example.org/b.mp4";
+    window.applySourceTransitionPolicy(video, true);
+    video.dispatchEvent(new Event("ratechange"));
+    await vi.advanceTimersByTimeAsync(300);
+
+    expect(video.playbackRate).toBe(1);
+    expect(window.tc.settings.lastSpeed).toBe(1.8);
+    expect(chrome.storage.sync._dump().lastSpeed).toBe(1.8);
+  });
+
+  it("persists an explicit Speeder speed even before a native event arrives", async () => {
+    vi.useFakeTimers();
+    const chrome = bootInject({ lastSpeed: 1.25, rememberSpeed: false });
+    const video = await createVideo();
+
+    window.setSpeed(video, 1.75, false, true);
+    await vi.advanceTimersByTimeAsync(300);
+
+    expect(window.tc.settings.lastSpeed).toBe(1.75);
+    expect(chrome.storage.sync._dump().lastSpeed).toBe(1.75);
+  });
+
+  it("does not treat an external ratechange as saved intent when remember is off", async () => {
+    vi.useFakeTimers();
+    const chrome = bootInject({ lastSpeed: 1.8, rememberSpeed: false });
+    const video = await createVideo();
+
+    video.playbackRate = 0.75;
+    video.dispatchEvent(new Event("ratechange"));
+    await vi.advanceTimersByTimeAsync(300);
+
+    expect(window.tc.settings.lastSpeed).toBe(1.8);
+    expect(chrome.storage.sync._dump().lastSpeed).toBe(1.8);
+  });
+
+  it("does not let a site reset corrupt saved intent when remember is on", async () => {
+    vi.useFakeTimers();
+    const chrome = bootInject({ lastSpeed: 1.8, rememberSpeed: true });
+    const video = await createVideo();
+
+    video.playbackRate = 1;
+    video.dispatchEvent(new Event("ratechange"));
+    await vi.advanceTimersByTimeAsync(600);
+
+    expect(window.tc.settings.lastSpeed).toBe(1.8);
+    expect(chrome.storage.sync._dump().lastSpeed).toBe(1.8);
+  });
+
+  it("gives force mode precedence over per-source memory", async () => {
+    bootInject({
+      lastSpeed: 1.8,
+      rememberSpeed: true,
+      forceLastSavedSpeed: true
+    });
+    const video = await createVideo();
+    const sourceKey = window.getVideoSourceKey(video);
+    window.tc.settings.speeds[sourceKey] = 1.25;
+    video.vsc.targetSpeed = 1.25;
+    video.vsc.targetSpeedSourceKey = sourceKey;
+
+    expect(window.getRememberedSpeed(video)).toBe(1.8);
+    expect(window.getDesiredSpeed(video)).toBe(1.8);
+  });
+
+  it("persists a bounded per-source speed map in local storage", async () => {
+    vi.useFakeTimers();
+    const chrome = bootInject({ lastSpeed: 1.25, rememberSpeed: true });
+    const video = await createVideo();
+
+    window.setSpeed(video, 1.6, false, true);
+    await vi.advanceTimersByTimeAsync(600);
+
+    const remembered = chrome.storage.local._dump().rememberedSpeeds;
+    expect(remembered["https://example.org/a.mp4"]).toEqual(
+      expect.objectContaining({ speed: 1.6 })
+    );
+  });
+
+  it("hydrates per-source speed before creating the first controller", async () => {
+    bootInject(
+      { lastSpeed: 1.8, rememberSpeed: true },
+      "https://example.org/watch",
+      {
+        rememberedSpeeds: {
+          "https://example.org/a.mp4": {
+            speed: 1.4,
+            updatedAt: 100
+          }
+        }
+      }
+    );
+    const video = await createVideo();
+
+    expect(video.playbackRate).toBe(1.4);
+    expect(window.getRememberedSpeed(video)).toBe(1.4);
+  });
+
+  it("merges another frame's source map without losing a queued local speed", async () => {
+    vi.useFakeTimers();
+    const chrome = bootInject({ lastSpeed: 1.25, rememberSpeed: true });
+    const video = await createVideo();
+
+    window.setSpeed(video, 1.6, false, true);
+    chrome.storage.local.set({
+      rememberedSpeeds: {
+        "https://example.org/other.mp4": {
+          speed: 1.3,
+          updatedAt: Date.now() + 1
+        }
+      }
+    });
+    await vi.advanceTimersByTimeAsync(700);
+
+    const remembered = chrome.storage.local._dump().rememberedSpeeds;
+    expect(remembered["https://example.org/a.mp4"].speed).toBe(1.6);
+    expect(remembered["https://example.org/other.mp4"].speed).toBe(1.3);
+  });
+
+  it("drops a stale pre-reset write without deleting a newer cross-frame speed", async () => {
+    vi.useFakeTimers();
+    const chrome = bootInject({ lastSpeed: 1.25, rememberSpeed: true });
+    const video = await createVideo();
+    const originalSet = chrome.storage.local.set.getMockImplementation();
+    let finishStaleSet;
+    chrome.storage.local.set.mockImplementationOnce((items, callback) => {
+      finishStaleSet = () => originalSet(items, callback);
+    });
+
+    window.setSpeed(video, 1.6, false, true);
+    await vi.advanceTimersByTimeAsync(500);
+    expect(finishStaleSet).toBeTypeOf("function");
+
+    const resetAt = Date.now();
+    chrome.storage.local.set({
+      rememberedSpeedsResetAt: resetAt,
+      rememberedSpeeds: {}
+    });
+    chrome.storage.local.set({
+      rememberedSpeeds: {
+        "https://example.org/new-after-reset.mp4": {
+          speed: 1.4,
+          updatedAt: resetAt + 1
+        }
+      }
+    });
+    finishStaleSet();
+    await vi.advanceTimersByTimeAsync(0);
+
+    expect(chrome.storage.local._dump().rememberedSpeeds).toEqual({
+      "https://example.org/new-after-reset.mp4": {
+        speed: 1.4,
+        updatedAt: resetAt + 1
+      }
+    });
+    expect(window.tc.settings.speeds).not.toHaveProperty(
+      "https://example.org/a.mp4"
+    );
+    expect(window.tc.settings.speeds).toHaveProperty(
+      "https://example.org/new-after-reset.mp4",
+      1.4
+    );
+  });
+
+  it("reapplies the Shorts rule on same-source SPA navigation and resists an immediate reset", async () => {
+    vi.useFakeTimers();
+    bootInject(
+      { lastSpeed: 1.8 },
+      "https://www.youtube.com/watch?v=same-source",
+      {
+        rememberedSpeeds: {
+          "https://example.org/a.mp4": { speed: 1.8, updatedAt: 100 }
+        }
+      }
+    );
+    const video = await createVideo();
+    Object.defineProperty(video, "paused", {
+      configurable: true,
+      value: false
+    });
+
+    window.history.pushState({}, "", "/shorts/same-source");
+    await vi.advanceTimersByTimeAsync(350);
+    await flushAsyncWork(2);
+
+    expect(window.tc.settings.rememberSpeed).toBe(true);
+    expect(video.playbackRate).toBe(1.8);
+
+    video.playbackRate = 1;
+    video.dispatchEvent(new Event("ratechange"));
+    await vi.advanceTimersByTimeAsync(0);
+    expect(video.playbackRate).toBe(1.8);
+  });
+
+  it("disarms remembered policy when same-source SPA navigation leaves Shorts", async () => {
+    vi.useFakeTimers();
+    bootInject(
+      { lastSpeed: 1.8 },
+      "https://www.youtube.com/shorts/leaving",
+      {
+        rememberedSpeeds: {
+          "https://example.org/a.mp4": { speed: 1.8, updatedAt: 100 }
+        }
+      }
+    );
+    const video = await createVideo();
+    expect(video.vsc.targetSpeedOrigin).toBe("policy");
+
+    window.history.pushState({}, "", "/watch?v=leaving");
+    await vi.advanceTimersByTimeAsync(350);
+    await flushAsyncWork(2);
+
+    expect(window.tc.settings.rememberSpeed).toBe(false);
+    expect(video.vsc.targetSpeedOrigin).not.toBe("policy");
+    video.playbackRate = 1;
+    video.dispatchEvent(new Event("ratechange"));
+    await vi.advanceTimersByTimeAsync(0);
+    expect(video.playbackRate).toBe(1);
+  });
+
+  it("live-reloads sparse settings without leaking a route override into the global base", async () => {
+    vi.useFakeTimers();
+    const chrome = bootInject(
+      {
+        rememberSpeed: false,
+        siteRules: [
+          {
+            pattern: "example.org/shorts/",
+            enabled: true,
+            rememberSpeed: true
+          }
+        ]
+      },
+      "https://example.org/shorts/one"
+    );
+    await createVideo();
+    expect(window.tc.settings.rememberSpeed).toBe(true);
+
+    chrome.storage.sync.set({ controllerOpacity: 0.7 });
+    await vi.advanceTimersByTimeAsync(100);
+    expect(window.tc.siteRuleBase.rememberSpeed).toBe(false);
+    expect(window.tc.settings.rememberSpeed).toBe(true);
+
+    window.history.pushState({}, "", "/watch/two");
+    await vi.advanceTimersByTimeAsync(350);
+    expect(window.tc.activeSiteRule).toBeNull();
+    expect(window.tc.settings.rememberSpeed).toBe(false);
+  });
+
+  it("does not trust forged force-mode ratechange metadata as user intent", async () => {
+    vi.useFakeTimers();
+    const chrome = bootInject({
+      lastSpeed: 1.8,
+      forceLastSavedSpeed: true
+    });
+    const video = await createVideo();
+    video.vsc.pendingRateChange = null;
+
+    video.dispatchEvent(
+      new CustomEvent("ratechange", {
+        detail: {
+          origin: "videoSpeed",
+          speed: 0.5,
+          fromUserInput: true
+        }
+      })
+    );
+    await vi.advanceTimersByTimeAsync(300);
+
+    expect(video.playbackRate).toBe(1.8);
+    expect(window.tc.settings.lastSpeed).toBe(1.8);
+    expect(chrome.storage.sync._dump().lastSpeed).toBe(1.8);
+  });
+
+  it("ignores a stale popup speed payload and can still persist that value later", async () => {
+    vi.useFakeTimers();
+    const chrome = bootInject({ lastSpeed: 2 });
+    const video = await createVideo();
+    const listener = chrome.runtime.onMessage.listeners[0];
+    let response;
+
+    listener(
+      {
+        action: "set_force_last_saved_speed",
+        enabled: true,
+        speed: 1.5
+      },
+      {},
+      (value) => {
+        response = value;
+      }
+    );
+
+    expect(response.enabled).toBe(true);
+    expect(window.tc.settings.lastSpeed).toBe(2);
+    expect(window.tc.persistedLastSpeed).toBe(2);
+
+    window.setSpeed(video, 1.5, false, true);
+    await vi.advanceTimersByTimeAsync(300);
+    expect(chrome.storage.sync._dump().lastSpeed).toBe(1.5);
+  });
+
+  it("clears the anti-reset window when force mode is turned off", async () => {
+    const chrome = bootInject({
+      lastSpeed: 1.8,
+      forceLastSavedSpeed: true
+    });
+    const video = await createVideo();
+    video.vsc.speedRestoreUntil = Date.now() + 5000;
+    video.vsc.restoreSpeedTimer = setTimeout(() => {}, 5000);
+    const listener = chrome.runtime.onMessage.listeners[0];
+
+    listener(
+      { action: "set_force_last_saved_speed", enabled: false },
+      {},
+      () => {}
+    );
+
+    expect(window.tc.settings.forceLastSavedSpeed).toBe(false);
+    expect(video.vsc.speedRestoreUntil).toBe(0);
+    expect(video.vsc.restoreSpeedTimer).toBeNull();
+    expect(video.vsc.targetSpeedOrigin).not.toBe("policy");
+
+    video.playbackRate = 1;
+    video.dispatchEvent(new Event("ratechange"));
+    expect(video.playbackRate).toBe(1);
+  });
+
+  it("keeps force ownership through a redundant event so disabling force fully releases it", async () => {
+    const chrome = bootInject({
+      lastSpeed: 1.8,
+      forceLastSavedSpeed: true
+    });
+    const video = await createVideo();
+    const listener = chrome.runtime.onMessage.listeners[0];
+
+    video.dispatchEvent(new Event("ratechange"));
+    expect(video.vsc.targetSpeedOrigin).toBe("policy");
+
+    listener(
+      { action: "set_force_last_saved_speed", enabled: false },
+      {},
+      () => {}
+    );
+    video.playbackRate = 1;
+    video.dispatchEvent(new Event("ratechange"));
+
+    expect(video.playbackRate).toBe(1);
+    expect(video.vsc.targetSpeedOrigin).toBe("external");
+  });
+
+  it("accepts a native speed change while paused when no Speeder policy owns the target", async () => {
+    vi.useFakeTimers();
+    const chrome = bootInject({ lastSpeed: 1.8, rememberSpeed: false });
+    const video = await createVideo();
+
+    expect(video.paused).toBe(true);
+    expect(video.vsc.targetSpeedOrigin).toBe("initial");
+    video.playbackRate = 1.5;
+    video.dispatchEvent(new Event("ratechange"));
+    await vi.advanceTimersByTimeAsync(300);
+
+    expect(video.playbackRate).toBe(1.5);
+    expect(video.vsc.targetSpeedOrigin).toBe("external");
+    expect(window.tc.settings.lastSpeed).toBe(1.8);
+    expect(chrome.storage.sync._dump().lastSpeed).toBe(1.8);
+  });
+
+  it("defensively replaces an invalid zero speed step instead of jumping to 16x", async () => {
+    bootInject({
+      keyBindings: [
+        {
+          action: "faster",
+          code: "KeyD",
+          value: 0,
+          disabled: false
+        }
+      ]
+    });
+    const video = await createVideo();
+
+    window.runAction("faster", 0, null, video);
+
+    expect(video.playbackRate).toBeCloseTo(1.1, 5);
+    expect(video.playbackRate).not.toBe(16);
+  });
+
+  it("bounds verification retries when a player silently rejects forced speed", async () => {
+    vi.useFakeTimers();
+    bootInject({ lastSpeed: 1.8, forceLastSavedSpeed: true });
+    const video = await createVideo();
+    await vi.advanceTimersByTimeAsync(200);
+    let assignmentCount = 0;
+    Object.defineProperty(video, "playbackRate", {
+      configurable: true,
+      get() {
+        return 1;
+      },
+      set() {
+        assignmentCount += 1;
+      }
+    });
+
+    window.setSpeed(video, 1.8, false, false);
+    await vi.advanceTimersByTimeAsync(2000);
+
+    expect(assignmentCount).toBe(4);
+    expect(video.vsc.speedVerificationTimer).toBeNull();
+    expect(video.vsc.speedVerificationAttempts).toBe(0);
+  });
+});