diff --git a/AGENTS.md b/AGENTS.md
index c280cfbc..a8facf46 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -80,7 +80,7 @@ Private simulator behavior is implemented locally in:
 The current repo uses the private boot path, private display bridge, and private accessibility translation bridge directly. The browser streams frames from that bridge, injects touch and keyboard events through the same native session layer, inspects accessibility through `AccessibilityPlatformTranslation`, and renders device chrome from `packages/server/native/XCWChromeRenderer.*`.
 CoreSimulator service contexts resolve the active developer directory from `DEVELOPER_DIR`, then `xcode-select -p`, then `/Applications/Xcode.app/Contents/Developer`. The display bridge prefers direct CoreSimulator screen IOSurface callbacks and activates the SimulatorKit offscreen renderable view only if direct callbacks are unavailable.
 Accessibility recovery may use simulator launchctl UIKit application state plus hit-tested translations to recover candidate foreground pids; the returned tree must still be rooted at tokenized `AXPTranslator` application objects, because `translationApplicationObjectForPid:` can omit the bridge delegate token after private display lifecycle changes. Full-tree snapshots merge those recovered roots with the private frontmost application translation. Shallow snapshots with `maxDepth <= 2` use the tokenized frontmost application translation directly when it is available, and only run the expensive recovery sweep if frontmost lookup fails, so agent-oriented describe loops avoid launchctl and hit-test recovery overhead. Interactive-only snapshots also prune non-actionable native AX leaves during Objective-C serialization before the Rust-side compacting pass; keep this native pruning conservative so selector taps still retain actionable rows plus their ancestors. When multiple candidate application roots are discovered, serialize all of them in preferred order: non-extension app roots first, then largest translated roots, with `.appex`/PlugIns processes de-prioritized so SpringBoard and Safari app roots stay primary while widgets and WebContent roots remain debuggable. Widget renderer extension roots may report local frames; normalize those roots and children against matching SpringBoard widget placeholder frames before returning the snapshot.
-Physical chrome button support uses DeviceKit `chrome.json` input geometry for browser hit targets. Volume, action, mute, Apple Watch digital crown, Watch side button, and Watch left-side button dispatch through `IndigoHIDMessageForHIDArbitrary` with consumer/telephony/vendor HID usage pairs from the device chrome metadata; home, lock, and app-switcher remain on the existing SimulatorKit button paths. Apple Watch Digital Crown rotation dispatches through `IndigoHIDMessageForDigitalCrownEvent` when SimulatorKit exposes it, with `IndigoHIDMessageForScrollEvent(..., target=0x34)` as the fallback. tvOS simulators do not support direct screen touch; browser/API tap maps to Enter, swipe maps to arrow keys, and the native bridge rejects tvOS touch packets before they reach guest `SimulatorHID`. watchOS/tvOS skip dynamic pointer/mouse service warm-up because those guest runtimes abort on unsupported virtual services. Apple TV and Apple Watch simulators are fixed-orientation devices, so client and server rotation paths must not expose or dispatch device rotation for those families.
+Physical chrome button support uses DeviceKit `chrome.json` input geometry for browser hit targets. Volume, action, mute, Apple Watch digital crown, Watch side button, and Watch left-side button dispatch through `IndigoHIDMessageForHIDArbitrary` with consumer/telephony/vendor HID usage pairs from the device chrome metadata; home, lock, and app-switcher remain on the existing SimulatorKit button paths. Apple Watch Digital Crown rotation dispatches through `IndigoHIDMessageForDigitalCrownEvent` when SimulatorKit exposes it, with `IndigoHIDMessageForScrollEvent(..., target=0x34)` as the fallback. Browser mouse/trackpad wheel input over the device screen sends the normalized screen point with the scroll delta, moves the SimulatorKit pointer target there, then dispatches native scroll packets through `IndigoHIDMessageForScrollEvent(..., target=0x2)` with a digitizer-target fallback instead of synthesizing touch drags. tvOS simulators do not support direct screen touch; browser/API tap maps to Enter, swipe maps to arrow keys, and the native bridge rejects tvOS touch packets before they reach guest `SimulatorHID`. watchOS/tvOS skip dynamic pointer/mouse service warm-up because those guest runtimes abort on unsupported virtual services. Apple TV and Apple Watch simulators are fixed-orientation devices, so client and server rotation paths must not expose or dispatch device rotation for those families.
 On macOS/Xcode 27-era CoreSimulator profiles, `mainScreenWidth`, `mainScreenHeight`, and `mainScreenScale` may be absent from `profile.plist`; DeviceKit chrome rendering must read `capabilities.plist` `ScreenDimensionsCapability` or the primary `displays` entry before falling back to the framebuffer mask PDF. If none of those sources produce usable display geometry, the chrome profile must fail instead of returning a tiny synthetic bezel that hides the stream.
 Two-point multi-touch dispatch prefers the current SimulatorKit/Indigo packet constructor and falls back to SimDeck's manual Indigo packet adapter. On Xcode 26 SimulatorKit, the constructor expects pixel-space points and stable two-finger movement requires sending `LeftMouseDown` for both `began` and `moved`, then `LeftMouseUp` for `ended`/`cancelled`; using `LeftMouseDragged` for multi-touch moves only advances one contact in UIKit. Do not coalesce multi-touch move packets in the WebSocket or WebRTC control paths, because gesture recognizers need the intermediate two-contact samples.
 WebKit inspection uses the simulator `webinspectord` Unix socket named `com.apple.webinspectord_sim.socket` and WebKit's binary-plist Remote Inspector selectors. It lists only WebKit content that the runtime exposes as inspectable. For app-owned `WKWebView` on iOS 16.4 and newer, the app must set `isInspectable = true`.
diff --git a/docs/api/rest.md b/docs/api/rest.md
index 5acba0e8..4fdf9f5d 100644
--- a/docs/api/rest.md
+++ b/docs/api/rest.md
@@ -174,6 +174,13 @@ Performance query parameters:
 
 For normal clients, copy the browser behavior instead of hand-coding a raw decoder. The UI uses the WebRTC offer endpoint for live video. Android emulator IDs use the same WebRTC endpoint; their H.264 frames are produced from the emulator `-share-vid` display surface, not screenshot polling.
 
