diff --git a/moli-cdp-smoke/README.md b/moli-cdp-smoke/README.md
index 68e0acb184..fc36859100 100644
--- a/moli-cdp-smoke/README.md
+++ b/moli-cdp-smoke/README.md
@@ -151,7 +151,7 @@ or identical scenario counts:
 | Fetch body streams | Buffered seeking and explicit rejection of continuation after body take | Sequential reads; EOF may require a separate empty read |
 | WebSocket events and URL blocking | Extra generic request events, payload lengths, and WebSocket URL blocking | Dedicated WebSocket events and payload data; URL blocking excludes WebSockets |
 | Hosted file URLs | Capability error before navigation/interception | File navigation and interception; missing file returns `ERR_FILE_NOT_FOUND` |
-| Other capability boundaries | Stack timing privacy, unsupported drag/CPU throttling, PI rename extension | Observed stack timing, successful drag/throttling, rejected PI rename |
+| Other capability boundaries | Stack timing privacy, unsupported CPU throttling, PI rename extension | Observed stack timing, successful throttling, rejected PI rename |
 | Response/manifest/idle details | Plaintext TextTrack bodies, document-relative data manifest URLs, same-site idle persistence | Base64 TextTrack bodies, data manifest URL fallbacks, cross-document idle reset |
 
 The `dom-input` text-editing checks were calibrated on 2026-09-12 against
@@ -190,6 +190,17 @@ observed, but it does not replace the executable probe when one can be run. If
 Chromium cannot be tested, document that limitation explicitly instead of
 presenting an inferred expectation as verified behavior.
 
+The native drag scenarios were calibrated on 2026-10-28 against Playwright's
+Chrome for Testing 145.0.7632.6. The `dom` group checks drag eligibility and
+movement thresholds, native `effectAllowed: "uninitialized"`, frontend-session
+isolation, cancellation, protected dragenter/dragover data, client-edited replay
+payloads, and accepted or rejected drops. Chromium reports all operations as
+`-1`, while Moli reports the supported mask `19`; the shared assertion compares
+the copy/link/move bits. Default text drops into writable input, textarea, and
+contenteditable targets need no author-canceled dragover. They use copy for a
+draggable element source: `copyMove` allows the drop, while `linkMove` rejects it.
+The same scenarios run against Moli's current build.
+
 The `Fetch.getResponseBody` text encoding was calibrated on 2026-10-19 against
 Debian `/usr/bin/chromium` 145.0.7632.116. A fresh page enabled `Network` and
 `Fetch` with `requestStage: "Response"`, navigated to a local UTF-8 HTML fixture,
diff --git a/moli-cdp-smoke/moli_cdp_smoke/groups/dom_input.py b/moli-cdp-smoke/moli_cdp_smoke/groups/dom_input.py
index 062228281d..1b7d2e038f 100644
--- a/moli-cdp-smoke/moli_cdp_smoke/groups/dom_input.py
+++ b/moli-cdp-smoke/moli_cdp_smoke/groups/dom_input.py
@@ -15,6 +15,7 @@ from ..config import is_moli_browser
 from .drop_input import run_drop_input_workflow
 from ..assertions import SmokeError, assert_equal, wait_until
 from ..progress import await_with_progress
+from .drag_interception import run_drag_interception_workflows
 
 
 async def run_dom_input_group(state: SmokeState) -> None:
@@ -237,6 +238,7 @@ async def run_dom_input_group(state: SmokeState) -> None:
     state.record("auth_style_hydrated_click_redirect")
 
     await run_locator_input_workflows(state)
+    await run_drag_interception_workflows(state)
     await run_user_facing_locator_workflows(state)
     await run_role_selector_state_workflows(state)
     await run_playwright_expect_matcher_workflows(state)