+The input/control WebSocket accepts JSON control messages with camelCase fields,
+including `touch`, `edgeTouch`, `multiTouch`, `key`, `button`, `crown`,
+`scroll`, `home`, `appSwitcher`, and rotation controls. Native iOS scroll wheel
+input uses `{ "type": "scroll", "deltaX": 0, "deltaY": 24, "x": 0.5, "y": 0.5 }`,
+where `x` and `y` are optional normalized screen coordinates from `0.0` to
+`1.0`. Touch-like messages use normalized screen coordinates too.
+
 Minimal WebRTC request:
 
 ```json
diff --git a/packages/client/src/api/controls.ts b/packages/client/src/api/controls.ts
index 6e04a7c3..acd40b35 100644
--- a/packages/client/src/api/controls.ts
+++ b/packages/client/src/api/controls.ts
@@ -9,6 +9,7 @@ import type {
   LaunchPayload,
   MultiTouchPayload,
   OpenUrlPayload,
+  ScrollPayload,
   SimulatorMetadata,
   SimulatorResponse,
   TouchPayload,
@@ -21,6 +22,7 @@ export type ControlMessage =
   | ({ type: "key" } & KeyPayload)
   | ({ type: "button" } & ButtonPayload)
   | ({ type: "crown" } & CrownPayload)
+  | ({ type: "scroll" } & ScrollPayload)
   | { type: "dismissKeyboard" }
   | { type: "toggleSoftwareKeyboard" }
   | { type: "home" }
diff --git a/packages/client/src/api/types.ts b/packages/client/src/api/types.ts
index e6da623a..31dbde3d 100644
--- a/packages/client/src/api/types.ts
+++ b/packages/client/src/api/types.ts
@@ -569,6 +569,13 @@ export interface CrownPayload {
   delta: number;
 }
 
+export interface ScrollPayload {
+  deltaX: number;
+  deltaY: number;
+  x?: number;
+  y?: number;
+}
+
 export interface LaunchPayload {
   bundleId: string;
 }
diff --git a/packages/client/src/app/AppShell.tsx b/packages/client/src/app/AppShell.tsx
index 962d0e09..ec218be0 100644
--- a/packages/client/src/app/AppShell.tsx
+++ b/packages/client/src/app/AppShell.tsx
@@ -44,6 +44,7 @@ import type {
 } from "../api/types";
 import { AccessibilityInspector } from "../features/accessibility/AccessibilityInspector";
 import { DevToolsPanel } from "../features/devtools/DevToolsPanel";
+import { normalizedClientCoordinates } from "../features/input/gestureMath";
 import { isEditableTarget } from "../features/input/keycodes";
 import { useKeyboardInput } from "../features/input/useKeyboardInput";
 import { usePointerInput } from "../features/input/usePointerInput";
@@ -71,6 +72,7 @@ import type {
   Point,
   Size,
   TouchIndicator,
+  TouchPreviewPoint,
   ViewMode,
 } from "../features/viewport/types";
 import { useViewportLayout } from "../features/viewport/useViewportLayout";
@@ -84,6 +86,7 @@ import {
   computeChromeBackingRect,
   computeChromeScreenBorderRadius,
   computeChromeScreenRect,
+  mapDisplayedPointToNaturalOrientation,
   normalizeQuarterTurns,
   screenAspectRatio,
   shellSize,
@@ -104,6 +107,7 @@ import {
   HIERARCHY_VISIBLE_STORAGE_KEY,
   nextAccessibilitySourcePreference,
   readPersistedUiState,
+  readStoredAccessibilitySkeletonMode,
   readStoredAccessibilitySource,
   readStoredFlag,
   sanitizeAccessibilitySources,
@@ -111,18 +115,32 @@ import {
   TOUCH_OVERLAY_VISIBLE_STORAGE_KEY,
   viewportStateForUDID,
   writePersistedUiState,
+  writeStoredAccessibilitySkeletonMode,
   writeStoredFlag,
 } from "./uiState";
 import { isMoveControlMessage } from "./controlMessages";
 
 const ACCESSIBILITY_REFRESH_MS = 1500;
+const ACCESSIBILITY_SKELETON_REFRESH_MS = 500;
 const REACT_NATIVE_ACCESSIBILITY_REFRESH_MS = 500;
 const FLUTTER_ACCESSIBILITY_REFRESH_MS = 1000;
 const ACCESSIBILITY_BACKGROUND_REFRESH_MS = 3000;
 const ANDROID_METADATA_REFRESH_MS = 1000;
+const BROWSER_EDGE_GESTURE_WIDTH = 32;
+const BROWSER_EDGE_GESTURE_MIN_DELTA = 8;
+const SAFARI_SCREEN_GESTURE_INITIAL_SPREAD = 0.28;
+const SAFARI_SCREEN_GESTURE_MIN_SCALE = 0.25;
+const SAFARI_SCREEN_GESTURE_MAX_SCALE = 4;
+const REAL_MULTITOUCH_GESTURE_GRACE_MS = 120;
+const NATIVE_SCROLL_DELTA_SCALE = 4;
+const NATIVE_SCROLL_MAX_DELTA = 180;
 const DEFAULT_ACCESSIBILITY_MAX_DEPTH = 10;
 const LOGICAL_INSPECTOR_MAX_DEPTH = 80;
 const FLUTTER_INSPECTOR_MAX_DEPTH = 48;
+
+function clampNumber(value: number, min: number, max: number): number {
+  return Math.min(Math.max(value, min), max);
+}
 const AUTH_REQUIRED_MESSAGE = "SimDeck API access token is required.";
 const NOT_CONNECTED_MESSAGE = "Not connected";
 const LOCAL_STREAM_DEFAULTS: StreamConfig = {
@@ -407,6 +425,20 @@ type AppInstallState = {
   phase: "dragging" | "installing" | "installed";
 };
 
+type SafariScreenGesturePair = {
+  first: Point;
+  second: Point;
+  firstPreview: TouchPreviewPoint;
+  secondPreview: TouchPreviewPoint;
+};
+
+type SafariScreenGestureState = {
+  blockedByPointerInput: boolean;
+  lastPair: SafariScreenGesturePair | null;
+  screenElement: HTMLElement;
+  startRotationDegrees: number;
+};
+
 type CaptureStatus = {
   busy: boolean;
   label: string;
@@ -529,6 +561,9 @@ export function AppShell({
     useState<AccessibilitySource[]>([]);
   const [accessibilityPreferredSource, setAccessibilityPreferredSource] =
     useState<AccessibilitySourcePreference>(readStoredAccessibilitySource);
+  const [accessibilitySkeletonMode, setAccessibilitySkeletonMode] = useState(
+    readStoredAccessibilitySkeletonMode,
+  );
   const [zoomAnimating, setZoomAnimating] = useState(false);
   const [touchOverlayVisible, setTouchOverlayVisible] = useState(() =>
     readStoredFlag(TOUCH_OVERLAY_VISIBLE_STORAGE_KEY, true),
@@ -572,6 +607,12 @@ export function AppShell({
   const zoomAnimationTimeoutRef = useRef<number>(0);
   const touchIndicatorTimeoutRef = useRef<number>(0);
   const gestureStartZoomRef = useRef(1);
+  const screenGestureRef = useRef<SafariScreenGestureState | null>(null);
+  const recentPointerInputMultiTouchAtRef = useRef(0);
+  const cancelPointerGestureForScreenGestureRef = useRef<() => void>(() => {});
+  const scrollAccumulatorRef = useRef<Point>({ x: 0, y: 0 });
+  const scrollFrameRef = useRef<number>(0);
+  const scrollPointRef = useRef<Point>({ x: 0.5, y: 0.5 });
   const effectiveZoomRef = useRef(initialViewportState.zoom ?? 1);
   const panRef = useRef<Point>(initialViewportState.pan);
   const applyZoomAtClientPointRef = useRef<
@@ -614,6 +655,15 @@ export function AppShell({
     setZoomDockElement(node);
   }, []);
 
+  useEffect(() => {
+    return () => {
+      if (scrollFrameRef.current !== 0) {
+        window.cancelAnimationFrame(scrollFrameRef.current);
+        scrollFrameRef.current = 0;
+      }
+    };
+  }, []);
+
   const searchNeedle = search.trim().toLowerCase();
   const filteredSimulators = simulators.filter((simulator) => {
     if (!searchNeedle) {
@@ -1102,6 +1152,10 @@ export function AppShell({
     writeStoredFlag(DEVICE_CHROME_VISIBLE_STORAGE_KEY, deviceChromeVisible);
   }, [deviceChromeVisible]);
 
+  useEffect(() => {
+    writeStoredAccessibilitySkeletonMode(accessibilitySkeletonMode);
+  }, [accessibilitySkeletonMode]);
+
   const toggleDevTools = useCallback(() => {
     setDevToolsVisible((current) => !current);
   }, []);
@@ -1442,16 +1496,23 @@ export function AppShell({
     [accessibilityPreferredSource, updateAccessibilityRoots],
   );
 
+  const accessibilitySkeletonVisible =
+    accessibilitySource === "native-ax" &&
+    (accessibilitySkeletonMode === "always" ||
+      (accessibilitySkeletonMode === "auto" && hierarchyVisible));
+
   useEffect(() => {
-    const refreshMs = hierarchyVisible
-      ? accessibilityPreferredSource === "react-native" ||
-        accessibilitySource === "react-native"
-        ? REACT_NATIVE_ACCESSIBILITY_REFRESH_MS
-        : accessibilityPreferredSource === "flutter" ||
-            accessibilitySource === "flutter"
-          ? FLUTTER_ACCESSIBILITY_REFRESH_MS
-          : ACCESSIBILITY_REFRESH_MS
-      : ACCESSIBILITY_BACKGROUND_REFRESH_MS;
+    const refreshMs = accessibilitySkeletonVisible
+      ? ACCESSIBILITY_SKELETON_REFRESH_MS
+      : hierarchyVisible
+        ? accessibilityPreferredSource === "react-native" ||
+          accessibilitySource === "react-native"
+          ? REACT_NATIVE_ACCESSIBILITY_REFRESH_MS
+          : accessibilityPreferredSource === "flutter" ||
+              accessibilitySource === "flutter"
+            ? FLUTTER_ACCESSIBILITY_REFRESH_MS
+            : ACCESSIBILITY_REFRESH_MS
+        : ACCESSIBILITY_BACKGROUND_REFRESH_MS;
     let disposed = false;
     let timeout: number | null = null;
     const refreshLoop = async () => {
@@ -1475,6 +1536,7 @@ export function AppShell({
   }, [
     accessibilityPreferredSource,
     accessibilitySource,
+    accessibilitySkeletonVisible,
     hierarchyVisible,
     loadAccessibilityTree,
   ]);
@@ -1792,6 +1854,101 @@ export function AppShell({
     };
   }, []);
 
+  useEffect(() => {
+    let edgeTouch: {
+      identifier: number;
+      startX: number;
+      startY: number;
+    } | null = null;
+
+    function touchByIdentifier(touches: TouchList, identifier: number) {
+      for (let index = 0; index < touches.length; index += 1) {
+        const touch = touches.item(index);
+        if (touch?.identifier === identifier) {
+          return touch;
+        }
+      }
+      return null;
+    }
+
+    function handleDocumentTouchStart(event: TouchEvent) {
+      if (event.touches.length !== 1) {
+        edgeTouch = null;
+        return;
+      }
+      const touch = event.touches.item(0);
+      if (!touch) {
+        edgeTouch = null;
+        return;
+      }
+      const viewportWidth = window.visualViewport?.width ?? window.innerWidth;
+      const fromHorizontalEdge =
+        touch.clientX <= BROWSER_EDGE_GESTURE_WIDTH ||
+        touch.clientX >= viewportWidth - BROWSER_EDGE_GESTURE_WIDTH;
+      edgeTouch = fromHorizontalEdge
+        ? {
+            identifier: touch.identifier,
+            startX: touch.clientX,
+            startY: touch.clientY,
+          }
+        : null;
+    }
+
+    function handleDocumentTouchMove(event: TouchEvent) {
+      if (!edgeTouch) {
+        return;
+      }
+      const touch = touchByIdentifier(event.touches, edgeTouch.identifier);
+      if (!touch) {
+        edgeTouch = null;
+        return;
+      }
+      const deltaX = touch.clientX - edgeTouch.startX;
+      const deltaY = touch.clientY - edgeTouch.startY;
+      if (
+        Math.abs(deltaX) >= BROWSER_EDGE_GESTURE_MIN_DELTA &&
+        Math.abs(deltaX) > Math.abs(deltaY)
+      ) {
+        event.preventDefault();
+      }
+    }
+
+    function clearDocumentEdgeTouch() {
+      edgeTouch = null;
+    }
+
+    document.addEventListener("touchstart", handleDocumentTouchStart, {
+      capture: true,
+      passive: false,
+    });
+    document.addEventListener("touchmove", handleDocumentTouchMove, {
+      capture: true,
+      passive: false,
+    });
+    document.addEventListener("touchend", clearDocumentEdgeTouch, {
+      capture: true,
+      passive: true,
+    });
+    document.addEventListener("touchcancel", clearDocumentEdgeTouch, {
+      capture: true,
+      passive: true,
+    });
+    return () => {
+      document.removeEventListener("touchstart", handleDocumentTouchStart, {
+        capture: true,
+      });
+      document.removeEventListener("touchmove", handleDocumentTouchMove, {
+        capture: true,
+      });
+      document.removeEventListener("touchend", clearDocumentEdgeTouch, {
+        capture: true,
+      });
+      document.removeEventListener("touchcancel", clearDocumentEdgeTouch, {
+        capture: true,
+      });
+    };
+  }, []);
+
   useEffect(() => {
     if (!touchOverlayVisible) {
       setTouchIndicators([]);
@@ -1847,6 +2004,7 @@ export function AppShell({
       if (!selectedSimulator) {
         return;
       }
+      recentPointerInputMultiTouchAtRef.current = performance.now();
       if (phase === "began" && accessibilitySelectedId) {
         setAccessibilitySelectedId("");
         setAccessibilityHoveredId(null);
@@ -1867,6 +2025,8 @@ export function AppShell({
     rotationQuarterTurns: viewportRotationQuarterTurns,
     setPan,
   });
+  cancelPointerGestureForScreenGestureRef.current =
+    pointerInput.cancelActiveGestureForExternalMultiTouch;
 
   const pairingRequired =
     !remoteStream &&
@@ -2421,6 +2581,42 @@ export function AppShell({
     applyZoomAtClientPointRef.current = applyZoomAtClientPoint;
   });
 
+  function screenElementForWheel(event: React.WheelEvent<HTMLElement>) {
+    const target = event.target;
+    return target instanceof Element
+      ? (target.closest(".device-screen") as HTMLElement | null)
+      : null;
+  }
+
+  function handleNativeScreenWheel(
+    event: React.WheelEvent<HTMLElement>,
+    deltaX: number,
+    deltaY: number,
+  ): boolean {
+    const screenElement = screenElementForWheel(event);
+    if (!screenElement || !selectedSimulator?.isBooted) {
+      return false;
+    }
+    if (deltaX === 0 && deltaY === 0) {
+      return true;
+    }
+
+    const displayedPoint = normalizedClientCoordinates(
+      screenElement,
+      event.clientX,
+      event.clientY,
+      { clamp: true },
+    );
+    const screenPoint = mapDisplayedPointToNaturalOrientation(
+      displayedPoint ?? { x: 0.5, y: 0.5 },
+      viewportRotationQuarterTurns,
+    );
+    setAccessibilitySelectedId("");
+    setAccessibilityHoveredId(null);
+    sendScrollWheel(deltaX, deltaY, screenPoint.x, screenPoint.y);
+    return true;
+  }
+
   function handleViewportWheel(event: React.WheelEvent<HTMLElement>) {
     if (!selectedSimulator) {
       return;
@@ -2448,6 +2644,10 @@ export function AppShell({
       return;
     }
 
+    if (handleNativeScreenWheel(event, deltaX, deltaY)) {
+      return;
+    }
+
     setPan(
       (currentPan) =>
         nextViewportWheelPanState({
@@ -2467,22 +2667,53 @@ export function AppShell({
     );
   }
 
-  function showTouchIndicator(phase: TouchPhase, coords: Point) {
+  function showTouchIndicator(phase: TouchPhase, coords: TouchPreviewPoint) {
     showTouchIndicators(phase, [coords]);
   }
 
-  function showTouchIndicators(phase: TouchPhase, coords: Point[]) {
+  function showTouchIndicators(phase: TouchPhase, coords: TouchPreviewPoint[]) {
     if (!touchOverlayVisible) {
       return;
     }
 
+    const canvasElement = outerCanvasRef.current ?? outerCanvasElement;
+    const canvasRect = canvasElement?.getBoundingClientRect() ?? null;
     setTouchIndicators(
-      coords.map((coord, index) => ({
-        id: index + 1,
-        phase,
-        x: coord.x,
-        y: coord.y,
-      })),
+      coords.map((coord, index) => {
+        if (
+          canvasRect &&
+          Number.isFinite(coord.pageX) &&
+          Number.isFinite(coord.pageY)
+        ) {
+          return {
+            id: index + 1,
+            phase,
+            space: "canvas",
+            x: (coord.pageX ?? 0) - (canvasRect.left + window.scrollX),
+            y: (coord.pageY ?? 0) - (canvasRect.top + window.scrollY),
+          };
+        }
+        if (
+          canvasRect &&
+          Number.isFinite(coord.clientX) &&
+          Number.isFinite(coord.clientY)
+        ) {
+          return {
+            id: index + 1,
+            phase,
+            space: "canvas",
+            x: (coord.clientX ?? 0) - canvasRect.left,
+            y: (coord.clientY ?? 0) - canvasRect.top,
+          };
+        }
+        return {
+          id: index + 1,
+          phase,
+          space: "screen",
+          x: coord.x,
+          y: coord.y,
+        };
+      }),
     );
     if (touchIndicatorTimeoutRef.current) {
       clearTimeout(touchIndicatorTimeoutRef.current);
@@ -2505,15 +2736,240 @@ export function AppShell({
     type WebKitGestureEvent = Event & {
       clientX?: number;
       clientY?: number;
+      rotation?: number;
       scale?: number;
     };
 
+    function finiteGestureNumber(value: number | undefined, fallback: number) {
+      return typeof value === "number" && Number.isFinite(value)
+        ? value
+        : fallback;
+    }
+
+    function currentBrowserTimestamp() {
+      return performance.now();
+    }
+
+    function clampSafariGestureScale(value: number | undefined) {
+      return Math.min(
+        Math.max(
+          finiteGestureNumber(value, 1),
+          SAFARI_SCREEN_GESTURE_MIN_SCALE,
+        ),
+        SAFARI_SCREEN_GESTURE_MAX_SCALE,
+      );
+    }
+
+    function screenElementForGesture(event: Event): HTMLElement | null {
+      const target = event.target;
+      return target instanceof Element
+        ? (target.closest(".device-screen") as HTMLElement | null)
+        : null;
+    }
+
+    function screenGestureAnchor(
+      screenElement: HTMLElement,
+      event: Event,
+    ): Point & { clientX: number; clientY: number } {
+      const gestureEvent = event as WebKitGestureEvent;
+      const screenRect = screenElement.getBoundingClientRect();
+      let clientX = finiteGestureNumber(
+        gestureEvent.clientX,
+        screenRect.left + screenRect.width / 2,
+      );
+      let clientY = finiteGestureNumber(
+        gestureEvent.clientY,
+        screenRect.top + screenRect.height / 2,
+      );
+      let displayed = normalizedClientCoordinates(
+        screenElement,
+        clientX,
+        clientY,
+        {
+          clamp: false,
+        },
+      );
+      if (
+        !displayed ||
+        displayed.x < -0.25 ||
+        displayed.x > 1.25 ||
+        displayed.y < -0.25 ||
+        displayed.y > 1.25
+      ) {
+        clientX = screenRect.left + screenRect.width / 2;
+        clientY = screenRect.top + screenRect.height / 2;
+        displayed = normalizedClientCoordinates(
+          screenElement,
+          clientX,
+          clientY,
+          {
+            clamp: false,
+          },
+        ) ?? { x: 0.5, y: 0.5 };
+      }
+      return {
+        ...displayed,
+        clientX,
+        clientY,
+      };
+    }
+
+    function previewPointFromClient(
+      screenElement: HTMLElement,
+      clientX: number,
+      clientY: number,
+    ): TouchPreviewPoint | null {
+      const displayed = normalizedClientCoordinates(
+        screenElement,
+        clientX,
+        clientY,
+        {
+          clamp: false,
+        },
+      );
+      return displayed
+        ? {
+            ...displayed,
+            clientX,
+            clientY,
+            pageX: clientX + window.scrollX,
+            pageY: clientY + window.scrollY,
+          }
+        : null;
+    }
+
+    function screenGesturePairFromEvent(
+      screenElement: HTMLElement,
+      event: Event,
+      startRotationDegrees: number,
+    ): SafariScreenGesturePair | null {
+      const gestureEvent = event as WebKitGestureEvent;
+      const screenRect = screenElement.getBoundingClientRect();
+      const anchor = screenGestureAnchor(screenElement, event);
+      const minScreenPixels = Math.max(
+        1,
+        Math.min(screenRect.width, screenRect.height),
+      );
+      const scale = clampSafariGestureScale(gestureEvent.scale);
+      const rotationDegrees =
+        finiteGestureNumber(gestureEvent.rotation, startRotationDegrees) -
+        startRotationDegrees;
+      const radians = (rotationDegrees * Math.PI) / 180;
+      const halfSpreadPixels =
+        (minScreenPixels * SAFARI_SCREEN_GESTURE_INITIAL_SPREAD * scale) / 2;
+      const offsetX = Math.cos(radians) * halfSpreadPixels;
+      const offsetY = Math.sin(radians) * halfSpreadPixels;
+      const firstPreview = previewPointFromClient(
+        screenElement,
+        anchor.clientX + offsetX,
+        anchor.clientY + offsetY,
+      );
+      const secondPreview = previewPointFromClient(
+        screenElement,
+        anchor.clientX - offsetX,
+        anchor.clientY - offsetY,
+      );
+      if (!firstPreview || !secondPreview) {
+        return null;
+      }
+      return {
+        first: mapDisplayedPointToNaturalOrientation(
+          firstPreview,
+          viewportRotationQuarterTurns,
+        ),
+        second: mapDisplayedPointToNaturalOrientation(
+          secondPreview,
+          viewportRotationQuarterTurns,
+        ),
+        firstPreview,
+        secondPreview,
+      };
+    }
+
+    function sendScreenGestureMultiTouch(
+      phase: TouchPhase,
+      state: SafariScreenGestureState,
+      event: Event,
+    ) {
+      if (!selectedSimulator?.isBooted) {
+        return false;
+      }
+      const pair =
+        screenGesturePairFromEvent(
+          state.screenElement,
+          event,
+          state.startRotationDegrees,
+        ) ?? state.lastPair;
+      if (!pair) {
+        return false;
+      }
+      state.lastPair = pair;
+      if (phase === "began" && accessibilitySelectedId) {
+        setAccessibilitySelectedId("");
+        setAccessibilityHoveredId(null);
+      }
+      showTouchIndicators(phase, [pair.firstPreview, pair.secondPreview]);
+      sendControl(selectedSimulator.udid, {
+        type: "multiTouch",
+        x1: pair.first.x,
+        y1: pair.first.y,
+        x2: pair.second.x,
+        y2: pair.second.y,
+        phase,
+      });
+      return true;
+    }
+
     function handleGestureStart(event: Event) {
+      const screenElement = screenElementForGesture(event);
+      if (screenElement) {
+        event.preventDefault();
+        event.stopPropagation();
+        const gestureEvent = event as WebKitGestureEvent;
+        const blockedByPointerInput =
+          currentBrowserTimestamp() -
+            recentPointerInputMultiTouchAtRef.current <
+          REAL_MULTITOUCH_GESTURE_GRACE_MS;
+        const startRotationDegrees = finiteGestureNumber(
+          gestureEvent.rotation,
+          0,
+        );
+        const pair = screenGesturePairFromEvent(
+          screenElement,
+          event,
+          startRotationDegrees,
+        );
+        const state: SafariScreenGestureState = {
+          blockedByPointerInput,
+          lastPair: pair,
+          screenElement,
+          startRotationDegrees,
+        };
+        screenGestureRef.current = state;
+        if (blockedByPointerInput || !pair || !selectedSimulator?.isBooted) {
+          return;
+        }
+        cancelPointerGestureForScreenGestureRef.current();
+        sendScreenGestureMultiTouch("began", state, event);
+        return;
+      }
+
+      screenGestureRef.current = null;
       event.preventDefault();
       gestureStartZoomRef.current = effectiveZoomRef.current;
     }
 
     function handleGestureChange(event: Event) {
+      const screenGesture = screenGestureRef.current;
+      if (screenGesture) {
+        event.preventDefault();
+        event.stopPropagation();
+        if (!screenGesture.blockedByPointerInput) {
+          sendScreenGestureMultiTouch("moved", screenGesture, event);
+        }
+        return;
+      }
+
       event.preventDefault();
       const gestureEvent = event as WebKitGestureEvent;
       const bounds = canvasElement.getBoundingClientRect();
@@ -2524,17 +2980,41 @@ export function AppShell({
       );
     }
 
+    function handleGestureEnd(event: Event) {
+      const screenGesture = screenGestureRef.current;
+      if (screenGesture) {
+        event.preventDefault();
+        event.stopPropagation();
+        if (!screenGesture.blockedByPointerInput) {
+          sendScreenGestureMultiTouch("ended", screenGesture, event);
+        }
+        screenGestureRef.current = null;
+        return;
+      }
+
+      event.preventDefault();
+    }
+
     canvasElement.addEventListener("gesturestart", handleGestureStart, {
       passive: false,
     });
     canvasElement.addEventListener("gesturechange", handleGestureChange, {
       passive: false,
     });
+    canvasElement.addEventListener("gestureend", handleGestureEnd, {
+      passive: false,
+    });
     return () => {
       canvasElement.removeEventListener("gesturestart", handleGestureStart);
       canvasElement.removeEventListener("gesturechange", handleGestureChange);
+      canvasElement.removeEventListener("gestureend", handleGestureEnd);
     };
-  }, [outerCanvasElement]);
+  }, [
+    accessibilitySelectedId,
+    outerCanvasElement,
+    selectedSimulator,
+    viewportRotationQuarterTurns,
+  ]);
 
   function promptForURL() {
     if (!selectedSimulator) {
@@ -2630,6 +3110,95 @@ export function AppShell({
     }
   }
 
+  function flushScrollWheel() {
+    scrollFrameRef.current = 0;
+    const accumulated = scrollAccumulatorRef.current;
+    scrollAccumulatorRef.current = { x: 0, y: 0 };
+    if (accumulated.x === 0 && accumulated.y === 0) {
+      return;
+    }
+
+    const deltaX = clampNumber(
+      accumulated.x,
+      -NATIVE_SCROLL_MAX_DELTA,
+      NATIVE_SCROLL_MAX_DELTA,
+    );
+    const deltaY = clampNumber(
+      accumulated.y,
+      -NATIVE_SCROLL_MAX_DELTA,
+      NATIVE_SCROLL_MAX_DELTA,
+    );
+    const remainingX = accumulated.x - deltaX;
+    const remainingY = accumulated.y - deltaY;
+    if (remainingX !== 0 || remainingY !== 0) {
+      scrollAccumulatorRef.current = { x: remainingX, y: remainingY };
+      scrollFrameRef.current = window.requestAnimationFrame(flushScrollWheel);
+    }
+
+    sendScrollWheelNow(
+      deltaX,
+      deltaY,
+      scrollPointRef.current.x,
+      scrollPointRef.current.y,
+    );
+  }
+
+  function sendScrollWheel(
+    deltaX: number,
+    deltaY: number,
+    x: number,
+    y: number,
+  ) {
+    if (
+      !Number.isFinite(deltaX) ||
+      !Number.isFinite(deltaY) ||
+      (deltaX === 0 && deltaY === 0)
+    ) {
+      return;
+    }
+
+    scrollPointRef.current = {
+      x: Number.isFinite(x) ? clampNumber(x, 0, 1) : 0.5,
+      y: Number.isFinite(y) ? clampNumber(y, 0, 1) : 0.5,
+    };
+    scrollAccumulatorRef.current = {
+      x: scrollAccumulatorRef.current.x + deltaX * NATIVE_SCROLL_DELTA_SCALE,
+      y: scrollAccumulatorRef.current.y + deltaY * NATIVE_SCROLL_DELTA_SCALE,
+    };
+    if (scrollFrameRef.current === 0) {
+      scrollFrameRef.current = window.requestAnimationFrame(flushScrollWheel);
+    }
+  }
+
+  function sendScrollWheelNow(
+    deltaX: number,
+    deltaY: number,
+    x: number,
+    y: number,
+  ) {
+    if (
+      !selectedSimulator ||
+      !Number.isFinite(deltaX) ||
+      !Number.isFinite(deltaY) ||
+      !Number.isFinite(x) ||
+      !Number.isFinite(y) ||
+      (deltaX === 0 && deltaY === 0)
+    ) {
+      return;
+    }
+    if (
+      !sendControl(selectedSimulator.udid, {
+        type: "scroll",
+        deltaX,
+        deltaY,
+        x: clampNumber(x, 0, 1),
+        y: clampNumber(y, 0, 1),
+      })
+    ) {
+      setLocalError("Simulator control stream disconnected.");
+    }
+  }
+
   function prepareSimulatorInput() {
     setMenuOpen(false);
     setAccessibilitySelectedId("");
@@ -2890,6 +3459,7 @@ export function AppShell({
         type="file"
       />
       <Toolbar
+        accessibilitySkeletonMode={accessibilitySkeletonMode}
         captureBusy={Boolean(captureStatus?.busy)}
         canInstallApp={canInstallApp}
         closeMenu={() => setMenuOpen(false)}
@@ -3012,6 +3582,7 @@ export function AppShell({
         onToggleTouchOverlay={() =>
           setTouchOverlayVisible((current) => !current)
         }
+        onAccessibilitySkeletonModeChange={setAccessibilitySkeletonMode}
         recordingActive={screenRecording?.phase === "recording"}
         recordingStopping={screenRecording?.phase === "stopping"}
         remoteStream={remoteStream}
@@ -3083,6 +3654,7 @@ export function AppShell({
         accessibilityPickerActive={accessibilityPickerActive}
         accessibilityRoots={accessibilityRoots}
         accessibilitySelectedId={accessibilitySelectedId}
+        accessibilitySkeletonVisible={accessibilitySkeletonVisible}
         chromeLoaded={chromeLoaded}
         chromeProfile={viewportChromeProfile}
         chromeRequired={chromeRequired}
@@ -3120,6 +3692,14 @@ export function AppShell({
         onAppInstallDragOver={handleAppInstallDragOver}
         onAppInstallDrop={handleAppInstallDrop}
         onChromeButtonEvent={sendHardwareButtonEvent}
+        onBottomBezelPointerCancel={pointerInput.handleBottomBezelPointerCancel}
+        onBottomBezelPointerDown={pointerInput.handleBottomBezelPointerDown}
+        onBottomBezelPointerMove={pointerInput.handleBottomBezelPointerMove}
+        onBottomBezelPointerUp={pointerInput.handleBottomBezelPointerUp}
+        onBottomBezelTouchCancel={pointerInput.handleBottomBezelTouchCancel}
+        onBottomBezelTouchEnd={pointerInput.handleBottomBezelTouchEnd}
+        onBottomBezelTouchMove={pointerInput.handleBottomBezelTouchMove}
+        onBottomBezelTouchStart={pointerInput.handleBottomBezelTouchStart}
         onPanPointerMove={pointerInput.handlePanPointerMove}
         onPanPointerUp={pointerInput.handlePanPointerUp}
         onPickerHover={setAccessibilityHoveredId}
@@ -3133,6 +3713,10 @@ export function AppShell({
         onScreenPointerDown={pointerInput.handleScreenPointerDown}
         onScreenPointerMove={pointerInput.handleScreenPointerMove}
         onScreenPointerUp={pointerInput.handleScreenPointerUp}
+        onScreenTouchCancel={pointerInput.handleScreenTouchCancel}
+        onScreenTouchEnd={pointerInput.handleScreenTouchEnd}
+        onScreenTouchMove={pointerInput.handleScreenTouchMove}
+        onScreenTouchStart={pointerInput.handleScreenTouchStart}
         onStartPanning={pointerInput.startPanning}
         onViewportWheel={handleViewportWheel}
         onZoomActual={() =>
diff --git a/packages/client/src/app/controlMessages.test.ts b/packages/client/src/app/controlMessages.test.ts
index e77c1b87..0bf41e6a 100644
--- a/packages/client/src/app/controlMessages.test.ts
+++ b/packages/client/src/app/controlMessages.test.ts
@@ -42,6 +42,9 @@ describe("controlMessages", () => {
         phase: "ended",
       }),
     ).toBe(false);
+    expect(
+      isMoveControlMessage({ type: "scroll", deltaX: 0, deltaY: 42 }),
+    ).toBe(false);
     expect(isMoveControlMessage({ type: "home" })).toBe(false);
   });
 });
diff --git a/packages/client/src/app/uiState.test.ts b/packages/client/src/app/uiState.test.ts
index c0dae8b4..b69c5119 100644
--- a/packages/client/src/app/uiState.test.ts
+++ b/packages/client/src/app/uiState.test.ts
@@ -4,6 +4,7 @@ import {
   DEFAULT_VIEWPORT_STATE,
   nextAccessibilitySourcePreference,
   preferredRicherAccessibilitySource,
+  readStoredAccessibilitySkeletonMode,
   readStoredFlag,
   sanitizeAccessibilitySources,
   sanitizePersistedUiState,
@@ -240,4 +241,8 @@ describe("uiState", () => {
   it("uses the supplied stored-flag default outside the browser", () => {
     expect(readStoredFlag("missing-flag", true)).toBe(true);
   });
+
+  it("defaults accessibility skeleton frames to auto outside the browser", () => {
+    expect(readStoredAccessibilitySkeletonMode()).toBe("auto");
+  });
 });
diff --git a/packages/client/src/app/uiState.ts b/packages/client/src/app/uiState.ts
index 084f9300..6069c192 100644
--- a/packages/client/src/app/uiState.ts
+++ b/packages/client/src/app/uiState.ts
@@ -2,6 +2,10 @@ import type {
   AccessibilitySource,
   AccessibilitySourcePreference,
 } from "../api/types";
+import {
+  isAccessibilitySkeletonMode,
+  type AccessibilitySkeletonMode,
+} from "../features/accessibility/skeletonMode";
 import type { Point, ViewMode } from "../features/viewport/types";
 
 export interface PersistedViewportState {
@@ -29,6 +33,8 @@ export const WEBKIT_INSPECTOR_VISIBLE_STORAGE_KEY =
 export const CHROME_DEVTOOLS_VISIBLE_STORAGE_KEY =
   "xcw-chrome-devtools-visible";
 export const ACCESSIBILITY_SOURCE_STORAGE_KEY = "xcw-hierarchy-source";
+export const ACCESSIBILITY_SKELETON_MODE_STORAGE_KEY =
+  "xcw-accessibility-skeleton-mode";
 export const TOUCH_OVERLAY_VISIBLE_STORAGE_KEY = "xcw-touch-overlay-visible";
 export const DEVICE_CHROME_VISIBLE_STORAGE_KEY = "xcw-device-chrome-visible";
 
@@ -111,6 +117,27 @@ export function readStoredAccessibilitySource(): AccessibilitySourcePreference {
   return source === "auto" || isAccessibilitySource(source) ? source : "auto";
 }
 
+export function readStoredAccessibilitySkeletonMode(): AccessibilitySkeletonMode {
+  if (typeof window === "undefined") {
+    return "auto";
+  }
+
+  const mode = window.localStorage.getItem(
+    ACCESSIBILITY_SKELETON_MODE_STORAGE_KEY,
+  );
+  return isAccessibilitySkeletonMode(mode) ? mode : "auto";
+}
+
+export function writeStoredAccessibilitySkeletonMode(
+  mode: AccessibilitySkeletonMode,
+): void {
+  if (typeof window === "undefined") {
+    return;
+  }
+
+  window.localStorage.setItem(ACCESSIBILITY_SKELETON_MODE_STORAGE_KEY, mode);
+}
+
 export function sanitizeAccessibilitySources(
   value: unknown,
 ): AccessibilitySource[] {
diff --git a/packages/client/src/features/accessibility/AccessibilityOverlay.test.ts b/packages/client/src/features/accessibility/AccessibilityOverlay.test.ts
index c9880849..08b071ac 100644
--- a/packages/client/src/features/accessibility/AccessibilityOverlay.test.ts
+++ b/packages/client/src/features/accessibility/AccessibilityOverlay.test.ts
@@ -103,4 +103,30 @@ describe("AccessibilityOverlay", () => {
     expect(markup).not.toContain("; disabled");
     expect(markup).not.toContain(" title=");
   });
+
+  it("draws label-free skeleton frames when requested", () => {
+    const markup = renderToStaticMarkup(
+      createElement(AccessibilityOverlay, {
+        hoveredId: null,
+        roots: [
+          {
+            frame: { height: 844, width: 390, x: 0, y: 0 },
+            role: "application",
+            children: [
+              {
+                AXLabel: "Continue",
+                frame: { height: 48, width: 180, x: 105, y: 720 },
+                type: "Button",
+              },
+            ],
+          },
+        ],
+        selectedId: "",
+        skeletonVisible: true,
+      }),
+    );
+
+    expect(markup).toContain("accessibility-rect skeleton");
+    expect(markup).not.toContain("<span>Continue</span>");
+  });
 });
diff --git a/packages/client/src/features/accessibility/AccessibilityOverlay.tsx b/packages/client/src/features/accessibility/AccessibilityOverlay.tsx
index 8e1adcae..9c8e4d6e 100644
--- a/packages/client/src/features/accessibility/AccessibilityOverlay.tsx
+++ b/packages/client/src/features/accessibility/AccessibilityOverlay.tsx
@@ -17,12 +17,14 @@ interface AccessibilityOverlayProps {
   hoveredId: string | null;
   roots: AccessibilityNode[];
   selectedId: string;
+  skeletonVisible?: boolean;
 }
 
 export function AccessibilityOverlay({
   hoveredId,
   roots,
   selectedId,
+  skeletonVisible = false,
 }: AccessibilityOverlayProps) {
   const rootFrame = accessibilityRootFrame(roots);
   const tree = buildAccessibilityTree(roots);
@@ -63,6 +65,16 @@ export function AccessibilityOverlay({
         ))}
       </div>
       <div className="accessibility-visual-overlay" aria-hidden="true">
+        {skeletonVisible
+          ? overlayItems.map((item) => (
+              <NodeRect
+                key={`skeleton-${item.id}`}
+                node={item.node}
+                rootFrame={rootFrame}
+                variant="skeleton"
+              />
+            ))
+          : null}
         {hovered ? (
           <NodeRect node={hovered} rootFrame={rootFrame} variant="hovered" />
         ) : null}
@@ -99,7 +111,7 @@ function NodeRect({
 }: {
   node: AccessibilityNode;
   rootFrame: { height: number; width: number; x: number; y: number };
-  variant: "hovered" | "selected";
+  variant: "hovered" | "selected" | "skeleton";
 }) {
   if (!validFrame(node.frame)) {
     return null;
@@ -109,7 +121,10 @@ function NodeRect({
   const top = ((node.frame.y - rootFrame.y) / rootFrame.height) * 100;
   const width = (node.frame.width / rootFrame.width) * 100;
   const height = (node.frame.height / rootFrame.height) * 100;
-  const label = primaryAccessibilityText(node) || accessibilityKind(node);
+  const label =
+    variant === "skeleton"
+      ? ""
+      : primaryAccessibilityText(node) || accessibilityKind(node);
 
   return (
     <div
@@ -121,7 +136,7 @@ function NodeRect({
         width: `${width}%`,
       }}
     >
-      <span>{label}</span>
+      {label ? <span>{label}</span> : null}
     </div>
   );
 }
diff --git a/packages/client/src/features/accessibility/skeletonMode.ts b/packages/client/src/features/accessibility/skeletonMode.ts
new file mode 100644
index 00000000..62069293
--- /dev/null
+++ b/packages/client/src/features/accessibility/skeletonMode.ts
@@ -0,0 +1,13 @@
+export type AccessibilitySkeletonMode = "auto" | "always" | "off";
+
+export const ACCESSIBILITY_SKELETON_MODES: AccessibilitySkeletonMode[] = [
+  "auto",
+  "always",
+  "off",
+];
+
+export function isAccessibilitySkeletonMode(
+  value: unknown,
+): value is AccessibilitySkeletonMode {
+  return value === "auto" || value === "always" || value === "off";
+}
diff --git a/packages/client/src/features/devtools/DevToolsPanel.test.ts b/packages/client/src/features/devtools/DevToolsPanel.test.ts
index 472c7a76..83ceae35 100644
--- a/packages/client/src/features/devtools/DevToolsPanel.test.ts
+++ b/packages/client/src/features/devtools/DevToolsPanel.test.ts
@@ -86,6 +86,27 @@ describe("resolveDevToolsTargetSelection", () => {
     });
   });
 
+  it("ignores malformed Safari target strings while building the auto target", () => {
+    const malformed = safariTarget("webkit:malformed", "https://bad.example/", {
+      appName: { name: "Safari" } as unknown as string,
+      bundleIdentifier: 42 as unknown as string,
+      frameUrl: 12 as unknown as string,
+      url: { href: "https://bad.example/" } as unknown as string,
+    });
+
+    expect(() =>
+      withSafariAutoTarget([malformed], "bad.example"),
+    ).not.toThrow();
+    expect(withSafariAutoTarget([malformed], "bad.example")[0]).toMatchObject({
+      appName: "Safari",
+      bundleIdentifier: "com.apple.mobilesafari",
+      frameUrl: "",
+      id: "webkit:safari:auto",
+      meta: "Latest Safari tab",
+      url: null,
+    });
+  });
+
   it("uses Safari auto when Safari is foreground and selection is automatic", () => {
     const inactive = safariTarget("webkit:old", "https://old.example/");
     const active = safariTarget("webkit:active", "https://active.example/", {
@@ -96,7 +117,7 @@ describe("resolveDevToolsTargetSelection", () => {
     expect(
       resolveDevToolsTargetSelection({
         currentForegroundKey: "com.apple.mobilesafari",
-        currentTargetId: inactive.id,
+        currentTargetId: "",
         foregroundApp: {
           appName: "MobileSafari",
           bundleIdentifier: "com.apple.mobilesafari",
@@ -107,8 +128,9 @@ describe("resolveDevToolsTargetSelection", () => {
         pendingForegroundKey: "",
         targets,
       }),
-    ).toMatchObject({
+    ).toEqual({
       automaticTargetId: "webkit:safari:auto",
+      shouldClearPendingForeground: false,
       targetId: "webkit:safari:auto",
     });
   });
@@ -209,6 +231,38 @@ describe("resolveDevToolsTargetSelection", () => {
       targetId: metroTarget.id,
     });
   });
+
+  it("does not throw when foreground app metadata is not string-shaped", () => {
+    const runtimeTarget: DevToolsTarget = {
+      appName: { name: "Example" } as unknown as string,
+      bundleIdentifier: 123 as unknown as string,
+      frameUrl: "/chrome-devtools-ui/inspector.html",
+      id: "chrome:sdi-123",
+      meta: "com.example.app",
+      processIdentifier: 123,
+      source: "React Native",
+      title: { title: "Example" } as unknown as string,
+    };
+    const selectionInput = {
+      currentForegroundKey: "pid:123",
+      currentTargetId: "",
+      foregroundApp: {
+        appName: { name: "Example" } as unknown as string,
+        bundleIdentifier: 456 as unknown as string,
+        processIdentifier: 123,
+      },
+      manualOverride: false,
+      pendingForegroundApp: null,
+      pendingForegroundKey: "",
+      targets: [runtimeTarget],
+    };
+
+    expect(() => resolveDevToolsTargetSelection(selectionInput)).not.toThrow();
+    expect(resolveDevToolsTargetSelection(selectionInput)).toMatchObject({
+      automaticTargetId: runtimeTarget.id,
+      targetId: runtimeTarget.id,
+    });
+  });
 });
 
 describe("shouldRemountWebKitFrameForHealth", () => {
diff --git a/packages/client/src/features/devtools/DevToolsPanel.tsx b/packages/client/src/features/devtools/DevToolsPanel.tsx
index a56e3af6..cba6b2b1 100644
--- a/packages/client/src/features/devtools/DevToolsPanel.tsx
+++ b/packages/client/src/features/devtools/DevToolsPanel.tsx
@@ -181,15 +181,15 @@ export function DevToolsPanel({
 
   const targets = discovery?.targets ?? [];
   const selectedTarget = useMemo(() => {
-    if (targets.length === 0) {
+    if (!selectedTargetId || targets.length === 0) {
       return null;
     }
-    return (
-      targets.find((target) => target.id === selectedTargetId) ?? targets[0]
-    );
+    return targets.find((target) => target.id === selectedTargetId) ?? null;
   }, [selectedTargetId, targets]);
+  const showTargetOverview =
+    overviewVisible || (!selectedTarget && targets.length > 0);
   const frameUrl =
-    visible && !overviewVisible ? (selectedTarget?.frameUrl ?? "") : "";
+    visible && !showTargetOverview ? (selectedTarget?.frameUrl ?? "") : "";
 
   useEffect(() => {
     panelWidthRef.current = panelWidth;
@@ -449,7 +449,9 @@ export function DevToolsPanel({
           pendingForegroundKeyRef.current = "";
           pendingForegroundAppRef.current = null;
         }
-        if (selection.automaticTargetId && !overviewPinnedRef.current) {
+        if (!selection.targetId && discoverableTargets.length > 0) {
+          setOverviewVisible(true);
+        } else if (selection.automaticTargetId && !overviewPinnedRef.current) {
           setOverviewVisible(false);
         }
         applySelectedTargetId(selection.targetId);
@@ -526,6 +528,7 @@ export function DevToolsPanel({
       !visible ||
       !selectedSimulator?.isBooted ||
       !selectedSimulator.udid ||
+      selectedTargetIdRef.current !== SAFARI_AUTO_TARGET_ID ||
       manualTargetSelectionRef.current ||
       loadingActiveWebKitUrlRef.current
     ) {
@@ -863,27 +866,26 @@ export function DevToolsPanel({
     ? NOT_CONNECTED_MESSAGE
     : chromeDevToolsBlocked
       ? "Chrome DevTools don't work in Safari"
-      : error ||
-        (!selectedSimulator
-          ? "No simulator selected."
-          : isDiscoveringTargets && targets.length === 0
-            ? "Connecting..."
-            : safariAutoWaiting
-              ? "Finding current Safari tab..."
-              : targets.length === 0
-                ? selectedSimulator.isBooted
-                  ? "No DevTools targets. Open Safari, enable inspectable WKWebViews, start Metro, or launch a Chrome remote debugging target."
-                  : "No DevTools targets. Boot the simulator for Safari/WebKit, or start Metro or Chrome remote debugging."
-                : "");
+      : targets.length > 0 && !selectedTarget
+        ? "Select a DevTools target."
+        : error ||
+          (!selectedSimulator
+            ? "No simulator selected."
+            : isDiscoveringTargets && targets.length === 0
+              ? "Connecting..."
+              : safariAutoWaiting
+                ? "Finding current Safari tab..."
+                : targets.length === 0
+                  ? selectedSimulator.isBooted
+                    ? "No DevTools targets. Open Safari, enable inspectable WKWebViews, start Metro, or launch a Chrome remote debugging target."
+                    : "No DevTools targets. Boot the simulator for Safari/WebKit, or start Metro or Chrome remote debugging."
+                  : "");
   const emptyOverviewMessage = effectivelyDisconnected
     ? NOT_CONNECTED_MESSAGE
     : isDiscoveringTargets
       ? "Connecting..."
       : "No targets";
   const frameStatusMessage = webKitFrameStatusMessage(frameHealth);
-  const displayWarnings = selectedSimulator?.isBooted
-    ? (discovery?.warnings ?? []).filter(shouldDisplayDevToolsWarning)
-    : [];
   const panelStyle = {
     "--webkit-panel-width": `${panelWidth}px`,
   } as CSSProperties;
@@ -916,7 +918,7 @@ export function DevToolsPanel({
       <div className="webkit-targetbar">
         <button
           aria-label="DevTools Home"
-          className={`tbtn icon-btn ${overviewVisible ? "active" : ""}`}
+          className={`tbtn icon-btn ${showTargetOverview ? "active" : ""}`}
           onClick={showOverview}
           title="DevTools Home"
           type="button"
@@ -937,11 +939,14 @@ export function DevToolsPanel({
               {isDiscoveringTargets ? "Connecting..." : "No targets"}
             </option>
           ) : (
-            targets.map((target) => (
-              <option key={target.id} value={target.id}>
-                {targetLabel(target)}
-              </option>
-            ))
+            <>
+              {selectedTarget ? null : <option value="">Select target</option>}
+              {targets.map((target) => (
+                <option key={target.id} value={target.id}>
+                  {targetLabel(target)}
+                </option>
+              ))}
+            </>
           )}
         </select>
         <button
@@ -974,7 +979,7 @@ export function DevToolsPanel({
         </button>
       </div>
 
-      {selectedTarget && !overviewVisible ? (
+      {selectedTarget && !showTargetOverview ? (
         <div className="webkit-target-meta">
           <span>{selectedTarget.source}</span>
           {selectedTarget.meta ? <span>{selectedTarget.meta}</span> : null}
@@ -986,7 +991,7 @@ export function DevToolsPanel({
           <div className={`webkit-status ${error ? "error" : ""}`}>
             {statusMessage}
           </div>
-        ) : overviewVisible ? (
+        ) : showTargetOverview ? (
           <DevToolsOverview
             emptyMessage={emptyOverviewMessage}
             targets={targets}
@@ -1020,14 +1025,6 @@ export function DevToolsPanel({
           </div>
         )}
       </div>
-
-      {displayWarnings.length ? (
-        <div className="webkit-warnings">
-          {displayWarnings.map((warning) => (
-            <div key={warning}>{warning}</div>
-          ))}
-        </div>
-      ) : null}
     </aside>
   );
 }
@@ -1076,33 +1073,42 @@ function DevToolsOverview({
 }
 
 function mapChromeTarget(target: ChromeDevToolsTarget): DevToolsTarget {
+  const appName = nullableString(target.appName);
+  const bundleIdentifier = nullableString(target.bundleIdentifier);
+  const id = trimmedString(target.id) || String(target.processIdentifier);
+  const url = trimmedString(target.url);
   const source = sourceLabel(target.source);
   return {
-    appName: target.appName ?? null,
-    bundleIdentifier: target.bundleIdentifier ?? null,
+    appName,
+    bundleIdentifier,
     frameUrl: buildChromeDevToolsFrameUrl(target),
-    id: `chrome:${target.id}`,
-    meta: target.bundleIdentifier ?? target.url,
-    processIdentifier: target.processIdentifier,
+    id: `chrome:${id}`,
+    meta: bundleIdentifier ?? url,
+    processIdentifier: finiteNumber(target.processIdentifier),
     source,
     title: chromeTargetLabel(target),
   };
 }
 
 function mapWebKitTarget(target: WebKitTarget): DevToolsTarget {
+  const appId = trimmedString(target.appId);
+  const appName = nullableString(target.appName);
+  const pageId = finiteNumber(target.pageId);
+  const id = trimmedString(target.id) || appId || String(pageId ?? "unknown");
+  const url = nullableString(target.url);
   return {
-    appId: target.appId,
-    appActive: target.appActive ?? false,
-    appName: target.appName ?? null,
+    appId,
+    appActive: target.appActive === true,
+    appName,
     frameUrl: buildWebKitInspectorFrameUrl(target),
-    id: `webkit:${target.id}`,
-    meta: target.url ?? "",
-    pageActive: target.pageActive ?? false,
-    pageId: target.pageId,
+    id: `webkit:${id}`,
+    meta: url ?? "",
+    pageActive: target.pageActive === true,
+    pageId: pageId ?? undefined,
     processIdentifier: webKitTargetProcessIdentifier(target),
     source: webKitTargetKindLabel(target),
     title: webKitTargetLabel(target),
-    url: target.url ?? null,
+    url,
   };
 }
 
@@ -1128,21 +1134,22 @@ export function withSafariAutoTarget(
     .sort((left, right) => (right.pageId ?? 0) - (left.pageId ?? 0))[0];
   const fallbackTarget = activeTarget ?? newestTarget ?? safariTargets[0];
   const autoTarget: DevToolsTarget = {
-    appId: fallbackTarget?.appId ?? "com.apple.mobilesafari",
+    appId: nullableString(fallbackTarget?.appId) ?? "com.apple.mobilesafari",
     appActive: safariTargets.some((target) => target.appActive),
-    appName: fallbackTarget?.appName ?? "Safari",
+    appName: nullableString(fallbackTarget?.appName) ?? "Safari",
     bundleIdentifier:
-      fallbackTarget?.bundleIdentifier ?? "com.apple.mobilesafari",
-    frameUrl: fallbackTarget?.frameUrl ?? "",
+      nullableString(fallbackTarget?.bundleIdentifier) ??
+      "com.apple.mobilesafari",
+    frameUrl: trimmedString(fallbackTarget?.frameUrl),
     id: SAFARI_AUTO_TARGET_ID,
-    meta: fallbackTarget?.url ?? "Latest Safari tab",
+    meta: nullableString(fallbackTarget?.url) ?? "Latest Safari tab",
     pageActive: Boolean(activeTarget),
-    pageId: fallbackTarget?.pageId,
-    processIdentifier: fallbackTarget?.processIdentifier ?? null,
+    pageId: finiteNumber(fallbackTarget?.pageId) ?? undefined,
+    processIdentifier: finiteNumber(fallbackTarget?.processIdentifier),
     safariAuto: true,
     source: "Safari",
     title: "Auto",
-    url: fallbackTarget?.url ?? null,
+    url: nullableString(fallbackTarget?.url),
   };
   return [autoTarget, ...concreteTargets];
 }
@@ -1157,6 +1164,7 @@ export function resolveDevToolsTargetSelection({
   targets,
 }: DevToolsTargetSelectionInput): DevToolsTargetSelection {
   const currentTarget = targets.find((target) => target.id === currentTargetId);
+  const automaticCandidates = targets.filter(canAutoOpenDevToolsTarget);
   if (manualOverride) {
     return {
       automaticTargetId: "",
@@ -1186,13 +1194,13 @@ export function resolveDevToolsTargetSelection({
   const compatibleTarget =
     pendingForegroundApp && pendingForegroundMatches
       ? highlyCompatibleTargetForForeground(
-          targets,
+          automaticCandidates,
           pendingForegroundApp,
           currentTargetId,
         )
       : foregroundApp
         ? highlyCompatibleTargetForForeground(
-            targets,
+            automaticCandidates,
             foregroundApp,
             currentTargetId,
           )
@@ -1202,10 +1210,18 @@ export function resolveDevToolsTargetSelection({
   return {
     automaticTargetId: automaticTarget?.id ?? "",
     shouldClearPendingForeground: Boolean(compatibleTarget),
-    targetId: automaticTarget?.id || currentTarget?.id || targets[0]?.id || "",
+    targetId:
+      automaticTarget?.id ||
+      currentTarget?.id ||
+      automaticCandidates[0]?.id ||
+      "",
   };
 }
 
+function canAutoOpenDevToolsTarget(target: DevToolsTarget): boolean {
+  return !isWebKitTarget(target);
+}
+
 function highlyCompatibleTargetForForeground(
   targets: DevToolsTarget[],
   foregroundApp: ChromeDevToolsTargetDiscovery["foregroundApp"],
@@ -1238,7 +1254,7 @@ function bestWebKitTargetForUrlHint(
   targets: DevToolsTarget[],
   urlHint: string,
 ): DevToolsTarget | null {
-  const hint = urlHint.trim();
+  const hint = trimmedString(urlHint);
   if (!hint) {
     return null;
   }
@@ -1257,7 +1273,7 @@ function safariActiveUrlMatchScore(
   urlHint: string,
   target: DevToolsTarget,
 ): number {
-  const targetUrl = target.url?.trim() ?? "";
+  const targetUrl = trimmedString(target.url);
   if (!targetUrl) {
     return 0;
   }
@@ -1289,9 +1305,12 @@ function foregroundCompatibilityScore(
   foregroundApp: NonNullable<ChromeDevToolsTargetDiscovery["foregroundApp"]>,
 ): number {
   let score = 0;
-  const foregroundBundle = foregroundApp.bundleIdentifier?.trim() ?? "";
-  const foregroundAppName = foregroundApp.appName?.trim() ?? "";
+  const foregroundBundle = trimmedString(foregroundApp.bundleIdentifier);
+  const foregroundAppName = trimmedString(foregroundApp.appName);
   const foregroundPid = foregroundApp.processIdentifier;
+  const targetAppName = trimmedString(target.appName);
+  const targetBundle = trimmedString(target.bundleIdentifier);
+  const targetTitle = trimmedString(target.title);
   const webKitMatchesForeground =
     isWebKitTarget(target) &&
     webKitTargetMatchesForegroundApp(target, foregroundApp);
@@ -1304,15 +1323,15 @@ function foregroundCompatibilityScore(
     score = Math.max(score, isWebKitTarget(target) ? 100 : 92);
   }
 
-  if (foregroundBundle && target.bundleIdentifier === foregroundBundle) {
+  if (foregroundBundle && targetBundle === foregroundBundle) {
     score = Math.max(score, target.source === "React Native Metro" ? 98 : 90);
   }
 
   if (
     foregroundAppName &&
-    (target.appName === foregroundAppName ||
-      target.title === foregroundAppName ||
-      target.title.startsWith(`${foregroundAppName}:`))
+    (targetAppName === foregroundAppName ||
+      targetTitle === foregroundAppName ||
+      targetTitle.startsWith(`${foregroundAppName}:`))
   ) {
     score = Math.max(score, target.source === "React Native Metro" ? 94 : 86);
   }
@@ -1342,8 +1361,8 @@ function foregroundCompatibilityScore(
   if (
     foregroundAppName &&
     isWebKitTarget(target) &&
-    (target.appName === foregroundAppName ||
-      target.title.startsWith(`${foregroundAppName}:`))
+    (targetAppName === foregroundAppName ||
+      targetTitle.startsWith(`${foregroundAppName}:`))
   ) {
     score = Math.max(score, 88);
   }
@@ -1368,11 +1387,13 @@ function webKitTargetMatchesForegroundApp(
     return true;
   }
 
-  const foregroundAppName = foregroundApp.appName?.trim();
+  const foregroundAppName = trimmedString(foregroundApp.appName);
+  const targetAppName = trimmedString(target.appName);
+  const targetTitle = trimmedString(target.title);
   return Boolean(
     foregroundAppName &&
-    (target.appName === foregroundAppName ||
-      target.title.startsWith(`${foregroundAppName}:`)),
+    (targetAppName === foregroundAppName ||
+      targetTitle.startsWith(`${foregroundAppName}:`)),
   );
 }
 
@@ -1383,8 +1404,8 @@ function foregroundAppKey(
     return "";
   }
   return (
-    foregroundApp.bundleIdentifier?.trim() ||
-    foregroundApp.appName?.trim() ||
+    trimmedString(foregroundApp.bundleIdentifier) ||
+    trimmedString(foregroundApp.appName) ||
     `pid:${foregroundApp.processIdentifier}`
   );
 }
@@ -1400,10 +1421,12 @@ function isSafariForegroundApp(
 function isSafariForeground(
   foregroundApp: NonNullable<ChromeDevToolsTargetDiscovery["foregroundApp"]>,
 ): boolean {
+  const bundleIdentifier = trimmedString(foregroundApp.bundleIdentifier);
+  const appName = trimmedString(foregroundApp.appName);
   return (
-    foregroundApp.bundleIdentifier === "com.apple.mobilesafari" ||
-    foregroundApp.appName === "Safari" ||
-    foregroundApp.appName === "MobileSafari"
+    bundleIdentifier === "com.apple.mobilesafari" ||
+    appName === "Safari" ||
+    appName === "MobileSafari"
   );
 }
 
@@ -1510,9 +1533,8 @@ function sanitizeActiveUrlHint(value: unknown): string {
     : "";
 }
 
-function normalizedUrlKey(value: string): string {
-  let key = value
-    .trim()
+function normalizedUrlKey(value: unknown): string {
+  let key = trimmedString(value)
     .replace(/^"|"$/g, "")
     .replace(/\/+$/g, "")
     .toLowerCase();
@@ -1528,7 +1550,7 @@ function normalizedUrlKey(value: string): string {
   return key.replace(/\/+$/g, "");
 }
 
-function normalizedUrlHost(value: string): string {
+function normalizedUrlHost(value: unknown): string {
   return (
     normalizedUrlKey(value)
       .split(/[/?#]/, 1)[0]
@@ -1765,11 +1787,12 @@ function buildWebKitInspectorFrameUrl(target: WebKitTarget): string {
   return url.toString();
 }
 
-function frontendUrl(value: string): URL {
-  if (value.startsWith("http://") || value.startsWith("https://")) {
-    return new URL(value);
+function frontendUrl(value: unknown): URL {
+  const url = trimmedString(value);
+  if (url.startsWith("http://") || url.startsWith("https://")) {
+    return new URL(url);
   }
-  return new URL(apiUrl(value), window.location.href);
+  return new URL(apiUrl(url), window.location.href);
 }
 
 function normalizeWebSocketUrl(
@@ -1807,15 +1830,17 @@ function devToolsSocketParam(socketUrl: URL): string {
 }
 
 function targetLabel(target: DevToolsTarget): string {
-  if (target.title.startsWith(`${target.source}:`)) {
-    return target.title;
+  const source = trimmedString(target.source) || "DevTools";
+  const title = trimmedString(target.title) || "Untitled";
+  if (title.startsWith(`${source}:`)) {
+    return title;
   }
-  return `${target.source}: ${target.title}`;
+  return `${source}: ${title}`;
 }
 
 function chromeTargetLabel(target: ChromeDevToolsTarget): string {
-  const title = target.title?.trim();
-  const appName = target.appName?.trim();
+  const title = trimmedString(target.title);
+  const appName = trimmedString(target.appName);
   if (title && appName && !title.includes(appName)) {
     return `${appName}: ${title}`;
   }
@@ -1823,17 +1848,17 @@ function chromeTargetLabel(target: ChromeDevToolsTarget): string {
 }
 
 function webKitTargetLabel(target: WebKitTarget): string {
-  const title = target.title?.trim();
-  const url = target.url?.trim();
-  const appName = target.appName?.trim();
+  const title = trimmedString(target.title);
+  const url = trimmedString(target.url);
+  const appName = trimmedString(target.appName);
   if (title && appName) {
     return `${appName}: ${title}`;
   }
   return title || url || appName || `Page ${target.pageId}`;
 }
 
-function sourceLabel(source: string): string {
-  switch (source) {
+function sourceLabel(source: unknown): string {
+  switch (trimmedString(source)) {
     case "react-native":
       return "React Native";
     case "react-native-metro":
@@ -1852,20 +1877,34 @@ function sourceLabel(source: string): string {
 }
 
 function webKitTargetKindLabel(target: WebKitTarget): string {
-  if (target.kind === "safari-page" || target.appName === "Safari") {
+  const appName = trimmedString(target.appName);
+  if (target.kind === "safari-page" || appName === "Safari") {
     return "Safari";
   }
   if (target.kind === "web-content-proxy") {
     return "WebKit proxy";
   }
-  return target.appName ?? "WebKit";
+  return appName || "WebKit";
 }
 
 function webKitTargetProcessIdentifier(target: WebKitTarget): number | null {
-  const match = target.appId.match(/^PID:(\d+)$/);
+  const match = trimmedString(target.appId).match(/^PID:(\d+)$/);
   return match ? Number.parseInt(match[1], 10) : null;
 }
 
+function trimmedString(value: unknown): string {
+  return typeof value === "string" ? value.trim() : "";
+}
+
+function nullableString(value: unknown): string | null {
+  const text = trimmedString(value);
+  return text || null;
+}
+
+function finiteNumber(value: unknown): number | null {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+
 function errorMessage(error: unknown): string {
   return error instanceof Error
     ? error.message
@@ -1913,23 +1952,6 @@ function isProviderDisconnectedMessage(message: string): boolean {
   );
 }
 
-function shouldDisplayDevToolsWarning(message: string): boolean {
-  const normalized = message.trim();
-  if (!normalized || normalized === NOT_CONNECTED_MESSAGE) {
-    return false;
-  }
-
-  const lower = normalized.toLowerCase();
-  return !(
-    lower.includes("timed out loading chrome devtools targets") ||
-    lower.includes("timed out loading webkit targets") ||
-    lower.includes("unable to read webkit packet header") ||
-    lower.includes("unable to write webkit packet") ||
-    lower.includes("retried webkit target discovery") ||
-    lower.includes("webinspectord was settling")
-  );
-}
-
 function cleanDevToolsMessages(messages: string[]): string[] {
   return messages.flatMap((message) => {
     const nextMessage = userFacingDevToolsMessage(message);
diff --git a/packages/client/src/features/input/gestureMath.ts b/packages/client/src/features/input/gestureMath.ts
index ca56360c..c30308a8 100644
--- a/packages/client/src/features/input/gestureMath.ts
+++ b/packages/client/src/features/input/gestureMath.ts
@@ -3,29 +3,113 @@ import type { PointerEvent as ReactPointerEvent } from "react";
 import type { Point } from "../viewport/types";
 import { mapDisplayedPointToNaturalOrientation } from "../viewport/viewportMath";
 
-export function normalizedPointerCoordinates(
-  event: PointerEvent | ReactPointerEvent<HTMLElement>,
-): Point | null {
-  const currentTarget = event.currentTarget as HTMLElement | null;
-  if (!currentTarget) {
+type QuadPoint = { x: number; y: number };
+type BoxQuad = {
+  p1: QuadPoint;
+  p2: QuadPoint;
+  p4: QuadPoint;
+};
+type ElementWithBoxQuads = HTMLElement & {
+  getBoxQuads?: () => BoxQuad[];
+};
+
+function clampNormalized(point: Point): Point {
+  return {
+    x: Math.min(Math.max(point.x, 0), 1),
+    y: Math.min(Math.max(point.y, 0), 1),
+  };
+}
+
+function pointInTransformedBox(point: QuadPoint, quad: BoxQuad): Point | null {
+  const xAxis = {
+    x: quad.p2.x - quad.p1.x,
+    y: quad.p2.y - quad.p1.y,
+  };
+  const yAxis = {
+    x: quad.p4.x - quad.p1.x,
+    y: quad.p4.y - quad.p1.y,
+  };
+  const relative = {
+    x: point.x - quad.p1.x,
+    y: point.y - quad.p1.y,
+  };
+  const determinant = xAxis.x * yAxis.y - xAxis.y * yAxis.x;
+  if (Math.abs(determinant) < 0.000001) {
     return null;
   }
-  const rect = currentTarget.getBoundingClientRect();
+
+  return {
+    x: (relative.x * yAxis.y - relative.y * yAxis.x) / determinant,
+    y: (xAxis.x * relative.y - xAxis.y * relative.x) / determinant,
+  };
+}
+
+export function normalizedClientCoordinates(
+  target: HTMLElement,
+  clientX: number,
+  clientY: number,
+  { clamp = true }: { clamp?: boolean } = {},
+): Point | null {
+  const quad = (() => {
+    try {
+      return (target as ElementWithBoxQuads).getBoxQuads?.()[0] ?? null;
+    } catch {
+      return null;
+    }
+  })();
+  if (quad) {
+    const point = pointInTransformedBox({ x: clientX, y: clientY }, quad);
+    return point ? (clamp ? clampNormalized(point) : point) : null;
+  }
+
+  const rect = target.getBoundingClientRect();
   if (rect.width <= 0 || rect.height <= 0) {
     return null;
   }
-  return {
-    x: Math.min(Math.max((event.clientX - rect.left) / rect.width, 0), 1),
-    y: Math.min(Math.max((event.clientY - rect.top) / rect.height, 0), 1),
+  const point = {
+    x: (clientX - rect.left) / rect.width,
+    y: (clientY - rect.top) / rect.height,
   };
+  return clamp ? clampNormalized(point) : point;
 }
 
-export function normalizedPointerCoordinatesForOrientation(
+export function normalizedPointerCoordinates(
   event: PointerEvent | ReactPointerEvent<HTMLElement>,
+): Point | null {
+  const currentTarget = event.currentTarget as HTMLElement | null;
+  if (!currentTarget) {
+    return null;
+  }
+  return normalizedClientCoordinates(
+    currentTarget,
+    event.clientX,
+    event.clientY,
+  );
+}
+
+export function normalizedClientCoordinatesForOrientation(
+  target: HTMLElement,
+  clientX: number,
+  clientY: number,
   rotationQuarterTurns: number,
 ): Point | null {
-  const coords = normalizedPointerCoordinates(event);
+  const coords = normalizedClientCoordinates(target, clientX, clientY);
   return coords
     ? mapDisplayedPointToNaturalOrientation(coords, rotationQuarterTurns)
     : null;
 }
+
+export function normalizedPointerCoordinatesForOrientation(
+  event: PointerEvent | ReactPointerEvent<HTMLElement>,
+  rotationQuarterTurns: number,
+): Point | null {
+  const currentTarget = event.currentTarget as HTMLElement | null;
+  return currentTarget
+    ? normalizedClientCoordinatesForOrientation(
+        currentTarget,
+        event.clientX,
+        event.clientY,
+        rotationQuarterTurns,
+      )
+    : null;
+}
diff --git a/packages/client/src/features/input/usePointerInput.ts b/packages/client/src/features/input/usePointerInput.ts
index 019e7f52..ae68c524 100644
--- a/packages/client/src/features/input/usePointerInput.ts
+++ b/packages/client/src/features/input/usePointerInput.ts
@@ -1,12 +1,16 @@
-import { useRef, useState } from "react";
+import { useEffect, useRef, useState } from "react";
 
 import type { ChromeProfile, TouchPhase } from "../../api/types";
 import {
+  normalizedClientCoordinates,
   normalizedPointerCoordinates,
-  normalizedPointerCoordinatesForOrientation,
 } from "./gestureMath";
-import { clampPan } from "../viewport/viewportMath";
-import type { Point, Size } from "../viewport/types";
+import {
+  clampPan,
+  mapDisplayedPointToNaturalOrientation,
+  mapNaturalPointToDisplayedOrientation,
+} from "../viewport/viewportMath";
+import type { Point, Size, TouchPreviewPoint } from "../viewport/types";
 
 interface UsePointerInputOptions {
   canvasSize: Size | null;
@@ -26,13 +30,16 @@ interface UsePointerInputOptions {
     edge: "left" | "top" | "bottom" | "right" | "none",
   ) => void;
   onMultiTouch?: (phase: TouchPhase, first: Point, second: Point) => void;
-  onTouchPreview?: (phase: TouchPhase, coords: Point) => void;
-  onMultiTouchPreview?: (phase: TouchPhase, coords: Point[]) => void;
+  onTouchPreview?: (phase: TouchPhase, coords: TouchPreviewPoint) => void;
+  onMultiTouchPreview?: (
+    phase: TouchPhase,
+    coords: TouchPreviewPoint[],
+  ) => void;
 }
 
 type ActiveGesture =
   | { kind: "single"; pointerId: number }
-  | { kind: "edgeBottom"; pointerId: number }
+  | { kind: "edgeBottom"; pointerId: number; targetElement: HTMLElement }
   | { kind: "pinch"; pointerId: number; first: Point; second: Point }
   | {
       kind: "twoFingerPan";
@@ -40,11 +47,51 @@ type ActiveGesture =
       start: Point;
       first: Point;
       second: Point;
+    }
+  | {
+      kind: "directTouch";
+      primaryPointerId: number;
+      pointers: Map<number, TouchSample>;
+      mode: "single" | "multi";
+    }
+  | {
+      kind: "touchMulti";
+      touchIds: [number, number];
+      targetElement: HTMLElement;
+      first: TouchSample;
+      second: TouchSample;
+    }
+  | {
+      kind: "touchPendingSingle";
+      touchId: number;
+      targetElement: HTMLElement;
+      sample: TouchSample;
+      timer: number;
+    }
+  | {
+      kind: "touchSingle";
+      touchId: number;
+      targetElement: HTMLElement;
+      sample: TouchSample;
+    }
+  | {
+      kind: "touchEdgeBottom";
+      touchId: number;
+      targetElement: HTMLElement;
+      sample: TouchSample;
     };
 
+type TouchSample = {
+  displayed: Point;
+  natural: Point;
+  preview: TouchPreviewPoint;
+};
+
 const TWO_FINGER_SPREAD = 0.16;
 const PINCH_MINIMUM_SPREAD = 0.16;
 const BOTTOM_EDGE_GESTURE_START_Y = 0.93;
+const TOUCH_TARGET_TOLERANCE = 0.08;
+const TOUCH_SINGLE_BEGIN_DELAY_MS = 70;
 
 export function usePointerInput({
   canvasSize,
@@ -72,6 +119,15 @@ export function usePointerInput({
   } | null>(null);
   const [isPanning, setIsPanning] = useState(false);
 
+  useEffect(() => {
+    return () => {
+      const active = activeGestureRef.current;
+      if (active?.kind === "touchPendingSingle") {
+        window.clearTimeout(active.timer);
+      }
+    };
+  }, []);
+
   function clampPoint(point: Point): Point {
     return {
       x: Math.min(Math.max(point.x, 0), 1),
@@ -100,7 +156,50 @@ export function usePointerInput({
     ];
   }
 
-  function previewMultiTouch(phase: TouchPhase, first: Point, second: Point) {
+  function sampleFromDisplayedPoint(
+    displayed: Point,
+    browser?: {
+      clientX: number;
+      clientY: number;
+      pageX: number;
+      pageY: number;
+    },
+  ): TouchSample {
+    return {
+      displayed,
+      natural: mapDisplayedPointToNaturalOrientation(
+        displayed,
+        rotationQuarterTurns,
+      ),
+      preview: browser
+        ? {
+            ...displayed,
+            clientX: browser.clientX,
+            clientY: browser.clientY,
+            pageX: browser.pageX,
+            pageY: browser.pageY,
+          }
+        : displayed,
+    };
+  }
+
+  function sampleFromNaturalPoint(natural: Point): TouchSample {
+    const displayed = mapNaturalPointToDisplayedOrientation(
+      natural,
+      rotationQuarterTurns,
+    );
+    return {
+      displayed,
+      natural,
+      preview: displayed,
+    };
+  }
+
+  function previewMultiTouch(
+    phase: TouchPhase,
+    first: TouchPreviewPoint,
+    second: TouchPreviewPoint,
+  ) {
     if (onMultiTouchPreview) {
       onMultiTouchPreview(phase, [first, second]);
       return;
@@ -108,11 +207,316 @@ export function usePointerInput({
     onTouchPreview?.(phase, first);
   }
 
-  function sendMultiTouch(phase: TouchPhase, first: Point, second: Point) {
-    previewMultiTouch(phase, first, second);
+  function sendMultiTouch(
+    phase: TouchPhase,
+    first: Point,
+    second: Point,
+    firstPreview = sampleFromNaturalPoint(first).preview,
+    secondPreview = sampleFromNaturalPoint(second).preview,
+  ) {
+    previewMultiTouch(phase, firstPreview, secondPreview);
     onMultiTouch?.(phase, first, second);
   }
 
+  function sendMultiTouchSamples(
+    phase: TouchPhase,
+    first: TouchSample,
+    second: TouchSample,
+  ) {
+    sendMultiTouch(
+      phase,
+      first.natural,
+      second.natural,
+      first.preview,
+      second.preview,
+    );
+  }
+
+  function firstTwoTouchPoints(
+    pointers: Map<number, TouchSample>,
+  ): [TouchSample, TouchSample] | null {
+    const points = Array.from(pointers.values());
+    return points.length >= 2 ? [points[0], points[1]] : null;
+  }
+
+  function clientTouchSample(
+    target: HTMLElement,
+    clientX: number,
+    clientY: number,
+    pageX = clientX + window.scrollX,
+    pageY = clientY + window.scrollY,
+    clamp = true,
+  ): TouchSample | null {
+    const displayed = displayedClientPoint(target, clientX, clientY, clamp);
+    return displayed
+      ? sampleFromDisplayedPoint(displayed, {
+          clientX,
+          clientY,
+          pageX,
+          pageY,
+        })
+      : null;
+  }
+
+  function touchSample(
+    touch: React.Touch,
+    target: HTMLElement,
+    clamp = true,
+  ): TouchSample | null {
+    return clientTouchSample(
+      target,
+      touch.clientX,
+      touch.clientY,
+      touch.pageX,
+      touch.pageY,
+      clamp,
+    );
+  }
+
+  function displayedClientPoint(
+    target: HTMLElement,
+    clientX: number,
+    clientY: number,
+    clamp = true,
+  ): Point | null {
+    return normalizedClientCoordinates(target, clientX, clientY, { clamp });
+  }
+
+  function touchById(
+    touches: React.TouchList,
+    identifier: number,
+  ): React.Touch | null {
+    for (let index = 0; index < touches.length; index += 1) {
+      const touch = touches.item(index);
+      if (touch?.identifier === identifier) {
+        return touch;
+      }
+    }
+    return null;
+  }
+
+  function touchesForTarget(
+    touches: React.TouchList,
+    target: HTMLElement,
+  ): React.Touch[] {
+    const matchingTouches: React.Touch[] = [];
+    for (let index = 0; index < touches.length; index += 1) {
+      const touch = touches.item(index);
+      if (!touch) {
+        continue;
+      }
+      const displayed = displayedClientPoint(
+        target,
+        touch.clientX,
+        touch.clientY,
+        false,
+      );
+      if (
+        displayed &&
+        displayed.x >= -TOUCH_TARGET_TOLERANCE &&
+        displayed.x <= 1 + TOUCH_TARGET_TOLERANCE &&
+        displayed.y >= -TOUCH_TARGET_TOLERANCE &&
+        displayed.y <= 1 + TOUCH_TARGET_TOLERANCE
+      ) {
+        matchingTouches.push(touch);
+      }
+    }
+    return matchingTouches;
+  }
+
+  function touchPairForIds(
+    target: HTMLElement,
+    touches: React.TouchList,
+    touchIds: [number, number],
+    clamp = true,
+  ): [TouchSample, TouchSample] | null {
+    const firstTouch = touchById(touches, touchIds[0]);
+    const secondTouch = touchById(touches, touchIds[1]);
+    if (!firstTouch || !secondTouch) {
+      return null;
+    }
+    const first = touchSample(firstTouch, target, clamp);
+    const second = touchSample(secondTouch, target, clamp);
+    return first && second ? [first, second] : null;
+  }
+
+  function touchPairForEvent(
+    event: React.TouchEvent<HTMLElement>,
+    touchIds: [number, number],
+    clamp = true,
+  ): [TouchSample, TouchSample] | null {
+    const firstTouch =
+      touchById(event.touches, touchIds[0]) ??
+      touchById(event.changedTouches, touchIds[0]);
+    const secondTouch =
+      touchById(event.touches, touchIds[1]) ??
+      touchById(event.changedTouches, touchIds[1]);
+    if (!firstTouch || !secondTouch) {
+      return null;
+    }
+    const first = touchSample(firstTouch, event.currentTarget, clamp);
+    const second = touchSample(secondTouch, event.currentTarget, clamp);
+    return first && second ? [first, second] : null;
+  }
+
+  function clearPendingTouchSingle(active: ActiveGesture | null) {
+    if (active?.kind === "touchPendingSingle") {
+      window.clearTimeout(active.timer);
+    }
+  }
+
+  function flushPendingTouchSingle(touchId: number) {
+    const active = activeGestureRef.current;
+    if (active?.kind !== "touchPendingSingle" || active.touchId !== touchId) {
+      return;
+    }
+    window.clearTimeout(active.timer);
+    activeGestureRef.current = {
+      kind: "touchSingle",
+      touchId: active.touchId,
+      targetElement: active.targetElement,
+      sample: active.sample,
+    };
+    onTouch("began", active.sample.natural);
+  }
+
+  function beginPendingTouchSingle(
+    touchId: number,
+    targetElement: HTMLElement,
+    sample: TouchSample,
+  ) {
+    const timer = window.setTimeout(
+      () => flushPendingTouchSingle(touchId),
+      TOUCH_SINGLE_BEGIN_DELAY_MS,
+    );
+    activeGestureRef.current = {
+      kind: "touchPendingSingle",
+      touchId,
+      targetElement,
+      sample,
+      timer,
+    };
+    onTouchPreview?.("began", sample.preview);
+  }
+
+  function cancelActiveGestureForTouchMulti() {
+    const active = activeGestureRef.current;
+    if (!active) {
+      return;
+    }
+    activeGestureRef.current = null;
+    clearPendingTouchSingle(active);
+
+    if (active.kind === "directTouch") {
+      if (active.mode === "multi") {
+        const pair = firstTwoTouchPoints(active.pointers);
+        if (pair) {
+          sendMultiTouchSamples("cancelled", pair[0], pair[1]);
+        }
+        return;
+      }
+      const primary = active.pointers.get(active.primaryPointerId);
+      if (primary) {
+        onTouchPreview?.("cancelled", primary.preview);
+        onTouch("cancelled", primary.natural);
+      }
+      return;
+    }
+
+    if (active.kind === "pinch") {
+      sendMultiTouch("cancelled", active.first, active.second);
+      return;
+    }
+
+    if (active.kind === "twoFingerPan") {
+      sendMultiTouch("cancelled", active.first, active.second);
+      return;
+    }
+
+    if (active.kind === "touchMulti") {
+      sendMultiTouchSamples("cancelled", active.first, active.second);
+      return;
+    }
+
+    if (active.kind === "touchPendingSingle") {
+      return;
+    }
+
+    if (active.kind === "touchSingle") {
+      onTouchPreview?.("cancelled", active.sample.preview);
+      onTouch("cancelled", active.sample.natural);
+      return;
+    }
+
+    if (active.kind === "touchEdgeBottom") {
+      onTouchPreview?.("cancelled", active.sample.preview);
+      onEdgeTouch?.("cancelled", active.sample.natural, "bottom");
+    }
+  }
+
+  function handleDirectTouchPointerDown(
+    event: React.PointerEvent<HTMLElement>,
+    sample: TouchSample,
+  ): boolean {
+    if (event.pointerType === "mouse") {
+      return false;
+    }
+
+    event.currentTarget.setPointerCapture(event.pointerId);
+    const active = activeGestureRef.current;
+    if (active?.kind === "directTouch") {
+      active.pointers.set(event.pointerId, sample);
+      const pair = firstTwoTouchPoints(active.pointers);
+      if (pair && onMultiTouch) {
+        if (active.mode === "single") {
+          const primary = active.pointers.get(active.primaryPointerId);
+          if (primary) {
+            onTouchPreview?.("cancelled", primary.preview);
+            onTouch("cancelled", primary.natural);
+          }
+          active.mode = "multi";
+          sendMultiTouchSamples("began", pair[0], pair[1]);
+        } else {
+          sendMultiTouchSamples("moved", pair[0], pair[1]);
+        }
+      }
+      return true;
+    }
+
+    const pointers = new Map<number, TouchSample>();
+    pointers.set(event.pointerId, sample);
+    activeGestureRef.current = {
+      kind: "directTouch",
+      primaryPointerId: event.pointerId,
+      pointers,
+      mode: "single",
+    };
+    onTouchPreview?.("began", sample.preview);
+    onTouch("began", sample.natural);
+    return true;
+  }
+
+  function pointerEventShouldDeferToTouchEvents(
+    event: React.PointerEvent<HTMLElement>,
+  ): boolean {
+    return false;
+  }
+
+  function screenElementFromBottomBezelTarget(
+    target: HTMLElement,
+  ): HTMLElement | null {
+    return (target.parentElement?.querySelector(".device-screen") ??
+      null) as HTMLElement | null;
+  }
+
+  function bottomEdgeCoordsFromClientPoint(
+    screenElement: HTMLElement,
+    clientX: number,
+    clientY: number,
+  ): TouchSample | null {
+    return clientTouchSample(screenElement, clientX, clientY);
+  }
+
   function startPanning(event: React.PointerEvent<HTMLElement>) {
     if (event.pointerType !== "mouse") {
       return;
@@ -170,14 +574,28 @@ export function usePointerInput({
       return;
     }
     event.stopPropagation();
+    if (pointerEventShouldDeferToTouchEvents(event)) {
+      return;
+    }
     event.preventDefault();
-    const coords = normalizedPointerCoordinatesForOrientation(
-      event,
-      rotationQuarterTurns,
+    const sample = clientTouchSample(
+      event.currentTarget,
+      event.clientX,
+      event.clientY,
+      event.pageX,
+      event.pageY,
     );
-    if (!coords) {
+    if (!sample) {
+      return;
+    }
+    if (activeGestureRef.current?.kind === "touchMulti") {
       return;
     }
+
+    if (handleDirectTouchPointerDown(event, sample)) {
+      return;
+    }
+
     event.currentTarget.setPointerCapture(event.pointerId);
 
     const displayedCoords = normalizedPointerCoordinates(event);
@@ -190,9 +608,10 @@ export function usePointerInput({
       activeGestureRef.current = {
         kind: "edgeBottom",
         pointerId: event.pointerId,
+        targetElement: event.currentTarget,
       };
-      onTouchPreview?.("began", coords);
-      onEdgeTouch("began", coords, "bottom");
+      onTouchPreview?.("began", sample.preview);
+      onEdgeTouch("began", sample.natural, "bottom");
       return;
     }
 
@@ -203,7 +622,7 @@ export function usePointerInput({
         activeGestureRef.current = {
           kind: "twoFingerPan",
           pointerId: event.pointerId,
-          start: coords,
+          start: sample.natural,
           first,
           second,
         };
@@ -211,7 +630,7 @@ export function usePointerInput({
         return;
       }
 
-      const [first, second] = pinchPointsAroundCenter(coords);
+      const [first, second] = pinchPointsAroundCenter(sample.natural);
       activeGestureRef.current = {
         kind: "pinch",
         pointerId: event.pointerId,
@@ -223,27 +642,82 @@ export function usePointerInput({
     }
 
     activeGestureRef.current = { kind: "single", pointerId: event.pointerId };
-    onTouchPreview?.("began", coords);
-    onTouch("began", coords);
+    onTouchPreview?.("began", sample.preview);
+    onTouch("began", sample.natural);
   }
 
   function handleScreenPointerMove(event: React.PointerEvent<HTMLElement>) {
     event.stopPropagation();
     const active = activeGestureRef.current;
-    if (!active || active.pointerId !== event.pointerId) {
+    if (!active) {
       return;
     }
     event.preventDefault();
-    const coords = normalizedPointerCoordinatesForOrientation(
-      event,
-      rotationQuarterTurns,
+    if (active.kind === "touchMulti" || active.kind === "touchPendingSingle") {
+      return;
+    }
+    if (active.kind === "touchSingle" || active.kind === "touchEdgeBottom") {
+      return;
+    }
+
+    if (active.kind === "edgeBottom") {
+      if (active.pointerId !== event.pointerId) {
+        return;
+      }
+      const sample = clientTouchSample(
+        active.targetElement,
+        event.clientX,
+        event.clientY,
+        event.pageX,
+        event.pageY,
+      );
+      if (sample) {
+        onTouchPreview?.("moved", sample.preview);
+        onEdgeTouch?.("moved", sample.natural, "bottom");
+      }
+      return;
+    }
+
+    const sample = clientTouchSample(
+      event.currentTarget,
+      event.clientX,
+      event.clientY,
+      event.pageX,
+      event.pageY,
+      active.kind === "directTouch" && active.mode === "multi" ? false : true,
     );
-    if (!coords) {
+    if (!sample) {
+      return;
+    }
+
+    if (active.kind === "directTouch") {
+      if (!active.pointers.has(event.pointerId)) {
+        return;
+      }
+      active.pointers.set(event.pointerId, sample);
+      if (active.mode === "multi") {
+        const pair = firstTwoTouchPoints(active.pointers);
+        if (pair) {
+          sendMultiTouchSamples("moved", pair[0], pair[1]);
+        }
+        return;
+      }
+      if (active.primaryPointerId === event.pointerId) {
+        onTouchPreview?.("moved", sample.preview);
+        onTouch("moved", sample.natural);
+      }
+      return;
+    }
+
+    if (active.pointerId !== event.pointerId) {
       return;
     }
 
     if (active.kind === "pinch") {
-      const [first, second] = pinchPointsAroundCenter(coords, active.first);
+      const [first, second] = pinchPointsAroundCenter(
+        sample.natural,
+        active.first,
+      );
       activeGestureRef.current = { ...active, first, second };
       sendMultiTouch("moved", first, second);
       return;
@@ -251,8 +725,8 @@ export function usePointerInput({
 
     if (active.kind === "twoFingerPan") {
       const delta = {
-        x: coords.x - active.start.x,
-        y: coords.y - active.start.y,
+        x: sample.natural.x - active.start.x,
+        y: sample.natural.y - active.start.y,
       };
       const first = clampPoint({
         x: 0.5 + TWO_FINGER_SPREAD / 2 + delta.x,
@@ -268,15 +742,10 @@ export function usePointerInput({
     }
 
     if (active.kind === "single") {
-      onTouchPreview?.("moved", coords);
-      onTouch("moved", coords);
+      onTouchPreview?.("moved", sample.preview);
+      onTouch("moved", sample.natural);
       return;
     }
-
-    if (active.kind === "edgeBottom") {
-      onTouchPreview?.("moved", coords);
-      onEdgeTouch?.("moved", coords, "bottom");
-    }
   }
 
   function finishTouch(
@@ -285,19 +754,74 @@ export function usePointerInput({
   ) {
     event.stopPropagation();
     const active = activeGestureRef.current;
-    if (!active || active.pointerId !== event.pointerId) {
+    if (!active) {
       return;
     }
     event.preventDefault();
-    activeGestureRef.current = null;
-    const coords = normalizedPointerCoordinatesForOrientation(
-      event,
-      rotationQuarterTurns,
+    if (active.kind === "touchMulti" || active.kind === "touchPendingSingle") {
+      return;
+    }
+    if (active.kind === "touchSingle" || active.kind === "touchEdgeBottom") {
+      return;
+    }
+    if (active.kind === "edgeBottom") {
+      if (active.pointerId !== event.pointerId) {
+        return;
+      }
+      activeGestureRef.current = null;
+      const sample = clientTouchSample(
+        active.targetElement,
+        event.clientX,
+        event.clientY,
+        event.pageX,
+        event.pageY,
+      );
+      if (sample) {
+        onTouchPreview?.(phase, sample.preview);
+        onEdgeTouch?.(phase, sample.natural, "bottom");
+      }
+      return;
+    }
+    const sample = clientTouchSample(
+      event.currentTarget,
+      event.clientX,
+      event.clientY,
+      event.pageX,
+      event.pageY,
     );
 
+    if (active.kind === "directTouch") {
+      if (!active.pointers.has(event.pointerId)) {
+        return;
+      }
+      if (sample) {
+        active.pointers.set(event.pointerId, sample);
+      }
+      if (active.mode === "multi") {
+        const pair = firstTwoTouchPoints(active.pointers);
+        if (pair) {
+          sendMultiTouchSamples(phase, pair[0], pair[1]);
+        }
+      } else {
+        const finalSample =
+          sample ?? active.pointers.get(active.primaryPointerId);
+        if (finalSample) {
+          onTouchPreview?.(phase, finalSample.preview);
+          onTouch(phase, finalSample.natural);
+        }
+      }
+      activeGestureRef.current = null;
+      return;
+    }
+
+    if (active.pointerId !== event.pointerId) {
+      return;
+    }
+    activeGestureRef.current = null;
+
     if (active.kind === "pinch") {
-      const [first, second] = coords
-        ? pinchPointsAroundCenter(coords, active.first)
+      const [first, second] = sample
+        ? pinchPointsAroundCenter(sample.natural, active.first)
         : [active.first, active.second];
       sendMultiTouch(phase, first, second);
       return;
@@ -308,22 +832,315 @@ export function usePointerInput({
       return;
     }
 
-    if (active.kind === "edgeBottom") {
-      if (coords) {
-        onTouchPreview?.(phase, coords);
-        onEdgeTouch?.(phase, coords, "bottom");
+    if (sample) {
+      onTouchPreview?.(phase, sample.preview);
+      onTouch(phase, sample.natural);
+    }
+  }
+
+  function handleScreenTouchStart(event: React.TouchEvent<HTMLElement>) {
+    if (!isBooted) {
+      return;
+    }
+
+    event.stopPropagation();
+    event.preventDefault();
+
+    const active = activeGestureRef.current;
+    if (active?.kind === "directTouch") {
+      return;
+    }
+    const targetTouches = touchesForTarget(event.touches, event.currentTarget);
+    if (targetTouches.length === 0) {
+      return;
+    }
+
+    if (targetTouches.length >= 2 && onMultiTouch) {
+      const touches: [React.Touch, React.Touch] = [
+        targetTouches[0],
+        targetTouches[1],
+      ];
+      const first = touchSample(touches[0], event.currentTarget);
+      const second = touchSample(touches[1], event.currentTarget);
+      if (!first || !second) {
+        return;
+      }
+
+      if (active?.kind !== "touchMulti") {
+        cancelActiveGestureForTouchMulti();
+        activeGestureRef.current = {
+          kind: "touchMulti",
+          touchIds: [touches[0].identifier, touches[1].identifier],
+          targetElement: event.currentTarget,
+          first,
+          second,
+        };
+        sendMultiTouchSamples("began", first, second);
+        return;
+      }
+
+      const pair = touchPairForIds(
+        active.targetElement,
+        event.touches,
+        active.touchIds,
+        false,
+      ) ?? [first, second];
+      active.first = pair[0];
+      active.second = pair[1];
+      sendMultiTouchSamples("moved", pair[0], pair[1]);
+      return;
+    }
+
+    if (active?.kind === "touchMulti") {
+      return;
+    }
+
+    const touch = targetTouches[0];
+    const first = touchSample(touch, event.currentTarget);
+    if (!first) {
+      return;
+    }
+
+    cancelActiveGestureForTouchMulti();
+    if (first.displayed.y >= BOTTOM_EDGE_GESTURE_START_Y && onEdgeTouch) {
+      activeGestureRef.current = {
+        kind: "touchEdgeBottom",
+        touchId: touch.identifier,
+        targetElement: event.currentTarget,
+        sample: first,
+      };
+      onTouchPreview?.("began", first.preview);
+      onEdgeTouch("began", first.natural, "bottom");
+      return;
+    }
+
+    beginPendingTouchSingle(touch.identifier, event.currentTarget, first);
+  }
+
+  function handleScreenTouchMove(event: React.TouchEvent<HTMLElement>) {
+    const active = activeGestureRef.current;
+    if (
+      active?.kind !== "touchMulti" &&
+      active?.kind !== "touchPendingSingle" &&
+      active?.kind !== "touchSingle" &&
+      active?.kind !== "touchEdgeBottom"
+    ) {
+      return;
+    }
+
+    event.stopPropagation();
+    event.preventDefault();
+
+    if (active.kind === "touchPendingSingle") {
+      const touch = touchById(event.touches, active.touchId);
+      if (!touch) {
+        return;
+      }
+      const sample = touchSample(touch, active.targetElement);
+      if (!sample) {
+        return;
+      }
+      active.sample = sample;
+      onTouchPreview?.("moved", sample.preview);
+      return;
+    }
+
+    if (active.kind === "touchSingle" || active.kind === "touchEdgeBottom") {
+      const touch = touchById(event.touches, active.touchId);
+      if (!touch) {
+        return;
+      }
+      const sample = touchSample(touch, active.targetElement);
+      if (!sample) {
+        return;
+      }
+      active.sample = sample;
+      onTouchPreview?.("moved", sample.preview);
+      if (active.kind === "touchEdgeBottom") {
+        onEdgeTouch?.("moved", sample.natural, "bottom");
+      } else {
+        onTouch("moved", sample.natural);
       }
       return;
     }
 
-    if (coords) {
-      onTouchPreview?.(phase, coords);
-      onTouch(phase, coords);
+    const pair = touchPairForIds(
+      active.targetElement,
+      event.touches,
+      active.touchIds,
+      false,
+    );
+    if (!pair) {
+      return;
     }
+    active.first = pair[0];
+    active.second = pair[1];
+    sendMultiTouchSamples("moved", pair[0], pair[1]);
+  }
+
+  function finishScreenTouch(
+    event: React.TouchEvent<HTMLElement>,
+    phase: Exclude<TouchPhase, "moved" | "began">,
+  ) {
+    const active = activeGestureRef.current;
+    if (
+      active?.kind !== "touchMulti" &&
+      active?.kind !== "touchPendingSingle" &&
+      active?.kind !== "touchSingle" &&
+      active?.kind !== "touchEdgeBottom"
+    ) {
+      return;
+    }
+
+    event.stopPropagation();
+    event.preventDefault();
+
+    if (active.kind === "touchPendingSingle") {
+      const liveTouch = touchById(event.touches, active.touchId);
+      if (liveTouch) {
+        const sample = touchSample(liveTouch, active.targetElement);
+        if (sample) {
+          active.sample = sample;
+        }
+        return;
+      }
+
+      const finalTouch = touchById(event.changedTouches, active.touchId);
+      const finalSample = finalTouch
+        ? touchSample(finalTouch, active.targetElement)
+        : active.sample;
+      window.clearTimeout(active.timer);
+      activeGestureRef.current = null;
+      if (finalSample) {
+        onTouchPreview?.(phase, finalSample.preview);
+        if (phase === "ended") {
+          onTouch("began", active.sample.natural);
+          onTouch("ended", finalSample.natural);
+        }
+      }
+      return;
+    }
+
+    if (active.kind === "touchSingle" || active.kind === "touchEdgeBottom") {
+      const liveTouch = touchById(event.touches, active.touchId);
+      if (liveTouch) {
+        const sample = touchSample(liveTouch, active.targetElement);
+        if (sample) {
+          active.sample = sample;
+        }
+        return;
+      }
+
+      const finalTouch = touchById(event.changedTouches, active.touchId);
+      const finalSample = finalTouch
+        ? touchSample(finalTouch, active.targetElement)
+        : active.sample;
+      activeGestureRef.current = null;
+      if (finalSample) {
+        onTouchPreview?.(phase, finalSample.preview);
+        if (active.kind === "touchEdgeBottom") {
+          onEdgeTouch?.(phase, finalSample.natural, "bottom");
+        } else {
+          onTouch(phase, finalSample.natural);
+        }
+      }
+      return;
+    }
+
+    const livePair = touchPairForIds(
+      active.targetElement,
+      event.touches,
+      active.touchIds,
+      false,
+    );
+    if (livePair) {
+      active.first = livePair[0];
+      active.second = livePair[1];
+      return;
+    }
+
+    const finalPair = touchPairForEvent(event, active.touchIds, false) ?? [
+      active.first,
+      active.second,
+    ];
+    activeGestureRef.current = null;
+    sendMultiTouchSamples(phase, finalPair[0], finalPair[1]);
+  }
+
+  function handleBottomBezelPointerDown(
+    event: React.PointerEvent<HTMLElement>,
+  ) {
+    if (
+      event.button !== 0 ||
+      !isBooted ||
+      !onEdgeTouch ||
+      pointerEventShouldDeferToTouchEvents(event)
+    ) {
+      return;
+    }
+    const screenElement = screenElementFromBottomBezelTarget(
+      event.currentTarget,
+    );
+    if (!screenElement) {
+      return;
+    }
+    const sample = bottomEdgeCoordsFromClientPoint(
+      screenElement,
+      event.clientX,
+      event.clientY,
+    );
+    if (!sample) {
+      return;
+    }
+
+    event.stopPropagation();
+    event.preventDefault();
+    event.currentTarget.setPointerCapture(event.pointerId);
+    activeGestureRef.current = {
+      kind: "edgeBottom",
+      pointerId: event.pointerId,
+      targetElement: screenElement,
+    };
+    onTouchPreview?.("began", sample.preview);
+    onEdgeTouch("began", sample.natural, "bottom");
+  }
+
+  function handleBottomBezelTouchStart(event: React.TouchEvent<HTMLElement>) {
+    if (!isBooted || !onEdgeTouch || event.touches.length === 0) {
+      return;
+    }
+    const screenElement = screenElementFromBottomBezelTarget(
+      event.currentTarget,
+    );
+    const touch = event.touches.item(0);
+    if (!screenElement || !touch) {
+      return;
+    }
+    const sample = bottomEdgeCoordsFromClientPoint(
+      screenElement,
+      touch.clientX,
+      touch.clientY,
+    );
+    if (!sample) {
+      return;
+    }
+
+    event.stopPropagation();
+    event.preventDefault();
+    cancelActiveGestureForTouchMulti();
+    activeGestureRef.current = {
+      kind: "touchEdgeBottom",
+      touchId: touch.identifier,
+      targetElement: screenElement,
+      sample,
+    };
+    onTouchPreview?.("began", sample.preview);
+    onEdgeTouch("began", sample.natural, "bottom");
   }
 
   return {
     isPanning,
+    cancelActiveGestureForExternalMultiTouch: cancelActiveGestureForTouchMulti,
     startPanning,
     handlePanPointerMove,
     handlePanPointerUp,
@@ -333,5 +1150,23 @@ export function usePointerInput({
       finishTouch(event, "ended"),
     handleScreenPointerCancel: (event: React.PointerEvent<HTMLElement>) =>
       finishTouch(event, "cancelled"),
+    handleScreenTouchStart,
+    handleScreenTouchMove,
+    handleScreenTouchEnd: (event: React.TouchEvent<HTMLElement>) =>
+      finishScreenTouch(event, "ended"),
+    handleScreenTouchCancel: (event: React.TouchEvent<HTMLElement>) =>
+      finishScreenTouch(event, "cancelled"),
+    handleBottomBezelPointerDown,
+    handleBottomBezelPointerMove: handleScreenPointerMove,
+    handleBottomBezelPointerUp: (event: React.PointerEvent<HTMLElement>) =>
+      finishTouch(event, "ended"),
+    handleBottomBezelPointerCancel: (event: React.PointerEvent<HTMLElement>) =>
+      finishTouch(event, "cancelled"),
+    handleBottomBezelTouchStart,
+    handleBottomBezelTouchMove: handleScreenTouchMove,
+    handleBottomBezelTouchEnd: (event: React.TouchEvent<HTMLElement>) =>
+      finishScreenTouch(event, "ended"),
+    handleBottomBezelTouchCancel: (event: React.TouchEvent<HTMLElement>) =>
+      finishScreenTouch(event, "cancelled"),
   };
 }
diff --git a/packages/client/src/features/simulators/SimulatorMenu.tsx b/packages/client/src/features/simulators/SimulatorMenu.tsx
index b0859ab3..c9c1cc9f 100644
--- a/packages/client/src/features/simulators/SimulatorMenu.tsx
+++ b/packages/client/src/features/simulators/SimulatorMenu.tsx
@@ -2,6 +2,7 @@ import { MixerHorizontalIcon as MenuIcon } from "@radix-ui/react-icons";
 import type { RefObject } from "react";
 
 import type { SimulatorMetadata } from "../../api/types";
+import type { AccessibilitySkeletonMode } from "../accessibility/skeletonMode";
 import type {
   StreamConfig,
   StreamEncoder,
@@ -12,6 +13,7 @@ import type {
 import { simulatorHasFixedOrientation } from "./simulatorDisplay";
 
 interface SimulatorMenuProps {
+  accessibilitySkeletonMode: AccessibilitySkeletonMode;
   captureBusy: boolean;
   debugVisible: boolean;
   deviceChromeAvailable: boolean;
@@ -31,6 +33,7 @@ interface SimulatorMenuProps {
   onOpenBundlePrompt: () => void;
   onOpenUrlPrompt: () => void;
   onRotateRight: () => void;
+  onAccessibilitySkeletonModeChange: (mode: AccessibilitySkeletonMode) => void;
   onShutdown: () => void;
   onStreamEncoderChange: (encoder: StreamEncoder) => void;
   onStreamFpsChange: (fps: StreamFps) => void;
@@ -55,6 +58,7 @@ interface SimulatorMenuProps {
 }
 
 export function SimulatorMenu({
+  accessibilitySkeletonMode,
   captureBusy,
   debugVisible,
   deviceChromeAvailable,
@@ -74,6 +78,7 @@ export function SimulatorMenu({
   onOpenBundlePrompt,
   onOpenUrlPrompt,
   onRotateRight,
+  onAccessibilitySkeletonModeChange,
   onShutdown,
   onStreamEncoderChange,
   onStreamFpsChange,
@@ -217,6 +222,22 @@ export function SimulatorMenu({
                   />
                   <span>Bezel</span>
                 </label>
+                <label className="menu-field">
+                  <span className="menu-field-label">AX Frames</span>
+                  <select
+                    className="menu-select"
+                    onChange={(event) =>
+                      onAccessibilitySkeletonModeChange(
+                        event.currentTarget.value as AccessibilitySkeletonMode,
+                      )
+                    }
+                    value={accessibilitySkeletonMode}
+                  >
+                    <option value="auto">Auto</option>
+                    <option value="always">Always</option>
+                    <option value="off">Off</option>
+                  </select>
+                </label>
               </div>
               <div className="menu-divider" />
               <div className="menu-actions">
diff --git a/packages/client/src/features/toolbar/Toolbar.tsx b/packages/client/src/features/toolbar/Toolbar.tsx
index 685325ff..7e8819f3 100644
--- a/packages/client/src/features/toolbar/Toolbar.tsx
+++ b/packages/client/src/features/toolbar/Toolbar.tsx
@@ -12,6 +12,7 @@ import {
 import { useEffect, useState, type RefObject } from "react";
 
 import type { SimulatorMetadata } from "../../api/types";
+import type { AccessibilitySkeletonMode } from "../accessibility/skeletonMode";
 import type {
   StreamConfig,
   StreamEncoder,
@@ -24,6 +25,7 @@ import { SimulatorMenu } from "../simulators/SimulatorMenu";
 import { SimulatorPickerMenu } from "../simulators/SimulatorPickerMenu";
 
 interface ToolbarProps {
+  accessibilitySkeletonMode: AccessibilitySkeletonMode;
   debugVisible: boolean;
   deviceChromeAvailable: boolean;
   deviceChromeVisible: boolean;
@@ -48,6 +50,7 @@ interface ToolbarProps {
   onOpenUrlPrompt: () => void;
   onRotateLeft: () => void;
   onRotateRight: () => void;
+  onAccessibilitySkeletonModeChange: (mode: AccessibilitySkeletonMode) => void;
   onShutdown: () => void;
   onStreamEncoderChange: (encoder: StreamEncoder) => void;
   onStreamFpsChange: (fps: StreamFps) => void;
@@ -85,6 +88,7 @@ interface ToolbarProps {
 }
 
 export function Toolbar({
+  accessibilitySkeletonMode,
   captureBusy,
   closeSimulatorMenu,
   closeMenu,
@@ -114,6 +118,7 @@ export function Toolbar({
   onOpenUrlPrompt,
   onRotateLeft,
   onRotateRight,
+  onAccessibilitySkeletonModeChange,
   onShutdown,
   onStreamEncoderChange,
   onStreamFpsChange,
@@ -195,6 +200,7 @@ export function Toolbar({
           onOpenBundlePrompt={onOpenBundlePrompt}
           onOpenUrlPrompt={onOpenUrlPrompt}
           onRotateRight={onRotateRight}
+          onAccessibilitySkeletonModeChange={onAccessibilitySkeletonModeChange}
           onShutdown={onShutdown}
           onStreamEncoderChange={onStreamEncoderChange}
           onStreamFpsChange={onStreamFpsChange}
@@ -216,6 +222,7 @@ export function Toolbar({
           canInstallApp={canInstallApp}
           streamConfig={streamConfig}
           streamTransport={streamTransport}
+          accessibilitySkeletonMode={accessibilitySkeletonMode}
           deviceChromeAvailable={deviceChromeAvailable}
           deviceChromeVisible={deviceChromeVisible}
           touchOverlayVisible={touchOverlayVisible}
diff --git a/packages/client/src/features/viewport/DeviceChrome.tsx b/packages/client/src/features/viewport/DeviceChrome.tsx
index f9c13212..770db811 100644
--- a/packages/client/src/features/viewport/DeviceChrome.tsx
+++ b/packages/client/src/features/viewport/DeviceChrome.tsx
@@ -15,6 +15,7 @@ interface DeviceChromeProps {
   accessibilityPickerActive: boolean;
   accessibilityRoots: AccessibilityNode[];
   accessibilitySelectedId: string;
+  accessibilitySkeletonVisible: boolean;
   chromeProfile: ChromeProfile | null;
   chromeButtonsRenderedInChrome: boolean;
   chromeScreenBackingStyle: CSSProperties | null;
@@ -31,6 +32,14 @@ interface DeviceChromeProps {
     usagePage?: number,
     usage?: number,
   ) => void;
+  onBottomBezelPointerCancel: (event: React.PointerEvent<HTMLElement>) => void;
+  onBottomBezelPointerDown: (event: React.PointerEvent<HTMLElement>) => void;
+  onBottomBezelPointerMove: (event: React.PointerEvent<HTMLElement>) => void;
+  onBottomBezelPointerUp: (event: React.PointerEvent<HTMLElement>) => void;
+  onBottomBezelTouchCancel: (event: React.TouchEvent<HTMLElement>) => void;
+  onBottomBezelTouchEnd: (event: React.TouchEvent<HTMLElement>) => void;
+  onBottomBezelTouchMove: (event: React.TouchEvent<HTMLElement>) => void;
+  onBottomBezelTouchStart: (event: React.TouchEvent<HTMLElement>) => void;
   onPanPointerCancel: (event: React.PointerEvent<HTMLElement>) => void;
   onPanPointerMove: (event: React.PointerEvent<HTMLElement>) => void;
   onPanPointerUp: () => void;
@@ -41,6 +50,10 @@ interface DeviceChromeProps {
   onScreenPointerDown: (event: React.PointerEvent<HTMLElement>) => void;
   onScreenPointerMove: (event: React.PointerEvent<HTMLElement>) => void;
   onScreenPointerUp: (event: React.PointerEvent<HTMLElement>) => void;
+  onScreenTouchCancel: (event: React.TouchEvent<HTMLElement>) => void;
+  onScreenTouchEnd: (event: React.TouchEvent<HTMLElement>) => void;
+  onScreenTouchMove: (event: React.TouchEvent<HTMLElement>) => void;
+  onScreenTouchStart: (event: React.TouchEvent<HTMLElement>) => void;
   onStartPanning: (event: React.PointerEvent<HTMLElement>) => void;
   rotationQuarterTurns: number;
   screenAspect: string;
@@ -62,6 +75,7 @@ export function DeviceChrome({
   accessibilityPickerActive,
   accessibilityRoots,
   accessibilitySelectedId,
+  accessibilitySkeletonVisible,
   chromeProfile,
   chromeButtonsRenderedInChrome,
   chromeScreenBackingStyle,
@@ -73,6 +87,14 @@ export function DeviceChrome({
   isLoadingStream,
   isStreamError,
   onChromeButtonEvent,
+  onBottomBezelPointerCancel,
+  onBottomBezelPointerDown,
+  onBottomBezelPointerMove,
+  onBottomBezelPointerUp,
+  onBottomBezelTouchCancel,
+  onBottomBezelTouchEnd,
+  onBottomBezelTouchMove,
+  onBottomBezelTouchStart,
   onPanPointerCancel,
   onPanPointerMove,
   onPanPointerUp,
@@ -83,6 +105,10 @@ export function DeviceChrome({
   onScreenPointerDown,
   onScreenPointerMove,
   onScreenPointerUp,
+  onScreenTouchCancel,
+  onScreenTouchEnd,
+  onScreenTouchMove,
+  onScreenTouchStart,
   onStartPanning,
   rotationQuarterTurns,
   screenAspect,
@@ -136,11 +162,24 @@ export function DeviceChrome({
           onEvent={onChromeButtonEvent}
           renderImages={!chromeButtonsRenderedInChrome}
         />
+        <BottomEdgeCatcher
+          chromeScreenStyle={chromeScreenStyle}
+          onPointerCancel={onBottomBezelPointerCancel}
+          onPointerDown={onBottomBezelPointerDown}
+          onPointerMove={onBottomBezelPointerMove}
+          onPointerUp={onBottomBezelPointerUp}
+          onSimulatorInteraction={onSimulatorInteraction}
+          onTouchCancel={onBottomBezelTouchCancel}
+          onTouchEnd={onBottomBezelTouchEnd}
+          onTouchMove={onBottomBezelTouchMove}
+          onTouchStart={onBottomBezelTouchStart}
+        />
         <ScreenLayer
           accessibilityHoveredId={accessibilityHoveredId}
           accessibilityPickerActive={accessibilityPickerActive}
           accessibilityRoots={accessibilityRoots}
           accessibilitySelectedId={accessibilitySelectedId}
+          accessibilitySkeletonVisible={accessibilitySkeletonVisible}
           chromeScreenStyle={chromeScreenStyle}
           hasFrame={hasFrame}
           isBooted={isBooted}
@@ -150,6 +189,10 @@ export function DeviceChrome({
           onScreenPointerDown={onScreenPointerDown}
           onScreenPointerMove={onScreenPointerMove}
           onScreenPointerUp={onScreenPointerUp}
+          onScreenTouchCancel={onScreenTouchCancel}
+          onScreenTouchEnd={onScreenTouchEnd}
+          onScreenTouchMove={onScreenTouchMove}
+          onScreenTouchStart={onScreenTouchStart}
           onPickerHover={onPickerHover}
           onPickerSelect={onPickerSelect}
           onSimulatorInteraction={onSimulatorInteraction}
@@ -182,6 +225,7 @@ export function DeviceChrome({
         accessibilityPickerActive={accessibilityPickerActive}
         accessibilityRoots={accessibilityRoots}
         accessibilitySelectedId={accessibilitySelectedId}
+        accessibilitySkeletonVisible={accessibilitySkeletonVisible}
         chromeScreenStyle={{
           aspectRatio: screenAspect,
           ...(chromeScreenStyle ?? {}),
@@ -194,6 +238,10 @@ export function DeviceChrome({
         onScreenPointerDown={onScreenPointerDown}
         onScreenPointerMove={onScreenPointerMove}
         onScreenPointerUp={onScreenPointerUp}
+        onScreenTouchCancel={onScreenTouchCancel}
+        onScreenTouchEnd={onScreenTouchEnd}
+        onScreenTouchMove={onScreenTouchMove}
+        onScreenTouchStart={onScreenTouchStart}
         onPickerHover={onPickerHover}
         onPickerSelect={onPickerSelect}
         onSimulatorInteraction={onSimulatorInteraction}
@@ -213,6 +261,81 @@ export function DeviceChrome({
   );
 }
 
+function screenEdgeCatcherStyle(
+  chromeScreenStyle: CSSProperties | null,
+): CSSProperties | null {
+  const left =
+    typeof chromeScreenStyle?.left === "string" ? chromeScreenStyle.left : null;
+  const top =
+    typeof chromeScreenStyle?.top === "string" ? chromeScreenStyle.top : null;
+  const width =
+    typeof chromeScreenStyle?.width === "string"
+      ? chromeScreenStyle.width
+      : null;
+  const height =
+    typeof chromeScreenStyle?.height === "string"
+      ? chromeScreenStyle.height
+      : null;
+  if (!left || !top || !width || !height) {
+    return null;
+  }
+  return {
+    left,
+    top: `calc(${top} + ${height} - 2px)`,
+    width,
+  };
+}
+
+function BottomEdgeCatcher({
+  chromeScreenStyle,
+  onPointerCancel,
+  onPointerDown,
+  onPointerMove,
+  onPointerUp,
+  onSimulatorInteraction,
+  onTouchCancel,
+  onTouchEnd,
+  onTouchMove,
+  onTouchStart,
+}: {
+  chromeScreenStyle: CSSProperties | null;
+  onPointerCancel: (event: React.PointerEvent<HTMLElement>) => void;
+  onPointerDown: (event: React.PointerEvent<HTMLElement>) => void;
+  onPointerMove: (event: React.PointerEvent<HTMLElement>) => void;
+  onPointerUp: (event: React.PointerEvent<HTMLElement>) => void;
+  onSimulatorInteraction: () => void;
+  onTouchCancel: (event: React.TouchEvent<HTMLElement>) => void;
+  onTouchEnd: (event: React.TouchEvent<HTMLElement>) => void;
+  onTouchMove: (event: React.TouchEvent<HTMLElement>) => void;
+  onTouchStart: (event: React.TouchEvent<HTMLElement>) => void;
+}) {
+  const style = screenEdgeCatcherStyle(chromeScreenStyle);
+  if (!style) {
+    return null;
+  }
+  return (
+    <div
+      aria-hidden="true"
+      className="device-bottom-edge-catcher"
+      onPointerCancel={onPointerCancel}
+      onPointerDown={(event) => {
+        onSimulatorInteraction();
+        onPointerDown(event);
+      }}
+      onPointerMove={onPointerMove}
+      onPointerUp={onPointerUp}
+      onTouchCancel={onTouchCancel}
+      onTouchEnd={onTouchEnd}
+      onTouchMove={onTouchMove}
+      onTouchStart={(event) => {
+        onSimulatorInteraction();
+        onTouchStart(event);
+      }}
+      style={style}
+    />
+  );
+}
+
 const CHROME_BUTTON_WIRE_NAMES: Record<string, string> = {
   action: "action",
   "digital-crown": "digital-crown",
@@ -468,6 +591,7 @@ interface ScreenLayerProps {
   accessibilityPickerActive: boolean;
   accessibilityRoots: AccessibilityNode[];
   accessibilitySelectedId: string;
+  accessibilitySkeletonVisible: boolean;
   chromeScreenStyle: CSSProperties | null;
   hasFrame: boolean;
   isBooted: boolean;
@@ -477,6 +601,10 @@ interface ScreenLayerProps {
   onScreenPointerDown: (event: React.PointerEvent<HTMLElement>) => void;
   onScreenPointerMove: (event: React.PointerEvent<HTMLElement>) => void;
   onScreenPointerUp: (event: React.PointerEvent<HTMLElement>) => void;
+  onScreenTouchCancel: (event: React.TouchEvent<HTMLElement>) => void;
+  onScreenTouchEnd: (event: React.TouchEvent<HTMLElement>) => void;
+  onScreenTouchMove: (event: React.TouchEvent<HTMLElement>) => void;
+  onScreenTouchStart: (event: React.TouchEvent<HTMLElement>) => void;
   onPickerHover: (id: string | null) => void;
   onPickerSelect: (id: string) => void;
   onSimulatorInteraction: () => void;
@@ -498,6 +626,7 @@ function ScreenLayer({
   accessibilityPickerActive,
   accessibilityRoots,
   accessibilitySelectedId,
+  accessibilitySkeletonVisible,
   chromeScreenStyle,
   hasFrame,
   isBooted,
@@ -507,6 +636,10 @@ function ScreenLayer({
   onScreenPointerDown,
   onScreenPointerMove,
   onScreenPointerUp,
+  onScreenTouchCancel,
+  onScreenTouchEnd,
+  onScreenTouchMove,
+  onScreenTouchStart,
   onPickerHover,
   onPickerSelect,
   onSimulatorInteraction,
@@ -538,6 +671,13 @@ function ScreenLayer({
       }}
       onPointerMove={onScreenPointerMove}
       onPointerUp={onScreenPointerUp}
+      onTouchCancel={onScreenTouchCancel}
+      onTouchEnd={onScreenTouchEnd}
+      onTouchMove={onScreenTouchMove}
+      onTouchStart={(event) => {
+        onSimulatorInteraction();
+        onScreenTouchStart(event);
+      }}
       style={chromeScreenStyle ?? undefined}
     >
       <canvas
@@ -559,9 +699,14 @@ function ScreenLayer({
         hoveredId={accessibilityHoveredId}
         roots={accessibilityRoots}
         selectedId={accessibilitySelectedId}
+        skeletonVisible={accessibilitySkeletonVisible}
       />
       {touchOverlayVisible ? (
-        <TouchInteractionOverlay indicators={touchIndicators} />
+        <TouchInteractionOverlay
+          indicators={touchIndicators.filter(
+            (indicator) => (indicator.space ?? "screen") === "screen",
+          )}
+        />
       ) : null}
       {accessibilityPickerActive ? (
         <div
diff --git a/packages/client/src/features/viewport/SimulatorViewport.tsx b/packages/client/src/features/viewport/SimulatorViewport.tsx
index df9541c0..0888c022 100644
--- a/packages/client/src/features/viewport/SimulatorViewport.tsx
+++ b/packages/client/src/features/viewport/SimulatorViewport.tsx
@@ -17,6 +17,7 @@ interface SimulatorViewportProps {
   accessibilityPickerActive: boolean;
   accessibilityRoots: AccessibilityNode[];
   accessibilitySelectedId: string;
+  accessibilitySkeletonVisible: boolean;
   chromeProfile: ChromeProfile | null;
   chromeLoaded: boolean;
   chromeRequired: boolean;
@@ -46,6 +47,14 @@ interface SimulatorViewportProps {
     usage?: number,
   ) => void;
   chromeButtonUrl: (button: string, pressed?: boolean) => string;
+  onBottomBezelPointerCancel: (event: React.PointerEvent<HTMLElement>) => void;
+  onBottomBezelPointerDown: (event: React.PointerEvent<HTMLElement>) => void;
+  onBottomBezelPointerMove: (event: React.PointerEvent<HTMLElement>) => void;
+  onBottomBezelPointerUp: (event: React.PointerEvent<HTMLElement>) => void;
+  onBottomBezelTouchCancel: (event: React.TouchEvent<HTMLElement>) => void;
+  onBottomBezelTouchEnd: (event: React.TouchEvent<HTMLElement>) => void;
+  onBottomBezelTouchMove: (event: React.TouchEvent<HTMLElement>) => void;
+  onBottomBezelTouchStart: (event: React.TouchEvent<HTMLElement>) => void;
   onPanPointerMove: (event: React.PointerEvent<HTMLElement>) => void;
   onPanPointerUp: () => void;
   onPickerHover: (id: string | null) => void;
@@ -56,6 +65,10 @@ interface SimulatorViewportProps {
   onScreenPointerDown: (event: React.PointerEvent<HTMLElement>) => void;
   onScreenPointerMove: (event: React.PointerEvent<HTMLElement>) => void;
   onScreenPointerUp: (event: React.PointerEvent<HTMLElement>) => void;
+  onScreenTouchCancel: (event: React.TouchEvent<HTMLElement>) => void;
+  onScreenTouchEnd: (event: React.TouchEvent<HTMLElement>) => void;
+  onScreenTouchMove: (event: React.TouchEvent<HTMLElement>) => void;
+  onScreenTouchStart: (event: React.TouchEvent<HTMLElement>) => void;
   onStartPanning: (event: React.PointerEvent<HTMLElement>) => void;
   onZoomActual: () => void;
   onZoomCenter: () => void;
@@ -88,6 +101,7 @@ export function SimulatorViewport({
   accessibilityPickerActive,
   accessibilityRoots,
   accessibilitySelectedId,
+  accessibilitySkeletonVisible,
   debugPanel,
   chromeProfile,
   chromeLoaded,
@@ -113,6 +127,14 @@ export function SimulatorViewport({
   onAppInstallDrop,
   onChromeButtonEvent,
   chromeButtonUrl,
+  onBottomBezelPointerCancel,
+  onBottomBezelPointerDown,
+  onBottomBezelPointerMove,
+  onBottomBezelPointerUp,
+  onBottomBezelTouchCancel,
+  onBottomBezelTouchEnd,
+  onBottomBezelTouchMove,
+  onBottomBezelTouchStart,
   onPanPointerMove,
   onPanPointerUp,
   onPickerHover,
@@ -123,6 +145,10 @@ export function SimulatorViewport({
   onScreenPointerDown,
   onScreenPointerMove,
   onScreenPointerUp,
+  onScreenTouchCancel,
+  onScreenTouchEnd,
+  onScreenTouchMove,
+  onScreenTouchStart,
   onStartPanning,
   onZoomActual,
   onZoomCenter,
@@ -202,6 +228,7 @@ export function SimulatorViewport({
                   accessibilityPickerActive={accessibilityPickerActive}
                   accessibilityRoots={accessibilityRoots}
                   accessibilitySelectedId={accessibilitySelectedId}
+                  accessibilitySkeletonVisible={accessibilitySkeletonVisible}
                   chromeProfile={chromeProfile}
                   chromeButtonsRenderedInChrome={chromeButtonsRenderedInChrome}
                   chromeScreenBackingStyle={chromeScreenBackingStyle}
@@ -213,6 +240,14 @@ export function SimulatorViewport({
                   isLoadingStream={showScreenLoading}
                   isStreamError={isStreamError}
                   onChromeButtonEvent={onChromeButtonEvent}
+                  onBottomBezelPointerCancel={onBottomBezelPointerCancel}
+                  onBottomBezelPointerDown={onBottomBezelPointerDown}
+                  onBottomBezelPointerMove={onBottomBezelPointerMove}
+                  onBottomBezelPointerUp={onBottomBezelPointerUp}
+                  onBottomBezelTouchCancel={onBottomBezelTouchCancel}
+                  onBottomBezelTouchEnd={onBottomBezelTouchEnd}
+                  onBottomBezelTouchMove={onBottomBezelTouchMove}
+                  onBottomBezelTouchStart={onBottomBezelTouchStart}
                   onPanPointerCancel={onPanPointerUp}
                   onPanPointerMove={onPanPointerMove}
                   onPanPointerUp={onPanPointerUp}
@@ -223,6 +258,10 @@ export function SimulatorViewport({
                   onScreenPointerDown={onScreenPointerDown}
                   onScreenPointerMove={onScreenPointerMove}
                   onScreenPointerUp={onScreenPointerUp}
+                  onScreenTouchCancel={onScreenTouchCancel}
+                  onScreenTouchEnd={onScreenTouchEnd}
+                  onScreenTouchMove={onScreenTouchMove}
+                  onScreenTouchStart={onScreenTouchStart}
                   onStartPanning={onStartPanning}
                   rotationQuarterTurns={rotationQuarterTurns}
                   screenAspect={screenAspect}
@@ -246,6 +285,9 @@ export function SimulatorViewport({
             <p>{isLoading ? "Loading simulators…" : "Select a simulator"}</p>
           </div>
         )}
+        {touchOverlayVisible ? (
+          <CanvasTouchInteractionOverlay indicators={touchIndicators} />
+        ) : null}
         {showDeviceLoading ? (
           <div
             aria-label="Loading simulator"
@@ -289,3 +331,30 @@ export function SimulatorViewport({
     </div>
   );
 }
+
+function CanvasTouchInteractionOverlay({
+  indicators,
+}: {
+  indicators: TouchIndicator[];
+}) {
+  const canvasIndicators = indicators.filter(
+    (indicator) => indicator.space === "canvas",
+  );
+  if (canvasIndicators.length === 0) {
+    return null;
+  }
+  return (
+    <div className="canvas-touch-interaction-overlay" aria-hidden="true">
+      {canvasIndicators.map((indicator) => (
+        <span
+          className={`touch-indicator touch-indicator-${indicator.phase}`}
+          key={indicator.id}
+          style={{
+            left: `${indicator.x}px`,
+            top: `${indicator.y}px`,
+          }}
+        />
+      ))}
+    </div>
+  );
+}
diff --git a/packages/client/src/features/viewport/types.ts b/packages/client/src/features/viewport/types.ts
index c2159095..ee4556c5 100644
--- a/packages/client/src/features/viewport/types.ts
+++ b/packages/client/src/features/viewport/types.ts
@@ -10,9 +10,17 @@ export interface Point {
   y: number;
 }
 
+export interface TouchPreviewPoint extends Point {
+  clientX?: number;
+  clientY?: number;
+  pageX?: number;
+  pageY?: number;
+}
+
 export interface TouchIndicator {
   id: number;
   phase: "began" | "moved" | "ended" | "cancelled";
+  space?: "screen" | "canvas";
   x: number;
   y: number;
 }
diff --git a/packages/client/src/features/viewport/viewportMath.test.ts b/packages/client/src/features/viewport/viewportMath.test.ts
index c3b8ab44..9789de22 100644
--- a/packages/client/src/features/viewport/viewportMath.test.ts
+++ b/packages/client/src/features/viewport/viewportMath.test.ts
@@ -9,6 +9,7 @@ import {
   computeChromeScreenRect,
   computeFitScale,
   mapDisplayedPointToNaturalOrientation,
+  mapNaturalPointToDisplayedOrientation,
   shellSize,
 } from "./viewportMath";
 
@@ -188,6 +189,22 @@ describe("viewportMath", () => {
     });
   });
 
+  it("maps natural stream points back to displayed overlay coordinates", () => {
+    const displayed = { x: 0.2, y: 0.75 };
+    const natural = mapDisplayedPointToNaturalOrientation(displayed, 1);
+    const remapped = mapNaturalPointToDisplayedOrientation(natural, 1);
+
+    expect(remapped.x).toBeCloseTo(displayed.x);
+    expect(remapped.y).toBeCloseTo(displayed.y);
+
+    const remappedCounterClockwise = mapNaturalPointToDisplayedOrientation(
+      mapDisplayedPointToNaturalOrientation(displayed, 3),
+      3,
+    );
+    expect(remappedCounterClockwise.x).toBeCloseTo(displayed.x);
+    expect(remappedCounterClockwise.y).toBeCloseTo(displayed.y);
+  });
+
   it("builds a quarter-turn transform around the shell origin", () => {
     const portrait = shellSize({ width: 300, height: 650 }, null, 0);
     expect(
diff --git a/packages/client/src/features/viewport/viewportMath.ts b/packages/client/src/features/viewport/viewportMath.ts
index 2ebee5db..1f1d2b1f 100644
--- a/packages/client/src/features/viewport/viewportMath.ts
+++ b/packages/client/src/features/viewport/viewportMath.ts
@@ -86,6 +86,22 @@ export function mapDisplayedPointToNaturalOrientation(
   }
 }
 
+export function mapNaturalPointToDisplayedOrientation(
+  point: Point,
+  rotationQuarterTurns: number,
+): Point {
+  switch (normalizeQuarterTurns(rotationQuarterTurns)) {
+    case 1:
+      return { x: 1 - point.y, y: point.x };
+    case 2:
+      return { x: 1 - point.x, y: 1 - point.y };
+    case 3:
+      return { x: point.y, y: 1 - point.x };
+    default:
+      return point;
+  }
+}
+
 export function computeChromeScreenRect(
   chromeProfile: ChromeProfile | null,
   _deviceNaturalSize: Size | null,
diff --git a/packages/client/src/styles/base.css b/packages/client/src/styles/base.css
index 037aceb7..14db288b 100644
--- a/packages/client/src/styles/base.css
+++ b/packages/client/src/styles/base.css
@@ -5,12 +5,17 @@
   margin: 0;
 }
 
+html {
+  overscroll-behavior: none;
+}
+
 body {
   font-family:
     -apple-system, BlinkMacSystemFont, "Segoe UI", system-ui, sans-serif;
   font-size: 13px;
   background: var(--bg);
   color: var(--text);
+  overscroll-behavior: none;
   overflow: hidden;
 }
 
diff --git a/packages/client/src/styles/components.css b/packages/client/src/styles/components.css
index 2fcf1373..a8123982 100644
--- a/packages/client/src/styles/components.css
+++ b/packages/client/src/styles/components.css
@@ -1703,6 +1703,7 @@ a.hierarchy-node-source:hover,
   position: absolute;
   inset: 0;
   display: grid;
+  gap: 10px;
   place-items: center;
   padding: 18px;
   color: var(--text-muted);
@@ -1716,17 +1717,6 @@ a.hierarchy-node-source:hover,
   color: var(--error);
 }
 
-.webkit-warnings {
-  flex: 0 0 auto;
-  max-height: 96px;
-  overflow: auto;
-  padding: 7px 10px;
-  border-top: 1px solid var(--border-subtle);
-  color: var(--text-muted);
-  font-size: 11px;
-  line-height: 1.35;
-}
-
 .console-panel {
   flex: 1;
   overflow: auto;
@@ -2457,28 +2447,57 @@ a.hierarchy-node-source:hover,
   z-index: 0;
 }
 
+.device-bottom-edge-catcher {
+  position: absolute;
+  height: min(12%, 56px);
+  cursor: crosshair;
+  pointer-events: auto;
+  touch-action: none;
+  z-index: 2;
+}
+
 .device-chrome-button {
   position: absolute;
   display: block;
   padding: 0;
   border: 0;
+  border-radius: 4px;
   background: transparent;
   cursor: pointer;
+  overflow: hidden;
   pointer-events: auto;
   touch-action: none;
   transform: translate3d(var(--button-rest-x, 0), var(--button-rest-y, 0), 0);
   transition: transform 180ms cubic-bezier(0.16, 1, 0.3, 1);
+  appearance: none;
   -webkit-tap-highlight-color: transparent;
   will-change: transform;
   z-index: 1;
 }
 
+.device-chrome-button-left {
+  border-radius: 5px 0 0 5px;
+}
+
+.device-chrome-button-right {
+  border-radius: 0 5px 5px 0;
+}
+
+.device-chrome-button-top {
+  border-radius: 5px 5px 0 0;
+}
+
+.device-chrome-button-bottom {
+  border-radius: 0 0 5px 5px;
+}
+
 .device-chrome-button img {
   position: absolute;
   inset: 0;
   display: block;
   width: 100%;
   height: 100%;
+  border-radius: inherit;
   pointer-events: none;
   user-select: none;
   -webkit-user-drag: none;
@@ -2625,6 +2644,14 @@ a.hierarchy-node-source:hover,
   pointer-events: none;
 }
 
+.canvas-touch-interaction-overlay {
+  position: absolute;
+  inset: 0;
+  z-index: 6;
+  overflow: visible;
+  pointer-events: none;
+}
+
 .touch-indicator {
   position: absolute;
   width: 30px;
@@ -2668,6 +2695,12 @@ a.hierarchy-node-source:hover,
   background: color-mix(in srgb, var(--accent) 12%, transparent);
 }
 
+.accessibility-rect.skeleton {
+  border-color: rgba(78, 185, 255, 0.38);
+  background: rgba(78, 185, 255, 0.055);
+  box-shadow: none;
+}
+
 .accessibility-rect.selected {
   border-color: var(--accent);
   background: color-mix(in srgb, var(--accent) 18%, transparent);
diff --git a/packages/client/src/styles/tokens.css b/packages/client/src/styles/tokens.css
index c8fd552a..c08130c0 100644
--- a/packages/client/src/styles/tokens.css
+++ b/packages/client/src/styles/tokens.css
@@ -17,7 +17,7 @@
   --success-bg: rgba(78, 201, 176, 0.12);
   --error: #f14c4c;
   --error-bg: rgba(241, 76, 76, 0.1);
-  --canvas-bg: #1a1a1a;
+  --canvas-bg: #000000;
   --bezel: #111111;
   --bezel-highlight: rgba(255, 255, 255, 0.06);
   --screen-bg: #000000;
diff --git a/packages/server/native/DFPrivateSimulatorDisplayBridge.h b/packages/server/native/DFPrivateSimulatorDisplayBridge.h
index 5bdef2a7..e1563bfa 100644
--- a/packages/server/native/DFPrivateSimulatorDisplayBridge.h
+++ b/packages/server/native/DFPrivateSimulatorDisplayBridge.h
@@ -70,6 +70,12 @@ NS_SWIFT_NAME(PrivateSimulatorDisplayBridge)
                                 phase:(DFPrivateSimulatorTouchPhase)phase
                                 error:(NSError * _Nullable * _Nullable)error NS_SWIFT_NAME(sendMultiTouch(normalizedX1:normalizedY1:normalizedX2:normalizedY2:phase:));
 
+- (BOOL)sendScrollWithDeltaX:(double)deltaX
+                      deltaY:(double)deltaY
+                 normalizedX:(double)normalizedX
+                 normalizedY:(double)normalizedY
+                       error:(NSError * _Nullable * _Nullable)error NS_SWIFT_NAME(sendScroll(deltaX:deltaY:normalizedX:normalizedY:));
+
 - (BOOL)sendKeyCode:(uint16_t)keyCode
           modifiers:(NSUInteger)modifiers
               error:(NSError * _Nullable * _Nullable)error NS_SWIFT_NAME(sendKey(keyCode:modifiers:));
diff --git a/packages/server/native/DFPrivateSimulatorDisplayBridge.m b/packages/server/native/DFPrivateSimulatorDisplayBridge.m
index 39ddcaac..83855db7 100644
--- a/packages/server/native/DFPrivateSimulatorDisplayBridge.m
+++ b/packages/server/native/DFPrivateSimulatorDisplayBridge.m
@@ -92,6 +92,7 @@
 #pragma pack(pop)
 
 static const uint32_t DFIndigoDigitizerTarget = 0x32;
+static const uint32_t DFIndigoPointerTarget = 0x2;
 static const uint32_t DFIndigoDigitalCrownTarget = 0x34;
 static const uint8_t DFIndigoEventTypeTouch = 0x02;
 static const uint32_t DFIndigoTouchEventKind = 0x0b;
@@ -1724,6 +1725,38 @@ static id DFCreateSimulatorKitHIDClientForDevice(id device, NSError **error) {
     return message;
 }
 
+static IndigoHIDMessage *DFCreatePointerMoveHIDMessage(CGPoint normalizedPoint, NSSize displaySize, NSError **error) {
+    DFIndigoHIDMessageForMouseNSEventFn mouseMessage = (DFIndigoHIDMessageForMouseNSEventFn)dlsym(RTLD_DEFAULT, "IndigoHIDMessageForMouseNSEvent");
+    if (mouseMessage == NULL) {
+        if (error != NULL) {
+            *error = DFMakeError(
+                DFPrivateSimulatorErrorCodeTouchDispatchFailed,
+                @"SimulatorKit did not expose IndigoHIDMessageForMouseNSEvent."
+            );
+        }
+        return NULL;
+    }
+
+    CGPoint pixelPoint = CGPointMake(
+        fmax(0.0, fmin(1.0, normalizedPoint.x)) * displaySize.width,
+        fmax(0.0, fmin(1.0, normalizedPoint.y)) * displaySize.height
+    );
+    IndigoHIDMessage *message = mouseMessage(&pixelPoint,
+                                             NULL,
+                                             DFIndigoPointerTarget,
+                                             NSEventTypeMouseMoved,
+                                             displaySize,
+                                             DFIndigoHIDEdgeNone);
+    if (message == NULL && error != NULL) {
+        *error = DFMakeError(
+            DFPrivateSimulatorErrorCodeTouchDispatchFailed,
+            @"SimulatorKit could not construct a pointer move HID packet for scroll input."
+        );
+    }
+
+    return message;
+}
+
 static IndigoHIDMessage *DFCreateDigitalCrownHIDMessage(double delta, NSError **error) {
     DFIndigoHIDMessageForDigitalCrownEventFn crownMessage = (DFIndigoHIDMessageForDigitalCrownEventFn)dlsym(RTLD_DEFAULT, "IndigoHIDMessageForDigitalCrownEvent");
     if (crownMessage == NULL) {
@@ -2729,6 +2762,9 @@ @implementation DFPrivateSimulatorDisplayBridge {
     NSView *_headlessHostView;
     NSUUID *_screenAdapterCallbackUUID;
     NSUUID *_screenCallbackUUID;
+    NSUUID *_ioSurfaceCallbackUUID;
+    NSUUID *_damageRectanglesCallbackUUID;
+    NSUUID *_displayPropertiesCallbackUUID;
     CVPixelBufferRef _latestPixelBuffer;
     CVPixelBufferRef _pendingDelegatePixelBuffer;
     NSString *_displayStatusValue;
@@ -2737,6 +2773,8 @@ @implementation DFPrivateSimulatorDisplayBridge {
     CGPoint _lastTouchPoint;
     BOOL _hasLastTouchPoint;
     BOOL _hasLoggedFirstFrame;
+    NSUInteger _screenFrameCallbackCount;
+    NSUInteger _damageRectanglesCallbackCount;
     BOOL _isActivatingDisplay;
     BOOL _hasActivatedDisplay;
     BOOL _digitizerInputReady;
@@ -2800,6 +2838,66 @@ - (void)notifyDelegateOfStatus:(NSString *)status isReady:(BOOL)isReady {
     });
 }
 
+- (void)notifyDirectFrameFromSource:(NSString *)source {
+    if (_latestPixelBuffer == nil) {
+        return;
+    }
+
+    _screenFrameCallbackCount += 1;
+    if (![_displayStatusValue hasPrefix:@"Receiving headless screen frames"]) {
+        DFLog(@"Receiving headless screen frames via %@", source ?: @"CoreSimulator callback");
+    }
+    if (!_hasLoggedFirstFrame) {
+        _hasLoggedFirstFrame = YES;
+        [self updateStatus:@"Receiving headless screen frames"];
+    }
+    [self notifyDelegateOfFrame:_latestPixelBuffer];
+}
+
+- (void)updateLatestPixelBufferWithSurface:(id)surface maskedSurface:(id)maskedSurface source:(NSString *)source {
+    (void)maskedSurface;
+    if (surface == nil) {
+        return;
+    }
+
+    CVPixelBufferRef pixelBuffer = DFCreatePixelBufferFromSurface((__bridge IOSurfaceRef)surface);
+    if (pixelBuffer == nil) {
+        [self updateStatus:[NSString stringWithFormat:@"%@ surfaced an unsupported IOSurface", source ?: @"CoreSimulator"]];
+        return;
+    }
+
+    if (_latestPixelBuffer != nil) {
+        CVPixelBufferRelease(_latestPixelBuffer);
+    }
+    _latestPixelBuffer = pixelBuffer;
+    size_t width = CVPixelBufferGetWidth(pixelBuffer);
+    size_t height = CVPixelBufferGetHeight(pixelBuffer);
+    _displayPixelSize = CGSizeMake((CGFloat)width, (CGFloat)height);
+    DFReconcileRotationWithDisplaySize(&_deviceRotationDegrees, _displayPixelSize);
+    [self notifyDelegateOfFrame:pixelBuffer];
+    DFRunOnMainAsync(^{
+        if (self->_headlessHostWindow != nil) {
+            NSSize windowSize = NSMakeSize((CGFloat)width, (CGFloat)height);
+            [self->_headlessHostWindow setContentSize:windowSize];
+            self->_headlessHostView.frame = NSMakeRect(0, 0, windowSize.width, windowSize.height);
+        }
+        DFConfigureDisplayGeometry(self->_displayView, self->_displayPixelSize);
+        if (self->_digitizerInputView != nil) {
+            [self->_digitizerInputView setFrame:NSMakeRect(0, 0, (CGFloat)width, (CGFloat)height)];
+        }
+    });
+    [self updateStatus:[NSString stringWithFormat:@"Private display ready (%zux%zu)", width, height]];
+}
+
+- (void)handleDisplayPropertiesChanged:(id)properties source:(NSString *)source {
+    DFLog(@"%@ properties updated: class=%@", source ?: @"Headless screen", properties != nil ? NSStringFromClass([properties class]) : @"(nil)");
+    if (properties != nil && [properties respondsToSelector:sel_registerName("uiOrientation")]) {
+        NSInteger uiOrientation = ((NSInteger(*)(id, SEL))objc_msgSend)(properties, sel_registerName("uiOrientation"));
+        DFLog(@"%@ uiOrientation=%ld", source ?: @"Headless screen", (long)uiOrientation);
+    }
+    [self updateStatus:@"Headless screen properties updated"];
+}
+
 - (void)notifyDelegateOfFrame:(CVPixelBufferRef)pixelBuffer {
     if (pixelBuffer == nil) {
         return;
@@ -3115,6 +3213,81 @@ - (nullable instancetype)initWithUDID:(NSString *)udid
         return nil;
     }
 
+    SEL registerIOSurfacesSelector = sel_registerName("registerCallbackWithUUID:ioSurfacesChangeCallback:");
+    if ([rawScreen respondsToSelector:registerIOSurfacesSelector]) {
+        _ioSurfaceCallbackUUID = [NSUUID UUID];
+        ((void(*)(id, SEL, id, id))objc_msgSend)(
+            rawScreen,
+            registerIOSurfacesSelector,
+            _ioSurfaceCallbackUUID,
+            ^(id surface, id maskedSurface) {
+                __strong typeof(weakSelf) strongSelf = weakSelf;
+                if (strongSelf == nil) {
+                    return;
+                }
+                dispatch_async(strongSelf->_callbackQueue, ^{
+                    [strongSelf updateLatestPixelBufferWithSurface:surface
+                                                     maskedSurface:maskedSurface
+                                                            source:@"SimDisplayIOSurfaceRenderable"];
+                });
+            }
+        );
+
+        id framebufferSurface = DFSendObjectIfResponds(rawScreen, "framebufferSurface");
+        id maskedFramebufferSurface = DFSendObjectIfResponds(rawScreen, "maskedFramebufferSurface");
+        if (framebufferSurface != nil) {
+            [self updateLatestPixelBufferWithSurface:framebufferSurface
+                                      maskedSurface:maskedFramebufferSurface
+                                             source:@"SimDisplayIOSurfaceRenderable"];
+        }
+        DFLog(@"Registered direct SimDisplayIOSurfaceRenderable callback for screen %u", _activeScreenID);
+    } else {
+        DFLog(@"Selected CoreSimulator screen does not expose SimDisplayIOSurfaceRenderable callbacks for %@", udid);
+    }
+
+    SEL registerDamageSelector = sel_registerName("registerCallbackWithUUID:damageRectanglesCallback:");
+    if ([rawScreen respondsToSelector:registerDamageSelector]) {
+        _damageRectanglesCallbackUUID = [NSUUID UUID];
+        ((void(*)(id, SEL, id, id))objc_msgSend)(
+            rawScreen,
+            registerDamageSelector,
+            _damageRectanglesCallbackUUID,
+            ^(__unused id damageRectangles) {
+                __strong typeof(weakSelf) strongSelf = weakSelf;
+                if (strongSelf == nil) {
+                    return;
+                }
+                dispatch_async(strongSelf->_callbackQueue, ^{
+                    strongSelf->_damageRectanglesCallbackCount += 1;
+                    [strongSelf notifyDirectFrameFromSource:@"SimDisplayRenderable damage callback"];
+                });
+            }
+        );
+        DFLog(@"Registered direct SimDisplayRenderable damage callback for screen %u", _activeScreenID);
+    } else {
+        DFLog(@"Selected CoreSimulator screen does not expose SimDisplayRenderable damage callbacks for %@", udid);
+    }
+
+    SEL registerDisplayPropertiesSelector = sel_registerName("registerCallbackWithUUID:displayPropertiesChanged:");
+    if ([rawScreen respondsToSelector:registerDisplayPropertiesSelector]) {
+        _displayPropertiesCallbackUUID = [NSUUID UUID];
+        ((void(*)(id, SEL, id, id))objc_msgSend)(
+            rawScreen,
+            registerDisplayPropertiesSelector,
+            _displayPropertiesCallbackUUID,
+            ^(id properties) {
+                __strong typeof(weakSelf) strongSelf = weakSelf;
+                if (strongSelf == nil) {
+                    return;
+                }
+                dispatch_async(strongSelf->_callbackQueue, ^{
+                    [strongSelf handleDisplayPropertiesChanged:properties source:@"SimDisplayRenderable"];
+                });
+            }
+        );
+        DFLog(@"Registered direct SimDisplayRenderable display-properties callback for screen %u", _activeScreenID);
+    }
+
     _screenCallbackUUID = [NSUUID UUID];
     ((void(*)(id, SEL, id, id, id, id, id))objc_msgSend)(
         rawScreen,
@@ -3126,58 +3299,23 @@ - (nullable instancetype)initWithUDID:(NSString *)udid
             if (strongSelf == nil || strongSelf->_latestPixelBuffer == nil) {
                 return;
             }
-            if (!strongSelf->_hasLoggedFirstFrame) {
-                strongSelf->_hasLoggedFirstFrame = YES;
-                [strongSelf updateStatus:@"Receiving headless screen frames"];
-            }
-            [strongSelf notifyDelegateOfFrame:strongSelf->_latestPixelBuffer];
+            [strongSelf notifyDirectFrameFromSource:@"screen callback"];
         },
         ^(id surface, id maskedSurface) {
-            (void)maskedSurface;
             __strong typeof(weakSelf) strongSelf = weakSelf;
             if (strongSelf == nil) {
                 return;
             }
-
-            CVPixelBufferRef pixelBuffer = DFCreatePixelBufferFromSurface((__bridge IOSurfaceRef)surface);
-            if (pixelBuffer == nil) {
-                [strongSelf updateStatus:@"Headless screen surfaced an unsupported IOSurface"];
-                return;
-            }
-
-            if (strongSelf->_latestPixelBuffer != nil) {
-                CVPixelBufferRelease(strongSelf->_latestPixelBuffer);
-            }
-            strongSelf->_latestPixelBuffer = pixelBuffer;
-            size_t width = CVPixelBufferGetWidth(pixelBuffer);
-            size_t height = CVPixelBufferGetHeight(pixelBuffer);
-            strongSelf->_displayPixelSize = CGSizeMake((CGFloat)width, (CGFloat)height);
-            DFReconcileRotationWithDisplaySize(&strongSelf->_deviceRotationDegrees, strongSelf->_displayPixelSize);
-            [strongSelf notifyDelegateOfFrame:pixelBuffer];
-            DFRunOnMainAsync(^{
-                if (strongSelf->_headlessHostWindow != nil) {
-                    NSSize windowSize = NSMakeSize((CGFloat)width, (CGFloat)height);
-                    [strongSelf->_headlessHostWindow setContentSize:windowSize];
-                    strongSelf->_headlessHostView.frame = NSMakeRect(0, 0, windowSize.width, windowSize.height);
-                }
-                DFConfigureDisplayGeometry(strongSelf->_displayView, strongSelf->_displayPixelSize);
-                if (strongSelf->_digitizerInputView != nil) {
-                    [strongSelf->_digitizerInputView setFrame:NSMakeRect(0, 0, (CGFloat)width, (CGFloat)height)];
-                }
-            });
-            [strongSelf updateStatus:[NSString stringWithFormat:@"Private display ready (%zux%zu)", width, height]];
+            [strongSelf updateLatestPixelBufferWithSurface:surface
+                                             maskedSurface:maskedSurface
+                                                    source:@"Headless screen"];
         },
         ^(id properties) {
             __strong typeof(weakSelf) strongSelf = weakSelf;
             if (strongSelf == nil) {
                 return;
             }
-            DFLog(@"Headless screen properties updated: class=%@", properties != nil ? NSStringFromClass([properties class]) : @"(nil)");
-            if (properties != nil && [properties respondsToSelector:sel_registerName("uiOrientation")]) {
-                NSInteger uiOrientation = ((NSInteger(*)(id, SEL))objc_msgSend)(properties, sel_registerName("uiOrientation"));
-                DFLog(@"Headless screen uiOrientation=%ld", (long)uiOrientation);
-            }
-            [strongSelf updateStatus:@"Headless screen properties updated"];
+            [strongSelf handleDisplayPropertiesChanged:properties source:@"Headless screen"];
         }
     );
 
@@ -3191,8 +3329,19 @@ - (nullable instancetype)initWithUDID:(NSString *)udid
         DFSpinRunLoop(0.05);
     }
     if (_latestPixelBuffer == nil) {
-        [self updateStatus:@"Direct CoreSimulator frames unavailable; attaching SimulatorKit fallback display"];
-        [self activateDisplayIfNeeded];
+        [self updateStatus:@"Direct CoreSimulator frames unavailable"];
+        DFLog(@"Direct CoreSimulator IOSurface unavailable for %@; skipping SimulatorKit display fallback to avoid visible host windows.", udid);
+    } else if (_screenFrameCallbackCount == 0) {
+        NSDate *directCallbackDeadline = [NSDate dateWithTimeIntervalSinceNow:1.0];
+        while (_screenFrameCallbackCount == 0 && [directCallbackDeadline timeIntervalSinceNow] > 0) {
+            DFSpinRunLoop(0.05);
+        }
+        if (_screenFrameCallbackCount == 0) {
+            DFLog(@"CoreSimulator exposed an IOSurface for %@ but did not deliver direct frame ticks within startup window; continuing without SimulatorKit display fallback. damageCallbacks=%@", udid, @(_damageRectanglesCallbackCount));
+            [self updateStatus:@"Private display ready; waiting for direct frame ticks"];
+        } else {
+            DFLog(@"Using direct CoreSimulator screen callbacks without activating SimulatorKit fallback display.");
+        }
     } else {
         DFLog(@"Using direct CoreSimulator screen callbacks without activating SimulatorKit fallback display.");
     }
@@ -3894,8 +4043,24 @@ - (void)disconnect {
 
         NSDictionary<NSNumber *, id> *screens = DFReadAvailableAdapterScreens(self->_screenAdapterHost, self->_screenAdapter);
         id rawScreen = screens[@(self->_activeScreenID)];
+        if (rawScreen == nil) {
+            rawScreen = self->_rawScreen;
+        }
+        if (rawScreen != nil && self->_ioSurfaceCallbackUUID != nil && [rawScreen respondsToSelector:sel_registerName("unregisterIOSurfacesChangeCallbackWithUUID:")]) {
+            ((void(*)(id, SEL, id))objc_msgSend)(rawScreen, sel_registerName("unregisterIOSurfacesChangeCallbackWithUUID:"), self->_ioSurfaceCallbackUUID);
+            self->_ioSurfaceCallbackUUID = nil;
+        }
+        if (rawScreen != nil && self->_damageRectanglesCallbackUUID != nil && [rawScreen respondsToSelector:sel_registerName("unregisterDamageRectanglesCallbackWithUUID:")]) {
+            ((void(*)(id, SEL, id))objc_msgSend)(rawScreen, sel_registerName("unregisterDamageRectanglesCallbackWithUUID:"), self->_damageRectanglesCallbackUUID);
+            self->_damageRectanglesCallbackUUID = nil;
+        }
+        if (rawScreen != nil && self->_displayPropertiesCallbackUUID != nil && [rawScreen respondsToSelector:sel_registerName("unregisterDisplayPropertiesChangedCallbackWithUUID:")]) {
+            ((void(*)(id, SEL, id))objc_msgSend)(rawScreen, sel_registerName("unregisterDisplayPropertiesChangedCallbackWithUUID:"), self->_displayPropertiesCallbackUUID);
+            self->_displayPropertiesCallbackUUID = nil;
+        }
         if (rawScreen != nil && self->_screenCallbackUUID != nil && [rawScreen respondsToSelector:sel_registerName("unregisterScreenCallbacksWithUUID:")]) {
             ((void(*)(id, SEL, id))objc_msgSend)(rawScreen, sel_registerName("unregisterScreenCallbacksWithUUID:"), self->_screenCallbackUUID);
+            self->_screenCallbackUUID = nil;
         }
 
         if (self->_latestPixelBuffer != nil) {
@@ -4305,6 +4470,101 @@ - (BOOL)sendMultiTouchAtNormalizedX1:(double)normalizedX1
     return success;
 }
 
+- (BOOL)sendScrollWithDeltaX:(double)deltaX
+                      deltaY:(double)deltaY
+                 normalizedX:(double)normalizedX
+                 normalizedY:(double)normalizedY
+                       error:(NSError * _Nullable __autoreleasing *)error {
+    if (!isfinite(deltaX) || !isfinite(deltaY) || !isfinite(normalizedX) || !isfinite(normalizedY)) {
+        if (error != NULL) {
+            *error = DFMakeError(
+                DFPrivateSimulatorErrorCodeTouchDispatchFailed,
+                @"Scroll deltas and coordinates must be finite."
+            );
+        }
+        return NO;
+    }
+
+    __block BOOL success = NO;
+    __block NSError *dispatchError = nil;
+
+    dispatch_block_t work = ^{
+        if (self->_inputFamily == DFSimulatorInputFamilyTV) {
+            dispatchError = DFMakeError(
+                DFPrivateSimulatorErrorCodeTouchDispatchFailed,
+                @"tvOS simulators do not support direct scroll wheel input. Use Enter and arrow keys instead."
+            );
+            return;
+        }
+        if (self->_hidClient == nil) {
+            dispatchError = DFMakeError(
+                DFPrivateSimulatorErrorCodeTouchDispatchFailed,
+                @"SimulatorKit did not provide a headless HID client for scroll input."
+            );
+            return;
+        }
+
+        CGSize displaySize = self->_displayPixelSize;
+        if (displaySize.width < 1.0 || displaySize.height < 1.0) {
+            displaySize = CGSizeMake(1.0, 1.0);
+        }
+        CGPoint scrollPoint = CGPointMake(
+            fmax(0.0, fmin(1.0, normalizedX)),
+            fmax(0.0, fmin(1.0, normalizedY))
+        );
+
+        NSError *messageError = nil;
+        IndigoHIDMessage *pointerMove = DFCreatePointerMoveHIDMessage(scrollPoint, displaySize, &messageError);
+        if (pointerMove != NULL) {
+            if (!DFSendHIDMessage(self->_hidClient, pointerMove, YES, &messageError)) {
+                dispatchError = messageError;
+            } else if (DFVerboseTouchLoggingEnabled()) {
+                DFLog(@"Moved Indigo pointer target=0x%x to ratio (%.4f, %.4f) before scroll", DFIndigoPointerTarget, scrollPoint.x, scrollPoint.y);
+            }
+        }
+
+        uint32_t targets[] = { DFIndigoPointerTarget, DFIndigoDigitizerTarget };
+        for (NSUInteger targetIndex = 0; targetIndex < sizeof(targets) / sizeof(targets[0]); targetIndex++) {
+            messageError = nil;
+            IndigoHIDMessage *message = DFCreateScrollHIDMessage(targets[targetIndex], deltaX, deltaY, &messageError);
+            if (message == NULL || !DFSendHIDMessage(self->_hidClient, message, YES, &messageError)) {
+                dispatchError = messageError;
+                continue;
+            }
+
+            if (DFVerboseTouchLoggingEnabled()) {
+                DFLog(@"Sending Indigo HID scroll target=0x%x delta=(%.3f, %.3f) ratio=(%.4f, %.4f)",
+                      targets[targetIndex],
+                      deltaX,
+                      deltaY,
+                      scrollPoint.x,
+                      scrollPoint.y);
+            }
+            success = YES;
+            return;
+        }
+
+        if (dispatchError == nil) {
+            dispatchError = DFMakeError(
+                DFPrivateSimulatorErrorCodeTouchDispatchFailed,
+                @"SimulatorKit rejected the Indigo HID scroll packet."
+            );
+        }
+    };
+
+    if (dispatch_get_specific(DFPrivateSimulatorCallbackQueueKey) != NULL) {
+        work();
+    } else {
+        dispatch_sync(_callbackQueue, work);
+    }
+
+    if (!success && error != NULL) {
+        *error = dispatchError;
+    }
+
+    return success;
+}
+
 - (BOOL)sendKeyCode:(uint16_t)keyCode
           modifiers:(NSUInteger)modifiers
               error:(NSError * _Nullable __autoreleasing *)error {
diff --git a/packages/server/native/XCWPrivateSimulatorSession.h b/packages/server/native/XCWPrivateSimulatorSession.h
index 8a6e51b0..10fa5a9b 100644
--- a/packages/server/native/XCWPrivateSimulatorSession.h
+++ b/packages/server/native/XCWPrivateSimulatorSession.h
@@ -54,6 +54,12 @@ typedef void (^XCWPrivateSimulatorEncodedFrameHandler)(NSData *sampleData,
                                  phase:(NSString *)phase
                                  error:(NSError * _Nullable * _Nullable)error;
 
+- (BOOL)sendScrollWithDeltaX:(double)deltaX
+                      deltaY:(double)deltaY
+                 normalizedX:(double)normalizedX
+                 normalizedY:(double)normalizedY
+                       error:(NSError * _Nullable * _Nullable)error;
+
 - (BOOL)sendKeyCode:(uint16_t)keyCode
           modifiers:(NSUInteger)modifiers
               error:(NSError * _Nullable * _Nullable)error;
diff --git a/packages/server/native/XCWPrivateSimulatorSession.m b/packages/server/native/XCWPrivateSimulatorSession.m
index 701299cf..9ca8de54 100644
--- a/packages/server/native/XCWPrivateSimulatorSession.m
+++ b/packages/server/native/XCWPrivateSimulatorSession.m
@@ -2,12 +2,17 @@
 
 #import <CoreGraphics/CoreGraphics.h>
 #import <CoreVideo/CoreVideo.h>
+#import <QuartzCore/QuartzCore.h>
 
 #import "DFPrivateSimulatorDisplayBridge.h"
 #import "XCWH264Encoder.h"
 
 static NSString * const XCWPrivateSimulatorSessionErrorDomain = @"SimDeck.PrivateSimulatorSession";
 
+static uint64_t XCWPrivateSimulatorNowUs(void) {
+    return (uint64_t)llround(CACurrentMediaTime() * 1000000.0);
+}
+
 @interface XCWPrivateSimulatorSession () <DFPrivateSimulatorDisplayBridgeDelegate>
 
 @property (nonatomic, copy, readwrite) NSString *udid;
@@ -32,6 +37,14 @@ @implementation XCWPrivateSimulatorSession {
     NSUInteger _latestKeyFrameSequenceValue;
     BOOL _displayReadyValue;
     BOOL _didSignalReadiness;
+    NSUInteger _directFrameCount;
+    NSUInteger _manualRefreshFrameCount;
+    uint64_t _lastDirectFrameUs;
+    uint64_t _lastManualRefreshUs;
+    double _latestDirectFrameGapMs;
+    double _averageDirectFrameGapMs;
+    double _latestManualRefreshGapMs;
+    double _averageManualRefreshGapMs;
 }
 
 - (nullable instancetype)initWithUDID:(NSString *)udid
@@ -152,7 +165,9 @@ - (void)refreshCurrentFrame {
     }
 
     CGSize displaySize = CGSizeMake((CGFloat)CVPixelBufferGetWidth(pixelBuffer), (CGFloat)CVPixelBufferGetHeight(pixelBuffer));
+    uint64_t nowUs = XCWPrivateSimulatorNowUs();
     dispatch_async(_stateQueue, ^{
+        [self recordManualRefreshLockedAtTimeUs:nowUs];
         self->_displaySizeValue = displaySize;
         self->_displayReadyValue = YES;
         self->_displayStatusValue = [NSString stringWithFormat:@"Private display ready (%.0fx%.0f)", displaySize.width, displaySize.height];
@@ -186,7 +201,15 @@ - (void)setClientForeground:(BOOL)foreground {
 }
 
 - (NSDictionary *)videoEncoderStats {
-    return [_videoEncoder statsRepresentation];
+    NSMutableDictionary *stats = [[_videoEncoder statsRepresentation] mutableCopy];
+    if (stats == nil) {
+        stats = [NSMutableDictionary dictionary];
+    }
+    NSDictionary *displayStats = [self displayFrameStats];
+    if (displayStats != nil) {
+        stats[@"display"] = displayStats;
+    }
+    return stats;
 }
 
 - (id)addEncodedFrameListener:(XCWPrivateSimulatorEncodedFrameHandler)handler {
@@ -316,6 +339,14 @@ - (BOOL)sendMultiTouchWithNormalizedX1:(double)normalizedX1
                                                  error:error];
 }
 
+- (BOOL)sendScrollWithDeltaX:(double)deltaX
+                      deltaY:(double)deltaY
+                 normalizedX:(double)normalizedX
+                 normalizedY:(double)normalizedY
+                       error:(NSError * _Nullable __autoreleasing *)error {
+    return [_displayBridge sendScrollWithDeltaX:deltaX deltaY:deltaY normalizedX:normalizedX normalizedY:normalizedY error:error];
+}
+
 - (BOOL)touchPhaseFromString:(NSString *)phase
                     outPhase:(DFPrivateSimulatorTouchPhase *)outPhase
                        error:(NSError * _Nullable __autoreleasing *)error {
@@ -394,7 +425,9 @@ - (void)disconnect {
 
 - (void)privateSimulatorDisplayBridge:(DFPrivateSimulatorDisplayBridge *)bridge didUpdateFrame:(CVPixelBufferRef)pixelBuffer {
     CGSize displaySize = CGSizeMake((CGFloat)CVPixelBufferGetWidth(pixelBuffer), (CGFloat)CVPixelBufferGetHeight(pixelBuffer));
+    uint64_t nowUs = XCWPrivateSimulatorNowUs();
     dispatch_async(_stateQueue, ^{
+        [self recordDirectFrameLockedAtTimeUs:nowUs];
         self->_displaySizeValue = displaySize;
         self->_displayReadyValue = YES;
         self->_displayStatusValue = [NSString stringWithFormat:@"Private display ready (%.0fx%.0f)", displaySize.width, displaySize.height];
@@ -423,7 +456,9 @@ - (void)primeStateFromBridge {
     CVPixelBufferRef pixelBuffer = [_displayBridge copyPixelBuffer];
     if (pixelBuffer != nil) {
         CGSize displaySize = CGSizeMake((CGFloat)CVPixelBufferGetWidth(pixelBuffer), (CGFloat)CVPixelBufferGetHeight(pixelBuffer));
+        uint64_t nowUs = XCWPrivateSimulatorNowUs();
         dispatch_async(_stateQueue, ^{
+            [self recordManualRefreshLockedAtTimeUs:nowUs];
             self->_displaySizeValue = displaySize;
             self->_displayReadyValue = YES;
             self->_displayStatusValue = [NSString stringWithFormat:@"Private display ready (%.0fx%.0f)", displaySize.width, displaySize.height];
@@ -434,6 +469,47 @@ - (void)primeStateFromBridge {
     }
 }
 
+- (void)recordDirectFrameLockedAtTimeUs:(uint64_t)nowUs {
+    _directFrameCount += 1;
+    if (_lastDirectFrameUs != 0 && nowUs > _lastDirectFrameUs) {
+        _latestDirectFrameGapMs = ((double)(nowUs - _lastDirectFrameUs)) / 1000.0;
+        _averageDirectFrameGapMs = _averageDirectFrameGapMs <= 0.0
+            ? _latestDirectFrameGapMs
+            : (_averageDirectFrameGapMs * 0.9) + (_latestDirectFrameGapMs * 0.1);
+    }
+    _lastDirectFrameUs = nowUs;
+}
+
+- (void)recordManualRefreshLockedAtTimeUs:(uint64_t)nowUs {
+    _manualRefreshFrameCount += 1;
+    if (_lastManualRefreshUs != 0 && nowUs > _lastManualRefreshUs) {
+        _latestManualRefreshGapMs = ((double)(nowUs - _lastManualRefreshUs)) / 1000.0;
+        _averageManualRefreshGapMs = _averageManualRefreshGapMs <= 0.0
+            ? _latestManualRefreshGapMs
+            : (_averageManualRefreshGapMs * 0.9) + (_latestManualRefreshGapMs * 0.1);
+    }
+    _lastManualRefreshUs = nowUs;
+}
+
+- (NSDictionary *)displayFrameStats {
+    __block NSDictionary *stats = nil;
+    dispatch_sync(_stateQueue, ^{
+        stats = @{
+            @"directFrameCount": @(self->_directFrameCount),
+            @"manualRefreshFrameCount": @(self->_manualRefreshFrameCount),
+            @"latestDirectFrameGapMs": @(self->_latestDirectFrameGapMs),
+            @"averageDirectFrameGapMs": @(self->_averageDirectFrameGapMs),
+            @"latestManualRefreshGapMs": @(self->_latestManualRefreshGapMs),
+            @"averageManualRefreshGapMs": @(self->_averageManualRefreshGapMs),
+            @"displayReady": @(self->_displayReadyValue),
+            @"displayWidth": @(self->_displaySizeValue.width),
+            @"displayHeight": @(self->_displaySizeValue.height),
+            @"encodedFrameListeners": @(self->_encodedFrameListeners.count),
+        };
+    });
+    return stats;
+}
+
 - (void)signalReadinessIfNeededLocked {
     if (_didSignalReadiness || !_displayReadyValue) {
         return;
diff --git a/packages/server/native/bridge/XCWNativeBridge.h b/packages/server/native/bridge/XCWNativeBridge.h
index c54d287e..81d33c48 100644
--- a/packages/server/native/bridge/XCWNativeBridge.h
+++ b/packages/server/native/bridge/XCWNativeBridge.h
@@ -99,6 +99,7 @@ bool xcw_native_session_press_home(void * _Nonnull handle, char * _Nullable * _N
 bool xcw_native_session_press_button(void * _Nonnull handle, const char * _Nonnull button_name, uint32_t duration_ms, char * _Nullable * _Nullable error_message);
 bool xcw_native_session_send_button(void * _Nonnull handle, const char * _Nonnull button_name, bool pressed, bool has_usage, uint32_t usage_page, uint32_t usage, char * _Nullable * _Nullable error_message);
 bool xcw_native_session_rotate_crown(void * _Nonnull handle, double delta, char * _Nullable * _Nullable error_message);
+bool xcw_native_session_send_scroll(void * _Nonnull handle, double delta_x, double delta_y, double normalized_x, double normalized_y, char * _Nullable * _Nullable error_message);
 bool xcw_native_session_open_app_switcher(void * _Nonnull handle, char * _Nullable * _Nullable error_message);
 bool xcw_native_session_rotate_right(void * _Nonnull handle, char * _Nullable * _Nullable error_message);
 bool xcw_native_session_rotate_left(void * _Nonnull handle, char * _Nullable * _Nullable error_message);
diff --git a/packages/server/native/bridge/XCWNativeBridge.m b/packages/server/native/bridge/XCWNativeBridge.m
index 71d09457..5988096a 100644
--- a/packages/server/native/bridge/XCWNativeBridge.m
+++ b/packages/server/native/bridge/XCWNativeBridge.m
@@ -1360,6 +1360,17 @@ bool xcw_native_session_rotate_crown(void *handle, double delta, char **error_me
     }
 }
 
+bool xcw_native_session_send_scroll(void *handle, double delta_x, double delta_y, double normalized_x, double normalized_y, char **error_message) {
+    @autoreleasepool {
+        NSError *error = nil;
+        BOOL ok = [XCWNativeSessionFromHandle(handle) sendScrollWithDeltaX:delta_x deltaY:delta_y normalizedX:normalized_x normalizedY:normalized_y error:&error];
+        if (!ok) {
+            XCWSetErrorMessage(error_message, error);
+        }
+        return ok;
+    }
+}
+
 bool xcw_native_session_open_app_switcher(void *handle, char **error_message) {
     @autoreleasepool {
         NSError *error = nil;
diff --git a/packages/server/native/bridge/XCWNativeSession.h b/packages/server/native/bridge/XCWNativeSession.h
index 387f904f..bc2508ed 100644
--- a/packages/server/native/bridge/XCWNativeSession.h
+++ b/packages/server/native/bridge/XCWNativeSession.h
@@ -47,6 +47,11 @@ NS_ASSUME_NONNULL_BEGIN
                            error:(NSError * _Nullable * _Nullable)error;
 - (BOOL)rotateDigitalCrownByDelta:(double)delta
                              error:(NSError * _Nullable * _Nullable)error;
+- (BOOL)sendScrollWithDeltaX:(double)deltaX
+                      deltaY:(double)deltaY
+                 normalizedX:(double)normalizedX
+                 normalizedY:(double)normalizedY
+                       error:(NSError * _Nullable * _Nullable)error;
 - (BOOL)openAppSwitcher:(NSError * _Nullable * _Nullable)error;
 - (BOOL)rotateRight:(NSError * _Nullable * _Nullable)error;
 - (BOOL)rotateLeft:(NSError * _Nullable * _Nullable)error;
diff --git a/packages/server/native/bridge/XCWNativeSession.m b/packages/server/native/bridge/XCWNativeSession.m
index c956f9d3..29afed0b 100644
--- a/packages/server/native/bridge/XCWNativeSession.m
+++ b/packages/server/native/bridge/XCWNativeSession.m
@@ -180,6 +180,14 @@ - (BOOL)rotateDigitalCrownByDelta:(double)delta
     return [self.session rotateDigitalCrownByDelta:delta error:error];
 }
 
+- (BOOL)sendScrollWithDeltaX:(double)deltaX
+                      deltaY:(double)deltaY
+                 normalizedX:(double)normalizedX
+                 normalizedY:(double)normalizedY
+                       error:(NSError * _Nullable __autoreleasing *)error {
+    return [self.session sendScrollWithDeltaX:deltaX deltaY:deltaY normalizedX:normalizedX normalizedY:normalizedY error:error];
+}
+
 - (BOOL)openAppSwitcher:(NSError * _Nullable __autoreleasing *)error {
     return [self.session openAppSwitcher:error];
 }
diff --git a/packages/server/native_stubs.c b/packages/server/native_stubs.c
index 698c0272..9d2bd413 100644
--- a/packages/server/native_stubs.c
+++ b/packages/server/native_stubs.c
@@ -541,6 +541,17 @@ bool xcw_native_session_rotate_crown(void *handle, double delta,
   return xcw_unsupported(error_message);
 }
 
+bool xcw_native_session_send_scroll(void *handle, double delta_x,
+                                    double delta_y, double normalized_x,
+                                    double normalized_y, char **error_message) {
+  (void)handle;
+  (void)delta_x;
+  (void)delta_y;
+  (void)normalized_x;
+  (void)normalized_y;
+  return xcw_unsupported(error_message);
+}
+
 bool xcw_native_session_open_app_switcher(void *handle, char **error_message) {
   (void)handle;
   return xcw_unsupported(error_message);
diff --git a/packages/server/src/api/routes.rs b/packages/server/src/api/routes.rs
index dd811743..156ab73e 100644
--- a/packages/server/src/api/routes.rs
+++ b/packages/server/src/api/routes.rs
@@ -560,6 +560,12 @@ pub(crate) enum ControlMessage {
     Crown {
         delta: f64,
     },
+    Scroll {
+        delta_x: f64,
+        delta_y: f64,
+        x: Option<f64>,
+        y: Option<f64>,
+    },
     DismissKeyboard,
     ToggleSoftwareKeyboard,
     Home,
@@ -2798,6 +2804,9 @@ async fn run_android_control_message(
                 ControlMessage::Crown { .. } => Err(AppError::bad_request(
                     "Digital Crown rotation is only available for Apple Watch simulators.",
                 )),
+                ControlMessage::Scroll { .. } => Err(AppError::bad_request(
+                    "Native scroll wheel input is only available for iOS simulators.",
+                )),
                 ControlMessage::ToggleAppearance => android.toggle_appearance(&udid),
                 ControlMessage::Touch { .. }
                 | ControlMessage::EdgeTouch { .. }
@@ -3033,13 +3042,7 @@ pub(crate) async fn run_control_message(
                     "`x1`, `y1`, `x2`, and `y2` must be finite normalized numbers.",
                 ));
             }
-            session.send_multitouch(
-                x1.clamp(0.0, 1.0),
-                y1.clamp(0.0, 1.0),
-                x2.clamp(0.0, 1.0),
-                y2.clamp(0.0, 1.0),
-                &phase,
-            )
+            session.send_multitouch(x1, y1, x2, y2, &phase)
         }
         ControlMessage::Key {
             key_code,
@@ -3068,6 +3071,17 @@ pub(crate) async fn run_control_message(
             }
         }
         ControlMessage::Crown { delta } => session.rotate_crown(delta),
+        ControlMessage::Scroll {
+            delta_x,
+            delta_y,
+            x,
+            y,
+        } => {
+            if !delta_x.is_finite() || !delta_y.is_finite() {
+                return Err(AppError::bad_request("Scroll deltas must be finite."));
+            }
+            session.send_scroll(delta_x, delta_y, x.unwrap_or(0.5), y.unwrap_or(0.5))
+        }
         ControlMessage::DismissKeyboard => session.send_key(41, 0),
         ControlMessage::ToggleSoftwareKeyboard => session.press_button("software-keyboard", 0),
         ControlMessage::Home => session.press_home(),
@@ -3121,13 +3135,7 @@ pub(crate) async fn run_bridge_multitouch_control_message(
                     "`x1`, `y1`, `x2`, and `y2` must be finite normalized numbers.",
                 ));
             }
-            input.send_multitouch(
-                x1.clamp(0.0, 1.0),
-                y1.clamp(0.0, 1.0),
-                x2.clamp(0.0, 1.0),
-                y2.clamp(0.0, 1.0),
-                &phase,
-            )
+            input.send_multitouch(x1, y1, x2, y2, &phase)
         }
         _ => Err(AppError::bad_request(
             "Bridge input control only supports multi-touch messages.",
diff --git a/packages/server/src/native/bridge.rs b/packages/server/src/native/bridge.rs
index 22039229..d4371608 100644
--- a/packages/server/src/native/bridge.rs
+++ b/packages/server/src/native/bridge.rs
@@ -1238,6 +1238,35 @@ impl NativeSession {
         }
     }
 
+    pub fn send_scroll(
+        &self,
+        delta_x: f64,
+        delta_y: f64,
+        normalized_x: f64,
+        normalized_y: f64,
+    ) -> Result<(), AppError> {
+        if !delta_x.is_finite() || !delta_y.is_finite() {
+            return Err(AppError::bad_request("Scroll deltas must be finite."));
+        }
+        if !normalized_x.is_finite() || !normalized_y.is_finite() {
+            return Err(AppError::bad_request("Scroll coordinates must be finite."));
+        }
+        unsafe {
+            let mut error = ptr::null_mut();
+            bool_result(
+                ffi::xcw_native_session_send_scroll(
+                    self.handle,
+                    delta_x,
+                    delta_y,
+                    normalized_x,
+                    normalized_y,
+                    &mut error,
+                ),
+                error,
+            )
+        }
+    }
+
     pub fn open_app_switcher(&self) -> Result<(), AppError> {
         unsafe {
             let mut error = ptr::null_mut();
diff --git a/packages/server/src/native/ffi.rs b/packages/server/src/native/ffi.rs
index 4fe9e724..41486253 100644
--- a/packages/server/src/native/ffi.rs
+++ b/packages/server/src/native/ffi.rs
@@ -321,6 +321,14 @@ unsafe extern "C" {
         delta: f64,
         error_message: *mut *mut c_char,
     ) -> bool;
+    pub fn xcw_native_session_send_scroll(
+        handle: *mut c_void,
+        delta_x: f64,
+        delta_y: f64,
+        normalized_x: f64,
+        normalized_y: f64,
+        error_message: *mut *mut c_char,
+    ) -> bool;
     pub fn xcw_native_session_open_app_switcher(
         handle: *mut c_void,
         error_message: *mut *mut c_char,
diff --git a/packages/server/src/service.rs b/packages/server/src/service.rs
index c85ce310..69f019ee 100644
--- a/packages/server/src/service.rs
+++ b/packages/server/src/service.rs
@@ -101,6 +101,7 @@ pub fn installed_port() -> anyhow::Result<Option<u16>> {
     if !launch_agent_supported() {
         return Ok(None);
     }
+    ensure_not_root()?;
     Ok(installed_argument_value("--port")?.and_then(|value| value.parse::<u16>().ok()))
 }
 
@@ -108,6 +109,7 @@ pub fn active() -> anyhow::Result<Option<ServiceInstallResult>> {
     if !launch_agent_supported() {
         return Ok(None);
     }
+    ensure_not_root()?;
     let domain = launchctl_domain()?;
     if launchagent_pid(&domain, SERVICE_LABEL).is_none() {
         return Ok(None);
@@ -164,8 +166,14 @@ fn install(mut options: ServiceOptions) -> anyhow::Result<ServiceInstallResult>
         &options,
     );
 
+    if plist_path.exists() {
+        fs::remove_file(&plist_path)
+            .with_context(|| format!("replace {}", plist_path.display()))?;
+    }
     fs::write(&plist_path, plist).with_context(|| format!("write {}", plist_path.display()))?;
 
+    let service_target = format!("{domain}/{SERVICE_LABEL}");
+    run_launchctl(["enable", service_target.as_str()])?;
     run_launchctl(["bootstrap", &domain, plist_path.to_string_lossy().as_ref()])?;
 
     let advertise_host = options.advertise_host.clone();
@@ -233,11 +241,19 @@ fn launch_agent_supported() -> bool {
 }
 
 fn ensure_launch_agent_supported() -> anyhow::Result<()> {
-    if launch_agent_supported() {
-        Ok(())
-    } else {
+    if !launch_agent_supported() {
         bail!("SimDeck persistent LaunchAgent services are only available on macOS.")
     }
+    ensure_not_root()
+}
+
+fn ensure_not_root() -> anyhow::Result<()> {
+    if current_uid()? == 0 {
+        bail!(
+            "SimDeck LaunchAgent commands must be run as your logged-in user, not with sudo. Re-run without sudo so launchctl can target your gui session."
+        );
+    }
+    Ok(())
 }
 
 fn plist_path() -> anyhow::Result<PathBuf> {
@@ -460,6 +476,10 @@ fn home_dir() -> anyhow::Result<PathBuf> {
 }
 
 fn launchctl_domain() -> anyhow::Result<String> {
+    Ok(format!("gui/{}", current_uid()?))
+}
+
+fn current_uid() -> anyhow::Result<u32> {
     let output = Command::new("id")
         .arg("-u")
         .output()
@@ -470,11 +490,9 @@ fn launchctl_domain() -> anyhow::Result<String> {
     let uid = String::from_utf8(output.stdout)
         .context("parse uid as utf-8")?
         .trim()
-        .to_string();
-    if uid.is_empty() {
-        bail!("`id -u` returned an empty uid");
-    }
-    Ok(format!("gui/{uid}"))
+        .parse::<u32>()
+        .context("parse uid as integer")?;
+    Ok(uid)
 }
 
 fn unload_existing_services(domain: &str) -> anyhow::Result<Vec<u32>> {
diff --git a/packages/server/src/simulators/session.rs b/packages/server/src/simulators/session.rs
index 4b3d61c6..c81c59c1 100644
--- a/packages/server/src/simulators/session.rs
+++ b/packages/server/src/simulators/session.rs
@@ -170,6 +170,9 @@ impl SimulatorSession {
             self.inner.start_condvar.notify_all();
             return Err(error);
         }
+        if self.inner.active_frame_subscribers.load(Ordering::Relaxed) == 0 {
+            self.inner.native.set_client_foreground(false);
+        }
         *self.inner.state.lock().unwrap() = SessionState::Ready;
         self.inner.start_condvar.notify_all();
         Ok(())
@@ -377,6 +380,16 @@ impl SimulatorSession {
         self.inner.native.rotate_crown(delta)
     }
 
+    pub fn send_scroll(&self, delta_x: f64, delta_y: f64, x: f64, y: f64) -> Result<(), AppError> {
+        self.mark_activity();
+        if self.is_tvos() {
+            return Err(AppError::bad_request(
+                "tvOS simulators do not support direct scroll wheel input. Use Enter and arrow keys instead.",
+            ));
+        }
+        self.inner.native.send_scroll(delta_x, delta_y, x, y)
+    }
+
     pub fn open_app_switcher(&self) -> Result<(), AppError> {
         self.mark_activity();
         self.inner.native.open_app_switcher()
diff --git a/packages/server/src/transport/webrtc.rs b/packages/server/src/transport/webrtc.rs
index 26c7a328..607f02a6 100644
--- a/packages/server/src/transport/webrtc.rs
+++ b/packages/server/src/transport/webrtc.rs
@@ -827,6 +827,9 @@ async fn run_android_webrtc_control_message(
         ControlMessage::Crown { .. } => Err(AppError::bad_request(
             "Digital Crown rotation is only available for Apple Watch simulators.",
         )),
+        ControlMessage::Scroll { .. } => Err(AppError::bad_request(
+            "Native scroll wheel input is only available for iOS simulators.",
+        )),
         ControlMessage::ToggleAppearance => state.android.toggle_appearance(&udid),
         ControlMessage::Touch { .. }
         | ControlMessage::EdgeTouch { .. }
diff --git a/scripts/build-cli.mjs b/scripts/build-cli.mjs
index 5cf649f8..ba7c7c73 100644
--- a/scripts/build-cli.mjs
+++ b/scripts/build-cli.mjs
@@ -18,6 +18,7 @@ const outputBin = path.join(
   buildDir,
   `simdeck-bin${targetExe(target) ?? hostExe}`,
 );
+const hostPlatformBin = target ? null : hostPlatformBinaryPath();
 
 fs.mkdirSync(buildDir, { recursive: true });
 
@@ -49,9 +50,21 @@ if (process.platform !== "win32") {
   fs.chmodSync(tmpOutputBin, 0o755);
 }
 fs.renameSync(tmpOutputBin, outputBin);
+if (hostPlatformBin && hostPlatformBin !== outputBin) {
+  const tmpHostPlatformBin = `${hostPlatformBin}.tmp.${process.pid}`;
+  fs.copyFileSync(outputBin, tmpHostPlatformBin);
+  if (process.platform !== "win32") {
+    fs.chmodSync(tmpHostPlatformBin, 0o755);
+  }
+  fs.renameSync(tmpHostPlatformBin, hostPlatformBin);
+}
 
 console.log(`Built ${outputBin}`);
 run("file", [outputBin], { optional: true });
+if (hostPlatformBin && hostPlatformBin !== outputBin) {
+  console.log(`Built ${hostPlatformBin}`);
+  run("file", [hostPlatformBin], { optional: true });
+}
 
 if (process.platform !== "win32") {
   const output = path.join(buildDir, "simdeck");
@@ -89,6 +102,18 @@ function targetExe(value) {
   return value.includes("windows") ? ".exe" : "";
 }
 
+function hostPlatformBinaryPath() {
+  const binaryByHost = {
+    "darwin-arm64": "simdeck-bin-darwin-arm64",
+    "darwin-x64": "simdeck-bin-darwin-x64",
+    "linux-arm64": "simdeck-bin-linux-arm64",
+    "linux-x64": "simdeck-bin-linux-x64",
+    "win32-x64": "simdeck-bin-win32-x64.exe",
+  };
+  const binary = binaryByHost[`${process.platform}-${process.arch}`];
+  return binary ? path.join(buildDir, binary) : null;
+}
+
 function run(command, args, options = {}) {
   const spawnOptions = {
     cwd: rootDir,