@@ -358,6 +360,7 @@ async def run_locator_input_workflows(state: SmokeState) -> None:
             <div id="drop">drop</div>
           `;
           window.__keys = [];
+          window.__dragEvents = [];
           const textInput = document.getElementById('text');
           const hoverTarget = document.getElementById('hover');
           const hoverChild = document.getElementById('hover-child');
@@ -366,10 +369,15 @@ async def run_locator_input_workflows(state: SmokeState) -> None:
           textInput.addEventListener('keydown', event => window.__keys.push(`${event.key}:${event.shiftKey}:${event.ctrlKey || event.metaKey}`));
           hoverTarget.addEventListener('mouseenter', () => window.__hovered = true);
           hoverChild.addEventListener('click', () => window.__hoverChildClicked = true);
-          dragSource.addEventListener('dragstart', event => event.dataTransfer.setData('text/plain', 'dragged-value'));
+          dragSource.addEventListener('dragstart', event => {
+            window.__dragEvents.push('start');
+            event.dataTransfer.setData('text/plain', 'dragged-value');
+          });
+          dragSource.addEventListener('dragend', () => window.__dragEvents.push('end'));
           dropTarget.addEventListener('dragover', event => event.preventDefault());
           dropTarget.addEventListener('drop', event => {
             event.preventDefault();
+            window.__dragEvents.push('drop');
             dropTarget.textContent = event.dataTransfer.getData('text/plain');
           });
         }"""
@@ -437,13 +445,13 @@ async def run_locator_input_workflows(state: SmokeState) -> None:
     )
     assert_equal(form_state, {"checked": True, "radio": "b", "select": "two"}, "checkbox/radio/select state")
 
-    drag = page.locator("#drag").drag_to(page.locator("#drop"), timeout=1_000)
-    if is_moli_browser():
-        await _expect_drag_interception_boundary(drag, "Moli drag interception boundary")
-        assert_equal(await page.text_content("#drop"), "drop", "unsupported drag/drop does not dispatch")
-    else:
-        await drag
-        assert_equal(await page.text_content("#drop"), "dragged-value", "Chromium drag/drop dispatches")
+    await page.locator("#drag").drag_to(page.locator("#drop"), timeout=1_000)
+    assert_equal(await page.text_content("#drop"), "dragged-value", "drag/drop transfers the native payload")
+    assert_equal(
+        await page.evaluate("() => window.__dragEvents"),
+        ["start", "drop", "end"],
+        "drag/drop dispatches dragend on the source after drop",
+    )
     state.record("locator_input_workflows")
 
 
@@ -1809,17 +1817,6 @@ async def _expect_playwright_error(awaitable: object) -> str:
     raise SmokeError("expected Playwright command to fail")
 
 
-async def _expect_drag_interception_boundary(awaitable: object, label: str) -> str:
-    error = await _expect_playwright_error(awaitable)
-    explicit_unsupported = "Input.setInterceptDrags" in error and "not supported" in error
-    bounded_drag_interception = (
-        "Timeout 1000ms exceeded" in error and "performing move and up action" in error
-    )
-    if not explicit_unsupported and not bounded_drag_interception:
-        raise SmokeError(f"{label}: expected drag interception boundary, got: {error}")
-    return error
-
-
 async def run_selector_eval_and_handle_conversion_workflows(state: SmokeState) -> None:
     # Reduced from Playwright eval-on-selector*.spec.ts,
     # elementhandle-content-frame.spec.ts, and jshandle-as-element.spec.ts.
diff --git a/moli-cdp-smoke/moli_cdp_smoke/groups/drag_interception.py b/moli-cdp-smoke/moli_cdp_smoke/groups/drag_interception.py
new file mode 100644
index 0000000000..8360a7ef65
--- /dev/null
+++ b/moli-cdp-smoke/moli_cdp_smoke/groups/drag_interception.py
@@ -0,0 +1,220 @@
+from __future__ import annotations
+
+import asyncio
+from contextlib import AsyncExitStack
+
+from ..assertions import assert_equal
+from ..diagnostics import new_cdp_session
+from ..helpers import capture_layout
+from . import SmokeState
+from .drag_protocol_contracts import run_drag_protocol_contracts
+
+
+async def run_drag_interception_workflows(state: SmokeState) -> None:
+    page = state.page
+    await page.set_content(
+        """
+        <style>
+          html,body { margin:0; height:320px }
+          #source,#target,#plain { position:absolute; width:100px; height:80px }
+          #source { left:20px; top:20px; background:#ddd }
+          #target { left:220px; top:20px; background:#eee }
+          #plain { left:20px; top:140px; background:#ccc }
+        </style>
+        <div id=source draggable=true>source</div><div id=target>target</div><div id=plain></div>
+        <script>
+          window.__dragLog = [];
+          window.__acceptDrop = true;
+          for (const type of ['dragstart','dragenter','dragover','dragleave','drop','dragend']) {
+            document.addEventListener(type, event => {
+              if (type === 'dragstart') event.dataTransfer.setData('text/plain','native-payload');
+              if (event.target.id === 'target' && type === 'dragover' && window.__acceptDrop)
+                event.preventDefault();
+              if (type === 'drop') event.preventDefault();
+              window.__dragLog.push({type, target:event.target.id,
+                allowed:event.dataTransfer.effectAllowed, effect:event.dataTransfer.dropEffect,
+                types:Array.from(event.dataTransfer.types), data:event.dataTransfer.getData('text/plain')});
+            });
+          }
+        </script>
+        """
+    )
+    await capture_layout(page)
+
+    await page.locator("#source").drag_to(page.locator("#target"), timeout=5_000)
+    events = await page.evaluate("() => window.__dragLog")
+    assert_equal([event["type"] for event in events if event["type"] in ("dragstart", "drop", "dragend")],
+                 ["dragstart", "drop", "dragend"], "Playwright dragTo completes the native source lifecycle")
+    assert_equal(next(event for event in events if event["type"] == "drop")["data"],
+                 "native-payload", "Playwright dragTo transfers the native payload")
+    await page.evaluate("() => window.__dragLog = []")
+    state.record("locator_native_drag_to")
+
+    async with AsyncExitStack() as cleanup:
+        first = await new_cdp_session(page.context, page)
+        cleanup.push_async_callback(first.detach)
+        second = await new_cdp_session(page.context, page)
+        cleanup.push_async_callback(second.detach)
+        intercepted: dict[str, list[dict]] = {"first": [], "second": []}
+        ready = {"first": asyncio.Event(), "second": asyncio.Event()}
+
+        def capture(name: str, event: dict) -> None:
+            intercepted[name].append(event)
+            ready[name].set()
+
+        first.on("Input.dragIntercepted", lambda event: capture("first", event))
+        second.on("Input.dragIntercepted", lambda event: capture("second", event))
+        await first.send("Input.setInterceptDrags", {"enabled": True})
+        await second.send("Input.setInterceptDrags", {"enabled": False})
+
+        async def mouse(session, kind: str, x: float, y: float, buttons: int) -> None:
+            await session.send("Input.dispatchMouseEvent", {
+                "type": kind, "x": x, "y": y, "buttons": buttons,
+                "button": "none" if kind == "mouseMoved" and not buttons else "left",
+            })
+
+        async def log() -> list[dict]:
+            return await page.evaluate("() => window.__dragLog")
+
+        async def start(session, name: str) -> dict:
+            ready[name].clear()
+            await page.evaluate("() => window.__dragLog = []")
+            await mouse(session, "mousePressed", 40, 40, 1)
+            await mouse(session, "mouseMoved", 50, 50, 1)
+            await asyncio.wait_for(ready[name].wait(), timeout=5)
+            return intercepted[name][-1]["data"]
+
+        async def replay(session, kind: str, data: dict) -> None:
+            await session.send("Input.dispatchDragEvent", {
+                "type": kind, "x": 250, "y": 40, "data": data,
+            })
+
+        # A plain element cannot start a native drag merely by moving the mouse.
+        await mouse(first, "mousePressed", 40, 160, 1)
+        await mouse(first, "mouseMoved", 90, 160, 1)
+        await mouse(first, "mouseReleased", 90, 160, 0)
+        assert_equal(await log(), [], "ordinary held mouse movement does not start a drag")
+        assert_equal(intercepted["first"], [], "ordinary movement is not intercepted")
+
+        # Movement inside the threshold preserves the candidate for a later move.
+        await mouse(first, "mousePressed", 40, 40, 1)
+        await mouse(first, "mouseMoved", 41, 41, 1)
+        assert_equal(await log(), [], "sub-threshold movement does not start a drag")
+        assert_equal(intercepted["first"], [], "sub-threshold movement is not intercepted")
+        await mouse(first, "mouseMoved", 50, 50, 1)
+        await asyncio.wait_for(ready["first"].wait(), timeout=5)
+        data = intercepted["first"][-1]["data"]
+        # Chromium encodes all operations as -1; Moli uses the supported bits 19.
+        assert_equal(data["dragOperationsMask"] & 19, 19, "native default allows copy/link/move")
+        starts = [event for event in await log() if event["type"] == "dragstart"]
+        assert_equal(len(starts), 1, "threshold crossing starts one native drag")
+        assert_equal(starts[0]["allowed"], "uninitialized", "native effectAllowed starts uninitialized")
+        assert_equal(starts[0]["data"], "native-payload", "dragstart has read/write data access")
+        assert_equal(intercepted["second"], [], "interception event stays with the enabled session")
+        await replay(first, "dragCancel", data)
+        await mouse(first, "mouseReleased", 50, 50, 0)
+        assert_equal(
+            [event["type"] for event in await log() if event["type"] in ("dragstart", "dragend")],
+            ["dragstart", "dragend"], "cancel ends the source once",
+        )
+
+        data = await start(first, "first")
+        for kind in ("dragEnter", "dragOver", "drop"):
+            await replay(first, kind, data)
+        events = await log()
+        assert_equal(
+            [event["type"] for event in events if event["type"] in ("dragstart", "drop", "dragend")],
+            ["dragstart", "drop", "dragend"], "accepted replay completes the source lifecycle",
+        )
+        for event in events:
+            if event["type"] in ("dragenter", "dragover"):
+                assert_equal(event["data"], "", f"{event['type']} protects the payload")
+                assert_equal(event["types"], ["text/plain"], f"{event['type']} exposes types")
+        assert_equal(next(event for event in events if event["type"] == "drop")["data"],
+                     "native-payload", "drop can read the original payload")
+        await mouse(first, "mouseReleased", 250, 40, 0)
+
+        data = await start(first, "first")
+        data = {**data, "items": [{"mimeType": "text/plain", "data": "client-payload"}]}
+        for kind in ("dragEnter", "drop"):
+            await replay(first, kind, data)
+        events = await log()
+        assert_equal(next(event for event in events if event["type"] == "drop")["data"],
+                     "client-payload", "replay consumes the client's explicit payload")
+        assert_equal([event["type"] for event in events if event["type"] == "dragend"],
+                     ["dragend"], "replacing replay data still ends the source once")
+        await mouse(first, "mouseReleased", 250, 40, 0)
+
+        # Drop performs a fresh dragover; a target that refuses it must see no drop.
+        await page.evaluate("() => window.__acceptDrop = false")
+        data = await start(first, "first")
+        await replay(first, "dragEnter", data)
+        await replay(first, "drop", data)
+        events = await log()
+        assert_equal([event for event in events if event["type"] == "drop"], [],
+                     "a refusing target receives no drop")
+        assert_equal([event["effect"] for event in events if event["type"] == "dragend"],
+                     ["none"], "a rejected drop ends with no operation")
+        await mouse(first, "mouseReleased", 250, 40, 0)
+
+        # Disable one session without overriding the other session's configuration.
+        await second.send("Input.setInterceptDrags", {"enabled": True})
+        await first.send("Input.setInterceptDrags", {"enabled": False})
+        first_count = len(intercepted["first"])
+        data = await start(second, "second")
+        assert_equal(len(intercepted["first"]), first_count, "other session receives no interception event")
+        await replay(second, "dragCancel", data)
+        await mouse(second, "mouseReleased", 50, 50, 0)
+        await second.send("Input.setInterceptDrags", {"enabled": False})
+    state.record("drag_interception_lifecycle_and_session_isolation")
+    await run_native_text_drop_workflows(state)
+    await run_drag_protocol_contracts(state)
+
+
+async def run_native_text_drop_workflows(state: SmokeState) -> None:
+    page = state.page
+    cases = [
+        ("<input id=target>", "payload", "uninitialized"),
+        ("<textarea id=target></textarea>", "payload", "uninitialized"),
+        ("<div id=target contenteditable=true></div>", "payload", "uninitialized"),
+        ("<input id=target readonly>", "", "uninitialized"),
+        ("<textarea id=target readonly></textarea>", "", "uninitialized"),
+        ("<input id=target disabled>", "", "uninitialized"),
+        ("<div id=target></div>", "", "uninitialized"),
+    ]
+    for markup in ("<input id=target>", "<textarea id=target></textarea>",
+                   "<div id=target contenteditable=true></div>"):
+        cases.extend([(markup, "payload", "copyMove"), (markup, "", "linkMove")])
+    for markup, expected, allowed in cases:
+        label = f"{markup}, effectAllowed={allowed}"
+        await page.set_content(
+            """<style>
+              #source,#target{position:absolute;width:100px;height:80px}
+              #source{left:20px;top:20px}#target{left:220px;top:20px}
+            </style><div id=source draggable=true>source</div>""" + markup + """<script>
+              window.__defaultDropLog=[];
+              document.getElementById('source').addEventListener('dragstart', event => {
+                event.dataTransfer.setData('text/plain','payload');
+                event.dataTransfer.effectAllowed='""" + allowed + """';
+              });
+              for(const type of ['dragover','drop','dragend']) document.addEventListener(type, event =>
+                window.__defaultDropLog.push({type, canceled:event.defaultPrevented,
+                  effect:event.dataTransfer.dropEffect, data:event.dataTransfer.getData('text/plain')}));
+            </script>"""
+        )
+        await capture_layout(page)
+        await page.locator("#source").drag_to(page.locator("#target"), timeout=5_000)
+        result = await page.evaluate("""() => {
+          const target=document.getElementById('target');
+          return {events:window.__defaultDropLog, value:target.value ?? target.textContent};
+        }""")
+        assert_equal(result["value"], expected, f"default drop into {label}")
+        drops = [event for event in result["events"] if event["type"] == "drop"]
+        assert_equal(len(drops), int(bool(expected)), f"default acceptance for {label}")
+        assert_equal([event["effect"] for event in result["events"] if event["type"] == "dragend"],
+                     ["copy" if expected else "none"], f"source finishes with the default operation for {label}")
+        for event in result["events"]:
+            if event["type"] == "dragover":
+                assert_equal(event["canceled"], False, f"author does not accept dragover for {label}")
+                assert_equal(event["data"], "", f"dragover protects default drop data for {label}")
+    state.record("native_text_drop_default_acceptance")
diff --git a/moli-cdp-smoke/moli_cdp_smoke/groups/drag_protocol_contracts.py b/moli-cdp-smoke/moli_cdp_smoke/groups/drag_protocol_contracts.py
new file mode 100644
index 0000000000..66ccf3a006
--- /dev/null
+++ b/moli-cdp-smoke/moli_cdp_smoke/groups/drag_protocol_contracts.py
@@ -0,0 +1,335 @@
+"""Drag payload, event-view, and pointer contracts checked against Chromium."""
+
+from __future__ import annotations
+
+import asyncio
+from contextlib import AsyncExitStack, asynccontextmanager
+from pathlib import Path
+from tempfile import TemporaryDirectory
+
+from ..assertions import assert_equal
+from ..diagnostics import new_cdp_session
+from ..helpers import capture_layout
+from . import SmokeState
+
+
+_BOARD = """<!doctype html><style>
+  html,body{margin:0;height:320px}
+  #source,#a,#b{position:absolute;width:100px;height:80px}
+  #source{left:20px;top:20px}#a{left:220px;top:20px}#b{left:420px;top:20px}
+</style><div id=source draggable=true>source</div><div id=a>A</div><div id=b>B</div>"""
+
+_INSTALL = """options => {
+  const contract = window.__dragContract = {events:[], views:[], stringCallbacks:[]};
+  const identities = new WeakMap();
+  let nextIdentity = 1;
+  const identity = value => {
+    if (!identities.has(value)) identities.set(value, nextIdentity++);
+    return identities.get(value);
+  };
+  const node = value => value ? (value.id || value.nodeName) : null;
+  const oldView = view => ({
+    type:view.type, data:view.dt.getData('text/plain'), types:Array.from(view.dt.types),
+    itemCount:view.items.length, fileNames:Array.from(view.files,file=>file.name),
+    savedTypes:Array.from(view.types), kind:view.item?.kind ?? null,
+    fileKind:view.fileItem?.kind ?? null, file:view.fileItem?.getAsFile()?.name ?? null,
+  });
+  contract.sourceState = () => {
+    const view=contract.sourceView;
+    if(!view) return null;
+    return {data:view.dt.getData('text/plain'),nativeData:view.dt.getData('application/x-native'),
+      types:Array.from(view.dt.types),items:Array.from(view.items,item=>({kind:item.kind,type:item.type})),
+      files:Array.from(view.dt.files,file=>file.name),savedTypes:Array.from(view.types),
+      savedItem:{kind:view.item.kind,type:view.item.type},
+      savedFile:view.fileItem ? {kind:view.fileItem.kind,type:view.fileItem.type,
+        name:view.fileItem.getAsFile()?.name ?? null} : null};
+  };
+  for (const type of ['dragstart','drag','dragenter','dragover','dragleave','drop','dragend']) {
+    document.addEventListener(type, event => {
+      const dt=event.dataTransfer;
+      if(type==='dragstart') {
+        dt.setData('text/plain','native-secret');
+        dt.setData('application/x-native','native-only');
+        if(options.sourceFile) dt.items.add(new File(['native-file-payload'],'source-file.txt',{type:'text/plain'}));
+        dt.effectAllowed='copyMove';
+      }
+      if(type==='dragover' && ['a','b'].includes(event.target.id)) event.preventDefault();
+      if(type==='drop') event.preventDefault();
+      const view={type,dt,items:dt.items,types:dt.types,files:dt.files,item:dt.items[0],
+        fileItem:Array.from(dt.items).find(item=>item.kind==='file')};
+      if(type==='dragstart') contract.sourceView=view;
+      const record={type,target:node(event.target),relatedTarget:node(event.relatedTarget),
+        cancelable:event.cancelable,dt:identity(dt),data:dt.getData('text/plain'),
+        types:Array.from(dt.types),allowed:dt.effectAllowed,effect:dt.dropEffect};
+      if(contract.sourceView) record.source=contract.sourceState();
+      if(type==='drop') {
+        record.oldViews=contract.views.filter(view=>['dragenter','dragover'].includes(view.type)).map(oldView);
+        contract.dropFiles=Array.from(dt.files);
+        contract.dropView=view;
+        if(options.strings) {
+          for(const previous of contract.views) if(previous.item) previous.item.getAsString(data =>
+            contract.stringCallbacks.push({type:'old:'+previous.type,data}));
+          contract.dropString = new Promise(resolve => {
+            view.item.getAsString(data => resolve({data,kind:view.item.kind,type:view.item.type}));
+          });
+        }
+      }
+      if(options.strings && type!=='drop' && view.item) view.item.getAsString(data =>
+        contract.stringCallbacks.push({type,data}));
+      contract.views.push(view);
+      contract.events.push(record);
+    });
+  }
+  for (const type of ['pointerdown','pointermove','pointerup','pointercancel',
+                      'gotpointercapture','lostpointercapture','mousedown','mousemove','mouseup']) {
+    document.addEventListener(type,event => {
+      contract.events.push({type,target:node(event.target),buttons:event.buttons,cancelable:event.cancelable});
+      if(options.capture && type==='pointerdown' && event.target.id==='source')
+        event.target.setPointerCapture(event.pointerId);
+    });
+  }
+}"""
+
+
+def _data(value: str | None, mask: int = 1, mime: str = "text/plain") -> dict:
+    return {
+        "items": [] if value is None else [{"mimeType": mime, "data": value}],
+        "dragOperationsMask": mask,
+    }
+
+
+async def _mouse(session, kind: str, x: int, y: int, buttons: int) -> None:
+    await session.send("Input.dispatchMouseEvent", {
+        "type": kind, "x": x, "y": y, "buttons": buttons,
+        "button": "none" if kind == "mouseMoved" and not buttons else "left",
+    })
+
+
+async def _drag(session, kind: str, data: dict, x: int = 250) -> None:
+    await session.send("Input.dispatchDragEvent", {"type": kind, "x": x, "y": 40, "data": data})
+
+
+async def _events(page) -> list[dict]:
+    return await page.evaluate("() => window.__dragContract.events")
+
+
+async def _drag_step(page, session, kind: str, data: dict, x: int = 250) -> list[dict]:
+    start = len(await _events(page))
+    await _drag(session, kind, data, x)
+    return [event for event in (await _events(page))[start:]
+            if event["type"] in ("dragenter", "dragover", "dragleave", "drop")]
+
+
+@asynccontextmanager
+async def _board(state: SmokeState, *, native: bool = True, capture: bool = False,
+                 strings: bool = False, source_file: bool = False, page=None):
+    page = state.page if page is None else page
+    await page.set_content(_BOARD)
+    await page.evaluate(_INSTALL, {"capture": capture, "strings": strings, "sourceFile": source_file})
+    await capture_layout(page)
+    session = await new_cdp_session(page.context, page)
+    intercepted = []
+    ready = asyncio.Event()
+
+    def on_intercepted(event: dict) -> None:
+        intercepted.append(event)
+        ready.set()
+
+    session.on("Input.dragIntercepted", on_intercepted)
+    try:
+        await session.send("Input.setInterceptDrags", {"enabled": native})
+        if native:
+            await _mouse(session, "mouseMoved", 40, 40, 0)
+            await _mouse(session, "mousePressed", 40, 40, 1)
+            await _mouse(session, "mouseMoved", 55, 50, 1)
+            await asyncio.wait_for(ready.wait(), timeout=5)
+        yield session, intercepted
+    finally:
+        # dragCancel really ends intercepted native drags in Chromium. Its
+        # cancelDragging command can leave that particular source pending.
+        await _drag(session, "dragCancel", _data(None))
+        await _mouse(session, "mouseReleased", 250, 40, 0)
+        await session.send("Input.setInterceptDrags", {"enabled": False})
+        await session.detach()
+
+
+async def _payload_contracts(state: SmokeState) -> None:
+    page = state.page
+    async with _board(state) as (session, intercepted):
+        assert_equal(intercepted[0]["data"]["items"][0]["data"], "native-secret", "source interception payload")
+        enter = await _drag_step(page, session, "dragEnter", _data(None))
+        assert_equal([(event["type"], event["types"]) for event in enter],
+                     [("dragenter", [])], "an explicitly empty enter replaces the native secret")
+        drop = await _drag_step(page, session, "drop", _data("drop-replacement"))
+        assert_equal([(event["type"], event["types"], event["data"]) for event in drop],
+                     [("dragover", [], ""), ("drop", ["text/plain"], "drop-replacement")],
+                     "drop pre-over keeps enter data; drop consumes its own payload")
+
+    async with _board(state) as (session, _):
+        await _drag_step(page, session, "dragEnter", _data("enter-secret"))
+        over = await _drag_step(page, session, "dragOver", _data("ignored-over", 16, "application/x-over"))
+        assert_equal([(event["type"], event["types"], event["allowed"]) for event in over],
+                     [("dragover", ["text/plain"], "move")], "over updates mask without replacing enter items")
+        drop = await _drag_step(page, session, "drop", _data("drop-replacement", 1))
+        assert_equal([(event["type"], event["types"], event["allowed"], event["data"]) for event in drop],
+                     [("dragover", ["text/plain"], "copy", ""),
+                      ("drop", ["text/plain"], "copy", "drop-replacement")],
+                     "drop updates the pre-over mask and replaces data only for drop")
+
+    async with _board(state) as (session, _):
+        await _drag_step(page, session, "dragEnter", _data("enter-secret"))
+        drop = await _drag_step(page, session, "drop", _data(None))
+        assert_equal([(event["type"], event["types"], event["data"]) for event in drop],
+                     [("dragover", ["text/plain"], ""), ("drop", [], "")],
+                     "an explicitly empty drop cannot reuse enter payload")
+    state.record("drag_command_payload_and_operation_replacement")
+
+
+async def _view_contracts(state: SmokeState) -> None:
+    page = state.page
+    source_types = ["text/plain", "application/x-native", "Files"]
+    protected_source = {
+        "data": "", "nativeData": "", "types": source_types,
+        "items": [{"kind": "string", "type": "text/plain"},
+                  {"kind": "string", "type": "application/x-native"},
+                  {"kind": "file", "type": "text/plain"}],
+        "files": [], "savedTypes": source_types,
+        "savedItem": {"kind": "string", "type": "text/plain"},
+        "savedFile": {"kind": "file", "type": "text/plain", "name": None},
+    }
+    async with _board(state, source_file=True) as (session, _):
+        assert_equal(await page.evaluate("() => window.__dragContract.sourceState()"), protected_source,
+                     "the retained source view exposes metadata but protects data and files after dragstart")
+        packet = _data("target-data", 17)
+        for kind in ("dragEnter", "dragOver", "drop"):
+            await _drag_step(page, session, kind, packet)
+        events = await _events(page)
+        start = next(event for event in events if event["type"] == "dragstart")
+        end = next(event for event in events if event["type"] == "dragend")
+        target = [event for event in events if event["type"] in ("dragenter", "dragover", "drop")]
+        assert_equal(start["dt"], end["dt"], "source dragend retains the source DataTransfer identity")
+        assert_equal(end["effect"], "move", "accepted copyMove without explicit dropEffect prefers move")
+        assert_equal(start["source"], {**protected_source, "data": "native-secret", "nativeData": "native-only",
+                     "files": ["source-file.txt"],
+                     "savedFile": {"kind": "file", "type": "text/plain", "name": "source-file.txt"}},
+                     "the source is writable and its File is readable inside dragstart")
+        assert_equal(len({event["dt"] for event in target}), len(target),
+                     "distinct target updates use distinct DataTransfer views")
+        assert_equal(start["dt"] in {event["dt"] for event in target}, False,
+                     "target views do not borrow the source's writable object")
+        for event in events:
+            if "source" in event and event["type"] != "dragstart":
+                assert_equal(event["source"], protected_source,
+                             f"retained source metadata survives {event['type']} without exposing native data")
+            if event["type"] in ("dragstart", "drag", "dragend"):
+                assert_equal(event["cancelable"], event["type"] != "dragend",
+                             f"source {event['type']} cancellation contract")
+        assert_equal(await page.evaluate("() => window.__dragContract.sourceState()"),
+                     {"data": "", "nativeData": "", "types": [], "items": [], "files": [],
+                      "savedTypes": source_types, "savedItem": {"kind": "", "type": ""},
+                      "savedFile": {"kind": "", "type": "", "name": None}},
+                     "the source becomes disabled only after dragend dispatch finishes")
+
+    with TemporaryDirectory(prefix="moli-drag-views-") as directory:
+        file = Path(directory) / "payload.txt"
+        file.write_text("retained-file-payload", encoding="utf-8")
+        async with _board(state, native=False, strings=True) as (session, _):
+            packet = {**_data("enter-data"), "files": [str(file)]}
+            for kind in ("dragEnter", "dragOver"):
+                await _drag_step(page, session, kind, packet)
+            await _drag_step(page, session, "drop", {**packet, "items": _data("drop-data")["items"]})
+            callback = await page.evaluate("async () => await window.__dragContract.dropString")
+            assert_equal(callback, {"data": "drop-data", "kind": "", "type": ""},
+                         "queued getAsString reads its captured value after the item becomes disabled")
+            drop = next(event for event in await _events(page) if event["type"] == "drop")
+            for view in drop["oldViews"]:
+                assert_equal({key: view[key] for key in ("data", "types", "itemCount", "fileNames", "kind", "fileKind", "file")},
+                             {"data": "", "types": [], "itemCount": 0, "fileNames": [],
+                              "kind": "", "fileKind": "", "file": None},
+                             "saved protected target views cannot regain access during drop")
+                assert_equal(view["savedTypes"], ["text/plain", "Files"], "saved types array is a snapshot")
+            result = await page.evaluate("""async () => {
+              const contract=window.__dragContract;
+              return {protectedCallbacks:contract.stringCallbacks,
+                capturedFiles:await Promise.all(contract.dropFiles.map(async file=>({name:file.name,data:await file.text()}))),
+                data:contract.dropView.dt.getData('text/plain'),types:Array.from(contract.dropView.dt.types),
+                items:contract.dropView.dt.items.length,files:contract.dropView.dt.files.length};
+            }""")
+            assert_equal(result, {"protectedCallbacks": [],
+                         "capturedFiles": [{"name": "payload.txt", "data": "retained-file-payload"}],
+                         "data": "", "types": [], "items": 0, "files": 0},
+                         "completed stores stay disabled while captured File objects remain readable")
+    state.record("drag_data_transfer_view_access_and_async_callbacks")
+
+
+async def _target_contracts(state: SmokeState) -> None:
+    page = state.page
+    async with _board(state, native=False) as (session, _):
+        packet = _data("target-data", 17)
+        steps = []
+        for kind, x in (("dragEnter", 250), ("dragOver", 250), ("dragOver", 450),
+                        ("dragOver", 250), ("drop", 250)):
+            steps.append(await _drag_step(page, session, kind, packet, x))
+        expected = [
+            [("dragenter", "a", None)], [("dragover", "a", None)],
+            [("dragenter", "b", "a"), ("dragleave", "a", "b")],
+            [("dragenter", "a", "b"), ("dragleave", "b", "a")],
+            [("dragover", "a", None), ("drop", "a", None)],
+        ]
+        assert_equal([[(event["type"], event["target"], event["relatedTarget"]) for event in step] for step in steps],
+                     expected, "target changes enter new before leaving old, without an extra over")
+        for step in steps[2:4]:
+            assert_equal(step[0]["dt"], step[1]["dt"], "one target transition shares one event view")
+        events = [event for step in steps for event in step]
+        for event in events:
+            assert_equal(event["cancelable"], event["type"] != "dragleave", f"{event['type']} cancellation contract")
+            assert_equal(event["effect"], "none", "plain target event views start with no explicit dropEffect")
+    state.record("drag_target_transition_order_related_target_and_views")
+
+
+async def _pointer_contracts(state: SmokeState) -> None:
+    async with AsyncExitStack() as cleanup:
+        # Give pointer capture its own Page, independent of the earlier external
+        # drag cases and the pointer streams those commands created.
+        page = await state.page.context.new_page()
+        cleanup.push_async_callback(page.close)
+        async with _board(state, capture=True, page=page) as (session, intercepted):
+            await page.wait_for_function(
+                "() => window.__dragContract.events.some(event => event.type === 'lostpointercapture')",
+                timeout=5_000,
+            )
+            initial = await _events(page)
+            start = next(index for index, event in enumerate(initial) if event["type"] == "dragstart")
+            assert_equal([event["type"] for event in initial[start:start + 3]],
+                         ["dragstart", "pointercancel", "lostpointercapture"],
+                         "native drag cancels the pointer before releasing capture")
+            assert_equal([(event["buttons"], event["cancelable"]) for event in initial[start + 1:start + 3]],
+                         [(0, False), (0, False)], "pointer cancellation and capture loss have no pressed buttons")
+            assert_equal(any(event["type"] == "gotpointercapture" for event in initial[:start]), True,
+                         "the source actually acquired capture before dragging")
+            before = len(initial)
+            await _mouse(session, "mouseMoved", 60, 50, 1)
+            await _mouse(session, "mouseMoved", 250, 40, 1)
+            ordinary = [event["type"] for event in (await _events(page))[before:]
+                        if event["type"].startswith("pointer") or event["type"] in ("mousemove", "mouseup")]
+            assert_equal(ordinary, [], "an active native drag suppresses the ordinary pointer/mouse stream")
+            await _drag(session, "dragCancel", intercepted[0]["data"])
+            end = [event for event in await _events(page) if event["type"] == "dragend"]
+            assert_equal([(event["effect"], event["cancelable"]) for event in end], [("none", False)],
+                         "effective cancellation ends the source exactly once")
+            before = len(await _events(page))
+            await _mouse(session, "mouseMoved", 60, 50, 1)
+            await _mouse(session, "mouseReleased", 60, 50, 0)
+            resumed = [event["type"] for event in (await _events(page))[before:]]
+            assert_equal(resumed, ["pointermove", "mousemove", "pointerup", "mouseup"],
+                         "a completed dragCancel restores ordinary input even before the held button is released")
+            assert_equal(len(intercepted), 1, "held movement after cancellation cannot start a second drag")
+
+    state.record("native_drag_pointer_cancel_capture_and_stream_recovery")
+
+
+async def run_drag_protocol_contracts(state: SmokeState) -> None:
+    await _payload_contracts(state)
+    await _view_contracts(state)
+    await _target_contracts(state)
+    await _pointer_contracts(state)
diff --git a/moli-core/src/page/input_support.rs b/moli-core/src/page/input_support.rs
index 0415a6b385..ae88da0019 100644
--- a/moli-core/src/page/input_support.rs
+++ b/moli-core/src/page/input_support.rs
@@ -95,6 +95,7 @@ pub trait PageInputExt {
         delta_y: f64,
         pointer: RendererPointerEventProperties,
         modifiers: u8,
+        intercept_drags: bool,
     ) -> Result<PendingPageCommand>;
     fn finish_dispatch_mouse_event_at_point_with_outcome(
         &mut self,
@@ -161,6 +162,7 @@ pub trait PageInputExt {
     ) -> Result<RendererInputDispatchOutcome>;
     async fn clear_active_drag_data_transfer_async(&mut self) -> Result<()>;
     fn start_clear_active_drag_data_transfer(&self) -> Result<PendingPageCommand>;
+    fn start_cancel_dragging(&self) -> Result<PendingPageCommand>;
     fn finish_clear_active_drag_data_transfer(
         &mut self,
         completion: CompletedPageCommand,
@@ -261,6 +263,7 @@ impl PageInputExt for Page {
             delta_y,
             RendererPointerEventProperties::default(),
             0,
+            false,
         )
     }
 
@@ -276,6 +279,7 @@ impl PageInputExt for Page {
         delta_y: f64,
         pointer: RendererPointerEventProperties,
         modifiers: u8,
+        intercept_drags: bool,
     ) -> Result<PendingPageCommand> {
         self.start_page_command(RendererPageCommand::DispatchMouseEventAtPoint {
             x,
@@ -288,6 +292,7 @@ impl PageInputExt for Page {
             delta_y,
             pointer,
             modifiers,
+            intercept_drags,
         })
     }
 
@@ -413,6 +418,10 @@ impl PageInputExt for Page {
         self.start_page_command(RendererPageCommand::ClearActiveDragDataTransfer)
     }
 
+    fn start_cancel_dragging(&self) -> Result<PendingPageCommand> {
+        self.start_page_command(RendererPageCommand::CancelDragging)
+    }
+
     fn finish_clear_active_drag_data_transfer(
         &mut self,
         completion: CompletedPageCommand,
diff --git a/moli-core/src/page/mod.rs b/moli-core/src/page/mod.rs
index 204b6ed94c..80466c9d58 100644
--- a/moli-core/src/page/mod.rs
+++ b/moli-core/src/page/mod.rs
@@ -106,7 +106,7 @@ pub use moli_renderer_v8::{
     RendererDomFocusOutcome, RendererDomMutationEvent, RendererDomMutationEventBatch,
     RendererDomSnapshotCaptureOptions, RendererDomSnapshotCapturePayload, RendererDragData,
     RendererDragDataItem, RendererDraggedDirectory, RendererDraggedFile, RendererFrameToken,
-    RendererInputDispatchOutcome, RendererInspectorCommandRoute,
+    RendererInputDispatchOutcome, RendererInspectorCommandRoute, RendererInterceptedDrag,
     RendererJavaScriptDialogCompletion, RendererJavaScriptDialogId, RendererJavaScriptDialogResult,
     RendererJavaScriptDialogSource, RendererLayoutMetrics, RendererLifecycleEpoch,
     RendererLifecycleEventStamp, RendererLifecycleStartReason, RendererLifecycleTerminationStamp,
@@ -417,6 +417,7 @@ impl Page {
             delta_y,
             pointer: RendererPointerEventProperties::default(),
             modifiers: 0,
+            intercept_drags: false,
         };
         let reply = self.dispatch_page_command_async(command).await?;
         expect_page_reply!(
diff --git a/moli-file-api/src/data_transfer.rs b/moli-file-api/src/data_transfer.rs
index 15b414ce13..69fbfde565 100644
--- a/moli-file-api/src/data_transfer.rs
+++ b/moli-file-api/src/data_transfer.rs
@@ -3,7 +3,7 @@ const DRAG_MODIFIER_CTRL: u8 = 2;
 const DRAG_MODIFIER_META: u8 = 4;
 const DRAG_MODIFIER_SHIFT: u8 = 8;
 
-/// Permissions granted to a DataTransfer view of a native data store.
+/// Access granted to a drag data store while a native drag event is dispatched.
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 pub enum DragDataStoreMode {
     ReadWrite,
@@ -86,12 +86,16 @@ pub fn drag_operations_mask_from_effect_allowed(effect_allowed: &str) -> i32 {
 }
 
 pub fn preferred_drop_effect_from_mask(mask: i32) -> &'static str {
-    if (mask & 1) != 0 {
+    // Chromium prefers move for constrained source operations, but uses copy
+    // for all/uninitialized rather than treating that mask as move-first.
+    if (mask & 19) == 19 {
+        "copy"
+    } else if (mask & 16) != 0 {
+        "move"
+    } else if (mask & 1) != 0 {
         "copy"
     } else if (mask & 2) != 0 {
         "link"
-    } else if (mask & 16) != 0 {
-        "move"
     } else {
         "none"
     }
@@ -219,6 +223,21 @@ pub fn child_entry_full_path(parent_path: Option<&str>, name: &str) -> String {
 mod tests {
     use super::*;
 
+    #[test]
+    fn effect_allowed_round_trips_through_drag_operations_mask() {
+        for effect in [
+            "none", "copy", "link", "move", "copyLink", "copyMove", "linkMove", "all",
+        ] {
+            let mask = drag_operations_mask_from_effect_allowed(effect);
+            assert_eq!(drag_effect_allowed_from_mask(mask), effect);
+        }
+        assert_eq!(
+            drag_operations_mask_from_effect_allowed("uninitialized"),
+            19
+        );
+        assert_eq!(drag_operations_mask_from_effect_allowed("bogus"), 0);
+    }
+
     #[test]
     fn normalizes_legacy_drag_data_type_aliases() {
         assert_eq!(normalize_drag_data_type(" text "), "text/plain");
@@ -242,7 +261,8 @@ mod tests {
         assert_eq!(drag_effect_allowed_from_mask(1 | 2 | 16), "all");
 
         assert_eq!(preferred_drop_effect_from_mask(1 | 2 | 16), "copy");
-        assert_eq!(preferred_drop_effect_from_mask(2 | 16), "link");
+        assert_eq!(preferred_drop_effect_from_mask(2 | 16), "move");
+        assert_eq!(preferred_drop_effect_from_mask(1 | 16), "move");
         assert_eq!(preferred_drop_effect_from_mask(16), "move");
         assert_eq!(preferred_drop_effect_from_mask(0), "none");
     }
diff --git a/moli-protocol/src/conn/dispatch_tests/command_dispatch.rs b/moli-protocol/src/conn/dispatch_tests/command_dispatch.rs
index 9a2cd19e1d..4801f3d6a0 100644
--- a/moli-protocol/src/conn/dispatch_tests/command_dispatch.rs
+++ b/moli-protocol/src/conn/dispatch_tests/command_dispatch.rs
@@ -2128,18 +2128,11 @@ fn command_dispatch_completes_input_owner_commands_without_legacy_fallback() {
     let step = conn.start_command_dispatch(&raw);
     assert_eq!(
         complete_messages(step),
-        vec![json!({
-            "id": 1001,
-            "error": {
-                "code": -32000,
-                "message": crate::domains::input::SET_INTERCEPT_DRAGS_UNSUPPORTED_MESSAGE
-            }
-        })]
+        vec![json!({ "id": 1001, "result": {} })]
     );
     assert!(
-        conn.browser_context
-            .as_ref()
-            .is_some_and(|context| !context.active_page_target().input_intercept_drags_enabled)
+        conn.target_page_session_state_for_session(None)
+            .is_some_and(|state| state.input_intercept_drags_enabled)
     );
 
     let raw = serde_json::to_string(&json!({
diff --git a/moli-protocol/src/conn/state/page_target_host.rs b/moli-protocol/src/conn/state/page_target_host.rs
index 1b2b244da4..73ebabb692 100644
--- a/moli-protocol/src/conn/state/page_target_host.rs
+++ b/moli-protocol/src/conn/state/page_target_host.rs
@@ -51,8 +51,6 @@ pub struct PageTargetHost {
     pub(crate) tls_verify_host_override: Option<bool>,
     pub(crate) environment_owner: moli_core::ProcessEnvironmentOwner,
     pub(crate) effective_emulation_state: EffectiveTargetEmulationState,
-    pub(crate) input_intercept_drags_enabled: bool,
-    pub(crate) input_drag_intercepted: bool,
     pub(crate) css_enabled: bool,
     pub(crate) document_cookie_manager_surface: BrowserContextCookieManagerSurface,
     pub(crate) dom_remote_object_node_cache: HashMap<String, Value>,
@@ -78,8 +76,6 @@ impl PageTargetHost {
             tls_verify_host_override: None,
             environment_owner: Default::default(),
             effective_emulation_state: EffectiveTargetEmulationState::default(),
-            input_intercept_drags_enabled: false,
-            input_drag_intercepted: false,
             css_enabled: false,
             document_cookie_manager_surface: BrowserContextCookieManagerSurface::default(),
             dom_remote_object_node_cache: HashMap::new(),
diff --git a/moli-protocol/src/conn/state/session.rs b/moli-protocol/src/conn/state/session.rs
index af43204906..717b3dece5 100644
--- a/moli-protocol/src/conn/state/session.rs
+++ b/moli-protocol/src/conn/state/session.rs
@@ -182,8 +182,6 @@ impl PageTargetHost {
             || self.tls_verify_host_override.is_some()
             || self.environment_owner.has_override()
             || self.effective_emulation_state != super::EffectiveTargetEmulationState::default()
-            || self.input_intercept_drags_enabled
-            || self.input_drag_intercepted
             || self.css_enabled
             || self.fetch_owner.config_snapshot() != super::fetch::TargetFetchConfig::default()
     }
@@ -198,8 +196,6 @@ impl PageTargetHost {
         self.http_proxy_override = None;
         self.http_no_proxy_override = None;
         self.tls_verify_host_override = None;
-        self.input_intercept_drags_enabled = false;
-        self.input_drag_intercepted = false;
         self.css_enabled = false;
     }
 }
@@ -430,6 +426,7 @@ impl PageScreencastSessionState {
 #[derive(Debug, Clone)]
 pub(crate) struct TargetPageSessionState {
     pub(crate) input_events_ignored: bool,
+    pub(crate) input_intercept_drags_enabled: bool,
     pub(crate) page_domain_enabled: bool,
     pub(crate) page_domain_subscription_generation: u64,
     pub(crate) page_lifecycle_events: bool,
@@ -448,6 +445,7 @@ impl Default for TargetPageSessionState {
     fn default() -> Self {
         Self {
             input_events_ignored: false,
+            input_intercept_drags_enabled: false,
             page_domain_enabled: false,
             page_domain_subscription_generation: 0,
             page_lifecycle_events: false,
@@ -493,6 +491,7 @@ impl TargetPageSessionState {
 impl PartialEq for TargetPageSessionState {
     fn eq(&self, other: &Self) -> bool {
         self.input_events_ignored == other.input_events_ignored
+            && self.input_intercept_drags_enabled == other.input_intercept_drags_enabled
             && self.page_domain_enabled == other.page_domain_enabled
             && self.page_lifecycle_events == other.page_lifecycle_events
             && self.audits == other.audits
diff --git a/moli-protocol/src/conn/state/tests.rs b/moli-protocol/src/conn/state/tests.rs
index 69293a8dc9..b761b973ea 100644
--- a/moli-protocol/src/conn/state/tests.rs
+++ b/moli-protocol/src/conn/state/tests.rs
@@ -116,6 +116,7 @@ fn page_domain_subscription_generation_tracks_distinct_enable_lifetimes() {
 fn input_event_ignore_state_survives_document_context_replacement() {
     let mut state = TargetPageSessionState {
         input_events_ignored: true,
+        input_intercept_drags_enabled: true,
         ..Default::default()
     };
 
@@ -125,6 +126,10 @@ fn input_event_ignore_state_survives_document_context_replacement() {
         state.input_events_ignored,
         "Chromium retains each Inspector session's input ignore handle across renderer navigation"
     );
+    assert!(
+        state.input_intercept_drags_enabled,
+        "drag interception belongs to the DevTools session, not the replaced Document"
+    );
 }
 
 #[test]
diff --git a/moli-protocol/src/conn/state_access/input.rs b/moli-protocol/src/conn/state_access/input.rs
index 0e8da9b85f..9edb3c8850 100644
--- a/moli-protocol/src/conn/state_access/input.rs
+++ b/moli-protocol/src/conn/state_access/input.rs
@@ -12,6 +12,19 @@ use moli_core::page::{
 };
 
 impl ProtocolWorkflowState<'_> {
+    pub(crate) fn input_page_is_current(
+        &self,
+        owner: &CommandOwnerScope,
+        page_owner: &TargetPageResidenceIdentity,
+        host: Option<&crate::conn::ProtocolPageHostScope>,
+    ) -> bool {
+        host.is_none_or(|host| host.is_current(self.connection))
+            && self
+                .connection
+                .target_page_residence_identity_for_owner(owner)
+                .as_ref()
+                == Some(page_owner)
+    }
     pub(crate) fn settle_input_page_command(
         self,
         owner: &TargetPageResidenceIdentity,
@@ -31,13 +44,7 @@ impl ProtocolWorkflowState<'_> {
         host: Option<&crate::conn::ProtocolPageHostScope>,
         activation: RendererPendingDownloadActivation,
     ) -> Result<Option<crate::conn::downloads::PreparedDownloadActivationDelivery>> {
-        if host.is_some_and(|host| !host.is_current(self.connection))
-            || self
-                .connection
-                .target_page_residence_identity_for_owner(owner)
-                .as_ref()
-                != Some(page_owner)
-        {
+        if !self.input_page_is_current(owner, page_owner, host) {
             return Ok(None);
         }
         self.connection
diff --git a/moli-protocol/src/domains/input.rs b/moli-protocol/src/domains/input.rs
index 2fa31e4755..c9605c5d33 100644
--- a/moli-protocol/src/domains/input.rs
+++ b/moli-protocol/src/domains/input.rs
@@ -55,8 +55,6 @@ pub(crate) const DISPATCH_TOUCH_EVENT_UNSUPPORTED_MESSAGE: &str = "Input.dispatc
 pub(crate) const EMULATE_TOUCH_FROM_MOUSE_EVENT_UNSUPPORTED_MESSAGE: &str = "Input.emulateTouchFromMouseEvent is not supported: coordinate-based touch emulation requires layout hit testing.";
 pub(crate) const SYNTHESIZE_TAP_GESTURE_UNSUPPORTED_MESSAGE: &str = "Input.synthesizeTapGesture is not supported: coordinate-based tap gestures require layout hit testing.";
 pub(crate) const DISPATCH_DRAG_EVENT_UNSUPPORTED_MESSAGE: &str = "Input.dispatchDragEvent is not supported: coordinate-based drag input requires layout hit testing.";
-pub(crate) const SET_INTERCEPT_DRAGS_UNSUPPORTED_MESSAGE: &str =
-    "Input.setInterceptDrags is not supported: drag interception events are not implemented.";
 
 #[derive(Deserialize)]
 struct SetIgnoreInputEventsParams {
@@ -129,6 +127,8 @@ struct PendingInputCommandStartError {
 enum InputAdmissionError {
     #[error("InvalidParams")]
     InvalidParams,
+    #[error("NoBrowserContext")]
+    NoBrowserContext,
     #[error("{0}")]
     Unsupported(&'static str),
     #[error("UnsupportedDevToolsCommand")]
@@ -145,6 +145,7 @@ enum PendingInputCommandKind {
     DispatchKeyEvent,
     DispatchTouchEvent,
     DispatchDragEvent,
+    CancelDragging,
     SynthesizeTapGesture,
     InsertText,
 }
@@ -321,7 +322,7 @@ pub(crate) fn try_start_input_command_dispatch(
     };
     match action {
         InputAction::CancelDragging => {
-            InputCommandDispatchStep::Complete(drag::cancel_dragging_command_output_plan(conn, cmd))
+            start_input_command_dispatch_after_noop_checks(conn, cmd, action)
         }
         InputAction::SetInterceptDrags => InputCommandDispatchStep::Complete(
             drag::set_intercept_drags_command_output_plan(conn, cmd),
@@ -675,9 +676,27 @@ fn start_pending_input_command(
                 |page| page.start_insert_text_into_active_control(&text),
             )
         }
-        InputAction::CancelDragging
-        | InputAction::SetIgnoreInputEvents
-        | InputAction::SetInterceptDrags => Ok(None),
+        InputAction::CancelDragging => {
+            let slot = conn
+                .runtime_session_owner_slot_for_owner(&owner)
+                .ok_or_else(|| {
+                    PendingInputCommandStartError::renderer_error(
+                        InputAdmissionError::NoBrowserContext,
+                    )
+                })?;
+            if slot.loaded_page().is_none() {
+                // An attached target with no renderer cannot own an active drag.
+                return Ok(None);
+            }
+            start_page_input_command(
+                conn,
+                cmd.id,
+                &owner,
+                PendingInputCommandKind::CancelDragging,
+                |page| page.start_cancel_dragging(),
+            )
+        }
+        InputAction::SetIgnoreInputEvents | InputAction::SetInterceptDrags => Ok(None),
     }
 }
 
@@ -1126,6 +1145,7 @@ fn start_devtools_dispatch_mouse_event_command(
         tilt_y: command.tilt_y,
         twist: command.twist,
     };
+    let intercept_drags = drag::intercept_drags_enabled(conn, owner);
     start_page_input_command(
         conn,
         command_id,
@@ -1143,6 +1163,7 @@ fn start_devtools_dispatch_mouse_event_command(
                 command.delta_y,
                 pointer,
                 command.modifiers,
+                intercept_drags,
             )
         },
     )
@@ -1426,6 +1447,7 @@ async fn complete_input_operation(
                 PendingInputCommandKind::DispatchTouchEvent
                 | PendingInputCommandKind::SynthesizeTapGesture => "touch event page command",
                 PendingInputCommandKind::DispatchDragEvent => "drag event page command",
+                PendingInputCommandKind::CancelDragging => "cancel dragging page command",
                 PendingInputCommandKind::DispatchKeyEvent => "key event page command",
                 _ => unreachable!(),
             };
@@ -1669,6 +1691,12 @@ async fn handle_input_dispatch_outcome(
             .await;
         }
     }
+    if let Some(drag) = outcome.intercepted_drag
+        && driver.with_state(|state| state.input_page_is_current(&action_owner, owner, host))?
+    {
+        out.events_mut()
+            .push(drag::drag_intercepted_event(session_id, &drag));
+    }
     // A navigation triggered by input is frozen by the renderer command turn
     // into a concrete owner-action record. Protocol ingress schedules that
     // action independently; this command path must not rescan mutable Page
diff --git a/moli-protocol/src/domains/input/drag.rs b/moli-protocol/src/domains/input/drag.rs
index f792b54337..5aba88f32c 100644
--- a/moli-protocol/src/domains/input/drag.rs
+++ b/moli-protocol/src/domains/input/drag.rs
@@ -1,14 +1,20 @@
 use super::*;
+use crate::conn::build_event;
+use moli_core::page::RendererInterceptedDrag;
+use serde_json::{Value, json};
 
 #[derive(Deserialize)]
 #[serde(rename_all = "camelCase")]
 struct SetInterceptDragsParams {
-    #[serde(default)]
     enabled: bool,
 }
 
+/// Chromium reports a drag that starts while interception is on through
+/// `Input.dragIntercepted` and leaves the rest of the drag to the client, which
+/// replays it with `Input.dispatchDragEvent`. The flag set here travels with
+/// every mouse event to the renderer, which decides whether `dragstart` ran.
 pub(super) fn set_intercept_drags_command_output_plan(
-    _conn: &mut CdpConnection,
+    conn: &mut CdpConnection,
     cmd: &Cmd<'_>,
 ) -> CommandOutputPlan {
     let params: SetInterceptDragsParams = match cmd.get_params() {
@@ -17,18 +23,49 @@ pub(super) fn set_intercept_drags_command_output_plan(
             return CommandOutputPlan::error(-32602, "InvalidParams");
         }
     };
-    let _ = params.enabled;
-    CommandOutputPlan::error(-32000, SET_INTERCEPT_DRAGS_UNSUPPORTED_MESSAGE)
-}
-
-pub(super) fn cancel_dragging_command_output_plan(
-    conn: &mut CdpConnection,
-    cmd: &Cmd<'_>,
-) -> CommandOutputPlan {
-    if !conn.mutate_target_page_state_for_session(cmd.session_id, |state| {
-        state.input_drag_intercepted = false;
-    }) {
+    if conn
+        .with_target_devtools_session_state_for_session_mut(cmd.session_id, |state| {
+            state.page_session_state.input_intercept_drags_enabled = params.enabled;
+        })
+        .is_none()
+    {
         return CommandOutputPlan::error(-32000, "NoBrowserContext");
     }
     CommandOutputPlan::success()
 }
+
+pub(super) fn intercept_drags_enabled(conn: &CdpConnection, owner: &CommandOwnerScope) -> bool {
+    conn.target_page_session_state_for_owner(owner)
+        .is_some_and(|state| state.input_intercept_drags_enabled)
+}
+
+/// Builds the `Input.dragIntercepted` event for a drag the renderer started.
+pub(super) fn drag_intercepted_event(
+    session_id: Option<&str>,
+    drag: &RendererInterceptedDrag,
+) -> BackgroundProtocolEvent {
+    let items: Vec<Value> = drag
+        .items
+        .iter()
+        .map(|item| {
+            let mut value = json!({ "mimeType": item.mime_type, "data": item.data });
+            if let Some(title) = &item.title {
+                value["title"] = json!(title);
+            }
+            if let Some(base_url) = &item.base_url {
+                value["baseURL"] = json!(base_url);
+            }
+            value
+        })
+        .collect();
+    BackgroundProtocolEvent::immediate(build_event(
+        "Input.dragIntercepted",
+        json!({
+            "data": {
+                "items": items,
+                "dragOperationsMask": drag.drag_operations_mask,
+            }
+        }),
+        session_id,
+    ))
+}
diff --git a/moli-protocol/src/domains/input/tests.rs b/moli-protocol/src/domains/input/tests.rs
index f084b07352..054eccba03 100644
--- a/moli-protocol/src/domains/input/tests.rs
+++ b/moli-protocol/src/domains/input/tests.rs
@@ -458,6 +458,37 @@ async fn coordinate_mouse_event_without_document_still_reports_no_document_loade
     ctx.expect_error(103, -32000, "NoDocumentLoaded");
 }
 
+#[tokio::test(flavor = "multi_thread")]
+async fn cancel_dragging_without_a_loaded_page_preserves_idle_success() {
+    let mut ctx = TestContext::new();
+    let mut bc = BrowserContext::new("BID-idle-drag".into());
+    bc.set_active_target_id("TID-idle-drag");
+    ctx.with_fixture(|conn| conn.install_browser_context_fixture_for_test(bc));
+    assert!(ctx.with_fixture(|conn| {
+        conn.runtime_session_owner_slot(None)
+            .expect("target slot")
+            .loaded_page()
+            .is_none()
+    }));
+    ctx.process_async(json!({ "id": 106, "method": "Input.cancelDragging" }))
+        .await;
+    ctx.expect_result(106, json!({}), None);
+    assert!(
+        ctx.with_fixture(|conn| conn
+            .runtime_session_owner_slot(None)
+            .expect("target slot")
+            .loaded_page()
+            .is_none()),
+        "idle cancellation must not instantiate a Page just to clear a nonexistent drag"
+    );
+
+    let mut without_context = TestContext::new();
+    without_context
+        .process_async(json!({ "id": 107, "method": "Input.cancelDragging" }))
+        .await;
+    without_context.expect_error(107, -32000, "NoBrowserContext");
+}
+
 #[tokio::test(flavor = "multi_thread")]
 async fn coordinate_mouse_down_applies_chromium_focus_default_action() {
     let mut ctx = TestContext::new();
@@ -781,7 +812,7 @@ async fn mock_layout_policy_rejects_coordinate_input_without_dispatching() {
 }
 
 #[tokio::test(flavor = "multi_thread")]
-async fn set_intercept_drags_fails_explicitly_without_drag_interception_events() {
+async fn set_intercept_drags_toggles_only_session_state() {
     let mut ctx = TestContext::new();
     with_loaded_document(
         &mut ctx,
@@ -789,54 +820,464 @@ async fn set_intercept_drags_fails_explicitly_without_drag_interception_events()
     )
     .await;
 
+    for (id, enabled) in [(12, true), (13, false)] {
+        ctx.process_async(json!({
+            "id": id,
+            "method": "Input.setInterceptDrags",
+            "params": { "enabled": enabled }
+        }))
+        .await;
+        ctx.expect_result(id, json!({}), None);
+        assert_eq!(
+            ctx.with_fixture(|conn| conn
+                .target_page_session_state_for_session(None)
+                .expect("Page session")
+                .input_intercept_drags_enabled),
+            enabled,
+        );
+    }
+
     ctx.process_async(json!({
-        "id": 12,
+        "id": 14,
+        "method": "Input.setInterceptDrags",
+        "params": { "enabled": "yes" }
+    }))
+    .await;
+    ctx.expect_error(14, -32602, "InvalidParams");
+}
+
+#[test]
+fn drag_interception_reads_the_explicit_target_owner_instead_of_the_active_target() {
+    let ctx = TestContext::new();
+    let mut browser_context = BrowserContext::new("BID-drag-owner".to_owned());
+    browser_context.set_active_target_id("TID-active".to_owned());
+    browser_context.stage_background_target(
+        "TID-explicit".to_owned(),
+        None,
+        "about:blank".to_owned(),
+        None,
+        None,
+    );
+    ctx.with_fixture(|conn| {
+        conn.install_browser_context_fixture_for_test(browser_context);
+        let active = CommandOwnerScope::capture(conn, None);
+        let explicit = CommandOwnerScope::for_route(
+            conn.target_session_route_for_target_id("TID-explicit")
+                .expect("explicit Page route"),
+        );
+        assert_eq!(active.session_id(), None);
+        assert_eq!(explicit.session_id(), None);
+        for (active_enabled, explicit_enabled) in [(true, false), (false, true)] {
+            let browser_context = conn.browser_context.as_mut().expect("browser context");
+            browser_context.active_page_target_mut().devtools_sessions
+                [moli_page_types::DevToolsSessionKey::Primary]
+                .page_session_state
+                .input_intercept_drags_enabled = active_enabled;
+            browser_context
+                .background_target_mut("TID-explicit")
+                .expect("background Page")
+                .devtools_sessions[moli_page_types::DevToolsSessionKey::Primary]
+                .page_session_state
+                .input_intercept_drags_enabled = explicit_enabled;
+            assert_eq!(drag::intercept_drags_enabled(conn, &active), active_enabled);
+            assert_eq!(
+                drag::intercept_drags_enabled(conn, &explicit),
+                explicit_enabled,
+                "route owners without a sessionId must retain their explicit target authority"
+            );
+        }
+    });
+}
+
+const DRAG_PAGE: &str = r#"<html><body>
+    <div id='source' draggable='true' style='position:absolute;left:0;top:0;width:100px;height:40px'></div>
+    <div id='target' style='position:absolute;left:0;top:100px;width:200px;height:100px'></div>
+    <script>
+      window.__drag = [];
+      const source = document.getElementById('source');
+      const target = document.getElementById('target');
+      source.addEventListener('dragstart', event => {
+        event.dataTransfer.setData('text/plain', 'payload');
+        event.dataTransfer.setData('application/x-moli', 'custom');
+        event.dataTransfer.effectAllowed = 'move';
+        window.__drag.push('dragstart');
+      });
+      source.addEventListener('dragend', () => window.__drag.push('dragend'));
+      target.addEventListener('dragenter', event => {
+        window.__drag.push('dragenter:' + event.dataTransfer.getData('text/plain')
+          + ':' + Array.from(event.dataTransfer.types).join(','));
+      });
+      target.addEventListener('dragover', event => {
+        event.preventDefault();
+        window.__drag.push('dragover');
+      });
+      target.addEventListener('drop', event => {
+        event.preventDefault();
+        window.__drag.push('drop:' + event.dataTransfer.getData('application/x-moli'));
+      });
+    </script>
+</body></html>"#;
+
+async fn dispatch_drag_mouse(
+    ctx: &mut TestContext,
+    id: u64,
+    event_type: &str,
+    y: u32,
+    buttons: u32,
+) {
+    dispatch_drag_mouse_for_session(ctx, id, event_type, y, buttons, None).await;
+}
+
+async fn dispatch_drag_mouse_for_session(
+    ctx: &mut TestContext,
+    id: u64,
+    event_type: &str,
+    y: u32,
+    buttons: u32,
+    session_id: Option<&str>,
+) {
+    let mut command = json!({
+        "id": id,
+        "method": "Input.dispatchMouseEvent",
+        "params": {
+            "type": event_type,
+            "x": INPUT_HIT_X,
+            "y": y,
+            "button": "left",
+            "buttons": buttons
+        }
+    });
+    if let Some(session_id) = session_id {
+        command["sessionId"] = json!(session_id);
+    }
+    ctx.process_async(command).await;
+    ctx.expect_result(id, json!({}), session_id);
+}
+
+#[tokio::test(flavor = "multi_thread")]
+async fn mouse_drag_with_interception_reports_drag_intercepted_and_replays_through_drag_events() {
+    let mut ctx = TestContext::new();
+    with_loaded_document(&mut ctx, DRAG_PAGE).await;
+    ctx.capture_fixture_layout(None).await;
+
+    ctx.process_async(json!({
+        "id": 1,
         "method": "Input.setInterceptDrags",
         "params": { "enabled": true }
     }))
     .await;
+    ctx.expect_result(1, json!({}), None);
 
-    ctx.expect_error(12, -32000, SET_INTERCEPT_DRAGS_UNSUPPORTED_MESSAGE);
+    dispatch_drag_mouse(&mut ctx, 2, "mousePressed", 20, 1).await;
+    dispatch_drag_mouse(&mut ctx, 3, "mouseMoved", 120, 1).await;
+
+    let intercepted = json!({
+        "data": {
+            "items": [
+                { "mimeType": "text/plain", "data": "payload" },
+                { "mimeType": "application/x-moli", "data": "custom" }
+            ],
+            "dragOperationsMask": 16
+        }
+    });
+    ctx.expect_event("Input.dragIntercepted", Some(&intercepted));
+    assert_eq!(
+        evaluate_string(&mut ctx, "window.__drag.join('|')").await,
+        "dragstart"
+    );
+
+    for (id, drag_type) in [(4, "dragEnter"), (5, "dragOver"), (6, "drop")] {
+        ctx.process_async(json!({
+            "id": id,
+            "method": "Input.dispatchDragEvent",
+            "params": {
+                "type": drag_type,
+                "x": INPUT_HIT_X,
+                "y": 120,
+                "data": intercepted["data"]
+            }
+        }))
+        .await;
+        ctx.expect_result(id, json!({}), None);
+        if drag_type == "dragEnter" {
+            assert_eq!(
+                evaluate_string(&mut ctx, "window.__drag.join('|')").await,
+                "dragstart|dragenter::text/plain,application/x-moli"
+            );
+        } else if drag_type == "dragOver" {
+            assert_eq!(
+                evaluate_string(&mut ctx, "window.__drag.join('|')").await,
+                "dragstart|dragenter::text/plain,application/x-moli|dragover"
+            );
+        }
+    }
+
+    assert_eq!(
+        evaluate_string(&mut ctx, "window.__drag.join('|')").await,
+        "dragstart|dragenter::text/plain,application/x-moli|dragover|dragover|drop:custom|dragend"
+    );
+}
+
+#[tokio::test(flavor = "multi_thread")]
+async fn mouse_drag_without_interception_emits_no_drag_intercepted_event() {
+    let mut ctx = TestContext::new();
+    with_loaded_document(&mut ctx, DRAG_PAGE).await;
+    ctx.capture_fixture_layout(None).await;
+
+    dispatch_drag_mouse(&mut ctx, 2, "mousePressed", 20, 1).await;
+    dispatch_drag_mouse(&mut ctx, 3, "mouseMoved", 120, 1).await;
+    assert_eq!(
+        evaluate_string(&mut ctx, "window.__drag.join('|')").await,
+        "dragstart|dragenter::text/plain,application/x-moli"
+    );
+    dispatch_drag_mouse(&mut ctx, 4, "mouseReleased", 120, 0).await;
+
+    assert!(
+        ctx.take_all()
+            .iter()
+            .all(|message| message["method"] != "Input.dragIntercepted")
+    );
+    assert_eq!(
+        evaluate_string(&mut ctx, "window.__drag.join('|')").await,
+        "dragstart|dragenter::text/plain,application/x-moli|dragover|drop:custom|dragend"
+    );
+}
+
+#[tokio::test(flavor = "multi_thread")]
+async fn pending_drag_interception_uses_the_admitted_command_configuration() {
+    let mut ctx = TestContext::new();
+    with_loaded_document(&mut ctx, DRAG_PAGE).await;
+    ctx.capture_fixture_layout(None).await;
+    ctx.process_async(json!({
+        "id": 70, "method": "Input.setInterceptDrags", "params": { "enabled": true }
+    }))
+    .await;
+    ctx.expect_result(70, json!({}), None);
+    dispatch_drag_mouse(&mut ctx, 71, "mousePressed", 20, 1).await;
+    let raw = json!({
+        "id": 72, "method": "Input.dispatchMouseEvent",
+        "params": { "type": "mouseMoved", "x": INPUT_HIT_X, "y": 120,
+            "button": "left", "buttons": 1 }
+    })
+    .to_string();
+    let pending = match ctx.with_fixture(|conn| conn.start_command_dispatch(&raw)) {
+        CdpCommandTaskStep::Pending(pending) => pending,
+        CdpCommandTaskStep::Complete(_) => {
+            panic!("mouse movement must wait for its renderer outcome")
+        }
+    };
+    // The enqueued command already owns interception, even if the frontend
+    // disables it before protocol consumes that command's renderer reply.
+    ctx.process_async(json!({
+        "id": 73, "method": "Input.setInterceptDrags", "params": { "enabled": false }
+    }))
+    .await;
+    ctx.expect_result(73, json!({}), None);
+    let completed = ctx.drive_owned_wait(pending.wait()).await;
+    let outcome = ctx
+        .state
+        .with_state(|state| {
+            state.complete_command_dispatch_with_context(
+                completed,
+                &mut crate::conn::CommandDispatchContext::default(),
+            )
+        })
+        .expect("live test owner");
+    let (messages, scheduler_events) = ctx.complete_command_task_step_for_test(outcome).await;
+    assert!(scheduler_events.is_empty());
+    assert!(messages.contains(&json!({ "id": 72, "result": {} })));
+    let intercepted = messages
+        .iter()
+        .filter(|message| message["method"] == "Input.dragIntercepted")
+        .collect::<Vec<_>>();
+    assert_eq!(
+        intercepted.len(),
+        1,
+        "the renderer has already intercepted this drag and must notify its issuing frontend"
+    );
+    assert_eq!(
+        intercepted[0]["params"]["data"]["items"][0]["data"],
+        "payload"
+    );
+    assert_eq!(
+        evaluate_string(&mut ctx, "window.__drag.join('|')").await,
+        "dragstart"
+    );
+    ctx.process_async(json!({ "id": 74, "method": "Input.cancelDragging" }))
+        .await;
+    ctx.expect_result(74, json!({}), None);
 }
 
 #[tokio::test(flavor = "multi_thread")]
 async fn cancel_dragging_clears_reachable_drag_state_and_succeeds_when_idle() {
-    let mut ctx = TestContext::new();
-    with_loaded_document(&mut ctx, "<html><body>drag state</body></html>").await;
-    {
-        let fixture_value = true;
-        ctx.with_fixture(|conn| {
-            conn.browser_context
-                .as_mut()
-                .expect("browser context")
-                .active_page_target_mut()
-                .input_drag_intercepted = fixture_value;
-        });
+    for intercept in [false, true] {
+        let mut ctx = TestContext::new();
+        with_loaded_document(&mut ctx, DRAG_PAGE).await;
+        ctx.capture_fixture_layout(None).await;
+        ctx.process_async(json!({
+            "id": 1, "method": "Input.setInterceptDrags", "params": { "enabled": intercept }
+        }))
+        .await;
+        ctx.expect_result(1, json!({}), None);
+        dispatch_drag_mouse(&mut ctx, 2, "mousePressed", 20, 1).await;
+        dispatch_drag_mouse(&mut ctx, 3, "mouseMoved", 120, 1).await;
+        assert!(
+            evaluate_string(&mut ctx, "window.__drag.join('|')")
+                .await
+                .starts_with("dragstart")
+        );
+        ctx.process_async(json!({ "id": 13, "method": "Input.cancelDragging" }))
+            .await;
+        ctx.expect_result(13, json!({}), None);
+        let terminal = "JSON.stringify({ends:window.__drag.filter(e=>e==='dragend').length,drops:window.__drag.filter(e=>e.startsWith('drop:')).length})";
+        assert_eq!(
+            evaluate_string(&mut ctx, terminal).await,
+            r#"{"ends":1,"drops":0}"#
+        );
+        dispatch_drag_mouse(&mut ctx, 14, "mouseReleased", 120, 0).await;
+        ctx.process_async(json!({ "id": 15, "method": "Input.cancelDragging", "params": {} }))
+            .await;
+        ctx.expect_result(15, json!({}), None);
+        assert_eq!(
+            evaluate_string(&mut ctx, terminal).await,
+            r#"{"ends":1,"drops":0}"#,
+            "mouse release and repeated cancellation must not reuse the completed drag"
+        );
     }
+}
 
-    ctx.process_async(json!({
-        "id": 13,
-        "method": "Input.cancelDragging"
-    }))
-    .await;
-    ctx.expect_result(13, json!({}), None);
+#[tokio::test(flavor = "multi_thread")]
+async fn drag_interception_is_scoped_to_the_issuing_session_and_released_on_detach() {
+    let mut ctx = TestContext::new();
+    with_loaded_document(&mut ctx, DRAG_PAGE).await;
+    ctx.capture_fixture_layout(None).await;
     ctx.with_fixture(|conn| {
-        assert!(!{
-            conn.browser_context
-                .as_ref()
-                .expect("browser context")
-                .active_page_target()
-                .input_drag_intercepted
-        })
+        let browser_context = conn.browser_context.as_mut().expect("browser context");
+        browser_context.attach_active_session("SID-primary");
+        assert!(browser_context.assign_attached_session_to_target("TID-1", "SID-drag".to_owned()));
     });
-
     ctx.process_async(json!({
-        "id": 14,
-        "method": "Input.cancelDragging",
-        "params": {}
+        "id": 40, "method": "Input.setInterceptDrags", "sessionId": "SID-drag",
+        "params": { "enabled": true }
     }))
     .await;
-    ctx.expect_result(14, json!({}), None);
+    ctx.expect_result(40, json!({}), Some("SID-drag"));
+    assert!(ctx.with_fixture(|conn| {
+        conn.target_page_session_state_for_session(Some("SID-drag"))
+            .is_some_and(|state| state.input_intercept_drags_enabled)
+    }));
+    assert!(!ctx.with_fixture(|conn| {
+        conn.target_page_session_state_for_session(Some("SID-primary"))
+            .is_some_and(|state| state.input_intercept_drags_enabled)
+    }));
+
+    // Another attached frontend must still drive ordinary native dragging.
+    for (id, event_type, y, buttons) in [
+        (41, "mousePressed", 20, 1),
+        (42, "mouseMoved", 120, 1),
+        (43, "mouseReleased", 120, 0),
+    ] {
+        dispatch_drag_mouse_for_session(&mut ctx, id, event_type, y, buttons, Some("SID-primary"))
+            .await;
+    }
+    assert!(
+        evaluate_string(&mut ctx, "window.__drag.join('|')")
+            .await
+            .contains("drop:custom")
+    );
+    assert!(
+        ctx.take_all()
+            .iter()
+            .all(|message| message["method"] != "Input.dragIntercepted")
+    );
+    evaluate_string(&mut ctx, "window.__drag = []; 'reset'").await;
+
+    dispatch_drag_mouse_for_session(&mut ctx, 44, "mousePressed", 20, 1, Some("SID-drag")).await;
+    dispatch_drag_mouse_for_session(&mut ctx, 45, "mouseMoved", 120, 1, Some("SID-drag")).await;
+    let intercepted = ctx
+        .take_all()
+        .into_iter()
+        .filter(|message| message["method"] == "Input.dragIntercepted")
+        .collect::<Vec<_>>();
+    assert_eq!(intercepted.len(), 1);
+    assert_eq!(
+        intercepted[0]["sessionId"], "SID-drag",
+        "the triggering frontend alone receives the intercepted data"
+    );
+    assert_eq!(
+        evaluate_string(&mut ctx, "window.__drag.join('|')").await,
+        "dragstart"
+    );
+    // Switching to a frontend without interception must release the old drag,
+    // without exposing its payload or starting another drag from the held press.
+    dispatch_drag_mouse_for_session(&mut ctx, 46, "mouseMoved", 120, 1, Some("SID-primary")).await;
+    assert_eq!(
+        evaluate_string(&mut ctx, "window.__drag.join('|')").await,
+        "dragstart|dragend"
+    );
+    dispatch_drag_mouse_for_session(&mut ctx, 47, "mouseReleased", 120, 0, Some("SID-primary"))
+        .await;
+
+    ctx.process_async(json!({
+        "id": 48, "method": "Input.setInterceptDrags", "sessionId": "SID-drag",
+        "params": { "enabled": false }
+    }))
+    .await;
+    ctx.expect_result(48, json!({}), Some("SID-drag"));
+    evaluate_string(&mut ctx, "window.__drag = []; 'reset'").await;
+    for (id, event_type, y, buttons) in [
+        (49, "mousePressed", 20, 1),
+        (50, "mouseMoved", 120, 1),
+        (51, "mouseReleased", 120, 0),
+    ] {
+        dispatch_drag_mouse_for_session(&mut ctx, id, event_type, y, buttons, Some("SID-drag"))
+            .await;
+    }
+    assert!(
+        evaluate_string(&mut ctx, "window.__drag.join('|')")
+            .await
+            .contains("drop:custom")
+    );
+    assert!(
+        ctx.take_all()
+            .iter()
+            .all(|message| message["method"] != "Input.dragIntercepted")
+    );
+
+    ctx.process_async(json!({
+        "id": 52, "method": "Input.setInterceptDrags", "sessionId": "SID-drag",
+        "params": { "enabled": true }
+    }))
+    .await;
+    ctx.expect_result(52, json!({}), Some("SID-drag"));
+    ctx.process_async(json!({
+        "id": 53, "method": "Target.detachFromTarget", "params": { "sessionId": "SID-drag" }
+    }))
+    .await;
+    ctx.expect_result(53, json!({}), None);
+    assert!(ctx.with_fixture(|conn| {
+        conn.target_page_session_state_for_session(Some("SID-drag"))
+            .is_none()
+    }));
+    evaluate_string(&mut ctx, "window.__drag = []; 'reset'").await;
+    for (id, event_type, y, buttons) in [
+        (54, "mousePressed", 20, 1),
+        (55, "mouseMoved", 120, 1),
+        (56, "mouseReleased", 120, 0),
+    ] {
+        dispatch_drag_mouse_for_session(&mut ctx, id, event_type, y, buttons, Some("SID-primary"))
+            .await;
+    }
+    assert!(
+        evaluate_string(&mut ctx, "window.__drag.join('|')")
+            .await
+            .contains("drop:custom")
+    );
+    assert!(
+        ctx.take_all()
+            .iter()
+            .all(|message| message["method"] != "Input.dragIntercepted")
+    );
 }
 
 #[tokio::test(flavor = "multi_thread")]
diff --git a/moli-protocol/src/domains/target/tests/tests_target_attachment.rs b/moli-protocol/src/domains/target/tests/tests_target_attachment.rs
index 218234af0f..49c2a737e5 100644
--- a/moli-protocol/src/domains/target/tests/tests_target_attachment.rs
+++ b/moli-protocol/src/domains/target/tests/tests_target_attachment.rs
@@ -1696,8 +1696,10 @@ async fn detach_from_target() {
                 },
             );
         bc.active_page_target_mut().css_enabled = true;
-        bc.active_page_target_mut().input_intercept_drags_enabled = true;
-        bc.active_page_target_mut().input_drag_intercepted = true;
+        bc.active_page_target_mut().devtools_sessions
+            [moli_page_types::DevToolsSessionKey::Primary]
+            .page_session_state
+            .input_intercept_drags_enabled = true;
         bc.active_page_target_mut().fetch_owner.configure(
             Some(sid.clone()),
             true,
@@ -1746,8 +1748,12 @@ async fn detach_from_target() {
                 .bypass_service_worker()
         );
         assert!(!bc.active_page_target().css_enabled);
-        assert!(!bc.active_page_target().input_intercept_drags_enabled);
-        assert!(!bc.active_page_target().input_drag_intercepted);
+        assert!(
+            !bc.active_page_target().devtools_sessions
+                [moli_page_types::DevToolsSessionKey::Primary]
+                .page_session_state
+                .input_intercept_drags_enabled
+        );
         assert!(!bc.active_page_target().fetch_owner.is_enabled());
         assert!(!bc.active_page_target().fetch_owner.handle_auth_requests());
         assert!(
diff --git a/moli-renderer-v8/src/context_bootstrap.rs b/moli-renderer-v8/src/context_bootstrap.rs
index bb5499f992..52f7575be3 100644
--- a/moli-renderer-v8/src/context_bootstrap.rs
+++ b/moli-renderer-v8/src/context_bootstrap.rs
@@ -129,6 +129,7 @@ mod performance_observer_runtime;
 mod performance_runtime;
 mod range;
 mod range_algorithms;
+pub(crate) use range_algorithms::document_selection_drag_text_at_point;
 mod range_live;
 mod range_surface;
 mod resize_observer_runtime;
@@ -315,8 +316,8 @@ pub(crate) use self::file_api::{
     native_data_transfer_drop_effect, native_data_transfer_drop_effect_is_initialized,
     native_data_transfer_effect_allowed, native_data_transfer_file_count,
     native_data_transfer_files, native_data_transfer_get_data, native_data_transfer_has_type,
-    populate_native_drag_data_store, protect_native_drag_source_view,
-    readonly_data_transfer_for_input, replace_drag_data_store_contents,
+    native_set_drag_drop_effect, populate_native_drag_data_store, protect_native_drag_source_view,
+    read_string_drag_data, readonly_data_transfer_for_input, replace_drag_data_store_contents,
     update_drag_data_store_operations_mask,
 };
 pub(crate) use self::file_api::{
diff --git a/moli-renderer-v8/src/context_bootstrap/file_api.rs b/moli-renderer-v8/src/context_bootstrap/file_api.rs
index 14cd9f51a8..be852231c7 100644
--- a/moli-renderer-v8/src/context_bootstrap/file_api.rs
+++ b/moli-renderer-v8/src/context_bootstrap/file_api.rs
@@ -17,8 +17,8 @@ pub(crate) use data_transfer::{
     is_branded_data_transfer_object, native_data_transfer_drop_effect,
     native_data_transfer_drop_effect_is_initialized, native_data_transfer_effect_allowed,
     native_data_transfer_file_count, native_data_transfer_files, native_data_transfer_get_data,
-    native_data_transfer_has_type, populate_native_drag_data_store,
-    protect_native_drag_source_view, readonly_data_transfer_for_input,
+    native_data_transfer_has_type, native_set_drag_drop_effect, populate_native_drag_data_store,
+    protect_native_drag_source_view, read_string_drag_data, readonly_data_transfer_for_input,
     replace_drag_data_store_contents, update_drag_data_store_operations_mask,
 };
 pub(crate) use data_transfer::{
diff --git a/moli-renderer-v8/src/context_bootstrap/file_api/data_transfer.rs b/moli-renderer-v8/src/context_bootstrap/file_api/data_transfer.rs
index 207cdd2936..721aaa1c32 100644
--- a/moli-renderer-v8/src/context_bootstrap/file_api/data_transfer.rs
+++ b/moli-renderer-v8/src/context_bootstrap/file_api/data_transfer.rs
@@ -1,14 +1,17 @@
 use super::*;
 use crate::blob;
 use crate::native_bridge::throw_dom_exception;
-use crate::runtime::{RendererDragData, RendererDraggedDirectory, RendererDraggedFile};
+use crate::runtime::{
+    RendererDragData, RendererDragDataItem, RendererDraggedDirectory, RendererDraggedFile,
+};
 use crate::util::{get_private_object, get_private_value, set_private_value};
 use crate::web_api_interfaces;
 use crate::webidl;
 use moli_file_api::data_transfer::{
     DataTransferItemSummary, child_entry_full_path, clear_data_removes_item,
     contains_string_item_type, data_transfer_types_from_items, drag_effect_allowed_from_mask,
-    normalize_drag_data_type, valid_drop_effect, valid_effect_allowed,
+    drag_operations_mask_from_effect_allowed, normalize_drag_data_type, valid_drop_effect,
+    valid_effect_allowed,
 };
 use moli_webapi_declare::{WebApiFunctionTemplate, WebApiObject};
 
@@ -474,6 +477,46 @@ pub(crate) fn native_set_drag_drop_effect<'s>(
     }
 }
 
+/// Reads the string items and `effectAllowed` that `dragstart` listeners left
+/// in the shared store, in the shape CDP reports as `Input.DragData`.
+pub(crate) fn read_string_drag_data<'s>(
+    scope: &mut v8::PinScope<'s, '_>,
+    store: &NativeDragDataStore,
+) -> (Vec<RendererDragDataItem>, i32) {
+    let backing = store.local(scope);
+    let mask = drag_operations_mask_from_effect_allowed(
+        &private_string_property(scope, backing, DATA_TRANSFER_EFFECT_ALLOWED_SLOT)
+            .unwrap_or_else(|| "uninitialized".to_owned()),
+    );
+    let mut items = Vec::new();
+    let Some(item_array) =
+        private_property_as_array(scope, backing, DATA_TRANSFER_STORE_ITEMS_SLOT)
+    else {
+        return (items, mask);
+    };
+    for index in 0..item_array.length() {
+        let Some(item) = item_array
+            .get_index(scope, index)
+            .and_then(|value| v8::Local::<v8::Object>::try_from(value).ok())
+        else {
+            continue;
+        };
+        if item_kind(scope, item).as_deref() != Some("string") {
+            continue;
+        }
+        items.push(RendererDragDataItem {
+            mime_type: item_type(scope, item).unwrap_or_default(),
+            // Native interception serializes the store, independently of the
+            // access granted to the last JavaScript event listener.
+            data: private_string_property(scope, item, DATA_TRANSFER_ITEM_STRING_SLOT)
+                .unwrap_or_default(),
+            title: None,
+            base_url: None,
+        });
+    }
+    (items, mask)
+}
+
 fn private_string_property<'s>(
     scope: &mut v8::PinScope<'s, '_>,
     object: v8::Local<'s, v8::Object>,
diff --git a/moli-renderer-v8/src/context_bootstrap/range.rs b/moli-renderer-v8/src/context_bootstrap/range.rs
index 0e415c2275..133b1b4cd6 100644
--- a/moli-renderer-v8/src/context_bootstrap/range.rs
+++ b/moli-renderer-v8/src/context_bootstrap/range.rs
@@ -8,10 +8,11 @@ mod validation;
 
 pub(super) use exceptions::throw_named_dom_exception;
 pub(super) use object::{
-    RANGE_WRAPPER_INTERNAL_FIELD_COUNT, current_document_object, initialize_range_object,
-    live_range_from_static_range, native_range_boundary_handles, native_range_boundary_point,
-    new_range_for_document, range_boundary_container_object, range_boundary_offset,
-    range_is_collapsed, range_native_record_handle, set_range_boundary, static_range_snapshot,
+    RANGE_WRAPPER_INTERNAL_FIELD_COUNT, RangeBoundaryHandle, RangeBoundaryHandles,
+    current_document_object, initialize_range_object, live_range_from_static_range,
+    native_range_boundary_handles, native_range_boundary_point, new_range_for_document,
+    range_boundary_container_object, range_boundary_offset, range_is_collapsed,
+    range_native_record_handle, set_range_boundary, static_range_snapshot,
 };
 pub(super) use static_storage::{StaticRangeInitMembers, initialize_static_range_object};
 pub(super) use validation::{
diff --git a/moli-renderer-v8/src/context_bootstrap/range_algorithms.rs b/moli-renderer-v8/src/context_bootstrap/range_algorithms.rs
index 79f76cdbb1..9eda0bf1cc 100644
--- a/moli-renderer-v8/src/context_bootstrap/range_algorithms.rs
+++ b/moli-renderer-v8/src/context_bootstrap/range_algorithms.rs
@@ -1,7 +1,8 @@
 use super::super::util::node_wrapper_from_handle;
 use super::range::{
-    RangeBoundarySide, native_range_boundary_handles, native_range_boundary_point,
-    range_boundary_container_object, range_boundary_offset, range_is_collapsed, set_range_boundary,
+    RangeBoundaryHandle, RangeBoundaryHandles, RangeBoundarySide, native_range_boundary_handles,
+    native_range_boundary_point, range_boundary_container_object, range_boundary_offset,
+    range_is_collapsed, set_range_boundary,
 };
 use super::*;
 use crate::document_runtime::DomHandle;
@@ -51,3 +52,53 @@ pub(in crate::context_bootstrap::range_algorithms) use ordering::common_ancestor
 pub(in crate::context_bootstrap::range_algorithms) use mutation::{
     range_insert_node_handle_at_boundary, range_select_node_handle,
 };
+
+/// Resolve browser-initiated selection drags through the same native Range
+/// geometry and visible-text serializer used by the Selection Web API.
+pub(crate) fn document_selection_drag_text_at_point(
+    scope: &mut v8::PinScope<'_, '_>,
+    runtime_ptr: *mut crate::native_bridge::JsContextHost,
+    handle: DomHandle,
+    x: f64,
+    y: f64,
+) -> Option<String> {
+    let runtime = unsafe { &*runtime_ptr };
+    let host = runtime.dom_host();
+    let document = host.owner_document_handle(handle)?;
+    let selection = runtime.document_selection_snapshot(document)?;
+    let (mut start, mut end) = (selection.start, selection.end);
+    match crate::range_boundary::point_order_in_dom(
+        host,
+        start.container,
+        start.offset,
+        end.container,
+        end.offset,
+    )? {
+        std::cmp::Ordering::Equal => return None,
+        std::cmp::Ordering::Greater => std::mem::swap(&mut start, &mut end),
+        std::cmp::Ordering::Less => {}
+    }
+    let boundaries = RangeBoundaryHandles {
+        start: RangeBoundaryHandle {
+            container: start.container,
+            offset: start.offset,
+        },
+        end: RangeBoundaryHandle {
+            container: end.container,
+            offset: end.offset,
+        },
+    };
+    let rects = geometry::native_range_client_rects_for_boundaries(scope, boundaries)?.ok()?;
+    if !rects.iter().any(|rect| {
+        rect.width > 0.0
+            && rect.height > 0.0
+            && x >= rect.left
+            && x <= rect.right
+            && y >= rect.top
+            && y <= rect.bottom
+    }) {
+        return None;
+    }
+    text::range_selection_string_contents_for_boundaries(scope, boundaries)
+        .filter(|text| !text.is_empty())
+}
diff --git a/moli-renderer-v8/src/context_bootstrap/range_algorithms/geometry.rs b/moli-renderer-v8/src/context_bootstrap/range_algorithms/geometry.rs
index 7235cb87c5..6bc93b73dc 100644
--- a/moli-renderer-v8/src/context_bootstrap/range_algorithms/geometry.rs
+++ b/moli-renderer-v8/src/context_bootstrap/range_algorithms/geometry.rs
@@ -11,6 +11,13 @@ fn native_range_client_rects<'s>(
     range: v8::Local<'s, v8::Object>,
 ) -> Option<Result<Vec<ClientRect>, moli_layout::LayoutError>> {
     let boundaries = native_range_boundary_handles(scope, range)?;
+    native_range_client_rects_for_boundaries(scope, boundaries)
+}
+
+pub(super) fn native_range_client_rects_for_boundaries(
+    scope: &mut v8::PinScope<'_, '_>,
+    boundaries: RangeBoundaryHandles,
+) -> Option<Result<Vec<ClientRect>, moli_layout::LayoutError>> {
     let host_ptr = context_host_ptr_from_global_bridge(scope)?;
     let host = unsafe { &*host_ptr };
     if !host.layout_policy().uses_real_layout() {
diff --git a/moli-renderer-v8/src/context_bootstrap/range_algorithms/text.rs b/moli-renderer-v8/src/context_bootstrap/range_algorithms/text.rs
index b0c6d27780..ad5d9a9bc3 100644
--- a/moli-renderer-v8/src/context_bootstrap/range_algorithms/text.rs
+++ b/moli-renderer-v8/src/context_bootstrap/range_algorithms/text.rs
@@ -52,6 +52,31 @@ pub(in crate::context_bootstrap) fn range_selection_string_contents<'s>(
                 range_boundary_offset(scope, range, RangeBoundarySide::End) as u32,
             )
         };
+    range_selection_string_contents_for_boundaries(
+        scope,
+        RangeBoundaryHandles {
+            start: RangeBoundaryHandle {
+                container: start,
+                offset: start_offset,
+            },
+            end: RangeBoundaryHandle {
+                container: end,
+                offset: end_offset,
+            },
+        },
+    )
+}
+
+pub(super) fn range_selection_string_contents_for_boundaries(
+    scope: &mut v8::PinScope<'_, '_>,
+    boundaries: RangeBoundaryHandles,
+) -> Option<String> {
+    let (start, start_offset, end, end_offset) = (
+        boundaries.start.container,
+        boundaries.start.offset,
+        boundaries.end.container,
+        boundaries.end.offset,
+    );
     if start == end && start_offset == end_offset {
         return Some(String::new());
     }
diff --git a/moli-renderer-v8/src/devtools/command/nested.rs b/moli-renderer-v8/src/devtools/command/nested.rs
index 4c38ae7447..169a65252e 100644
--- a/moli-renderer-v8/src/devtools/command/nested.rs
+++ b/moli-renderer-v8/src/devtools/command/nested.rs
@@ -113,6 +113,7 @@ impl RendererPageCommand {
             | Self::DispatchMouseEventAtPoint { .. }
             | Self::DispatchTouchEvent { .. }
             | Self::DispatchDragEventAtPoint { .. }
+            | Self::CancelDragging
             | Self::ClearActiveDragDataTransfer
             | Self::InsertTextIntoActiveControl(..)
             | Self::DispatchKeyEvent { .. }
diff --git a/moli-renderer-v8/src/lib.rs b/moli-renderer-v8/src/lib.rs
index cabebd4eb6..d6a11b1310 100644
--- a/moli-renderer-v8/src/lib.rs
+++ b/moli-renderer-v8/src/lib.rs
@@ -277,16 +277,16 @@ pub use runtime::{
     RendererGeometryQuad, RendererInputDispatchOutcome, RendererInspectorCommandEnvelope,
     RendererInspectorCommandRoute, RendererInspectorIngressTicket,
     RendererInspectorProtocolConfiguration, RendererInspectorProtocolConfigurationCommand,
-    RendererInspectorSessionRestoreSnapshot, RendererJavaScriptDialogCompletion,
-    RendererJavaScriptDialogId, RendererJavaScriptDialogResult, RendererJavaScriptDialogSource,
-    RendererLayoutMetrics, RendererLifecycleDecider, RendererLifecycleDecision,
-    RendererLifecycleEpoch, RendererLifecycleEventStamp, RendererLifecycleSnapshot,
-    RendererLifecycleStartReason, RendererLifecycleTerminationStamp, RendererMainDocumentCommit,
-    RendererMainDocumentResource, RendererMoliDomMemoryDiagnostics, RendererMoliMemoryDiagnostics,
-    RendererMoliMemoryScopeDiagnostics, RendererMoliRuntimeMemoryDiagnostics,
-    RendererNativeCommandReadyResponse, RendererNativeCommandResponseGuard,
-    RendererNativeCommandTerminal, RendererNativeOperation, RendererNativeOperationStep,
-    RendererNativeProtocolError, RendererNativeProtocolNotification,
+    RendererInspectorSessionRestoreSnapshot, RendererInterceptedDrag,
+    RendererJavaScriptDialogCompletion, RendererJavaScriptDialogId, RendererJavaScriptDialogResult,
+    RendererJavaScriptDialogSource, RendererLayoutMetrics, RendererLifecycleDecider,
+    RendererLifecycleDecision, RendererLifecycleEpoch, RendererLifecycleEventStamp,
+    RendererLifecycleSnapshot, RendererLifecycleStartReason, RendererLifecycleTerminationStamp,
+    RendererMainDocumentCommit, RendererMainDocumentResource, RendererMoliDomMemoryDiagnostics,
+    RendererMoliMemoryDiagnostics, RendererMoliMemoryScopeDiagnostics,
+    RendererMoliRuntimeMemoryDiagnostics, RendererNativeCommandReadyResponse,
+    RendererNativeCommandResponseGuard, RendererNativeCommandTerminal, RendererNativeOperation,
+    RendererNativeOperationStep, RendererNativeProtocolError, RendererNativeProtocolNotification,
     RendererNativeProtocolResponse, RendererNativeProtocolStateUpdate, RendererNavigationInitiator,
     RendererOutputCursor, RendererOutputFence, RendererOutputFenceLeaseId, RendererOutputItem,
     RendererOutputPublication, RendererOutputPublicationOrdering, RendererOutputRecord,
diff --git a/moli-renderer-v8/src/native_bridge/element.rs b/moli-renderer-v8/src/native_bridge/element.rs
index d943a3bf1d..497741a59d 100644
--- a/moli-renderer-v8/src/native_bridge/element.rs
+++ b/moli-renderer-v8/src/native_bridge/element.rs
@@ -272,11 +272,12 @@ pub(in crate::native_bridge::element) use events::construct_event;
 pub(crate) use events::construct_focus_event;
 pub(crate) use events::{
     InputEventCoordinates, NodePublicEventDispatchOutcome, TextEditInputType, TouchEventPoint,
-    construct_command_event, construct_drag_event, construct_drop_input_event,
-    construct_input_event, construct_interest_event, construct_keyboard_event,
-    construct_mouse_event_with_detail_and_modifiers, construct_mouse_event_with_modifiers,
-    construct_mouse_event_with_related_target_and_modifiers, construct_pointer_event,
-    construct_pointer_event_with_modifiers, construct_pointer_event_with_related_target,
+    construct_command_event, construct_drag_event, construct_drag_event_with_related_target,
+    construct_drop_input_event, construct_input_event, construct_interest_event,
+    construct_keyboard_event, construct_mouse_event_with_detail_and_modifiers,
+    construct_mouse_event_with_modifiers, construct_mouse_event_with_related_target_and_modifiers,
+    construct_pointer_event, construct_pointer_event_with_modifiers,
+    construct_pointer_event_with_related_target,
     construct_pointer_event_with_related_target_and_modifiers, construct_simple_event,
     construct_submit_event, construct_toggle_event, construct_touch_event,
     construct_touch_event_with_points, construct_wheel_event, dispatch_beforeinput,
diff --git a/moli-renderer-v8/src/native_bridge/element/activation/default_action.rs b/moli-renderer-v8/src/native_bridge/element/activation/default_action.rs
index 23bc2c6e35..482ee122cb 100644
--- a/moli-renderer-v8/src/native_bridge/element/activation/default_action.rs
+++ b/moli-renderer-v8/src/native_bridge/element/activation/default_action.rs
@@ -755,6 +755,7 @@ fn click_handle_internal(
             triggered_top_level_navigation: false,
             pending_download: None,
             pending_file_chooser: None,
+            intercepted_drag: None,
         };
     }
     if focus_behavior == ClickFocusBehavior::Apply
@@ -974,6 +975,7 @@ fn click_handle_internal(
         triggered_top_level_navigation: false,
         pending_download: None,
         pending_file_chooser: None,
+        intercepted_drag: None,
     }
 }
 
@@ -990,6 +992,7 @@ fn input_dispatch_outcome_after_click(
             && unsafe { &*runtime_ptr }.has_pending_location_navigation(),
         pending_download,
         pending_file_chooser,
+        intercepted_drag: None,
     }
 }
 
diff --git a/moli-renderer-v8/src/native_bridge/element/events.rs b/moli-renderer-v8/src/native_bridge/element/events.rs
index 976ed3a3dc..244643db2e 100644
--- a/moli-renderer-v8/src/native_bridge/element/events.rs
+++ b/moli-renderer-v8/src/native_bridge/element/events.rs
@@ -6,8 +6,8 @@ mod dispatch;
 pub(crate) use self::constructors::construct_focus_event;
 pub(crate) use self::constructors::{
     InputEventCoordinates, TextEditInputType, TouchEventPoint, construct_command_event,
-    construct_drag_event, construct_drop_input_event, construct_input_event,
-    construct_interest_event, construct_keyboard_event,
+    construct_drag_event, construct_drag_event_with_related_target, construct_drop_input_event,
+    construct_input_event, construct_interest_event, construct_keyboard_event,
     construct_mouse_event_with_detail_and_modifiers, construct_mouse_event_with_modifiers,
     construct_mouse_event_with_related_target_and_modifiers, construct_pointer_event,
     construct_pointer_event_with_modifiers, construct_pointer_event_with_related_target,
diff --git a/moli-renderer-v8/src/native_bridge/element/events/constructors.rs b/moli-renderer-v8/src/native_bridge/element/events/constructors.rs
index 44c8648638..61e0eda32e 100644
--- a/moli-renderer-v8/src/native_bridge/element/events/constructors.rs
+++ b/moli-renderer-v8/src/native_bridge/element/events/constructors.rs
@@ -68,6 +68,7 @@ struct DragEventInitDeclaration<'scope> {
     meta_key: bool,
     shift_key: bool,
     data_transfer: v8::Local<'scope, v8::Value>,
+    related_target: Option<v8::Local<'scope, v8::Value>>,
 }
 
 #[derive(WebApiObject)]
@@ -637,7 +638,11 @@ pub(crate) fn construct_pointer_event_with_related_target_and_modifiers<'s>(
     let modifier_keys = modifier_key_state(modifiers);
     let init = PointerEventInitDeclaration::new(
         !is_enter_or_leave,
-        !is_enter_or_leave,
+        !is_enter_or_leave
+            && !matches!(
+                event_type,
+                "pointercancel" | "gotpointercapture" | "lostpointercapture"
+            ),
         true,
         coordinates.screen_x,
         coordinates.screen_y,
@@ -672,11 +677,29 @@ pub(crate) fn construct_drag_event<'s>(
     coordinates: InputEventCoordinates,
     data_transfer: v8::Local<'s, v8::Value>,
     modifiers: u8,
+) -> Option<v8::Local<'s, v8::Object>> {
+    construct_drag_event_with_related_target(
+        scope,
+        event_type,
+        coordinates,
+        data_transfer,
+        None,
+        modifiers,
+    )
+}
+
+pub(crate) fn construct_drag_event_with_related_target<'s>(
+    scope: &mut v8::PinScope<'s, '_>,
+    event_type: &str,
+    coordinates: InputEventCoordinates,
+    data_transfer: v8::Local<'s, v8::Value>,
+    related_target: Option<v8::Local<'s, v8::Value>>,
+    modifiers: u8,
 ) -> Option<v8::Local<'s, v8::Object>> {
     let modifier_keys = modifier_key_state(modifiers);
     let init = DragEventInitDeclaration::new(
         true,
-        true,
+        !matches!(event_type, "dragleave" | "dragend"),
         true,
         coordinates.screen_x,
         coordinates.screen_y,
@@ -687,6 +710,7 @@ pub(crate) fn construct_drag_event<'s>(
         modifier_keys.meta,
         modifier_keys.shift,
         data_transfer,
+        related_target,
     )
     .bind(scope)
     .ok()?;
diff --git a/moli-renderer-v8/src/native_bridge/element/forms/submission.rs b/moli-renderer-v8/src/native_bridge/element/forms/submission.rs
index 637d36830c..34ec3d6931 100644
--- a/moli-renderer-v8/src/native_bridge/element/forms/submission.rs
+++ b/moli-renderer-v8/src/native_bridge/element/forms/submission.rs
@@ -128,6 +128,7 @@ fn perform_implicit_form_submission(
             && unsafe { &*runtime_ptr }.has_pending_location_navigation(),
         pending_download: None,
         pending_file_chooser: None,
+        intercepted_drag: None,
     }
 }
 
diff --git a/moli-renderer-v8/src/runtime/mod.rs b/moli-renderer-v8/src/runtime/mod.rs
index 8776e974bd..6c75eaa46e 100644
--- a/moli-renderer-v8/src/runtime/mod.rs
+++ b/moli-renderer-v8/src/runtime/mod.rs
@@ -370,13 +370,13 @@ pub use self::page_surface::{
     RendererDragDataItem, RendererDraggedDirectory, RendererDraggedFile, RendererGeometryQuad,
     RendererInputDispatchOutcome, RendererInspectorProtocolConfiguration,
     RendererInspectorProtocolConfigurationCommand, RendererInspectorSessionRestoreSnapshot,
-    RendererJavaScriptDialogId, RendererJavaScriptDialogSource, RendererLayoutMetrics,
-    RendererMainDocumentCommit, RendererMoliDomMemoryDiagnostics, RendererMoliMemoryDiagnostics,
-    RendererMoliMemoryScopeDiagnostics, RendererMoliRuntimeMemoryDiagnostics,
-    RendererNavigationInitiator, RendererPageCommand, RendererPageCommandPostResponseContinuation,
-    RendererPageCookieFacadeSnapshotReply, RendererPageCreationDiagnostics,
-    RendererPageDiagnosticsSnapshot, RendererPageDumpFormat, RendererPageDumpOptions,
-    RendererPageDumpStripOptions, RendererPageReply, RendererPageView,
+    RendererInterceptedDrag, RendererJavaScriptDialogId, RendererJavaScriptDialogSource,
+    RendererLayoutMetrics, RendererMainDocumentCommit, RendererMoliDomMemoryDiagnostics,
+    RendererMoliMemoryDiagnostics, RendererMoliMemoryScopeDiagnostics,
+    RendererMoliRuntimeMemoryDiagnostics, RendererNavigationInitiator, RendererPageCommand,
+    RendererPageCommandPostResponseContinuation, RendererPageCookieFacadeSnapshotReply,
+    RendererPageCreationDiagnostics, RendererPageDiagnosticsSnapshot, RendererPageDumpFormat,
+    RendererPageDumpOptions, RendererPageDumpStripOptions, RendererPageReply, RendererPageView,
     RendererPendingDownloadActivation, RendererPendingDownloadResponse,
     RendererPendingFileChooserActivation, RendererPendingJavaScriptDialog,
     RendererPendingPopupActivation, RendererPendingSameDocumentNavigation,
diff --git a/moli-renderer-v8/src/runtime/page_commands.rs b/moli-renderer-v8/src/runtime/page_commands.rs
index 493ef1eb9f..c186a3b19f 100644
--- a/moli-renderer-v8/src/runtime/page_commands.rs
+++ b/moli-renderer-v8/src/runtime/page_commands.rs
@@ -122,6 +122,7 @@ impl PageVm {
                 delta_y,
                 pointer,
                 modifiers,
+                intercept_drags: _,
             } if event_name == "wheel" => self
                 .queue_wheel_event(
                     x,
@@ -146,8 +147,9 @@ impl PageVm {
                 delta_y,
                 pointer,
                 modifiers,
-            } => self
-                .dispatch_mouse_event_at_point_with_pointer(
+                intercept_drags,
+            } => {
+                self.dispatch_mouse_event_at_point_with_pointer(
                     x,
                     y,
                     &event_name,
@@ -158,8 +160,10 @@ impl PageVm {
                     delta_y,
                     pointer,
                     modifiers,
+                    intercept_drags,
                 )
-                .map(RendererPageReply::InputDispatchOutcome),
+                .map(RendererPageReply::InputDispatchOutcome)
+            }
             RendererPageCommand::DispatchTouchEvent {
                 points,
                 event_name,
@@ -180,6 +184,9 @@ impl PageVm {
                 self.clear_active_drag_data_transfer()?;
                 Ok(RendererPageReply::Unit)
             }
+            RendererPageCommand::CancelDragging => self
+                .cancel_dragging()
+                .map(RendererPageReply::InputDispatchOutcome),
             RendererPageCommand::MutateDocumentNodeAttribute {
                 reference,
                 mutation,
diff --git a/moli-renderer-v8/src/runtime/page_dom.rs b/moli-renderer-v8/src/runtime/page_dom.rs
index a81a7634b4..0bdf99476a 100644
--- a/moli-renderer-v8/src/runtime/page_dom.rs
+++ b/moli-renderer-v8/src/runtime/page_dom.rs
@@ -594,6 +594,7 @@ impl PageVm {
         delta_y: f64,
         pointer: RendererPointerEventProperties,
         modifiers: u8,
+        intercept_drags: bool,
     ) -> Result<RendererInputDispatchOutcome> {
         let mut outcome = self
             .vm_mut()
@@ -608,6 +609,7 @@ impl PageVm {
                 delta_y,
                 pointer,
                 modifiers,
+                intercept_drags,
             )?;
         self.bind_input_dispatch_file_chooser_backend_node_id(&mut outcome);
         Ok(outcome)
@@ -626,6 +628,12 @@ impl PageVm {
         Ok(outcome)
     }
 
+    pub(crate) fn cancel_dragging(&mut self) -> Result<RendererInputDispatchOutcome> {
+        let mut outcome = self.vm_mut().cancel_dragging()?;
+        self.bind_input_dispatch_file_chooser_backend_node_id(&mut outcome);
+        Ok(outcome)
+    }
+
     pub(crate) fn dispatch_drag_event_at_point(
         &mut self,
         x: f64,
diff --git a/moli-renderer-v8/src/runtime/page_surface.rs b/moli-renderer-v8/src/runtime/page_surface.rs
index 0bbe352eb3..50a731a03e 100644
--- a/moli-renderer-v8/src/runtime/page_surface.rs
+++ b/moli-renderer-v8/src/runtime/page_surface.rs
@@ -479,12 +479,26 @@ pub struct RendererDragData {
     pub drag_operations_mask: i32,
 }
 
+/// String data of a drag that started while the client intercepts drags.
+///
+/// Files and directories are not carried: only string items set through
+/// `DataTransfer.setData` during `dragstart` leave the renderer.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct RendererInterceptedDrag {
+    pub items: Vec<RendererDragDataItem>,
+    pub drag_operations_mask: i32,
+}
+
 #[derive(Debug, Default, Clone, PartialEq, Eq)]
 pub struct RendererInputDispatchOutcome {
     pub handled: bool,
     pub triggered_top_level_navigation: bool,
     pub pending_download: Option<RendererPendingDownloadActivation>,
     pub pending_file_chooser: Option<RendererPendingFileChooserActivation>,
+    /// Set when `dragstart` ran uncanceled and the command asked to intercept
+    /// drags. The renderer then leaves `dragenter`, `dragover` and `drop` to
+    /// `RendererPageCommand::DispatchDragEventAtPoint`.
+    pub intercepted_drag: Option<RendererInterceptedDrag>,
 }
 
 #[derive(Debug, Clone, PartialEq)]
@@ -4824,6 +4838,8 @@ pub enum RendererPageCommand {
         delta_y: f64,
         pointer: RendererPointerEventProperties,
         modifiers: u8,
+        /// `Input.setInterceptDrags` state of the issuing DevTools session.
+        intercept_drags: bool,
     },
     DispatchTouchEvent {
         points: Vec<RendererTouchPoint>,
@@ -4838,6 +4854,7 @@ pub enum RendererPageCommand {
         modifiers: u8,
     },
     ClearActiveDragDataTransfer,
+    CancelDragging,
     InsertTextIntoActiveControl(String),
     DispatchKeyEvent {
         event_name: String,
diff --git a/moli-renderer-v8/src/runtime/page_vm/page_action_window.rs b/moli-renderer-v8/src/runtime/page_vm/page_action_window.rs
index 547d7babc9..57d7a6a792 100644
--- a/moli-renderer-v8/src/runtime/page_vm/page_action_window.rs
+++ b/moli-renderer-v8/src/runtime/page_vm/page_action_window.rs
@@ -111,6 +111,7 @@ impl PageVm {
             triggered_top_level_navigation: false,
             pending_download: None,
             pending_file_chooser: None,
+            intercepted_drag: None,
         })
     }
 
@@ -214,6 +215,7 @@ impl PageVm {
                     event.delta_y,
                     event.pointer,
                     event.modifiers,
+                    false,
                 );
             if let Err(error) = result
                 && first_error.is_none()
diff --git a/moli-renderer-v8/src/runtime/page_vm/tests/file_system_directory_reader.rs b/moli-renderer-v8/src/runtime/page_vm/tests/file_system_directory_reader.rs
index 089c2edf92..141d657817 100644
--- a/moli-renderer-v8/src/runtime/page_vm/tests/file_system_directory_reader.rs
+++ b/moli-renderer-v8/src/runtime/page_vm/tests/file_system_directory_reader.rs
@@ -29,6 +29,7 @@ const dropTarget = document.createElement("div");
 dropTarget.id = "directory-reader-drop-target";
 dropTarget.style.width = "100px";
 dropTarget.style.height = "100px";
+dropTarget.addEventListener("dragover", event => event.preventDefault());
 dropTarget.addEventListener("drop", event => {
   globalThis.__directoryEntry =
     event.dataTransfer.items[0].webkitGetAsEntry();
@@ -39,14 +40,14 @@ document.body.appendChild(dropTarget);
 "#,
     )?;
     page_vm.vm_mut().publish_layout_for_test()?;
-    let outcome = page_vm.dispatch_drag_event_at_point(
-        10.0,
-        10.0,
-        "drop",
-        directory_drag_data(file_count),
-        0,
-    )?;
-    assert!(outcome.handled, "the directory drop fixture must dispatch");
+    let data = directory_drag_data(file_count);
+    for event in ["dragenter", "dragover", "drop"] {
+        let outcome = page_vm.dispatch_drag_event_at_point(10.0, 10.0, event, data.clone(), 0)?;
+        assert!(
+            outcome.handled,
+            "the accepted directory drag fixture must dispatch {event}"
+        );
+    }
     assert_eq!(
         page_vm.vm_mut().eval(
             "__directoryEntry.isDirectory && \
diff --git a/moli-renderer-v8/src/runtime/phase_one/tests/extracted/dom_mutation_state.rs b/moli-renderer-v8/src/runtime/phase_one/tests/extracted/dom_mutation_state.rs
index 268e40b9b4..33915bb120 100644
--- a/moli-renderer-v8/src/runtime/phase_one/tests/extracted/dom_mutation_state.rs
+++ b/moli-renderer-v8/src/runtime/phase_one/tests/extracted/dom_mutation_state.rs
@@ -448,6 +448,7 @@ window.parserPendingPointerCapture = installPendingPointerCaptureTarget('parser-
                     0.0,
                     RendererPointerEventProperties::default(),
                     0,
+                    false,
                 )
                 .expect("JS baseline mousedown should set then clear pending capture");
             page_vm
@@ -462,6 +463,7 @@ window.parserPendingPointerCapture = installPendingPointerCaptureTarget('parser-
                     0.0,
                     RendererPointerEventProperties::default(),
                     0,
+                    false,
                 )
                 .expect("JS baseline mouseup should not use removed pending capture");
             let js_log = page_vm
@@ -486,6 +488,7 @@ window.parserPendingPointerCapture = installPendingPointerCaptureTarget('parser-
                     0.0,
                     RendererPointerEventProperties::default(),
                     0,
+                    false,
                 )
                 .expect("parser baseline mousedown should set pending capture");
 
@@ -527,6 +530,7 @@ window.parserPendingPointerCapture = installPendingPointerCaptureTarget('parser-
                     0.0,
                     RendererPointerEventProperties::default(),
                     0,
+                    false,
                 )
                 .expect("parser baseline mouseup should not use removed pending capture");
             let parser_log = page_vm
@@ -618,6 +622,7 @@ window.parserPendingPointerCaptureReparent =
                     0.0,
                     RendererPointerEventProperties::default(),
                     0,
+                    false,
                 )
                 .expect("JS baseline mousedown should set then clear pending capture by reparent");
             page_vm
@@ -632,6 +637,7 @@ window.parserPendingPointerCaptureReparent =
                     0.0,
                     RendererPointerEventProperties::default(),
                     0,
+                    false,
                 )
                 .expect("JS baseline mouseup should not use reparented pending capture");
             let js_log = page_vm
@@ -656,6 +662,7 @@ window.parserPendingPointerCaptureReparent =
                     0.0,
                     RendererPointerEventProperties::default(),
                     0,
+                    false,
                 )
                 .expect("parser baseline mousedown should set pending capture");
 
@@ -715,6 +722,7 @@ window.parserPendingPointerCaptureReparent =
                     0.0,
                     RendererPointerEventProperties::default(),
                     0,
+                    false,
                 )
                 .expect("parser baseline mouseup should not use reparented pending capture");
             let parser_log = page_vm
diff --git a/moli-renderer-v8/src/runtime/tests.rs b/moli-renderer-v8/src/runtime/tests.rs
index dbf1c33f16..deedf96c6b 100644
--- a/moli-renderer-v8/src/runtime/tests.rs
+++ b/moli-renderer-v8/src/runtime/tests.rs
@@ -360,6 +360,7 @@ async fn dispatch_wheel_for_action_window_test(
             delta_y,
             pointer: RendererPointerEventProperties::default(),
             modifiers: 0,
+            intercept_drags: false,
         })
         .await
         .expect("wheel action should enter the renderer action window");
diff --git a/moli-renderer-v8/src/runtime/tests/extracted/input_dispatch.rs b/moli-renderer-v8/src/runtime/tests/extracted/input_dispatch.rs
index 1f1e1f6d66..95acd1e769 100644
--- a/moli-renderer-v8/src/runtime/tests/extracted/input_dispatch.rs
+++ b/moli-renderer-v8/src/runtime/tests/extracted/input_dispatch.rs
@@ -72,6 +72,7 @@ async fn mouse_input_completion_publishes_handler_navigation_once() {
                 delta_y: 0.0,
                 pointer: RendererPointerEventProperties::default(),
                 modifiers: 0,
+                intercept_drags: false,
             })
             .await
             .expect("input command");
@@ -219,6 +220,7 @@ async fn mouse_input_completion_preserves_standalone_and_child_navigation_scope(
                 delta_y: 0.0,
                 pointer: RendererPointerEventProperties::default(),
                 modifiers: 0,
+                intercept_drags: false,
             })
             .await
             .expect("scope input command");
diff --git a/moli-renderer-v8/src/runtime/tests/extracted/owner_lifecycle.rs b/moli-renderer-v8/src/runtime/tests/extracted/owner_lifecycle.rs
index ce1bf47948..57184039ee 100644
--- a/moli-renderer-v8/src/runtime/tests/extracted/owner_lifecycle.rs
+++ b/moli-renderer-v8/src/runtime/tests/extracted/owner_lifecycle.rs
@@ -20,6 +20,7 @@ async fn owner_loop_runs_file_reading_callback_without_retry_command() {
         r#"<!doctype html><body>
 <div id="drop" style="width: 100px; height: 100px">drop</div>
 <script>
+document.getElementById("drop").addEventListener("dragover", event => event.preventDefault());
 document.getElementById("drop").addEventListener("drop", event => {
   const reader =
     event.dataTransfer.items[0].webkitGetAsEntry().createReader();
@@ -35,37 +36,40 @@ document.getElementById("drop").addEventListener("drop", event => {
     )
     .await;
 
-    let (reply, _) = page
-        .run_async_command(RendererPageCommand::DispatchDragEventAtPoint {
-            x: 10.0,
-            y: 10.0,
-            event_name: "drop".to_owned(),
-            data: RendererDragData {
-                items: Vec::new(),
-                files: Vec::new(),
-                directories: vec![RendererDraggedDirectory {
-                    name: "fixture".to_owned(),
-                    files: vec![RendererDraggedFile {
-                        bytes: b"body".to_vec(),
-                        mime_type: "text/plain".to_owned(),
-                        name: "entry.txt".to_owned(),
-                        last_modified: 1.0,
-                    }],
-                    directories: Vec::new(),
-                }],
-                drag_operations_mask: 1,
-            },
-            modifiers: 0,
-        })
-        .await
-        .expect("directory drop command should run");
-    assert!(
-        matches!(
-            reply,
-            RendererPageReply::InputDispatchOutcome(ref outcome) if outcome.handled
-        ),
-        "directory drop command should dispatch to the target"
-    );
+    let data = RendererDragData {
+        items: Vec::new(),
+        files: Vec::new(),
+        directories: vec![RendererDraggedDirectory {
+            name: "fixture".to_owned(),
+            files: vec![RendererDraggedFile {
+                bytes: b"body".to_vec(),
+                mime_type: "text/plain".to_owned(),
+                name: "entry.txt".to_owned(),
+                last_modified: 1.0,
+            }],
+            directories: Vec::new(),
+        }],
+        drag_operations_mask: 1,
+    };
+    for event_name in ["dragenter", "dragover", "drop"] {
+        let (reply, _) = page
+            .run_async_command(RendererPageCommand::DispatchDragEventAtPoint {
+                x: 10.0,
+                y: 10.0,
+                event_name: event_name.to_owned(),
+                data: data.clone(),
+                modifiers: 0,
+            })
+            .await
+            .expect("directory drop command should run");
+        assert!(
+            matches!(
+                reply,
+                RendererPageReply::InputDispatchOutcome(ref outcome) if outcome.handled
+            ),
+            "directory drop command should dispatch to the target"
+        );
+    }
 
     tokio::time::timeout(Duration::from_secs(2), callback_request_seen)
         .await
diff --git a/moli-renderer-v8/src/script_vm.rs b/moli-renderer-v8/src/script_vm.rs
index 0499e83d42..e34950de3a 100644
--- a/moli-renderer-v8/src/script_vm.rs
+++ b/moli-renderer-v8/src/script_vm.rs
@@ -877,6 +877,7 @@ fn input_dispatch_outcome(handled: bool) -> RendererInputDispatchOutcome {
         triggered_top_level_navigation: false,
         pending_download: None,
         pending_file_chooser: None,
+        intercepted_drag: None,
     }
 }
 
@@ -1043,6 +1044,7 @@ pub(super) struct ScriptVm {
     suppress_compat_mouse_events: bool,
     active_scrollbar_drag: Option<ActiveScrollbarDrag>,
     active_drag_session: Option<ActiveDragSession>,
+    pending_drag_gesture: Option<PendingDragGesture>,
     promise_reject_dispatch: PromiseRejectDispatchSlot,
     next_internal_runtime_evaluate_call_id: i32,
     next_internal_frontend_inspector_call_id: i32,
@@ -1113,9 +1115,28 @@ pub(super) struct ActiveTouchPoint {
 
 pub(super) struct ActiveDragSession {
     pub data_store: crate::context_bootstrap::NativeDragDataStore,
+    /// Chromium retains the source view for dragend, without restoring data access.
     pub source_transfer: Option<v8::Global<v8::Object>>,
     pub drop_effect: String,
     pub drop_allowed: bool,
+    /// Element that received `dragstart`; `dragend` is dispatched here.
+    /// `None` for sessions created from externally supplied drag data.
+    pub source: Option<DomHandle>,
+    /// The DevTools client asked to take over the drag, so mouse events no
+    /// longer drive `dragover` and `drop`. `Input.dispatchDragEvent` does.
+    pub intercepted: bool,
+    pub target: Option<DomHandle>,
+    pub x: f64,
+    pub y: f64,
+    pub modifiers: u8,
+}
+
+#[derive(Clone, Copy)]
+pub(super) struct PendingDragGesture {
+    pub handle: DomHandle,
+    pub x: f64,
+    pub y: f64,
+    pub root_to_frame: moli_layout::LayoutTransform2D,
 }
 
 #[derive(Clone, Copy, Debug, PartialEq)]
@@ -2554,6 +2575,7 @@ impl ScriptVmDefaultWorldBootstrap {
             suppress_compat_mouse_events: false,
             active_scrollbar_drag: None,
             active_drag_session: None,
+            pending_drag_gesture: None,
             promise_reject_dispatch,
             next_internal_runtime_evaluate_call_id: 1,
             next_internal_frontend_inspector_call_id: -1,
diff --git a/moli-renderer-v8/src/script_vm/element_click.rs b/moli-renderer-v8/src/script_vm/element_click.rs
index c66efcbb77..7e8fd437d5 100644
--- a/moli-renderer-v8/src/script_vm/element_click.rs
+++ b/moli-renderer-v8/src/script_vm/element_click.rs
@@ -192,6 +192,7 @@ impl ScriptVm {
                 0.0,
                 RendererPointerEventProperties::default(),
                 0,
+                false,
             );
             let next = match dispatched {
                 Ok(next) => next,
diff --git a/moli-renderer-v8/src/script_vm/input_dispatch.rs b/moli-renderer-v8/src/script_vm/input_dispatch.rs
index 172dd1ff56..7204a10db4 100644
--- a/moli-renderer-v8/src/script_vm/input_dispatch.rs
+++ b/moli-renderer-v8/src/script_vm/input_dispatch.rs
@@ -11,7 +11,9 @@ use super::input_helpers::{mouse_button_mask, single_changed_mouse_button};
 use super::inspector::{
     current_selection_state, is_space_key, key_target_info, option_is_disabled, radio_group_members,
 };
-use super::{ActiveDragSession, ActiveScrollbarDrag, ActiveTouchPoint, ScriptVm};
+use super::{
+    ActiveDragSession, ActiveScrollbarDrag, ActiveTouchPoint, PendingDragGesture, ScriptVm,
+};
 use crate::context_bootstrap::DragDataStoreMode;
 use crate::document_runtime::DomHandle;
 use crate::dom::{
@@ -22,7 +24,7 @@ use crate::native_bridge::element::{
     InputEventCoordinates, TextEditInputType, TouchEventPoint,
     activate_handle_after_pointer_release, activate_handle_via_click,
     activate_handle_via_click_with_detail_and_modifiers, cache_input_files_from_selected_files,
-    construct_drag_event, construct_keyboard_event,
+    construct_drag_event, construct_drag_event_with_related_target, construct_keyboard_event,
     construct_mouse_event_with_detail_and_modifiers, construct_mouse_event_with_modifiers,
     construct_mouse_event_with_related_target_and_modifiers, construct_pointer_event,
     construct_pointer_event_with_modifiers, construct_pointer_event_with_related_target,
@@ -40,8 +42,8 @@ use crate::native_bridge::{
     CurrentInputEvent, CurrentInputEventScope, MouseReleaseFollowUp, PointerCaptureDispatchEvent,
 };
 use crate::runtime::{
-    RendererDragData, RendererInputDispatchOutcome, RendererPointerEventProperties,
-    RendererTouchPoint,
+    RendererDragData, RendererDragDataItem, RendererInputDispatchOutcome, RendererInterceptedDrag,
+    RendererPointerEventProperties, RendererTouchPoint,
 };
 use crate::util::{
     node_wrapper_from_handle, utf16_len, utf16_next_scalar_boundary,
@@ -55,36 +57,79 @@ fn related_target_value<'s>(
     node_wrapper_from_handle(scope, handle?).map(Into::into)
 }
 
-fn close_drag_data_transfer_source(
-    scope: &mut v8::PinScope<'_, '_>,
-    active: &mut Option<ActiveDragSession>,
-) {
-    if let Some(session) = active.take()
-        && let Some(source) = session.source_transfer
-    {
-        let source = v8::Local::new(scope, &source);
-        crate::context_bootstrap::finish_drag_data_transfer_view(scope, source);
-    }
+#[derive(Clone, Copy)]
+enum DragFinishReason {
+    Dropped,
+    Canceled,
+    Rejected,
 }
 
-fn accepted_drag_view_operation<'s>(
+/// Take the session before calling script so every exit path ends it once.
+fn finish_drag_session<'s>(
     scope: &mut v8::PinScope<'s, '_>,
     runtime_ptr: *mut crate::native_bridge::JsContextHost,
-    target: DomHandle,
+    active: &mut Option<ActiveDragSession>,
+    reason: DragFinishReason,
+    x: f64,
+    y: f64,
+    modifiers: u8,
+) {
+    let Some(session) = active.take() else {
+        return;
+    };
+    if !matches!(reason, DragFinishReason::Dropped)
+        && let Some(target) = session.target
+        && let Some(data_transfer) = crate::context_bootstrap::create_drag_data_transfer_view(
+            scope,
+            &session.data_store,
+            DragDataStoreMode::Protected,
+            "none",
+        )
+    {
+        if let Some(event) = construct_drag_event(
+            scope,
+            "dragleave",
+            InputEventCoordinates::from_root(x, y),
+            data_transfer.into(),
+            modifiers,
+        ) {
+            let _ = dispatch_public_event(scope, runtime_ptr, target, event);
+        }
+        crate::context_bootstrap::finish_drag_data_transfer_view(scope, data_transfer);
+    }
+    if let Some(source) = session.source
+        && let Some(source_transfer) = session.source_transfer.as_ref()
+    {
+        let data_transfer = v8::Local::new(scope, source_transfer);
+        // The source keeps its identity and protected original metadata.
+        // Only the final operation is published back to dragend listeners;
+        // source data never becomes readable during the target's drop.
+        let effect = if matches!(reason, DragFinishReason::Dropped) {
+            session.drop_effect.as_str()
+        } else {
+            "none"
+        };
+        crate::context_bootstrap::native_set_drag_drop_effect(scope, data_transfer, effect);
+        if let Some(event) = construct_drag_event(
+            scope,
+            "dragend",
+            InputEventCoordinates::from_root(x, y),
+            data_transfer.into(),
+            modifiers,
+        ) {
+            let _ = dispatch_public_event(scope, runtime_ptr, source, event);
+        }
+        crate::context_bootstrap::finish_drag_data_transfer_view(scope, data_transfer);
+    }
+    unsafe { &mut *runtime_ptr }.clear_mouse_press();
+}
+
+fn author_drag_operation<'s>(
+    scope: &mut v8::PinScope<'s, '_>,
     transfer: v8::Local<'s, v8::Object>,
-    allows_default: bool,
     modifiers: u8,
 ) -> Option<String> {
     let allowed = crate::context_bootstrap::native_data_transfer_effect_allowed(scope, transfer);
-    if allows_default {
-        return (crate::native_bridge::element::accepts_drop_default_action(
-            scope,
-            runtime_ptr,
-            target,
-            transfer,
-        ) && drop_effect_allowed_by_effect_allowed(Some(&allowed), "copy"))
-        .then(|| "copy".to_owned());
-    }
     let operation = if crate::context_bootstrap::native_data_transfer_drop_effect_is_initialized(
         scope, transfer,
     ) {
@@ -100,21 +145,251 @@ fn accepted_drag_view_operation<'s>(
     drop_effect_allowed_by_effect_allowed(Some(&allowed), &operation).then_some(operation)
 }
 
-fn perform_drag_default_action_with_private_view(
-    scope: &mut v8::PinScope<'_, '_>,
+fn accepted_drag_operation<'s>(
+    scope: &mut v8::PinScope<'s, '_>,
     runtime_ptr: *mut crate::native_bridge::JsContextHost,
-    handle: DomHandle,
-    session: &ActiveDragSession,
+    target: DomHandle,
+    transfer: v8::Local<'s, v8::Object>,
+    canceled: bool,
+    modifiers: u8,
+) -> Option<String> {
+    if canceled {
+        return author_drag_operation(scope, transfer, modifiers);
+    }
+    let allowed = crate::context_bootstrap::native_data_transfer_effect_allowed(scope, transfer);
+    (crate::native_bridge::element::accepts_drop_default_action(
+        scope,
+        runtime_ptr,
+        target,
+        transfer,
+    ) && drop_effect_allowed_by_effect_allowed(Some(&allowed), "copy"))
+    .then(|| "copy".to_owned())
+}
+
+/// One renderer update owns one target view. A transition delivers enter before
+/// leave using that view; a later update delivers over using a new view.
+fn update_drag_target<'s>(
+    scope: &mut v8::PinScope<'s, '_>,
+    runtime_ptr: *mut crate::native_bridge::JsContextHost,
+    session: &mut ActiveDragSession,
+    target: Option<DomHandle>,
+    x: f64,
+    y: f64,
+    modifiers: u8,
 ) {
-    if let Some(transfer) = crate::context_bootstrap::create_drag_data_transfer_view(
+    session.x = x;
+    session.y = y;
+    session.modifiers = modifiers;
+    session.drop_allowed = false;
+    session.drop_effect = "none".to_owned();
+    let Some(transfer) = crate::context_bootstrap::create_drag_data_transfer_view(
+        scope,
+        &session.data_store,
+        DragDataStoreMode::Protected,
+        "none",
+    ) else {
+        return;
+    };
+    let mut operation = None;
+    if session.target != target {
+        if let Some(target) = target {
+            let related = related_target_value(scope, session.target);
+            if let Some(event) = construct_drag_event_with_related_target(
+                scope,
+                "dragenter",
+                InputEventCoordinates::from_root(x, y),
+                transfer.into(),
+                related,
+                modifiers,
+            ) {
+                let canceled =
+                    !dispatch_public_event(scope, runtime_ptr, target, event).allows_default();
+                operation = accepted_drag_operation(
+                    scope,
+                    runtime_ptr,
+                    target,
+                    transfer,
+                    canceled,
+                    modifiers,
+                );
+            }
+        }
+        if let Some(previous) = session.target {
+            let related = related_target_value(scope, target);
+            if let Some(event) = construct_drag_event_with_related_target(
+                scope,
+                "dragleave",
+                InputEventCoordinates::from_root(x, y),
+                transfer.into(),
+                related,
+                modifiers,
+            ) {
+                let _ = dispatch_public_event(scope, runtime_ptr, previous, event);
+            }
+        }
+        session.target = target;
+    } else if let Some(target) = target
+        && let Some(event) = construct_drag_event(
+            scope,
+            "dragover",
+            InputEventCoordinates::from_root(x, y),
+            transfer.into(),
+            modifiers,
+        )
+    {
+        let canceled = !dispatch_public_event(scope, runtime_ptr, target, event).allows_default();
+        operation =
+            accepted_drag_operation(scope, runtime_ptr, target, transfer, canceled, modifiers);
+    }
+    crate::context_bootstrap::finish_drag_data_transfer_view(scope, transfer);
+    if let Some(operation) = operation {
+        session.drop_allowed = true;
+        session.drop_effect = operation;
+    }
+}
+
+fn drop_drag_target<'s>(
+    scope: &mut v8::PinScope<'s, '_>,
+    runtime_ptr: *mut crate::native_bridge::JsContextHost,
+    session: &ActiveDragSession,
+    x: f64,
+    y: f64,
+    modifiers: u8,
+) -> DragFinishReason {
+    let Some(target) = session.target.filter(|_| session.drop_allowed) else {
+        return DragFinishReason::Rejected;
+    };
+    let Some(transfer) = crate::context_bootstrap::create_drag_data_transfer_view(
         scope,
         &session.data_store,
         DragDataStoreMode::ReadOnly,
-        &session.drop_effect,
-    ) {
-        let _ = perform_drop_default_action(scope, runtime_ptr, handle, transfer);
-        crate::context_bootstrap::finish_drag_data_transfer_view(scope, transfer);
+        "none",
+    ) else {
+        return DragFinishReason::Rejected;
+    };
+    let event = construct_drag_event(
+        scope,
+        "drop",
+        InputEventCoordinates::from_root(x, y),
+        transfer.into(),
+        modifiers,
+    );
+    let default_allowed = event.is_some_and(|event| {
+        dispatch_public_event(scope, runtime_ptr, target, event).allows_default()
+    });
+    crate::context_bootstrap::finish_drag_data_transfer_view(scope, transfer);
+    if default_allowed
+        && let Some(default_transfer) = crate::context_bootstrap::create_drag_data_transfer_view(
+            scope,
+            &session.data_store,
+            DragDataStoreMode::ReadOnly,
+            &session.drop_effect,
+        )
+    {
+        // The DOM drop view is already disabled before beforeinput/input run.
+        // The existing editing code consumes a private view of the same store.
+        let _ = perform_drop_default_action(scope, runtime_ptr, target, default_transfer);
+        crate::context_bootstrap::finish_drag_data_transfer_view(scope, default_transfer);
     }
+    if event.is_some() {
+        DragFinishReason::Dropped
+    } else {
+        DragFinishReason::Rejected
+    }
+}
+
+/// Only text whose selected ink contains the original press starts a selection
+/// drag. An unrelated selection elsewhere in the document is not a source.
+fn selected_drag_text(
+    scope: &mut v8::PinScope<'_, '_>,
+    runtime_ptr: *mut crate::native_bridge::JsContextHost,
+    handle: DomHandle,
+    x: f64,
+    y: f64,
+) -> Option<String> {
+    crate::context_bootstrap::document_selection_drag_text_at_point(
+        scope,
+        runtime_ptr,
+        handle,
+        x,
+        y,
+    )
+}
+
+fn native_drag_source(
+    scope: &mut v8::PinScope<'_, '_>,
+    runtime_ptr: *mut crate::native_bridge::JsContextHost,
+    gesture: PendingDragGesture,
+) -> Option<(DomHandle, RendererDragData)> {
+    let runtime = unsafe { &*runtime_ptr };
+    let host = runtime.dom_host();
+    if !host.is_connected(gesture.handle) {
+        return None;
+    }
+    let mut candidate = None;
+    let mut current = Some(gesture.handle);
+    while let Some(handle) = current {
+        if let Some(element) = host.node(handle).and_then(Node::as_element) {
+            let attribute = element.attribute_ns("", "draggable");
+            let is_image = element.is_html_element("img");
+            let is_link = element.is_html_element("a") && element.has_attribute_ns("", "href");
+            let explicitly_draggable =
+                attribute.is_some_and(|value| value.eq_ignore_ascii_case("true"));
+            let disabled = attribute.is_some_and(|value| value.eq_ignore_ascii_case("false"));
+            if !disabled && (explicitly_draggable || is_image || is_link) {
+                candidate = Some((
+                    handle,
+                    if is_image {
+                        Some("src")
+                    } else if is_link {
+                        Some("href")
+                    } else {
+                        None
+                    },
+                ));
+                break;
+            }
+        }
+        current = host
+            .parent_node(handle)
+            .or_else(|| host.shadow_root_host(handle));
+    }
+    let mut data = RendererDragData {
+        items: Vec::new(),
+        files: Vec::new(),
+        directories: Vec::new(),
+        drag_operations_mask: 19,
+    };
+    if candidate.is_none_or(|(_, attribute)| attribute != Some("src"))
+        && let Some(text) =
+            selected_drag_text(scope, runtime_ptr, gesture.handle, gesture.x, gesture.y)
+    {
+        data.items.push(RendererDragDataItem {
+            mime_type: "text/plain".to_owned(),
+            data: text,
+            title: None,
+            base_url: None,
+        });
+        return Some((gesture.handle, data));
+    }
+    let (source, attribute) = candidate?;
+    if let Some(attribute) = attribute {
+        let element = host.node(source)?.as_element()?;
+        if let Some(raw) = element.attribute_ns("", attribute)
+            && let Some(document) = host.owner_document_handle(source)
+            && let Ok(url) = runtime.document_base_url_for_handle(document).join(raw)
+        {
+            for mime_type in ["text/uri-list", "text/plain"] {
+                data.items.push(RendererDragDataItem {
+                    mime_type: mime_type.to_owned(),
+                    data: url.to_string(),
+                    title: None,
+                    base_url: None,
+                });
+            }
+        }
+    }
+    Some((source, data))
 }
 
 fn tracks_mouse_hover_for_event(event_name: &str) -> bool {
@@ -417,6 +692,7 @@ impl ScriptVm {
             delta_y,
             pointer,
             0,
+            false,
         )
     }
 
@@ -432,6 +708,7 @@ impl ScriptVm {
         delta_y: f64,
         pointer: RendererPointerEventProperties,
         modifiers: u8,
+        intercept_drags: bool,
     ) -> Result<RendererInputDispatchOutcome> {
         let surface_hit = self.mouse_input_surface_hit(x, y, event_name)?;
         let prepared = self.prepare_mouse_input_dispatch(event_name, button, buttons);
@@ -450,6 +727,7 @@ impl ScriptVm {
             delta_y,
             pointer,
             modifiers,
+            intercept_drags,
         );
         if event_name == "mouseup" {
             self._context_host.borrow_mut().clear_mouse_press();
@@ -506,6 +784,7 @@ impl ScriptVm {
         delta_y: f64,
         pointer: RendererPointerEventProperties,
         modifiers: u8,
+        intercept_drags: bool,
     ) -> Result<RendererInputDispatchOutcome> {
         let surface_hit = self.mouse_input_surface_hit(x, y, event_name)?;
         let prepared = self.prepare_mouse_input_dispatch(event_name, button, buttons);
@@ -524,6 +803,7 @@ impl ScriptVm {
             delta_y,
             pointer,
             modifiers,
+            intercept_drags,
         );
         if event_name == "mouseup" {
             self._context_host.borrow_mut().clear_mouse_press();
@@ -595,6 +875,9 @@ impl ScriptVm {
         let buttons = buttons.unwrap_or(self.pressed_mouse_buttons);
         if event_name == "mousedown" {
             self._context_host.borrow_mut().clear_mouse_press();
+            self.pending_drag_gesture = None;
+        } else if event_name == "mouseup" || self.pressed_mouse_buttons & 1 == 0 {
+            self.pending_drag_gesture = None;
         }
         PreparedMouseInputDispatch { button, buttons }
     }
@@ -612,28 +895,93 @@ impl ScriptVm {
         delta_y: f64,
         pointer: RendererPointerEventProperties,
         modifiers: u8,
+        intercept_drags: bool,
     ) -> Result<RendererInputDispatchOutcome> {
         let PreparedMouseInputDispatch { button, buttons } = prepared;
 
-        if (event_name == "mousemove" && buttons & 1 == 0)
-            || (event_name == "mousedown" && button == 0)
+        if self
+            .active_drag_session
+            .as_ref()
+            .is_some_and(|session| session.intercepted && !intercept_drags)
+            || event_name == "mousedown" && button == 0
+            || event_name == "mousemove" && buttons & 1 == 0
         {
-            self.clear_active_drag_data_transfer()?;
+            self.finish_active_drag(DragFinishReason::Canceled, x, y, modifiers)?;
+        }
+
+        // Native dragging owns the pointer stream until the drag ends. The
+        // threshold-crossing move has already sent pointercancel; further
+        // moves and the native release drive dragging rather than DOM mouse
+        // input. A later explicit CDP release after replay ends is normal input.
+        if matches!(event_name, "mousemove" | "mouseup")
+            && self
+                .active_drag_session
+                .as_ref()
+                .is_some_and(|session| session.source.is_some())
+        {
+            let hit = surface_hit.input;
+            let target = hit.map(|hit| hit.handle);
+            let local = hit.map(|hit| {
+                hit.root_to_frame
+                    .map_point(moli_layout::LayoutPoint::new(x as f32, y as f32))
+            });
+            let (client_x, client_y) = local
+                .map(|point| (f64::from(point.x), f64::from(point.y)))
+                .unwrap_or((x, y));
+            let active = &mut self.active_drag_session as *mut Option<ActiveDragSession>;
+            self.with_default_context_scope(|scope, runtime_ptr| {
+                let active = unsafe { &mut *active };
+                if let Some(session) = active.as_mut() {
+                    if !session.intercepted {
+                        update_drag_target(
+                            scope,
+                            runtime_ptr,
+                            session,
+                            target,
+                            client_x,
+                            client_y,
+                            modifiers,
+                        );
+                    }
+                    if event_name == "mouseup" && button == 0 {
+                        let reason = if session.intercepted {
+                            DragFinishReason::Rejected
+                        } else {
+                            drop_drag_target(
+                                scope,
+                                runtime_ptr,
+                                session,
+                                client_x,
+                                client_y,
+                                modifiers,
+                            )
+                        };
+                        finish_drag_session(
+                            scope,
+                            runtime_ptr,
+                            active,
+                            reason,
+                            client_x,
+                            client_y,
+                            modifiers,
+                        );
+                    }
+                }
+                Ok(())
+            })?;
+            return Ok(input_dispatch_outcome(true));
         }
 
         if let Some(outcome) =
             self.dispatch_active_scrollbar_mouse_event(x, y, event_name, button, buttons)?
         {
-            if event_name == "mouseup" && button == 0 {
-                self.clear_active_drag_data_transfer()?;
-            }
             return Ok(outcome);
         }
 
         let root_point = moli_layout::LayoutPoint::new(x as f32, y as f32);
         if let Some(control) = surface_hit.control {
             if event_name == "mouseup" && button == 0 {
-                self.clear_active_drag_data_transfer()?;
+                self.finish_active_drag(DragFinishReason::Rejected, x, y, modifiers)?;
             }
             return match control {
                 moli_layout::LayoutControlSurfaceHit::Scrollbar(scrollbar) => {
@@ -701,7 +1049,17 @@ impl ScriptVm {
             .flatten();
         let Some(handle) = capture_handle.or(hit_handle).or(wheel_fallback_handle) else {
             if event_name == "mouseup" && button == 0 {
-                self.clear_active_drag_data_transfer()?;
+                self.finish_active_drag(DragFinishReason::Rejected, x, y, modifiers)?;
+            } else if event_name == "mousemove" {
+                let active = &mut self.active_drag_session as *mut Option<ActiveDragSession>;
+                self.with_default_context_scope(|scope, runtime_ptr| {
+                    if let Some(session) = unsafe { &mut *active }.as_mut()
+                        && !session.intercepted
+                    {
+                        update_drag_target(scope, runtime_ptr, session, None, x, y, modifiers);
+                    }
+                    Ok(())
+                })?;
             }
             return Ok(input_dispatch_outcome(false));
         };
@@ -715,8 +1073,9 @@ impl ScriptVm {
             .map(|hit| hit.root_to_frame)
             .unwrap_or(moli_layout::LayoutTransform2D::IDENTITY);
         let client_point = root_to_frame.map_point(root_point);
-        let coordinates = InputEventCoordinates::from_root(x, y)
-            .with_client(f64::from(client_point.x), f64::from(client_point.y));
+        let client_x = f64::from(client_point.x);
+        let client_y = f64::from(client_point.y);
+        let coordinates = InputEventCoordinates::from_root(x, y).with_client(client_x, client_y);
         let hover_transition = if tracks_mouse_hover_for_event(event_name) {
             let previous = self.hovered_mouse_handle;
             if previous != Some(handle) {
@@ -731,11 +1090,30 @@ impl ScriptVm {
         } else {
             None
         };
-        let drag_start_handle = if event_name == "mousemove"
+        let drag_start = if event_name == "mousemove"
             && buttons & 1 != 0
             && self.active_drag_session.is_none()
         {
-            self._context_host.borrow().mouse_press_handle()
+            if self._context_host.borrow().mouse_press_handle().is_none() {
+                self.pending_drag_gesture = None;
+            }
+            let gesture = self.pending_drag_gesture.filter(|gesture| {
+                let point = gesture.root_to_frame.map_point(root_point);
+                #[cfg(target_os = "macos")]
+                let threshold = 3.0;
+                #[cfg(not(target_os = "macos"))]
+                let threshold = 4.0;
+                (f64::from(point.x).floor() - gesture.x.floor()).abs() >= threshold
+                    || (f64::from(point.y).floor() - gesture.y.floor()).abs() >= threshold
+            });
+            if let Some(gesture) = gesture {
+                // The gesture is consumed even if dragstart is canceled. A
+                // held button cannot start another drag until a fresh press.
+                self.pending_drag_gesture = None;
+                Some(gesture)
+            } else {
+                None
+            }
         } else {
             None
         };
@@ -744,500 +1122,574 @@ impl ScriptVm {
             self._context_host
                 .borrow_mut()
                 .begin_mouse_press(handle, button);
+            if button == 0 {
+                self.pending_drag_gesture = Some(PendingDragGesture {
+                    handle: hit_handle.unwrap_or(handle),
+                    x: client_x,
+                    y: client_y,
+                    root_to_frame,
+                });
+            }
         }
 
         let active_drag_session: *mut Option<ActiveDragSession> = &mut self.active_drag_session;
+        let intercepted_drag = Cell::new(None);
+        let mouse_down_allows_drag = Cell::new(true);
 
         let mut suppress_compat_mouse_events = self.suppress_compat_mouse_events;
         if event_name == "mousemove" && buttons == 0 {
             suppress_compat_mouse_events = false;
         }
 
-        let result =
-            self.with_default_context_scope(|scope, runtime_ptr| {
-                let mut pointer_dispatch_handle = handle;
-                if let Some((Some(previous_handle), previous_root_to_frame)) = hover_transition {
-                    let previous_client_point = previous_root_to_frame.map_point(root_point);
-                    let previous_coordinates = InputEventCoordinates::from_root(x, y).with_client(
-                        f64::from(previous_client_point.x),
-                        f64::from(previous_client_point.y),
-                    );
-                    let related_target = related_target_value(scope, Some(handle));
-                    if let Some(event) = construct_pointer_event_with_related_target_and_modifiers(
-                        scope,
-                        "pointerout",
-                        previous_coordinates,
-                        button,
-                        buttons,
-                        &pointer,
-                        related_target,
-                        modifiers,
-                    ) {
-                        let _ = dispatch_public_event(scope, runtime_ptr, previous_handle, event);
-                    }
-                    let related_target = related_target_value(scope, Some(handle));
-                    if let Some(event) = construct_pointer_event_with_related_target_and_modifiers(
-                        scope,
-                        "pointerleave",
-                        previous_coordinates,
-                        button,
-                        buttons,
-                        &pointer,
-                        related_target,
-                        modifiers,
-                    ) {
-                        let _ = dispatch_public_event(scope, runtime_ptr, previous_handle, event);
-                    }
+        let result = self.with_default_context_scope(|scope, runtime_ptr| {
+            let drag_start = drag_start.and_then(|gesture| {
+                let start_root =
+                    gesture
+                        .root_to_frame
+                        .inverse()?
+                        .map_point(moli_layout::LayoutPoint::new(
+                            gesture.x as f32,
+                            gesture.y as f32,
+                        ));
+                let start_coordinates = InputEventCoordinates::from_root(
+                    f64::from(start_root.x),
+                    f64::from(start_root.y),
+                )
+                .with_client(gesture.x, gesture.y);
+                native_drag_source(scope, runtime_ptr, gesture)
+                    .map(|(source, data)| (source, data, start_coordinates))
+            });
+            let mut pointer_dispatch_handle = handle;
+            if let Some((Some(previous_handle), previous_root_to_frame)) = hover_transition {
+                let previous_client_point = previous_root_to_frame.map_point(root_point);
+                let previous_coordinates = InputEventCoordinates::from_root(x, y).with_client(
+                    f64::from(previous_client_point.x),
+                    f64::from(previous_client_point.y),
+                );
+                let related_target = related_target_value(scope, Some(handle));
+                if let Some(event) = construct_pointer_event_with_related_target_and_modifiers(
+                    scope,
+                    "pointerout",
+                    previous_coordinates,
+                    button,
+                    buttons,
+                    &pointer,
+                    related_target,
+                    modifiers,
+                ) {
+                    let _ = dispatch_public_event(scope, runtime_ptr, previous_handle, event);
                 }
-                if let Some((previous_handle, _)) = hover_transition {
-                    let related_target = related_target_value(scope, previous_handle);
-                    if let Some(event) = construct_pointer_event_with_related_target_and_modifiers(
-                        scope,
-                        "pointerover",
-                        coordinates,
-                        button,
-                        buttons,
-                        &pointer,
-                        related_target,
-                        modifiers,
-                    ) {
-                        let _ = dispatch_public_event(scope, runtime_ptr, handle, event);
-                    }
-                    let related_target = related_target_value(scope, previous_handle);
-                    if let Some(event) = construct_pointer_event_with_related_target_and_modifiers(
-                        scope,
-                        "pointerenter",
-                        coordinates,
-                        button,
-                        buttons,
-                        &pointer,
-                        related_target,
-                        modifiers,
-                    ) {
-                        let _ = dispatch_public_event(scope, runtime_ptr, handle, event);
-                    }
+                let related_target = related_target_value(scope, Some(handle));
+                if let Some(event) = construct_pointer_event_with_related_target_and_modifiers(
+                    scope,
+                    "pointerleave",
+                    previous_coordinates,
+                    button,
+                    buttons,
+                    &pointer,
+                    related_target,
+                    modifiers,
+                ) {
+                    let _ = dispatch_public_event(scope, runtime_ptr, previous_handle, event);
                 }
-                if pointer_event_name == Some("pointermove")
-                    && let Some(event) = construct_pointer_event_with_modifiers(
-                        scope,
-                        "pointerrawupdate",
-                        coordinates,
-                        button,
-                        buttons,
-                        &pointer,
-                        modifiers,
-                    )
-                {
-                    let _ =
-                        dispatch_public_event(scope, runtime_ptr, pointer_dispatch_handle, event);
-                    let post_raw_update_capture_events = {
-                        let runtime = unsafe { &mut *runtime_ptr };
-                        runtime.process_pending_pointer_capture(MOUSE_POINTER_ID)
-                    };
-                    dispatch_pointer_capture_events(
-                        scope,
-                        runtime_ptr,
-                        MOUSE_POINTER_ID,
-                        &post_raw_update_capture_events,
-                        coordinates,
-                        button,
-                        buttons,
-                        &pointer,
-                        modifiers,
-                    );
-                    if !post_raw_update_capture_events.is_empty() {
-                        pointer_dispatch_handle = unsafe { &*runtime_ptr }
-                            .active_pointer_capture_target(MOUSE_POINTER_ID)
-                            .or(hit_handle)
-                            .unwrap_or(pointer_dispatch_handle);
-                        unsafe { &mut *runtime_ptr }
-                            .set_mouse_event_target(pointer_dispatch_handle);
-                    }
+            }
+            if let Some((previous_handle, _)) = hover_transition {
+                let related_target = related_target_value(scope, previous_handle);
+                if let Some(event) = construct_pointer_event_with_related_target_and_modifiers(
+                    scope,
+                    "pointerover",
+                    coordinates,
+                    button,
+                    buttons,
+                    &pointer,
+                    related_target,
+                    modifiers,
+                ) {
+                    let _ = dispatch_public_event(scope, runtime_ptr, handle, event);
                 }
-                if let Some((Some(previous_handle), previous_root_to_frame)) = hover_transition {
-                    let previous_client_point = previous_root_to_frame.map_point(root_point);
-                    let previous_coordinates = InputEventCoordinates::from_root(x, y).with_client(
-                        f64::from(previous_client_point.x),
-                        f64::from(previous_client_point.y),
-                    );
-                    let related_target = related_target_value(scope, Some(handle));
-                    if let Some(event) = construct_mouse_event_with_related_target_and_modifiers(
-                        scope,
-                        "mouseout",
-                        previous_coordinates,
-                        button,
-                        buttons,
-                        related_target,
-                        modifiers,
-                    ) {
-                        let _ = dispatch_public_event(scope, runtime_ptr, previous_handle, event);
-                    }
-                    let related_target = related_target_value(scope, Some(handle));
-                    if let Some(event) = construct_mouse_event_with_related_target_and_modifiers(
-                        scope,
-                        "mouseleave",
-                        previous_coordinates,
-                        button,
-                        buttons,
-                        related_target,
-                        modifiers,
-                    ) {
-                        let _ = dispatch_public_event(scope, runtime_ptr, previous_handle, event);
-                    }
+                let related_target = related_target_value(scope, previous_handle);
+                if let Some(event) = construct_pointer_event_with_related_target_and_modifiers(
+                    scope,
+                    "pointerenter",
+                    coordinates,
+                    button,
+                    buttons,
+                    &pointer,
+                    related_target,
+                    modifiers,
+                ) {
+                    let _ = dispatch_public_event(scope, runtime_ptr, handle, event);
                 }
-                if let Some((previous_handle, _)) = hover_transition {
-                    let related_target = related_target_value(scope, previous_handle);
-                    if let Some(event) = construct_mouse_event_with_related_target_and_modifiers(
-                        scope,
-                        "mouseover",
-                        coordinates,
-                        button,
-                        buttons,
-                        related_target,
-                        modifiers,
-                    ) {
-                        let _ = dispatch_public_event(scope, runtime_ptr, handle, event);
-                    }
-                    let related_target = related_target_value(scope, previous_handle);
-                    if let Some(event) = construct_mouse_event_with_related_target_and_modifiers(
-                        scope,
-                        "mouseenter",
-                        coordinates,
-                        button,
-                        buttons,
-                        related_target,
-                        modifiers,
-                    ) {
-                        let _ = dispatch_public_event(scope, runtime_ptr, handle, event);
-                    }
-                }
-                if let Some(pointer_event_name) = pointer_event_name_for_mouse_event(event_name)
-                    && let Some(event) = construct_pointer_event_with_modifiers(
-                        scope,
-                        pointer_event_name,
-                        coordinates,
-                        button,
-                        buttons,
-                        &pointer,
-                        modifiers,
-                    )
-                {
-                    let dispatched =
-                        dispatch_public_event(scope, runtime_ptr, pointer_dispatch_handle, event);
-                    if event_name == "mousedown" && !dispatched.allows_default() {
-                        suppress_compat_mouse_events = true;
-                    }
-                }
-                let mouse_dispatch_handle = if pointer_event_name.is_some() {
-                    unsafe { &*runtime_ptr }.mouse_event_target()
-                } else {
-                    Some(pointer_dispatch_handle)
+            }
+            if pointer_event_name == Some("pointermove")
+                && let Some(event) = construct_pointer_event_with_modifiers(
+                    scope,
+                    "pointerrawupdate",
+                    coordinates,
+                    button,
+                    buttons,
+                    &pointer,
+                    modifiers,
+                )
+            {
+                let _ = dispatch_public_event(scope, runtime_ptr, pointer_dispatch_handle, event);
+                let post_raw_update_capture_events = {
+                    let runtime = unsafe { &mut *runtime_ptr };
+                    runtime.process_pending_pointer_capture(MOUSE_POINTER_ID)
                 };
-                let suppress_current_mouse_event =
-                    suppress_compat_mouse_events && can_suppress_compat_mouse_event(event_name);
-                if !suppress_current_mouse_event
-                    && let Some(mouse_dispatch_handle) = mouse_dispatch_handle
-                {
-                    let event = if event_name == "wheel" {
-                        construct_wheel_event(
+                dispatch_pointer_capture_events(
+                    scope,
+                    runtime_ptr,
+                    MOUSE_POINTER_ID,
+                    &post_raw_update_capture_events,
+                    coordinates,
+                    button,
+                    buttons,
+                    &pointer,
+                    modifiers,
+                );
+                if !post_raw_update_capture_events.is_empty() {
+                    pointer_dispatch_handle = unsafe { &*runtime_ptr }
+                        .active_pointer_capture_target(MOUSE_POINTER_ID)
+                        .or(hit_handle)
+                        .unwrap_or(pointer_dispatch_handle);
+                    unsafe { &mut *runtime_ptr }.set_mouse_event_target(pointer_dispatch_handle);
+                }
+            }
+            if let Some((Some(previous_handle), previous_root_to_frame)) = hover_transition {
+                let previous_client_point = previous_root_to_frame.map_point(root_point);
+                let previous_coordinates = InputEventCoordinates::from_root(x, y).with_client(
+                    f64::from(previous_client_point.x),
+                    f64::from(previous_client_point.y),
+                );
+                let related_target = related_target_value(scope, Some(handle));
+                if let Some(event) = construct_mouse_event_with_related_target_and_modifiers(
+                    scope,
+                    "mouseout",
+                    previous_coordinates,
+                    button,
+                    buttons,
+                    related_target,
+                    modifiers,
+                ) {
+                    let _ = dispatch_public_event(scope, runtime_ptr, previous_handle, event);
+                }
+                let related_target = related_target_value(scope, Some(handle));
+                if let Some(event) = construct_mouse_event_with_related_target_and_modifiers(
+                    scope,
+                    "mouseleave",
+                    previous_coordinates,
+                    button,
+                    buttons,
+                    related_target,
+                    modifiers,
+                ) {
+                    let _ = dispatch_public_event(scope, runtime_ptr, previous_handle, event);
+                }
+            }
+            if let Some((previous_handle, _)) = hover_transition {
+                let related_target = related_target_value(scope, previous_handle);
+                if let Some(event) = construct_mouse_event_with_related_target_and_modifiers(
+                    scope,
+                    "mouseover",
+                    coordinates,
+                    button,
+                    buttons,
+                    related_target,
+                    modifiers,
+                ) {
+                    let _ = dispatch_public_event(scope, runtime_ptr, handle, event);
+                }
+                let related_target = related_target_value(scope, previous_handle);
+                if let Some(event) = construct_mouse_event_with_related_target_and_modifiers(
+                    scope,
+                    "mouseenter",
+                    coordinates,
+                    button,
+                    buttons,
+                    related_target,
+                    modifiers,
+                ) {
+                    let _ = dispatch_public_event(scope, runtime_ptr, handle, event);
+                }
+            }
+            if let Some(pointer_event_name) = pointer_event_name_for_mouse_event(event_name)
+                && let Some(event) = construct_pointer_event_with_modifiers(
+                    scope,
+                    pointer_event_name,
+                    coordinates,
+                    button,
+                    buttons,
+                    &pointer,
+                    modifiers,
+                )
+            {
+                let dispatched =
+                    dispatch_public_event(scope, runtime_ptr, pointer_dispatch_handle, event);
+                if event_name == "mousedown" && !dispatched.allows_default() {
+                    suppress_compat_mouse_events = true;
+                    mouse_down_allows_drag.set(false);
+                }
+            }
+            let mouse_dispatch_handle = if pointer_event_name.is_some() {
+                unsafe { &*runtime_ptr }.mouse_event_target()
+            } else {
+                Some(pointer_dispatch_handle)
+            };
+            let suppress_current_mouse_event =
+                suppress_compat_mouse_events && can_suppress_compat_mouse_event(event_name);
+            if !suppress_current_mouse_event
+                && let Some(mouse_dispatch_handle) = mouse_dispatch_handle
+            {
+                let event = if event_name == "wheel" {
+                    construct_wheel_event(
+                        scope,
+                        event_name,
+                        coordinates,
+                        delta_x,
+                        delta_y,
+                        button,
+                        buttons,
+                        modifiers,
+                    )
+                } else {
+                    construct_mouse_event_with_modifiers(
+                        scope,
+                        event_name,
+                        coordinates,
+                        button,
+                        buttons,
+                        modifiers,
+                    )
+                };
+                if let Some(event) = event {
+                    let dispatched =
+                        dispatch_public_event(scope, runtime_ptr, mouse_dispatch_handle, event);
+                    if event_name == "wheel" && dispatched.allows_default() {
+                        let _ = perform_wheel_scroll_default_action(
                             scope,
-                            event_name,
-                            coordinates,
+                            runtime_ptr,
+                            pointer_dispatch_handle,
                             delta_x,
                             delta_y,
-                            button,
-                            buttons,
-                            modifiers,
-                        )
-                    } else {
-                        construct_mouse_event_with_modifiers(
+                        )?;
+                    }
+                    if event_name == "mousedown" && !dispatched.allows_default() {
+                        mouse_down_allows_drag.set(false);
+                    }
+                    if event_name == "mousedown" && dispatched.allows_default() {
+                        // Chromium transfers mouse focus only after the
+                        // pointer/mouse down events have run and only when
+                        // their default action was not canceled. Focus the
+                        // actual hit target rather than a pointer-capture
+                        // target retained from an earlier event.
+                        perform_mouse_focus_default_action(
                             scope,
-                            event_name,
-                            coordinates,
-                            button,
-                            buttons,
-                            modifiers,
-                        )
-                    };
-                    if let Some(event) = event {
-                        let dispatched =
-                            dispatch_public_event(scope, runtime_ptr, mouse_dispatch_handle, event);
-                        if event_name == "wheel" && dispatched.allows_default() {
-                            let _ = perform_wheel_scroll_default_action(
-                                scope,
-                                runtime_ptr,
-                                pointer_dispatch_handle,
-                                delta_x,
-                                delta_y,
-                            )?;
-                        }
-                        if event_name == "mousedown" && dispatched.allows_default() {
-                            // Chromium transfers mouse focus only after the
-                            // pointer/mouse down events have run and only when
-                            // their default action was not canceled. Focus the
-                            // actual hit target rather than a pointer-capture
-                            // target retained from an earlier event.
-                            perform_mouse_focus_default_action(
-                                scope,
-                                runtime_ptr,
-                                hit_handle.unwrap_or(handle),
-                            );
-                        }
+                            runtime_ptr,
+                            hit_handle.unwrap_or(handle),
+                        );
                     }
                 }
-                let captured_click_target = if event_name == "mouseup" {
-                    let captured =
-                        unsafe { &*runtime_ptr }.pointer_capture_target_for_click(MOUSE_POINTER_ID);
+            }
+            let captured_click_target = if event_name == "mouseup" {
+                let captured =
+                    unsafe { &*runtime_ptr }.pointer_capture_target_for_click(MOUSE_POINTER_ID);
+                release_pointer_capture_after_pointer_end(
+                    scope,
+                    runtime_ptr,
+                    MOUSE_POINTER_ID,
+                    coordinates,
+                    button,
+                    buttons,
+                    &pointer,
+                    modifiers,
+                );
+                captured
+            } else {
+                None
+            };
+            if let Some((drag_start_handle, initial_data, start_coordinates)) = drag_start
+                && !suppress_current_mouse_event
+                && let Some(data_store) =
+                    crate::context_bootstrap::create_native_drag_data_store(scope)
+                && crate::context_bootstrap::populate_native_drag_data_store(
+                    scope,
+                    &data_store,
+                    &initial_data,
+                )
+                .is_some()
+                && let Some(data_transfer) =
+                    crate::context_bootstrap::create_drag_data_transfer_view(
+                        scope,
+                        &data_store,
+                        DragDataStoreMode::ReadWrite,
+                        "none",
+                    )
+            {
+                let allowed = construct_drag_event(
+                    scope,
+                    "dragstart",
+                    start_coordinates,
+                    data_transfer.into(),
+                    modifiers,
+                )
+                .is_some_and(|event| {
+                    dispatch_public_event(scope, runtime_ptr, drag_start_handle, event)
+                        .allows_default()
+                });
+                let (items, drag_operations_mask) =
+                    crate::context_bootstrap::read_string_drag_data(scope, &data_store);
+                let source_transfer = v8::Global::new(scope, data_transfer);
+                if allowed
+                    && unsafe { &*runtime_ptr }
+                        .dom_host()
+                        .is_connected(drag_start_handle)
+                {
+                    // Chromium keeps the source's original metadata readable
+                    // until dragend, while denying its data during target drop.
+                    crate::context_bootstrap::protect_native_drag_source_view(scope, data_transfer);
+                    *unsafe { &mut *active_drag_session } = Some(ActiveDragSession {
+                        data_store,
+                        source_transfer: Some(source_transfer),
+                        drop_effect: "none".to_owned(),
+                        drop_allowed: false,
+                        source: Some(drag_start_handle),
+                        intercepted: intercept_drags,
+                        target: None,
+                        x: client_x,
+                        y: client_y,
+                        modifiers,
+                    });
+                    unsafe { &mut *runtime_ptr }.clear_mouse_press();
+                    let cancel_target = unsafe { &*runtime_ptr }
+                        .active_pointer_capture_target(MOUSE_POINTER_ID)
+                        .unwrap_or(pointer_dispatch_handle);
+                    let cancel_pointer = RendererPointerEventProperties {
+                        pressure: 0.0,
+                        ..pointer.clone()
+                    };
+                    if let Some(event) = construct_pointer_event_with_modifiers(
+                        scope,
+                        "pointercancel",
+                        coordinates,
+                        -1,
+                        0,
+                        &cancel_pointer,
+                        modifiers,
+                    ) {
+                        let _ = dispatch_public_event(scope, runtime_ptr, cancel_target, event);
+                    }
                     release_pointer_capture_after_pointer_end(
                         scope,
                         runtime_ptr,
                         MOUSE_POINTER_ID,
                         coordinates,
-                        button,
-                        buttons,
-                        &pointer,
+                        -1,
+                        0,
+                        &cancel_pointer,
                         modifiers,
                     );
-                    captured
+                    if intercept_drags {
+                        intercepted_drag.set(Some(RendererInterceptedDrag {
+                            items,
+                            drag_operations_mask,
+                        }));
+                    }
                 } else {
-                    None
-                };
-                if let Some(drag_start_handle) = drag_start_handle
-                    && !suppress_current_mouse_event
+                    crate::context_bootstrap::finish_drag_data_transfer_view(scope, data_transfer);
+                }
+            }
+            if event_name == "mousemove"
+                && buttons & 1 != 0
+                && let Some(session) = unsafe { &mut *active_drag_session }.as_mut()
+                && !session.intercepted
+            {
+                update_drag_target(
+                    scope,
+                    runtime_ptr,
+                    session,
+                    hit_handle,
+                    client_x,
+                    client_y,
+                    modifiers,
+                );
+            }
+            if event_name == "mouseup" && button == 0 {
+                let active = unsafe { &mut *active_drag_session };
+                let mut reason = DragFinishReason::Rejected;
+                if let Some(session) = active.as_mut()
+                    && !session.intercepted
                 {
-                    // SAFETY: `with_default_context_scope` runs synchronously while `ScriptVm`
-                    // remains exclusively borrowed, so this field pointer is valid for the
-                    // duration of the callback.
-                    let active_drag_session = unsafe { &mut *active_drag_session };
-                    let empty_drag_data = RendererDragData {
-                        items: Vec::new(),
-                        files: Vec::new(),
-                        directories: Vec::new(),
-                        drag_operations_mask: 1,
-                    };
-                    if let Some(data_store) =
-                        crate::context_bootstrap::create_native_drag_data_store(scope)
-                        && crate::context_bootstrap::populate_native_drag_data_store(
+                    // Revalidate against the release target. Acceptance from
+                    // a previously hovered element must never authorize it.
+                    update_drag_target(
+                        scope,
+                        runtime_ptr,
+                        session,
+                        hit_handle,
+                        client_x,
+                        client_y,
+                        modifiers,
+                    );
+                    reason = drop_drag_target(
+                        scope,
+                        runtime_ptr,
+                        session,
+                        client_x,
+                        client_y,
+                        modifiers,
+                    );
+                }
+                finish_drag_session(
+                    scope,
+                    runtime_ptr,
+                    active,
+                    reason,
+                    client_x,
+                    client_y,
+                    modifiers,
+                );
+            }
+            // Keep the host-owned press alive through the release listeners;
+            // synchronous DOM removals can invalidate it before click targeting.
+            let follow_up = if event_name == "mouseup" {
+                mouse_dispatch_handle.and_then(|target| {
+                    unsafe { &mut *runtime_ptr }.mouse_release_follow_up(
+                        target,
+                        button,
+                        captured_click_target,
+                    )
+                })
+            } else {
+                None
+            };
+            match follow_up {
+                Some(MouseReleaseFollowUp::ActivateViaClick(click_target)) => {
+                    if event_name == "mouseup" {
+                        suppress_compat_mouse_events = false;
+                    }
+                    let outcome = activate_handle_after_pointer_release(
+                        scope,
+                        runtime_ptr,
+                        click_target,
+                        coordinates,
+                        button,
+                        buttons,
+                        click_count.max(1),
+                        modifiers,
+                    );
+                    if click_count >= 2
+                        && let Some(event) = construct_mouse_event_with_detail_and_modifiers(
                             scope,
-                            &data_store,
-                            &empty_drag_data,
-                        )
-                        .is_some()
-                        && let Some(data_transfer) =
-                            crate::context_bootstrap::create_drag_data_transfer_view(
-                                scope,
-                                &data_store,
-                                DragDataStoreMode::ReadWrite,
-                                "none",
-                            )
-                    {
-                        let allowed = construct_drag_event(
-                            scope,
-                            "dragstart",
+                            "dblclick",
                             coordinates,
-                            data_transfer.into(),
+                            click_count,
+                            button,
+                            buttons,
                             modifiers,
                         )
-                        .is_some_and(|event| {
-                            dispatch_public_event(scope, runtime_ptr, drag_start_handle, event)
-                                .allows_default()
-                        });
-                        if allowed {
-                            crate::context_bootstrap::protect_native_drag_source_view(
-                                scope,
-                                data_transfer,
-                            );
-                            *active_drag_session = Some(ActiveDragSession {
-                                data_store,
-                                source_transfer: Some(v8::Global::new(scope, data_transfer)),
-                                drop_effect: "none".to_owned(),
-                                drop_allowed: false,
-                            });
-                        } else {
-                            crate::context_bootstrap::finish_drag_data_transfer_view(
-                                scope,
-                                data_transfer,
-                            );
-                            close_drag_data_transfer_source(scope, active_drag_session);
-                        }
-                    }
-                }
-                if event_name == "mousemove" && buttons & 1 != 0 {
-                    let active_drag_session = unsafe { &mut *active_drag_session };
-                    if let Some(session) = active_drag_session.as_mut() {
-                        session.drop_allowed = false;
-                        session.drop_effect = "none".to_owned();
-                        if let Some(transfer) =
-                            crate::context_bootstrap::create_drag_data_transfer_view(
-                                scope,
-                                &session.data_store,
-                                DragDataStoreMode::Protected,
-                                "none",
-                            )
-                        {
-                            let operation = construct_drag_event(
-                                scope,
-                                "dragover",
-                                coordinates,
-                                transfer.into(),
-                                modifiers,
-                            )
-                            .and_then(|event| {
-                                let allows_default =
-                                    dispatch_public_event(scope, runtime_ptr, handle, event)
-                                        .allows_default();
-                                accepted_drag_view_operation(
-                                    scope,
-                                    runtime_ptr,
-                                    handle,
-                                    transfer,
-                                    allows_default,
-                                    modifiers,
-                                )
-                            });
-                            crate::context_bootstrap::finish_drag_data_transfer_view(
-                                scope, transfer,
-                            );
-                            if let Some(operation) = operation {
-                                session.drop_allowed = true;
-                                session.drop_effect = operation;
-                            }
-                        }
-                    }
-                }
-                if event_name == "mouseup" && button == 0 {
-                    let active_drag_session = unsafe { &mut *active_drag_session };
-                    if let Some(session) = active_drag_session.as_mut()
-                        && session.drop_allowed
-                        && let Some(transfer) =
-                            crate::context_bootstrap::create_drag_data_transfer_view(
-                                scope,
-                                &session.data_store,
-                                DragDataStoreMode::ReadOnly,
-                                "none",
-                            )
                     {
-                        let allows_default = if let Some(event) = construct_drag_event(
-                            scope,
-                            "drop",
-                            coordinates,
-                            transfer.into(),
-                            modifiers,
-                        ) {
-                            dispatch_public_event(scope, runtime_ptr, handle, event)
-                                .allows_default()
-                        } else {
-                            false
-                        };
-                        crate::context_bootstrap::finish_drag_data_transfer_view(scope, transfer);
-                        if allows_default {
-                            perform_drag_default_action_with_private_view(
+                        let _ = dispatch_public_event(scope, runtime_ptr, click_target, event);
+                    }
+                    return Ok(outcome);
+                }
+                Some(MouseReleaseFollowUp::DispatchEvent {
+                    name: follow_up_event_name,
+                    target,
+                }) => {
+                    if event_name == "mouseup" {
+                        suppress_compat_mouse_events = false;
+                    }
+                    let had_pending_top_level_navigation_before_event =
+                        unsafe { &*runtime_ptr }.has_pending_location_navigation();
+                    let pending_child_navigations_before_event = unsafe { &*runtime_ptr }
+                        .pending_live_child_browsing_context_navigation_snapshot();
+                    let mut pending_download = None;
+                    if let Some(event) = construct_mouse_event_with_modifiers(
+                        scope,
+                        follow_up_event_name,
+                        coordinates,
+                        button,
+                        buttons,
+                        modifiers,
+                    ) {
+                        let dispatched = dispatch_public_event(scope, runtime_ptr, target, event);
+                        if follow_up_event_name == "auxclick" && dispatched.allows_default() {
+                            pending_download = perform_auxiliary_link_default_action(
                                 scope,
                                 runtime_ptr,
-                                handle,
-                                session,
+                                target,
+                                button,
+                                modifiers,
+                                &pending_child_navigations_before_event,
                             );
                         }
                     }
-                    close_drag_data_transfer_source(scope, active_drag_session);
-                }
-                // Keep the host-owned press alive through the release listeners;
-                // synchronous DOM removals can invalidate it before click targeting.
-                let follow_up = if event_name == "mouseup" {
-                    mouse_dispatch_handle.and_then(|target| {
-                        unsafe { &mut *runtime_ptr }.mouse_release_follow_up(
-                            target,
-                            button,
-                            captured_click_target,
-                        )
-                    })
-                } else {
-                    None
-                };
-                match follow_up {
-                    Some(MouseReleaseFollowUp::ActivateViaClick(click_target)) => {
-                        if event_name == "mouseup" {
-                            suppress_compat_mouse_events = false;
-                        }
-                        let outcome = activate_handle_after_pointer_release(
-                            scope,
-                            runtime_ptr,
-                            click_target,
-                            coordinates,
-                            button,
-                            buttons,
-                            click_count.max(1),
-                            modifiers,
-                        );
-                        if click_count >= 2
-                            && let Some(event) = construct_mouse_event_with_detail_and_modifiers(
-                                scope,
-                                "dblclick",
-                                coordinates,
-                                click_count,
-                                button,
-                                buttons,
-                                modifiers,
-                            )
-                        {
-                            let _ = dispatch_public_event(scope, runtime_ptr, click_target, event);
-                        }
-                        return Ok(outcome);
+                    if follow_up_event_name == "auxclick" {
+                        return Ok(RendererInputDispatchOutcome {
+                            handled: true,
+                            triggered_top_level_navigation:
+                                !had_pending_top_level_navigation_before_event
+                                    && unsafe { &*runtime_ptr }.has_pending_location_navigation(),
+                            pending_download,
+                            pending_file_chooser: None,
+                            intercepted_drag: None,
+                        });
                     }
-                    Some(MouseReleaseFollowUp::DispatchEvent {
-                        name: follow_up_event_name,
-                        target,
-                    }) => {
-                        if event_name == "mouseup" {
-                            suppress_compat_mouse_events = false;
-                        }
-                        let had_pending_top_level_navigation_before_event =
-                            unsafe { &*runtime_ptr }.has_pending_location_navigation();
-                        let pending_child_navigations_before_event = unsafe { &*runtime_ptr }
-                            .pending_live_child_browsing_context_navigation_snapshot();
-                        let mut pending_download = None;
-                        if let Some(event) = construct_mouse_event_with_modifiers(
-                            scope,
-                            follow_up_event_name,
-                            coordinates,
-                            button,
-                            buttons,
-                            modifiers,
-                        ) {
-                            let dispatched =
-                                dispatch_public_event(scope, runtime_ptr, target, event);
-                            if follow_up_event_name == "auxclick" && dispatched.allows_default() {
-                                pending_download = perform_auxiliary_link_default_action(
-                                    scope,
-                                    runtime_ptr,
-                                    target,
-                                    button,
-                                    modifiers,
-                                    &pending_child_navigations_before_event,
-                                );
-                            }
-                        }
-                        if follow_up_event_name == "auxclick" {
-                            return Ok(RendererInputDispatchOutcome {
-                                handled: true,
-                                triggered_top_level_navigation:
-                                    !had_pending_top_level_navigation_before_event
-                                        && unsafe { &*runtime_ptr }
-                                            .has_pending_location_navigation(),
-                                pending_download,
-                                pending_file_chooser: None,
-                            });
-                        }
-                    }
-                    None => {}
                 }
-                if event_name == "mouseup" {
-                    suppress_compat_mouse_events = false;
-                }
-                Ok(input_dispatch_outcome(true))
-            });
+                None => {}
+            }
+            if event_name == "mouseup" {
+                suppress_compat_mouse_events = false;
+            }
+            Ok(input_dispatch_outcome(true))
+        });
         self.suppress_compat_mouse_events = suppress_compat_mouse_events;
-        result
+        if !mouse_down_allows_drag.get() {
+            self.pending_drag_gesture = None;
+        }
+        result.map(|mut outcome| {
+            outcome.intercepted_drag = intercepted_drag.take();
+            outcome
+        })
+    }
+
+    fn finish_active_drag(
+        &mut self,
+        reason: DragFinishReason,
+        x: f64,
+        y: f64,
+        modifiers: u8,
+    ) -> Result<()> {
+        self.pending_drag_gesture = None;
+        self._context_host.borrow_mut().clear_mouse_press();
+        let active = &mut self.active_drag_session as *mut Option<ActiveDragSession>;
+        self.with_default_context_scope(|scope, runtime_ptr| {
+            // SAFETY: with_default_context_scope runs synchronously under
+            // the exclusive ScriptVm borrow, without aliasing this field.
+            finish_drag_session(
+                scope,
+                runtime_ptr,
+                unsafe { &mut *active },
+                reason,
+                x,
+                y,
+                modifiers,
+            );
+            Ok(())
+        })
+    }
+
+    pub(crate) fn cancel_dragging(&mut self) -> Result<RendererInputDispatchOutcome> {
+        let (x, y, modifiers) = self
+            .active_drag_session
+            .as_ref()
+            .map(|session| (session.x, session.y, session.modifiers))
+            .unwrap_or((0.0, 0.0, 0));
+        let result = self
+            .finish_active_drag(DragFinishReason::Canceled, x, y, modifiers)
+            .map(|()| input_dispatch_outcome(true));
+        self.finish_input_event_dispatch_turn(result)
     }
 
     fn dispatch_active_scrollbar_mouse_event(
@@ -1809,122 +2261,104 @@ impl ScriptVm {
         data: RendererDragData,
         modifiers: u8,
     ) -> Result<RendererInputDispatchOutcome> {
-        let Some(handle) = observable_input_hit_test(
+        if matches!(event_name, "dragleave" | "dragcancel") {
+            let result = self
+                .finish_active_drag(DragFinishReason::Canceled, x, y, modifiers)
+                .map(|()| input_dispatch_outcome(true));
+            return self.finish_input_event_dispatch_turn(result);
+        }
+        let hit = observable_input_hit_test(
             &self._context_host.borrow(),
             self.document_runtime.document_handle(),
             moli_layout::LayoutPoint::new(x as f32, y as f32),
-        )?
-        .map(|hit| hit.handle) else {
-            if matches!(event_name, "drop" | "dragleave" | "dragcancel") {
-                self.clear_active_drag_data_transfer()?;
-            }
-            return Ok(input_dispatch_outcome(false));
-        };
-
-        let clear_active_drag_data_transfer =
-            matches!(event_name, "drop" | "dragleave" | "dragcancel");
-        let active_drag_session: *mut Option<ActiveDragSession> = &mut self.active_drag_session;
-
-        let result = self.with_default_context_scope(move |scope, runtime_ptr| {
-            // SAFETY: `with_default_context_scope` runs synchronously while `ScriptVm`
-            // remains exclusively borrowed, so the field pointer stays valid for the
-            // duration of this callback and is not aliased elsewhere.
-            let active_drag_session = unsafe { &mut *active_drag_session };
-            let created_session = active_drag_session.is_none();
-            if created_session {
+        )?;
+        let target = hit.map(|hit| hit.handle);
+        let local = hit.map(|hit| {
+            hit.root_to_frame
+                .map_point(moli_layout::LayoutPoint::new(x as f32, y as f32))
+        });
+        let (x, y) = local
+            .map(|point| (f64::from(point.x), f64::from(point.y)))
+            .unwrap_or((x, y));
+        let active = &mut self.active_drag_session as *mut Option<ActiveDragSession>;
+        // A finished/canceled session cannot be recreated by a late drop.
+        let result = self.with_default_context_scope(|scope, runtime_ptr| {
+            // SAFETY: the callback runs synchronously while ScriptVm is
+            // exclusively borrowed, without any other access to this field.
+            let active = unsafe { &mut *active };
+            if active.is_none() {
+                if event_name != "dragenter" || target.is_none() {
+                    return Ok(input_dispatch_outcome(false));
+                }
                 let Some(data_store) =
                     crate::context_bootstrap::create_external_drag_data_store(scope, &data)
                 else {
                     return Ok(input_dispatch_outcome(false));
                 };
-                *active_drag_session = Some(ActiveDragSession {
+                *active = Some(ActiveDragSession {
                     data_store,
                     source_transfer: None,
                     drop_effect: "none".to_owned(),
                     drop_allowed: false,
+                    source: None,
+                    intercepted: false,
+                    target: None,
+                    x,
+                    y,
+                    modifiers,
                 });
-            }
-            let session = active_drag_session
-                .as_mut()
-                .expect("drag store created above");
-            if !created_session && matches!(event_name, "dragenter" | "drop") {
-                if crate::context_bootstrap::replace_drag_data_store_contents(
+            } else if event_name == "dragenter"
+                && crate::context_bootstrap::replace_drag_data_store_contents(
                     scope,
-                    &session.data_store,
+                    &active.as_ref().expect("active drag").data_store,
                     &data,
                 )
                 .is_none()
-                {
-                    close_drag_data_transfer_source(scope, active_drag_session);
-                    return Ok(input_dispatch_outcome(false));
-                }
-            } else {
+            {
+                return Ok(input_dispatch_outcome(false));
+            }
+            let session = active.as_mut().expect("drag session initialized");
+            if matches!(event_name, "dragover" | "drop") {
+                // Chromium's over command replaces only the operation mask;
+                // its items are ignored. Drop's pre-over also uses the cached
+                // enter payload, with the new command's source operation mask.
                 crate::context_bootstrap::update_drag_data_store_operations_mask(
                     scope,
                     &session.data_store,
                     data.drag_operations_mask,
                 );
             }
-            let mode = match event_name {
-                "dragstart" => DragDataStoreMode::ReadWrite,
-                "drop" => DragDataStoreMode::ReadOnly,
-                _ => DragDataStoreMode::Protected,
-            };
-            let Some(transfer) = crate::context_bootstrap::create_drag_data_transfer_view(
-                scope,
-                &session.data_store,
-                mode,
-                "none",
-            ) else {
-                if clear_active_drag_data_transfer {
-                    close_drag_data_transfer_source(scope, active_drag_session);
-                }
-                return Ok(input_dispatch_outcome(false));
-            };
-            let allows_default = if let Some(event) = construct_drag_event(
-                scope,
-                event_name,
-                InputEventCoordinates::from_root(x, y),
-                transfer.into(),
-                modifiers,
-            ) {
-                dispatch_public_event(scope, runtime_ptr, handle, event).allows_default()
-            } else {
-                false
-            };
-            if event_name != "drop" || created_session {
-                let operation = accepted_drag_view_operation(
+            if matches!(event_name, "dragenter" | "dragover" | "drop") {
+                update_drag_target(scope, runtime_ptr, session, target, x, y, modifiers);
+            }
+            if event_name == "drop" {
+                // Empty data is an explicit replacement too. Import it only
+                // after the pre-over, before exposing the new drop view.
+                let reason = if crate::context_bootstrap::replace_drag_data_store_contents(
                     scope,
-                    runtime_ptr,
-                    handle,
-                    transfer,
-                    allows_default,
-                    modifiers,
-                );
-                session.drop_allowed = operation.is_some();
-                session.drop_effect = operation.unwrap_or_else(|| "none".to_owned());
+                    &session.data_store,
+                    &data,
+                )
+                .is_some()
+                {
+                    drop_drag_target(scope, runtime_ptr, session, x, y, modifiers)
+                } else {
+                    DragFinishReason::Rejected
+                };
+                finish_drag_session(scope, runtime_ptr, active, reason, x, y, modifiers);
             }
-            crate::context_bootstrap::finish_drag_data_transfer_view(scope, transfer);
-            if event_name == "drop" && allows_default {
-                perform_drag_default_action_with_private_view(scope, runtime_ptr, handle, session);
-            }
-            if clear_active_drag_data_transfer {
-                close_drag_data_transfer_source(scope, active_drag_session);
-            }
-            Ok(input_dispatch_outcome(true))
+            Ok(input_dispatch_outcome(target.is_some()))
         });
         self.finish_input_event_dispatch_turn(result)
     }
 
     pub(crate) fn clear_active_drag_data_transfer(&mut self) -> Result<()> {
-        let mut session = self.active_drag_session.take();
-        if session.is_none() {
-            return Ok(());
-        }
-        self.with_default_context_scope(|scope, _| {
-            close_drag_data_transfer_source(scope, &mut session);
-            Ok(())
-        })
+        let (x, y, modifiers) = self
+            .active_drag_session
+            .as_ref()
+            .map(|session| (session.x, session.y, session.modifiers))
+            .unwrap_or((0.0, 0.0, 0));
+        self.finish_active_drag(DragFinishReason::Canceled, x, y, modifiers)
     }
 
     pub(crate) fn set_file_input_files(
diff --git a/moli-renderer-v8/src/script_vm/input_helpers.rs b/moli-renderer-v8/src/script_vm/input_helpers.rs
index 6c74d03abd..39b9aca328 100644
--- a/moli-renderer-v8/src/script_vm/input_helpers.rs
+++ b/moli-renderer-v8/src/script_vm/input_helpers.rs
@@ -48,7 +48,18 @@ pub(super) fn clear_input_dispatch_state(vm: &mut ScriptVm) {
     vm.active_touch_event_handle = None;
     vm.active_touch_point = None;
     vm.active_touch_points.clear();
-    let _ = vm.clear_active_drag_data_transfer();
+    // Target views were disabled when their dispatch ended. Retiring the
+    // Document must also disable its protected source view without dragend.
+    if let Some(session) = vm.active_drag_session.take()
+        && let Some(source) = session.source_transfer
+    {
+        let _ = vm.with_default_context_scope(|scope, _| {
+            let transfer = v8::Local::new(scope, &source);
+            crate::context_bootstrap::finish_drag_data_transfer_view(scope, transfer);
+            Ok(())
+        });
+    }
+    vm.pending_drag_gesture = None;
     vm.active_scrollbar_drag = None;
     vm.suppress_compat_mouse_events = false;
     vm._context_host.borrow_mut().clear_pointer_capture_state();
diff --git a/moli-renderer-v8/src/script_vm/tests/baseline_drag_views.rs b/moli-renderer-v8/src/script_vm/tests/baseline_drag_views.rs
index 88235cc514..43c8499f2a 100644
--- a/moli-renderer-v8/src/script_vm/tests/baseline_drag_views.rs
+++ b/moli-renderer-v8/src/script_vm/tests/baseline_drag_views.rs
@@ -223,12 +223,13 @@ for(const type of ['dragenter','dragover','drop'])document.getElementById('targe
             serde_json::json!({
                 "records":[
                     ["dragenter","copy","none","","",["text/plain","application/x-seed","Files"],[["string","text/plain"],["string","application/x-seed"],["file","application/octet-stream"]],[]],
-                    ["dragenter","copy","none","","",entered_types,entered_items,[]],
+                    ["dragover","copy","none","","",entered_types,entered_items,[]],
+                    ["dragover","move","none","","",entered_types,entered_items,[]],
                     ["dragover","move","none","","",entered_types,entered_items,[]],
                     ["drop","move","none","drop-text","drop-metadata",["text/plain","application/x-drop","Files"],[["string","text/plain"],["string","application/x-drop"],["file","application/octet-stream"]],[["drop.bin","application/octet-stream",4,123]]]
                 ],
-                "prior":[[],[["",0,0,0]],[["",0,0,0],["",0,0,0]],[["",0,0,0],["",0,0,0],["",0,0,0]]],
-                "fileText":"drop","closed":[["",0,0,0],["",0,0,0],["",0,0,0],["",0,0,0]]
+                "prior":[[],[["",0,0,0]],[["",0,0,0],["",0,0,0]],[["",0,0,0],["",0,0,0],["",0,0,0]],[["",0,0,0],["",0,0,0],["",0,0,0],["",0,0,0]]],
+                "fileText":"drop","closed":[["",0,0,0],["",0,0,0],["",0,0,0],["",0,0,0],["",0,0,0]]
             }),
             "empty_enter={empty_enter}"
         );
diff --git a/moli-renderer-v8/src/script_vm/tests/dom_elements/dom_surface/extracted/frame_geometry_and_input.rs b/moli-renderer-v8/src/script_vm/tests/dom_elements/dom_surface/extracted/frame_geometry_and_input.rs
index 554d401d81..b8b46adf18 100644
--- a/moli-renderer-v8/src/script_vm/tests/dom_elements/dom_surface/extracted/frame_geometry_and_input.rs
+++ b/moli-renderer-v8/src/script_vm/tests/dom_elements/dom_surface/extracted/frame_geometry_and_input.rs
@@ -761,6 +761,7 @@ fn iframe_wheel_batch_reuses_one_composite_snapshot_for_every_scroll_step() {
             delta_y,
             crate::runtime::RendererPointerEventProperties::default(),
             0,
+            false,
         )
         .expect("batched child wheel step should dispatch");
     }
diff --git a/moli-renderer-v8/src/script_vm/tests/dom_xhr/dom/files_and_transfer.rs b/moli-renderer-v8/src/script_vm/tests/dom_xhr/dom/files_and_transfer.rs
index fa45696523..2a34fa6c11 100644
--- a/moli-renderer-v8/src/script_vm/tests/dom_xhr/dom/files_and_transfer.rs
+++ b/moli-renderer-v8/src/script_vm/tests/dom_xhr/dom/files_and_transfer.rs
@@ -1010,6 +1010,7 @@ fn data_transfer_directory_entries_use_private_slots_for_reflection_and_spoofing
         r#"
 (() => {
   const target = document.getElementById('drop');
+  target.addEventListener('dragover', event => event.preventDefault());
   const internalNames = object => Object.getOwnPropertyNames(object)
     .filter(name => name.startsWith('__lmDataTransfer') || name.startsWith('__lmFileSystem'))
     .sort();
@@ -1084,6 +1085,10 @@ fn data_transfer_directory_entries_use_private_slots_for_reflection_and_spoofing
         }],
         drag_operations_mask: 1,
     };
+    for event_name in ["dragenter", "dragover"] {
+        vm.dispatch_drag_event_at_point(10.0, 10.0, event_name, drag_data.clone(), 0)
+            .expect("directory drag target should accept the drag");
+    }
     vm.dispatch_drag_event_at_point(10.0, 10.0, "drop", drag_data, 0)
         .expect("directory drop should dispatch");
 
@@ -1463,7 +1468,7 @@ fn mouse_dragstart_bubbles_to_window_once() {
 
     vm.dispatch_mouse_event_at_point(20.0, 20.0, "mousedown", 0, None, 0.0, 0.0)
         .expect("mousedown should dispatch");
-    vm.dispatch_mouse_event_at_point(20.0, 20.0, "mousemove", 0, Some(1), 0.0, 0.0)
+    vm.dispatch_mouse_event_at_point(30.0, 20.0, "mousemove", 0, Some(1), 0.0, 0.0)
         .expect("mousemove should start drag");
 
     let result = vm
diff --git a/moli-renderer-v8/src/script_vm/tests/dom_xhr/dom/pointer_and_mouse.rs b/moli-renderer-v8/src/script_vm/tests/dom_xhr/dom/pointer_and_mouse.rs
index bc1007321d..c83bb4004c 100644
--- a/moli-renderer-v8/src/script_vm/tests/dom_xhr/dom/pointer_and_mouse.rs
+++ b/moli-renderer-v8/src/script_vm/tests/dom_xhr/dom/pointer_and_mouse.rs
@@ -1,4 +1,7 @@
 use super::*;
+use crate::runtime::{
+    RendererDragData, RendererDragDataItem, RendererDraggedFile, RendererInterceptedDrag,
+};
 
 #[test]
 fn mouse_drop_requires_prevented_dragover() {
@@ -36,9 +39,9 @@ fn mouse_drop_requires_prevented_dragover() {
 
     vm.dispatch_mouse_event_at_point(20.0, 20.0, "mousedown", 0, None, 0.0, 0.0)
         .expect("first mousedown should dispatch");
-    vm.dispatch_mouse_event_at_point(20.0, 20.0, "mousemove", 0, Some(1), 0.0, 0.0)
+    vm.dispatch_mouse_event_at_point(25.0, 20.0, "mousemove", 0, Some(1), 0.0, 0.0)
         .expect("first mousemove should start drag");
-    vm.dispatch_mouse_event_at_point(20.0, 20.0, "mouseup", 0, Some(0), 0.0, 0.0)
+    vm.dispatch_mouse_event_at_point(25.0, 20.0, "mouseup", 0, Some(0), 0.0, 0.0)
         .expect("first mouseup should finish drag");
 
     let first_result = vm
@@ -54,9 +57,9 @@ fn mouse_drop_requires_prevented_dragover() {
         .expect("drop permission flag should update");
     vm.dispatch_mouse_event_at_point(20.0, 20.0, "mousedown", 0, None, 0.0, 0.0)
         .expect("second mousedown should dispatch");
-    vm.dispatch_mouse_event_at_point(20.0, 20.0, "mousemove", 0, Some(1), 0.0, 0.0)
+    vm.dispatch_mouse_event_at_point(25.0, 20.0, "mousemove", 0, Some(1), 0.0, 0.0)
         .expect("second mousemove should start drag");
-    vm.dispatch_mouse_event_at_point(20.0, 20.0, "mouseup", 0, Some(0), 0.0, 0.0)
+    vm.dispatch_mouse_event_at_point(25.0, 20.0, "mouseup", 0, Some(0), 0.0, 0.0)
         .expect("second mouseup should finish drag");
 
     let second_result = vm
@@ -106,9 +109,9 @@ fn mouse_dragstart_prevent_default_cancels_drag_session() {
 
     vm.dispatch_mouse_event_at_point(20.0, 20.0, "mousedown", 0, None, 0.0, 0.0)
         .expect("mousedown should dispatch");
-    vm.dispatch_mouse_event_at_point(20.0, 20.0, "mousemove", 0, Some(1), 0.0, 0.0)
+    vm.dispatch_mouse_event_at_point(25.0, 20.0, "mousemove", 0, Some(1), 0.0, 0.0)
         .expect("mousemove should attempt drag");
-    vm.dispatch_mouse_event_at_point(20.0, 20.0, "mouseup", 0, Some(0), 0.0, 0.0)
+    vm.dispatch_mouse_event_at_point(25.0, 20.0, "mouseup", 0, Some(0), 0.0, 0.0)
         .expect("mouseup should dispatch");
 
     let result = vm
@@ -378,6 +381,7 @@ fn pointer_capture_mouse_events_preserve_modifiers() {
         0.0,
         crate::runtime::RendererPointerEventProperties::default(),
         10,
+        false,
     )
     .expect("mousedown should dispatch pointerdown with modifiers");
     vm.dispatch_mouse_event_at_point_with_pointer_and_modifiers(
@@ -391,6 +395,7 @@ fn pointer_capture_mouse_events_preserve_modifiers() {
         0.0,
         crate::runtime::RendererPointerEventProperties::default(),
         10,
+        false,
     )
     .expect("mouseup should dispatch pointerup and capture release with modifiers");
 
@@ -1084,3 +1089,1080 @@ fn mouse_hover_persists_stylo_state_and_reflows_dropdown_on_fresh_paint() {
         "false|false|false|true|none"
     );
 }
+
+const DRAG_INTERCEPT_PAGE: &str = r#"<html><body>
+<div id="source" draggable="true" style="position:absolute;left:0;top:0;width:100px;height:40px"></div>
+<div id="target" style="position:absolute;left:0;top:100px;width:200px;height:100px"></div>
+</body></html>"#;
+
+const DRAG_INTERCEPT_LISTENERS: &str = r#"
+(() => {
+  window.__dragLog = [];
+  const source = document.getElementById('source');
+  const target = document.getElementById('target');
+  source.addEventListener('dragstart', event => {
+    event.dataTransfer.setData('text/plain', 'payload');
+    event.dataTransfer.setData('application/x-moli', 'custom');
+    event.dataTransfer.effectAllowed = 'move';
+    window.__dragLog.push('dragstart');
+  });
+  source.addEventListener('dragend', () => window.__dragLog.push('dragend'));
+  target.addEventListener('dragenter', event => {
+    window.__dragLog.push('dragenter:' + event.dataTransfer.getData('text/plain'));
+  });
+  target.addEventListener('dragover', event => {
+    event.preventDefault();
+    window.__dragLog.push('dragover');
+  });
+  target.addEventListener('dragleave', () => window.__dragLog.push('dragleave'));
+  target.addEventListener('drop', event => {
+    event.preventDefault();
+    window.__dragLog.push([
+      'drop',
+      event.dataTransfer.getData('application/x-moli'),
+      event.dataTransfer.types.join(','),
+      event.dataTransfer.effectAllowed,
+    ].join(':'));
+  });
+})()
+"#;
+
+fn dispatch_drag_mouse(
+    vm: &mut ScriptVm,
+    x: f64,
+    y: f64,
+    event_name: &str,
+    intercept_drags: bool,
+) -> crate::runtime::RendererInputDispatchOutcome {
+    vm.dispatch_mouse_event_at_point_with_pointer_and_modifiers(
+        x,
+        y,
+        event_name,
+        0,
+        Some(if event_name == "mouseup" { 0 } else { 1 }),
+        0,
+        0.0,
+        0.0,
+        crate::runtime::RendererPointerEventProperties::default(),
+        0,
+        intercept_drags,
+    )
+    .expect("drag mouse event should dispatch")
+}
+
+fn start_intercepted_drag(vm: &mut ScriptVm) -> RendererInterceptedDrag {
+    vm.publish_layout_for_test()
+        .expect("publish geometry before coordinate input");
+    vm.dispatch_mouse_event_at_point(20.0, 20.0, "mousedown", 0, None, 0.0, 0.0)
+        .expect("mousedown should dispatch");
+    dispatch_drag_mouse(vm, 20.0, 120.0, "mousemove", true)
+        .intercepted_drag
+        .expect("an uncanceled dragstart should be reported while intercepting")
+}
+
+fn drag_data_from(drag: &RendererInterceptedDrag) -> RendererDragData {
+    RendererDragData {
+        items: drag.items.clone(),
+        files: Vec::new(),
+        directories: Vec::new(),
+        drag_operations_mask: drag.drag_operations_mask,
+    }
+}
+
+#[test]
+fn intercepted_drag_reports_string_data_and_waits_for_drag_events() {
+    let mut vm = new_rendered_test_vm("https://drag-intercept-report.test/", DRAG_INTERCEPT_PAGE);
+    vm.eval(DRAG_INTERCEPT_LISTENERS)
+        .expect("drag listener setup should evaluate");
+
+    let drag = start_intercepted_drag(&mut vm);
+
+    let items: Vec<(&str, &str)> = drag
+        .items
+        .iter()
+        .map(|item| (item.mime_type.as_str(), item.data.as_str()))
+        .collect();
+    assert_eq!(
+        items,
+        vec![("text/plain", "payload"), ("application/x-moli", "custom")]
+    );
+    assert_eq!(drag.drag_operations_mask, 16);
+    // The mouse move that started the drag must not also drive dragover.
+    assert_eq!(
+        vm.eval("window.__dragLog.join('|')").expect("log"),
+        "dragstart"
+    );
+
+    // Mouse events no longer drive the intercepted drag.
+    dispatch_drag_mouse(&mut vm, 20.0, 120.0, "mousemove", true);
+    assert_eq!(
+        vm.eval("window.__dragLog.join('|')").expect("log"),
+        "dragstart"
+    );
+}
+
+#[test]
+fn intercepted_drag_replays_enter_over_drop_and_ends_on_source() {
+    let mut vm = new_rendered_test_vm("https://drag-intercept-replay.test/", DRAG_INTERCEPT_PAGE);
+    vm.eval(DRAG_INTERCEPT_LISTENERS)
+        .expect("drag listener setup should evaluate");
+    let data = drag_data_from(&start_intercepted_drag(&mut vm));
+
+    for event in ["dragenter", "dragover", "drop"] {
+        let outcome = vm
+            .dispatch_drag_event_at_point(20.0, 120.0, event, data.clone(), 0)
+            .expect("drag event should dispatch");
+        assert!(outcome.handled, "{event} should hit the target");
+    }
+
+    assert_eq!(
+        vm.eval("window.__dragLog.join('|')").expect("log"),
+        "dragstart|dragenter:|dragover|dragover|drop:custom:text/plain,application/x-moli:move|dragend"
+    );
+}
+
+#[test]
+fn intercepted_drag_cancel_dispatches_dragleave_and_dragend() {
+    let mut vm = new_rendered_test_vm("https://drag-intercept-cancel.test/", DRAG_INTERCEPT_PAGE);
+    vm.eval(DRAG_INTERCEPT_LISTENERS)
+        .expect("drag listener setup should evaluate");
+    let data = drag_data_from(&start_intercepted_drag(&mut vm));
+
+    for event in ["dragenter", "dragleave"] {
+        vm.dispatch_drag_event_at_point(20.0, 120.0, event, data.clone(), 0)
+            .expect("drag event should dispatch");
+    }
+    // The session is over: a late drop must not reach the page as part of it.
+    vm.dispatch_mouse_event_at_point(20.0, 120.0, "mouseup", 0, Some(0), 0.0, 0.0)
+        .expect("mouseup after cancel");
+
+    assert_eq!(
+        vm.eval("window.__dragLog.join('|')").expect("log"),
+        "dragstart|dragenter:|dragleave|dragend"
+    );
+}
+
+#[test]
+fn canceled_dragstart_is_not_intercepted() {
+    let mut vm = new_rendered_test_vm("https://drag-intercept-canceled.test/", DRAG_INTERCEPT_PAGE);
+    vm.eval(
+        "document.getElementById('source').addEventListener('dragstart', e => e.preventDefault())",
+    )
+    .expect("listener setup should evaluate");
+    vm.publish_layout_for_test()
+        .expect("publish geometry before coordinate input");
+
+    vm.dispatch_mouse_event_at_point(20.0, 20.0, "mousedown", 0, None, 0.0, 0.0)
+        .expect("mousedown should dispatch");
+    let outcome = dispatch_drag_mouse(&mut vm, 20.0, 120.0, "mousemove", true);
+    assert_eq!(outcome.intercepted_drag, None);
+}
+
+#[test]
+fn drag_without_interception_is_not_reported_and_ends_on_source() {
+    let mut vm = new_rendered_test_vm("https://drag-no-intercept.test/", DRAG_INTERCEPT_PAGE);
+    vm.eval(DRAG_INTERCEPT_LISTENERS)
+        .expect("drag listener setup should evaluate");
+    vm.publish_layout_for_test()
+        .expect("publish geometry before coordinate input");
+
+    vm.dispatch_mouse_event_at_point(20.0, 20.0, "mousedown", 0, None, 0.0, 0.0)
+        .expect("mousedown should dispatch");
+    let outcome = vm
+        .dispatch_mouse_event_at_point(20.0, 120.0, "mousemove", 0, Some(1), 0.0, 0.0)
+        .expect("mousemove should start the drag");
+    assert_eq!(outcome.intercepted_drag, None);
+    vm.dispatch_mouse_event_at_point(20.0, 120.0, "mouseup", 0, Some(0), 0.0, 0.0)
+        .expect("mouseup should finish the drag");
+
+    assert_eq!(
+        vm.eval("window.__dragLog.join('|')").expect("log"),
+        "dragstart|dragenter:|dragover|drop:custom:text/plain,application/x-moli:move|dragend"
+    );
+}
+
+#[test]
+fn native_drag_eligibility_ignores_author_getters_and_requires_threshold() {
+    for (tag, attribute, expected) in [
+        ("div", "", false),
+        ("div", "draggable=false", false),
+        ("div", "draggable=TRUE", true),
+        ("a", "href=/destination", true),
+        ("a", "href=/destination draggable=false", false),
+        ("img", "src=/image.png", true),
+        ("img", "src=/image.png draggable=false", false),
+    ] {
+        let markup = format!(
+            "<html><body style='margin:0'><{tag} id=source {attribute} style='display:block;position:absolute;left:0;top:0;width:100px;height:40px'></{tag}></body></html>"
+        );
+        let mut vm = new_rendered_test_vm("https://drag-eligibility.test/", &markup);
+        vm.eval(
+            r#"
+window.__starts = 0;
+const source = document.getElementById('source');
+Object.defineProperty(source, 'draggable', { get() { throw new Error('author getter'); } });
+source.addEventListener('dragstart', event => {
+  window.__starts++;
+  window.__initialEffect = event.dataTransfer.effectAllowed;
+});
+"#,
+        )
+        .expect("native source setup");
+        dispatch_drag_mouse(&mut vm, 20.0, 20.0, "mousedown", true);
+        let before_threshold = dispatch_drag_mouse(&mut vm, 21.0, 21.0, "mousemove", true);
+        assert_eq!(before_threshold.intercepted_drag, None);
+        assert_eq!(vm.eval("window.__starts").expect("start count"), "0");
+        let drag = dispatch_drag_mouse(&mut vm, 24.0, 20.0, "mousemove", true);
+        assert_eq!(
+            drag.intercepted_drag.is_some(),
+            expected,
+            "{tag} {attribute}"
+        );
+        if expected {
+            assert_eq!(
+                vm.eval("window.__initialEffect").expect("initial effect"),
+                "uninitialized"
+            );
+            let drag = drag.intercepted_drag.expect("native drag");
+            if tag == "a" || tag == "img" {
+                let expected = if tag == "a" {
+                    "https://drag-eligibility.test/destination"
+                } else {
+                    "https://drag-eligibility.test/image.png"
+                };
+                assert!(
+                    drag.items
+                        .iter()
+                        .any(|item| { item.mime_type == "text/uri-list" && item.data == expected })
+                );
+            }
+        }
+        vm.cancel_dragging().expect("cancel native drag");
+    }
+}
+
+#[test]
+fn native_drag_uses_draggable_ancestor_and_only_a_primary_press() {
+    let page = r#"<html><body style="margin:0"><div id="source" draggable="true"
+style="position:absolute;left:0;top:0;width:100px;height:40px"><span id="child"
+style="display:block;width:100px;height:40px"></span></div></body></html>"#;
+    let mut vm = new_rendered_test_vm("https://drag-ancestor.test/", page);
+    vm.eval("window.__source=''; document.addEventListener('dragstart', e => window.__source=e.target.id)")
+        .expect("source listener");
+    assert_eq!(
+        dispatch_drag_mouse(&mut vm, 30.0, 20.0, "mousemove", true).intercepted_drag,
+        None,
+        "a synthetic buttons mask alone must not arm a gesture"
+    );
+    vm.dispatch_mouse_event_at_point(20.0, 20.0, "mousedown", 2, Some(2), 0.0, 0.0)
+        .expect("secondary press");
+    assert_eq!(
+        vm.dispatch_mouse_event_at_point(30.0, 20.0, "mousemove", 2, Some(2), 0.0, 0.0)
+            .expect("secondary move")
+            .intercepted_drag,
+        None
+    );
+    vm.dispatch_mouse_event_at_point(30.0, 20.0, "mouseup", 2, Some(0), 0.0, 0.0)
+        .expect("secondary release");
+    dispatch_drag_mouse(&mut vm, 20.0, 20.0, "mousedown", true);
+    assert!(
+        dispatch_drag_mouse(&mut vm, 24.0, 20.0, "mousemove", true)
+            .intercepted_drag
+            .is_some()
+    );
+    assert_eq!(vm.eval("window.__source").expect("drag source"), "source");
+}
+
+#[test]
+fn canceled_dragstart_and_cancel_command_consume_the_held_gesture() {
+    let mut vm = new_rendered_test_vm("https://drag-cancel-held.test/", DRAG_INTERCEPT_PAGE);
+    vm.eval(
+        "window.__starts=0; document.getElementById('source').addEventListener('dragstart', e => { window.__starts++; if(window.__starts === 1)e.preventDefault(); })",
+    ).expect("cancel start listener");
+    dispatch_drag_mouse(&mut vm, 20.0, 20.0, "mousedown", true);
+    for y in [25.0, 30.0, 120.0] {
+        assert_eq!(
+            dispatch_drag_mouse(&mut vm, 20.0, y, "mousemove", true).intercepted_drag,
+            None
+        );
+    }
+    assert_eq!(vm.eval("window.__starts").expect("canceled starts"), "1");
+    dispatch_drag_mouse(&mut vm, 20.0, 120.0, "mouseup", true);
+    dispatch_drag_mouse(&mut vm, 20.0, 20.0, "mousedown", true);
+    assert!(
+        dispatch_drag_mouse(&mut vm, 20.0, 120.0, "mousemove", true)
+            .intercepted_drag
+            .is_some()
+    );
+    vm.eval("window.__ends=0; document.getElementById('source').addEventListener('dragend', () => window.__ends++)")
+        .expect("end listener");
+    vm.cancel_dragging().expect("cancel active drag");
+    vm.cancel_dragging().expect("idle cancel is idempotent");
+    assert_eq!(
+        dispatch_drag_mouse(&mut vm, 30.0, 120.0, "mousemove", true).intercepted_drag,
+        None
+    );
+    dispatch_drag_mouse(&mut vm, 30.0, 120.0, "mouseup", true);
+    assert_eq!(
+        vm.eval("window.__starts+':'+window.__ends")
+            .expect("counts"),
+        "2:1"
+    );
+    // Even cancellation before crossing the threshold disarms the press.
+    dispatch_drag_mouse(&mut vm, 20.0, 20.0, "mousedown", true);
+    vm.cancel_dragging().expect("cancel pending gesture");
+    assert_eq!(
+        dispatch_drag_mouse(&mut vm, 20.0, 120.0, "mousemove", true).intercepted_drag,
+        None
+    );
+}
+
+#[test]
+fn intercepted_drop_revalidates_target_and_operations_and_finishes_without_a_hit() {
+    for rejection in ["not-canceled", "none", "disallowed", "new-target", "no-hit"] {
+        let mut vm = new_rendered_test_vm("https://drag-rejected-drop.test/", DRAG_INTERCEPT_PAGE);
+        vm.eval(
+            r#"
+window.__drops=0; window.__ends=0;
+document.getElementById('source').addEventListener('dragstart', e => {
+  e.dataTransfer.setData('text/plain','payload'); e.dataTransfer.effectAllowed='copy';
+});
+document.getElementById('source').addEventListener('dragend', e => {
+  window.__ends++; window.__endEffect=e.dataTransfer.dropEffect;
+});
+const target=document.getElementById('target');
+target.addEventListener('dragover', e => {
+  if(window.__reject !== 'not-canceled') e.preventDefault();
+  if(window.__reject === 'none') e.dataTransfer.dropEffect='none';
+  if(window.__reject === 'disallowed') e.dataTransfer.dropEffect='move';
+});
+document.addEventListener('drop', () => window.__drops++);
+const other=document.createElement('div'); other.style='position:absolute;left:300px;top:100px;width:100px;height:100px';
+document.body.append(other);
+"#,
+        ).expect("drop rejection setup");
+        vm.publish_layout_for_test().expect("new target geometry");
+        let data = drag_data_from(&start_intercepted_drag(&mut vm));
+        vm.dispatch_drag_event_at_point(20.0, 120.0, "dragenter", data.clone(), 0)
+            .expect("initial accepted target");
+        vm.eval(&format!("window.__reject='{rejection}'"))
+            .expect("rejection mode");
+        let x = match rejection {
+            "new-target" => 320.0,
+            "no-hit" => -1000.0,
+            _ => 20.0,
+        };
+        vm.dispatch_drag_event_at_point(x, 120.0, "drop", data.clone(), 0)
+            .expect("drop attempt");
+        assert!(
+            vm.active_drag_session.is_none(),
+            "{rejection}: finished session"
+        );
+        assert_eq!(
+            vm.eval("window.__drops+':'+window.__ends+':'+window.__endEffect")
+                .expect("drop counts"),
+            "0:1:none",
+            "{rejection}"
+        );
+        let late = vm
+            .dispatch_drag_event_at_point(20.0, 120.0, "drop", data, 0)
+            .expect("late drop");
+        assert!(
+            !late.handled,
+            "{rejection}: late drop cannot recreate a session"
+        );
+        assert_eq!(
+            vm.eval("window.__drops+':'+window.__ends")
+                .expect("late counts"),
+            "0:1"
+        );
+    }
+}
+
+#[test]
+fn native_drag_data_store_is_writable_only_at_start_and_readable_only_at_drop() {
+    let mut vm = new_rendered_test_vm("https://drag-store-lifecycle.test/", DRAG_INTERCEPT_PAGE);
+    vm.eval(
+        r#"
+window.__phases=[];
+window.DataTransfer=function(){ throw new Error('page constructor must not run'); };
+const source=document.getElementById('source'), target=document.getElementById('target');
+source.addEventListener('dragstart', e => {
+  window.__held=e.dataTransfer;
+  e.dataTransfer.setData('text/plain','original');
+  window.__phases.push('start:'+e.dataTransfer.getData('text/plain'));
+});
+for(const type of ['dragenter','dragover']) target.addEventListener(type, e => {
+  e.dataTransfer.setData('text/plain','overwritten');
+  window.__phases.push(type+':'+e.dataTransfer.getData('text/plain')+':'+e.dataTransfer.types.join(','));
+  if(type==='dragover')e.preventDefault();
+});
+target.addEventListener('drop', e => {
+  e.preventDefault();
+  e.dataTransfer.setData('text/plain','overwritten');
+  window.__phases.push('drop:'+e.dataTransfer.getData('text/plain'));
+});
+source.addEventListener('dragend', e => window.__phases.push('end:'+e.dataTransfer.getData('text/plain')+':'+e.dataTransfer.types.join(',')));
+"#,
+    ).expect("store lifecycle listeners");
+    let data = drag_data_from(&start_intercepted_drag(&mut vm));
+    assert_eq!(
+        vm.eval("JSON.stringify([window.__held.getData('text/plain'),Array.from(window.__held.types),Array.from(window.__held.items,item => [item.kind,item.type])])")
+            .expect("protected source between events"),
+        r#"["",["text/plain"],[["string","text/plain"]]]"#
+    );
+    vm.dispatch_drag_event_at_point(20.0, 120.0, "dragenter", data.clone(), 0)
+        .expect("enter");
+    vm.dispatch_drag_event_at_point(20.0, 120.0, "drop", data, 0)
+        .expect("accepted drop");
+    assert_eq!(
+        vm.eval("window.__phases.join('|')")
+            .expect("store phase log"),
+        "start:original|dragenter::text/plain|dragover::text/plain|drop:original|end::text/plain"
+    );
+    assert_eq!(vm.eval("window.__held.setData('text/plain','late'); window.__held.getData('text/plain')+':'+window.__held.types.length+':'+window.__held.items.length+':'+window.__held.files.length").expect("disabled store"), ":0:0:0");
+}
+
+#[test]
+fn native_selection_drag_requires_press_inside_selected_text() {
+    let page = r#"<html><body style="margin:0"><div id="source"
+style="position:absolute;left:0;top:0;width:400px;height:50px;font:20px monospace">selected text</div></body></html>"#;
+    let mut vm = new_rendered_test_vm("https://drag-selection.test/", page);
+    let point: Vec<f64> = serde_json::from_str(
+        &vm.eval(
+            r#"
+const text=document.getElementById('source').firstChild;
+const range=document.createRange();range.setStart(text,0);range.setEnd(text,8);
+const selection=window.getSelection();selection.removeAllRanges();selection.addRange(range);
+const rect=range.getBoundingClientRect();JSON.stringify([rect.left+2,rect.top+2]);
+"#,
+        )
+        .expect("selection geometry"),
+    )
+    .expect("point coordinates");
+    vm.publish_layout_for_test().expect("selected layout");
+    dispatch_drag_mouse(&mut vm, 390.0, point[1], "mousedown", true);
+    assert_eq!(
+        dispatch_drag_mouse(&mut vm, 395.0, point[1], "mousemove", true).intercepted_drag,
+        None
+    );
+    dispatch_drag_mouse(&mut vm, 395.0, point[1], "mouseup", true);
+    dispatch_drag_mouse(&mut vm, point[0], point[1], "mousedown", true);
+    let drag = dispatch_drag_mouse(&mut vm, point[0] + 5.0, point[1], "mousemove", true)
+        .intercepted_drag
+        .expect("selected text is a native drag source");
+    assert_eq!(drag.items.len(), 1);
+    assert_eq!(drag.items[0].mime_type, "text/plain");
+    assert_eq!(drag.items[0].data, "selected");
+}
+
+#[test]
+fn intercepted_drag_replay_replaces_enter_and_drop_data_including_empty_enter() {
+    for empty_enter in [true, false] {
+        let mut vm = new_rendered_test_vm("https://drag-client-payload.test/", DRAG_INTERCEPT_PAGE);
+        vm.eval(
+            r#"
+window.__ends=0;
+document.getElementById('source').addEventListener('dragstart', e => {
+  e.dataTransfer.effectAllowed='copy';
+  e.dataTransfer.setData('text/plain','original');
+  window.__sourceTransfer=e.dataTransfer;
+  window.__oldItem=e.dataTransfer.items[0];
+});
+document.getElementById('source').addEventListener('dragend', e => {
+  window.__ends++;
+  window.__sameSourceAtEnd=e.dataTransfer===window.__sourceTransfer;
+});
+document.getElementById('target').addEventListener('dragenter', e => {
+  window.__enterTypes=Array.from(e.dataTransfer.types);
+  window.__enterRead=e.dataTransfer.getData('text/plain');
+});
+document.getElementById('target').addEventListener('dragover', e => e.preventDefault());
+document.getElementById('target').addEventListener('drop', e => {
+  e.preventDefault();
+  window.__seen=[e.dataTransfer===window.__sourceTransfer,
+    e.dataTransfer.getData('text/plain'),window.__oldItem.type,
+    Array.from(e.dataTransfer.types),e.dataTransfer.dropEffect];
+});
+"#,
+        )
+        .expect("client replay listeners");
+        let original = drag_data_from(&start_intercepted_drag(&mut vm));
+        assert_eq!(original.items.len(), 1);
+        let mut enter = original.clone();
+        if empty_enter {
+            enter.items.clear();
+        } else {
+            enter.items[0].data = "client-enter".to_owned();
+        }
+        vm.dispatch_drag_event_at_point(20.0, 120.0, "dragenter", enter, 0)
+            .expect("replay enter");
+        let mut drop_data = original;
+        drop_data.items[0].data = "client-drop".to_owned();
+        vm.dispatch_drag_event_at_point(20.0, 120.0, "drop", drop_data, 0)
+            .expect("replay drop");
+        let result: serde_json::Value = serde_json::from_str(
+            &vm.eval("JSON.stringify([window.__enterTypes,window.__enterRead,window.__seen,window.__ends,window.__sameSourceAtEnd,window.__sourceTransfer.items.length])")
+                .expect("replay result"),
+        ).expect("replay JSON");
+        let enter_types = if empty_enter {
+            Vec::<&str>::new()
+        } else {
+            vec!["text/plain"]
+        };
+        assert_eq!(
+            result,
+            serde_json::json!([
+                enter_types,
+                "",
+                [false, "client-drop", "text/plain", ["text/plain"], "none"],
+                1,
+                true,
+                0
+            ])
+        );
+    }
+}
+
+#[test]
+fn native_drop_defaults_accept_editable_targets_without_canceling_dragover() {
+    for (markup, mime_type, effect_allowed, accepted) in [
+        ("<input id=target>", "text/plain", "copy", true),
+        (
+            "<textarea id=target></textarea>",
+            "text/plain",
+            "copy",
+            true,
+        ),
+        (
+            "<div id=target contenteditable=true></div>",
+            "text/plain",
+            "copy",
+            true,
+        ),
+        (
+            "<div contenteditable=true><span id=target></span></div>",
+            "text/plain",
+            "copy",
+            true,
+        ),
+        ("<input id=target>", "text/plain", "copyMove", true),
+        (
+            "<textarea id=target></textarea>",
+            "text/plain",
+            "copyMove",
+            true,
+        ),
+        (
+            "<div id=target contenteditable=true></div>",
+            "text/plain",
+            "copyMove",
+            true,
+        ),
+        ("<input id=target>", "text/plain", "linkMove", false),
+        (
+            "<textarea id=target></textarea>",
+            "text/plain",
+            "linkMove",
+            false,
+        ),
+        (
+            "<div id=target contenteditable=true></div>",
+            "text/plain",
+            "linkMove",
+            false,
+        ),
+        ("<input id=target readonly>", "text/plain", "copy", false),
+        ("<input id=target disabled>", "text/plain", "copy", false),
+        (
+            "<fieldset disabled><input id=target></fieldset>",
+            "text/plain",
+            "copy",
+            false,
+        ),
+        (
+            "<textarea id=target readonly></textarea>",
+            "text/plain",
+            "copy",
+            false,
+        ),
+        (
+            "<textarea id=target disabled></textarea>",
+            "text/plain",
+            "copy",
+            false,
+        ),
+        (
+            "<div contenteditable=true><input id=target readonly></div>",
+            "text/plain",
+            "copy",
+            false,
+        ),
+        (
+            "<div contenteditable=true><span id=target contenteditable=false></span></div>",
+            "text/plain",
+            "copy",
+            false,
+        ),
+        ("<div id=target></div>", "text/plain", "copy", false),
+        ("<input id=target>", "text/html", "copy", false),
+        ("<input id=target>", "text/plain", "none", false),
+    ] {
+        let page = format!(
+            r#"<html><head><style>
+body {{ margin:0 }}
+#source {{ position:absolute;left:0;top:0;width:100px;height:40px }}
+#target {{ display:block;position:absolute;left:0;top:100px;width:200px;height:80px }}
+</style></head><body><div id=source draggable=true></div>{markup}</body></html>"#
+        );
+        let mut vm = new_rendered_test_vm("https://drag-editable-default.test/", &page);
+        vm.eval(&format!(
+            r#"
+window.__drops=0;window.__ends=0;window.__protectedReads='';
+window.__dropTarget=document.getElementById('target');
+window.__dropHost=window.__dropTarget.closest('[contenteditable]') || window.__dropTarget;
+document.getElementById('source').addEventListener('dragstart', e => {{
+  e.dataTransfer.setData('{mime_type}','payload');
+  e.dataTransfer.effectAllowed='{effect_allowed}';
+}});
+document.getElementById('source').addEventListener('dragend', e => {{
+  window.__ends++;window.__endEffect=e.dataTransfer.dropEffect;
+}});
+document.getElementById('target').addEventListener('dragover', e => {{
+  window.__protectedReads+=e.dataTransfer.getData('text/plain');
+}});
+document.addEventListener('drop', () => window.__drops++);
+"#
+        ))
+        .expect("editable drop listeners");
+        let data = drag_data_from(&start_intercepted_drag(&mut vm));
+        vm.dispatch_drag_event_at_point(20.0, 120.0, "dragenter", data.clone(), 0)
+            .expect("editable target enter");
+        vm.dispatch_drag_event_at_point(20.0, 120.0, "drop", data, 0)
+            .expect("editable target drop");
+        let observed: serde_json::Value = serde_json::from_str(
+            &vm.eval(
+                r#"(() => {
+const target=window.__dropTarget;
+const host=window.__dropHost;
+const value='value' in target ? target.value : host.textContent;
+return JSON.stringify([window.__drops,window.__ends,value,window.__protectedReads,window.__endEffect]);
+})()"#,
+            )
+            .expect("editable drop result"),
+        )
+        .expect("editable result JSON");
+        assert_eq!(
+            observed,
+            serde_json::json!([
+                usize::from(accepted),
+                1,
+                if accepted { "payload" } else { "" },
+                "",
+                if accepted { "copy" } else { "none" }
+            ]),
+            "{markup}, {mime_type}, effectAllowed={effect_allowed}"
+        );
+    }
+}
+
+#[test]
+fn successful_native_drag_suppresses_pointer_input_until_the_drag_finishes() {
+    let mut vm = new_rendered_test_vm("https://drag-pointer-stream.test/", DRAG_INTERCEPT_PAGE);
+    vm.eval(
+        r#"
+window.__ordinary=[];window.__dragPointerOrder=[];window.__cancelState=[];
+const source=document.getElementById('source');
+source.addEventListener('pointerdown', e => source.setPointerCapture(e.pointerId));
+source.addEventListener('dragstart', e => e.dataTransfer.setData('text/plain','payload'));
+for(const type of ['pointerdown','mousedown','pointermove','mousemove','pointerup','mouseup','click']) {
+  document.addEventListener(type, () => window.__ordinary.push(type));
+}
+for(const type of ['dragstart','pointercancel','lostpointercapture','dragend']) {
+  document.addEventListener(type, e => {
+    window.__dragPointerOrder.push(type);
+    if(type==='pointercancel') {
+      window.__cancelState.push([type,e.cancelable,e.buttons,e.pressure,source.hasPointerCapture(e.pointerId)]);
+    } else if(type==='lostpointercapture') {
+      window.__cancelState.push([type,e.cancelable,e.buttons,source.hasPointerCapture(e.pointerId)]);
+    }
+  });
+}
+"#,
+    ).expect("pointer stream listeners");
+    dispatch_drag_mouse(&mut vm, 20.0, 20.0, "mousedown", true);
+    let outcome = dispatch_drag_mouse(&mut vm, 20.0, 120.0, "mousemove", true);
+    let data = drag_data_from(&outcome.intercepted_drag.expect("successful native drag"));
+    assert_eq!(
+        vm.eval("window.__dragPointerOrder.join('|')")
+            .expect("start order"),
+        "dragstart|pointercancel|lostpointercapture"
+    );
+    assert_eq!(
+        vm.eval("JSON.stringify(window.__cancelState)")
+            .expect("cancel state"),
+        "[[\"pointercancel\",false,0,0,true],[\"lostpointercapture\",false,0,false]]"
+    );
+    let ordinary_at_start = vm
+        .eval("window.__ordinary.join('|')")
+        .expect("initial stream");
+    assert_eq!(
+        ordinary_at_start,
+        "pointerdown|mousedown|pointermove|mousemove"
+    );
+    dispatch_drag_mouse(&mut vm, 20.0, 125.0, "mousemove", true);
+    assert_eq!(
+        vm.eval("window.__ordinary.join('|')")
+            .expect("active drag suppresses input"),
+        ordinary_at_start
+    );
+    vm.dispatch_drag_event_at_point(20.0, 125.0, "dragcancel", data, 0)
+        .expect("end the intercepted drag");
+    // Chromium resumes explicitly injected ordinary input after dragCancel,
+    // even when the client still reports the physical button as held.
+    dispatch_drag_mouse(&mut vm, 20.0, 130.0, "mousemove", true);
+    dispatch_drag_mouse(&mut vm, 20.0, 130.0, "mouseup", true);
+    assert_eq!(
+        vm.eval("window.__ordinary.join('|')")
+            .expect("ordinary input after cancellation"),
+        format!("{ordinary_at_start}|pointermove|mousemove|pointerup|mouseup")
+    );
+    assert_eq!(
+        vm.eval("window.__dragPointerOrder.join('|')")
+            .expect("final order"),
+        "dragstart|pointercancel|lostpointercapture|dragend"
+    );
+    dispatch_drag_mouse(&mut vm, 20.0, 20.0, "mousedown", true);
+    dispatch_drag_mouse(&mut vm, 20.0, 20.0, "mouseup", true);
+    assert_eq!(
+        vm.eval("window.__ordinary.slice(-5).join('|')")
+            .expect("fresh gesture"),
+        "pointerdown|mousedown|pointerup|mouseup|click"
+    );
+}
+
+#[test]
+fn canceled_native_dragstart_preserves_the_pointer_stream_and_capture_until_release() {
+    let mut vm = new_rendered_test_vm(
+        "https://drag-pointer-start-canceled.test/",
+        DRAG_INTERCEPT_PAGE,
+    );
+    vm.eval(
+        r#"
+window.__counts={};window.__captureLost=false;
+const source=document.getElementById('source');
+source.addEventListener('pointerdown', e => source.setPointerCapture(e.pointerId));
+source.addEventListener('dragstart', e => e.preventDefault());
+source.addEventListener('lostpointercapture', e => {
+  window.__captureLost=!source.hasPointerCapture(e.pointerId);
+});
+for(const type of ['pointermove','mousemove','pointerup','mouseup','dragstart','pointercancel','lostpointercapture','dragend']) {
+  document.addEventListener(type, () => window.__counts[type]=(window.__counts[type] || 0)+1);
+}
+"#,
+    ).expect("canceled pointer stream listeners");
+    dispatch_drag_mouse(&mut vm, 20.0, 20.0, "mousedown", true);
+    let outcome = dispatch_drag_mouse(&mut vm, 20.0, 120.0, "mousemove", true);
+    assert!(
+        outcome.intercepted_drag.is_none(),
+        "canceled start is not intercepted"
+    );
+    dispatch_drag_mouse(&mut vm, 20.0, 125.0, "mousemove", true);
+    dispatch_drag_mouse(&mut vm, 20.0, 125.0, "mouseup", true);
+    assert_eq!(
+        vm.eval("JSON.stringify(['pointermove','mousemove','pointerup','mouseup','dragstart','pointercancel','lostpointercapture','dragend'].map(type => window.__counts[type] || 0))")
+            .expect("ordinary stream counts"),
+        "[2,2,1,1,1,0,1,0]"
+    );
+    assert_eq!(
+        vm.eval("window.__captureLost").expect("capture released"),
+        "true"
+    );
+}
+
+#[test]
+fn cdp_drag_payload_replacement_and_event_view_lifetimes_are_independent() {
+    for empty_enter in [false, true] {
+        let mut vm = new_rendered_test_vm("https://drag-payload-views.test/", DRAG_INTERCEPT_PAGE);
+        vm.eval(
+            r#"
+window.__views=[];window.__records=[];window.__priorStates=[];window.__ends=0;
+const source=document.getElementById('source'),target=document.getElementById('target');
+source.addEventListener('dragstart', e => {
+  e.dataTransfer.setData('text/plain','source-text');
+  e.dataTransfer.setData('application/x-source','source-metadata');
+  e.dataTransfer.effectAllowed='copyMove';
+  window.__sourceTransfer=e.dataTransfer;
+  window.__sourceItem=e.dataTransfer.items[0];
+  window.__sourceTypes=e.dataTransfer.types;
+});
+source.addEventListener('dragend', e => {
+  window.__ends++;
+  window.__sourceEnd=[e.dataTransfer===window.__sourceTransfer,e.cancelable,
+    e.dataTransfer.getData('text/plain'),e.dataTransfer.types.length,
+    e.dataTransfer.items.length,e.dataTransfer.files.length,
+    e.dataTransfer.effectAllowed,e.dataTransfer.dropEffect];
+});
+for(const type of ['dragenter','dragover','drop']) target.addEventListener(type, e => {
+  window.__priorStates.push(window.__views.map(view => [view.getData('text/plain'),
+    view.types.length,view.items.length,view.files.length]));
+  const view=e.dataTransfer;
+  window.__views.push(view);
+  view.setData('text/plain','must-not-replace');
+  view.effectAllowed='none';
+  window.__records.push({
+    type,allowed:view.effectAllowed,effect:view.dropEffect,
+    data:[view.getData('text/plain'),view.getData('application/x-enter'),
+      view.getData('application/x-ignored'),view.getData('application/x-drop')],
+    types:Array.from(view.types),
+    items:Array.from(view.items,item => [item.kind,item.type]),
+    files:Array.from(view.files,file => [file.name,file.type,file.size,file.lastModified]),
+    sourceSame:view===window.__sourceTransfer,
+    sourceClosed:[window.__sourceTransfer.getData('text/plain'),
+      window.__sourceTransfer.types.length,window.__sourceTransfer.items.length,
+      window.__sourceItem.kind,window.__sourceItem.type]
+  });
+  if(type==='dragover') {
+    e.preventDefault();
+    view.dropEffect=view.effectAllowed==='linkMove' ? 'move' : 'copy';
+  }
+  if(type==='drop') {
+    e.preventDefault();
+    window.__savedDropFile=view.files[0];
+    window.__savedDropFile.text().then(text => window.__fileText=text);
+  }
+});
+"#,
+        )
+        .expect("payload and view listeners");
+        let intercepted = start_intercepted_drag(&mut vm);
+        assert_eq!(intercepted.drag_operations_mask, 17);
+        assert_eq!(intercepted.items.len(), 2);
+        assert_eq!(intercepted.items[0].data, "source-text");
+        assert_eq!(intercepted.items[1].mime_type, "application/x-source");
+        assert_eq!(intercepted.items[1].data, "source-metadata");
+        let payload = |name: &str, mask| RendererDragData {
+            items: vec![
+                RendererDragDataItem {
+                    mime_type: "text/plain".to_owned(),
+                    data: format!("{name}-text"),
+                    title: None,
+                    base_url: None,
+                },
+                RendererDragDataItem {
+                    mime_type: format!("application/x-{name}"),
+                    data: format!("{name}-metadata"),
+                    title: None,
+                    base_url: None,
+                },
+            ],
+            files: vec![RendererDraggedFile {
+                name: format!("{name}.bin"),
+                mime_type: "application/octet-stream".to_owned(),
+                bytes: name.as_bytes().to_vec(),
+                last_modified: 123.0,
+            }],
+            directories: Vec::new(),
+            drag_operations_mask: mask,
+        };
+        let mut enter = payload("enter", 1);
+        if empty_enter {
+            enter.items.clear();
+            enter.files.clear();
+        }
+        vm.dispatch_drag_event_at_point(20.0, 120.0, "dragenter", enter, 0)
+            .expect("enter payload");
+        vm.dispatch_drag_event_at_point(20.0, 120.0, "dragover", payload("ignored", 18), 0)
+            .expect("over changes operations only");
+        vm.dispatch_drag_event_at_point(20.0, 120.0, "drop", payload("drop", 17), 0)
+            .expect("drop replaces payload after pre-over");
+        let observed: serde_json::Value = serde_json::from_str(&vm.eval(
+            "JSON.stringify({records:window.__records,prior:window.__priorStates,distinct:new Set(window.__views).size,ends:window.__ends,end:window.__sourceEnd,sourceTypes:Array.from(window.__sourceTypes),sourceAfter:[window.__sourceTransfer.getData('text/plain'),window.__sourceTransfer.types.length,window.__sourceTransfer.items.length,window.__sourceTransfer.files.length,window.__sourceItem.kind,window.__sourceItem.type],fileBytes:window.__fileText,closed:window.__views.map(view => [view.getData('text/plain'),view.types.length,view.items.length,view.files.length])})",
+        ).expect("payload and identity result")).expect("payload JSON");
+        let entered_types = if empty_enter {
+            serde_json::json!([])
+        } else {
+            serde_json::json!(["text/plain", "application/x-enter", "Files"])
+        };
+        let entered_items = if empty_enter {
+            serde_json::json!([])
+        } else {
+            serde_json::json!([
+                ["string", "text/plain"],
+                ["string", "application/x-enter"],
+                ["file", "application/octet-stream"]
+            ])
+        };
+        let mut expected_records = Vec::new();
+        for (event, allowed) in [
+            ("dragenter", "copy"),
+            ("dragover", "linkMove"),
+            ("dragover", "copyMove"),
+        ] {
+            expected_records.push(serde_json::json!({
+                "type":event,"allowed":allowed,"effect":"none","data":["","","",""],
+                "types":entered_types,"items":entered_items,"files":[],"sourceSame":false,
+                "sourceClosed":["",2,2,"string","text/plain"]
+            }));
+        }
+        expected_records.push(serde_json::json!({
+            "type":"drop","allowed":"copyMove","effect":"none",
+            "data":["drop-text","","","drop-metadata"],
+            "types":["text/plain","application/x-drop","Files"],
+            "items":[["string","text/plain"],["string","application/x-drop"],["file","application/octet-stream"]],
+            "files":[["drop.bin","application/octet-stream",4,123]],"sourceSame":false,
+            "sourceClosed":["",2,2,"string","text/plain"]
+        }));
+        assert_eq!(
+            observed,
+            serde_json::json!({
+                "records":expected_records,
+                "prior":[[],[["",0,0,0]],[["",0,0,0],["",0,0,0]],[["",0,0,0],["",0,0,0],["",0,0,0]]],
+                "distinct":4,"ends":1,"end":[true,false,"",2,2,0,"copyMove","copy"],
+                "sourceTypes":["text/plain","application/x-source"],
+                "sourceAfter":["",0,0,0,"",""],
+                "fileBytes":"drop",
+                "closed":[["",0,0,0],["",0,0,0],["",0,0,0],["",0,0,0]]
+            }),
+            "empty_enter={empty_enter}"
+        );
+    }
+}
+
+#[test]
+fn native_drag_target_transitions_share_enter_leave_view_and_preserve_related_targets() {
+    let page = r#"<html><body style="margin:0">
+<div id=source draggable=true style="position:absolute;left:0;top:0;width:100px;height:40px"></div>
+<div id=a style="position:absolute;left:0;top:100px;width:150px;height:100px"></div>
+<div id=b style="position:absolute;left:200px;top:100px;width:150px;height:100px"></div>
+</body></html>"#;
+    let mut vm = new_rendered_test_vm("https://drag-target-transitions.test/", page);
+    vm.eval(
+        r#"
+window.__views=[];window.__events=[];window.__sourceTransfer=null;
+const source=document.getElementById('source');
+source.addEventListener('dragstart', e => {
+  window.__sourceTransfer=e.dataTransfer;
+  e.dataTransfer.setData('text/plain','source');e.dataTransfer.effectAllowed='copy';
+});
+function record(e) {
+  const transfer=e.dataTransfer;
+  if(!window.__views.includes(transfer))window.__views.push(transfer);
+  if(e.type==='dragenter' && e.target.id==='b')transfer.dropEffect='copy';
+  e.preventDefault();
+  window.__events.push([e.type,e.target.id,e.relatedTarget ? e.relatedTarget.id : null,
+    e.cancelable,e.defaultPrevented,window.__views.indexOf(transfer),
+    transfer===window.__sourceTransfer,transfer.getData('text/plain'),transfer.dropEffect]);
+}
+for(const id of ['a','b']) {
+  const target=document.getElementById(id);
+  for(const type of ['dragenter','dragleave','dragover','drop'])target.addEventListener(type,record);
+}
+source.addEventListener('dragend',record);
+"#,
+    ).expect("target transition listeners");
+    let mut data = drag_data_from(&start_intercepted_drag(&mut vm));
+    vm.dispatch_drag_event_at_point(20.0, 120.0, "dragenter", data.clone(), 0)
+        .expect("first enter A");
+    vm.dispatch_drag_event_at_point(220.0, 120.0, "dragover", data.clone(), 0)
+        .expect("move A to B");
+    vm.dispatch_drag_event_at_point(20.0, 120.0, "dragover", data.clone(), 0)
+        .expect("move B to A");
+    vm.dispatch_drag_event_at_point(20.0, 120.0, "dragover", data.clone(), 0)
+        .expect("over A without transition");
+    data.items[0].data = "target-final".to_owned();
+    vm.dispatch_drag_event_at_point(20.0, 120.0, "drop", data, 0)
+        .expect("drop A");
+    let observed: serde_json::Value = serde_json::from_str(&vm.eval(
+        "JSON.stringify([window.__events,window.__views.map(view => [view.getData('text/plain'),view.types.length,view.items.length,view.files.length])])",
+    ).expect("target transition result")).expect("transition JSON");
+    assert_eq!(
+        observed,
+        serde_json::json!([
+            [
+                ["dragenter", "a", null, true, true, 0, false, "", "none"],
+                ["dragenter", "b", "a", true, true, 1, false, "", "copy"],
+                ["dragleave", "a", "b", false, false, 1, false, "", "copy"],
+                ["dragenter", "a", "b", true, true, 2, false, "", "none"],
+                ["dragleave", "b", "a", false, false, 2, false, "", "none"],
+                ["dragover", "a", null, true, true, 3, false, "", "none"],
+                ["dragover", "a", null, true, true, 4, false, "", "none"],
+                [
+                    "drop",
+                    "a",
+                    null,
+                    true,
+                    true,
+                    5,
+                    false,
+                    "target-final",
+                    "none"
+                ],
+                ["dragend", "source", null, false, false, 6, true, "", "copy"]
+            ],
+            [
+                ["", 0, 0, 0],
+                ["", 0, 0, 0],
+                ["", 0, 0, 0],
+                ["", 0, 0, 0],
+                ["", 0, 0, 0],
+                ["", 0, 0, 0],
+                ["", 0, 0, 0]
+            ]
+        ])
+    );
+}
+
+#[test]
+fn native_selection_drag_reuses_selection_serializer_without_author_callbacks() {
+    let page = r#"<html><body style="margin:0"><div id=source style="font:20px/24px monospace;width:400px"><div id=first>alpha<span style="display:none">display-omitted</span></div><div>beta<br>gamma</div></div></body></html>"#;
+    let mut vm = new_rendered_test_vm("https://drag-selection-serializer.test/", page);
+    let (selected_text, point, raw_text): (String, Vec<f64>, String) = serde_json::from_str(
+        &vm.eval(
+            r#"
+const source=document.getElementById('source');
+const range=document.createRange();range.selectNodeContents(source);
+const selection=getSelection();selection.removeAllRanges();selection.addRange(range);
+const selectedText=selection.toString();
+const firstTextRange=document.createRange();
+firstTextRange.selectNodeContents(document.getElementById('first').firstChild);
+const rect=firstTextRange.getBoundingClientRect();
+window.__selectionStringCalls=0;
+Selection.prototype.toString=Range.prototype.toString=function() {
+  window.__selectionStringCalls++;
+  throw new Error('native selection dragging must not call author toString');
+};
+JSON.stringify([selectedText,[rect.left+2,rect.top+2],source.textContent]);
+"#,
+        )
+        .expect("select visible text and replace public stringifiers"),
+    )
+    .expect("selection text and hit point");
+    let alpha = selected_text.find("alpha").expect("first visible block");
+    let beta = selected_text.find("beta").expect("second visible block");
+    let gamma = selected_text.find("gamma").expect("visible text after br");
+    assert!(alpha < beta && beta < gamma, "{selected_text:?}");
+    assert!(
+        raw_text.contains("display-omitted"),
+        "fixture includes hidden text"
+    );
+    assert!(
+        !selected_text.contains("display-omitted"),
+        "Selection excludes display:none text"
+    );
+    vm.publish_layout_for_test()
+        .expect("publish selected text geometry");
+    dispatch_drag_mouse(&mut vm, point[0], point[1], "mousedown", true);
+    let drag = dispatch_drag_mouse(&mut vm, point[0] + 5.0, point[1], "mousemove", true)
+        .intercepted_drag
+        .expect("visible selection starts a native drag");
+    assert_eq!(drag.items.len(), 1);
+    assert_eq!(drag.items[0].mime_type, "text/plain");
+    assert_eq!(drag.items[0].data, selected_text);
+    vm.cancel_dragging().expect("finish selected text drag");
+    assert_eq!(
+        vm.eval("String(window.__selectionStringCalls)")
+            .expect("author stringifier invocation count"),
+        "0"
+    );
+}
diff --git a/moli-renderer-v8/src/script_vm/tests/dom_xhr/forms.rs b/moli-renderer-v8/src/script_vm/tests/dom_xhr/forms.rs
index 34b26fbd31..2284658e65 100644
--- a/moli-renderer-v8/src/script_vm/tests/dom_xhr/forms.rs
+++ b/moli-renderer-v8/src/script_vm/tests/dom_xhr/forms.rs
@@ -3792,6 +3792,7 @@ fn trusted_alt_click_downloads_an_anchor_without_a_download_attribute() {
         0.0,
         crate::runtime::RendererPointerEventProperties::default(),
         1,
+        false,
     )
     .expect("alt mousedown should dispatch");
     let outcome = vm
@@ -3806,6 +3807,7 @@ fn trusted_alt_click_downloads_an_anchor_without_a_download_attribute() {
             0.0,
             crate::runtime::RendererPointerEventProperties::default(),
             1,
+            false,
         )
         .expect("alt mouseup should dispatch");
 
@@ -3852,6 +3854,7 @@ fn alt_input_does_not_turn_window_open_into_a_download_or_background_popup() {
         0.0,
         crate::runtime::RendererPointerEventProperties::default(),
         1,
+        false,
     )
     .expect("Alt mousedown should dispatch");
     let outcome = vm
@@ -3866,6 +3869,7 @@ fn alt_input_does_not_turn_window_open_into_a_download_or_background_popup() {
             0.0,
             crate::runtime::RendererPointerEventProperties::default(),
             1,
+            false,
         )
         .expect("Alt mouseup should dispatch");
 
@@ -3921,6 +3925,7 @@ fn window_open_in_click_listener_uses_current_input_event() {
             0.0,
             crate::runtime::RendererPointerEventProperties::default(),
             platform_modifier,
+            false,
         )
         .expect("new-tab-modified mousedown should dispatch");
     trusted
@@ -3935,6 +3940,7 @@ fn window_open_in_click_listener_uses_current_input_event() {
             0.0,
             crate::runtime::RendererPointerEventProperties::default(),
             platform_modifier,
+            false,
         )
         .expect("new-tab-modified mouseup should dispatch");
     let trusted_popups = trusted.take_pending_popup_activations();
@@ -4024,6 +4030,7 @@ fn current_mouseup_input_covers_pointer_mouse_click_and_microtask_callbacks() {
         0.0,
         crate::runtime::RendererPointerEventProperties::default(),
         platform_modifier,
+        false,
     )
     .expect("new-tab-modified mousedown should dispatch");
     vm.dispatch_mouse_event_at_point_with_pointer_and_modifiers(
@@ -4037,6 +4044,7 @@ fn current_mouseup_input_covers_pointer_mouse_click_and_microtask_callbacks() {
         0.0,
         crate::runtime::RendererPointerEventProperties::default(),
         platform_modifier,
+        false,
     )
     .expect("new-tab-modified mouseup should dispatch");
 
diff --git a/moli-wpt-compat/fixtures/wpt/manifest.toml b/moli-wpt-compat/fixtures/wpt/manifest.toml
index 74f8694d65..ad8d80a29b 100644
--- a/moli-wpt-compat/fixtures/wpt/manifest.toml
+++ b/moli-wpt-compat/fixtures/wpt/manifest.toml
@@ -2355,7 +2355,7 @@ wait_until = "load"
 timeout_ms = 5000
 suite = "smoke"
 tags = ["fileapi", "drag-and-drop", "datatransfer", "events", "input", "actions"]
-notes = "Manual compat port for renderer-driven drag lifecycle behavior: manifest dispatch-drag actions synthesize dragenter/dragover/drop, use independent protected/readonly DataTransfer views, ignore listener payload mutations, and run the text input drop default action when drop is not canceled."
+notes = "Manual compat port for renderer-driven drag lifecycle behavior: manifest dispatch-drag actions synthesize dragenter/dragover/drop, give each target dispatch a separate DataTransfer view, keep data protected during dragenter/dragover so listener payload mutations are ignored, and let the user-agent insert the current drop command payload with a negotiated copy operation when the drop is accepted."
 
 [[test.actions]]
 type = "dispatch-drag"
@@ -2393,7 +2393,7 @@ wait_until = "load"
 timeout_ms = 5000
 suite = "smoke"
 tags = ["fileapi", "drag-and-drop", "datatransfer", "events", "input", "actions"]
-notes = "Manual compat port for renderer drag operation-mask mapping: source drag_operations_mask values are exposed through DataTransfer.effectAllowed while each event view starts with dropEffect=none; explicit dragover cancellation negotiates author-handled operations, target dropEffect overrides only run text drop defaults when allowed by the source mask, dispatch-drag modifiers populate DragEvent modifier-key state, and Ctrl/Meta/Shift/Alt modifier combinations select copy/move/link defaults with explicit link gestures taking precedence when the source mask allows them."
+notes = "Manual compat port for renderer drag operation-mask mapping: source drag_operations_mask values are exposed through DataTransfer.effectAllowed while every target event view starts with dropEffect none, explicitly canceled dragover requests only deliver drop and run text defaults when their dropEffect is allowed by the source mask, dispatch-drag modifiers populate DragEvent modifier-key state, and Ctrl/Meta/Shift/Alt modifier combinations select copy/move/link defaults with explicit link gestures taking precedence when the source mask allows them."
 
 [[test.actions]]
 type = "dispatch-drag"
@@ -2661,7 +2661,7 @@ wait_until = "load"
 timeout_ms = 5000
 suite = "smoke"
 tags = ["fileapi", "drag-and-drop", "datatransfer", "events", "input", "actions"]
-notes = "Manual compat port for dropEffect/effectAllowed default-action negotiation: an explicitly canceled dragover negotiates the target operation, which must be allowed by the source operation mask before text-control drop default insertion runs."
+notes = "Manual compat port for dropEffect/effectAllowed default-action negotiation: the target explicitly cancels dragover to request its dropEffect, which must be allowed by the source operation mask before drop delivery or text-control insertion runs."
 
 [[test.actions]]
 type = "dispatch-drag"
@@ -2802,7 +2802,7 @@ wait_until = "load"
 timeout_ms = 5000
 suite = "smoke"
 tags = ["fileapi", "drag-and-drop", "datatransfer", "events", "input", "selection", "contenteditable", "actions"]
-notes = "Manual compat port for inherited contenteditable text drop behavior: a drop targeting a descendant of a contenteditable host edits the nearest editing host, while a contenteditable=false descendant stops the inherited default editing action."
+notes = "Manual compat port for inherited contenteditable text drop behavior: a drop targeting a descendant of a contenteditable host edits the nearest editing host, while a contenteditable=false descendant rejects drop delivery and editing events without changing its text or selection."
 
 [[test.actions]]
 type = "dispatch-drag"
@@ -2856,6 +2856,10 @@ y = 10.0
 drag_operations_mask = 1
 items = [{ mime_type = "text/plain", data = "blocked-text" }]
 
+[[test.actions]]
+type = "evaluate"
+expression = "__finishContenteditableInheritance()"
+
 [[test]]
 id = "drag-contenteditable-range-basic"
 upstream = "web-platform-tests/html/editing/dnd/events/*"
@@ -2934,7 +2938,7 @@ wait_until = "load"
 timeout_ms = 5000
 suite = "smoke"
 tags = ["fileapi", "drag-and-drop", "datatransfer", "events", "actions"]
-notes = "Manual compat port for renderer-driven drag cancellation: manifest dispatch-drag event=dragCancel clears the active DataTransfer session without dispatching a DOM dragCancel event, so a subsequent baseline drop uses its own payload; protected listener mutations cannot change the drag data."
+notes = "Manual compat port for renderer-driven drag cancellation: manifest dispatch-drag event=dragCancel clears the active DataTransfer session without dispatching a DOM dragCancel event, disables the canceled DataTransfer, and new dragenter/drop commands establish fresh payloads for a subsequent accepted drop. Renderer tests separately cover rejection of a late bare drop, since manifest drag actions require a handled command."
 
 [[test.actions]]
 type = "dispatch-drag"
@@ -2960,6 +2964,18 @@ y = 15.0
 drag_operations_mask = 1
 items = [{ mime_type = "text/plain", data = "ignored-cancel" }]
 
+[[test.actions]]
+type = "evaluate"
+expression = "__assertCanceledDragState()"
+
+[[test.actions]]
+type = "dispatch-drag"
+event = "dragenter"
+x = 15.0
+y = 15.0
+drag_operations_mask = 1
+items = [{ mime_type = "text/plain", data = "fresh-after-cancel" }]
+
 [[test.actions]]
 type = "dispatch-drag"
 event = "drop"
@@ -2982,6 +2998,14 @@ suite = "smoke"
 tags = ["fileapi", "drag-and-drop", "datatransfer", "events", "input", "file", "actions"]
 notes = "Manual compat port for renderer-driven file drop behavior: manifest dispatch-drag file payloads populate DataTransfer.files, uncanceled drops assign input[type=file].files and dispatch input/change with fakepath metadata, while preventDefault preserves the existing file selection and suppresses input/change."
 
+[[test.actions]]
+type = "dispatch-drag"
+event = "dragenter"
+x = 15.0
+y = 15.0
+drag_operations_mask = 1
+files = [{ name = "drag-upload.txt", mime_type = "text/plain", text = "drag-upload", last_modified = 7 }]
+
 [[test.actions]]
 type = "dispatch-drag"
 event = "drop"
@@ -2994,6 +3018,14 @@ files = [{ name = "drag-upload.txt", mime_type = "text/plain", text = "drag-uplo
 type = "evaluate"
 expression = "__advanceDragFileDropPhase()"
 
+[[test.actions]]
+type = "dispatch-drag"
+event = "dragenter"
+x = 15.0
+y = 15.0
+drag_operations_mask = 1
+files = [{ name = "blocked-upload.txt", mime_type = "text/plain", text = "blocked-upload", last_modified = 11 }]
+
 [[test.actions]]
 type = "dispatch-drag"
 event = "drop"
@@ -3002,6 +3034,10 @@ y = 15.0
 drag_operations_mask = 1
 files = [{ name = "blocked-upload.txt", mime_type = "text/plain", text = "blocked-upload", last_modified = 11 }]
 
+[[test.actions]]
+type = "evaluate"
+expression = "__finishDragFileDrop()"
+
 [[test]]
 id = "drag-file-multiple-basic"
 upstream = "web-platform-tests/html/editing/dnd/file/*"
@@ -3014,7 +3050,18 @@ wait_until = "load"
 timeout_ms = 5000
 suite = "smoke"
 tags = ["fileapi", "drag-and-drop", "datatransfer", "events", "input", "file", "actions"]
-notes = "Manual compat port for file input multiple selection semantics under renderer-driven drops: a non-multiple input rejects multiple-file default editing without changing its selection, while an input with multiple=true preserves all dropped files and exposes fakepath metadata for the first selected file."
+notes = "Manual compat port for file input multiple selection semantics under renderer-driven drops: a non-multiple input rejects a multiple-file drag without drop/input/change events, while an input with multiple=true accepts all dropped files and exposes fakepath metadata for the first selected file. Payload Files are captured synchronously during drop and remain readable after the DataTransfer becomes disabled."
+
+[[test.actions]]
+type = "dispatch-drag"
+event = "dragenter"
+x = 15.0
+y = 15.0
+drag_operations_mask = 1
+files = [
+  { name = "first.txt", mime_type = "text/plain", text = "first", last_modified = 1 },
+  { name = "second.txt", mime_type = "text/plain", text = "second", last_modified = 2 },
+]
 
 [[test.actions]]
 type = "dispatch-drag"
@@ -3031,6 +3078,17 @@ files = [
 type = "evaluate"
 expression = "__enableMultipleFileDropPhase()"
 
+[[test.actions]]
+type = "dispatch-drag"
+event = "dragenter"
+x = 15.0
+y = 15.0
+drag_operations_mask = 1
+files = [
+  { name = "alpha.txt", mime_type = "text/plain", text = "alpha", last_modified = 3 },
+  { name = "beta.txt", mime_type = "text/plain", text = "beta", last_modified = 4 },
+]
+
 [[test.actions]]
 type = "dispatch-drag"
 event = "drop"
@@ -3042,6 +3100,10 @@ files = [
   { name = "beta.txt", mime_type = "text/plain", text = "beta", last_modified = 4 },
 ]
 
+[[test.actions]]
+type = "evaluate"
+expression = "__finishMultipleFileDrop()"
+
 [[test]]
 id = "formdata-idlharness"
 upstream = "web-platform-tests/interfaces/xhr.idl"
diff --git a/moli-wpt-compat/fixtures/wpt/ported/fileapi/drag-cancel-basic.html b/moli-wpt-compat/fixtures/wpt/ported/fileapi/drag-cancel-basic.html
index d714f8a54c..0704c532bd 100644
--- a/moli-wpt-compat/fixtures/wpt/ported/fileapi/drag-cancel-basic.html
+++ b/moli-wpt-compat/fixtures/wpt/ported/fileapi/drag-cancel-basic.html
@@ -9,9 +9,22 @@ const target = document.getElementById("target");
 const events = [];
 let firstDataTransfer = null;
 
+window.__assertCanceledDragState = function () {
+  assert_array_equals(
+    events,
+    ["dragenter::true", "dragover::false", "dragleave::false"],
+    "cancellation leaves the completed drag lifecycle intact",
+  );
+  assert_equals(firstDataTransfer.getData("text"), "", "canceled data is unreadable");
+  assert_equals(firstDataTransfer.types.length, 0, "canceled store exposes no types");
+  assert_equals(firstDataTransfer.items.length, 0, "canceled store exposes no items");
+};
+
 const dropped = new Promise(function (resolve) {
   target.addEventListener("dragenter", function (event) {
-    firstDataTransfer = event.dataTransfer;
+    if (firstDataTransfer === null) {
+      firstDataTransfer = event.dataTransfer;
+    }
     events.push(
       "dragenter:" +
         event.dataTransfer.getData("text") +
@@ -21,6 +34,7 @@ const dropped = new Promise(function (resolve) {
   });
 
   target.addEventListener("dragover", function (event) {
+    event.preventDefault();
     event.dataTransfer.setData("text", "mutated-before-cancel");
     events.push(
       "dragover:" +
@@ -34,6 +48,15 @@ const dropped = new Promise(function (resolve) {
     events.push("dragCancel:" + event.dataTransfer.getData("text"));
   });
 
+  target.addEventListener("dragleave", function (event) {
+    events.push(
+      "dragleave:" +
+        event.dataTransfer.getData("text") +
+        ":" +
+        (event.dataTransfer === firstDataTransfer),
+    );
+  });
+
   target.addEventListener("drop", function (event) {
     events.push(
       "drop:" +
@@ -52,12 +75,12 @@ promise_test(async function () {
     [
       "dragenter::true",
       "dragover::false",
+      "dragleave::false",
+      "dragenter::false",
+      "dragover::false",
       "drop:fresh-after-cancel:false",
     ],
-    "dragCancel clears the session, protected mutations are ignored, and a fresh drop receives its own view",
+    "dragCancel ends the store and rejects late drops until a new dragenter starts a fresh session",
   );
-  assert_equals(firstDataTransfer.getData("text"), "", "completed enter view cannot expose its string data");
-  assert_equals(firstDataTransfer.types.length, 0, "completed enter view exposes no types");
-  assert_equals(firstDataTransfer.items.length, 0, "completed enter view exposes no items");
 }, "Input.dispatchDragEvent dragCancel clears the active drag session");
 </script>
diff --git a/moli-wpt-compat/fixtures/wpt/ported/fileapi/drag-contenteditable-inheritance-basic.html b/moli-wpt-compat/fixtures/wpt/ported/fileapi/drag-contenteditable-inheritance-basic.html
index c37d44707d..a61a7212f2 100644
--- a/moli-wpt-compat/fixtures/wpt/ported/fileapi/drag-contenteditable-inheritance-basic.html
+++ b/moli-wpt-compat/fixtures/wpt/ported/fileapi/drag-contenteditable-inheritance-basic.html
@@ -11,6 +11,7 @@ const host = document.getElementById("host");
 const child = document.getElementById("child");
 const events = [];
 let phase = "allowed";
+let finishActions = null;
 
 function selectedText() {
   const selection = getSelection();
@@ -37,49 +38,52 @@ window.__advanceContenteditableInheritancePhase = function () {
 resetSelection();
 
 const complete = new Promise(function (resolve) {
-  host.addEventListener("drop", function (event) {
-    events.push(
-      phase +
-        "-drop:" +
-        event.target.id +
-        ":" +
-        event.dataTransfer.getData("text") +
-        ":" +
-        child.textContent +
-        ":" +
-        selectedText(),
-    );
-    if (phase === "blocked") {
-      resolve();
-    }
-  });
+  finishActions = resolve;
+});
 
-  host.addEventListener("beforeinput", function (event) {
-    events.push(
-      phase +
-        "-beforeinput:" +
-        event.target.id +
-        ":" +
-        child.textContent +
-        ":" +
-        selectedText(),
-    );
-  });
+window.__finishContenteditableInheritance = function () {
+  finishActions();
+};
 
-  host.addEventListener("input", function (event) {
-    const selection = getSelection();
-    events.push(
-      phase +
-        "-input:" +
-        event.target.id +
-        ":" +
-        child.textContent +
-        ":" +
-        selection.anchorOffset +
-        ":" +
-        selection.focusOffset,
-    );
-  });
+host.addEventListener("drop", function (event) {
+  events.push(
+    phase +
+      "-drop:" +
+      event.target.id +
+      ":" +
+      event.dataTransfer.getData("text") +
+      ":" +
+      child.textContent +
+      ":" +
+      selectedText(),
+  );
+});
+
+host.addEventListener("beforeinput", function (event) {
+  events.push(
+    phase +
+      "-beforeinput:" +
+      event.target.id +
+      ":" +
+      child.textContent +
+      ":" +
+      selectedText(),
+  );
+});
+
+host.addEventListener("input", function (event) {
+  const selection = getSelection();
+  events.push(
+    phase +
+      "-input:" +
+      event.target.id +
+      ":" +
+      child.textContent +
+      ":" +
+      selection.anchorOffset +
+      ":" +
+      selection.focusOffset,
+  );
 });
 
 promise_test(async function () {
@@ -90,10 +94,10 @@ promise_test(async function () {
       "allowed-drop:child:allowed-text:hello world:world",
       "allowed-beforeinput:host:hello world:world",
       "allowed-input:host:hello allowed-text:18:18",
-      "blocked-drop:child:blocked-text:hello world:world",
     ],
-    "contenteditable drop should inherit editing host and stop at contenteditable=false",
+    "inherited contenteditable accepts the drop, while contenteditable=false rejects drop and editing events",
   );
   assert_equals(child.textContent, "hello world", "contenteditable=false child was not edited");
+  assert_equals(selectedText(), "world", "rejected drop preserves the selection inside the non-editable child");
 }, "Input.dispatchDragEvent applies contenteditable inheritance for text drop defaults");
 </script>
diff --git a/moli-wpt-compat/fixtures/wpt/ported/fileapi/drag-effect-negotiation-basic.html b/moli-wpt-compat/fixtures/wpt/ported/fileapi/drag-effect-negotiation-basic.html
index ac57b05014..7519772dc7 100644
--- a/moli-wpt-compat/fixtures/wpt/ported/fileapi/drag-effect-negotiation-basic.html
+++ b/moli-wpt-compat/fixtures/wpt/ported/fileapi/drag-effect-negotiation-basic.html
@@ -82,13 +82,14 @@ promise_test(async function () {
     [
       "blocked-enter:none:copy",
       "blocked-over:move:copy",
-      "blocked-drop:blocked-text:none:copy:hello world",
+      "blocked-over:move:copy",
       "allowed-enter:none:copyMove",
       "allowed-over:move:copyMove",
+      "allowed-over:move:copyMove",
       "allowed-drop:allowed-text:none:copyMove:hello world",
       "allowed-input:hello allowed-text:18:18",
     ],
-    "independent drop views start with none, while the negotiated operation gates default insertion",
+    "an author-accepted drop is dispatched only when its operation is allowed by the source",
   );
 }, "Input.dispatchDragEvent gates text drop defaults on effect negotiation");
 </script>
diff --git a/moli-wpt-compat/fixtures/wpt/ported/fileapi/drag-file-drop-basic.html b/moli-wpt-compat/fixtures/wpt/ported/fileapi/drag-file-drop-basic.html
index e01262e4d3..f70886e32d 100644
--- a/moli-wpt-compat/fixtures/wpt/ported/fileapi/drag-file-drop-basic.html
+++ b/moli-wpt-compat/fixtures/wpt/ported/fileapi/drag-file-drop-basic.html
@@ -8,16 +8,20 @@
 const input = document.getElementById("upload");
 const events = [];
 let phase = "default";
-let preventedDropResolve = null;
 let defaultDropFile = null;
 let preventedDropFile = null;
 let defaultDropTransfer = null;
 let preventedDropTransfer = null;
+let finishActions = null;
 
-const preventedDrop = new Promise(function (resolve) {
-  preventedDropResolve = resolve;
+const actionsFinished = new Promise(function (resolve) {
+  finishActions = resolve;
 });
 
+window.__finishDragFileDrop = function () {
+  finishActions();
+};
+
 window.__advanceDragFileDropPhase = function () {
   phase = "prevented";
 };
@@ -44,7 +48,6 @@ input.addEventListener("drop", function (event) {
         ":" +
         input.files[0].name,
     );
-    setTimeout(preventedDropResolve, 0);
     return;
   }
 
@@ -83,7 +86,7 @@ input.addEventListener("change", function () {
 });
 
 promise_test(async function () {
-  await preventedDrop;
+  await actionsFinished;
   assert_array_equals(
     events,
     [
diff --git a/moli-wpt-compat/fixtures/wpt/ported/fileapi/drag-file-multiple-basic.html b/moli-wpt-compat/fixtures/wpt/ported/fileapi/drag-file-multiple-basic.html
index 125dd22878..33ad1d9ecf 100644
--- a/moli-wpt-compat/fixtures/wpt/ported/fileapi/drag-file-multiple-basic.html
+++ b/moli-wpt-compat/fixtures/wpt/ported/fileapi/drag-file-multiple-basic.html
@@ -8,15 +8,19 @@
 const input = document.getElementById("upload");
 const events = [];
 let phase = "single";
-let multipleChangeResolve = null;
 let multipleDropFiles = null;
 let singleSelection = null;
 let droppedTransfer = null;
+let finishActions = null;
 
-const multipleChanged = new Promise(function (resolve) {
-  multipleChangeResolve = resolve;
+const actionsFinished = new Promise(function (resolve) {
+  finishActions = resolve;
 });
 
+window.__finishMultipleFileDrop = function () {
+  finishActions();
+};
+
 window.__enableMultipleFileDropPhase = function () {
   singleSelection = Array.from(input.files).map(file => file.name);
   input.multiple = true;
@@ -59,23 +63,19 @@ input.addEventListener("change", function () {
       ":" +
       Array.from(input.files).map(file => file.name).join(","),
   );
-  if (phase === "multiple") {
-    multipleChangeResolve();
-  }
 });
 
 promise_test(async function () {
-  await multipleChanged;
-  assert_array_equals(singleSelection, [], "single-file input rejects multiple files without changing selection");
+  await actionsFinished;
+  assert_array_equals(singleSelection, [], "single-file input rejects a multiple-file drag without changing selection");
   assert_array_equals(
     events,
     [
-      "single-drop:2:first.txt,second.txt:0",
       "multiple-drop:2:alpha.txt,beta.txt:0",
       "multiple-input:2:alpha.txt,beta.txt:C:\\fakepath\\alpha.txt",
       "multiple-change:2:alpha.txt,beta.txt",
     ],
-    "single-file default editing rejects multiple files; multiple input retains both and dispatches input/change",
+    "single-file input rejects the drag before drop; multiple input accepts both files and emits input/change",
   );
   assert_equals(input.files.length, 2, "multiple input keeps both dropped files");
   assert_equals(input.files[0].name, "alpha.txt", "first multiple file");
@@ -90,7 +90,7 @@ promise_test(async function () {
   assert_equals(await input.files[1].text(), "beta", "second multiple file bytes");
   assert_equals(await multipleDropFiles[0].text(), "alpha", "drop DataTransfer first file bytes");
   assert_equals(await multipleDropFiles[1].text(), "beta", "drop DataTransfer second file bytes");
-  assert_equals(droppedTransfer.files.length, 0, "completed drop disables its DataTransfer while captured Files remain readable");
+  assert_equals(droppedTransfer.files.length, 0, "completed drop disables the retained DataTransfer, while captured Files stay readable");
   assert_equals(input.value, "C:\\fakepath\\alpha.txt", "fakepath reflects first selected file");
 }, "Input.dispatchDragEvent respects file input multiple selection semantics");
 </script>
diff --git a/moli-wpt-compat/fixtures/wpt/ported/fileapi/drag-lifecycle-basic.html b/moli-wpt-compat/fixtures/wpt/ported/fileapi/drag-lifecycle-basic.html
index 015f898dc0..6f8d002cac 100644
--- a/moli-wpt-compat/fixtures/wpt/ported/fileapi/drag-lifecycle-basic.html
+++ b/moli-wpt-compat/fixtures/wpt/ported/fileapi/drag-lifecycle-basic.html
@@ -78,6 +78,8 @@ promise_test(async function () {
       "dragenter:true::none:copyMove",
       "dragover-before:false:",
       "dragover-after::move",
+      "dragover-before:false:",
+      "dragover-after::move",
       "drop:false:drop-text:none:hello world",
       "input:hello drop-text:15:15",
     ],
diff --git a/moli-wpt-compat/fixtures/wpt/ported/fileapi/drag-operation-mask-basic.html b/moli-wpt-compat/fixtures/wpt/ported/fileapi/drag-operation-mask-basic.html
index 0d2893cd90..6601bd83d3 100644
--- a/moli-wpt-compat/fixtures/wpt/ported/fileapi/drag-operation-mask-basic.html
+++ b/moli-wpt-compat/fixtures/wpt/ported/fileapi/drag-operation-mask-basic.html
@@ -6,24 +6,20 @@
 <script src="/wpt/resources/moli-wpt-adapter.js"></script>
 <script>
 const target = document.getElementById("target");
-const events = [];
+const records = Object.create(null);
 let phase = "none";
 let overrideDropEffect = null;
 let expectedDrops = 0;
 
-function shouldRecordModifierKeys() {
-  return phase === "modifiers" ||
-    phase === "modifierSelection" ||
-    phase === "modifierPrecedence";
+function phaseRecord() {
+  if (!records[phase]) {
+    records[phase] = { enter: [], over: [], drop: [], input: [] };
+  }
+  return records[phase];
 }
 
 function modifierState(event) {
-  return [
-    event.altKey,
-    event.ctrlKey,
-    event.metaKey,
-    event.shiftKey,
-  ].join(",");
+  return [event.altKey, event.ctrlKey, event.metaKey, event.shiftKey].join(",");
 }
 
 function resetTargetValue() {
@@ -42,119 +38,98 @@ resetTargetValue();
 
 const complete = new Promise(function (resolve) {
   target.addEventListener("dragenter", function (event) {
-    if (shouldRecordModifierKeys()) {
-      events.push(phase + "-enter-keys:" + modifierState(event));
-    }
-    events.push(
-      phase +
-        "-enter:" +
-        event.dataTransfer.dropEffect +
-        ":" +
-        event.dataTransfer.effectAllowed,
-    );
+    phaseRecord().enter.push([
+      event.dataTransfer.dropEffect,
+      event.dataTransfer.effectAllowed,
+      modifierState(event),
+      event.dataTransfer.getData("text"),
+    ]);
   });
 
   target.addEventListener("dragover", function (event) {
-    // Exercise author-selected operations rather than the editor's default copy.
+    // This fixture negotiates author-handled operations. Uncanceled editor
+    // drops instead use the editor's default copy operation.
     event.preventDefault();
-    if (shouldRecordModifierKeys()) {
-      events.push(phase + "-over-keys:" + modifierState(event));
-    }
     if (overrideDropEffect !== null) {
       event.dataTransfer.dropEffect = overrideDropEffect;
     }
-    events.push(
-      phase +
-        "-over:" +
-        event.dataTransfer.dropEffect +
-        ":" +
-        event.dataTransfer.effectAllowed,
-    );
+    event.dataTransfer.setData("text", "must-not-replace-the-payload");
+    phaseRecord().over.push([
+      event.dataTransfer.dropEffect,
+      event.dataTransfer.effectAllowed,
+      modifierState(event),
+      event.dataTransfer.getData("text"),
+    ]);
   });
 
   target.addEventListener("drop", function (event) {
-    if (shouldRecordModifierKeys()) {
-      events.push(phase + "-drop-keys:" + modifierState(event));
-    }
-    events.push(
-      phase +
-        "-drop:" +
-        event.dataTransfer.getData("text") +
-        ":" +
-        event.dataTransfer.dropEffect +
-        ":" +
-        event.dataTransfer.effectAllowed +
-        ":" +
-        target.value,
-    );
+    phaseRecord().drop.push([
+      event.dataTransfer.getData("text"),
+      event.dataTransfer.dropEffect,
+      event.dataTransfer.effectAllowed,
+      target.value,
+      modifierState(event),
+    ]);
     expectedDrops += 1;
-    if (expectedDrops === 9) {
+    if (phase === "modifierPrecedence") {
+      // The default input action runs after the drop listener returns.
       setTimeout(resolve, 0);
     }
   });
 
   target.addEventListener("input", function () {
-    events.push(
-      phase +
-        "-input:" +
-        target.value +
-        ":" +
-        target.selectionStart +
-        ":" +
-        target.selectionEnd,
-    );
+    phaseRecord().input.push([
+      target.value,
+      target.selectionStart,
+      target.selectionEnd,
+    ]);
   });
 });
 
 promise_test(async function () {
   await complete;
-  assert_array_equals(
-    events,
-    [
-      "none-enter:none:none",
-      "none-over:none:none",
-      "none-drop:none-text:none:none:hello world",
-      "link-enter:none:link",
-      "link-over:none:link",
-      "link-drop:link-text:none:link:hello world",
-      "link-input:hello link-text:15:15",
-      "move-enter:none:move",
-      "move-over:none:move",
-      "move-drop:move-text:none:move:hello world",
-      "move-input:hello move-text:15:15",
-      "copyLink-enter:none:copyLink",
-      "copyLink-over:move:copyLink",
-      "copyLink-drop:copylink-text:none:copyLink:hello world",
-      "linkMove-enter:none:linkMove",
-      "linkMove-over:copy:linkMove",
-      "linkMove-drop:linkmove-text:none:linkMove:hello world",
-      "all-enter:none:all",
-      "all-over:link:all",
-      "all-drop:all-text:none:all:hello world",
-      "all-input:hello all-text:14:14",
-      "modifiers-enter-keys:true,true,true,true",
-      "modifiers-enter:none:copy",
-      "modifiers-over-keys:false,true,false,true",
-      "modifiers-over:none:copy",
-      "modifiers-drop-keys:true,false,true,false",
-      "modifiers-drop:modifiers-text:none:copy:hello world",
-      "modifiers-input:hello modifiers-text:20:20",
-      "modifierSelection-enter-keys:false,true,false,false",
-      "modifierSelection-enter:none:all",
-      "modifierSelection-over-keys:false,false,false,true",
-      "modifierSelection-over:none:all",
-      "modifierSelection-drop-keys:true,false,false,false",
-      "modifierSelection-drop:auto-text:none:all:hello world",
-      "modifierSelection-input:hello auto-text:15:15",
-      "modifierPrecedence-enter-keys:false,false,true,false",
-      "modifierPrecedence-enter:none:all",
-      "modifierPrecedence-over-keys:false,true,false,true",
-      "modifierPrecedence-over:none:all",
-      "modifierPrecedence-drop-keys:true,false,true,false",
-      "modifierPrecedence-drop:precedence-text:none:all:hello world",
-      "modifierPrecedence-input:hello precedence-text:21:21",
-    ],
-    "independent event views expose source masks and modifier keys, while negotiated operations gate editing",
-  );
-}, "Input.dispatchDragEvent exposes operation-mask effect negotiation and modifier-key matrix");
+  const noKeys = "false,false,false,false";
+  const expected = [
+    { phase: "none", allowed: "none", over: ["none", "none"] },
+    { phase: "link", allowed: "link", over: ["none", "none"], text: "link-text" },
+    { phase: "move", allowed: "move", over: ["none", "none"], text: "move-text" },
+    { phase: "copyLink", allowed: "copyLink", over: ["move", "move"] },
+    { phase: "linkMove", allowed: "linkMove", over: ["copy", "copy"] },
+    { phase: "all", allowed: "all", over: ["link", "link"], text: "all-text" },
+    {
+      phase: "modifiers", allowed: "copy", over: ["none", "none"], text: "modifiers-text",
+      keys: ["true,true,true,true", "false,true,false,true", "true,false,true,false"],
+    },
+    {
+      phase: "modifierSelection", allowed: "all", over: ["none", "none"], text: "auto-text",
+      keys: ["false,true,false,false", "false,false,false,true", "true,false,false,false"],
+    },
+    {
+      phase: "modifierPrecedence", allowed: "all", over: ["none", "none"], text: "precedence-text",
+      keys: ["false,false,true,false", "false,true,false,true", "true,false,true,false"],
+    },
+  ];
+  assert_array_equals(Object.keys(records), expected.map(function (item) { return item.phase; }), "every requested operation phase ran");
+  for (const item of expected) {
+    const record = records[item.phase];
+    const keys = item.keys || [noKeys, noKeys, noKeys];
+    assert_equals(record.enter.length, 1, item.phase + ": one dragenter");
+    assert_array_equals(record.enter[0], ["none", item.allowed, keys[0], ""], item.phase + ": event view starts with none and protected data");
+    assert_equals(record.over.length, 2, item.phase + ": explicit over and drop each negotiate dragover");
+    for (let index = 0; index < 2; index++) {
+      assert_array_equals(record.over[index], [item.over[index], item.allowed, keys[index + 1], ""], item.phase + ": operation/modifiers/protected data at over " + index);
+    }
+    if (item.text) {
+      assert_equals(record.drop.length, 1, item.phase + ": allowed operation dispatches drop");
+      assert_array_equals(record.drop[0], [item.text, "none", item.allowed, "hello world", keys[2]], item.phase + ": the drop command payload is readable only during drop");
+      const caret = 6 + item.text.length;
+      assert_equals(record.input.length, 1, item.phase + ": one default edit");
+      assert_array_equals(record.input[0], ["hello " + item.text, caret, caret], item.phase + ": accepted drop replaces the selection");
+    } else {
+      assert_equals(record.drop.length, 0, item.phase + ": forbidden operation must not dispatch drop");
+      assert_equals(record.input.length, 0, item.phase + ": forbidden operation must not edit");
+    }
+  }
+  assert_equals(expectedDrops, 6, "only the six accepted phases dispatch drop");
+}, "Input.dispatchDragEvent validates operation masks, protected data and modifier-key negotiation");
 </script>