From 98fa126678e4b6b869f4430f1ebe3f14fc06e433 Mon Sep 17 00:00:00 2001
From: Masamichi Hatayama <booqle@gmail.com>
Date: Tue, 13 Oct 2026 21:22:59 +0900
Subject: [PATCH 1/5] feat: screenshot --annotate-elements lists UI Toolkit
 controls on screen-space panels (#3308)

---
 .../Editor/UIElementAnnotatorCollectTests.cs  |  20 +
 .../Editor/UIToolkitElementClassifierTests.cs |  37 ++
 .../UIToolkitElementClassifierTests.cs.meta   |  11 +
 .../Tests/Editor/UIToolkitPanelKindTests.cs   |  89 ++++
 .../Editor/UIToolkitPanelKindTests.cs.meta    |  11 +
 .../Editor/UIToolkitReachabilityProbeTests.cs | 131 +++++
 .../UIToolkitReachabilityProbeTests.cs.meta   |  11 +
 .../Editor/UIToolkitScreenMappingTests.cs     | 118 +++++
 .../UIToolkitScreenMappingTests.cs.meta       |  11 +
 .../UIToolkitElementCollectorTests.cs         | 446 ++++++++++++++++++
 .../UIToolkitElementCollectorTests.cs.meta    |  11 +
 .../UnityCLILoop.Tests.PlayMode.asmdef        |   3 +-
 Assets/UI Toolkit.meta                        |   8 +
 Assets/UI Toolkit/UnityThemes.meta            |   8 +
 .../UnityThemes/UnityDefaultRuntimeTheme.tss  |   1 +
 .../UnityDefaultRuntimeTheme.tss.meta         |  11 +
 .../Screenshot/AnnotatedUiSystem.cs           |  12 +
 .../Screenshot/AnnotatedUiSystem.cs.meta      |  11 +
 .../Screenshot/UIElementAnnotator.cs          |   2 +
 .../Screenshot/UIToolkitAnnotation.meta       |   8 +
 .../UIToolkitElementClassifier.cs             |  48 ++
 .../UIToolkitElementClassifier.cs.meta        |  11 +
 .../UIToolkitElementCollector.cs              | 324 +++++++++++++
 .../UIToolkitElementCollector.cs.meta         |  11 +
 .../UIToolkitAnnotation/UIToolkitPanelKind.cs |  39 ++
 .../UIToolkitPanelKind.cs.meta                |  11 +
 .../UIToolkitReachabilityProbe.cs             |  76 +++
 .../UIToolkitReachabilityProbe.cs.meta        |  11 +
 .../UIToolkitScreenMapping.cs                 |  82 ++++
 .../UIToolkitScreenMapping.cs.meta            |  11 +
 .../src/Editor/ToolContracts/UIElementInfo.cs |   1 +
 31 files changed, 1584 insertions(+), 1 deletion(-)
 create mode 100644 Assets/Tests/Editor/UIToolkitElementClassifierTests.cs
 create mode 100644 Assets/Tests/Editor/UIToolkitElementClassifierTests.cs.meta
 create mode 100644 Assets/Tests/Editor/UIToolkitPanelKindTests.cs
 create mode 100644 Assets/Tests/Editor/UIToolkitPanelKindTests.cs.meta
 create mode 100644 Assets/Tests/Editor/UIToolkitReachabilityProbeTests.cs
 create mode 100644 Assets/Tests/Editor/UIToolkitReachabilityProbeTests.cs.meta
 create mode 100644 Assets/Tests/Editor/UIToolkitScreenMappingTests.cs
 create mode 100644 Assets/Tests/Editor/UIToolkitScreenMappingTests.cs.meta
 create mode 100644 Assets/Tests/PlayMode/UIToolkitElementCollectorTests.cs
 create mode 100644 Assets/Tests/PlayMode/UIToolkitElementCollectorTests.cs.meta
 create mode 100644 Assets/UI Toolkit.meta
 create mode 100644 Assets/UI Toolkit/UnityThemes.meta
 create mode 100644 Assets/UI Toolkit/UnityThemes/UnityDefaultRuntimeTheme.tss
 create mode 100644 Assets/UI Toolkit/UnityThemes/UnityDefaultRuntimeTheme.tss.meta
 create mode 100644 Packages/src/Editor/FirstPartyTools/Screenshot/AnnotatedUiSystem.cs
 create mode 100644 Packages/src/Editor/FirstPartyTools/Screenshot/AnnotatedUiSystem.cs.meta
 create mode 100644 Packages/src/Editor/FirstPartyTools/Screenshot/UIToolkitAnnotation.meta
 create mode 100644 Packages/src/Editor/FirstPartyTools/Screenshot/UIToolkitAnnotation/UIToolkitElementClassifier.cs
 create mode 100644 Packages/src/Editor/FirstPartyTools/Screenshot/UIToolkitAnnotation/UIToolkitElementClassifier.cs.meta
 create mode 100644 Packages/src/Editor/FirstPartyTools/Screenshot/UIToolkitAnnotation/UIToolkitElementCollector.cs
 create mode 100644 Packages/src/Editor/FirstPartyTools/Screenshot/UIToolkitAnnotation/UIToolkitElementCollector.cs.meta
 create mode 100644 Packages/src/Editor/FirstPartyTools/Screenshot/UIToolkitAnnotation/UIToolkitPanelKind.cs
 create mode 100644 Packages/src/Editor/FirstPartyTools/Screenshot/UIToolkitAnnotation/UIToolkitPanelKind.cs.meta
 create mode 100644 Packages/src/Editor/FirstPartyTools/Screenshot/UIToolkitAnnotation/UIToolkitReachabilityProbe.cs
 create mode 100644 Packages/src/Editor/FirstPartyTools/Screenshot/UIToolkitAnnotation/UIToolkitReachabilityProbe.cs.meta
 create mode 100644 Packages/src/Editor/FirstPartyTools/Screenshot/UIToolkitAnnotation/UIToolkitScreenMapping.cs
 create mode 100644 Packages/src/Editor/FirstPartyTools/Screenshot/UIToolkitAnnotation/UIToolkitScreenMapping.cs.meta

diff --git a/Assets/Tests/Editor/UIElementAnnotatorCollectTests.cs b/Assets/Tests/Editor/UIElementAnnotatorCollectTests.cs
index be0e642510..f4d507d6e5 100644
--- a/Assets/Tests/Editor/UIElementAnnotatorCollectTests.cs
+++ b/Assets/Tests/Editor/UIElementAnnotatorCollectTests.cs
@@ -89,6 +89,26 @@ public void CollectInteractiveElements_WithEventHandlerScripts_ClassifiesThem()
             Assert.That(typesByPath[root + "PointerDown"], Is.EqualTo("Button"));
         }
 
+        /// <summary>
+        /// Verifies uGUI elements, both selectables and handler scripts, are tagged as coming from uGUI.
+        /// </summary>
+        [Test]
+        public void CollectInteractiveElements_WithUguiElements_TagsThemAsUgui()
+        {
+            Assume.That(EventSystem.current, Is.Null);
+            Transform canvas = CreateCanvas("UiSystem", RenderMode.ScreenSpaceOverlay, true, null);
+            CreateUiChild<Button>(canvas, "Button");
+            CreateUiChild<UIElementAnnotatorTestClickHandler>(canvas, "Click");
+
+            List<UIElementInfo> buttons = CollectByPath(Prefix + "UiSystem/Button");
+            List<UIElementInfo> handlers = CollectByPath(Prefix + "UiSystem/Click");
+
+            Assert.That(buttons.Count, Is.EqualTo(1));
+            Assert.That(buttons[0].UiSystem, Is.EqualTo("UGUI"));
+            Assert.That(handlers.Count, Is.EqualTo(1));
+            Assert.That(handlers[0].UiSystem, Is.EqualTo("UGUI"));
+        }
+
         /// <summary>
         /// Verifies an object with both a selectable and a handler script is collected once, as the selectable.
         /// </summary>
diff --git a/Assets/Tests/Editor/UIToolkitElementClassifierTests.cs b/Assets/Tests/Editor/UIToolkitElementClassifierTests.cs
new file mode 100644
index 0000000000..9b1ccfdc9c
--- /dev/null
+++ b/Assets/Tests/Editor/UIToolkitElementClassifierTests.cs
@@ -0,0 +1,37 @@
+using System;
+using NUnit.Framework;
+using UnityEngine.UIElements;
+
+using io.github.hatayama.UnityCliLoop.FirstPartyTools;
+
+namespace io.github.hatayama.UnityCliLoop.Tests.Editor
+{
+    /// <summary>
+    /// Verifies which UI Toolkit controls are annotated and which uGUI-style type each one is reported as.
+    /// </summary>
+    public sealed class UIToolkitElementClassifierTests
+    {
+        /// <summary>
+        /// Verifies each supported control maps to its type, and plain elements map to null.
+        /// </summary>
+        [TestCase(typeof(Button), "Button")]
+        [TestCase(typeof(RepeatButton), "Button")]
+        [TestCase(typeof(Toggle), "Toggle")]
+        [TestCase(typeof(RadioButton), "Toggle")]
+        [TestCase(typeof(Scroller), "Scrollbar")]
+        [TestCase(typeof(Slider), "Slider")]
+        [TestCase(typeof(SliderInt), "Slider")]
+        [TestCase(typeof(MinMaxSlider), "Slider")]
+        [TestCase(typeof(TextField), "InputField")]
+        [TestCase(typeof(DropdownField), "Dropdown")]
+        [TestCase(typeof(EnumField), "Dropdown")]
+        [TestCase(typeof(Label), null)]
+        [TestCase(typeof(VisualElement), null)]
+        public void Classify_ShouldMapControlToType(Type elementType, string expectedType)
+        {
+            VisualElement element = (VisualElement)Activator.CreateInstance(elementType);
+
+            Assert.That(UIToolkitElementClassifier.Classify(element), Is.EqualTo(expectedType));
+        }
+    }
+}
diff --git a/Assets/Tests/Editor/UIToolkitElementClassifierTests.cs.meta b/Assets/Tests/Editor/UIToolkitElementClassifierTests.cs.meta
new file mode 100644
index 0000000000..896fd26d32
--- /dev/null
+++ b/Assets/Tests/Editor/UIToolkitElementClassifierTests.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: a47a1830bbd394fcaa5411c824155148
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Tests/Editor/UIToolkitPanelKindTests.cs b/Assets/Tests/Editor/UIToolkitPanelKindTests.cs
new file mode 100644
index 0000000000..18c59d76a5
--- /dev/null
+++ b/Assets/Tests/Editor/UIToolkitPanelKindTests.cs
@@ -0,0 +1,89 @@
+using NUnit.Framework;
+using UnityEngine;
+using UnityEngine.UIElements;
+
+using io.github.hatayama.UnityCliLoop.FirstPartyTools;
+
+namespace io.github.hatayama.UnityCliLoop.Tests.Editor
+{
+    /// <summary>
+    /// Verifies how panels are told apart as world-space or screen-space. The project's Unity version has no
+    /// render mode on PanelSettings, so stand-in types exercise the property lookup and the value comparison.
+    /// </summary>
+    public sealed class UIToolkitPanelKindTests
+    {
+        /// <summary>
+        /// Verifies default panel settings are not world-space, including on versions without a render mode
+        /// property at all.
+        /// </summary>
+        [Test]
+        public void IsWorldSpace_WithDefaultPanelSettings_ShouldReturnFalse()
+        {
+            PanelSettings settings = ScriptableObject.CreateInstance<PanelSettings>();
+
+            bool isWorldSpace = UIToolkitPanelKind.IsWorldSpace(settings);
+
+            Object.DestroyImmediate(settings);
+            Assert.That(isWorldSpace, Is.False);
+        }
+
+        /// <summary>
+        /// Verifies an internal render mode set to WorldSpace is detected, as on the Unity 6 versions where the
+        /// property is not public.
+        /// </summary>
+        [Test]
+        public void HasWorldSpaceRenderMode_WithInternalWorldSpace_ShouldReturnTrue()
+        {
+            InternalRenderModeSettings settings = new InternalRenderModeSettings(StandInRenderMode.WorldSpace);
+
+            Assert.That(UIToolkitPanelKind.HasWorldSpaceRenderMode(settings), Is.True);
+        }
+
+        /// <summary>
+        /// Verifies a public render mode set to a screen-space value is not treated as world-space.
+        /// </summary>
+        [Test]
+        public void HasWorldSpaceRenderMode_WithPublicScreenSpaceOverlay_ShouldReturnFalse()
+        {
+            PublicRenderModeSettings settings = new PublicRenderModeSettings(StandInRenderMode.ScreenSpaceOverlay);
+
+            Assert.That(UIToolkitPanelKind.HasWorldSpaceRenderMode(settings), Is.False);
+        }
+
+        /// <summary>
+        /// Verifies an object without a render mode property is not treated as world-space.
+        /// </summary>
+        [Test]
+        public void HasWorldSpaceRenderMode_WithoutRenderMode_ShouldReturnFalse()
+        {
+            Assert.That(UIToolkitPanelKind.HasWorldSpaceRenderMode(new object()), Is.False);
+        }
+
+        private enum StandInRenderMode
+        {
+            ScreenSpaceOverlay,
+            WorldSpace
+        }
+
+        private sealed class InternalRenderModeSettings
+        {
+            internal InternalRenderModeSettings(StandInRenderMode renderMode)
+            {
+                this.renderMode = renderMode;
+            }
+
+            // The lower-case name matches the Unity property the lookup searches for.
+            internal StandInRenderMode renderMode { get; }
+        }
+
+        private sealed class PublicRenderModeSettings
+        {
+            public PublicRenderModeSettings(StandInRenderMode renderMode)
+            {
+                this.renderMode = renderMode;
+            }
+
+            public StandInRenderMode renderMode { get; }
+        }
+    }
+}
diff --git a/Assets/Tests/Editor/UIToolkitPanelKindTests.cs.meta b/Assets/Tests/Editor/UIToolkitPanelKindTests.cs.meta
new file mode 100644
index 0000000000..8108f993b1
--- /dev/null
+++ b/Assets/Tests/Editor/UIToolkitPanelKindTests.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 6fea20beca70f484c90a8bc60d3ccc61
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Tests/Editor/UIToolkitReachabilityProbeTests.cs b/Assets/Tests/Editor/UIToolkitReachabilityProbeTests.cs
new file mode 100644
index 0000000000..bec5c849d9
--- /dev/null
+++ b/Assets/Tests/Editor/UIToolkitReachabilityProbeTests.cs
@@ -0,0 +1,131 @@
+using System;
+using System.Collections.Generic;
+using NUnit.Framework;
+using UnityEngine;
+using UnityEngine.UIElements;
+
+using io.github.hatayama.UnityCliLoop.FirstPartyTools;
+
+namespace io.github.hatayama.UnityCliLoop.Tests.Editor
+{
+    /// <summary>
+    /// Verifies which probe point, if any, reaches a UI Toolkit element given what the panels in front of it
+    /// and its own panel pick at each point.
+    /// </summary>
+    public sealed class UIToolkitReachabilityProbeTests
+    {
+        private static readonly Vector2 Center = new Vector2(50f, 50f);
+        private static readonly Vector2 Second = new Vector2(25f, 25f);
+
+        private static readonly Vector2[] ProbePoints =
+        {
+            Center,
+            Second,
+            new Vector2(75f, 25f),
+            new Vector2(25f, 75f),
+            new Vector2(75f, 75f)
+        };
+
+        /// <summary>
+        /// Verifies the center is returned when the own panel picks the target there.
+        /// </summary>
+        [Test]
+        public void FindReachablePoint_TargetPickedAtCenter_ShouldReturnCenter()
+        {
+            VisualElement target = new VisualElement();
+
+            Vector2? point = UIToolkitReachabilityProbe.FindReachablePoint(
+                ProbePoints, target, NoFrontPanels(), _ => target);
+
+            Assert.That(point, Is.EqualTo(Center));
+        }
+
+        /// <summary>
+        /// Verifies a point taken by a front panel is skipped and the next point the target owns is returned.
+        /// </summary>
+        [Test]
+        public void FindReachablePoint_FrontPanelTakesCenter_ShouldReturnSecondPoint()
+        {
+            VisualElement target = new VisualElement();
+            VisualElement cover = new VisualElement();
+            Func<Vector2, VisualElement> frontPanel = point => point == Center ? cover : null;
+
+            Vector2? point = UIToolkitReachabilityProbe.FindReachablePoint(
+                ProbePoints, target, new List<Func<Vector2, VisualElement>> { frontPanel }, _ => target);
+
+            Assert.That(point, Is.EqualTo(Second));
+        }
+
+        /// <summary>
+        /// Verifies picking a descendant of the target counts as reaching the target.
+        /// </summary>
+        [Test]
+        public void FindReachablePoint_DescendantPicked_ShouldReturnCenter()
+        {
+            VisualElement target = new VisualElement();
+            VisualElement child = new VisualElement();
+            VisualElement grandChild = new VisualElement();
+            target.hierarchy.Add(child);
+            child.hierarchy.Add(grandChild);
+            Func<Vector2, VisualElement> frontPanel = _ => null;
+
+            Vector2? point = UIToolkitReachabilityProbe.FindReachablePoint(
+                ProbePoints, target, new List<Func<Vector2, VisualElement>> { frontPanel }, _ => grandChild);
+
+            Assert.That(point, Is.EqualTo(Center));
+        }
+
+        /// <summary>
+        /// Verifies the target is unreachable when its own panel always picks another element, such as a sibling
+        /// drawn on top or the target's parent.
+        /// </summary>
+        [Test]
+        public void FindReachablePoint_OtherElementPickedEverywhere_ShouldReturnNull()
+        {
+            VisualElement parent = new VisualElement();
+            VisualElement target = new VisualElement();
+            parent.hierarchy.Add(target);
+
+            Vector2? point = UIToolkitReachabilityProbe.FindReachablePoint(
+                ProbePoints, target, NoFrontPanels(), _ => parent);
+
+            Assert.That(point, Is.Null);
+        }
+
+        /// <summary>
+        /// Verifies the target is unreachable when its own panel picks nothing at any point.
+        /// </summary>
+        [Test]
+        public void FindReachablePoint_NothingPicked_ShouldReturnNull()
+        {
+            VisualElement target = new VisualElement();
+
+            Vector2? point = UIToolkitReachabilityProbe.FindReachablePoint(
+                ProbePoints, target, NoFrontPanels(), _ => null);
+
+            Assert.That(point, Is.Null);
+        }
+
+        /// <summary>
+        /// Verifies a front panel that picks something at every point hides the target even though its own
+        /// panel would pick it.
+        /// </summary>
+        [Test]
+        public void FindReachablePoint_FrontPanelTakesEveryPoint_ShouldReturnNull()
+        {
+            VisualElement target = new VisualElement();
+            VisualElement cover = new VisualElement();
+            Func<Vector2, VisualElement> frontPanel = _ => cover;
+
+            Vector2? point = UIToolkitReachabilityProbe.FindReachablePoint(
+                ProbePoints, target, new List<Func<Vector2, VisualElement>> { frontPanel }, _ => target);
+
+            Assert.That(point, Is.Null);
+        }
+
+        private static List<Func<Vector2, VisualElement>> NoFrontPanels()
+        {
+            return new List<Func<Vector2, VisualElement>>();
+        }
+    }
+}
diff --git a/Assets/Tests/Editor/UIToolkitReachabilityProbeTests.cs.meta b/Assets/Tests/Editor/UIToolkitReachabilityProbeTests.cs.meta
new file mode 100644
index 0000000000..4db4b19d52
--- /dev/null
+++ b/Assets/Tests/Editor/UIToolkitReachabilityProbeTests.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 999f8e21dc79a4074bc61951c5daced8
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Tests/Editor/UIToolkitScreenMappingTests.cs b/Assets/Tests/Editor/UIToolkitScreenMappingTests.cs
new file mode 100644
index 0000000000..e320793d71
--- /dev/null
+++ b/Assets/Tests/Editor/UIToolkitScreenMappingTests.cs
@@ -0,0 +1,118 @@
+using NUnit.Framework;
+using UnityEngine;
+
+using io.github.hatayama.UnityCliLoop.FirstPartyTools;
+
+namespace io.github.hatayama.UnityCliLoop.Tests.Editor
+{
+    /// <summary>
+    /// Verifies which screen-to-panel functions can be inverted, and that the inversion maps panel points
+    /// back to the screen points they came from.
+    /// </summary>
+    public sealed class UIToolkitScreenMappingTests
+    {
+        /// <summary>
+        /// Verifies a pure scale is inverted by multiplying panel points back up.
+        /// </summary>
+        [Test]
+        public void TryCreate_WithHalfScale_ShouldDoublePanelPoints()
+        {
+            UIToolkitScreenMapping mapping = UIToolkitScreenMapping.TryCreate(screen => screen / 2f);
+
+            Assert.That(mapping, Is.Not.Null);
+            Vector2 screen = mapping.PanelToScreenTopLeft(new Vector2(50f, 20f));
+            Assert.That(screen.x, Is.EqualTo(100f).Within(0.001f));
+            Assert.That(screen.y, Is.EqualTo(40f).Within(0.001f));
+        }
+
+        /// <summary>
+        /// Verifies an offset plus a scale is inverted so that several screen points round-trip.
+        /// </summary>
+        [Test]
+        public void TryCreate_WithOffsetAndScale_ShouldRoundTripScreenPoints()
+        {
+            Vector2 offset = new Vector2(10f, 20f);
+            UIToolkitScreenMapping mapping = UIToolkitScreenMapping.TryCreate(screen => (screen - offset) / 2f);
+
+            Assert.That(mapping, Is.Not.Null);
+            Vector2[] screenPoints = { new Vector2(0f, 0f), new Vector2(130f, 75f), new Vector2(1920f, 1080f) };
+            foreach (Vector2 screenPoint in screenPoints)
+            {
+                Vector2 roundTrip = mapping.PanelToScreenTopLeft((screenPoint - offset) / 2f);
+                Assert.That(roundTrip.x, Is.EqualTo(screenPoint.x).Within(0.01f));
+                Assert.That(roundTrip.y, Is.EqualTo(screenPoint.y).Within(0.01f));
+            }
+        }
+
+        /// <summary>
+        /// Verifies a function that is not linear along an axis is rejected.
+        /// </summary>
+        [Test]
+        public void TryCreate_WithNonLinearFunction_ShouldReturnNull()
+        {
+            UIToolkitScreenMapping mapping = UIToolkitScreenMapping.TryCreate(
+                screen => new Vector2(screen.x * screen.x / 1000f, screen.y));
+
+            Assert.That(mapping, Is.Null);
+        }
+
+        /// <summary>
+        /// Verifies a shear, which mixes the axes, is rejected.
+        /// </summary>
+        [Test]
+        public void TryCreate_WithShear_ShouldReturnNull()
+        {
+            UIToolkitScreenMapping mapping = UIToolkitScreenMapping.TryCreate(
+                screen => new Vector2(screen.x + 0.5f * screen.y, screen.y));
+
+            Assert.That(mapping, Is.Null);
+        }
+
+        /// <summary>
+        /// Verifies a function that swaps the axes is rejected as degenerate.
+        /// </summary>
+        [Test]
+        public void TryCreate_WithSwappedAxes_ShouldReturnNull()
+        {
+            UIToolkitScreenMapping mapping = UIToolkitScreenMapping.TryCreate(screen => new Vector2(screen.y, screen.x));
+
+            Assert.That(mapping, Is.Null);
+        }
+
+        /// <summary>
+        /// Verifies a function that mirrors an axis is rejected, since inverting it would yield bounds whose
+        /// minimum exceeds their maximum.
+        /// </summary>
+        [Test]
+        public void TryCreate_WithMirroredAxis_ShouldReturnNull()
+        {
+            UIToolkitScreenMapping mapping = UIToolkitScreenMapping.TryCreate(
+                screen => new Vector2(1000f - screen.x, screen.y));
+
+            Assert.That(mapping, Is.Null);
+        }
+
+        /// <summary>
+        /// Verifies a constant function, which has no inverse, is rejected.
+        /// </summary>
+        [Test]
+        public void TryCreate_WithConstantFunction_ShouldReturnNull()
+        {
+            UIToolkitScreenMapping mapping = UIToolkitScreenMapping.TryCreate(screen => new Vector2(5f, 5f));
+
+            Assert.That(mapping, Is.Null);
+        }
+
+        /// <summary>
+        /// Verifies functions returning NaN or infinity, as a zero panel scale does, are rejected.
+        /// </summary>
+        [TestCase(float.NaN)]
+        [TestCase(float.PositiveInfinity)]
+        public void TryCreate_WithNonFiniteResult_ShouldReturnNull(float nonFinite)
+        {
+            UIToolkitScreenMapping mapping = UIToolkitScreenMapping.TryCreate(screen => new Vector2(nonFinite, screen.y));
+
+            Assert.That(mapping, Is.Null);
+        }
+    }
+}
diff --git a/Assets/Tests/Editor/UIToolkitScreenMappingTests.cs.meta b/Assets/Tests/Editor/UIToolkitScreenMappingTests.cs.meta
new file mode 100644
index 0000000000..8aefe4d12a
--- /dev/null
+++ b/Assets/Tests/Editor/UIToolkitScreenMappingTests.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 4553ee6a2350d4081bca1675b3ecc04d
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Tests/PlayMode/UIToolkitElementCollectorTests.cs b/Assets/Tests/PlayMode/UIToolkitElementCollectorTests.cs
new file mode 100644
index 0000000000..a76444ee37
--- /dev/null
+++ b/Assets/Tests/PlayMode/UIToolkitElementCollectorTests.cs
@@ -0,0 +1,446 @@
+using System.Collections;
+using System.Collections.Generic;
+using NUnit.Framework;
+using UnityEditor;
+using UnityEngine;
+using UnityEngine.TestTools;
+using UnityEngine.UIElements;
+
+using io.github.hatayama.UnityCliLoop.FirstPartyTools;
+using io.github.hatayama.UnityCliLoop.ToolContracts;
+
+namespace io.github.hatayama.UnityCliLoop.Tests.PlayMode
+{
+    /// <summary>
+    /// Verifies which UI Toolkit controls the annotator collects from live runtime panels and where it places
+    /// them, in bottom-left screen pixels. PanelSettings.Reset gives every panel the project's default theme, so
+    /// every element size is set explicitly to keep results independent of theme values. Every object is
+    /// destroyed in TearDown.
+    /// </summary>
+    public sealed class UIToolkitElementCollectorTests
+    {
+        private const string Prefix = "UIToolkitElementCollectorTests_";
+        private const float Tolerance = 1f;
+        private const float Left = 100f;
+        private const float Top = 50f;
+        private const float Width = 200f;
+        private const float Height = 40f;
+
+        private readonly List<Object> _createdObjects = new List<Object>();
+
+        [TearDown]
+        public void TearDown()
+        {
+            foreach (Object createdObject in _createdObjects)
+            {
+                if (createdObject != null)
+                {
+                    Object.Destroy(createdObject);
+                }
+            }
+
+            _createdObjects.Clear();
+        }
+
+        /// <summary>
+        /// Verifies a button on an overlay panel is reported with its bounds, its center as the click point,
+        /// and the UI Toolkit tags.
+        /// </summary>
+        [UnityTest]
+        public IEnumerator Collect_ButtonOnOverlayPanel_ShouldReportBoundsAndCenter()
+        {
+            UIDocument document = CreateDocument("Overlay", CreatePanelSettings(0f));
+            AddPlaced(document.rootVisualElement, new Button { name = "play" }, Left, Top, Width, Height);
+            yield return WaitForLayout();
+
+            List<UIElementInfo> matches = CollectFrom("Overlay");
+
+            Assert.That(matches.Count, Is.EqualTo(1));
+            UIElementInfo element = matches[0];
+            float gameViewHeight = Handles.GetMainGameViewSize().y;
+            Assert.That(element.Name, Is.EqualTo("play"));
+            Assert.That(element.Path, Is.EqualTo(Prefix + "Overlay#play"));
+            Assert.That(element.Type, Is.EqualTo("Button"));
+            Assert.That(element.Interaction, Is.EqualTo("Click"));
+            Assert.That(element.UiSystem, Is.EqualTo("UIToolkit"));
+            AssertBounds(element, Left, gameViewHeight - (Top + Height), Left + Width, gameViewHeight - Top);
+            Assert.That(element.SimX, Is.EqualTo(Left + Width / 2f).Within(Tolerance));
+            Assert.That(element.SimY, Is.EqualTo(gameViewHeight - (Top + Height / 2f)).Within(Tolerance));
+        }
+
+        /// <summary>
+        /// Verifies the flip to a bottom-left origin uses the Game View height it is given rather than
+        /// Screen.height, which outside the player loop reports the size of the last Editor view drawn.
+        /// </summary>
+        [UnityTest]
+        public IEnumerator Collect_WithGameViewHeightUnlikeScreenHeight_ShouldFlipWithGivenHeight()
+        {
+            UIDocument document = CreateDocument("GivenHeight", CreatePanelSettings(0f));
+            AddPlaced(document.rootVisualElement, new Button { name = "play" }, Left, Top, Width, Height);
+            yield return WaitForLayout();
+            float gameViewHeight = Screen.height + 300f;
+
+            List<UIElementInfo> elements = new List<UIElementInfo>();
+            UIToolkitElementCollector.Collect(elements, gameViewHeight);
+            List<UIElementInfo> matches = elements.FindAll(element => element.Path.StartsWith(Prefix + "GivenHeight"));
+
+            Assert.That(matches.Count, Is.EqualTo(1));
+            AssertBounds(matches[0], Left, gameViewHeight - (Top + Height), Left + Width, gameViewHeight - Top);
+            Assert.That(matches[0].SimX, Is.EqualTo(Left + Width / 2f).Within(Tolerance));
+            Assert.That(matches[0].SimY, Is.EqualTo(gameViewHeight - (Top + Height / 2f)).Within(Tolerance));
+        }
+
+        /// <summary>
+        /// Verifies a panel scale multiplies the reported screen bounds and click point.
+        /// </summary>
+        [UnityTest]
+        public IEnumerator Collect_PanelScale_ShouldScaleBounds()
+        {
+            PanelSettings settings = CreatePanelSettings(0f);
+            settings.scale = 2f;
+            UIDocument document = CreateDocument("Scaled", settings);
+            AddPlaced(document.rootVisualElement, new Button { name = "play" }, Left, Top, Width, Height);
+            yield return WaitForLayout();
+
+            List<UIElementInfo> matches = CollectFrom("Scaled");
+
+            Assert.That(matches.Count, Is.EqualTo(1));
+            float gameViewHeight = Handles.GetMainGameViewSize().y;
+            AssertBounds(matches[0], Left * 2f, gameViewHeight - (Top + Height) * 2f, (Left + Width) * 2f, gameViewHeight - Top * 2f);
+            Assert.That(matches[0].SimX, Is.EqualTo((Left + Width / 2f) * 2f).Within(Tolerance));
+            Assert.That(matches[0].SimY, Is.EqualTo(gameViewHeight - (Top + Height / 2f) * 2f).Within(Tolerance));
+        }
+
+        /// <summary>
+        /// Verifies a front panel covering the left 60% moves the click point to the first uncovered probe,
+        /// the three-quarter point on the lower quarter line.
+        /// </summary>
+        [UnityTest]
+        public IEnumerator Collect_FrontPanelCoversCenter_ShouldUseUncoveredProbe()
+        {
+            UIDocument back = CreateDocument("PartlyCovered", CreatePanelSettings(0f));
+            AddPlaced(back.rootVisualElement, new Button { name = "target" }, Left, Top, Width, Height);
+            UIDocument front = CreateDocument("PartlyCoveredFront", CreatePanelSettings(10f));
+            AddPlaced(front.rootVisualElement, new VisualElement { name = "cover" }, Left, Top, Width * 0.6f, Height);
+            yield return WaitForLayout();
+
+            List<UIElementInfo> matches = CollectFrom("PartlyCovered#");
+
+            Assert.That(matches.Count, Is.EqualTo(1));
+            float gameViewHeight = Handles.GetMainGameViewSize().y;
+            Assert.That(matches[0].SimX, Is.EqualTo(Left + Width * 0.75f).Within(Tolerance));
+            Assert.That(matches[0].SimY, Is.EqualTo(gameViewHeight - (Top + Height) + Height * 0.25f).Within(Tolerance));
+        }
+
+        /// <summary>
+        /// Verifies a button fully covered by a front panel is left out.
+        /// </summary>
+        [UnityTest]
+        public IEnumerator Collect_FrontPanelCoversAll_ShouldExclude()
+        {
+            UIDocument back = CreateDocument("Covered", CreatePanelSettings(0f));
+            AddPlaced(back.rootVisualElement, new Button { name = "target" }, Left, Top, Width, Height);
+            UIDocument front = CreateDocument("CoveredFront", CreatePanelSettings(10f));
+            AddPlaced(front.rootVisualElement, new VisualElement { name = "cover" }, Left, Top, Width, Height);
+            yield return WaitForLayout();
+
+            Assert.That(CollectFrom("Covered#").Count, Is.EqualTo(0));
+        }
+
+        /// <summary>
+        /// Verifies a front panel that renders into a texture still covers a button, because Unity still routes
+        /// screen input to it.
+        /// </summary>
+        [UnityTest]
+        public IEnumerator Collect_FrontTargetTexturePanelCoversAll_ShouldExclude()
+        {
+            UIDocument back = CreateDocument("TextureCovered", CreatePanelSettings(0f));
+            AddPlaced(back.rootVisualElement, new Button { name = "target" }, Left, Top, Width, Height);
+            PanelSettings frontSettings = CreatePanelSettings(10f);
+            frontSettings.targetTexture = CreateScreenSizedTexture();
+            UIDocument front = CreateDocument("TextureCoveredFront", frontSettings);
+            AddPlaced(front.rootVisualElement, new VisualElement { name = "cover" }, Left, Top, Width, Height);
+            yield return WaitForLayout();
+
+            Assert.That(CollectFrom("TextureCovered#").Count, Is.EqualTo(0));
+        }
+
+        /// <summary>
+        /// Verifies panels with the same sorting order do not hide each other's controls, since their real order
+        /// is not public.
+        /// </summary>
+        [UnityTest]
+        public IEnumerator Collect_SameSortingOrderPanelCovers_ShouldKeepBoth()
+        {
+            UIDocument first = CreateDocument("SameOrderFirst", CreatePanelSettings(5f));
+            AddPlaced(first.rootVisualElement, new Button { name = "first" }, Left, Top, Width, Height);
+            UIDocument second = CreateDocument("SameOrderSecond", CreatePanelSettings(5f));
+            AddPlaced(second.rootVisualElement, new Button { name = "second" }, Left, Top, Width, Height);
+            yield return WaitForLayout();
+
+            Assert.That(CollectFrom("SameOrderFirst").Count, Is.EqualTo(1));
+            Assert.That(CollectFrom("SameOrderSecond").Count, Is.EqualTo(1));
+        }
+
+        /// <summary>
+        /// Verifies a button fully covered by a later sibling on the same panel is left out.
+        /// </summary>
+        [UnityTest]
+        public IEnumerator Collect_SiblingCoversAll_ShouldExclude()
+        {
+            UIDocument document = CreateDocument("SiblingCovered", CreatePanelSettings(0f));
+            AddPlaced(document.rootVisualElement, new Button { name = "target" }, Left, Top, Width, Height);
+            AddPlaced(document.rootVisualElement, new VisualElement { name = "cover" }, Left, Top, Width, Height);
+            yield return WaitForLayout();
+
+            Assert.That(CollectFrom("SiblingCovered").Count, Is.EqualTo(0));
+        }
+
+        /// <summary>
+        /// Verifies a button placed entirely outside a parent with hidden overflow is left out, as it is clipped.
+        /// </summary>
+        [UnityTest]
+        public IEnumerator Collect_ButtonOutsideClippingParent_ShouldExclude()
+        {
+            UIDocument document = CreateDocument("Clipped", CreatePanelSettings(0f));
+            VisualElement clip = new VisualElement { name = "clip" };
+            clip.style.overflow = Overflow.Hidden;
+            AddPlaced(document.rootVisualElement, clip, Left, Top, Width, Height);
+            AddPlaced(clip, new Button { name = "target" }, 300f, 0f, Width, Height);
+            yield return WaitForLayout();
+
+            Assert.That(CollectFrom("Clipped").Count, Is.EqualTo(0));
+        }
+
+        /// <summary>
+        /// Verifies a disabled button is left out.
+        /// </summary>
+        [UnityTest]
+        public IEnumerator Collect_DisabledButton_ShouldExclude()
+        {
+            UIDocument document = CreateDocument("Disabled", CreatePanelSettings(0f));
+            Button button = new Button { name = "target" };
+            button.SetEnabled(false);
+            AddPlaced(document.rootVisualElement, button, Left, Top, Width, Height);
+            yield return WaitForLayout();
+
+            Assert.That(CollectFrom("Disabled").Count, Is.EqualTo(0));
+        }
+
+        /// <summary>
+        /// Verifies a button under a display:none ancestor is left out.
+        /// </summary>
+        [UnityTest]
+        public IEnumerator Collect_DisplayNoneAncestor_ShouldExclude()
+        {
+            UIDocument document = CreateDocument("DisplayNone", CreatePanelSettings(0f));
+            VisualElement hiddenParent = new VisualElement { name = "hidden-parent" };
+            AddPlaced(document.rootVisualElement, hiddenParent, Left, Top, Width, Height);
+            hiddenParent.style.display = DisplayStyle.None;
+            AddPlaced(hiddenParent, new Button { name = "target" }, 0f, 0f, Width, Height);
+            yield return WaitForLayout();
+
+            Assert.That(CollectFrom("DisplayNone").Count, Is.EqualTo(0));
+        }
+
+        /// <summary>
+        /// Verifies a button with hidden visibility is left out.
+        /// </summary>
+        [UnityTest]
+        public IEnumerator Collect_HiddenButton_ShouldExclude()
+        {
+            UIDocument document = CreateDocument("Hidden", CreatePanelSettings(0f));
+            Button button = new Button { name = "target" };
+            button.style.visibility = Visibility.Hidden;
+            AddPlaced(document.rootVisualElement, button, Left, Top, Width, Height);
+            yield return WaitForLayout();
+
+            Assert.That(CollectFrom("Hidden").Count, Is.EqualTo(0));
+        }
+
+        /// <summary>
+        /// Verifies a button added in the same frame as the collection is reported with laid-out bounds.
+        /// </summary>
+        [UnityTest]
+        public IEnumerator Collect_ButtonAddedInSameFrame_ShouldReportLaidOutBounds()
+        {
+            UIDocument document = CreateDocument("SameFrame", CreatePanelSettings(0f));
+            yield return WaitForLayout();
+            AddPlaced(document.rootVisualElement, new Button { name = "late" }, Left, Top, Width, Height);
+
+            List<UIElementInfo> matches = CollectFrom("SameFrame");
+
+            Assert.That(matches.Count, Is.EqualTo(1));
+            float gameViewHeight = Handles.GetMainGameViewSize().y;
+            AssertBounds(matches[0], Left, gameViewHeight - (Top + Height), Left + Width, gameViewHeight - Top);
+        }
+
+        /// <summary>
+        /// Verifies a scroll view yields its scroller once, without the slider and buttons inside the scroller.
+        /// </summary>
+        [UnityTest]
+        public IEnumerator Collect_ScrollView_ShouldReportScrollerOnly()
+        {
+            UIDocument document = CreateDocument("Scroll", CreatePanelSettings(0f));
+            ScrollView scrollView = new ScrollView { name = "list" };
+            scrollView.verticalScrollerVisibility = ScrollerVisibility.AlwaysVisible;
+            scrollView.horizontalScrollerVisibility = ScrollerVisibility.Hidden;
+            AddPlaced(document.rootVisualElement, scrollView, Left, Top, Width, 100f);
+            Scroller scroller = scrollView.verticalScroller;
+            SetSize(scroller, 20f, 100f);
+            SetSize(scroller.lowButton, 20f, 20f);
+            SetSize(scroller.highButton, 20f, 20f);
+            SetSize(scroller.slider, 20f, 60f);
+            // The scroll view disables a scroller whose content fits, so the viewport is sized and given
+            // content taller than itself that does not shrink to fit.
+            SetSize(scrollView.contentViewport, 180f, 100f);
+            VisualElement content = new VisualElement { name = "content" };
+            SetSize(content, 180f, 500f);
+            content.style.flexShrink = 0f;
+            scrollView.Add(content);
+            yield return WaitForLayout();
+            Assert.That(scroller.worldBound.width, Is.GreaterThan(0f));
+            Assert.That(scroller.worldBound.height, Is.GreaterThan(0f));
+            Assert.That(scroller.enabledInHierarchy, Is.True);
+
+            List<UIElementInfo> matches = CollectFrom("Scroll");
+
+            Assert.That(matches.Count, Is.EqualTo(1));
+            Assert.That(matches[0].Type, Is.EqualTo("Scrollbar"));
+        }
+
+        /// <summary>
+        /// Verifies controls on a panel that renders into a texture are not listed, as they are not on screen.
+        /// </summary>
+        [UnityTest]
+        public IEnumerator Collect_TargetTexturePanel_ShouldNotListElements()
+        {
+            PanelSettings settings = CreatePanelSettings(0f);
+            settings.targetTexture = CreateScreenSizedTexture();
+            UIDocument document = CreateDocument("Texture", settings);
+            AddPlaced(document.rootVisualElement, new Button { name = "target" }, Left, Top, Width, Height);
+            yield return WaitForLayout();
+
+            Assert.That(CollectFrom("Texture").Count, Is.EqualTo(0));
+        }
+
+        /// <summary>
+        /// Verifies controls on a panel shown on a display other than the Game View's are left out.
+        /// </summary>
+        [UnityTest]
+        public IEnumerator Collect_PanelOnOtherDisplay_ShouldExclude()
+        {
+            PanelSettings settings = CreatePanelSettings(0f);
+            settings.targetDisplay = 1;
+            UIDocument document = CreateDocument("OtherDisplay", settings);
+            AddPlaced(document.rootVisualElement, new Button { name = "target" }, Left, Top, Width, Height);
+            yield return WaitForLayout();
+
+            Assert.That(CollectFrom("OtherDisplay").Count, Is.EqualTo(0));
+        }
+
+        /// <summary>
+        /// Verifies two documents sharing one panel each contribute their button.
+        /// </summary>
+        [UnityTest]
+        public IEnumerator Collect_DocumentsSharingPanel_ShouldReportBoth()
+        {
+            PanelSettings settings = CreatePanelSettings(0f);
+            UIDocument first = CreateDocument("SharedFirst", settings);
+            AddPlaced(first.rootVisualElement, new Button { name = "first" }, Left, Top, Width, Height);
+            UIDocument second = CreateDocument("SharedSecond", settings);
+            AddPlaced(second.rootVisualElement, new Button { name = "second" }, Left, Top + 100f, Width, Height);
+            yield return WaitForLayout();
+
+            Assert.That(CollectFrom("SharedFirst").Count, Is.EqualTo(1));
+            Assert.That(CollectFrom("SharedSecond").Count, Is.EqualTo(1));
+        }
+
+        /// <summary>
+        /// Verifies a button in a nested document is reported once, through the parent document.
+        /// </summary>
+        [UnityTest]
+        public IEnumerator Collect_NestedDocument_ShouldReportOnce()
+        {
+            UIDocument parent = CreateDocument("NestedParent", CreatePanelSettings(0f));
+            GameObject childObject = new GameObject(Prefix + "NestedChild");
+            childObject.SetActive(false);
+            childObject.transform.SetParent(parent.transform, false);
+            UIDocument child = childObject.AddComponent<UIDocument>();
+            childObject.SetActive(true);
+            Assume.That(child.parentUI, Is.EqualTo(parent));
+            AddPlaced(child.rootVisualElement, new Button { name = "nested" }, Left, Top, Width, Height);
+            yield return WaitForLayout();
+
+            List<UIElementInfo> matches = UIElementAnnotator.CollectInteractiveElements()
+                .FindAll(element => element.Name == "nested" && element.UiSystem == "UIToolkit");
+
+            Assert.That(matches.Count, Is.EqualTo(1));
+        }
+
+        private PanelSettings CreatePanelSettings(float sortingOrder)
+        {
+            PanelSettings settings = ScriptableObject.CreateInstance<PanelSettings>();
+            settings.scaleMode = PanelScaleMode.ConstantPixelSize;
+            settings.scale = 1f;
+            settings.sortingOrder = sortingOrder;
+            _createdObjects.Add(settings);
+            return settings;
+        }
+
+        private RenderTexture CreateScreenSizedTexture()
+        {
+            RenderTexture texture = new RenderTexture(Screen.width, Screen.height, 0);
+            _createdObjects.Add(texture);
+            return texture;
+        }
+
+        // The object starts inactive so the document sees its panel settings when it first enables.
+        private UIDocument CreateDocument(string name, PanelSettings settings)
+        {
+            GameObject documentObject = new GameObject(Prefix + name);
+            documentObject.SetActive(false);
+            _createdObjects.Add(documentObject);
+            UIDocument document = documentObject.AddComponent<UIDocument>();
+            document.panelSettings = settings;
+            documentObject.SetActive(true);
+            return document;
+        }
+
+        private static void AddPlaced(VisualElement parent, VisualElement element, float left, float top, float width, float height)
+        {
+            element.style.position = Position.Absolute;
+            element.style.left = left;
+            element.style.top = top;
+            SetSize(element, width, height);
+            parent.Add(element);
+        }
+
+        private static void SetSize(VisualElement element, float width, float height)
+        {
+            element.style.width = width;
+            element.style.height = height;
+        }
+
+        // The root's size is set by the runtime panel update in the player loop, so frames must pass.
+        private static IEnumerator WaitForLayout()
+        {
+            yield return null;
+            yield return null;
+        }
+
+        private static List<UIElementInfo> CollectFrom(string pathStart)
+        {
+            return UIElementAnnotator.CollectInteractiveElements()
+                .FindAll(element => element.UiSystem == "UIToolkit" && element.Path.StartsWith(Prefix + pathStart));
+        }
+
+        private static void AssertBounds(UIElementInfo element, float minX, float minY, float maxX, float maxY)
+        {
+            Assert.That(element.BoundsMinX, Is.EqualTo(minX).Within(Tolerance));
+            Assert.That(element.BoundsMinY, Is.EqualTo(minY).Within(Tolerance));
+            Assert.That(element.BoundsMaxX, Is.EqualTo(maxX).Within(Tolerance));
+            Assert.That(element.BoundsMaxY, Is.EqualTo(maxY).Within(Tolerance));
+        }
+    }
+}
diff --git a/Assets/Tests/PlayMode/UIToolkitElementCollectorTests.cs.meta b/Assets/Tests/PlayMode/UIToolkitElementCollectorTests.cs.meta
new file mode 100644
index 0000000000..e215d8c650
--- /dev/null
+++ b/Assets/Tests/PlayMode/UIToolkitElementCollectorTests.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: c5a92fe9c7ee147ed847b94d82b70eb7
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Tests/PlayMode/UnityCLILoop.Tests.PlayMode.asmdef b/Assets/Tests/PlayMode/UnityCLILoop.Tests.PlayMode.asmdef
index cdfcc32acf..f3c297c562 100644
--- a/Assets/Tests/PlayMode/UnityCLILoop.Tests.PlayMode.asmdef
+++ b/Assets/Tests/PlayMode/UnityCLILoop.Tests.PlayMode.asmdef
@@ -25,7 +25,8 @@
         "GUID:75469ad4d38634e559750d17036d5f7c",
         "GUID:dc04f38471c3a459fb4d31124ee9127d",
         "GUID:6399a27a6ac3945be87994ba344509be",
-        "GUID:96b8d4624fb74ea2849fed17e7ad69d3"
+        "GUID:96b8d4624fb74ea2849fed17e7ad69d3",
+        "GUID:a0bdbd2c5705643fbb9aef9fac8fd46a"
     ],
     "includePlatforms": [],
     "excludePlatforms": [],
diff --git a/Assets/UI Toolkit.meta b/Assets/UI Toolkit.meta
new file mode 100644
index 0000000000..42033ea176
--- /dev/null
+++ b/Assets/UI Toolkit.meta	
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: ff80b66b333234847ac7a9e646a8e968
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UI Toolkit/UnityThemes.meta b/Assets/UI Toolkit/UnityThemes.meta
new file mode 100644
index 0000000000..e10f02e597
--- /dev/null
+++ b/Assets/UI Toolkit/UnityThemes.meta	
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: c4edb96868970486f8c7bb71f2d4a256
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UI Toolkit/UnityThemes/UnityDefaultRuntimeTheme.tss b/Assets/UI Toolkit/UnityThemes/UnityDefaultRuntimeTheme.tss
new file mode 100644
index 0000000000..1056e07ed4
--- /dev/null
+++ b/Assets/UI Toolkit/UnityThemes/UnityDefaultRuntimeTheme.tss	
@@ -0,0 +1 @@
+@import url("unity-theme://default");
\ No newline at end of file
diff --git a/Assets/UI Toolkit/UnityThemes/UnityDefaultRuntimeTheme.tss.meta b/Assets/UI Toolkit/UnityThemes/UnityDefaultRuntimeTheme.tss.meta
new file mode 100644
index 0000000000..706b9eded4
--- /dev/null
+++ b/Assets/UI Toolkit/UnityThemes/UnityDefaultRuntimeTheme.tss.meta	
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 8fd404036dab64fb4bde32641268683b
+ScriptedImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 2
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 12388, guid: 0000000000000000e000000000000000, type: 0}
+  disableValidation: 0
diff --git a/Packages/src/Editor/FirstPartyTools/Screenshot/AnnotatedUiSystem.cs b/Packages/src/Editor/FirstPartyTools/Screenshot/AnnotatedUiSystem.cs
new file mode 100644
index 0000000000..46b643c218
--- /dev/null
+++ b/Packages/src/Editor/FirstPartyTools/Screenshot/AnnotatedUiSystem.cs
@@ -0,0 +1,12 @@
+namespace io.github.hatayama.UnityCliLoop.FirstPartyTools
+{
+    /// <summary>
+    /// Names the UI system an annotated element came from, as reported in its UiSystem field.
+    /// PhysicsCollider elements leave the field empty.
+    /// </summary>
+    internal static class AnnotatedUiSystem
+    {
+        internal const string UGUI = "UGUI";
+        internal const string UIToolkit = "UIToolkit";
+    }
+}
diff --git a/Packages/src/Editor/FirstPartyTools/Screenshot/AnnotatedUiSystem.cs.meta b/Packages/src/Editor/FirstPartyTools/Screenshot/AnnotatedUiSystem.cs.meta
new file mode 100644
index 0000000000..fc215410cb
--- /dev/null
+++ b/Packages/src/Editor/FirstPartyTools/Screenshot/AnnotatedUiSystem.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 25798f40df86a4947a007d2e6aa078ff
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Packages/src/Editor/FirstPartyTools/Screenshot/UIElementAnnotator.cs b/Packages/src/Editor/FirstPartyTools/Screenshot/UIElementAnnotator.cs
index a9df153057..fdf2bcf9c7 100644
--- a/Packages/src/Editor/FirstPartyTools/Screenshot/UIElementAnnotator.cs
+++ b/Packages/src/Editor/FirstPartyTools/Screenshot/UIElementAnnotator.cs
@@ -28,6 +28,7 @@ public static List<UIElementInfo> CollectInteractiveElements()
 
             CollectSelectables(elements, processedObjects, raycastContext);
             CollectEventHandlers(elements, processedObjects, raycastContext);
+            UIToolkitElementCollector.Collect(elements, GameViewCoordinateUtility.GetMainGameViewSize().y);
 
             return elements;
         }
@@ -232,6 +233,7 @@ private static void AddElementInfo(
                 Path = GameObjectPathUtility.GetFullPath(go),
                 Type = type,
                 Interaction = GetInteractionForType(type),
+                UiSystem = AnnotatedUiSystem.UGUI,
                 SimX = reachablePoint.x,
                 SimY = reachablePoint.y,
                 BoundsMinX = minX,
diff --git a/Packages/src/Editor/FirstPartyTools/Screenshot/UIToolkitAnnotation.meta b/Packages/src/Editor/FirstPartyTools/Screenshot/UIToolkitAnnotation.meta
new file mode 100644
index 0000000000..b252252608
--- /dev/null
+++ b/Packages/src/Editor/FirstPartyTools/Screenshot/UIToolkitAnnotation.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 8160ff1211a254c57833ac2648e53298
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Packages/src/Editor/FirstPartyTools/Screenshot/UIToolkitAnnotation/UIToolkitElementClassifier.cs b/Packages/src/Editor/FirstPartyTools/Screenshot/UIToolkitAnnotation/UIToolkitElementClassifier.cs
new file mode 100644
index 0000000000..10f2d19f36
--- /dev/null
+++ b/Packages/src/Editor/FirstPartyTools/Screenshot/UIToolkitAnnotation/UIToolkitElementClassifier.cs
@@ -0,0 +1,48 @@
+#nullable enable
+using UnityEngine.UIElements;
+
+namespace io.github.hatayama.UnityCliLoop.FirstPartyTools
+{
+    /// <summary>
+    /// Decides which UI Toolkit controls are annotated and names each with the uGUI type word, so the same
+    /// interaction mapping applies to both UI systems.
+    /// </summary>
+    internal static class UIToolkitElementClassifier
+    {
+        // Returns null for elements that are not annotated, including plain elements with a Clickable attached.
+        internal static string? Classify(VisualElement element)
+        {
+            if (element is Button || element is RepeatButton)
+            {
+                return "Button";
+            }
+
+            if (element is BaseBoolField)
+            {
+                return "Toggle";
+            }
+
+            if (element is Scroller)
+            {
+                return "Scrollbar";
+            }
+
+            if (element is Slider || element is SliderInt || element is MinMaxSlider)
+            {
+                return "Slider";
+            }
+
+            if (element is TextField)
+            {
+                return "InputField";
+            }
+
+            if (element is DropdownField || element is EnumField)
+            {
+                return "Dropdown";
+            }
+
+            return null;
+        }
+    }
+}
diff --git a/Packages/src/Editor/FirstPartyTools/Screenshot/UIToolkitAnnotation/UIToolkitElementClassifier.cs.meta b/Packages/src/Editor/FirstPartyTools/Screenshot/UIToolkitAnnotation/UIToolkitElementClassifier.cs.meta
new file mode 100644
index 0000000000..9b30de3466
--- /dev/null
+++ b/Packages/src/Editor/FirstPartyTools/Screenshot/UIToolkitAnnotation/UIToolkitElementClassifier.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: cedc9b792f5dd4f4b9f0da55a580eb42
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Packages/src/Editor/FirstPartyTools/Screenshot/UIToolkitAnnotation/UIToolkitElementCollector.cs b/Packages/src/Editor/FirstPartyTools/Screenshot/UIToolkitAnnotation/UIToolkitElementCollector.cs
new file mode 100644
index 0000000000..86fe5059b9
--- /dev/null
+++ b/Packages/src/Editor/FirstPartyTools/Screenshot/UIToolkitAnnotation/UIToolkitElementCollector.cs
@@ -0,0 +1,324 @@
+#nullable enable
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEngine;
+using UnityEngine.UIElements;
+
+using io.github.hatayama.UnityCliLoop.ToolContracts;
+
+namespace io.github.hatayama.UnityCliLoop.FirstPartyTools
+{
+    /// <summary>
+    /// Collects the interactive controls of the screen-space UI Toolkit panels shown in the Game View, in the
+    /// same shape and bottom-left screen coordinates as the uGUI annotator, skipping controls that pointer input
+    /// at the screenshot's point of view could not reach.
+    /// </summary>
+    internal static class UIToolkitElementCollector
+    {
+        private const char PATH_SEPARATOR = '#';
+        private const string CHAIN_SEPARATOR = "/";
+
+        internal static void Collect(List<UIElementInfo> elements, float gameViewHeight)
+        {
+            List<PanelEntry> panels = GatherPanels();
+
+            // worldBound and visualTree.layout are only settled once the panel validates its layout, and Pick is
+            // the only public call that does so. Every panel is settled, including those used only to decide
+            // what covers what, because PickInPanel reads their layout too.
+            foreach (PanelEntry entry in panels)
+            {
+                entry.Panel.Pick(Vector2.zero);
+            }
+
+            foreach (PanelEntry entry in panels)
+            {
+                if (entry.Mapping == null)
+                {
+                    continue;
+                }
+
+                VisitContext context = new VisitContext(
+                    gameViewHeight,
+                    entry,
+                    entry.Mapping,
+                    CreateFrontPickers(panels, entry),
+                    point => PickInPanel(entry.Panel, point),
+                    elements);
+                foreach (UIDocument document in entry.Documents)
+                {
+                    Visit(document.rootVisualElement, document, context);
+                }
+            }
+        }
+
+        private static List<PanelEntry> GatherPanels()
+        {
+#if UNITY_6000_4_OR_NEWER
+            UIDocument[] documents = UnityEngine.Object.FindObjectsByType<UIDocument>();
+#else
+            UIDocument[] documents = UnityEngine.Object.FindObjectsOfType<UIDocument>();
+#endif
+            List<PanelEntry> panels = new List<PanelEntry>();
+            foreach (UIDocument document in documents)
+            {
+                IPanel? panel = GetScreenSpacePanelShownInGameView(document);
+                if (panel == null)
+                {
+                    continue;
+                }
+
+                PanelEntry? entry = panels.Find(candidate => candidate.Panel == panel);
+                if (entry == null)
+                {
+                    entry = CreatePanelEntry(panel, document.panelSettings);
+                    panels.Add(entry);
+                }
+
+                entry.Documents.Add(document);
+            }
+
+            return panels;
+        }
+
+        // Returns null for documents that contribute nothing: their panel neither shows in the Game View nor
+        // takes input there, or they are nested and reached through their parent document's root.
+        private static IPanel? GetScreenSpacePanelShownInGameView(UIDocument document)
+        {
+            if (!document.isActiveAndEnabled || document.parentUI != null)
+            {
+                return null;
+            }
+
+            PanelSettings settings = document.panelSettings;
+            VisualElement root = document.rootVisualElement;
+            if (settings == null || root == null || root.panel == null)
+            {
+                return null;
+            }
+
+            if (settings.targetDisplay != Display.activeEditorGameViewTarget)
+            {
+                return null;
+            }
+
+            // World-space panels do not cover overlay controls and their elements have no screen rectangle.
+            if (UIToolkitPanelKind.IsWorldSpace(settings))
+            {
+                return null;
+            }
+
+            return root.panel;
+        }
+
+        // A panel that renders into a texture still takes screen input, so it stays as a cover candidate, but
+        // its controls are not on the screenshot and get no mapping.
+        private static PanelEntry CreatePanelEntry(IPanel panel, PanelSettings settings)
+        {
+            UIToolkitScreenMapping? mapping = settings.targetTexture == null
+                ? UIToolkitScreenMapping.TryCreate(screen => RuntimePanelUtils.ScreenToPanel(panel, screen))
+                : null;
+            return new PanelEntry(panel, settings.sortingOrder, mapping);
+        }
+
+        // Panels with the same sorting order are not treated as covering each other: Unity breaks that tie by
+        // creation order, which is not public.
+        private static List<Func<Vector2, VisualElement?>> CreateFrontPickers(List<PanelEntry> panels, PanelEntry entry)
+        {
+            return panels
+                .Where(other => other.SortingOrder > entry.SortingOrder)
+                .OrderByDescending(other => other.SortingOrder)
+                .Select(other => (Func<Vector2, VisualElement?>)(point => PickInPanel(other.Panel, point)))
+                .ToList();
+        }
+
+        // Uses the forward screen-to-panel function Unity applies to input, so the result matches where input
+        // goes even for panels whose function cannot be inverted.
+        private static VisualElement? PickInPanel(IPanel panel, Vector2 screenTopLeftPoint)
+        {
+            Vector2 panelPoint = RuntimePanelUtils.ScreenToPanel(panel, screenTopLeftPoint);
+            if (!panel.visualTree.layout.Contains(panelPoint))
+            {
+                return null;
+            }
+
+            return panel.Pick(panelPoint);
+        }
+
+        private static void Visit(VisualElement element, UIDocument document, VisitContext context)
+        {
+            // A child can still resolve to Flex under a display:none parent, so the whole subtree stops here.
+            if (element.resolvedStyle.display == DisplayStyle.None)
+            {
+                return;
+            }
+
+            string? type = UIToolkitElementClassifier.Classify(element);
+            if (type != null)
+            {
+                TryAdd(element, type, document, context);
+
+                // The parts inside a control (the slider and buttons of a Scroller, for example) are not
+                // separate controls.
+                return;
+            }
+
+            // hierarchy, not Children(): Children() lists only the content container, which hides a
+            // ScrollView's scrollers.
+            for (int index = 0; index < element.hierarchy.childCount; index++)
+            {
+                Visit(element.hierarchy[index], document, context);
+            }
+        }
+
+        private static void TryAdd(VisualElement element, string type, UIDocument document, VisitContext context)
+        {
+            if (!element.enabledInHierarchy || element.resolvedStyle.visibility == Visibility.Hidden)
+            {
+                return;
+            }
+
+            Rect worldBound = element.worldBound;
+            if (!IsFiniteNonEmpty(worldBound))
+            {
+                return;
+            }
+
+            // Not Screen.height: uloop commands run outside the player loop, where Screen reports the size of the
+            // last Editor view drawn. ConvertToSimCoordinates flips the result back with the Game View height, so
+            // the same height is used here.
+            float gameViewHeight = context.GameViewHeight;
+            Vector2 topLeftMin = context.Mapping.PanelToScreenTopLeft(new Vector2(worldBound.xMin, worldBound.yMin));
+            Vector2 topLeftMax = context.Mapping.PanelToScreenTopLeft(new Vector2(worldBound.xMax, worldBound.yMax));
+            Rect bottomLeftBounds = Rect.MinMaxRect(
+                topLeftMin.x,
+                gameViewHeight - topLeftMax.y,
+                topLeftMax.x,
+                gameViewHeight - topLeftMin.y);
+
+            Vector2? reachable = FindReachablePoint(element, bottomLeftBounds, gameViewHeight, context);
+            if (reachable == null)
+            {
+                return;
+            }
+
+            context.Elements.Add(CreateElementInfo(
+                element, type, document, context.Entry, bottomLeftBounds, new Vector2(reachable.Value.x, gameViewHeight - reachable.Value.y)));
+        }
+
+        // Probes the same points as the uGUI annotator, converted to the top-left origin panels take input in.
+        private static Vector2? FindReachablePoint(
+            VisualElement element, Rect bottomLeftBounds, float gameViewHeight, VisitContext context)
+        {
+            Vector2[] bottomLeftProbes = UIElementAnnotator.GenerateReachabilityProbePoints(
+                bottomLeftBounds.xMin, bottomLeftBounds.yMin, bottomLeftBounds.xMax, bottomLeftBounds.yMax);
+            Vector2[] topLeftProbes = bottomLeftProbes
+                .Select(probe => new Vector2(probe.x, gameViewHeight - probe.y))
+                .ToArray();
+            return UIToolkitReachabilityProbe.FindReachablePoint(
+                topLeftProbes, element, context.FrontPickers, context.OwnPicker);
+        }
+
+        private static UIElementInfo CreateElementInfo(
+            VisualElement element,
+            string type,
+            UIDocument document,
+            PanelEntry entry,
+            Rect bottomLeftBounds,
+            Vector2 bottomLeftPoint)
+        {
+            VisualElement? parent = element.hierarchy.parent;
+            return new UIElementInfo
+            {
+                Name = GetDisplayName(element),
+                Path = GameObjectPathUtility.GetFullPath(document.gameObject) + PATH_SEPARATOR
+                    + BuildElementChain(document.rootVisualElement, element),
+                Type = type,
+                Interaction = UIElementAnnotationStyling.GetInteractionForType(type),
+                UiSystem = AnnotatedUiSystem.UIToolkit,
+                SimX = bottomLeftPoint.x,
+                SimY = bottomLeftPoint.y,
+                BoundsMinX = bottomLeftBounds.xMin,
+                BoundsMinY = bottomLeftBounds.yMin,
+                BoundsMaxX = bottomLeftBounds.xMax,
+                BoundsMaxY = bottomLeftBounds.yMax,
+                SortingOrder = Mathf.FloorToInt(entry.SortingOrder),
+                SiblingIndex = parent == null ? 0 : parent.hierarchy.IndexOf(element)
+            };
+        }
+
+        // Lists the elements from just below the document root down to the element, so the root itself, which
+        // has no name of its own, is left out.
+        private static string BuildElementChain(VisualElement root, VisualElement element)
+        {
+            List<string> segments = new List<string>();
+            VisualElement? current = element;
+            while (current != null && current != root)
+            {
+                segments.Add(GetDisplayName(current));
+                current = current.hierarchy.parent;
+            }
+
+            segments.Reverse();
+            return string.Join(CHAIN_SEPARATOR, segments);
+        }
+
+        private static string GetDisplayName(VisualElement element)
+        {
+            return string.IsNullOrEmpty(element.name) ? element.GetType().Name : element.name;
+        }
+
+        private static bool IsFiniteNonEmpty(Rect rect)
+        {
+            return float.IsFinite(rect.x)
+                && float.IsFinite(rect.y)
+                && float.IsFinite(rect.width)
+                && float.IsFinite(rect.height)
+                && rect.width > 0f
+                && rect.height > 0f;
+        }
+
+        private sealed class PanelEntry
+        {
+            internal PanelEntry(IPanel panel, float sortingOrder, UIToolkitScreenMapping? mapping)
+            {
+                Panel = panel;
+                SortingOrder = sortingOrder;
+                Mapping = mapping;
+            }
+
+            internal IPanel Panel { get; }
+            internal float SortingOrder { get; }
+
+            // Null when the panel's controls cannot be placed on the screenshot; the panel still covers others.
+            internal UIToolkitScreenMapping? Mapping { get; }
+            internal List<UIDocument> Documents { get; } = new List<UIDocument>();
+        }
+
+        private sealed class VisitContext
+        {
+            internal VisitContext(
+                float gameViewHeight,
+                PanelEntry entry,
+                UIToolkitScreenMapping mapping,
+                List<Func<Vector2, VisualElement?>> frontPickers,
+                Func<Vector2, VisualElement?> ownPicker,
+                List<UIElementInfo> elements)
+            {
+                GameViewHeight = gameViewHeight;
+                Entry = entry;
+                Mapping = mapping;
+                FrontPickers = frontPickers;
+                OwnPicker = ownPicker;
+                Elements = elements;
+            }
+
+            internal float GameViewHeight { get; }
+            internal PanelEntry Entry { get; }
+            internal UIToolkitScreenMapping Mapping { get; }
+            internal List<Func<Vector2, VisualElement?>> FrontPickers { get; }
+            internal Func<Vector2, VisualElement?> OwnPicker { get; }
+            internal List<UIElementInfo> Elements { get; }
+        }
+    }
+}
diff --git a/Packages/src/Editor/FirstPartyTools/Screenshot/UIToolkitAnnotation/UIToolkitElementCollector.cs.meta b/Packages/src/Editor/FirstPartyTools/Screenshot/UIToolkitAnnotation/UIToolkitElementCollector.cs.meta
new file mode 100644
index 0000000000..5cc40bc1da
--- /dev/null
+++ b/Packages/src/Editor/FirstPartyTools/Screenshot/UIToolkitAnnotation/UIToolkitElementCollector.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 414253f944a124db985aa97015a7fe9b
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Packages/src/Editor/FirstPartyTools/Screenshot/UIToolkitAnnotation/UIToolkitPanelKind.cs b/Packages/src/Editor/FirstPartyTools/Screenshot/UIToolkitAnnotation/UIToolkitPanelKind.cs
new file mode 100644
index 0000000000..e1c26e1e7b
--- /dev/null
+++ b/Packages/src/Editor/FirstPartyTools/Screenshot/UIToolkitAnnotation/UIToolkitPanelKind.cs
@@ -0,0 +1,39 @@
+#nullable enable
+using System.Reflection;
+using UnityEngine.UIElements;
+
+namespace io.github.hatayama.UnityCliLoop.FirstPartyTools
+{
+    /// <summary>
+    /// Tells world-space UI Toolkit panels apart from screen-space ones.
+    /// </summary>
+    internal static class UIToolkitPanelKind
+    {
+        private const string RENDER_MODE_PROPERTY = "renderMode";
+        private const string WORLD_SPACE = "WorldSpace";
+
+        // Reflection because renderMode is internal from 6000.0 to 6000.3.10 and public from 6000.3.11, and
+        // version defines cannot tell patch versions apart. 2022.3 has no such property and no world-space panels.
+        internal static bool IsWorldSpace(PanelSettings settings)
+        {
+            return HasWorldSpaceRenderMode(settings);
+        }
+
+        // Takes any object and looks the property up on its runtime type so tests can check the lookup and the
+        // comparison with stand-in types: the project's Unity has no renderMode, and CI's Unity 6 legs skip
+        // these tests.
+        internal static bool HasWorldSpaceRenderMode(object settings)
+        {
+            PropertyInfo? property = settings.GetType().GetProperty(
+                RENDER_MODE_PROPERTY,
+                BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
+            if (property == null)
+            {
+                return false;
+            }
+
+            object? value = property.GetValue(settings);
+            return value != null && value.ToString() == WORLD_SPACE;
+        }
+    }
+}
diff --git a/Packages/src/Editor/FirstPartyTools/Screenshot/UIToolkitAnnotation/UIToolkitPanelKind.cs.meta b/Packages/src/Editor/FirstPartyTools/Screenshot/UIToolkitAnnotation/UIToolkitPanelKind.cs.meta
new file mode 100644
index 0000000000..caa04a2fa9
--- /dev/null
+++ b/Packages/src/Editor/FirstPartyTools/Screenshot/UIToolkitAnnotation/UIToolkitPanelKind.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 3cac754bfe0ef4a7594c5d923d6e9e69
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Packages/src/Editor/FirstPartyTools/Screenshot/UIToolkitAnnotation/UIToolkitReachabilityProbe.cs b/Packages/src/Editor/FirstPartyTools/Screenshot/UIToolkitAnnotation/UIToolkitReachabilityProbe.cs
new file mode 100644
index 0000000000..bb752638dd
--- /dev/null
+++ b/Packages/src/Editor/FirstPartyTools/Screenshot/UIToolkitAnnotation/UIToolkitReachabilityProbe.cs
@@ -0,0 +1,76 @@
+#nullable enable
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.UIElements;
+
+namespace io.github.hatayama.UnityCliLoop.FirstPartyTools
+{
+    /// <summary>
+    /// Finds the first probe point at which pointer input would reach a UI Toolkit element, following the order
+    /// Unity routes input: panels in front first, then the element's own panel.
+    /// </summary>
+    internal static class UIToolkitReachabilityProbe
+    {
+        // Probe points and pickers use top-left screen coordinates. Front pickers are ordered front to back and
+        // return null where their panel would not take the input.
+        internal static Vector2? FindReachablePoint(
+            IReadOnlyList<Vector2> probePoints,
+            VisualElement target,
+            IReadOnlyList<Func<Vector2, VisualElement?>> frontPanelPickers,
+            Func<Vector2, VisualElement?> ownPanelPicker)
+        {
+            foreach (Vector2 point in probePoints)
+            {
+                // Unity hands the input to the first panel that picks anything, so a front panel takes it even
+                // when the element it picks is unrelated to the target.
+                if (IsCoveredByFrontPanel(point, frontPanelPickers))
+                {
+                    continue;
+                }
+
+                VisualElement? picked = ownPanelPicker(point);
+                if (picked == null)
+                {
+                    continue;
+                }
+
+                if (picked == target || IsDescendantOf(picked, target))
+                {
+                    return point;
+                }
+            }
+
+            return null;
+        }
+
+        private static bool IsCoveredByFrontPanel(Vector2 point, IReadOnlyList<Func<Vector2, VisualElement?>> pickers)
+        {
+            foreach (Func<Vector2, VisualElement?> picker in pickers)
+            {
+                if (picker(point) != null)
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        private static bool IsDescendantOf(VisualElement element, VisualElement ancestor)
+        {
+            VisualElement? current = element.hierarchy.parent;
+            while (current != null)
+            {
+                if (current == ancestor)
+                {
+                    return true;
+                }
+
+                current = current.hierarchy.parent;
+            }
+
+            return false;
+        }
+    }
+}
diff --git a/Packages/src/Editor/FirstPartyTools/Screenshot/UIToolkitAnnotation/UIToolkitReachabilityProbe.cs.meta b/Packages/src/Editor/FirstPartyTools/Screenshot/UIToolkitAnnotation/UIToolkitReachabilityProbe.cs.meta
new file mode 100644
index 0000000000..7ca6699022
--- /dev/null
+++ b/Packages/src/Editor/FirstPartyTools/Screenshot/UIToolkitAnnotation/UIToolkitReachabilityProbe.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 61ddc0512db654cc5a27dac9f3d9667d
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Packages/src/Editor/FirstPartyTools/Screenshot/UIToolkitAnnotation/UIToolkitScreenMapping.cs b/Packages/src/Editor/FirstPartyTools/Screenshot/UIToolkitAnnotation/UIToolkitScreenMapping.cs
new file mode 100644
index 0000000000..b0a2c3bc26
--- /dev/null
+++ b/Packages/src/Editor/FirstPartyTools/Screenshot/UIToolkitAnnotation/UIToolkitScreenMapping.cs
@@ -0,0 +1,82 @@
+#nullable enable
+using System;
+using UnityEngine;
+
+namespace io.github.hatayama.UnityCliLoop.FirstPartyTools
+{
+    /// <summary>
+    /// Inverts a panel's screen-to-panel function so panel-space rectangles can be reported in screen pixels.
+    /// Only functions that scale and offset each axis independently can be inverted.
+    /// </summary>
+    internal sealed class UIToolkitScreenMapping
+    {
+        private const float SAMPLE = 1000f;
+        private const float PROBE_X_RATIO = 0.37f;
+        private const float PROBE_Y_RATIO = 0.61f;
+        private const float MIN_SCALE = 1e-6f;
+        private const float LINEARITY_TOLERANCE = 0.01f;
+
+        private readonly Vector2 _origin;
+        private readonly float _scaleX;
+        private readonly float _scaleY;
+
+        private UIToolkitScreenMapping(Vector2 origin, float scaleX, float scaleY)
+        {
+            _origin = origin;
+            _scaleX = scaleX;
+            _scaleY = scaleY;
+        }
+
+        // Unity offers no panel-to-screen API, and a panel may replace the screen-to-panel function with any
+        // function, so the inverse is derived by sampling it. Returns null when the function is not invertible
+        // per axis (non-linear, sheared, rotated, swapped, mirrored, or non-finite), because no screen rectangle would
+        // then match what is drawn.
+        internal static UIToolkitScreenMapping? TryCreate(Func<Vector2, Vector2> screenTopLeftToPanel)
+        {
+            if (screenTopLeftToPanel == null)
+            {
+                throw new ArgumentNullException(nameof(screenTopLeftToPanel));
+            }
+
+            Vector2 origin = screenTopLeftToPanel(Vector2.zero);
+            Vector2 unitX = screenTopLeftToPanel(new Vector2(SAMPLE, 0f));
+            Vector2 unitY = screenTopLeftToPanel(new Vector2(0f, SAMPLE));
+            Vector2 probe = new Vector2(SAMPLE * PROBE_X_RATIO, SAMPLE * PROBE_Y_RATIO);
+            Vector2 check = screenTopLeftToPanel(probe);
+            if (!IsFinite(origin) || !IsFinite(unitX) || !IsFinite(unitY) || !IsFinite(check))
+            {
+                return null;
+            }
+
+            float scaleX = (unitX.x - origin.x) / SAMPLE;
+            float scaleY = (unitY.y - origin.y) / SAMPLE;
+            // A mirrored axis (negative scale) is rejected too: its inverse would swap the bounds' minimum and
+            // maximum.
+            if (scaleX < MIN_SCALE || scaleY < MIN_SCALE)
+            {
+                return null;
+            }
+
+            // Shear and rotation put part of one axis into the other, so the fourth point misses the
+            // per-axis prediction; no dedicated check is needed for them.
+            Vector2 predicted = new Vector2(origin.x + scaleX * probe.x, origin.y + scaleY * probe.y);
+            if (Mathf.Abs(predicted.x - check.x) > LINEARITY_TOLERANCE
+                || Mathf.Abs(predicted.y - check.y) > LINEARITY_TOLERANCE)
+            {
+                return null;
+            }
+
+            return new UIToolkitScreenMapping(origin, scaleX, scaleY);
+        }
+
+        internal Vector2 PanelToScreenTopLeft(Vector2 panelPoint)
+        {
+            return new Vector2((panelPoint.x - _origin.x) / _scaleX, (panelPoint.y - _origin.y) / _scaleY);
+        }
+
+        private static bool IsFinite(Vector2 value)
+        {
+            return float.IsFinite(value.x) && float.IsFinite(value.y);
+        }
+    }
+}
diff --git a/Packages/src/Editor/FirstPartyTools/Screenshot/UIToolkitAnnotation/UIToolkitScreenMapping.cs.meta b/Packages/src/Editor/FirstPartyTools/Screenshot/UIToolkitAnnotation/UIToolkitScreenMapping.cs.meta
new file mode 100644
index 0000000000..be24fbd80d
--- /dev/null
+++ b/Packages/src/Editor/FirstPartyTools/Screenshot/UIToolkitAnnotation/UIToolkitScreenMapping.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: c3cb533b060034c128ee04f6dd5a02f5
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Packages/src/Editor/ToolContracts/UIElementInfo.cs b/Packages/src/Editor/ToolContracts/UIElementInfo.cs
index 1516b528eb..4ff4e42da3 100644
--- a/Packages/src/Editor/ToolContracts/UIElementInfo.cs
+++ b/Packages/src/Editor/ToolContracts/UIElementInfo.cs
@@ -11,6 +11,7 @@ public class UIElementInfo
         public string Path { get; set; } = "";
         public string Type { get; set; } = "";
         public string Interaction { get; set; } = "";
+        public string UiSystem { get; set; } = "";
         public string Layer { get; set; } = "";
         public List<string> Components { get; set; } = new List<string>();
         public float SimX { get; set; }

From 33457e47cf4dac8ab4c8e325fb4fa75487230b8a Mon Sep 17 00:00:00 2001
From: Masamichi Hatayama <booqle@gmail.com>
Date: Tue, 13 Oct 2026 21:59:41 +0900
Subject: [PATCH 2/5] chore: Add an end-to-end check and docs for UI Toolkit
 screenshot annotation (#3309)

---
 .agents/skills/uloop-screenshot/SKILL.md      |   2 +-
 .../references/annotated-elements.md          |  34 +-
 .../uloop-simulate-mouse-input/SKILL.md       |   2 +-
 .../references/output-and-coordinates.md      |   2 +-
 .../skills/uloop-simulate-mouse-ui/SKILL.md   |   1 +
 .../references/output.md                      |   4 +
 .claude/skills/uloop-screenshot/SKILL.md      |   2 +-
 .../references/annotated-elements.md          |  34 +-
 .../uloop-simulate-mouse-input/SKILL.md       |   2 +-
 .../references/output-and-coordinates.md      |   2 +-
 .../skills/uloop-simulate-mouse-ui/SKILL.md   |   1 +
 .../references/output.md                      |   4 +
 .github/workflows/build-and-test.yml          |   1 +
 .../Scenes/UIToolkitAnnotationDemoScene.unity | 740 ++++++++++++++++++
 .../UIToolkitAnnotationDemoScene.unity.meta   |   7 +
 .../UIToolkitAnnotationDemoSceneBuilder.cs    | 142 ++++
 ...IToolkitAnnotationDemoSceneBuilder.cs.meta |  11 +
 Assets/Tests/Demo/UIToolkitAnnotation.meta    |   8 +
 .../UIToolkitAnnotationDemoBackPanel.asset    |  38 +
 ...IToolkitAnnotationDemoBackPanel.asset.meta |   8 +
 .../UIToolkitAnnotationDemoFrontPanel.asset   |  38 +
 ...ToolkitAnnotationDemoFrontPanel.asset.meta |   8 +
 Assets/Tests/Demo/UIToolkitAnnotationDemo.cs  |  93 +++
 .../Demo/UIToolkitAnnotationDemo.cs.meta      |  11 +
 Packages/src/Documentation~/tools.md          |   2 +-
 Packages/src/Documentation~/tools_ja.md       |   2 +-
 .../FirstPartyTools/Screenshot/Skill/SKILL.md |   2 +-
 .../Skill/references/annotated-elements.md    |  34 +-
 .../SimulateMouseInput/Skill/SKILL.md         |   2 +-
 .../references/output-and-coordinates.md      |   2 +-
 .../SimulateMouseUi/Skill/SKILL.md            |   1 +
 .../Skill/references/output.md                |   4 +
 cli/common/tools/default-tools.json           |   2 +-
 scripts/run-posix-e2e.sh                      |  12 +
 scripts/run-windows-e2e.ps1                   |   6 +
 ...-powershell51-native-argument-escaping.ps1 |   1 +
 .../test-screenshot-uitoolkit-annotation.ps1  | 477 +++++++++++
 .../test-screenshot-uitoolkit-annotation.sh   | 343 ++++++++
 38 files changed, 2064 insertions(+), 21 deletions(-)
 create mode 100644 Assets/Scenes/UIToolkitAnnotationDemoScene.unity
 create mode 100644 Assets/Scenes/UIToolkitAnnotationDemoScene.unity.meta
 create mode 100644 Assets/Tests/Demo/Editor/UIToolkitAnnotationDemoSceneBuilder.cs
 create mode 100644 Assets/Tests/Demo/Editor/UIToolkitAnnotationDemoSceneBuilder.cs.meta
 create mode 100644 Assets/Tests/Demo/UIToolkitAnnotation.meta
 create mode 100644 Assets/Tests/Demo/UIToolkitAnnotation/UIToolkitAnnotationDemoBackPanel.asset
 create mode 100644 Assets/Tests/Demo/UIToolkitAnnotation/UIToolkitAnnotationDemoBackPanel.asset.meta
 create mode 100644 Assets/Tests/Demo/UIToolkitAnnotation/UIToolkitAnnotationDemoFrontPanel.asset
 create mode 100644 Assets/Tests/Demo/UIToolkitAnnotation/UIToolkitAnnotationDemoFrontPanel.asset.meta
 create mode 100644 Assets/Tests/Demo/UIToolkitAnnotationDemo.cs
 create mode 100644 Assets/Tests/Demo/UIToolkitAnnotationDemo.cs.meta
 create mode 100644 scripts/test-screenshot-uitoolkit-annotation.ps1
 create mode 100755 scripts/test-screenshot-uitoolkit-annotation.sh

diff --git a/.agents/skills/uloop-screenshot/SKILL.md b/.agents/skills/uloop-screenshot/SKILL.md
index 422a7ec90f..116b4af479 100644
--- a/.agents/skills/uloop-screenshot/SKILL.md
+++ b/.agents/skills/uloop-screenshot/SKILL.md
@@ -23,7 +23,7 @@ uloop screenshot [--window-name <name>] [--resolution-scale <scale>] [--match-mo
 | `--match-mode` | enum | `exact` | Window name matching mode: `exact`, `prefix`, or `contains`. Ignored when the resolved capture mode is rendering (auto during Play Mode resolves to rendering). |
 | `--capture-mode` | enum | `auto` | `auto` - rendering in PlayMode and window otherwise, `window` - capture EditorWindow including toolbar, `rendering` - capture game rendering only (PlayMode required), `GameView` - alias for `rendering`. Rendering screenshots return `ScreenshotToInputFormula` for converting raw image pixels before calling simulate-mouse-input (including `--dry-run`) or simulate-mouse-ui. |
 | `--output-directory` | string | `""` | Output directory path for saving screenshots. When empty, uses default path (.uloop/outputs/Screenshots/). Accepts absolute paths. |
-| `--annotate-elements` | flag | - | Annotate interactive UI elements with index labels and interaction hints (A / CLICK, B / DRAG, ...). The response includes an `AnnotatedElements` array with element metadata sorted by `SortingOrder` then `SiblingIndex` (an approximation of z-order, not the guaranteed draw order). Only works when the resolved capture mode is rendering (auto during Play Mode resolves to rendering) in PlayMode. |
+| `--annotate-elements` | flag | - | Annotate interactive uGUI elements and UI Toolkit controls on screen-space panels with index labels and interaction hints (A / CLICK, B / DRAG, ...). The response includes an `AnnotatedElements` array with element metadata sorted by `SortingOrder` then `SiblingIndex` (an approximation of z-order, not the guaranteed draw order). Only works when the resolved capture mode is rendering (auto during Play Mode resolves to rendering) in PlayMode. |
 | `--annotate-raycast-grid` | flag | - | Annotate clustered 3D physics collider candidates as `PhysicsCollider` entries in `AnnotatedElements`. Uses `Camera.main` visibility and the same top-left Game View coordinates as `simulate-mouse-input`. Only works when the resolved capture mode is rendering (auto during Play Mode resolves to rendering) in PlayMode. |
 | `--raycast-layer-mask` | string | `""` | Comma-separated physics layer names to narrow which layers `--annotate-raycast-grid` clusters. Hits are limited to layers also visible to `Camera.main.cullingMask`. When omitted, clusters against `Physics.DefaultRaycastLayers`. |
 | `--elements-only` | flag | - | Return only annotated element JSON without capturing a screenshot image. Requires `--annotate-elements` or `--annotate-raycast-grid`, and the resolved capture mode to be rendering (auto during Play Mode resolves to rendering) in PlayMode. |
diff --git a/.agents/skills/uloop-screenshot/references/annotated-elements.md b/.agents/skills/uloop-screenshot/references/annotated-elements.md
index 1ef3f771da..5e1338e01d 100644
--- a/.agents/skills/uloop-screenshot/references/annotated-elements.md
+++ b/.agents/skills/uloop-screenshot/references/annotated-elements.md
@@ -10,15 +10,16 @@ Device Simulator is supported for this flow: prefer `--capture-mode rendering` (
 
 - `Label`: Index label in JSON (`A` = first in that sort, `B` = next, ...). Treat it as a stable handle, not as proof of what is actually in front: when overlapping elements cross parents, pick the target by `Path` and confirm the result with `simulate-mouse-ui`'s `HitGameObjectName` — the handler that received the events, resolved up the hierarchy from the raycast hit (or from `--target-path` in bypass mode), so it can name an ancestor of the element you clicked. Screenshot labels also include the interaction hint, such as `A / CLICK` or `B / DRAG`.
 - `Name`: Element name
-- `Path`: Hierarchy path from the scene root, for example `Canvas/Panel/Button`. Use this as `simulate-mouse-ui --target-path` when bypassing raycast blockers.
+- `Path`: Hierarchy path from the scene root, for example `Canvas/Panel/Button`. Use this as `simulate-mouse-ui --target-path` when bypassing raycast blockers. UI Toolkit entries use a different form that `--target-path` does not accept; see [UI Toolkit Elements](#ui-toolkit-elements).
 - `Type`: Element type (`Button`, `Toggle`, `Slider`, `Dropdown`, `InputField`, `Scrollbar`, `Draggable`, `DropTarget`, `Selectable`, `PhysicsCollider`)
 - `Interaction`: Derived interaction category (`Click`, `Drag`, `Drop`, `Text`) or `Raycast` for clustered physics collider entries. Use this to choose between `simulate-mouse-ui --action Click`, drag actions, or `simulate-mouse-input` (including `--dry-run`).
+- `UiSystem`: UI system the entry came from: `UGUI`, `UIToolkit`, or empty for `PhysicsCollider` entries.
 - `Layer`: Physics layer name for `PhysicsCollider` entries. Empty for UI entries.
 - `Components`: Collider and MonoBehaviour component type names from the hit GameObject for `PhysicsCollider` entries. Empty for UI entries.
 - `SimX`, `SimY`: Target click position in top-left Game View coordinates. For UI entries this is the element center when that center is raycast-reachable; otherwise it is a reachable probe point inside the bounds (center, then four interior quarter points). For `PhysicsCollider` entries this is a representative sampled hit. Use these directly with `simulate-mouse-ui --x/--y` or `simulate-mouse-input --x/--y` (`--dry-run` optional).
 - `BoundsMinX`, `BoundsMinY`, `BoundsMaxX`, `BoundsMaxY`: Bounding box in the same coordinates as `SimX/SimY`. For `PhysicsCollider` entries, this is the axis-aligned sampled-cell coverage box from reachable raycast hits, not a guarantee that every interior point is clickable.
-- `SortingOrder`: Canvas sorting order. Higher values are in front.
-- `SiblingIndex`: Transform sibling index under the element's direct parent. Do not use it as a reliable z-order signal across nested UI hierarchies; the frontmost-first sort above can then disagree with draw order.
+- `SortingOrder`: Canvas sorting order (for UI Toolkit, the panel's `PanelSettings.sortingOrder` rounded down). Higher values are in front.
+- `SiblingIndex`: Transform sibling index under the element's direct parent (for UI Toolkit, the index in the parent visual element). Do not use it as a reliable z-order signal across nested UI hierarchies; the frontmost-first sort above can then disagree with draw order.
 
 ## Exclusion rules (by design)
 
@@ -29,6 +30,33 @@ The annotator lists elements that share the same EventSystem raycast path as `si
 - Elements whose center and four interior quarter probe points are all covered by another raycast hit are not listed.
 - Selectables that are not interactable (`interactable = false`, or a parent `CanvasGroup` with `interactable = false`) ignore clicks and drags, so they are not listed. A separate pointer handler script on the same GameObject is still listed as that handler.
 
+## UI Toolkit Elements
+
+Entries with `UiSystem` `UIToolkit` come from the `UIDocument`s on screen-space panels shown in the Game View. They use the same fields and top-left Game View coordinates as uGUI entries.
+
+- `Type`: `Button` (`Button`, `RepeatButton`), `Toggle` (`Toggle` and other boolean fields), `Slider` (`Slider`, `SliderInt`, `MinMaxSlider`), `Scrollbar` (`Scroller`, including the scrollers of a `ScrollView`), `InputField` (`TextField`), `Dropdown` (`DropdownField`, `EnumField`). `Interaction` follows from `Type` as for uGUI.
+- `Path`: `<UIDocument GameObject path>#<element chain>`, for example `UI/Menu#panel/play`. The chain starts below the document root and joins element names with `/`; an element without a name appears as its type name.
+
+Omitted on purpose:
+
+- Disabled elements, `visibility: hidden`, `display: none` (with everything under it), and zero-size elements.
+- Elements covered at the center and every interior quarter probe point by a panel with a higher sorting order or by another element of the same panel, including parts clipped away by a parent with `overflow: hidden`.
+- Panels that render into a RenderTexture, panels on a display other than the Game View's, world-space panels (Unity 6), and panels whose screen-to-panel mapping is not a plain scale and offset.
+- Parts inside a control (the slider and buttons of a `Scroller`, for example) and any element that is not one of the types above. A custom element with only a `Clickable` manipulator is not listed.
+
+Limits:
+
+- When uGUI and UI Toolkit overlap, which one is in front is not checked; both may be listed.
+- Panels with the same sorting order are not checked against each other.
+- `Bounds` is the whole element rectangle and can include parts clipped away by a parent.
+- Unity 2022.3 with both Device Simulator and Game View open lays UI Toolkit panels out at the Game View size and stretches them onto the simulated screen. Bounds and `SimX`/`SimY` then match where clicks land but not the PNG, and `set-game-view-size` cannot change the hidden Game View while Simulator is shown. Closing the Game View while using Simulator makes them match.
+
+Clicking:
+
+- `simulate-mouse-input --action Click --x <SimX> --y <SimY>` reaches UI Toolkit controls when the scene has an EventSystem with an Input System UI input module.
+- Without an EventSystem the click does not reach UI Toolkit controls.
+- `simulate-mouse-ui` does not reach UI Toolkit controls, and its `--target-path` does not accept UI Toolkit `Path` values.
+
 ### PhysicsCollider Entries Per Closed Region
 
 When a single `PhysicsCollider` GameObject's reachable raycast samples form multiple 4-connected regions on screen — typically because UI occlusion splits them apart — each region becomes its own `AnnotatedElements` entry. `Path`, `Name`, `Layer`, and `Components` are identical across those entries (they describe the same GameObject), while `Label`, `Bounds`, `SimX`, `SimY`, and `RaycastOutlineSegments` are independent per region so each closed area is separately addressable.
diff --git a/.agents/skills/uloop-simulate-mouse-input/SKILL.md b/.agents/skills/uloop-simulate-mouse-input/SKILL.md
index b4e63a2c51..d7c92b3d44 100644
--- a/.agents/skills/uloop-simulate-mouse-input/SKILL.md
+++ b/.agents/skills/uloop-simulate-mouse-input/SKILL.md
@@ -110,7 +110,7 @@ uloop simulate-mouse-input --action SmoothDelta --delta-x 300 --delta-y 0 --dura
 ## Coordinate System
 
 `--x`/`--y` use top-left Game View coordinates: pass `AnnotatedElements[].SimX/SimY`
-directly, convert raw screenshot pixels with `ScreenshotToInputFormula`, and never flip Y
+directly (UI Toolkit entries need an EventSystem in the scene), convert raw screenshot pixels with `ScreenshotToInputFormula`, and never flip Y
 in the caller (the tool converts internally). Conversion formula, Device Simulator
 notes, and how the injected position reads back inside Unity are in
 `references/output-and-coordinates.md`.
diff --git a/.agents/skills/uloop-simulate-mouse-input/references/output-and-coordinates.md b/.agents/skills/uloop-simulate-mouse-input/references/output-and-coordinates.md
index ac7a1299f2..a5998020b4 100644
--- a/.agents/skills/uloop-simulate-mouse-input/references/output-and-coordinates.md
+++ b/.agents/skills/uloop-simulate-mouse-input/references/output-and-coordinates.md
@@ -30,7 +30,7 @@ Verify visual outcome with a follow-up screenshot.
 
 - `--x` / `--y` use **top-left Game View coordinates**.
 - Raw image pixels from `uloop screenshot --capture-mode rendering` must be converted with `ScreenshotToInputFormula`.
-- `AnnotatedElements[].SimX/SimY` can be passed directly to this tool.
+- `AnnotatedElements[].SimX/SimY` can be passed directly to this tool. For UI Toolkit entries (`UiSystem` `UIToolkit`), a `Click` reaches the control only when the scene has an EventSystem with an Input System UI input module; without one, nothing receives the click.
 - Do not flip Y in the caller. The tool converts internally for Unity Input System:
 
 ```text
diff --git a/.agents/skills/uloop-simulate-mouse-ui/SKILL.md b/.agents/skills/uloop-simulate-mouse-ui/SKILL.md
index 88af8895ab..03417c9713 100644
--- a/.agents/skills/uloop-simulate-mouse-ui/SKILL.md
+++ b/.agents/skills/uloop-simulate-mouse-ui/SKILL.md
@@ -64,6 +64,7 @@ uloop simulate-mouse-ui --action <action> --x <x> --y <y> [options]
 - Get coordinates from `AnnotatedElements` JSON (`SimX`/`SimY`) — do NOT look up GameObject positions
 - `--bypass-raycast` still uses coordinates for pointer event positions, but chooses the clicked, long-pressed, or dragged GameObject by `--target-path`
 - If `--target-path` or `--drop-target-path` matches multiple active GameObjects, the command fails instead of choosing an arbitrary duplicate
+- Not for UI Toolkit entries (`UiSystem` `UIToolkit`); see `references/output.md`.
 - Device Simulator play view is supported. Prefer `uloop screenshot --capture-mode rendering --annotate-elements` for coordinates; they use the simulated device resolution (`Handles.GetMainGameViewSize()` / `Screen`), not the Simulator chrome scale.
 
 ## Pause Point Inspection (Standard for E2E)
diff --git a/.agents/skills/uloop-simulate-mouse-ui/references/output.md b/.agents/skills/uloop-simulate-mouse-ui/references/output.md
index 779111873e..043b24d6aa 100644
--- a/.agents/skills/uloop-simulate-mouse-ui/references/output.md
+++ b/.agents/skills/uloop-simulate-mouse-ui/references/output.md
@@ -15,3 +15,7 @@ Returns JSON with:
 Verify the visual outcome with a follow-up `uloop screenshot --capture-mode rendering --annotate-elements`.
 
 Note: Click and LongPress on empty space (no UI element) still return `Success = true` with `HitGameObjectName = null`. Drag actions on empty space return `Success = false`.
+
+## UI Toolkit Elements
+
+`simulate-mouse-ui` drives the uGUI EventSystem raycast path, so it does not reach UI Toolkit controls (`AnnotatedElements` entries with `UiSystem` `UIToolkit`): a click at their `SimX`/`SimY` lands on the panel's own GameObject instead. `--target-path` does not accept their `Path` either. Click them with `simulate-mouse-input` instead, which works when the scene has an EventSystem with an Input System UI input module.
diff --git a/.claude/skills/uloop-screenshot/SKILL.md b/.claude/skills/uloop-screenshot/SKILL.md
index 422a7ec90f..116b4af479 100644
--- a/.claude/skills/uloop-screenshot/SKILL.md
+++ b/.claude/skills/uloop-screenshot/SKILL.md
@@ -23,7 +23,7 @@ uloop screenshot [--window-name <name>] [--resolution-scale <scale>] [--match-mo
 | `--match-mode` | enum | `exact` | Window name matching mode: `exact`, `prefix`, or `contains`. Ignored when the resolved capture mode is rendering (auto during Play Mode resolves to rendering). |
 | `--capture-mode` | enum | `auto` | `auto` - rendering in PlayMode and window otherwise, `window` - capture EditorWindow including toolbar, `rendering` - capture game rendering only (PlayMode required), `GameView` - alias for `rendering`. Rendering screenshots return `ScreenshotToInputFormula` for converting raw image pixels before calling simulate-mouse-input (including `--dry-run`) or simulate-mouse-ui. |
 | `--output-directory` | string | `""` | Output directory path for saving screenshots. When empty, uses default path (.uloop/outputs/Screenshots/). Accepts absolute paths. |
-| `--annotate-elements` | flag | - | Annotate interactive UI elements with index labels and interaction hints (A / CLICK, B / DRAG, ...). The response includes an `AnnotatedElements` array with element metadata sorted by `SortingOrder` then `SiblingIndex` (an approximation of z-order, not the guaranteed draw order). Only works when the resolved capture mode is rendering (auto during Play Mode resolves to rendering) in PlayMode. |
+| `--annotate-elements` | flag | - | Annotate interactive uGUI elements and UI Toolkit controls on screen-space panels with index labels and interaction hints (A / CLICK, B / DRAG, ...). The response includes an `AnnotatedElements` array with element metadata sorted by `SortingOrder` then `SiblingIndex` (an approximation of z-order, not the guaranteed draw order). Only works when the resolved capture mode is rendering (auto during Play Mode resolves to rendering) in PlayMode. |
 | `--annotate-raycast-grid` | flag | - | Annotate clustered 3D physics collider candidates as `PhysicsCollider` entries in `AnnotatedElements`. Uses `Camera.main` visibility and the same top-left Game View coordinates as `simulate-mouse-input`. Only works when the resolved capture mode is rendering (auto during Play Mode resolves to rendering) in PlayMode. |
 | `--raycast-layer-mask` | string | `""` | Comma-separated physics layer names to narrow which layers `--annotate-raycast-grid` clusters. Hits are limited to layers also visible to `Camera.main.cullingMask`. When omitted, clusters against `Physics.DefaultRaycastLayers`. |
 | `--elements-only` | flag | - | Return only annotated element JSON without capturing a screenshot image. Requires `--annotate-elements` or `--annotate-raycast-grid`, and the resolved capture mode to be rendering (auto during Play Mode resolves to rendering) in PlayMode. |
diff --git a/.claude/skills/uloop-screenshot/references/annotated-elements.md b/.claude/skills/uloop-screenshot/references/annotated-elements.md
index 1ef3f771da..5e1338e01d 100644
--- a/.claude/skills/uloop-screenshot/references/annotated-elements.md
+++ b/.claude/skills/uloop-screenshot/references/annotated-elements.md
@@ -10,15 +10,16 @@ Device Simulator is supported for this flow: prefer `--capture-mode rendering` (
 
 - `Label`: Index label in JSON (`A` = first in that sort, `B` = next, ...). Treat it as a stable handle, not as proof of what is actually in front: when overlapping elements cross parents, pick the target by `Path` and confirm the result with `simulate-mouse-ui`'s `HitGameObjectName` — the handler that received the events, resolved up the hierarchy from the raycast hit (or from `--target-path` in bypass mode), so it can name an ancestor of the element you clicked. Screenshot labels also include the interaction hint, such as `A / CLICK` or `B / DRAG`.
 - `Name`: Element name
-- `Path`: Hierarchy path from the scene root, for example `Canvas/Panel/Button`. Use this as `simulate-mouse-ui --target-path` when bypassing raycast blockers.
+- `Path`: Hierarchy path from the scene root, for example `Canvas/Panel/Button`. Use this as `simulate-mouse-ui --target-path` when bypassing raycast blockers. UI Toolkit entries use a different form that `--target-path` does not accept; see [UI Toolkit Elements](#ui-toolkit-elements).
 - `Type`: Element type (`Button`, `Toggle`, `Slider`, `Dropdown`, `InputField`, `Scrollbar`, `Draggable`, `DropTarget`, `Selectable`, `PhysicsCollider`)
 - `Interaction`: Derived interaction category (`Click`, `Drag`, `Drop`, `Text`) or `Raycast` for clustered physics collider entries. Use this to choose between `simulate-mouse-ui --action Click`, drag actions, or `simulate-mouse-input` (including `--dry-run`).
+- `UiSystem`: UI system the entry came from: `UGUI`, `UIToolkit`, or empty for `PhysicsCollider` entries.
 - `Layer`: Physics layer name for `PhysicsCollider` entries. Empty for UI entries.
 - `Components`: Collider and MonoBehaviour component type names from the hit GameObject for `PhysicsCollider` entries. Empty for UI entries.
 - `SimX`, `SimY`: Target click position in top-left Game View coordinates. For UI entries this is the element center when that center is raycast-reachable; otherwise it is a reachable probe point inside the bounds (center, then four interior quarter points). For `PhysicsCollider` entries this is a representative sampled hit. Use these directly with `simulate-mouse-ui --x/--y` or `simulate-mouse-input --x/--y` (`--dry-run` optional).
 - `BoundsMinX`, `BoundsMinY`, `BoundsMaxX`, `BoundsMaxY`: Bounding box in the same coordinates as `SimX/SimY`. For `PhysicsCollider` entries, this is the axis-aligned sampled-cell coverage box from reachable raycast hits, not a guarantee that every interior point is clickable.
-- `SortingOrder`: Canvas sorting order. Higher values are in front.
-- `SiblingIndex`: Transform sibling index under the element's direct parent. Do not use it as a reliable z-order signal across nested UI hierarchies; the frontmost-first sort above can then disagree with draw order.
+- `SortingOrder`: Canvas sorting order (for UI Toolkit, the panel's `PanelSettings.sortingOrder` rounded down). Higher values are in front.
+- `SiblingIndex`: Transform sibling index under the element's direct parent (for UI Toolkit, the index in the parent visual element). Do not use it as a reliable z-order signal across nested UI hierarchies; the frontmost-first sort above can then disagree with draw order.
 
 ## Exclusion rules (by design)
 
@@ -29,6 +30,33 @@ The annotator lists elements that share the same EventSystem raycast path as `si
 - Elements whose center and four interior quarter probe points are all covered by another raycast hit are not listed.
 - Selectables that are not interactable (`interactable = false`, or a parent `CanvasGroup` with `interactable = false`) ignore clicks and drags, so they are not listed. A separate pointer handler script on the same GameObject is still listed as that handler.
 
+## UI Toolkit Elements
+
+Entries with `UiSystem` `UIToolkit` come from the `UIDocument`s on screen-space panels shown in the Game View. They use the same fields and top-left Game View coordinates as uGUI entries.
+
+- `Type`: `Button` (`Button`, `RepeatButton`), `Toggle` (`Toggle` and other boolean fields), `Slider` (`Slider`, `SliderInt`, `MinMaxSlider`), `Scrollbar` (`Scroller`, including the scrollers of a `ScrollView`), `InputField` (`TextField`), `Dropdown` (`DropdownField`, `EnumField`). `Interaction` follows from `Type` as for uGUI.
+- `Path`: `<UIDocument GameObject path>#<element chain>`, for example `UI/Menu#panel/play`. The chain starts below the document root and joins element names with `/`; an element without a name appears as its type name.
+
+Omitted on purpose:
+
+- Disabled elements, `visibility: hidden`, `display: none` (with everything under it), and zero-size elements.
+- Elements covered at the center and every interior quarter probe point by a panel with a higher sorting order or by another element of the same panel, including parts clipped away by a parent with `overflow: hidden`.
+- Panels that render into a RenderTexture, panels on a display other than the Game View's, world-space panels (Unity 6), and panels whose screen-to-panel mapping is not a plain scale and offset.
+- Parts inside a control (the slider and buttons of a `Scroller`, for example) and any element that is not one of the types above. A custom element with only a `Clickable` manipulator is not listed.
+
+Limits:
+
+- When uGUI and UI Toolkit overlap, which one is in front is not checked; both may be listed.
+- Panels with the same sorting order are not checked against each other.
+- `Bounds` is the whole element rectangle and can include parts clipped away by a parent.
+- Unity 2022.3 with both Device Simulator and Game View open lays UI Toolkit panels out at the Game View size and stretches them onto the simulated screen. Bounds and `SimX`/`SimY` then match where clicks land but not the PNG, and `set-game-view-size` cannot change the hidden Game View while Simulator is shown. Closing the Game View while using Simulator makes them match.
+
+Clicking:
+
+- `simulate-mouse-input --action Click --x <SimX> --y <SimY>` reaches UI Toolkit controls when the scene has an EventSystem with an Input System UI input module.
+- Without an EventSystem the click does not reach UI Toolkit controls.
+- `simulate-mouse-ui` does not reach UI Toolkit controls, and its `--target-path` does not accept UI Toolkit `Path` values.
+
 ### PhysicsCollider Entries Per Closed Region
 
 When a single `PhysicsCollider` GameObject's reachable raycast samples form multiple 4-connected regions on screen — typically because UI occlusion splits them apart — each region becomes its own `AnnotatedElements` entry. `Path`, `Name`, `Layer`, and `Components` are identical across those entries (they describe the same GameObject), while `Label`, `Bounds`, `SimX`, `SimY`, and `RaycastOutlineSegments` are independent per region so each closed area is separately addressable.
diff --git a/.claude/skills/uloop-simulate-mouse-input/SKILL.md b/.claude/skills/uloop-simulate-mouse-input/SKILL.md
index b4e63a2c51..d7c92b3d44 100644
--- a/.claude/skills/uloop-simulate-mouse-input/SKILL.md
+++ b/.claude/skills/uloop-simulate-mouse-input/SKILL.md
@@ -110,7 +110,7 @@ uloop simulate-mouse-input --action SmoothDelta --delta-x 300 --delta-y 0 --dura
 ## Coordinate System
 
 `--x`/`--y` use top-left Game View coordinates: pass `AnnotatedElements[].SimX/SimY`
-directly, convert raw screenshot pixels with `ScreenshotToInputFormula`, and never flip Y
+directly (UI Toolkit entries need an EventSystem in the scene), convert raw screenshot pixels with `ScreenshotToInputFormula`, and never flip Y
 in the caller (the tool converts internally). Conversion formula, Device Simulator
 notes, and how the injected position reads back inside Unity are in
 `references/output-and-coordinates.md`.
diff --git a/.claude/skills/uloop-simulate-mouse-input/references/output-and-coordinates.md b/.claude/skills/uloop-simulate-mouse-input/references/output-and-coordinates.md
index ac7a1299f2..a5998020b4 100644
--- a/.claude/skills/uloop-simulate-mouse-input/references/output-and-coordinates.md
+++ b/.claude/skills/uloop-simulate-mouse-input/references/output-and-coordinates.md
@@ -30,7 +30,7 @@ Verify visual outcome with a follow-up screenshot.
 
 - `--x` / `--y` use **top-left Game View coordinates**.
 - Raw image pixels from `uloop screenshot --capture-mode rendering` must be converted with `ScreenshotToInputFormula`.
-- `AnnotatedElements[].SimX/SimY` can be passed directly to this tool.
+- `AnnotatedElements[].SimX/SimY` can be passed directly to this tool. For UI Toolkit entries (`UiSystem` `UIToolkit`), a `Click` reaches the control only when the scene has an EventSystem with an Input System UI input module; without one, nothing receives the click.
 - Do not flip Y in the caller. The tool converts internally for Unity Input System:
 
 ```text
diff --git a/.claude/skills/uloop-simulate-mouse-ui/SKILL.md b/.claude/skills/uloop-simulate-mouse-ui/SKILL.md
index 88af8895ab..03417c9713 100644
--- a/.claude/skills/uloop-simulate-mouse-ui/SKILL.md
+++ b/.claude/skills/uloop-simulate-mouse-ui/SKILL.md
@@ -64,6 +64,7 @@ uloop simulate-mouse-ui --action <action> --x <x> --y <y> [options]
 - Get coordinates from `AnnotatedElements` JSON (`SimX`/`SimY`) — do NOT look up GameObject positions
 - `--bypass-raycast` still uses coordinates for pointer event positions, but chooses the clicked, long-pressed, or dragged GameObject by `--target-path`
 - If `--target-path` or `--drop-target-path` matches multiple active GameObjects, the command fails instead of choosing an arbitrary duplicate
+- Not for UI Toolkit entries (`UiSystem` `UIToolkit`); see `references/output.md`.
 - Device Simulator play view is supported. Prefer `uloop screenshot --capture-mode rendering --annotate-elements` for coordinates; they use the simulated device resolution (`Handles.GetMainGameViewSize()` / `Screen`), not the Simulator chrome scale.
 
 ## Pause Point Inspection (Standard for E2E)
diff --git a/.claude/skills/uloop-simulate-mouse-ui/references/output.md b/.claude/skills/uloop-simulate-mouse-ui/references/output.md
index 779111873e..043b24d6aa 100644
--- a/.claude/skills/uloop-simulate-mouse-ui/references/output.md
+++ b/.claude/skills/uloop-simulate-mouse-ui/references/output.md
@@ -15,3 +15,7 @@ Returns JSON with:
 Verify the visual outcome with a follow-up `uloop screenshot --capture-mode rendering --annotate-elements`.
 
 Note: Click and LongPress on empty space (no UI element) still return `Success = true` with `HitGameObjectName = null`. Drag actions on empty space return `Success = false`.
+
+## UI Toolkit Elements
+
+`simulate-mouse-ui` drives the uGUI EventSystem raycast path, so it does not reach UI Toolkit controls (`AnnotatedElements` entries with `UiSystem` `UIToolkit`): a click at their `SimX`/`SimY` lands on the panel's own GameObject instead. `--target-path` does not accept their `Path` either. Click them with `simulate-mouse-input` instead, which works when the scene has an EventSystem with an Input System UI input module.
diff --git a/.github/workflows/build-and-test.yml b/.github/workflows/build-and-test.yml
index d87e245abc..c6a199d3ee 100644
--- a/.github/workflows/build-and-test.yml
+++ b/.github/workflows/build-and-test.yml
@@ -201,6 +201,7 @@ jobs:
           $null = [scriptblock]::Create((Get-Content -Raw -Encoding UTF8 scripts/test-check-release-installer.ps1))
           $null = [scriptblock]::Create((Get-Content -Raw -Encoding UTF8 scripts/run-windows-e2e.ps1))
           $null = [scriptblock]::Create((Get-Content -Raw -Encoding UTF8 scripts/test-simulate-mouse-demo.ps1))
+          $null = [scriptblock]::Create((Get-Content -Raw -Encoding UTF8 scripts/test-screenshot-uitoolkit-annotation.ps1))
           $null = [scriptblock]::Create((Get-Content -Raw -Encoding UTF8 Assets/Tests/Demo/scripts/verify-replay-via-cli.ps1))
           $null = [scriptblock]::Create((Get-Content -Raw -Encoding UTF8 scripts/test-powershell51-native-argument-escaping.ps1))
           $null = [scriptblock]::Create((Get-Content -Raw -Encoding UTF8 scripts/test-install-pin-resolution.ps1))
diff --git a/Assets/Scenes/UIToolkitAnnotationDemoScene.unity b/Assets/Scenes/UIToolkitAnnotationDemoScene.unity
new file mode 100644
index 0000000000..39e854c0e5
--- /dev/null
+++ b/Assets/Scenes/UIToolkitAnnotationDemoScene.unity
@@ -0,0 +1,740 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!29 &1
+OcclusionCullingSettings:
+  m_ObjectHideFlags: 0
+  serializedVersion: 2
+  m_OcclusionBakeSettings:
+    smallestOccluder: 5
+    smallestHole: 0.25
+    backfaceThreshold: 100
+  m_SceneGUID: 00000000000000000000000000000000
+  m_OcclusionCullingData: {fileID: 0}
+--- !u!104 &2
+RenderSettings:
+  m_ObjectHideFlags: 0
+  serializedVersion: 9
+  m_Fog: 0
+  m_FogColor: {r: 0.5, g: 0.5, b: 0.5, a: 1}
+  m_FogMode: 3
+  m_FogDensity: 0.01
+  m_LinearFogStart: 0
+  m_LinearFogEnd: 300
+  m_AmbientSkyColor: {r: 0.212, g: 0.227, b: 0.259, a: 1}
+  m_AmbientEquatorColor: {r: 0.114, g: 0.125, b: 0.133, a: 1}
+  m_AmbientGroundColor: {r: 0.047, g: 0.043, b: 0.035, a: 1}
+  m_AmbientIntensity: 1
+  m_AmbientMode: 0
+  m_SubtractiveShadowColor: {r: 0.42, g: 0.478, b: 0.627, a: 1}
+  m_SkyboxMaterial: {fileID: 10304, guid: 0000000000000000f000000000000000, type: 0}
+  m_HaloStrength: 0.5
+  m_FlareStrength: 1
+  m_FlareFadeSpeed: 3
+  m_HaloTexture: {fileID: 0}
+  m_SpotCookie: {fileID: 10001, guid: 0000000000000000e000000000000000, type: 0}
+  m_DefaultReflectionMode: 0
+  m_DefaultReflectionResolution: 128
+  m_ReflectionBounces: 1
+  m_ReflectionIntensity: 1
+  m_CustomReflection: {fileID: 0}
+  m_Sun: {fileID: 0}
+  m_UseRadianceAmbientProbe: 0
+--- !u!157 &3
+LightmapSettings:
+  m_ObjectHideFlags: 0
+  serializedVersion: 12
+  m_GIWorkflowMode: 1
+  m_GISettings:
+    serializedVersion: 2
+    m_BounceScale: 1
+    m_IndirectOutputScale: 1
+    m_AlbedoBoost: 1
+    m_EnvironmentLightingMode: 0
+    m_EnableBakedLightmaps: 1
+    m_EnableRealtimeLightmaps: 0
+  m_LightmapEditorSettings:
+    serializedVersion: 12
+    m_Resolution: 2
+    m_BakeResolution: 40
+    m_AtlasSize: 1024
+    m_AO: 0
+    m_AOMaxDistance: 1
+    m_CompAOExponent: 1
+    m_CompAOExponentDirect: 0
+    m_ExtractAmbientOcclusion: 0
+    m_Padding: 2
+    m_LightmapParameters: {fileID: 0}
+    m_LightmapsBakeMode: 1
+    m_TextureCompression: 1
+    m_FinalGather: 0
+    m_FinalGatherFiltering: 1
+    m_FinalGatherRayCount: 256
+    m_ReflectionCompression: 2
+    m_MixedBakeMode: 2
+    m_BakeBackend: 1
+    m_PVRSampling: 1
+    m_PVRDirectSampleCount: 32
+    m_PVRSampleCount: 512
+    m_PVRBounces: 2
+    m_PVREnvironmentSampleCount: 256
+    m_PVREnvironmentReferencePointCount: 2048
+    m_PVRFilteringMode: 1
+    m_PVRDenoiserTypeDirect: 1
+    m_PVRDenoiserTypeIndirect: 1
+    m_PVRDenoiserTypeAO: 1
+    m_PVRFilterTypeDirect: 0
+    m_PVRFilterTypeIndirect: 0
+    m_PVRFilterTypeAO: 0
+    m_PVREnvironmentMIS: 1
+    m_PVRCulling: 1
+    m_PVRFilteringGaussRadiusDirect: 1
+    m_PVRFilteringGaussRadiusIndirect: 5
+    m_PVRFilteringGaussRadiusAO: 2
+    m_PVRFilteringAtrousPositionSigmaDirect: 0.5
+    m_PVRFilteringAtrousPositionSigmaIndirect: 2
+    m_PVRFilteringAtrousPositionSigmaAO: 1
+    m_ExportTrainingData: 0
+    m_TrainingDataDestination: TrainingData
+    m_LightProbeSampleCountMultiplier: 4
+  m_LightingDataAsset: {fileID: 0}
+  m_LightingSettings: {fileID: 0}
+--- !u!196 &4
+NavMeshSettings:
+  serializedVersion: 2
+  m_ObjectHideFlags: 0
+  m_BuildSettings:
+    serializedVersion: 3
+    agentTypeID: 0
+    agentRadius: 0.5
+    agentHeight: 2
+    agentSlope: 45
+    agentClimb: 0.4
+    ledgeDropHeight: 0
+    maxJumpAcrossDistance: 0
+    minRegionArea: 2
+    manualCellSize: 0
+    cellSize: 0.16666667
+    manualTileSize: 0
+    tileSize: 256
+    buildHeightMesh: 0
+    maxJobWorkers: 0
+    preserveTilesOutsideBounds: 0
+    debug:
+      m_Flags: 0
+  m_NavMeshData: {fileID: 0}
+--- !u!1 &824351698
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 824351700}
+  - component: {fileID: 824351699}
+  m_Layer: 0
+  m_Name: FrontDocument
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!114 &824351699
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 824351698}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 19102, guid: 0000000000000000e000000000000000, type: 0}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_PanelSettings: {fileID: 11400000, guid: 7ba283d20dd0f429f952f9b6bc6f1546, type: 2}
+  m_ParentUI: {fileID: 0}
+  sourceAsset: {fileID: 0}
+  m_SortingOrder: 0
+--- !u!4 &824351700
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 824351698}
+  serializedVersion: 2
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_ConstrainProportionsScale: 0
+  m_Children: []
+  m_Father: {fileID: 926978105}
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!1 &888756792
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 888756793}
+  - component: {fileID: 888756795}
+  - component: {fileID: 888756794}
+  m_Layer: 0
+  m_Name: Text (Legacy)
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!224 &888756793
+RectTransform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 888756792}
+  m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_ConstrainProportionsScale: 0
+  m_Children: []
+  m_Father: {fileID: 1115416529}
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+  m_AnchorMin: {x: 0, y: 0}
+  m_AnchorMax: {x: 1, y: 1}
+  m_AnchoredPosition: {x: 0, y: 0}
+  m_SizeDelta: {x: 0, y: 0}
+  m_Pivot: {x: 0.5, y: 0.5}
+--- !u!114 &888756794
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 888756792}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 5f7201a12d95ffc409449d95f23cf332, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_Material: {fileID: 0}
+  m_Color: {r: 0.19607843, g: 0.19607843, b: 0.19607843, a: 1}
+  m_RaycastTarget: 1
+  m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0}
+  m_Maskable: 1
+  m_OnCullStateChanged:
+    m_PersistentCalls:
+      m_Calls: []
+  m_FontData:
+    m_Font: {fileID: 10102, guid: 0000000000000000e000000000000000, type: 0}
+    m_FontSize: 14
+    m_FontStyle: 0
+    m_BestFit: 0
+    m_MinSize: 10
+    m_MaxSize: 40
+    m_Alignment: 4
+    m_AlignByGeometry: 0
+    m_RichText: 1
+    m_HorizontalOverflow: 0
+    m_VerticalOverflow: 0
+    m_LineSpacing: 1
+  m_Text: Button
+--- !u!222 &888756795
+CanvasRenderer:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 888756792}
+  m_CullTransparentMesh: 1
+--- !u!1 &926978103
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 926978105}
+  - component: {fileID: 926978104}
+  m_Layer: 0
+  m_Name: UIToolkitAnnotationDemo
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!114 &926978104
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 926978103}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: b288f11987e9b4656905feabfc18ef89, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  backDocument: {fileID: 1341402965}
+  frontDocument: {fileID: 824351699}
+--- !u!4 &926978105
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 926978103}
+  serializedVersion: 2
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_ConstrainProportionsScale: 0
+  m_Children:
+  - {fileID: 1341402966}
+  - {fileID: 824351700}
+  m_Father: {fileID: 0}
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!1 &1115416528
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 1115416529}
+  - component: {fileID: 1115416532}
+  - component: {fileID: 1115416531}
+  - component: {fileID: 1115416530}
+  m_Layer: 0
+  m_Name: ugui-button
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!224 &1115416529
+RectTransform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1115416528}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_ConstrainProportionsScale: 0
+  m_Children:
+  - {fileID: 888756793}
+  m_Father: {fileID: 1546344952}
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+  m_AnchorMin: {x: 1, y: 0}
+  m_AnchorMax: {x: 1, y: 0}
+  m_AnchoredPosition: {x: -40, y: 40}
+  m_SizeDelta: {x: 200, y: 50}
+  m_Pivot: {x: 1, y: 0}
+--- !u!114 &1115416530
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1115416528}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 4e29b1a8efbd4b44bb3f3716e73f07ff, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_Navigation:
+    m_Mode: 3
+    m_WrapAround: 0
+    m_SelectOnUp: {fileID: 0}
+    m_SelectOnDown: {fileID: 0}
+    m_SelectOnLeft: {fileID: 0}
+    m_SelectOnRight: {fileID: 0}
+  m_Transition: 1
+  m_Colors:
+    m_NormalColor: {r: 1, g: 1, b: 1, a: 1}
+    m_HighlightedColor: {r: 0.9607843, g: 0.9607843, b: 0.9607843, a: 1}
+    m_PressedColor: {r: 0.78431374, g: 0.78431374, b: 0.78431374, a: 1}
+    m_SelectedColor: {r: 0.9607843, g: 0.9607843, b: 0.9607843, a: 1}
+    m_DisabledColor: {r: 0.78431374, g: 0.78431374, b: 0.78431374, a: 0.5019608}
+    m_ColorMultiplier: 1
+    m_FadeDuration: 0.1
+  m_SpriteState:
+    m_HighlightedSprite: {fileID: 0}
+    m_PressedSprite: {fileID: 0}
+    m_SelectedSprite: {fileID: 0}
+    m_DisabledSprite: {fileID: 0}
+  m_AnimationTriggers:
+    m_NormalTrigger: Normal
+    m_HighlightedTrigger: Highlighted
+    m_PressedTrigger: Pressed
+    m_SelectedTrigger: Selected
+    m_DisabledTrigger: Disabled
+  m_Interactable: 1
+  m_TargetGraphic: {fileID: 1115416531}
+  m_OnClick:
+    m_PersistentCalls:
+      m_Calls: []
+--- !u!114 &1115416531
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1115416528}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: fe87c0e1cc204ed48ad3b37840f39efc, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_Material: {fileID: 0}
+  m_Color: {r: 1, g: 1, b: 1, a: 1}
+  m_RaycastTarget: 1
+  m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0}
+  m_Maskable: 1
+  m_OnCullStateChanged:
+    m_PersistentCalls:
+      m_Calls: []
+  m_Sprite: {fileID: 0}
+  m_Type: 1
+  m_PreserveAspect: 0
+  m_FillCenter: 1
+  m_FillMethod: 4
+  m_FillAmount: 1
+  m_FillClockwise: 1
+  m_FillOrigin: 0
+  m_UseSpriteMesh: 0
+  m_PixelsPerUnitMultiplier: 1
+--- !u!222 &1115416532
+CanvasRenderer:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1115416528}
+  m_CullTransparentMesh: 1
+--- !u!1 &1341402964
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 1341402966}
+  - component: {fileID: 1341402965}
+  m_Layer: 0
+  m_Name: BackDocument
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!114 &1341402965
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1341402964}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 19102, guid: 0000000000000000e000000000000000, type: 0}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_PanelSettings: {fileID: 11400000, guid: 34868ecccc6b142e6a841a062a97a6bd, type: 2}
+  m_ParentUI: {fileID: 0}
+  sourceAsset: {fileID: 0}
+  m_SortingOrder: 0
+--- !u!4 &1341402966
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1341402964}
+  serializedVersion: 2
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_ConstrainProportionsScale: 0
+  m_Children: []
+  m_Father: {fileID: 926978105}
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!1 &1378620445
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 1378620448}
+  - component: {fileID: 1378620447}
+  - component: {fileID: 1378620446}
+  m_Layer: 0
+  m_Name: EventSystem
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!114 &1378620446
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1378620445}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 01614664b831546d2ae94a42149d80ac, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_SendPointerHoverToParent: 1
+  m_MoveRepeatDelay: 0.5
+  m_MoveRepeatRate: 0.1
+  m_XRTrackingOrigin: {fileID: 0}
+  m_ActionsAsset: {fileID: -944628639613478452, guid: ca9f5fa95ffab41fb9a615ab714db018, type: 3}
+  m_PointAction: {fileID: -1654692200621890270, guid: ca9f5fa95ffab41fb9a615ab714db018, type: 3}
+  m_MoveAction: {fileID: -8784545083839296357, guid: ca9f5fa95ffab41fb9a615ab714db018, type: 3}
+  m_SubmitAction: {fileID: 392368643174621059, guid: ca9f5fa95ffab41fb9a615ab714db018, type: 3}
+  m_CancelAction: {fileID: 7727032971491509709, guid: ca9f5fa95ffab41fb9a615ab714db018, type: 3}
+  m_LeftClickAction: {fileID: 3001919216989983466, guid: ca9f5fa95ffab41fb9a615ab714db018, type: 3}
+  m_MiddleClickAction: {fileID: -2185481485913320682, guid: ca9f5fa95ffab41fb9a615ab714db018, type: 3}
+  m_RightClickAction: {fileID: -4090225696740746782, guid: ca9f5fa95ffab41fb9a615ab714db018, type: 3}
+  m_ScrollWheelAction: {fileID: 6240969308177333660, guid: ca9f5fa95ffab41fb9a615ab714db018, type: 3}
+  m_TrackedDevicePositionAction: {fileID: 6564999863303420839, guid: ca9f5fa95ffab41fb9a615ab714db018, type: 3}
+  m_TrackedDeviceOrientationAction: {fileID: 7970375526676320489, guid: ca9f5fa95ffab41fb9a615ab714db018, type: 3}
+  m_DeselectOnBackgroundClick: 1
+  m_PointerBehavior: 0
+  m_CursorLockBehavior: 0
+  m_ScrollDeltaPerTick: 6
+--- !u!114 &1378620447
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1378620445}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 76c392e42b5098c458856cdf6ecaaaa1, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_FirstSelected: {fileID: 0}
+  m_sendNavigationEvents: 1
+  m_DragThreshold: 10
+--- !u!4 &1378620448
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1378620445}
+  serializedVersion: 2
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_ConstrainProportionsScale: 0
+  m_Children: []
+  m_Father: {fileID: 0}
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!1 &1546344948
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 1546344952}
+  - component: {fileID: 1546344951}
+  - component: {fileID: 1546344950}
+  - component: {fileID: 1546344949}
+  m_Layer: 0
+  m_Name: Canvas
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!114 &1546344949
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1546344948}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: dc42784cf147c0c48a680349fa168899, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_IgnoreReversedGraphics: 1
+  m_BlockingObjects: 0
+  m_BlockingMask:
+    serializedVersion: 2
+    m_Bits: 4294967295
+--- !u!114 &1546344950
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1546344948}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 0cd44c1031e13a943bb63640046fad76, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_UiScaleMode: 0
+  m_ReferencePixelsPerUnit: 100
+  m_ScaleFactor: 1
+  m_ReferenceResolution: {x: 800, y: 600}
+  m_ScreenMatchMode: 0
+  m_MatchWidthOrHeight: 0
+  m_PhysicalUnit: 3
+  m_FallbackScreenDPI: 96
+  m_DefaultSpriteDPI: 96
+  m_DynamicPixelsPerUnit: 1
+  m_PresetInfoIsWorld: 0
+--- !u!223 &1546344951
+Canvas:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1546344948}
+  m_Enabled: 1
+  serializedVersion: 3
+  m_RenderMode: 0
+  m_Camera: {fileID: 0}
+  m_PlaneDistance: 100
+  m_PixelPerfect: 0
+  m_ReceivesEvents: 1
+  m_OverrideSorting: 0
+  m_OverridePixelPerfect: 0
+  m_SortingBucketNormalizedSize: 0
+  m_VertexColorAlwaysGammaSpace: 0
+  m_AdditionalShaderChannelsFlag: 0
+  m_UpdateRectTransformForStandalone: 0
+  m_SortingLayerID: 0
+  m_SortingOrder: 0
+  m_TargetDisplay: 0
+--- !u!224 &1546344952
+RectTransform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1546344948}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 0, y: 0, z: 0}
+  m_ConstrainProportionsScale: 0
+  m_Children:
+  - {fileID: 1115416529}
+  m_Father: {fileID: 0}
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+  m_AnchorMin: {x: 0, y: 0}
+  m_AnchorMax: {x: 0, y: 0}
+  m_AnchoredPosition: {x: 0, y: 0}
+  m_SizeDelta: {x: 0, y: 0}
+  m_Pivot: {x: 0, y: 0}
+--- !u!1 &1633613639
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 1633613641}
+  - component: {fileID: 1633613640}
+  m_Layer: 0
+  m_Name: Main Camera
+  m_TagString: MainCamera
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!20 &1633613640
+Camera:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1633613639}
+  m_Enabled: 1
+  serializedVersion: 2
+  m_ClearFlags: 2
+  m_BackGroundColor: {r: 0.08, g: 0.09, b: 0.12, a: 1}
+  m_projectionMatrixMode: 1
+  m_GateFitMode: 2
+  m_FOVAxisMode: 0
+  m_Iso: 200
+  m_ShutterSpeed: 0.005
+  m_Aperture: 16
+  m_FocusDistance: 10
+  m_FocalLength: 50
+  m_BladeCount: 5
+  m_Curvature: {x: 2, y: 11}
+  m_BarrelClipping: 0.25
+  m_Anamorphism: 0
+  m_SensorSize: {x: 36, y: 24}
+  m_LensShift: {x: 0, y: 0}
+  m_NormalizedViewPortRect:
+    serializedVersion: 2
+    x: 0
+    y: 0
+    width: 1
+    height: 1
+  near clip plane: 0.3
+  far clip plane: 1000
+  field of view: 60
+  orthographic: 0
+  orthographic size: 5
+  m_Depth: 0
+  m_CullingMask:
+    serializedVersion: 2
+    m_Bits: 4294967295
+  m_RenderingPath: -1
+  m_TargetTexture: {fileID: 0}
+  m_TargetDisplay: 0
+  m_TargetEye: 3
+  m_HDR: 1
+  m_AllowMSAA: 1
+  m_AllowDynamicResolution: 0
+  m_ForceIntoRT: 0
+  m_OcclusionCulling: 1
+  m_StereoConvergence: 10
+  m_StereoSeparation: 0.022
+--- !u!4 &1633613641
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1633613639}
+  serializedVersion: 2
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 1, z: -10}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_ConstrainProportionsScale: 0
+  m_Children: []
+  m_Father: {fileID: 0}
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!1660057539 &9223372036854775807
+SceneRoots:
+  m_ObjectHideFlags: 0
+  m_Roots:
+  - {fileID: 1633613641}
+  - {fileID: 1378620448}
+  - {fileID: 926978105}
+  - {fileID: 1546344952}
diff --git a/Assets/Scenes/UIToolkitAnnotationDemoScene.unity.meta b/Assets/Scenes/UIToolkitAnnotationDemoScene.unity.meta
new file mode 100644
index 0000000000..4af61e3a45
--- /dev/null
+++ b/Assets/Scenes/UIToolkitAnnotationDemoScene.unity.meta
@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: c80190a87ff2e40f58bc9fda7d981d9c
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Tests/Demo/Editor/UIToolkitAnnotationDemoSceneBuilder.cs b/Assets/Tests/Demo/Editor/UIToolkitAnnotationDemoSceneBuilder.cs
new file mode 100644
index 0000000000..0c79d40e3a
--- /dev/null
+++ b/Assets/Tests/Demo/Editor/UIToolkitAnnotationDemoSceneBuilder.cs
@@ -0,0 +1,142 @@
+#if ULOOP_HAS_INPUT_SYSTEM
+#nullable enable
+using UnityEditor;
+using UnityEditor.SceneManagement;
+using UnityEngine;
+using UnityEngine.EventSystems;
+using UnityEngine.InputSystem.UI;
+using UnityEngine.SceneManagement;
+using UnityEngine.UI;
+using UnityEngine.UIElements;
+
+using io.github.hatayama.UnityCliLoop.Tests.Demo;
+
+namespace io.github.hatayama.UnityCliLoop.Tests.Demo.Editor
+{
+    /// <summary>
+    /// Builds the scene the UI Toolkit screenshot annotation E2E runs against: two screen-space UI Toolkit
+    /// panels driven by UIToolkitAnnotationDemo, plus one uGUI button so both UI systems are annotated together.
+    /// </summary>
+    public static class UIToolkitAnnotationDemoSceneBuilder
+    {
+        private const string SCENE_PATH = "Assets/Scenes/UIToolkitAnnotationDemoScene.unity";
+        private const string ASSET_FOLDER = "Assets/Tests/Demo/UIToolkitAnnotation";
+        private const string BACK_PANEL_PATH = ASSET_FOLDER + "/UIToolkitAnnotationDemoBackPanel.asset";
+        private const string FRONT_PANEL_PATH = ASSET_FOLDER + "/UIToolkitAnnotationDemoFrontPanel.asset";
+        private const string THEME_PATH = "Assets/UI Toolkit/UnityThemes/UnityDefaultRuntimeTheme.tss";
+        private const float BACK_SORTING_ORDER = 0f;
+        private const float FRONT_SORTING_ORDER = 10f;
+
+        [MenuItem("UnityCliLoop/Build UI Toolkit Annotation Demo Scene")]
+        public static void Build()
+        {
+            PanelSettings backPanel = CreateOrUpdatePanelSettings(BACK_PANEL_PATH, BACK_SORTING_ORDER);
+            PanelSettings frontPanel = CreateOrUpdatePanelSettings(FRONT_PANEL_PATH, FRONT_SORTING_ORDER);
+
+            Scene scene = EditorSceneManager.NewScene(NewSceneSetup.EmptyScene, NewSceneMode.Single);
+            CreateCamera();
+            CreateEventSystem();
+            CreateDemo(backPanel, frontPanel);
+            CreateUguiButton();
+
+            bool saved = EditorSceneManager.SaveScene(scene, SCENE_PATH);
+            if (!saved)
+            {
+                Debug.Assert(false, $"[UIToolkitAnnotationDemoSceneBuilder] Failed to save scene to {SCENE_PATH}");
+                return;
+            }
+            Debug.Log($"[UIToolkitAnnotationDemoSceneBuilder] Scene saved to {SCENE_PATH}");
+        }
+
+        // The theme is assigned explicitly so the panels do not depend on which theme Unity finds first.
+        private static PanelSettings CreateOrUpdatePanelSettings(string path, float sortingOrder)
+        {
+            if (!AssetDatabase.IsValidFolder(ASSET_FOLDER))
+            {
+                AssetDatabase.CreateFolder("Assets/Tests/Demo", "UIToolkitAnnotation");
+            }
+
+            PanelSettings? settings = AssetDatabase.LoadAssetAtPath<PanelSettings>(path);
+            if (settings == null)
+            {
+                settings = ScriptableObject.CreateInstance<PanelSettings>();
+                AssetDatabase.CreateAsset(settings, path);
+            }
+
+            ThemeStyleSheet theme = AssetDatabase.LoadAssetAtPath<ThemeStyleSheet>(THEME_PATH);
+            Debug.Assert(theme != null, $"[UIToolkitAnnotationDemoSceneBuilder] Missing theme at {THEME_PATH}");
+            settings.themeStyleSheet = theme;
+            settings.scaleMode = PanelScaleMode.ConstantPixelSize;
+            settings.scale = 1f;
+            settings.sortingOrder = sortingOrder;
+            EditorUtility.SetDirty(settings);
+            AssetDatabase.SaveAssets();
+            return settings;
+        }
+
+        private static void CreateCamera()
+        {
+            GameObject cameraGo = new("Main Camera");
+            cameraGo.tag = "MainCamera";
+            Camera camera = cameraGo.AddComponent<Camera>();
+            camera.clearFlags = CameraClearFlags.SolidColor;
+            camera.backgroundColor = new Color(0.08f, 0.09f, 0.12f, 1f);
+            camera.transform.position = new Vector3(0f, 1f, -10f);
+        }
+
+        private static void CreateEventSystem()
+        {
+            GameObject eventSystemGo = new("EventSystem");
+            eventSystemGo.AddComponent<EventSystem>();
+            eventSystemGo.AddComponent<InputSystemUIInputModule>();
+        }
+
+        // The two documents are siblings: a document under another document's GameObject would join its
+        // parent's panel instead of using its own panel settings.
+        private static void CreateDemo(PanelSettings backPanel, PanelSettings frontPanel)
+        {
+            GameObject demoGo = new("UIToolkitAnnotationDemo");
+            UIDocument backDocument = CreateDocument("BackDocument", demoGo.transform, backPanel);
+            UIDocument frontDocument = CreateDocument("FrontDocument", demoGo.transform, frontPanel);
+
+            UIToolkitAnnotationDemo demo = demoGo.AddComponent<UIToolkitAnnotationDemo>();
+            SerializedObject serializedDemo = new(demo);
+            serializedDemo.FindProperty("backDocument").objectReferenceValue = backDocument;
+            serializedDemo.FindProperty("frontDocument").objectReferenceValue = frontDocument;
+            serializedDemo.ApplyModifiedPropertiesWithoutUndo();
+        }
+
+        private static UIDocument CreateDocument(string name, Transform parent, PanelSettings panelSettings)
+        {
+            GameObject documentGo = new(name);
+            documentGo.transform.SetParent(parent, false);
+            UIDocument document = documentGo.AddComponent<UIDocument>();
+            // Through the serialized field: assigning the property from a builder did not reach the saved scene.
+            SerializedObject serializedDocument = new(document);
+            serializedDocument.FindProperty("m_PanelSettings").objectReferenceValue = panelSettings;
+            serializedDocument.ApplyModifiedPropertiesWithoutUndo();
+            return document;
+        }
+
+        // Placed in the bottom-right corner, away from every UI Toolkit control.
+        private static void CreateUguiButton()
+        {
+            GameObject canvasGo = new("Canvas");
+            Canvas canvas = canvasGo.AddComponent<Canvas>();
+            canvas.renderMode = RenderMode.ScreenSpaceOverlay;
+            canvasGo.AddComponent<CanvasScaler>();
+            canvasGo.AddComponent<GraphicRaycaster>();
+
+            GameObject buttonGo = DefaultControls.CreateButton(new DefaultControls.Resources());
+            buttonGo.name = "ugui-button";
+            buttonGo.transform.SetParent(canvasGo.transform, false);
+            RectTransform rectTransform = buttonGo.GetComponent<RectTransform>();
+            rectTransform.anchorMin = new Vector2(1f, 0f);
+            rectTransform.anchorMax = new Vector2(1f, 0f);
+            rectTransform.pivot = new Vector2(1f, 0f);
+            rectTransform.anchoredPosition = new Vector2(-40f, 40f);
+            rectTransform.sizeDelta = new Vector2(200f, 50f);
+        }
+    }
+}
+#endif
diff --git a/Assets/Tests/Demo/Editor/UIToolkitAnnotationDemoSceneBuilder.cs.meta b/Assets/Tests/Demo/Editor/UIToolkitAnnotationDemoSceneBuilder.cs.meta
new file mode 100644
index 0000000000..667b15063f
--- /dev/null
+++ b/Assets/Tests/Demo/Editor/UIToolkitAnnotationDemoSceneBuilder.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 37912b5d1be014e7ba283ec3fef44161
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Tests/Demo/UIToolkitAnnotation.meta b/Assets/Tests/Demo/UIToolkitAnnotation.meta
new file mode 100644
index 0000000000..57d86e4e1b
--- /dev/null
+++ b/Assets/Tests/Demo/UIToolkitAnnotation.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: f9e87819ed88e420f91d8c740b8e11f3
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Tests/Demo/UIToolkitAnnotation/UIToolkitAnnotationDemoBackPanel.asset b/Assets/Tests/Demo/UIToolkitAnnotation/UIToolkitAnnotationDemoBackPanel.asset
new file mode 100644
index 0000000000..66c8fe1689
--- /dev/null
+++ b/Assets/Tests/Demo/UIToolkitAnnotation/UIToolkitAnnotationDemoBackPanel.asset
@@ -0,0 +1,38 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &11400000
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 19101, guid: 0000000000000000e000000000000000, type: 0}
+  m_Name: UIToolkitAnnotationDemoBackPanel
+  m_EditorClassIdentifier: 
+  themeUss: {fileID: -4733365628477956816, guid: 8fd404036dab64fb4bde32641268683b, type: 3}
+  m_TargetTexture: {fileID: 0}
+  m_ScaleMode: 0
+  m_ReferenceSpritePixelsPerUnit: 100
+  m_Scale: 1
+  m_ReferenceDpi: 96
+  m_FallbackDpi: 96
+  m_ReferenceResolution: {x: 1200, y: 800}
+  m_ScreenMatchMode: 0
+  m_Match: 0
+  m_SortingOrder: 0
+  m_TargetDisplay: 0
+  m_ClearDepthStencil: 1
+  m_ClearColor: 0
+  m_ColorClearValue: {r: 0, g: 0, b: 0, a: 0}
+  m_DynamicAtlasSettings:
+    m_MinAtlasSize: 64
+    m_MaxAtlasSize: 4096
+    m_MaxSubTextureSize: 64
+    m_ActiveFilters: 31
+  m_AtlasBlitShader: {fileID: 9101, guid: 0000000000000000f000000000000000, type: 0}
+  m_RuntimeShader: {fileID: 9100, guid: 0000000000000000f000000000000000, type: 0}
+  m_RuntimeWorldShader: {fileID: 9102, guid: 0000000000000000f000000000000000, type: 0}
+  textSettings: {fileID: 0}
diff --git a/Assets/Tests/Demo/UIToolkitAnnotation/UIToolkitAnnotationDemoBackPanel.asset.meta b/Assets/Tests/Demo/UIToolkitAnnotation/UIToolkitAnnotationDemoBackPanel.asset.meta
new file mode 100644
index 0000000000..92fa4a5b8a
--- /dev/null
+++ b/Assets/Tests/Demo/UIToolkitAnnotation/UIToolkitAnnotationDemoBackPanel.asset.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 34868ecccc6b142e6a841a062a97a6bd
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 11400000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Tests/Demo/UIToolkitAnnotation/UIToolkitAnnotationDemoFrontPanel.asset b/Assets/Tests/Demo/UIToolkitAnnotation/UIToolkitAnnotationDemoFrontPanel.asset
new file mode 100644
index 0000000000..b60e59f071
--- /dev/null
+++ b/Assets/Tests/Demo/UIToolkitAnnotation/UIToolkitAnnotationDemoFrontPanel.asset
@@ -0,0 +1,38 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &11400000
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 19101, guid: 0000000000000000e000000000000000, type: 0}
+  m_Name: UIToolkitAnnotationDemoFrontPanel
+  m_EditorClassIdentifier: 
+  themeUss: {fileID: -4733365628477956816, guid: 8fd404036dab64fb4bde32641268683b, type: 3}
+  m_TargetTexture: {fileID: 0}
+  m_ScaleMode: 0
+  m_ReferenceSpritePixelsPerUnit: 100
+  m_Scale: 1
+  m_ReferenceDpi: 96
+  m_FallbackDpi: 96
+  m_ReferenceResolution: {x: 1200, y: 800}
+  m_ScreenMatchMode: 0
+  m_Match: 0
+  m_SortingOrder: 10
+  m_TargetDisplay: 0
+  m_ClearDepthStencil: 1
+  m_ClearColor: 0
+  m_ColorClearValue: {r: 0, g: 0, b: 0, a: 0}
+  m_DynamicAtlasSettings:
+    m_MinAtlasSize: 64
+    m_MaxAtlasSize: 4096
+    m_MaxSubTextureSize: 64
+    m_ActiveFilters: 31
+  m_AtlasBlitShader: {fileID: 9101, guid: 0000000000000000f000000000000000, type: 0}
+  m_RuntimeShader: {fileID: 9100, guid: 0000000000000000f000000000000000, type: 0}
+  m_RuntimeWorldShader: {fileID: 9102, guid: 0000000000000000f000000000000000, type: 0}
+  textSettings: {fileID: 0}
diff --git a/Assets/Tests/Demo/UIToolkitAnnotation/UIToolkitAnnotationDemoFrontPanel.asset.meta b/Assets/Tests/Demo/UIToolkitAnnotation/UIToolkitAnnotationDemoFrontPanel.asset.meta
new file mode 100644
index 0000000000..6e1a020c58
--- /dev/null
+++ b/Assets/Tests/Demo/UIToolkitAnnotation/UIToolkitAnnotationDemoFrontPanel.asset.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 7ba283d20dd0f429f952f9b6bc6f1546
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 11400000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Tests/Demo/UIToolkitAnnotationDemo.cs b/Assets/Tests/Demo/UIToolkitAnnotationDemo.cs
new file mode 100644
index 0000000000..78a82557e3
--- /dev/null
+++ b/Assets/Tests/Demo/UIToolkitAnnotationDemo.cs
@@ -0,0 +1,93 @@
+#nullable enable
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.UIElements;
+
+namespace io.github.hatayama.UnityCliLoop.Tests.Demo
+{
+    /// <summary>
+    /// Builds the UI Toolkit controls the screenshot annotation E2E expects on two screen-space panels, and
+    /// counts button clicks so the E2E can check that a click reached a control.
+    /// </summary>
+    public sealed class UIToolkitAnnotationDemo : MonoBehaviour
+    {
+        [SerializeField] private UIDocument backDocument = null!;
+        [SerializeField] private UIDocument frontDocument = null!;
+
+        private readonly Dictionary<string, int> _clickCounts = new Dictionary<string, int>();
+
+        public int GetClickCount(string elementName)
+        {
+            return _clickCounts.TryGetValue(elementName, out int count) ? count : 0;
+        }
+
+        // Start runs after every Awake and OnEnable, so both documents have created their roots by now
+        // regardless of component order.
+        private void Start()
+        {
+            BuildBackPanel(backDocument.rootVisualElement);
+            BuildFrontPanel(frontDocument.rootVisualElement);
+        }
+
+        private void BuildBackPanel(VisualElement root)
+        {
+            AddPlaced(root, CreateCountingButton("play"), 100f, 100f, 200f, 50f);
+            AddPlaced(root, new Toggle("Sound") { name = "sound" }, 100f, 180f, 200f, 30f);
+            AddPlaced(root, new Slider("Volume", 0f, 1f) { name = "volume" }, 100f, 240f, 300f, 30f);
+            AddPlaced(root, new TextField("Player") { name = "player-name" }, 100f, 300f, 300f, 40f);
+            DropdownField quality = new DropdownField(
+                "Quality", new List<string> { "Low", "Medium", "High" }, 1) { name = "quality" };
+            AddPlaced(root, quality, 100f, 370f, 300f, 40f);
+
+            Button locked = CreateCountingButton("locked");
+            locked.SetEnabled(false);
+            AddPlaced(root, locked, 100f, 440f, 200f, 50f);
+
+            Button ghost = CreateCountingButton("ghost");
+            ghost.style.visibility = Visibility.Hidden;
+            AddPlaced(root, ghost, 100f, 510f, 200f, 50f);
+
+            ScrollView list = new ScrollView { name = "list" };
+            list.verticalScrollerVisibility = ScrollerVisibility.AlwaysVisible;
+            VisualElement content = new VisualElement { name = "list-content" };
+            content.style.height = 1000f;
+            content.style.flexShrink = 0f;
+            list.Add(content);
+            AddPlaced(root, list, 500f, 100f, 200f, 200f);
+
+            AddPlaced(root, CreateCountingButton("partly-covered"), 800f, 100f, 300f, 60f);
+        }
+
+        // Covers the left 60% of partly-covered from a panel with a higher sorting order.
+        private static void BuildFrontPanel(VisualElement root)
+        {
+            VisualElement cover = new VisualElement { name = "cover" };
+            cover.style.backgroundColor = new Color(0.2f, 0.2f, 0.25f, 1f);
+            AddPlaced(root, cover, 800f, 100f, 180f, 60f);
+        }
+
+        private Button CreateCountingButton(string elementName)
+        {
+            Button button = new Button { name = elementName, text = elementName };
+            button.clicked += () => _clickCounts[elementName] = GetClickCount(elementName) + 1;
+            return button;
+        }
+
+        // Margins are zeroed because the theme gives controls margins that would shift their bounds away from
+        // the coordinates the E2E checks.
+        private static void AddPlaced(
+            VisualElement root, VisualElement element, float left, float top, float width, float height)
+        {
+            element.style.position = Position.Absolute;
+            element.style.left = left;
+            element.style.top = top;
+            element.style.width = width;
+            element.style.height = height;
+            element.style.marginLeft = 0f;
+            element.style.marginTop = 0f;
+            element.style.marginRight = 0f;
+            element.style.marginBottom = 0f;
+            root.Add(element);
+        }
+    }
+}
diff --git a/Assets/Tests/Demo/UIToolkitAnnotationDemo.cs.meta b/Assets/Tests/Demo/UIToolkitAnnotationDemo.cs.meta
new file mode 100644
index 0000000000..9ec0ef24b1
--- /dev/null
+++ b/Assets/Tests/Demo/UIToolkitAnnotationDemo.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: b288f11987e9b4656905feabfc18ef89
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Packages/src/Documentation~/tools.md b/Packages/src/Documentation~/tools.md
index b9f114ba97..efef7ade94 100644
--- a/Packages/src/Documentation~/tools.md
+++ b/Packages/src/Documentation~/tools.md
@@ -221,4 +221,4 @@ sh scripts/run-posix-e2e.sh --project-path /path/to/unity-project
 powershell -NoProfile -ExecutionPolicy Bypass -File .\scripts\run-windows-e2e.ps1
 ```
 
-`run-posix-e2e.sh` uses the built native CLI binary by default, passes an explicit `--project-path` to every `uloop` invocation, and runs CLI recovery/readiness and simulate-mouse UI coverage in one sequence. To verify `replay-input` against a JSON created in the Recordings window, run `verify-replay-via-cli.sh` separately.
+`run-posix-e2e.sh` uses the built native CLI binary by default, passes an explicit `--project-path` to every `uloop` invocation, and runs CLI recovery/readiness, simulate-mouse UI coverage, and UI Toolkit screenshot annotation coverage in one sequence (skip the last with `--skip-uitoolkit-annotation`). To verify `replay-input` against a JSON created in the Recordings window, run `verify-replay-via-cli.sh` separately.
diff --git a/Packages/src/Documentation~/tools_ja.md b/Packages/src/Documentation~/tools_ja.md
index 1743371c04..a336447c51 100644
--- a/Packages/src/Documentation~/tools_ja.md
+++ b/Packages/src/Documentation~/tools_ja.md
@@ -221,4 +221,4 @@ sh scripts/run-posix-e2e.sh --project-path /path/to/unity-project
 powershell -NoProfile -ExecutionPolicy Bypass -File .\scripts\run-windows-e2e.ps1
 ```
 
-`run-posix-e2e.sh` は、デフォルトでチェックイン済みのネイティブCLIバイナリを使い、すべての `uloop` 呼び出しに明示的な `--project-path` を渡します。CLI recovery/readiness と simulate-mouse UI を1つの流れで検証します。Recordingsウィンドウで作成したJSONの replay-input 検証は `verify-replay-via-cli.sh` を個別に実行します。
+`run-posix-e2e.sh` は、デフォルトでチェックイン済みのネイティブCLIバイナリを使い、すべての `uloop` 呼び出しに明示的な `--project-path` を渡します。CLI recovery/readiness、simulate-mouse UI、UI Toolkit のスクリーンショット注釈を1つの流れで検証します（最後のものは `--skip-uitoolkit-annotation` で省けます）。Recordingsウィンドウで作成したJSONの replay-input 検証は `verify-replay-via-cli.sh` を個別に実行します。
diff --git a/Packages/src/Editor/FirstPartyTools/Screenshot/Skill/SKILL.md b/Packages/src/Editor/FirstPartyTools/Screenshot/Skill/SKILL.md
index 422a7ec90f..116b4af479 100644
--- a/Packages/src/Editor/FirstPartyTools/Screenshot/Skill/SKILL.md
+++ b/Packages/src/Editor/FirstPartyTools/Screenshot/Skill/SKILL.md
@@ -23,7 +23,7 @@ uloop screenshot [--window-name <name>] [--resolution-scale <scale>] [--match-mo
 | `--match-mode` | enum | `exact` | Window name matching mode: `exact`, `prefix`, or `contains`. Ignored when the resolved capture mode is rendering (auto during Play Mode resolves to rendering). |
 | `--capture-mode` | enum | `auto` | `auto` - rendering in PlayMode and window otherwise, `window` - capture EditorWindow including toolbar, `rendering` - capture game rendering only (PlayMode required), `GameView` - alias for `rendering`. Rendering screenshots return `ScreenshotToInputFormula` for converting raw image pixels before calling simulate-mouse-input (including `--dry-run`) or simulate-mouse-ui. |
 | `--output-directory` | string | `""` | Output directory path for saving screenshots. When empty, uses default path (.uloop/outputs/Screenshots/). Accepts absolute paths. |
-| `--annotate-elements` | flag | - | Annotate interactive UI elements with index labels and interaction hints (A / CLICK, B / DRAG, ...). The response includes an `AnnotatedElements` array with element metadata sorted by `SortingOrder` then `SiblingIndex` (an approximation of z-order, not the guaranteed draw order). Only works when the resolved capture mode is rendering (auto during Play Mode resolves to rendering) in PlayMode. |
+| `--annotate-elements` | flag | - | Annotate interactive uGUI elements and UI Toolkit controls on screen-space panels with index labels and interaction hints (A / CLICK, B / DRAG, ...). The response includes an `AnnotatedElements` array with element metadata sorted by `SortingOrder` then `SiblingIndex` (an approximation of z-order, not the guaranteed draw order). Only works when the resolved capture mode is rendering (auto during Play Mode resolves to rendering) in PlayMode. |
 | `--annotate-raycast-grid` | flag | - | Annotate clustered 3D physics collider candidates as `PhysicsCollider` entries in `AnnotatedElements`. Uses `Camera.main` visibility and the same top-left Game View coordinates as `simulate-mouse-input`. Only works when the resolved capture mode is rendering (auto during Play Mode resolves to rendering) in PlayMode. |
 | `--raycast-layer-mask` | string | `""` | Comma-separated physics layer names to narrow which layers `--annotate-raycast-grid` clusters. Hits are limited to layers also visible to `Camera.main.cullingMask`. When omitted, clusters against `Physics.DefaultRaycastLayers`. |
 | `--elements-only` | flag | - | Return only annotated element JSON without capturing a screenshot image. Requires `--annotate-elements` or `--annotate-raycast-grid`, and the resolved capture mode to be rendering (auto during Play Mode resolves to rendering) in PlayMode. |
diff --git a/Packages/src/Editor/FirstPartyTools/Screenshot/Skill/references/annotated-elements.md b/Packages/src/Editor/FirstPartyTools/Screenshot/Skill/references/annotated-elements.md
index 1ef3f771da..5e1338e01d 100644
--- a/Packages/src/Editor/FirstPartyTools/Screenshot/Skill/references/annotated-elements.md
+++ b/Packages/src/Editor/FirstPartyTools/Screenshot/Skill/references/annotated-elements.md
@@ -10,15 +10,16 @@ Device Simulator is supported for this flow: prefer `--capture-mode rendering` (
 
 - `Label`: Index label in JSON (`A` = first in that sort, `B` = next, ...). Treat it as a stable handle, not as proof of what is actually in front: when overlapping elements cross parents, pick the target by `Path` and confirm the result with `simulate-mouse-ui`'s `HitGameObjectName` — the handler that received the events, resolved up the hierarchy from the raycast hit (or from `--target-path` in bypass mode), so it can name an ancestor of the element you clicked. Screenshot labels also include the interaction hint, such as `A / CLICK` or `B / DRAG`.
 - `Name`: Element name
-- `Path`: Hierarchy path from the scene root, for example `Canvas/Panel/Button`. Use this as `simulate-mouse-ui --target-path` when bypassing raycast blockers.
+- `Path`: Hierarchy path from the scene root, for example `Canvas/Panel/Button`. Use this as `simulate-mouse-ui --target-path` when bypassing raycast blockers. UI Toolkit entries use a different form that `--target-path` does not accept; see [UI Toolkit Elements](#ui-toolkit-elements).
 - `Type`: Element type (`Button`, `Toggle`, `Slider`, `Dropdown`, `InputField`, `Scrollbar`, `Draggable`, `DropTarget`, `Selectable`, `PhysicsCollider`)
 - `Interaction`: Derived interaction category (`Click`, `Drag`, `Drop`, `Text`) or `Raycast` for clustered physics collider entries. Use this to choose between `simulate-mouse-ui --action Click`, drag actions, or `simulate-mouse-input` (including `--dry-run`).
+- `UiSystem`: UI system the entry came from: `UGUI`, `UIToolkit`, or empty for `PhysicsCollider` entries.
 - `Layer`: Physics layer name for `PhysicsCollider` entries. Empty for UI entries.
 - `Components`: Collider and MonoBehaviour component type names from the hit GameObject for `PhysicsCollider` entries. Empty for UI entries.
 - `SimX`, `SimY`: Target click position in top-left Game View coordinates. For UI entries this is the element center when that center is raycast-reachable; otherwise it is a reachable probe point inside the bounds (center, then four interior quarter points). For `PhysicsCollider` entries this is a representative sampled hit. Use these directly with `simulate-mouse-ui --x/--y` or `simulate-mouse-input --x/--y` (`--dry-run` optional).
 - `BoundsMinX`, `BoundsMinY`, `BoundsMaxX`, `BoundsMaxY`: Bounding box in the same coordinates as `SimX/SimY`. For `PhysicsCollider` entries, this is the axis-aligned sampled-cell coverage box from reachable raycast hits, not a guarantee that every interior point is clickable.
-- `SortingOrder`: Canvas sorting order. Higher values are in front.
-- `SiblingIndex`: Transform sibling index under the element's direct parent. Do not use it as a reliable z-order signal across nested UI hierarchies; the frontmost-first sort above can then disagree with draw order.
+- `SortingOrder`: Canvas sorting order (for UI Toolkit, the panel's `PanelSettings.sortingOrder` rounded down). Higher values are in front.
+- `SiblingIndex`: Transform sibling index under the element's direct parent (for UI Toolkit, the index in the parent visual element). Do not use it as a reliable z-order signal across nested UI hierarchies; the frontmost-first sort above can then disagree with draw order.
 
 ## Exclusion rules (by design)
 
@@ -29,6 +30,33 @@ The annotator lists elements that share the same EventSystem raycast path as `si
 - Elements whose center and four interior quarter probe points are all covered by another raycast hit are not listed.
 - Selectables that are not interactable (`interactable = false`, or a parent `CanvasGroup` with `interactable = false`) ignore clicks and drags, so they are not listed. A separate pointer handler script on the same GameObject is still listed as that handler.
 
+## UI Toolkit Elements
+
+Entries with `UiSystem` `UIToolkit` come from the `UIDocument`s on screen-space panels shown in the Game View. They use the same fields and top-left Game View coordinates as uGUI entries.
+
+- `Type`: `Button` (`Button`, `RepeatButton`), `Toggle` (`Toggle` and other boolean fields), `Slider` (`Slider`, `SliderInt`, `MinMaxSlider`), `Scrollbar` (`Scroller`, including the scrollers of a `ScrollView`), `InputField` (`TextField`), `Dropdown` (`DropdownField`, `EnumField`). `Interaction` follows from `Type` as for uGUI.
+- `Path`: `<UIDocument GameObject path>#<element chain>`, for example `UI/Menu#panel/play`. The chain starts below the document root and joins element names with `/`; an element without a name appears as its type name.
+
+Omitted on purpose:
+
+- Disabled elements, `visibility: hidden`, `display: none` (with everything under it), and zero-size elements.
+- Elements covered at the center and every interior quarter probe point by a panel with a higher sorting order or by another element of the same panel, including parts clipped away by a parent with `overflow: hidden`.
+- Panels that render into a RenderTexture, panels on a display other than the Game View's, world-space panels (Unity 6), and panels whose screen-to-panel mapping is not a plain scale and offset.
+- Parts inside a control (the slider and buttons of a `Scroller`, for example) and any element that is not one of the types above. A custom element with only a `Clickable` manipulator is not listed.
+
+Limits:
+
+- When uGUI and UI Toolkit overlap, which one is in front is not checked; both may be listed.
+- Panels with the same sorting order are not checked against each other.
+- `Bounds` is the whole element rectangle and can include parts clipped away by a parent.
+- Unity 2022.3 with both Device Simulator and Game View open lays UI Toolkit panels out at the Game View size and stretches them onto the simulated screen. Bounds and `SimX`/`SimY` then match where clicks land but not the PNG, and `set-game-view-size` cannot change the hidden Game View while Simulator is shown. Closing the Game View while using Simulator makes them match.
+
+Clicking:
+
+- `simulate-mouse-input --action Click --x <SimX> --y <SimY>` reaches UI Toolkit controls when the scene has an EventSystem with an Input System UI input module.
+- Without an EventSystem the click does not reach UI Toolkit controls.
+- `simulate-mouse-ui` does not reach UI Toolkit controls, and its `--target-path` does not accept UI Toolkit `Path` values.
+
 ### PhysicsCollider Entries Per Closed Region
 
 When a single `PhysicsCollider` GameObject's reachable raycast samples form multiple 4-connected regions on screen — typically because UI occlusion splits them apart — each region becomes its own `AnnotatedElements` entry. `Path`, `Name`, `Layer`, and `Components` are identical across those entries (they describe the same GameObject), while `Label`, `Bounds`, `SimX`, `SimY`, and `RaycastOutlineSegments` are independent per region so each closed area is separately addressable.
diff --git a/Packages/src/Editor/FirstPartyTools/SimulateMouseInput/Skill/SKILL.md b/Packages/src/Editor/FirstPartyTools/SimulateMouseInput/Skill/SKILL.md
index b4e63a2c51..d7c92b3d44 100644
--- a/Packages/src/Editor/FirstPartyTools/SimulateMouseInput/Skill/SKILL.md
+++ b/Packages/src/Editor/FirstPartyTools/SimulateMouseInput/Skill/SKILL.md
@@ -110,7 +110,7 @@ uloop simulate-mouse-input --action SmoothDelta --delta-x 300 --delta-y 0 --dura
 ## Coordinate System
 
 `--x`/`--y` use top-left Game View coordinates: pass `AnnotatedElements[].SimX/SimY`
-directly, convert raw screenshot pixels with `ScreenshotToInputFormula`, and never flip Y
+directly (UI Toolkit entries need an EventSystem in the scene), convert raw screenshot pixels with `ScreenshotToInputFormula`, and never flip Y
 in the caller (the tool converts internally). Conversion formula, Device Simulator
 notes, and how the injected position reads back inside Unity are in
 `references/output-and-coordinates.md`.
diff --git a/Packages/src/Editor/FirstPartyTools/SimulateMouseInput/Skill/references/output-and-coordinates.md b/Packages/src/Editor/FirstPartyTools/SimulateMouseInput/Skill/references/output-and-coordinates.md
index ac7a1299f2..a5998020b4 100644
--- a/Packages/src/Editor/FirstPartyTools/SimulateMouseInput/Skill/references/output-and-coordinates.md
+++ b/Packages/src/Editor/FirstPartyTools/SimulateMouseInput/Skill/references/output-and-coordinates.md
@@ -30,7 +30,7 @@ Verify visual outcome with a follow-up screenshot.
 
 - `--x` / `--y` use **top-left Game View coordinates**.
 - Raw image pixels from `uloop screenshot --capture-mode rendering` must be converted with `ScreenshotToInputFormula`.
-- `AnnotatedElements[].SimX/SimY` can be passed directly to this tool.
+- `AnnotatedElements[].SimX/SimY` can be passed directly to this tool. For UI Toolkit entries (`UiSystem` `UIToolkit`), a `Click` reaches the control only when the scene has an EventSystem with an Input System UI input module; without one, nothing receives the click.
 - Do not flip Y in the caller. The tool converts internally for Unity Input System:
 
 ```text
diff --git a/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/Skill/SKILL.md b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/Skill/SKILL.md
index 88af8895ab..03417c9713 100644
--- a/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/Skill/SKILL.md
+++ b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/Skill/SKILL.md
@@ -64,6 +64,7 @@ uloop simulate-mouse-ui --action <action> --x <x> --y <y> [options]
 - Get coordinates from `AnnotatedElements` JSON (`SimX`/`SimY`) — do NOT look up GameObject positions
 - `--bypass-raycast` still uses coordinates for pointer event positions, but chooses the clicked, long-pressed, or dragged GameObject by `--target-path`
 - If `--target-path` or `--drop-target-path` matches multiple active GameObjects, the command fails instead of choosing an arbitrary duplicate
+- Not for UI Toolkit entries (`UiSystem` `UIToolkit`); see `references/output.md`.
 - Device Simulator play view is supported. Prefer `uloop screenshot --capture-mode rendering --annotate-elements` for coordinates; they use the simulated device resolution (`Handles.GetMainGameViewSize()` / `Screen`), not the Simulator chrome scale.
 
 ## Pause Point Inspection (Standard for E2E)
diff --git a/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/Skill/references/output.md b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/Skill/references/output.md
index 779111873e..043b24d6aa 100644
--- a/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/Skill/references/output.md
+++ b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/Skill/references/output.md
@@ -15,3 +15,7 @@ Returns JSON with:
 Verify the visual outcome with a follow-up `uloop screenshot --capture-mode rendering --annotate-elements`.
 
 Note: Click and LongPress on empty space (no UI element) still return `Success = true` with `HitGameObjectName = null`. Drag actions on empty space return `Success = false`.
+
+## UI Toolkit Elements
+
+`simulate-mouse-ui` drives the uGUI EventSystem raycast path, so it does not reach UI Toolkit controls (`AnnotatedElements` entries with `UiSystem` `UIToolkit`): a click at their `SimX`/`SimY` lands on the panel's own GameObject instead. `--target-path` does not accept their `Path` either. Click them with `simulate-mouse-input` instead, which works when the scene has an EventSystem with an Input System UI input module.
diff --git a/cli/common/tools/default-tools.json b/cli/common/tools/default-tools.json
index 05360489a3..e82d40a13d 100644
--- a/cli/common/tools/default-tools.json
+++ b/cli/common/tools/default-tools.json
@@ -289,7 +289,7 @@
           },
           "AnnotateElements": {
             "type": "boolean",
-            "description": "Annotate interactive UI elements with index labels and interaction hints (A / CLICK, B / DRAG, ...). The response includes an AnnotatedElements array with element metadata sorted by SortingOrder then SiblingIndex (an approximation of z-order, not the guaranteed draw order). Only works when the resolved capture mode is rendering (auto during Play Mode resolves to rendering) in PlayMode.",
+            "description": "Annotate interactive uGUI elements and UI Toolkit controls on screen-space panels with index labels and interaction hints (A / CLICK, B / DRAG, ...). The response includes an AnnotatedElements array with element metadata sorted by SortingOrder then SiblingIndex (an approximation of z-order, not the guaranteed draw order). Only works when the resolved capture mode is rendering (auto during Play Mode resolves to rendering) in PlayMode.",
             "default": false
           },
           "ElementsOnly": {
diff --git a/scripts/run-posix-e2e.sh b/scripts/run-posix-e2e.sh
index 60e5cf105d..70be2ed8b6 100755
--- a/scripts/run-posix-e2e.sh
+++ b/scripts/run-posix-e2e.sh
@@ -10,6 +10,7 @@ TIMEOUT_SECONDS=120
 LAUNCH_TIMEOUT_SECONDS=240
 SKIP_RECOVERY_READINESS=false
 SKIP_SIMULATE_MOUSE=false
+SKIP_UITOOLKIT_ANNOTATION=false
 
 fail() {
     printf 'ERROR: %s\n' "$1" >&2
@@ -27,6 +28,7 @@ Options:
   --launch-timeout <seconds>         Launch/reuse smoke timeout. Default: 240.
   --skip-recovery-readiness          Skip recovery/readiness smoke.
   --skip-simulate-mouse              Skip simulate-mouse UI E2E.
+  --skip-uitoolkit-annotation        Skip UI Toolkit screenshot annotation E2E.
   -h, --help                         Show this help.
 EOF
 }
@@ -61,6 +63,10 @@ while [ "$#" -gt 0 ]; do
             SKIP_SIMULATE_MOUSE=true
             shift
             ;;
+        --skip-uitoolkit-annotation)
+            SKIP_UITOOLKIT_ANNOTATION=true
+            shift
+            ;;
         -h|--help)
             usage
             exit 0
@@ -141,4 +147,10 @@ if [ "$SKIP_SIMULATE_MOUSE" = false ]; then
             --project-path "$PROJECT_PATH"
 fi
 
+if [ "$SKIP_UITOOLKIT_ANNOTATION" = false ]; then
+    run_step "Screenshot UI Toolkit annotation" \
+        sh "$ROOT_DIR/scripts/test-screenshot-uitoolkit-annotation.sh" \
+            --project-path "$PROJECT_PATH"
+fi
+
 printf '\nAll POSIX terminal-driven E2E checks passed.\n'
diff --git a/scripts/run-windows-e2e.ps1 b/scripts/run-windows-e2e.ps1
index fb5c3bae34..be940ac22b 100644
--- a/scripts/run-windows-e2e.ps1
+++ b/scripts/run-windows-e2e.ps1
@@ -437,6 +437,12 @@ try {
             $ResolvedProjectPath
         )
     }
+    Invoke-Step -Name "Screenshot UI Toolkit Annotation E2E" -Body {
+        Invoke-ScriptChecked -ScriptPath (Resolve-ProjectRelativePath -RelativePath "scripts\test-screenshot-uitoolkit-annotation.ps1") -Arguments @(
+            "-ProjectPath",
+            $ResolvedProjectPath
+        )
+    }
     Invoke-Step -Name "Compile Get Logs Stress" -Body { Invoke-CompileGetLogsStress }
     Invoke-Step -Name "Final Console Check" -Body {
         [pscustomobject]$logs = Invoke-UloopJsonChecked -CommandArguments @("get-logs", "--log-type", "All", "--max-count", "200")
diff --git a/scripts/test-powershell51-native-argument-escaping.ps1 b/scripts/test-powershell51-native-argument-escaping.ps1
index 26965aceaa..f8e7b23834 100644
--- a/scripts/test-powershell51-native-argument-escaping.ps1
+++ b/scripts/test-powershell51-native-argument-escaping.ps1
@@ -9,6 +9,7 @@ $ErrorActionPreference = "Stop"
 [string[]]$ScriptPaths = @(
     "scripts/run-windows-e2e.ps1",
     "scripts/test-simulate-mouse-demo.ps1",
+    "scripts/test-screenshot-uitoolkit-annotation.ps1",
     "Assets/Tests/Demo/scripts/verify-replay-via-cli.ps1"
 )
 
diff --git a/scripts/test-screenshot-uitoolkit-annotation.ps1 b/scripts/test-screenshot-uitoolkit-annotation.ps1
new file mode 100644
index 0000000000..db01ae5431
--- /dev/null
+++ b/scripts/test-screenshot-uitoolkit-annotation.ps1
@@ -0,0 +1,477 @@
+<#
+E2E verification that screenshot --annotate-elements lists UI Toolkit controls, using the uloop CLI against
+UIToolkitAnnotationDemoScene. Safe to run repeatedly: it stops PlayMode and restores the Game View size on exit,
+and never saves the scene.
+
+Usage:
+  powershell -NoProfile -ExecutionPolicy Bypass -File .\scripts\test-screenshot-uitoolkit-annotation.ps1
+  powershell -NoProfile -ExecutionPolicy Bypass -File .\scripts\test-screenshot-uitoolkit-annotation.ps1 -ProjectPath C:\path\to\project
+
+Prerequisites:
+  - Unity Editor is running
+  - uloop is available on PATH
+#>
+
+[CmdletBinding()]
+param(
+    [string]$ProjectPath = "",
+    [int]$UnityWaitAttempts = 15,
+    [int]$PlayModeWaitSeconds = 20,
+    [int]$ControlWaitSeconds = 20
+)
+
+Set-StrictMode -Version Latest
+$ErrorActionPreference = "Stop"
+
+$ScenePath = "Assets/Scenes/UIToolkitAnnotationDemoScene.unity"
+$TempDirectory = Join-Path ([System.IO.Path]::GetTempPath()) "unity-cli-loop-uitk-annotation"
+
+function Get-UloopArguments {
+    param(
+        [string[]]$CommandArguments
+    )
+
+    if ([string]::IsNullOrWhiteSpace($ProjectPath)) {
+        return $CommandArguments
+    }
+
+    return @($CommandArguments + @("--project-path", $ProjectPath))
+}
+
+function ConvertTo-WindowsPowerShellNativeArgument {
+    param(
+        [string]$Argument
+    )
+
+    # Windows argv rules treat backslashes specially only before a quote or the closing quote.
+    # Do not double every backslash: ordinary paths such as C:\Users must stay unchanged.
+    [string]$escapedArgument = [regex]::Replace($Argument, '(\\*)"', {
+        param($match)
+
+        [string]$backslashes = $match.Groups[1].Value
+        return $backslashes + $backslashes + '\"'
+    })
+
+    if ($Argument -notmatch '\s') {
+        return $escapedArgument
+    }
+
+    return [regex]::Replace($escapedArgument, '(\\*)\z', {
+        param($match)
+
+        [string]$backslashes = $match.Groups[1].Value
+        return $backslashes + $backslashes
+    })
+}
+
+function Invoke-UloopCapture {
+    param(
+        [string[]]$CommandArguments
+    )
+
+    [string[]]$arguments = Get-UloopArguments -CommandArguments $CommandArguments
+    if ($PSVersionTable.PSVersion.Major -lt 6) {
+        $arguments = @($arguments | ForEach-Object { ConvertTo-WindowsPowerShellNativeArgument -Argument $_ })
+    }
+
+    [string]$previousErrorActionPreference = $ErrorActionPreference
+    $ErrorActionPreference = "Continue"
+    try {
+        [object[]]$output = & uloop @arguments 2>&1
+        [int]$exitCode = $LASTEXITCODE
+    }
+    finally {
+        $ErrorActionPreference = $previousErrorActionPreference
+    }
+
+    [string]$text = ($output | ForEach-Object { $_.ToString() }) -join [Environment]::NewLine
+
+    return [pscustomobject]@{
+        ExitCode = $exitCode
+        Text = $text
+        Arguments = $arguments
+    }
+}
+
+function Invoke-UloopJson {
+    param(
+        [string[]]$CommandArguments
+    )
+
+    [pscustomobject]$result = Invoke-UloopCapture -CommandArguments $CommandArguments
+    if ($result.ExitCode -ne 0) {
+        if (-not [string]::IsNullOrWhiteSpace($result.Text)) {
+            Write-Host $result.Text
+        }
+
+        [string]$commandText = "uloop " + ($result.Arguments -join " ")
+        throw "$commandText failed with exit code $($result.ExitCode)"
+    }
+
+    return $result.Text | ConvertFrom-Json
+}
+
+function Wait-UnityReady {
+    for ([int]$attempt = 0; $attempt -lt $UnityWaitAttempts; $attempt++) {
+        [pscustomobject]$result = Invoke-UloopCapture -CommandArguments @("get-logs", "--max-count", "1")
+        if ($result.ExitCode -eq 0) {
+            return
+        }
+
+        Start-Sleep -Seconds 2
+    }
+
+    throw "Unity not responding"
+}
+
+function Wait-PlayMode {
+    for ([int]$attempt = 0; $attempt -lt $PlayModeWaitSeconds; $attempt++) {
+        [pscustomobject]$probe = Invoke-UloopCapture -CommandArguments @(
+            "execute-dynamic-code",
+            "--code",
+            "using UnityEngine; return Application.isPlaying;"
+        )
+
+        if ($probe.ExitCode -ne 0) {
+            Start-Sleep -Seconds 1
+            continue
+        }
+
+        [pscustomobject]$result = $probe.Text | ConvertFrom-Json
+        if ($result.Success -eq $true -and $result.Result -eq "True") {
+            return
+        }
+
+        Start-Sleep -Seconds 1
+    }
+
+    throw "Unity did not enter PlayMode within ${PlayModeWaitSeconds}s"
+}
+
+function Assert-EqualText {
+    param(
+        [string]$Actual,
+        [string]$Expected,
+        [string]$Context
+    )
+
+    if ($Actual -eq $Expected) {
+        return
+    }
+
+    throw "${Context}: expected '$Expected', got '$Actual'"
+}
+
+function Select-FullHdGameView {
+    [pscustomobject]$response = Invoke-UloopJson -CommandArguments @(
+        "set-game-view-size",
+        "--width",
+        "1920",
+        "--height",
+        "1080"
+    )
+
+    if ($response.Success -ne $true) {
+        throw "Set Full HD Game View failed: $($response.Message)"
+    }
+
+    Assert-EqualText -Actual ([string]$response.CurrentWidth) -Expected "1920" -Context "Game View width"
+    Assert-EqualText -Actual ([string]$response.CurrentHeight) -Expected "1080" -Context "Game View height"
+    Write-Host "    $($response.CurrentWidth)x$($response.CurrentHeight) (previous: $($response.PreviousWidth)x$($response.PreviousHeight))"
+    Start-Sleep -Seconds 1
+
+    return [pscustomobject]@{
+        Width = [int]$response.PreviousWidth
+        Height = [int]$response.PreviousHeight
+    }
+}
+
+function Restore-GameViewSize {
+    param(
+        [pscustomobject]$OriginalSize
+    )
+
+    if ($null -eq $OriginalSize) {
+        return
+    }
+
+    Invoke-UloopCapture -CommandArguments @(
+        "set-game-view-size",
+        "--width",
+        $OriginalSize.Width.ToString([Globalization.CultureInfo]::InvariantCulture),
+        "--height",
+        $OriginalSize.Height.ToString([Globalization.CultureInfo]::InvariantCulture)
+    ) | Out-Null
+}
+
+# Opening the scene in Single mode closes every loaded scene, so unsaved changes anywhere stop the run instead
+# of being discarded.
+function Initialize-DemoScene {
+    [pscustomobject]$stopResult = Invoke-UloopCapture -CommandArguments @("control-play-mode", "--action", "Stop")
+    if ($stopResult.ExitCode -ne 0 -and -not [string]::IsNullOrWhiteSpace($stopResult.Text)) {
+        Write-Host $stopResult.Text
+    }
+
+    [string]$code = @"
+using UnityEditor.SceneManagement;
+using UnityEngine.SceneManagement;
+for (int i = 0; i < SceneManager.sceneCount; i++)
+{
+    Scene loaded = SceneManager.GetSceneAt(i);
+    if (loaded.isLoaded && loaded.isDirty) { return "DIRTY: " + loaded.path; }
+}
+PrefabStage prefabStage = PrefabStageUtility.GetCurrentPrefabStage();
+if (prefabStage != null && prefabStage.scene.isDirty) { return "DIRTY: " + prefabStage.assetPath; }
+string scenePath = "$ScenePath";
+if (SceneManager.GetActiveScene().path != scenePath)
+{
+    EditorSceneManager.OpenScene(scenePath, OpenSceneMode.Single);
+}
+return SceneManager.GetActiveScene().path;
+"@
+
+    [pscustomobject]$result = Invoke-UloopJson -CommandArguments @("execute-dynamic-code", "--code", $code)
+    if ($result.Success -ne $true) {
+        throw "Failed to load ${ScenePath}: $($result.ErrorMessage)"
+    }
+
+    [string]$scene = [string]$result.Result
+    if ($scene.StartsWith("DIRTY: ")) {
+        throw "Unsaved changes would be lost by opening the demo scene ($($scene.Substring(7))). Save or discard them first."
+    }
+
+    Assert-EqualText -Actual $scene -Expected $ScenePath -Context "Active scene"
+}
+
+function Get-UiToolkitElements {
+    param(
+        [pscustomobject]$Response
+    )
+
+    return ,@($Response.Screenshots[0].AnnotatedElements | Where-Object { $_.UiSystem -eq "UIToolkit" })
+}
+
+function Invoke-ElementsOnlyCapture {
+    [pscustomobject]$response = Invoke-UloopJson -CommandArguments @(
+        "screenshot",
+        "--capture-mode",
+        "rendering",
+        "--annotate-elements",
+        "--elements-only"
+    )
+
+    if ($response.Success -ne $true -or $response.ScreenshotCount -ne 1) {
+        throw "Elements-only capture failed: $($response.Message)"
+    }
+
+    return $response
+}
+
+# The demo builds its controls in Start, so the first captures after entering PlayMode can miss them.
+function Wait-UiToolkitPlay {
+    for ([int]$attempt = 0; $attempt -lt $ControlWaitSeconds; $attempt++) {
+        [pscustomobject]$response = Invoke-ElementsOnlyCapture
+        [object[]]$elements = Get-UiToolkitElements -Response $response
+        if (@($elements | Where-Object { $_.Name -eq "play" }).Count -gt 0) {
+            return
+        }
+
+        Start-Sleep -Seconds 1
+    }
+
+    throw "UI Toolkit element 'play' did not appear"
+}
+
+function Assert-Condition {
+    param(
+        [bool]$Condition,
+        [string]$Message
+    )
+
+    if (-not $Condition) {
+        throw $Message
+    }
+}
+
+function Assert-Near {
+    param(
+        [double]$Actual,
+        [double]$Expected,
+        [string]$Context
+    )
+
+    Assert-Condition -Condition ([Math]::Abs($Actual - $Expected) -le 1) -Message "${Context}: expected $Expected (+/-1), got $Actual"
+}
+
+function Get-SingleUiToolkitElement {
+    param(
+        [object[]]$Elements,
+        [string]$Name,
+        [string]$Type,
+        [string]$Interaction
+    )
+
+    [object[]]$found = @($Elements | Where-Object { $_.Name -eq $Name })
+    Assert-Condition -Condition ($found.Count -eq 1) -Message "Expected exactly one UI Toolkit element named '$Name', found $($found.Count)"
+    Assert-EqualText -Actual $found[0].Type -Expected $Type -Context "$Name Type"
+    Assert-EqualText -Actual $found[0].Interaction -Expected $Interaction -Context "$Name Interaction"
+    return $found[0]
+}
+
+function Test-AnnotatedCapture {
+    $null = New-Item -ItemType Directory -Path $TempDirectory -Force
+    [pscustomobject]$response = Invoke-UloopJson -CommandArguments @(
+        "screenshot",
+        "--capture-mode",
+        "rendering",
+        "--annotate-elements",
+        "--output-directory",
+        $TempDirectory
+    )
+    Assert-Condition -Condition ($response.Success -eq $true -and $response.ScreenshotCount -eq 1) -Message "Annotated capture failed: $($response.Message)"
+
+    [object[]]$elements = Get-UiToolkitElements -Response $response
+    [pscustomobject]$play = Get-SingleUiToolkitElement -Elements $elements -Name "play" -Type "Button" -Interaction "Click"
+    Get-SingleUiToolkitElement -Elements $elements -Name "sound" -Type "Toggle" -Interaction "Click" | Out-Null
+    Get-SingleUiToolkitElement -Elements $elements -Name "volume" -Type "Slider" -Interaction "Drag" | Out-Null
+    Get-SingleUiToolkitElement -Elements $elements -Name "player-name" -Type "InputField" -Interaction "Text" | Out-Null
+    Get-SingleUiToolkitElement -Elements $elements -Name "quality" -Type "Dropdown" -Interaction "Click" | Out-Null
+    [pscustomobject]$partlyCovered = Get-SingleUiToolkitElement -Elements $elements -Name "partly-covered" -Type "Button" -Interaction "Click"
+    Assert-Condition -Condition (@($elements | Where-Object { $_.Type -eq "Scrollbar" }).Count -eq 1) -Message "Expected exactly one UI Toolkit Scrollbar"
+    # The six named controls plus the list's vertical Scroller; parts inside a control would add more.
+    Assert-EqualText -Actual ([string]$elements.Count) -Expected "7" -Context "UI Toolkit element count"
+    Assert-EqualText -Actual $play.Path -Expected "UIToolkitAnnotationDemo/BackDocument#play" -Context "UI Toolkit element 'play' path"
+
+    [object[]]$allElements = @($response.Screenshots[0].AnnotatedElements)
+    Assert-Condition -Condition (@($allElements | Where-Object { $_.Name -eq "locked" -or $_.Name -eq "ghost" }).Count -eq 0) -Message "Disabled or hidden UI Toolkit buttons were annotated"
+
+    # Top-left Game View coordinates: a wrong Y flip moves these away from the layout in the demo.
+    Assert-Near -Actual $play.BoundsMinX -Expected 100 -Context "play BoundsMinX"
+    Assert-Near -Actual $play.BoundsMaxX -Expected 300 -Context "play BoundsMaxX"
+    Assert-Near -Actual $play.BoundsMinY -Expected 100 -Context "play BoundsMinY"
+    Assert-Near -Actual $play.BoundsMaxY -Expected 150 -Context "play BoundsMaxY"
+
+    [double]$coverEdge = $partlyCovered.BoundsMinX + 0.6 * ($partlyCovered.BoundsMaxX - $partlyCovered.BoundsMinX)
+    Assert-Condition -Condition ($partlyCovered.SimX -gt $coverEdge) -Message "UI Toolkit element 'partly-covered' should be clicked right of the panel covering its left 60%"
+
+    foreach ($element in $elements) {
+        [bool]$inside = $element.Path.Contains("#") `
+            -and $element.BoundsMinX -le $element.SimX -and $element.SimX -le $element.BoundsMaxX `
+            -and $element.BoundsMinY -le $element.SimY -and $element.SimY -le $element.BoundsMaxY
+        Assert-Condition -Condition $inside -Message "UI Toolkit element '$($element.Path)' needs a '#' path and a click point inside its bounds"
+    }
+
+    Assert-Condition -Condition (@($allElements | Where-Object { $_.UiSystem -eq "UGUI" -and $_.Name -eq "ugui-button" }).Count -eq 1) -Message "Expected exactly one uGUI element named 'ugui-button'"
+
+    [string]$imagePath = $response.Screenshots[0].ImagePath
+    Assert-Condition -Condition ((Test-Path -LiteralPath $imagePath) -and (Get-Item -LiteralPath $imagePath).Length -gt 0) -Message "Annotated screenshot was not written: $imagePath"
+
+    return $response
+}
+
+# Compares the path set first so an element missing only from the elements-only capture is not overlooked.
+function Test-ElementsOnlyCapture {
+    param(
+        [pscustomobject]$AnnotatedResponse
+    )
+
+    [object[]]$first = Get-UiToolkitElements -Response $AnnotatedResponse
+    [object[]]$second = Get-UiToolkitElements -Response (Invoke-ElementsOnlyCapture)
+    [string]$firstPaths = (@($first | ForEach-Object { $_.Path }) | Sort-Object) -join "|"
+    [string]$secondPaths = (@($second | ForEach-Object { $_.Path }) | Sort-Object) -join "|"
+    Assert-EqualText -Actual $secondPaths -Expected $firstPaths -Context "UI Toolkit element paths in the elements-only capture"
+
+    foreach ($element in $second) {
+        [pscustomobject]$match = @($first | Where-Object { $_.Path -eq $element.Path })[0]
+        foreach ($field in @("SimX", "SimY", "BoundsMinX", "BoundsMaxX", "BoundsMinY", "BoundsMaxY")) {
+            Assert-Near -Actual $element.$field -Expected $match.$field -Context "$($element.Path) $field"
+        }
+    }
+}
+
+function Get-PlayClickCount {
+    [string]$code = @"
+UIToolkitAnnotationDemo demo = UnityEngine.Object.FindObjectOfType<UIToolkitAnnotationDemo>();
+if (demo == null) { return "ERROR: UIToolkitAnnotationDemo not found"; }
+return demo.GetClickCount("play");
+"@
+
+    [pscustomobject]$result = Invoke-UloopJson -CommandArguments @("execute-dynamic-code", "--code", $code)
+    Assert-Condition -Condition ($result.Success -eq $true) -Message "Read play click count failed: $($result.ErrorMessage)"
+    [string]$count = [string]$result.Result
+    if ($count.StartsWith("ERROR:")) {
+        throw "Read play click count failed: $($count.Substring(6).Trim())"
+    }
+
+    return $count
+}
+
+# simulate-mouse-input reaches UI Toolkit buttons through the EventSystem; simulate-mouse-ui does not.
+function Test-Click {
+    param(
+        [pscustomobject]$AnnotatedResponse
+    )
+
+    [object[]]$elements = Get-UiToolkitElements -Response $AnnotatedResponse
+    [pscustomobject]$play = @($elements | Where-Object { $_.Name -eq "play" })[0]
+    [int]$before = [int](Get-PlayClickCount)
+
+    [pscustomobject]$response = Invoke-UloopJson -CommandArguments @(
+        "simulate-mouse-input",
+        "--action",
+        "Click",
+        "--x",
+        ([double]$play.SimX).ToString([Globalization.CultureInfo]::InvariantCulture),
+        "--y",
+        ([double]$play.SimY).ToString([Globalization.CultureInfo]::InvariantCulture)
+    )
+    Assert-Condition -Condition ($response.Success -eq $true) -Message "Click play failed: $($response.Message)"
+    Start-Sleep -Seconds 1
+
+    Assert-EqualText -Actual (Get-PlayClickCount) -Expected ([string]($before + 1)) -Context "play click count"
+}
+
+if (Test-Path -LiteralPath $TempDirectory) {
+    Remove-Item -LiteralPath $TempDirectory -Recurse -Force
+}
+
+Write-Host ""
+Write-Host "========================================="
+Write-Host "  Screenshot UI Toolkit Annotation E2E"
+Write-Host "========================================="
+
+Wait-UnityReady
+
+[pscustomobject]$originalGameViewSize = $null
+
+try {
+    Write-Host "[1/6] Loading UI Toolkit annotation demo scene..."
+    Initialize-DemoScene
+
+    Write-Host "[2/6] Selecting Full HD Game View resolution..."
+    $originalGameViewSize = Select-FullHdGameView
+
+    Write-Host "[3/6] Starting PlayMode and waiting for UI Toolkit controls..."
+    Invoke-UloopJson -CommandArguments @("control-play-mode", "--action", "Play") | Out-Null
+    Wait-PlayMode
+    Wait-UiToolkitPlay
+
+    Write-Host "[4/6] Checking the annotated capture..."
+    [pscustomobject]$annotated = Test-AnnotatedCapture
+
+    Write-Host "[5/6] Checking the elements-only capture matches..."
+    Test-ElementsOnlyCapture -AnnotatedResponse $annotated
+
+    Write-Host "[6/6] Clicking a UI Toolkit button at its annotated point..."
+    Test-Click -AnnotatedResponse $annotated
+
+    Write-Host ""
+    Write-Host "========================================="
+    Write-Host "  RESULT: PASS"
+    Write-Host "========================================="
+    exit 0
+}
+finally {
+    Invoke-UloopCapture -CommandArguments @("control-play-mode", "--action", "Stop") | Out-Null
+    Restore-GameViewSize -OriginalSize $originalGameViewSize
+}
diff --git a/scripts/test-screenshot-uitoolkit-annotation.sh b/scripts/test-screenshot-uitoolkit-annotation.sh
new file mode 100755
index 0000000000..3798ad3b85
--- /dev/null
+++ b/scripts/test-screenshot-uitoolkit-annotation.sh
@@ -0,0 +1,343 @@
+#!/bin/sh
+# E2E verification that screenshot --annotate-elements lists UI Toolkit controls, using the uloop CLI against
+# UIToolkitAnnotationDemoScene. Safe to run repeatedly: it stops PlayMode and restores the Game View size on
+# exit, and never saves the scene.
+
+set -eu
+
+SCENE_PATH="Assets/Scenes/UIToolkitAnnotationDemoScene.unity"
+TMP_DIR="${TMPDIR:-/tmp}/unity-cli-loop-uitk-annotation"
+E1_JSON="$TMP_DIR/annotated.json"
+E2_JSON="$TMP_DIR/elements-only.json"
+POLL_JSON="$TMP_DIR/poll.json"
+ORIGINAL_GAME_VIEW_WIDTH=""
+ORIGINAL_GAME_VIEW_HEIGHT=""
+PROJECT_PATH=""
+ULOOP_PATH="${ULOOP_BIN:-uloop}"
+
+fail() {
+    printf 'ERROR: %s\n' "$1" >&2
+    exit 1
+}
+
+cleanup() {
+    run_uloop control-play-mode --action Stop >/dev/null 2>&1 || true
+    if [ -n "${ORIGINAL_GAME_VIEW_WIDTH:-}" ] && [ -n "${ORIGINAL_GAME_VIEW_HEIGHT:-}" ]; then
+        run_uloop set-game-view-size \
+            --width "$ORIGINAL_GAME_VIEW_WIDTH" \
+            --height "$ORIGINAL_GAME_VIEW_HEIGHT" >/dev/null 2>&1 || true
+    fi
+}
+trap cleanup EXIT INT TERM
+
+while [ "$#" -gt 0 ]; do
+    case "$1" in
+        --project-path)
+            [ "$#" -ge 2 ] || fail "--project-path requires a value"
+            PROJECT_PATH=$2
+            shift 2
+            ;;
+        --uloop-path)
+            [ "$#" -ge 2 ] || fail "--uloop-path requires a value"
+            ULOOP_PATH=$2
+            shift 2
+            ;;
+        -h|--help)
+            printf 'Usage: sh scripts/test-screenshot-uitoolkit-annotation.sh [--project-path <path>] [--uloop-path <path>]\n'
+            exit 0
+            ;;
+        *)
+            fail "unknown option: $1"
+            ;;
+    esac
+done
+
+require_jq() {
+    command -v jq >/dev/null 2>&1 || fail "jq is required to parse uloop JSON responses"
+}
+
+run_uloop() {
+    if [ -n "$PROJECT_PATH" ]; then
+        "$ULOOP_PATH" --project-path "$PROJECT_PATH" "$@"
+        return
+    fi
+
+    "$ULOOP_PATH" "$@"
+}
+
+run_uloop_json() {
+    if ! output=$(run_uloop "$@" 2>&1); then
+        printf '%s\n' "$output" >&2
+        fail "uloop $* failed"
+    fi
+
+    printf '%s\n' "$output"
+}
+
+assert_json_success() {
+    json=$1
+    context=$2
+
+    printf '%s\n' "$json" | jq -e '.Success == true' >/dev/null \
+        || fail "$context failed: $(printf '%s\n' "$json" | jq -r '.ErrorMessage // .Message // .Error // "unknown error"')"
+}
+
+assert_text_equals() {
+    actual=$1
+    expected=$2
+    context=$3
+
+    [ "$actual" = "$expected" ] || fail "$context: expected '$expected', got '$actual'"
+}
+
+# Fails with the message unless the jq filter is true for the file.
+assert_jq() {
+    file=$1
+    filter=$2
+    message=$3
+
+    jq -e "$filter" "$file" >/dev/null || fail "$message"
+}
+
+wait_unity_ready() {
+    attempt=0
+    while [ "$attempt" -lt 15 ]; do
+        if run_uloop get-logs --max-count 1 >/dev/null 2>&1; then
+            return
+        fi
+
+        attempt=$((attempt + 1))
+        sleep 2
+    done
+
+    fail "Unity did not respond to uloop"
+}
+
+wait_play_mode() {
+    attempt=0
+    while [ "$attempt" -lt 20 ]; do
+        json=$(run_uloop_json execute-dynamic-code --code 'using UnityEngine; return Application.isPlaying;')
+        if printf '%s\n' "$json" | jq -e '.Success == true and .Result == "True"' >/dev/null; then
+            return
+        fi
+
+        attempt=$((attempt + 1))
+        sleep 1
+    done
+
+    fail "Unity did not enter PlayMode"
+}
+
+# Opening the scene in Single mode closes every loaded scene, so unsaved changes anywhere stop the run instead
+# of being discarded.
+initialize_demo_scene() {
+    run_uloop control-play-mode --action Stop >/dev/null 2>&1 || true
+
+    code="
+using UnityEditor.SceneManagement;
+using UnityEngine.SceneManagement;
+for (int i = 0; i < SceneManager.sceneCount; i++)
+{
+    Scene loaded = SceneManager.GetSceneAt(i);
+    if (loaded.isLoaded && loaded.isDirty) { return \"DIRTY: \" + loaded.path; }
+}
+PrefabStage prefabStage = PrefabStageUtility.GetCurrentPrefabStage();
+if (prefabStage != null && prefabStage.scene.isDirty) { return \"DIRTY: \" + prefabStage.assetPath; }
+string scenePath = \"$SCENE_PATH\";
+if (SceneManager.GetActiveScene().path != scenePath)
+{
+    EditorSceneManager.OpenScene(scenePath, OpenSceneMode.Single);
+}
+return SceneManager.GetActiveScene().path;
+"
+
+    json=$(run_uloop_json execute-dynamic-code --code "$code")
+    assert_json_success "$json" "Load demo scene"
+    scene=$(printf '%s\n' "$json" | jq -r '.Result')
+    case "$scene" in
+        DIRTY:*)
+            fail "Unsaved changes would be lost by opening the demo scene (${scene#DIRTY: }). Save or discard them first."
+            ;;
+    esac
+    assert_text_equals "$scene" "$SCENE_PATH" "Active scene"
+}
+
+select_full_hd_game_view() {
+    json=$(run_uloop_json set-game-view-size --width 1920 --height 1080)
+    assert_json_success "$json" "Set Full HD Game View"
+    ORIGINAL_GAME_VIEW_WIDTH=$(printf '%s\n' "$json" | jq -r '.PreviousWidth')
+    ORIGINAL_GAME_VIEW_HEIGHT=$(printf '%s\n' "$json" | jq -r '.PreviousHeight')
+    assert_text_equals "$(printf '%s\n' "$json" | jq -r '.CurrentWidth')" "1920" "Game View width"
+    assert_text_equals "$(printf '%s\n' "$json" | jq -r '.CurrentHeight')" "1080" "Game View height"
+    printf '    1920x1080 (previous: %sx%s)\n' "$ORIGINAL_GAME_VIEW_WIDTH" "$ORIGINAL_GAME_VIEW_HEIGHT"
+}
+
+# The demo builds its controls in Start, so the first captures after entering PlayMode can miss them.
+wait_for_uitoolkit_play() {
+    attempt=0
+    while [ "$attempt" -lt 20 ]; do
+        run_uloop_json screenshot --capture-mode rendering --annotate-elements --elements-only >"$POLL_JSON"
+        if jq -e '[.Screenshots[0].AnnotatedElements[]? | select(.UiSystem == "UIToolkit" and .Name == "play")] | length > 0' \
+            "$POLL_JSON" >/dev/null; then
+            return
+        fi
+
+        attempt=$((attempt + 1))
+        sleep 1
+    done
+
+    fail "UI Toolkit element 'play' did not appear"
+}
+
+assert_single_uitoolkit_element() {
+    file=$1
+    name=$2
+    type=$3
+    interaction=$4
+
+    count=$(jq --arg name "$name" \
+        '[.Screenshots[0].AnnotatedElements[] | select(.UiSystem == "UIToolkit" and .Name == $name)] | length' "$file")
+    [ "$count" = "1" ] || fail "Expected exactly one UI Toolkit element named '$name', found $count"
+    assert_jq "$file" \
+        "[.Screenshots[0].AnnotatedElements[] | select(.UiSystem == \"UIToolkit\" and .Name == \"$name\")][0]
+            | .Type == \"$type\" and .Interaction == \"$interaction\"" \
+        "UI Toolkit element '$name' should be $type / $interaction"
+}
+
+verify_annotated_capture() {
+    run_uloop_json screenshot \
+        --capture-mode rendering \
+        --annotate-elements \
+        --output-directory "$TMP_DIR" >"$E1_JSON"
+    assert_jq "$E1_JSON" '.Success == true and .ScreenshotCount == 1' "Annotated capture failed"
+
+    assert_single_uitoolkit_element "$E1_JSON" "play" "Button" "Click"
+    assert_single_uitoolkit_element "$E1_JSON" "sound" "Toggle" "Click"
+    assert_single_uitoolkit_element "$E1_JSON" "volume" "Slider" "Drag"
+    assert_single_uitoolkit_element "$E1_JSON" "player-name" "InputField" "Text"
+    assert_single_uitoolkit_element "$E1_JSON" "quality" "Dropdown" "Click"
+    assert_single_uitoolkit_element "$E1_JSON" "partly-covered" "Button" "Click"
+    assert_jq "$E1_JSON" \
+        '[.Screenshots[0].AnnotatedElements[] | select(.UiSystem == "UIToolkit" and .Type == "Scrollbar")] | length == 1' \
+        "Expected exactly one UI Toolkit Scrollbar"
+    # The six named controls plus the list's vertical Scroller; parts inside a control would add more.
+    count=$(jq '[.Screenshots[0].AnnotatedElements[] | select(.UiSystem == "UIToolkit")] | length' "$E1_JSON")
+    assert_text_equals "$count" "7" "UI Toolkit element count"
+    play_path=$(jq -r '[.Screenshots[0].AnnotatedElements[] | select(.UiSystem == "UIToolkit" and .Name == "play")][0].Path' "$E1_JSON")
+    assert_text_equals "$play_path" "UIToolkitAnnotationDemo/BackDocument#play" "UI Toolkit element 'play' path"
+    assert_jq "$E1_JSON" \
+        '[.Screenshots[0].AnnotatedElements[] | select(.Name == "locked" or .Name == "ghost")] | length == 0' \
+        "Disabled or hidden UI Toolkit buttons were annotated"
+
+    # Top-left Game View coordinates: a wrong Y flip moves these away from the layout in the demo.
+    assert_jq "$E1_JSON" \
+        '[.Screenshots[0].AnnotatedElements[] | select(.UiSystem == "UIToolkit" and .Name == "play")][0]
+            | ((.BoundsMinX - 100) | fabs) <= 1 and ((.BoundsMaxX - 300) | fabs) <= 1
+              and ((.BoundsMinY - 100) | fabs) <= 1 and ((.BoundsMaxY - 150) | fabs) <= 1' \
+        "UI Toolkit element 'play' bounds should be 100,100 to 300,150"
+    assert_jq "$E1_JSON" \
+        '[.Screenshots[0].AnnotatedElements[] | select(.UiSystem == "UIToolkit" and .Name == "partly-covered")][0]
+            | .SimX > .BoundsMinX + 0.6 * (.BoundsMaxX - .BoundsMinX)' \
+        "UI Toolkit element 'partly-covered' should be clicked right of the panel covering its left 60%"
+    assert_jq "$E1_JSON" \
+        '[.Screenshots[0].AnnotatedElements[] | select(.UiSystem == "UIToolkit")]
+            | all((.Path | contains("#"))
+                  and .BoundsMinX <= .SimX and .SimX <= .BoundsMaxX
+                  and .BoundsMinY <= .SimY and .SimY <= .BoundsMaxY)' \
+        "Every UI Toolkit element needs a '#' path and a click point inside its bounds"
+    assert_jq "$E1_JSON" \
+        '[.Screenshots[0].AnnotatedElements[] | select(.UiSystem == "UGUI" and .Name == "ugui-button")] | length == 1' \
+        "Expected exactly one uGUI element named 'ugui-button'"
+
+    image_path=$(jq -r '.Screenshots[0].ImagePath' "$E1_JSON")
+    [ -s "$image_path" ] || fail "Annotated screenshot was not written: $image_path"
+}
+
+# Compares the path set first so an element missing only from the elements-only capture is not overlooked.
+verify_elements_only_capture() {
+    run_uloop_json screenshot --capture-mode rendering --annotate-elements --elements-only >"$E2_JSON"
+    assert_jq "$E2_JSON" '.Success == true and .ScreenshotCount == 1' "Elements-only capture failed"
+
+    paths_filter='[.Screenshots[0].AnnotatedElements[] | select(.UiSystem == "UIToolkit") | .Path] | sort'
+    e1_paths=$(jq -c "$paths_filter" "$E1_JSON")
+    e2_paths=$(jq -c "$paths_filter" "$E2_JSON")
+    assert_text_equals "$e2_paths" "$e1_paths" "UI Toolkit element paths in the elements-only capture"
+
+    jq -e -n --slurpfile e1 "$E1_JSON" --slurpfile e2 "$E2_JSON" '
+        def uitk($doc): [$doc[0].Screenshots[0].AnnotatedElements[] | select(.UiSystem == "UIToolkit")];
+        def close($a; $b): (($a - $b) | fabs) <= 1;
+        uitk($e1) as $first
+        | uitk($e2)
+        | all(. as $second
+              | ($first[] | select(.Path == $second.Path)) as $match
+              | close($match.SimX; $second.SimX) and close($match.SimY; $second.SimY)
+                and close($match.BoundsMinX; $second.BoundsMinX) and close($match.BoundsMaxX; $second.BoundsMaxX)
+                and close($match.BoundsMinY; $second.BoundsMinY) and close($match.BoundsMaxY; $second.BoundsMaxY))' \
+        >/dev/null || fail "Elements-only coordinates differ from the annotated capture by more than 1 pixel"
+}
+
+get_play_click_count() {
+    json=$(run_uloop_json execute-dynamic-code --code '
+UIToolkitAnnotationDemo demo = UnityEngine.Object.FindObjectOfType<UIToolkitAnnotationDemo>();
+if (demo == null) { return "ERROR: UIToolkitAnnotationDemo not found"; }
+return demo.GetClickCount("play");
+')
+    assert_json_success "$json" "Read play click count"
+    count=$(printf '%s\n' "$json" | jq -r '.Result')
+    case "$count" in
+        ERROR:*)
+            fail "Read play click count failed: ${count#ERROR: }"
+            ;;
+    esac
+    printf '%s\n' "$count"
+}
+
+# simulate-mouse-input reaches UI Toolkit buttons through the EventSystem; simulate-mouse-ui does not.
+verify_click() {
+    x=$(jq -r '[.Screenshots[0].AnnotatedElements[] | select(.UiSystem == "UIToolkit" and .Name == "play")][0].SimX' "$E1_JSON")
+    y=$(jq -r '[.Screenshots[0].AnnotatedElements[] | select(.UiSystem == "UIToolkit" and .Name == "play")][0].SimY' "$E1_JSON")
+    before=$(get_play_click_count)
+
+    json=$(run_uloop_json simulate-mouse-input --action Click --x "$x" --y "$y")
+    assert_json_success "$json" "Click play"
+    sleep 1
+
+    after=$(get_play_click_count)
+    assert_text_equals "$after" "$((before + 1))" "play click count"
+}
+
+rm -rf "$TMP_DIR"
+mkdir -p "$TMP_DIR"
+require_jq
+
+printf '\n'
+printf '=========================================\n'
+printf '  Screenshot UI Toolkit Annotation E2E\n'
+printf '=========================================\n'
+
+wait_unity_ready
+
+printf '[1/6] Loading UI Toolkit annotation demo scene...\n'
+initialize_demo_scene
+
+printf '[2/6] Selecting Full HD Game View resolution...\n'
+select_full_hd_game_view
+
+printf '[3/6] Starting PlayMode and waiting for UI Toolkit controls...\n'
+run_uloop_json control-play-mode --action Play >/dev/null
+wait_play_mode
+wait_for_uitoolkit_play
+
+printf '[4/6] Checking the annotated capture...\n'
+verify_annotated_capture
+
+printf '[5/6] Checking the elements-only capture matches...\n'
+verify_elements_only_capture
+
+printf '[6/6] Clicking a UI Toolkit button at its annotated point...\n'
+verify_click
+
+printf '\n'
+printf '=========================================\n'
+printf '  RESULT: PASS\n'
+printf '=========================================\n'

From 63ce71f6fb376aa208d4f4681fb996d42cafee5d Mon Sep 17 00:00:00 2001
From: Masamichi Hatayama <booqle@gmail.com>
Date: Wed, 14 Oct 2026 00:21:58 +0900
Subject: [PATCH 3/5] refactor: UI Toolkit screen elements move into a shared
 module behind one entry point (#3311)

---
 .../Editor/UnityCLILoop.Tests.Editor.asmdef   |   1 +
 .../UnityCLILoop.Tests.PlayMode.asmdef        |   1 +
 .../Common/MouseUi/AssemblyInfo.cs            |   1 +
 .../FirstPartyTools/Common/UIToolkit.meta     |   8 +
 .../Common/UIToolkit/AssemblyInfo.cs          |   6 +
 .../Common/UIToolkit/AssemblyInfo.cs.meta     |  11 +
 .../UIToolkit/UIToolkitControlCollector.cs    | 141 ++++++++
 .../UIToolkitControlCollector.cs.meta         |  11 +
 .../UIToolkit}/UIToolkitElementClassifier.cs  |   0
 .../UIToolkitElementClassifier.cs.meta        |   0
 .../Common/UIToolkit/UIToolkitElementPath.cs  |  43 +++
 .../UIToolkit/UIToolkitElementPath.cs.meta    |  11 +
 .../UIToolkit}/UIToolkitPanelKind.cs          |   0
 .../UIToolkit}/UIToolkitPanelKind.cs.meta     |   0
 .../UIToolkit}/UIToolkitReachabilityProbe.cs  |   0
 .../UIToolkitReachabilityProbe.cs.meta        |   0
 .../UIToolkit/UIToolkitScreenControl.cs       |  49 +++
 .../UIToolkit/UIToolkitScreenControl.cs.meta  |  11 +
 .../UIToolkit/UIToolkitScreenElements.cs      |  36 ++
 .../UIToolkit/UIToolkitScreenElements.cs.meta |  11 +
 .../UIToolkit}/UIToolkitScreenMapping.cs      |   0
 .../UIToolkit}/UIToolkitScreenMapping.cs.meta |   0
 .../Common/UIToolkit/UIToolkitScreenPanels.cs | 137 ++++++++
 .../UIToolkit/UIToolkitScreenPanels.cs.meta   |  11 +
 ...tPartyTools.Common.UIToolkit.Editor.asmdef |  18 +
 ...yTools.Common.UIToolkit.Editor.asmdef.meta |   7 +
 .../UIToolkitElementCollector.cs              | 320 ++----------------
 ...p.FirstPartyTools.Screenshot.Editor.asmdef |   1 +
 28 files changed, 546 insertions(+), 289 deletions(-)
 create mode 100644 Packages/src/Editor/FirstPartyTools/Common/UIToolkit.meta
 create mode 100644 Packages/src/Editor/FirstPartyTools/Common/UIToolkit/AssemblyInfo.cs
 create mode 100644 Packages/src/Editor/FirstPartyTools/Common/UIToolkit/AssemblyInfo.cs.meta
 create mode 100644 Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UIToolkitControlCollector.cs
 create mode 100644 Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UIToolkitControlCollector.cs.meta
 rename Packages/src/Editor/FirstPartyTools/{Screenshot/UIToolkitAnnotation => Common/UIToolkit}/UIToolkitElementClassifier.cs (100%)
 rename Packages/src/Editor/FirstPartyTools/{Screenshot/UIToolkitAnnotation => Common/UIToolkit}/UIToolkitElementClassifier.cs.meta (100%)
 create mode 100644 Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UIToolkitElementPath.cs
 create mode 100644 Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UIToolkitElementPath.cs.meta
 rename Packages/src/Editor/FirstPartyTools/{Screenshot/UIToolkitAnnotation => Common/UIToolkit}/UIToolkitPanelKind.cs (100%)
 rename Packages/src/Editor/FirstPartyTools/{Screenshot/UIToolkitAnnotation => Common/UIToolkit}/UIToolkitPanelKind.cs.meta (100%)
 rename Packages/src/Editor/FirstPartyTools/{Screenshot/UIToolkitAnnotation => Common/UIToolkit}/UIToolkitReachabilityProbe.cs (100%)
 rename Packages/src/Editor/FirstPartyTools/{Screenshot/UIToolkitAnnotation => Common/UIToolkit}/UIToolkitReachabilityProbe.cs.meta (100%)
 create mode 100644 Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UIToolkitScreenControl.cs
 create mode 100644 Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UIToolkitScreenControl.cs.meta
 create mode 100644 Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UIToolkitScreenElements.cs
 create mode 100644 Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UIToolkitScreenElements.cs.meta
 rename Packages/src/Editor/FirstPartyTools/{Screenshot/UIToolkitAnnotation => Common/UIToolkit}/UIToolkitScreenMapping.cs (100%)
 rename Packages/src/Editor/FirstPartyTools/{Screenshot/UIToolkitAnnotation => Common/UIToolkit}/UIToolkitScreenMapping.cs.meta (100%)
 create mode 100644 Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UIToolkitScreenPanels.cs
 create mode 100644 Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UIToolkitScreenPanels.cs.meta
 create mode 100644 Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UnityCLILoop.FirstPartyTools.Common.UIToolkit.Editor.asmdef
 create mode 100644 Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UnityCLILoop.FirstPartyTools.Common.UIToolkit.Editor.asmdef.meta

diff --git a/Assets/Tests/Editor/UnityCLILoop.Tests.Editor.asmdef b/Assets/Tests/Editor/UnityCLILoop.Tests.Editor.asmdef
index 6963c78b6d..457d9307bb 100644
--- a/Assets/Tests/Editor/UnityCLILoop.Tests.Editor.asmdef
+++ b/Assets/Tests/Editor/UnityCLILoop.Tests.Editor.asmdef
@@ -17,6 +17,7 @@
         "GUID:f1a38fcd7e85047c5a86331a3e37ddfc",
         "GUID:45d3617c96fa64d3e95383450e67f25a",
         "GUID:a2d87883023de4cf59b7d1962d5dd8aa",
+        "GUID:569bba870e5e64d0d94144057b927001",
         "GUID:527f26a36b5043c2bd4d4036d04cd76d",
         "GUID:94d8abc693f543a691a4645a5ff42e5c",
         "GUID:aa7cf56cc5f074e57ba35272b877e116",
diff --git a/Assets/Tests/PlayMode/UnityCLILoop.Tests.PlayMode.asmdef b/Assets/Tests/PlayMode/UnityCLILoop.Tests.PlayMode.asmdef
index f3c297c562..2ed54bbd2e 100644
--- a/Assets/Tests/PlayMode/UnityCLILoop.Tests.PlayMode.asmdef
+++ b/Assets/Tests/PlayMode/UnityCLILoop.Tests.PlayMode.asmdef
@@ -14,6 +14,7 @@
         "GUID:45d3617c96fa64d3e95383450e67f25a",
         "GUID:527f26a36b5043c2bd4d4036d04cd76d",
         "GUID:a2d87883023de4cf59b7d1962d5dd8aa",
+        "GUID:569bba870e5e64d0d94144057b927001",
         "GUID:aa7cf56cc5f074e57ba35272b877e116",
         "GUID:dc412b2cd951d452b8dcec99c3adeb19",
         "GUID:3b7aa330d87dc452293296dd5830859b",
diff --git a/Packages/src/Editor/FirstPartyTools/Common/MouseUi/AssemblyInfo.cs b/Packages/src/Editor/FirstPartyTools/Common/MouseUi/AssemblyInfo.cs
index 3cce180a5f..2d7abfd1a7 100644
--- a/Packages/src/Editor/FirstPartyTools/Common/MouseUi/AssemblyInfo.cs
+++ b/Packages/src/Editor/FirstPartyTools/Common/MouseUi/AssemblyInfo.cs
@@ -2,6 +2,7 @@
 
 [assembly: InternalsVisibleTo("UnityCLILoop.FirstPartyTools.Editor")]
 [assembly: InternalsVisibleTo("UnityCLILoop.FirstPartyTools.Common.InputRecording.Editor")]
+[assembly: InternalsVisibleTo("UnityCLILoop.FirstPartyTools.Common.UIToolkit.Editor")]
 [assembly: InternalsVisibleTo("UnityCLILoop.FirstPartyTools.ReplayInput.Editor")]
 [assembly: InternalsVisibleTo("UnityCLILoop.FirstPartyTools.Screenshot.Editor")]
 [assembly: InternalsVisibleTo("UnityCLILoop.FirstPartyTools.SimulateMouseUi.Editor")]
diff --git a/Packages/src/Editor/FirstPartyTools/Common/UIToolkit.meta b/Packages/src/Editor/FirstPartyTools/Common/UIToolkit.meta
new file mode 100644
index 0000000000..93e15e8c20
--- /dev/null
+++ b/Packages/src/Editor/FirstPartyTools/Common/UIToolkit.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 0762c3778edd0468ca0bd7dd96a36017
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Packages/src/Editor/FirstPartyTools/Common/UIToolkit/AssemblyInfo.cs b/Packages/src/Editor/FirstPartyTools/Common/UIToolkit/AssemblyInfo.cs
new file mode 100644
index 0000000000..6f9143d26e
--- /dev/null
+++ b/Packages/src/Editor/FirstPartyTools/Common/UIToolkit/AssemblyInfo.cs
@@ -0,0 +1,6 @@
+using System.Runtime.CompilerServices;
+
+// Only the tests see these internals: tools use this module through its entry point alone, and the
+// compiler keeps them away from the parts behind it.
+[assembly: InternalsVisibleTo("UnityCLILoop.Tests.Editor")]
+[assembly: InternalsVisibleTo("UnityCLILoop.Tests.PlayMode")]
diff --git a/Packages/src/Editor/FirstPartyTools/Common/UIToolkit/AssemblyInfo.cs.meta b/Packages/src/Editor/FirstPartyTools/Common/UIToolkit/AssemblyInfo.cs.meta
new file mode 100644
index 0000000000..fdfcb15522
--- /dev/null
+++ b/Packages/src/Editor/FirstPartyTools/Common/UIToolkit/AssemblyInfo.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: e4f778f9f51ce401bb91136ac63086a4
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UIToolkitControlCollector.cs b/Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UIToolkitControlCollector.cs
new file mode 100644
index 0000000000..61d742d76b
--- /dev/null
+++ b/Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UIToolkitControlCollector.cs
@@ -0,0 +1,141 @@
+#nullable enable
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.UIElements;
+
+namespace io.github.hatayama.UnityCliLoop.FirstPartyTools
+{
+    /// <summary>
+    /// Walks the documents of the gathered panels and lists their reachable controls in top-left Game View
+    /// pixels, skipping controls that pointer input could not reach.
+    /// </summary>
+    internal static class UIToolkitControlCollector
+    {
+        // Expects the panels' layouts to be settled already, because bounds and picking read them.
+        internal static List<UIToolkitScreenControl> Collect(
+            List<UIToolkitScreenPanels.PanelEntry> panels,
+            Func<Rect, IReadOnlyList<Vector2>> probePointsForTopLeftBounds)
+        {
+            List<UIToolkitScreenControl> controls = new List<UIToolkitScreenControl>();
+            foreach (UIToolkitScreenPanels.PanelEntry entry in panels)
+            {
+                if (entry.Mapping == null)
+                {
+                    continue;
+                }
+
+                VisitContext context = new VisitContext(
+                    entry,
+                    entry.Mapping,
+                    UIToolkitScreenPanels.CreateFrontPickers(panels, entry),
+                    point => UIToolkitScreenPanels.PickInPanel(entry.Panel, point),
+                    probePointsForTopLeftBounds,
+                    controls);
+                foreach (UIDocument document in entry.Documents)
+                {
+                    Visit(document.rootVisualElement, document, context);
+                }
+            }
+
+            return controls;
+        }
+
+        private static void Visit(VisualElement element, UIDocument document, VisitContext context)
+        {
+            // A child can still resolve to Flex under a display:none parent, so the whole subtree stops here.
+            if (element.resolvedStyle.display == DisplayStyle.None)
+            {
+                return;
+            }
+
+            string? type = UIToolkitElementClassifier.Classify(element);
+            if (type != null)
+            {
+                TryAdd(element, type, document, context);
+
+                // The parts inside a control (the slider and buttons of a Scroller, for example) are not
+                // separate controls.
+                return;
+            }
+
+            // hierarchy, not Children(): Children() lists only the content container, which hides a
+            // ScrollView's scrollers.
+            for (int index = 0; index < element.hierarchy.childCount; index++)
+            {
+                Visit(element.hierarchy[index], document, context);
+            }
+        }
+
+        private static void TryAdd(VisualElement element, string type, UIDocument document, VisitContext context)
+        {
+            if (!element.enabledInHierarchy || element.resolvedStyle.visibility == Visibility.Hidden)
+            {
+                return;
+            }
+
+            Rect worldBound = element.worldBound;
+            if (!IsFiniteNonEmpty(worldBound))
+            {
+                return;
+            }
+
+            Vector2 topLeftMin = context.Mapping.PanelToScreenTopLeft(new Vector2(worldBound.xMin, worldBound.yMin));
+            Vector2 topLeftMax = context.Mapping.PanelToScreenTopLeft(new Vector2(worldBound.xMax, worldBound.yMax));
+            Rect topLeftBounds = Rect.MinMaxRect(topLeftMin.x, topLeftMin.y, topLeftMax.x, topLeftMax.y);
+
+            Vector2? reachable = UIToolkitReachabilityProbe.FindReachablePoint(
+                context.ProbePointsForTopLeftBounds(topLeftBounds), element, context.FrontPickers, context.OwnPicker);
+            if (reachable == null)
+            {
+                return;
+            }
+
+            VisualElement? parent = element.hierarchy.parent;
+            context.Controls.Add(new UIToolkitScreenControl(
+                UIToolkitElementPath.GetDisplayName(element),
+                UIToolkitElementPath.Build(document, element),
+                type,
+                topLeftBounds,
+                reachable.Value,
+                Mathf.FloorToInt(context.Entry.SortingOrder),
+                parent == null ? 0 : parent.hierarchy.IndexOf(element)));
+        }
+
+        private static bool IsFiniteNonEmpty(Rect rect)
+        {
+            return float.IsFinite(rect.x)
+                && float.IsFinite(rect.y)
+                && float.IsFinite(rect.width)
+                && float.IsFinite(rect.height)
+                && rect.width > 0f
+                && rect.height > 0f;
+        }
+
+        private sealed class VisitContext
+        {
+            internal VisitContext(
+                UIToolkitScreenPanels.PanelEntry entry,
+                UIToolkitScreenMapping mapping,
+                List<Func<Vector2, VisualElement?>> frontPickers,
+                Func<Vector2, VisualElement?> ownPicker,
+                Func<Rect, IReadOnlyList<Vector2>> probePointsForTopLeftBounds,
+                List<UIToolkitScreenControl> controls)
+            {
+                Entry = entry;
+                Mapping = mapping;
+                FrontPickers = frontPickers;
+                OwnPicker = ownPicker;
+                ProbePointsForTopLeftBounds = probePointsForTopLeftBounds;
+                Controls = controls;
+            }
+
+            internal UIToolkitScreenPanels.PanelEntry Entry { get; }
+            internal UIToolkitScreenMapping Mapping { get; }
+            internal List<Func<Vector2, VisualElement?>> FrontPickers { get; }
+            internal Func<Vector2, VisualElement?> OwnPicker { get; }
+            internal Func<Rect, IReadOnlyList<Vector2>> ProbePointsForTopLeftBounds { get; }
+            internal List<UIToolkitScreenControl> Controls { get; }
+        }
+    }
+}
diff --git a/Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UIToolkitControlCollector.cs.meta b/Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UIToolkitControlCollector.cs.meta
new file mode 100644
index 0000000000..e6e5e54847
--- /dev/null
+++ b/Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UIToolkitControlCollector.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: a6afaba0bcc1a45978ec99510bea2198
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Packages/src/Editor/FirstPartyTools/Screenshot/UIToolkitAnnotation/UIToolkitElementClassifier.cs b/Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UIToolkitElementClassifier.cs
similarity index 100%
rename from Packages/src/Editor/FirstPartyTools/Screenshot/UIToolkitAnnotation/UIToolkitElementClassifier.cs
rename to Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UIToolkitElementClassifier.cs
diff --git a/Packages/src/Editor/FirstPartyTools/Screenshot/UIToolkitAnnotation/UIToolkitElementClassifier.cs.meta b/Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UIToolkitElementClassifier.cs.meta
similarity index 100%
rename from Packages/src/Editor/FirstPartyTools/Screenshot/UIToolkitAnnotation/UIToolkitElementClassifier.cs.meta
rename to Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UIToolkitElementClassifier.cs.meta
diff --git a/Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UIToolkitElementPath.cs b/Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UIToolkitElementPath.cs
new file mode 100644
index 0000000000..2fe140ba06
--- /dev/null
+++ b/Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UIToolkitElementPath.cs
@@ -0,0 +1,43 @@
+#nullable enable
+using System.Collections.Generic;
+using UnityEngine.UIElements;
+
+namespace io.github.hatayama.UnityCliLoop.FirstPartyTools
+{
+    /// <summary>
+    /// Names UI Toolkit elements the way annotations report them: the owning document's GameObject path,
+    /// a '#', then the element chain below the document root.
+    /// </summary>
+    internal static class UIToolkitElementPath
+    {
+        private const char PATH_SEPARATOR = '#';
+        private const string CHAIN_SEPARATOR = "/";
+
+        internal static string Build(UIDocument document, VisualElement element)
+        {
+            return GameObjectPathUtility.GetFullPath(document.gameObject) + PATH_SEPARATOR
+                + BuildElementChain(document.rootVisualElement, element);
+        }
+
+        internal static string GetDisplayName(VisualElement element)
+        {
+            return string.IsNullOrEmpty(element.name) ? element.GetType().Name : element.name;
+        }
+
+        // Lists the elements from just below the document root down to the element, so the root itself, which
+        // has no name of its own, is left out.
+        private static string BuildElementChain(VisualElement root, VisualElement element)
+        {
+            List<string> segments = new List<string>();
+            VisualElement? current = element;
+            while (current != null && current != root)
+            {
+                segments.Add(GetDisplayName(current));
+                current = current.hierarchy.parent;
+            }
+
+            segments.Reverse();
+            return string.Join(CHAIN_SEPARATOR, segments);
+        }
+    }
+}
diff --git a/Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UIToolkitElementPath.cs.meta b/Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UIToolkitElementPath.cs.meta
new file mode 100644
index 0000000000..9153987e20
--- /dev/null
+++ b/Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UIToolkitElementPath.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 0063bf7119a134d3482034492d38a1b7
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Packages/src/Editor/FirstPartyTools/Screenshot/UIToolkitAnnotation/UIToolkitPanelKind.cs b/Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UIToolkitPanelKind.cs
similarity index 100%
rename from Packages/src/Editor/FirstPartyTools/Screenshot/UIToolkitAnnotation/UIToolkitPanelKind.cs
rename to Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UIToolkitPanelKind.cs
diff --git a/Packages/src/Editor/FirstPartyTools/Screenshot/UIToolkitAnnotation/UIToolkitPanelKind.cs.meta b/Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UIToolkitPanelKind.cs.meta
similarity index 100%
rename from Packages/src/Editor/FirstPartyTools/Screenshot/UIToolkitAnnotation/UIToolkitPanelKind.cs.meta
rename to Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UIToolkitPanelKind.cs.meta
diff --git a/Packages/src/Editor/FirstPartyTools/Screenshot/UIToolkitAnnotation/UIToolkitReachabilityProbe.cs b/Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UIToolkitReachabilityProbe.cs
similarity index 100%
rename from Packages/src/Editor/FirstPartyTools/Screenshot/UIToolkitAnnotation/UIToolkitReachabilityProbe.cs
rename to Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UIToolkitReachabilityProbe.cs
diff --git a/Packages/src/Editor/FirstPartyTools/Screenshot/UIToolkitAnnotation/UIToolkitReachabilityProbe.cs.meta b/Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UIToolkitReachabilityProbe.cs.meta
similarity index 100%
rename from Packages/src/Editor/FirstPartyTools/Screenshot/UIToolkitAnnotation/UIToolkitReachabilityProbe.cs.meta
rename to Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UIToolkitReachabilityProbe.cs.meta
diff --git a/Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UIToolkitScreenControl.cs b/Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UIToolkitScreenControl.cs
new file mode 100644
index 0000000000..c8d69dfe20
--- /dev/null
+++ b/Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UIToolkitScreenControl.cs
@@ -0,0 +1,49 @@
+#nullable enable
+using UnityEngine;
+
+namespace io.github.hatayama.UnityCliLoop.FirstPartyTools
+{
+    /// <summary>
+    /// One interactive UI Toolkit control on screen, in top-left Game View pixels.
+    /// </summary>
+    public sealed class UIToolkitScreenControl
+    {
+        public UIToolkitScreenControl(
+            string name,
+            string path,
+            string type,
+            Rect topLeftBounds,
+            Vector2 topLeftReachablePoint,
+            int sortingOrder,
+            int siblingIndex)
+        {
+            Name = name;
+            Path = path;
+            Type = type;
+            TopLeftBounds = topLeftBounds;
+            TopLeftReachablePoint = topLeftReachablePoint;
+            SortingOrder = sortingOrder;
+            SiblingIndex = siblingIndex;
+        }
+
+        /// <summary>The element's name, or its type name when it has none.</summary>
+        public string Name { get; }
+
+        /// <summary>The owning document's GameObject path, '#', and the element chain below the document root.</summary>
+        public string Path { get; }
+
+        /// <summary>The kind of control, such as "Button", "Toggle" or "Slider".</summary>
+        public string Type { get; }
+
+        public Rect TopLeftBounds { get; }
+
+        /// <summary>A point inside the bounds where pointer input reaches this control.</summary>
+        public Vector2 TopLeftReachablePoint { get; }
+
+        /// <summary>The panel's sorting order, rounded down.</summary>
+        public int SortingOrder { get; }
+
+        /// <summary>The control's index among its parent's children.</summary>
+        public int SiblingIndex { get; }
+    }
+}
diff --git a/Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UIToolkitScreenControl.cs.meta b/Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UIToolkitScreenControl.cs.meta
new file mode 100644
index 0000000000..6f7cb1efea
--- /dev/null
+++ b/Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UIToolkitScreenControl.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 986bdff0569264bf395eed0b8b042fe8
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UIToolkitScreenElements.cs b/Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UIToolkitScreenElements.cs
new file mode 100644
index 0000000000..f3351c5714
--- /dev/null
+++ b/Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UIToolkitScreenElements.cs
@@ -0,0 +1,36 @@
+#nullable enable
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace io.github.hatayama.UnityCliLoop.FirstPartyTools
+{
+    /// <summary>
+    /// Entry point for the UI Toolkit controls shown over the Game View on screen-space panels. Every point and
+    /// rectangle is in Game View pixels with the origin at the top left, the space screenshot annotations and
+    /// simulated pointer input use.
+    /// </summary>
+    public static class UIToolkitScreenElements
+    {
+        /// <summary>
+        /// Returns the enabled, visible controls that pointer input can reach, each with a point where it does.
+        /// Controls inside another control (the buttons of a scrollbar, for example) are not listed separately.
+        /// </summary>
+        /// <param name="probePointsForTopLeftBounds">
+        /// Gives the candidate points to try for a control's bounds, in the order to try them. The first point
+        /// that is not covered by a panel in front or by another element becomes the reachable point.
+        /// </param>
+        public static IReadOnlyList<UIToolkitScreenControl> CollectControls(
+            Func<Rect, IReadOnlyList<Vector2>> probePointsForTopLeftBounds)
+        {
+            if (probePointsForTopLeftBounds == null)
+            {
+                throw new ArgumentNullException(nameof(probePointsForTopLeftBounds));
+            }
+
+            List<UIToolkitScreenPanels.PanelEntry> panels = UIToolkitScreenPanels.Gather();
+            UIToolkitScreenPanels.SettleLayouts(panels);
+            return UIToolkitControlCollector.Collect(panels, probePointsForTopLeftBounds);
+        }
+    }
+}
diff --git a/Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UIToolkitScreenElements.cs.meta b/Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UIToolkitScreenElements.cs.meta
new file mode 100644
index 0000000000..80e950e025
--- /dev/null
+++ b/Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UIToolkitScreenElements.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: d2e4ddae68bc647549c46ae552ba5cdf
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Packages/src/Editor/FirstPartyTools/Screenshot/UIToolkitAnnotation/UIToolkitScreenMapping.cs b/Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UIToolkitScreenMapping.cs
similarity index 100%
rename from Packages/src/Editor/FirstPartyTools/Screenshot/UIToolkitAnnotation/UIToolkitScreenMapping.cs
rename to Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UIToolkitScreenMapping.cs
diff --git a/Packages/src/Editor/FirstPartyTools/Screenshot/UIToolkitAnnotation/UIToolkitScreenMapping.cs.meta b/Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UIToolkitScreenMapping.cs.meta
similarity index 100%
rename from Packages/src/Editor/FirstPartyTools/Screenshot/UIToolkitAnnotation/UIToolkitScreenMapping.cs.meta
rename to Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UIToolkitScreenMapping.cs.meta
diff --git a/Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UIToolkitScreenPanels.cs b/Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UIToolkitScreenPanels.cs
new file mode 100644
index 0000000000..254ca21787
--- /dev/null
+++ b/Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UIToolkitScreenPanels.cs
@@ -0,0 +1,137 @@
+#nullable enable
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEngine;
+using UnityEngine.UIElements;
+
+namespace io.github.hatayama.UnityCliLoop.FirstPartyTools
+{
+    /// <summary>
+    /// Finds the screen-space UI Toolkit panels that show in the Game View or take input there, and picks
+    /// elements on them in top-left Game View pixels.
+    /// </summary>
+    internal static class UIToolkitScreenPanels
+    {
+        internal static List<PanelEntry> Gather()
+        {
+#if UNITY_6000_4_OR_NEWER
+            UIDocument[] documents = UnityEngine.Object.FindObjectsByType<UIDocument>();
+#else
+            UIDocument[] documents = UnityEngine.Object.FindObjectsOfType<UIDocument>();
+#endif
+            List<PanelEntry> panels = new List<PanelEntry>();
+            foreach (UIDocument document in documents)
+            {
+                IPanel? panel = GetScreenSpacePanelShownInGameView(document);
+                if (panel == null)
+                {
+                    continue;
+                }
+
+                PanelEntry? entry = panels.Find(candidate => candidate.Panel == panel);
+                if (entry == null)
+                {
+                    entry = CreatePanelEntry(panel, document.panelSettings);
+                    panels.Add(entry);
+                }
+
+                entry.Documents.Add(document);
+            }
+
+            return panels;
+        }
+
+        // worldBound and visualTree.layout are only settled once the panel validates its layout, and Pick is
+        // the only public call that does so. Every panel is settled, including those used only to decide
+        // what covers what, because PickInPanel reads their layout too.
+        internal static void SettleLayouts(List<PanelEntry> panels)
+        {
+            foreach (PanelEntry entry in panels)
+            {
+                entry.Panel.Pick(Vector2.zero);
+            }
+        }
+
+        // Panels with the same sorting order are not treated as covering each other: Unity breaks that tie by
+        // creation order, which is not public.
+        internal static List<Func<Vector2, VisualElement?>> CreateFrontPickers(List<PanelEntry> panels, PanelEntry entry)
+        {
+            return panels
+                .Where(other => other.SortingOrder > entry.SortingOrder)
+                .OrderByDescending(other => other.SortingOrder)
+                .Select(other => (Func<Vector2, VisualElement?>)(point => PickInPanel(other.Panel, point)))
+                .ToList();
+        }
+
+        // Uses the forward screen-to-panel function Unity applies to input, so the result matches where input
+        // goes even for panels whose function cannot be inverted.
+        internal static VisualElement? PickInPanel(IPanel panel, Vector2 screenTopLeftPoint)
+        {
+            Vector2 panelPoint = RuntimePanelUtils.ScreenToPanel(panel, screenTopLeftPoint);
+            if (!panel.visualTree.layout.Contains(panelPoint))
+            {
+                return null;
+            }
+
+            return panel.Pick(panelPoint);
+        }
+
+        // Returns null for documents that contribute nothing: their panel neither shows in the Game View nor
+        // takes input there, or they are nested and reached through their parent document's root.
+        private static IPanel? GetScreenSpacePanelShownInGameView(UIDocument document)
+        {
+            if (!document.isActiveAndEnabled || document.parentUI != null)
+            {
+                return null;
+            }
+
+            PanelSettings settings = document.panelSettings;
+            VisualElement root = document.rootVisualElement;
+            if (settings == null || root == null || root.panel == null)
+            {
+                return null;
+            }
+
+            if (settings.targetDisplay != Display.activeEditorGameViewTarget)
+            {
+                return null;
+            }
+
+            // World-space panels do not cover overlay controls and their elements have no screen rectangle.
+            if (UIToolkitPanelKind.IsWorldSpace(settings))
+            {
+                return null;
+            }
+
+            return root.panel;
+        }
+
+        // A panel that renders into a texture still takes screen input, so it stays as a cover candidate, but
+        // its controls are not on the screenshot and get no mapping.
+        private static PanelEntry CreatePanelEntry(IPanel panel, PanelSettings settings)
+        {
+            UIToolkitScreenMapping? mapping = settings.targetTexture == null
+                ? UIToolkitScreenMapping.TryCreate(screen => RuntimePanelUtils.ScreenToPanel(panel, screen))
+                : null;
+            return new PanelEntry(panel, settings.sortingOrder, mapping);
+        }
+
+        internal sealed class PanelEntry
+        {
+            internal PanelEntry(IPanel panel, float sortingOrder, UIToolkitScreenMapping? mapping)
+            {
+                Panel = panel;
+                SortingOrder = sortingOrder;
+                Mapping = mapping;
+            }
+
+            internal IPanel Panel { get; }
+            internal float SortingOrder { get; }
+
+            // Null when the panel's controls cannot be placed on the screenshot; the panel still covers others.
+            internal UIToolkitScreenMapping? Mapping { get; }
+            internal List<UIDocument> Documents { get; } = new List<UIDocument>();
+        }
+    }
+}
diff --git a/Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UIToolkitScreenPanels.cs.meta b/Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UIToolkitScreenPanels.cs.meta
new file mode 100644
index 0000000000..e06d7d0827
--- /dev/null
+++ b/Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UIToolkitScreenPanels.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: c1b1722f144d94fef89b4efcd6e14316
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UnityCLILoop.FirstPartyTools.Common.UIToolkit.Editor.asmdef b/Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UnityCLILoop.FirstPartyTools.Common.UIToolkit.Editor.asmdef
new file mode 100644
index 0000000000..525f80e291
--- /dev/null
+++ b/Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UnityCLILoop.FirstPartyTools.Common.UIToolkit.Editor.asmdef
@@ -0,0 +1,18 @@
+{
+    "name": "UnityCLILoop.FirstPartyTools.Common.UIToolkit.Editor",
+    "rootNamespace": "io.github.hatayama.UnityCliLoop.FirstPartyTools",
+    "references": [
+        "GUID:a2d87883023de4cf59b7d1962d5dd8aa"
+    ],
+    "includePlatforms": [
+        "Editor"
+    ],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": false,
+    "defineConstraints": [],
+    "versionDefines": [],
+    "noEngineReferences": false
+}
diff --git a/Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UnityCLILoop.FirstPartyTools.Common.UIToolkit.Editor.asmdef.meta b/Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UnityCLILoop.FirstPartyTools.Common.UIToolkit.Editor.asmdef.meta
new file mode 100644
index 0000000000..2e5312c8e0
--- /dev/null
+++ b/Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UnityCLILoop.FirstPartyTools.Common.UIToolkit.Editor.asmdef.meta
@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 569bba870e5e64d0d94144057b927001
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Packages/src/Editor/FirstPartyTools/Screenshot/UIToolkitAnnotation/UIToolkitElementCollector.cs b/Packages/src/Editor/FirstPartyTools/Screenshot/UIToolkitAnnotation/UIToolkitElementCollector.cs
index 86fe5059b9..7df4588027 100644
--- a/Packages/src/Editor/FirstPartyTools/Screenshot/UIToolkitAnnotation/UIToolkitElementCollector.cs
+++ b/Packages/src/Editor/FirstPartyTools/Screenshot/UIToolkitAnnotation/UIToolkitElementCollector.cs
@@ -1,9 +1,7 @@
 #nullable enable
-using System;
 using System.Collections.Generic;
 using System.Linq;
 using UnityEngine;
-using UnityEngine.UIElements;
 
 using io.github.hatayama.UnityCliLoop.ToolContracts;
 
@@ -16,309 +14,53 @@ namespace io.github.hatayama.UnityCliLoop.FirstPartyTools
     /// </summary>
     internal static class UIToolkitElementCollector
     {
-        private const char PATH_SEPARATOR = '#';
-        private const string CHAIN_SEPARATOR = "/";
-
+        // gameViewHeight, not Screen.height: uloop commands run outside the player loop, where Screen reports the
+        // size of the last Editor view drawn. ConvertToSimCoordinates flips the result back with the Game View
+        // height, so the same height is used here.
         internal static void Collect(List<UIElementInfo> elements, float gameViewHeight)
         {
-            List<PanelEntry> panels = GatherPanels();
-
-            // worldBound and visualTree.layout are only settled once the panel validates its layout, and Pick is
-            // the only public call that does so. Every panel is settled, including those used only to decide
-            // what covers what, because PickInPanel reads their layout too.
-            foreach (PanelEntry entry in panels)
-            {
-                entry.Panel.Pick(Vector2.zero);
-            }
-
-            foreach (PanelEntry entry in panels)
-            {
-                if (entry.Mapping == null)
-                {
-                    continue;
-                }
-
-                VisitContext context = new VisitContext(
-                    gameViewHeight,
-                    entry,
-                    entry.Mapping,
-                    CreateFrontPickers(panels, entry),
-                    point => PickInPanel(entry.Panel, point),
-                    elements);
-                foreach (UIDocument document in entry.Documents)
-                {
-                    Visit(document.rootVisualElement, document, context);
-                }
-            }
-        }
-
-        private static List<PanelEntry> GatherPanels()
-        {
-#if UNITY_6000_4_OR_NEWER
-            UIDocument[] documents = UnityEngine.Object.FindObjectsByType<UIDocument>();
-#else
-            UIDocument[] documents = UnityEngine.Object.FindObjectsOfType<UIDocument>();
-#endif
-            List<PanelEntry> panels = new List<PanelEntry>();
-            foreach (UIDocument document in documents)
+            IReadOnlyList<UIToolkitScreenControl> controls = UIToolkitScreenElements.CollectControls(
+                topLeftBounds => GenerateTopLeftProbePoints(topLeftBounds, gameViewHeight));
+            foreach (UIToolkitScreenControl control in controls)
             {
-                IPanel? panel = GetScreenSpacePanelShownInGameView(document);
-                if (panel == null)
-                {
-                    continue;
-                }
-
-                PanelEntry? entry = panels.Find(candidate => candidate.Panel == panel);
-                if (entry == null)
+                Rect bottomLeftBounds = ToBottomLeft(control.TopLeftBounds, gameViewHeight);
+                elements.Add(new UIElementInfo
                 {
-                    entry = CreatePanelEntry(panel, document.panelSettings);
-                    panels.Add(entry);
-                }
-
-                entry.Documents.Add(document);
-            }
-
-            return panels;
-        }
-
-        // Returns null for documents that contribute nothing: their panel neither shows in the Game View nor
-        // takes input there, or they are nested and reached through their parent document's root.
-        private static IPanel? GetScreenSpacePanelShownInGameView(UIDocument document)
-        {
-            if (!document.isActiveAndEnabled || document.parentUI != null)
-            {
-                return null;
-            }
-
-            PanelSettings settings = document.panelSettings;
-            VisualElement root = document.rootVisualElement;
-            if (settings == null || root == null || root.panel == null)
-            {
-                return null;
-            }
-
-            if (settings.targetDisplay != Display.activeEditorGameViewTarget)
-            {
-                return null;
-            }
-
-            // World-space panels do not cover overlay controls and their elements have no screen rectangle.
-            if (UIToolkitPanelKind.IsWorldSpace(settings))
-            {
-                return null;
-            }
-
-            return root.panel;
-        }
-
-        // A panel that renders into a texture still takes screen input, so it stays as a cover candidate, but
-        // its controls are not on the screenshot and get no mapping.
-        private static PanelEntry CreatePanelEntry(IPanel panel, PanelSettings settings)
-        {
-            UIToolkitScreenMapping? mapping = settings.targetTexture == null
-                ? UIToolkitScreenMapping.TryCreate(screen => RuntimePanelUtils.ScreenToPanel(panel, screen))
-                : null;
-            return new PanelEntry(panel, settings.sortingOrder, mapping);
-        }
-
-        // Panels with the same sorting order are not treated as covering each other: Unity breaks that tie by
-        // creation order, which is not public.
-        private static List<Func<Vector2, VisualElement?>> CreateFrontPickers(List<PanelEntry> panels, PanelEntry entry)
-        {
-            return panels
-                .Where(other => other.SortingOrder > entry.SortingOrder)
-                .OrderByDescending(other => other.SortingOrder)
-                .Select(other => (Func<Vector2, VisualElement?>)(point => PickInPanel(other.Panel, point)))
-                .ToList();
-        }
-
-        // Uses the forward screen-to-panel function Unity applies to input, so the result matches where input
-        // goes even for panels whose function cannot be inverted.
-        private static VisualElement? PickInPanel(IPanel panel, Vector2 screenTopLeftPoint)
-        {
-            Vector2 panelPoint = RuntimePanelUtils.ScreenToPanel(panel, screenTopLeftPoint);
-            if (!panel.visualTree.layout.Contains(panelPoint))
-            {
-                return null;
+                    Name = control.Name,
+                    Path = control.Path,
+                    Type = control.Type,
+                    Interaction = UIElementAnnotationStyling.GetInteractionForType(control.Type),
+                    UiSystem = AnnotatedUiSystem.UIToolkit,
+                    SimX = control.TopLeftReachablePoint.x,
+                    SimY = gameViewHeight - control.TopLeftReachablePoint.y,
+                    BoundsMinX = bottomLeftBounds.xMin,
+                    BoundsMinY = bottomLeftBounds.yMin,
+                    BoundsMaxX = bottomLeftBounds.xMax,
+                    BoundsMaxY = bottomLeftBounds.yMax,
+                    SortingOrder = control.SortingOrder,
+                    SiblingIndex = control.SiblingIndex
+                });
             }
-
-            return panel.Pick(panelPoint);
-        }
-
-        private static void Visit(VisualElement element, UIDocument document, VisitContext context)
-        {
-            // A child can still resolve to Flex under a display:none parent, so the whole subtree stops here.
-            if (element.resolvedStyle.display == DisplayStyle.None)
-            {
-                return;
-            }
-
-            string? type = UIToolkitElementClassifier.Classify(element);
-            if (type != null)
-            {
-                TryAdd(element, type, document, context);
-
-                // The parts inside a control (the slider and buttons of a Scroller, for example) are not
-                // separate controls.
-                return;
-            }
-
-            // hierarchy, not Children(): Children() lists only the content container, which hides a
-            // ScrollView's scrollers.
-            for (int index = 0; index < element.hierarchy.childCount; index++)
-            {
-                Visit(element.hierarchy[index], document, context);
-            }
-        }
-
-        private static void TryAdd(VisualElement element, string type, UIDocument document, VisitContext context)
-        {
-            if (!element.enabledInHierarchy || element.resolvedStyle.visibility == Visibility.Hidden)
-            {
-                return;
-            }
-
-            Rect worldBound = element.worldBound;
-            if (!IsFiniteNonEmpty(worldBound))
-            {
-                return;
-            }
-
-            // Not Screen.height: uloop commands run outside the player loop, where Screen reports the size of the
-            // last Editor view drawn. ConvertToSimCoordinates flips the result back with the Game View height, so
-            // the same height is used here.
-            float gameViewHeight = context.GameViewHeight;
-            Vector2 topLeftMin = context.Mapping.PanelToScreenTopLeft(new Vector2(worldBound.xMin, worldBound.yMin));
-            Vector2 topLeftMax = context.Mapping.PanelToScreenTopLeft(new Vector2(worldBound.xMax, worldBound.yMax));
-            Rect bottomLeftBounds = Rect.MinMaxRect(
-                topLeftMin.x,
-                gameViewHeight - topLeftMax.y,
-                topLeftMax.x,
-                gameViewHeight - topLeftMin.y);
-
-            Vector2? reachable = FindReachablePoint(element, bottomLeftBounds, gameViewHeight, context);
-            if (reachable == null)
-            {
-                return;
-            }
-
-            context.Elements.Add(CreateElementInfo(
-                element, type, document, context.Entry, bottomLeftBounds, new Vector2(reachable.Value.x, gameViewHeight - reachable.Value.y)));
         }
 
         // Probes the same points as the uGUI annotator, converted to the top-left origin panels take input in.
-        private static Vector2? FindReachablePoint(
-            VisualElement element, Rect bottomLeftBounds, float gameViewHeight, VisitContext context)
+        private static IReadOnlyList<Vector2> GenerateTopLeftProbePoints(Rect topLeftBounds, float gameViewHeight)
         {
+            Rect bottomLeftBounds = ToBottomLeft(topLeftBounds, gameViewHeight);
             Vector2[] bottomLeftProbes = UIElementAnnotator.GenerateReachabilityProbePoints(
                 bottomLeftBounds.xMin, bottomLeftBounds.yMin, bottomLeftBounds.xMax, bottomLeftBounds.yMax);
-            Vector2[] topLeftProbes = bottomLeftProbes
+            return bottomLeftProbes
                 .Select(probe => new Vector2(probe.x, gameViewHeight - probe.y))
                 .ToArray();
-            return UIToolkitReachabilityProbe.FindReachablePoint(
-                topLeftProbes, element, context.FrontPickers, context.OwnPicker);
         }
 
-        private static UIElementInfo CreateElementInfo(
-            VisualElement element,
-            string type,
-            UIDocument document,
-            PanelEntry entry,
-            Rect bottomLeftBounds,
-            Vector2 bottomLeftPoint)
+        private static Rect ToBottomLeft(Rect topLeftBounds, float gameViewHeight)
         {
-            VisualElement? parent = element.hierarchy.parent;
-            return new UIElementInfo
-            {
-                Name = GetDisplayName(element),
-                Path = GameObjectPathUtility.GetFullPath(document.gameObject) + PATH_SEPARATOR
-                    + BuildElementChain(document.rootVisualElement, element),
-                Type = type,
-                Interaction = UIElementAnnotationStyling.GetInteractionForType(type),
-                UiSystem = AnnotatedUiSystem.UIToolkit,
-                SimX = bottomLeftPoint.x,
-                SimY = bottomLeftPoint.y,
-                BoundsMinX = bottomLeftBounds.xMin,
-                BoundsMinY = bottomLeftBounds.yMin,
-                BoundsMaxX = bottomLeftBounds.xMax,
-                BoundsMaxY = bottomLeftBounds.yMax,
-                SortingOrder = Mathf.FloorToInt(entry.SortingOrder),
-                SiblingIndex = parent == null ? 0 : parent.hierarchy.IndexOf(element)
-            };
-        }
-
-        // Lists the elements from just below the document root down to the element, so the root itself, which
-        // has no name of its own, is left out.
-        private static string BuildElementChain(VisualElement root, VisualElement element)
-        {
-            List<string> segments = new List<string>();
-            VisualElement? current = element;
-            while (current != null && current != root)
-            {
-                segments.Add(GetDisplayName(current));
-                current = current.hierarchy.parent;
-            }
-
-            segments.Reverse();
-            return string.Join(CHAIN_SEPARATOR, segments);
-        }
-
-        private static string GetDisplayName(VisualElement element)
-        {
-            return string.IsNullOrEmpty(element.name) ? element.GetType().Name : element.name;
-        }
-
-        private static bool IsFiniteNonEmpty(Rect rect)
-        {
-            return float.IsFinite(rect.x)
-                && float.IsFinite(rect.y)
-                && float.IsFinite(rect.width)
-                && float.IsFinite(rect.height)
-                && rect.width > 0f
-                && rect.height > 0f;
-        }
-
-        private sealed class PanelEntry
-        {
-            internal PanelEntry(IPanel panel, float sortingOrder, UIToolkitScreenMapping? mapping)
-            {
-                Panel = panel;
-                SortingOrder = sortingOrder;
-                Mapping = mapping;
-            }
-
-            internal IPanel Panel { get; }
-            internal float SortingOrder { get; }
-
-            // Null when the panel's controls cannot be placed on the screenshot; the panel still covers others.
-            internal UIToolkitScreenMapping? Mapping { get; }
-            internal List<UIDocument> Documents { get; } = new List<UIDocument>();
-        }
-
-        private sealed class VisitContext
-        {
-            internal VisitContext(
-                float gameViewHeight,
-                PanelEntry entry,
-                UIToolkitScreenMapping mapping,
-                List<Func<Vector2, VisualElement?>> frontPickers,
-                Func<Vector2, VisualElement?> ownPicker,
-                List<UIElementInfo> elements)
-            {
-                GameViewHeight = gameViewHeight;
-                Entry = entry;
-                Mapping = mapping;
-                FrontPickers = frontPickers;
-                OwnPicker = ownPicker;
-                Elements = elements;
-            }
-
-            internal float GameViewHeight { get; }
-            internal PanelEntry Entry { get; }
-            internal UIToolkitScreenMapping Mapping { get; }
-            internal List<Func<Vector2, VisualElement?>> FrontPickers { get; }
-            internal Func<Vector2, VisualElement?> OwnPicker { get; }
-            internal List<UIElementInfo> Elements { get; }
+            return Rect.MinMaxRect(
+                topLeftBounds.xMin,
+                gameViewHeight - topLeftBounds.yMax,
+                topLeftBounds.xMax,
+                gameViewHeight - topLeftBounds.yMin);
         }
     }
 }
diff --git a/Packages/src/Editor/FirstPartyTools/Screenshot/UnityCLILoop.FirstPartyTools.Screenshot.Editor.asmdef b/Packages/src/Editor/FirstPartyTools/Screenshot/UnityCLILoop.FirstPartyTools.Screenshot.Editor.asmdef
index aa8752700b..fcf49663a7 100644
--- a/Packages/src/Editor/FirstPartyTools/Screenshot/UnityCLILoop.FirstPartyTools.Screenshot.Editor.asmdef
+++ b/Packages/src/Editor/FirstPartyTools/Screenshot/UnityCLILoop.FirstPartyTools.Screenshot.Editor.asmdef
@@ -5,6 +5,7 @@
         "GUID:214998e563c124e8a88199b2dd1f522d",
         "GUID:5079a8d3a72924a81aa1cbc25f65ed1b",
         "GUID:a2d87883023de4cf59b7d1962d5dd8aa",
+        "GUID:569bba870e5e64d0d94144057b927001",
         "GUID:fc3fd32eddbee40e39c2d76dc184957b",
         "GUID:96b8d4624fb74ea2849fed17e7ad69d3",
         "GUID:77087b1bb30a415e87a80cbf24e7430a",

From e3c2c751898ba12fea2089cc7854dd57e473e0c4 Mon Sep 17 00:00:00 2001
From: Masamichi Hatayama <booqle@gmail.com>
Date: Wed, 14 Oct 2026 01:40:46 +0900
Subject: [PATCH 4/5] feat: simulate-mouse-ui clicks and long-presses reach UI
 Toolkit controls (#3312)

---
 .../references/annotated-elements.md          |   8 +-
 .../uloop-simulate-mouse-input/SKILL.md       |   4 +-
 .../references/output-and-coordinates.md      |   2 +-
 .../skills/uloop-simulate-mouse-ui/SKILL.md   |  13 +-
 .../references/output.md                      |   6 +-
 .../references/ui-toolkit.md                  |  46 ++
 .../references/annotated-elements.md          |   8 +-
 .../uloop-simulate-mouse-input/SKILL.md       |   4 +-
 .../references/output-and-coordinates.md      |   2 +-
 .../skills/uloop-simulate-mouse-ui/SKILL.md   |  13 +-
 .../references/output.md                      |   6 +-
 .../references/ui-toolkit.md                  |  46 ++
 .../Tests/Editor/MouseUiHitPriorityTests.cs   |  64 ++
 .../Editor/MouseUiHitPriorityTests.cs.meta    |  11 +
 .../MouseUiPointerTargetResolverTests.cs      |  22 +
 .../MouseUiSimulationResponseFactoryTests.cs  |  55 +-
 .../Editor/StaticFacadeStateGuardTests.cs     |  17 +-
 .../Editor/UiRaycastHelperPanelSkipTests.cs   | 108 +++
 .../UiRaycastHelperPanelSkipTests.cs.meta     |  11 +
 .../PlayMode/SimulateMouseUiToolkitTests.cs   | 732 ++++++++++++++++++
 .../SimulateMouseUiToolkitTests.cs.meta       |  11 +
 .../UIToolkitScreenElementsPointerTests.cs    | 397 ++++++++++
 ...IToolkitScreenElementsPointerTests.cs.meta |  11 +
 Packages/src/Documentation~/tools.md          |   4 +-
 Packages/src/Documentation~/tools_ja.md       |   4 +-
 .../Common/MouseUi/UiRaycastHelper.cs         |  77 +-
 .../UIToolkit/UIToolkitPointerEvents.cs       |  55 ++
 .../UIToolkit/UIToolkitPointerEvents.cs.meta  |  11 +
 .../UIToolkit/UIToolkitPointerTarget.cs       | 108 +++
 .../UIToolkit/UIToolkitPointerTarget.cs.meta  |  11 +
 .../UIToolkit/UIToolkitPointerTargetFinder.cs |  82 ++
 .../UIToolkitPointerTargetFinder.cs.meta      |  11 +
 .../UIToolkit/UIToolkitScreenControl.cs       |   2 +-
 .../UIToolkit/UIToolkitScreenElements.cs      |  12 +
 .../Skill/references/annotated-elements.md    |   8 +-
 .../SimulateMouseInput/Skill/SKILL.md         |   4 +-
 .../references/output-and-coordinates.md      |   2 +-
 .../SimulateMouseUi/IMouseUiPressTarget.cs    |  20 +
 .../IMouseUiPressTarget.cs.meta               |  11 +
 .../SimulateMouseUi/MouseUiHitPriority.cs     |  21 +
 .../MouseUiHitPriority.cs.meta                |  11 +
 .../SimulateMouseUi/MouseUiHitReport.cs       |  26 +
 .../SimulateMouseUi/MouseUiHitReport.cs.meta  |  11 +
 .../SimulateMouseUi/MouseUiHitSystem.cs       |  16 +
 .../SimulateMouseUi/MouseUiHitSystem.cs.meta  |  11 +
 .../MouseUiPointerTargetResolver.cs           |   4 +-
 .../MouseUiPressActionExecutor.cs             | 116 +--
 .../MouseUiPressTargetResolver.cs             | 102 +++
 .../MouseUiPressTargetResolver.cs.meta        |  11 +
 .../MouseUiSimulationResponseFactory.cs       |  27 +-
 .../MouseUiSimulationValidator.cs             |  12 +-
 .../SimulateMouseUiResponse.cs                |  17 +
 .../SimulateMouseUi/SimulateMouseUiUseCase.cs |  22 +-
 .../SimulateMouseUi/Skill/SKILL.md            |  13 +-
 .../Skill/references/output.md                |   6 +-
 .../Skill/references/ui-toolkit.md            |  46 ++
 .../Skill/references/ui-toolkit.md.meta       |   7 +
 .../SimulateMouseUi/UIToolkitPressTarget.cs   |  50 ++
 .../UIToolkitPressTarget.cs.meta              |  11 +
 .../SimulateMouseUi/UguiPressTarget.cs        | 101 +++
 .../SimulateMouseUi/UguiPressTarget.cs.meta   |  11 +
 ...stPartyTools.SimulateMouseUi.Editor.asmdef |   1 +
 cli/common/tools/default-tools.json           |   2 +-
 .../test-screenshot-uitoolkit-annotation.ps1  | 243 +++++-
 .../test-screenshot-uitoolkit-annotation.sh   | 199 ++++-
 65 files changed, 2875 insertions(+), 241 deletions(-)
 create mode 100644 .agents/skills/uloop-simulate-mouse-ui/references/ui-toolkit.md
 create mode 100644 .claude/skills/uloop-simulate-mouse-ui/references/ui-toolkit.md
 create mode 100644 Assets/Tests/Editor/MouseUiHitPriorityTests.cs
 create mode 100644 Assets/Tests/Editor/MouseUiHitPriorityTests.cs.meta
 create mode 100644 Assets/Tests/Editor/UiRaycastHelperPanelSkipTests.cs
 create mode 100644 Assets/Tests/Editor/UiRaycastHelperPanelSkipTests.cs.meta
 create mode 100644 Assets/Tests/PlayMode/SimulateMouseUiToolkitTests.cs
 create mode 100644 Assets/Tests/PlayMode/SimulateMouseUiToolkitTests.cs.meta
 create mode 100644 Assets/Tests/PlayMode/UIToolkitScreenElementsPointerTests.cs
 create mode 100644 Assets/Tests/PlayMode/UIToolkitScreenElementsPointerTests.cs.meta
 create mode 100644 Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UIToolkitPointerEvents.cs
 create mode 100644 Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UIToolkitPointerEvents.cs.meta
 create mode 100644 Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UIToolkitPointerTarget.cs
 create mode 100644 Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UIToolkitPointerTarget.cs.meta
 create mode 100644 Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UIToolkitPointerTargetFinder.cs
 create mode 100644 Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UIToolkitPointerTargetFinder.cs.meta
 create mode 100644 Packages/src/Editor/FirstPartyTools/SimulateMouseUi/IMouseUiPressTarget.cs
 create mode 100644 Packages/src/Editor/FirstPartyTools/SimulateMouseUi/IMouseUiPressTarget.cs.meta
 create mode 100644 Packages/src/Editor/FirstPartyTools/SimulateMouseUi/MouseUiHitPriority.cs
 create mode 100644 Packages/src/Editor/FirstPartyTools/SimulateMouseUi/MouseUiHitPriority.cs.meta
 create mode 100644 Packages/src/Editor/FirstPartyTools/SimulateMouseUi/MouseUiHitReport.cs
 create mode 100644 Packages/src/Editor/FirstPartyTools/SimulateMouseUi/MouseUiHitReport.cs.meta
 create mode 100644 Packages/src/Editor/FirstPartyTools/SimulateMouseUi/MouseUiHitSystem.cs
 create mode 100644 Packages/src/Editor/FirstPartyTools/SimulateMouseUi/MouseUiHitSystem.cs.meta
 create mode 100644 Packages/src/Editor/FirstPartyTools/SimulateMouseUi/MouseUiPressTargetResolver.cs
 create mode 100644 Packages/src/Editor/FirstPartyTools/SimulateMouseUi/MouseUiPressTargetResolver.cs.meta
 create mode 100644 Packages/src/Editor/FirstPartyTools/SimulateMouseUi/Skill/references/ui-toolkit.md
 create mode 100644 Packages/src/Editor/FirstPartyTools/SimulateMouseUi/Skill/references/ui-toolkit.md.meta
 create mode 100644 Packages/src/Editor/FirstPartyTools/SimulateMouseUi/UIToolkitPressTarget.cs
 create mode 100644 Packages/src/Editor/FirstPartyTools/SimulateMouseUi/UIToolkitPressTarget.cs.meta
 create mode 100644 Packages/src/Editor/FirstPartyTools/SimulateMouseUi/UguiPressTarget.cs
 create mode 100644 Packages/src/Editor/FirstPartyTools/SimulateMouseUi/UguiPressTarget.cs.meta

diff --git a/.agents/skills/uloop-screenshot/references/annotated-elements.md b/.agents/skills/uloop-screenshot/references/annotated-elements.md
index 5e1338e01d..69466c0964 100644
--- a/.agents/skills/uloop-screenshot/references/annotated-elements.md
+++ b/.agents/skills/uloop-screenshot/references/annotated-elements.md
@@ -10,7 +10,7 @@ Device Simulator is supported for this flow: prefer `--capture-mode rendering` (
 
 - `Label`: Index label in JSON (`A` = first in that sort, `B` = next, ...). Treat it as a stable handle, not as proof of what is actually in front: when overlapping elements cross parents, pick the target by `Path` and confirm the result with `simulate-mouse-ui`'s `HitGameObjectName` — the handler that received the events, resolved up the hierarchy from the raycast hit (or from `--target-path` in bypass mode), so it can name an ancestor of the element you clicked. Screenshot labels also include the interaction hint, such as `A / CLICK` or `B / DRAG`.
 - `Name`: Element name
-- `Path`: Hierarchy path from the scene root, for example `Canvas/Panel/Button`. Use this as `simulate-mouse-ui --target-path` when bypassing raycast blockers. UI Toolkit entries use a different form that `--target-path` does not accept; see [UI Toolkit Elements](#ui-toolkit-elements).
+- `Path`: Hierarchy path from the scene root, for example `Canvas/Panel/Button`. Use this as `simulate-mouse-ui --target-path` when bypassing raycast blockers. UI Toolkit entries use a different form that `--target-path` does not accept; click them at `SimX`/`SimY` instead. See [UI Toolkit Elements](#ui-toolkit-elements).
 - `Type`: Element type (`Button`, `Toggle`, `Slider`, `Dropdown`, `InputField`, `Scrollbar`, `Draggable`, `DropTarget`, `Selectable`, `PhysicsCollider`)
 - `Interaction`: Derived interaction category (`Click`, `Drag`, `Drop`, `Text`) or `Raycast` for clustered physics collider entries. Use this to choose between `simulate-mouse-ui --action Click`, drag actions, or `simulate-mouse-input` (including `--dry-run`).
 - `UiSystem`: UI system the entry came from: `UGUI`, `UIToolkit`, or empty for `PhysicsCollider` entries.
@@ -53,9 +53,9 @@ Limits:
 
 Clicking:
 
-- `simulate-mouse-input --action Click --x <SimX> --y <SimY>` reaches UI Toolkit controls when the scene has an EventSystem with an Input System UI input module.
-- Without an EventSystem the click does not reach UI Toolkit controls.
-- `simulate-mouse-ui` does not reach UI Toolkit controls, and its `--target-path` does not accept UI Toolkit `Path` values.
+- `simulate-mouse-ui --action Click --x <SimX> --y <SimY>` (or `LongPress`) reaches UI Toolkit controls, with or without an EventSystem. Its `--target-path` does not accept UI Toolkit `Path` values.
+- `simulate-mouse-input --action Click --x <SimX> --y <SimY>` also reaches them when the scene has an EventSystem with an Input System UI input module.
+- Without an EventSystem the `simulate-mouse-input` click does not reach UI Toolkit controls.
 
 ### PhysicsCollider Entries Per Closed Region
 
diff --git a/.agents/skills/uloop-simulate-mouse-input/SKILL.md b/.agents/skills/uloop-simulate-mouse-input/SKILL.md
index d7c92b3d44..41723aa257 100644
--- a/.agents/skills/uloop-simulate-mouse-input/SKILL.md
+++ b/.agents/skills/uloop-simulate-mouse-input/SKILL.md
@@ -67,7 +67,7 @@ All rows below assume the New Input System is installed.
 
 | Scenario | Tool |
 |----------|------|
-| Click a Unity UI Button (IPointerClickHandler) | `simulate-mouse-ui` |
+| Click a uGUI or UI Toolkit button | `simulate-mouse-ui` |
 | Runtime logic reads `Mouse.current.leftButton` | `simulate-mouse-input` |
 | Runtime logic reads right-click | `simulate-mouse-input --button Right` |
 | Drag a UI slider | `simulate-mouse-ui --action Drag` |
@@ -110,7 +110,7 @@ uloop simulate-mouse-input --action SmoothDelta --delta-x 300 --delta-y 0 --dura
 ## Coordinate System
 
 `--x`/`--y` use top-left Game View coordinates: pass `AnnotatedElements[].SimX/SimY`
-directly (UI Toolkit entries need an EventSystem in the scene), convert raw screenshot pixels with `ScreenshotToInputFormula`, and never flip Y
+directly (UI Toolkit entries need an EventSystem with an Input System UI module here; `simulate-mouse-ui` reaches them without one), convert raw screenshot pixels with `ScreenshotToInputFormula`, and never flip Y
 in the caller (the tool converts internally). Conversion formula, Device Simulator
 notes, and how the injected position reads back inside Unity are in
 `references/output-and-coordinates.md`.
diff --git a/.agents/skills/uloop-simulate-mouse-input/references/output-and-coordinates.md b/.agents/skills/uloop-simulate-mouse-input/references/output-and-coordinates.md
index a5998020b4..979f721cb7 100644
--- a/.agents/skills/uloop-simulate-mouse-input/references/output-and-coordinates.md
+++ b/.agents/skills/uloop-simulate-mouse-input/references/output-and-coordinates.md
@@ -30,7 +30,7 @@ Verify visual outcome with a follow-up screenshot.
 
 - `--x` / `--y` use **top-left Game View coordinates**.
 - Raw image pixels from `uloop screenshot --capture-mode rendering` must be converted with `ScreenshotToInputFormula`.
-- `AnnotatedElements[].SimX/SimY` can be passed directly to this tool. For UI Toolkit entries (`UiSystem` `UIToolkit`), a `Click` reaches the control only when the scene has an EventSystem with an Input System UI input module; without one, nothing receives the click.
+- `AnnotatedElements[].SimX/SimY` can be passed directly to this tool. For UI Toolkit entries (`UiSystem` `UIToolkit`), a `Click` reaches the control only when the scene has an EventSystem with an Input System UI input module; without one, nothing receives the click. `simulate-mouse-ui` reaches them without an EventSystem.
 - Do not flip Y in the caller. The tool converts internally for Unity Input System:
 
 ```text
diff --git a/.agents/skills/uloop-simulate-mouse-ui/SKILL.md b/.agents/skills/uloop-simulate-mouse-ui/SKILL.md
index 03417c9713..0be9c8c4fb 100644
--- a/.agents/skills/uloop-simulate-mouse-ui/SKILL.md
+++ b/.agents/skills/uloop-simulate-mouse-ui/SKILL.md
@@ -1,7 +1,7 @@
 ---
 name: uloop-simulate-mouse-ui
 toolName: simulate-mouse-ui
-description: "Simulate PlayMode EventSystem UI mouse actions using screen coordinates. Use for UI clicks, long-presses, or drags from annotated screenshots."
+description: "Simulate PlayMode UI mouse actions on uGUI and UI Toolkit using screen coordinates. Use for UI clicks, long-presses, or drags from annotated screenshots."
 ---
 
 # Task
@@ -64,7 +64,7 @@ uloop simulate-mouse-ui --action <action> --x <x> --y <y> [options]
 - Get coordinates from `AnnotatedElements` JSON (`SimX`/`SimY`) — do NOT look up GameObject positions
 - `--bypass-raycast` still uses coordinates for pointer event positions, but chooses the clicked, long-pressed, or dragged GameObject by `--target-path`
 - If `--target-path` or `--drop-target-path` matches multiple active GameObjects, the command fails instead of choosing an arbitrary duplicate
-- Not for UI Toolkit entries (`UiSystem` `UIToolkit`); see `references/output.md`.
+- UI Toolkit entries (`UiSystem` `UIToolkit`) can be clicked and long-pressed at `SimX`/`SimY`; `--bypass-raycast`, `--target-path`, and `--drop-target-path` take GameObjects only. Details: `references/ui-toolkit.md`.
 - Device Simulator play view is supported. Prefer `uloop screenshot --capture-mode rendering --annotate-elements` for coordinates; they use the simulated device resolution (`Handles.GetMainGameViewSize()` / `Screen`), not the Simulator chrome scale.
 
 ## Pause Point Inspection (Standard for E2E)
@@ -86,9 +86,6 @@ uloop simulate-mouse-ui --action Drag --from-x 400 --from-y 300 --x 600 --y 300
 # Long-press a button for 3 seconds
 uloop simulate-mouse-ui --action LongPress --x 400 --y 300 --duration 3.0
 
-# One-shot drag (start to end in one call)
-uloop simulate-mouse-ui --action Drag --from-x 400 --from-y 300 --x 600 --y 300
-
 # Slow drag for visual inspection
 uloop simulate-mouse-ui --action Drag --from-x 400 --from-y 300 --x 600 --y 300 --drag-speed 200
 
@@ -102,14 +99,14 @@ uloop simulate-mouse-ui --action DragEnd --x 600 --y 300
 ## Prerequisites
 
 - Unity must be in **PlayMode**
-- Target scene must have an **EventSystem** GameObject
-- UI elements must have a **GraphicRaycaster** on their Canvas
+- uGUI targets need an **EventSystem** and a **GraphicRaycaster** on their Canvas; UI Toolkit targets need neither
 - If you need runtime mouse input rather than UI pointer events, `simulate-mouse-input` assumes the project uses the New Input System; otherwise prefer `execute-dynamic-code`
 
 ## Output
 
 The response reports `Success`, `Message`, `Action`, `HitGameObjectName`, the used
-coordinates, and `InterruptedByPausePoint`/`PausePointHits`. Two readings that matter:
+coordinates, and `InterruptedByPausePoint`/`PausePointHits`; `UiSystem` and `HitPath` say
+which UI system was hit and give its path in the annotation's form. Two readings that matter:
 `Click`/`LongPress` on empty space still return `Success = true` with
 `HitGameObjectName = null` (drag actions on empty space fail), and on a pause-point
 interruption `Message` states whether the pointer event fired before the pause.
diff --git a/.agents/skills/uloop-simulate-mouse-ui/references/output.md b/.agents/skills/uloop-simulate-mouse-ui/references/output.md
index 043b24d6aa..af20d8c00b 100644
--- a/.agents/skills/uloop-simulate-mouse-ui/references/output.md
+++ b/.agents/skills/uloop-simulate-mouse-ui/references/output.md
@@ -5,7 +5,9 @@ Returns JSON with:
 - `Success`: Whether the operation succeeded
 - `Message`: Status message (e.g. "Hit element: ButtonStart" or "No UI element under (x, y)")
 - `Action`: Echoes which action was executed (`Click`, `Drag`, `DragStart`, `DragMove`, `DragEnd`, or `LongPress`)
-- `HitGameObjectName`: Name of the GameObject that received the pointer events (nullable string; null if nothing was hit). It is the event-handler target resolved up the hierarchy from the raycast hit (the first `IPointerDownHandler`, else the first `IPointerClickHandler`, for `Click`/`LongPress`; the first `IDragHandler` for drags), so it can be an ancestor of the topmost raycast hit — a Button's child Text reports the Button. With `--bypass-raycast` it is the handler resolved the same way from `--target-path` (also possibly an ancestor), not the raycast hit and not necessarily the raw path GameObject itself
+- `HitGameObjectName`: Name of the GameObject that received the pointer events (nullable string; null if nothing was hit). It is the event-handler target resolved up the hierarchy from the raycast hit (the first `IPointerDownHandler`, else the first `IPointerClickHandler`, for `Click`/`LongPress`; the first `IDragHandler` for drags), so it can be an ancestor of the topmost raycast hit — a Button's child Text reports the Button. With `--bypass-raycast` it is the handler resolved the same way from `--target-path` (also possibly an ancestor), not the raycast hit and not necessarily the raw path GameObject itself. For a UI Toolkit hit it is the control's `name`, the same as the annotation's `Name`
+- `UiSystem`: Which UI system received the press (nullable string; `Click`/`LongPress` only, null if nothing was hit): `UGUI` for a target under a Canvas, `UIToolkit` for a UI Toolkit control, and `""` for a non-UI target such as a physics object
+- `HitPath`: Path of the hit target in the form `AnnotatedElements[].Path` uses (nullable string; `Click`/`LongPress` only): a hierarchy path for GameObjects, `Document/Path#element` for UI Toolkit controls
 - `PositionX`: Target X coordinate that was used
 - `PositionY`: Target Y coordinate that was used
 - `EndPositionX`: Drag end X coordinate (nullable float; populated for drag actions only)
@@ -18,4 +20,4 @@ Note: Click and LongPress on empty space (no UI element) still return `Success =
 
 ## UI Toolkit Elements
 
-`simulate-mouse-ui` drives the uGUI EventSystem raycast path, so it does not reach UI Toolkit controls (`AnnotatedElements` entries with `UiSystem` `UIToolkit`): a click at their `SimX`/`SimY` lands on the panel's own GameObject instead. `--target-path` does not accept their `Path` either. Click them with `simulate-mouse-input` instead, which works when the scene has an EventSystem with an Input System UI input module.
+`Click` and `LongPress` reach UI Toolkit controls at their annotated `SimX`/`SimY`. How presses are delivered and what is not supported: `ui-toolkit.md`.
diff --git a/.agents/skills/uloop-simulate-mouse-ui/references/ui-toolkit.md b/.agents/skills/uloop-simulate-mouse-ui/references/ui-toolkit.md
new file mode 100644
index 0000000000..ec3bb79d44
--- /dev/null
+++ b/.agents/skills/uloop-simulate-mouse-ui/references/ui-toolkit.md
@@ -0,0 +1,46 @@
+# simulate-mouse-ui and UI Toolkit
+
+`Click` and `LongPress` reach UI Toolkit controls on screen-space panels — the
+`AnnotatedElements` entries with `UiSystem` `UIToolkit`. Pass the entry's `SimX`/`SimY` as
+`--x`/`--y`; the response reports `UiSystem` `UIToolkit`, the control's `Name` as
+`HitGameObjectName`, and its annotation `Path` as `HitPath`.
+
+## How a press is delivered
+
+- The point is mapped to each panel the same way the screenshot annotation maps controls to
+  `SimX`/`SimY`, so an annotated point lands on the annotated control. It does not depend on
+  which Editor view was drawn last.
+- Panels are searched front to back by their panel settings' `sortingOrder`; the first panel
+  with a control under the point gets the press. The reported control is the outermost one an
+  annotation would list, so a click on a scrollbar's thumb reports the scrollbar.
+- Where a uGUI element and a UI Toolkit panel are both under the point, the uGUI element wins
+  only when its Canvas sorts above the panel (raycaster sort priority greater than the panel's
+  `sortingOrder`), the same rule the EventSystem applies to real input. A uGUI image without
+  any pointer handler in front still blocks the panel, as real input would.
+- A full-screen container left at the default `pickingMode` (`Position`) counts as a hit, so
+  uGUI underneath it is not reached — real input behaves the same way.
+- UI Toolkit presses do not need an EventSystem. With neither an EventSystem nor a UI Toolkit
+  control under the point, the command fails and says so.
+- A disabled control receives the press but does not react, as with real input.
+
+## LongPress
+
+A UI Toolkit `Button` fires `clicked` once when the long press is released (UI Toolkit's
+`Clickable` behaviour); a uGUI long press sends no click. A `RepeatButton` fires repeatedly
+while held.
+
+## Not supported
+
+- `--bypass-raycast`, `--target-path`, and `--drop-target-path` take GameObject paths only;
+  a UI Toolkit `Path` (it contains `#`) is reported as not found.
+- Drag actions go through the uGUI EventSystem only.
+- World-space panels (Unity 6), as in the annotation.
+- Two panels with the same `sortingOrder` overlapping at the point: Unity orders them by
+  creation order, which is not exposed, so either one may be chosen.
+
+## Notes
+
+- Move the real mouse cursor out of the Game View while simulating. Real pointer input over
+  the Game View reaches the same panels and can interleave with the simulated press.
+- Device Simulator has the same limits as the annotation: coordinates use the simulated device
+  resolution.
diff --git a/.claude/skills/uloop-screenshot/references/annotated-elements.md b/.claude/skills/uloop-screenshot/references/annotated-elements.md
index 5e1338e01d..69466c0964 100644
--- a/.claude/skills/uloop-screenshot/references/annotated-elements.md
+++ b/.claude/skills/uloop-screenshot/references/annotated-elements.md
@@ -10,7 +10,7 @@ Device Simulator is supported for this flow: prefer `--capture-mode rendering` (
 
 - `Label`: Index label in JSON (`A` = first in that sort, `B` = next, ...). Treat it as a stable handle, not as proof of what is actually in front: when overlapping elements cross parents, pick the target by `Path` and confirm the result with `simulate-mouse-ui`'s `HitGameObjectName` — the handler that received the events, resolved up the hierarchy from the raycast hit (or from `--target-path` in bypass mode), so it can name an ancestor of the element you clicked. Screenshot labels also include the interaction hint, such as `A / CLICK` or `B / DRAG`.
 - `Name`: Element name
-- `Path`: Hierarchy path from the scene root, for example `Canvas/Panel/Button`. Use this as `simulate-mouse-ui --target-path` when bypassing raycast blockers. UI Toolkit entries use a different form that `--target-path` does not accept; see [UI Toolkit Elements](#ui-toolkit-elements).
+- `Path`: Hierarchy path from the scene root, for example `Canvas/Panel/Button`. Use this as `simulate-mouse-ui --target-path` when bypassing raycast blockers. UI Toolkit entries use a different form that `--target-path` does not accept; click them at `SimX`/`SimY` instead. See [UI Toolkit Elements](#ui-toolkit-elements).
 - `Type`: Element type (`Button`, `Toggle`, `Slider`, `Dropdown`, `InputField`, `Scrollbar`, `Draggable`, `DropTarget`, `Selectable`, `PhysicsCollider`)
 - `Interaction`: Derived interaction category (`Click`, `Drag`, `Drop`, `Text`) or `Raycast` for clustered physics collider entries. Use this to choose between `simulate-mouse-ui --action Click`, drag actions, or `simulate-mouse-input` (including `--dry-run`).
 - `UiSystem`: UI system the entry came from: `UGUI`, `UIToolkit`, or empty for `PhysicsCollider` entries.
@@ -53,9 +53,9 @@ Limits:
 
 Clicking:
 
-- `simulate-mouse-input --action Click --x <SimX> --y <SimY>` reaches UI Toolkit controls when the scene has an EventSystem with an Input System UI input module.
-- Without an EventSystem the click does not reach UI Toolkit controls.
-- `simulate-mouse-ui` does not reach UI Toolkit controls, and its `--target-path` does not accept UI Toolkit `Path` values.
+- `simulate-mouse-ui --action Click --x <SimX> --y <SimY>` (or `LongPress`) reaches UI Toolkit controls, with or without an EventSystem. Its `--target-path` does not accept UI Toolkit `Path` values.
+- `simulate-mouse-input --action Click --x <SimX> --y <SimY>` also reaches them when the scene has an EventSystem with an Input System UI input module.
+- Without an EventSystem the `simulate-mouse-input` click does not reach UI Toolkit controls.
 
 ### PhysicsCollider Entries Per Closed Region
 
diff --git a/.claude/skills/uloop-simulate-mouse-input/SKILL.md b/.claude/skills/uloop-simulate-mouse-input/SKILL.md
index d7c92b3d44..41723aa257 100644
--- a/.claude/skills/uloop-simulate-mouse-input/SKILL.md
+++ b/.claude/skills/uloop-simulate-mouse-input/SKILL.md
@@ -67,7 +67,7 @@ All rows below assume the New Input System is installed.
 
 | Scenario | Tool |
 |----------|------|
-| Click a Unity UI Button (IPointerClickHandler) | `simulate-mouse-ui` |
+| Click a uGUI or UI Toolkit button | `simulate-mouse-ui` |
 | Runtime logic reads `Mouse.current.leftButton` | `simulate-mouse-input` |
 | Runtime logic reads right-click | `simulate-mouse-input --button Right` |
 | Drag a UI slider | `simulate-mouse-ui --action Drag` |
@@ -110,7 +110,7 @@ uloop simulate-mouse-input --action SmoothDelta --delta-x 300 --delta-y 0 --dura
 ## Coordinate System
 
 `--x`/`--y` use top-left Game View coordinates: pass `AnnotatedElements[].SimX/SimY`
-directly (UI Toolkit entries need an EventSystem in the scene), convert raw screenshot pixels with `ScreenshotToInputFormula`, and never flip Y
+directly (UI Toolkit entries need an EventSystem with an Input System UI module here; `simulate-mouse-ui` reaches them without one), convert raw screenshot pixels with `ScreenshotToInputFormula`, and never flip Y
 in the caller (the tool converts internally). Conversion formula, Device Simulator
 notes, and how the injected position reads back inside Unity are in
 `references/output-and-coordinates.md`.
diff --git a/.claude/skills/uloop-simulate-mouse-input/references/output-and-coordinates.md b/.claude/skills/uloop-simulate-mouse-input/references/output-and-coordinates.md
index a5998020b4..979f721cb7 100644
--- a/.claude/skills/uloop-simulate-mouse-input/references/output-and-coordinates.md
+++ b/.claude/skills/uloop-simulate-mouse-input/references/output-and-coordinates.md
@@ -30,7 +30,7 @@ Verify visual outcome with a follow-up screenshot.
 
 - `--x` / `--y` use **top-left Game View coordinates**.
 - Raw image pixels from `uloop screenshot --capture-mode rendering` must be converted with `ScreenshotToInputFormula`.
-- `AnnotatedElements[].SimX/SimY` can be passed directly to this tool. For UI Toolkit entries (`UiSystem` `UIToolkit`), a `Click` reaches the control only when the scene has an EventSystem with an Input System UI input module; without one, nothing receives the click.
+- `AnnotatedElements[].SimX/SimY` can be passed directly to this tool. For UI Toolkit entries (`UiSystem` `UIToolkit`), a `Click` reaches the control only when the scene has an EventSystem with an Input System UI input module; without one, nothing receives the click. `simulate-mouse-ui` reaches them without an EventSystem.
 - Do not flip Y in the caller. The tool converts internally for Unity Input System:
 
 ```text
diff --git a/.claude/skills/uloop-simulate-mouse-ui/SKILL.md b/.claude/skills/uloop-simulate-mouse-ui/SKILL.md
index 03417c9713..0be9c8c4fb 100644
--- a/.claude/skills/uloop-simulate-mouse-ui/SKILL.md
+++ b/.claude/skills/uloop-simulate-mouse-ui/SKILL.md
@@ -1,7 +1,7 @@
 ---
 name: uloop-simulate-mouse-ui
 toolName: simulate-mouse-ui
-description: "Simulate PlayMode EventSystem UI mouse actions using screen coordinates. Use for UI clicks, long-presses, or drags from annotated screenshots."
+description: "Simulate PlayMode UI mouse actions on uGUI and UI Toolkit using screen coordinates. Use for UI clicks, long-presses, or drags from annotated screenshots."
 ---
 
 # Task
@@ -64,7 +64,7 @@ uloop simulate-mouse-ui --action <action> --x <x> --y <y> [options]
 - Get coordinates from `AnnotatedElements` JSON (`SimX`/`SimY`) — do NOT look up GameObject positions
 - `--bypass-raycast` still uses coordinates for pointer event positions, but chooses the clicked, long-pressed, or dragged GameObject by `--target-path`
 - If `--target-path` or `--drop-target-path` matches multiple active GameObjects, the command fails instead of choosing an arbitrary duplicate
-- Not for UI Toolkit entries (`UiSystem` `UIToolkit`); see `references/output.md`.
+- UI Toolkit entries (`UiSystem` `UIToolkit`) can be clicked and long-pressed at `SimX`/`SimY`; `--bypass-raycast`, `--target-path`, and `--drop-target-path` take GameObjects only. Details: `references/ui-toolkit.md`.
 - Device Simulator play view is supported. Prefer `uloop screenshot --capture-mode rendering --annotate-elements` for coordinates; they use the simulated device resolution (`Handles.GetMainGameViewSize()` / `Screen`), not the Simulator chrome scale.
 
 ## Pause Point Inspection (Standard for E2E)
@@ -86,9 +86,6 @@ uloop simulate-mouse-ui --action Drag --from-x 400 --from-y 300 --x 600 --y 300
 # Long-press a button for 3 seconds
 uloop simulate-mouse-ui --action LongPress --x 400 --y 300 --duration 3.0
 
-# One-shot drag (start to end in one call)
-uloop simulate-mouse-ui --action Drag --from-x 400 --from-y 300 --x 600 --y 300
-
 # Slow drag for visual inspection
 uloop simulate-mouse-ui --action Drag --from-x 400 --from-y 300 --x 600 --y 300 --drag-speed 200
 
@@ -102,14 +99,14 @@ uloop simulate-mouse-ui --action DragEnd --x 600 --y 300
 ## Prerequisites
 
 - Unity must be in **PlayMode**
-- Target scene must have an **EventSystem** GameObject
-- UI elements must have a **GraphicRaycaster** on their Canvas
+- uGUI targets need an **EventSystem** and a **GraphicRaycaster** on their Canvas; UI Toolkit targets need neither
 - If you need runtime mouse input rather than UI pointer events, `simulate-mouse-input` assumes the project uses the New Input System; otherwise prefer `execute-dynamic-code`
 
 ## Output
 
 The response reports `Success`, `Message`, `Action`, `HitGameObjectName`, the used
-coordinates, and `InterruptedByPausePoint`/`PausePointHits`. Two readings that matter:
+coordinates, and `InterruptedByPausePoint`/`PausePointHits`; `UiSystem` and `HitPath` say
+which UI system was hit and give its path in the annotation's form. Two readings that matter:
 `Click`/`LongPress` on empty space still return `Success = true` with
 `HitGameObjectName = null` (drag actions on empty space fail), and on a pause-point
 interruption `Message` states whether the pointer event fired before the pause.
diff --git a/.claude/skills/uloop-simulate-mouse-ui/references/output.md b/.claude/skills/uloop-simulate-mouse-ui/references/output.md
index 043b24d6aa..af20d8c00b 100644
--- a/.claude/skills/uloop-simulate-mouse-ui/references/output.md
+++ b/.claude/skills/uloop-simulate-mouse-ui/references/output.md
@@ -5,7 +5,9 @@ Returns JSON with:
 - `Success`: Whether the operation succeeded
 - `Message`: Status message (e.g. "Hit element: ButtonStart" or "No UI element under (x, y)")
 - `Action`: Echoes which action was executed (`Click`, `Drag`, `DragStart`, `DragMove`, `DragEnd`, or `LongPress`)
-- `HitGameObjectName`: Name of the GameObject that received the pointer events (nullable string; null if nothing was hit). It is the event-handler target resolved up the hierarchy from the raycast hit (the first `IPointerDownHandler`, else the first `IPointerClickHandler`, for `Click`/`LongPress`; the first `IDragHandler` for drags), so it can be an ancestor of the topmost raycast hit — a Button's child Text reports the Button. With `--bypass-raycast` it is the handler resolved the same way from `--target-path` (also possibly an ancestor), not the raycast hit and not necessarily the raw path GameObject itself
+- `HitGameObjectName`: Name of the GameObject that received the pointer events (nullable string; null if nothing was hit). It is the event-handler target resolved up the hierarchy from the raycast hit (the first `IPointerDownHandler`, else the first `IPointerClickHandler`, for `Click`/`LongPress`; the first `IDragHandler` for drags), so it can be an ancestor of the topmost raycast hit — a Button's child Text reports the Button. With `--bypass-raycast` it is the handler resolved the same way from `--target-path` (also possibly an ancestor), not the raycast hit and not necessarily the raw path GameObject itself. For a UI Toolkit hit it is the control's `name`, the same as the annotation's `Name`
+- `UiSystem`: Which UI system received the press (nullable string; `Click`/`LongPress` only, null if nothing was hit): `UGUI` for a target under a Canvas, `UIToolkit` for a UI Toolkit control, and `""` for a non-UI target such as a physics object
+- `HitPath`: Path of the hit target in the form `AnnotatedElements[].Path` uses (nullable string; `Click`/`LongPress` only): a hierarchy path for GameObjects, `Document/Path#element` for UI Toolkit controls
 - `PositionX`: Target X coordinate that was used
 - `PositionY`: Target Y coordinate that was used
 - `EndPositionX`: Drag end X coordinate (nullable float; populated for drag actions only)
@@ -18,4 +20,4 @@ Note: Click and LongPress on empty space (no UI element) still return `Success =
 
 ## UI Toolkit Elements
 
-`simulate-mouse-ui` drives the uGUI EventSystem raycast path, so it does not reach UI Toolkit controls (`AnnotatedElements` entries with `UiSystem` `UIToolkit`): a click at their `SimX`/`SimY` lands on the panel's own GameObject instead. `--target-path` does not accept their `Path` either. Click them with `simulate-mouse-input` instead, which works when the scene has an EventSystem with an Input System UI input module.
+`Click` and `LongPress` reach UI Toolkit controls at their annotated `SimX`/`SimY`. How presses are delivered and what is not supported: `ui-toolkit.md`.
diff --git a/.claude/skills/uloop-simulate-mouse-ui/references/ui-toolkit.md b/.claude/skills/uloop-simulate-mouse-ui/references/ui-toolkit.md
new file mode 100644
index 0000000000..ec3bb79d44
--- /dev/null
+++ b/.claude/skills/uloop-simulate-mouse-ui/references/ui-toolkit.md
@@ -0,0 +1,46 @@
+# simulate-mouse-ui and UI Toolkit
+
+`Click` and `LongPress` reach UI Toolkit controls on screen-space panels — the
+`AnnotatedElements` entries with `UiSystem` `UIToolkit`. Pass the entry's `SimX`/`SimY` as
+`--x`/`--y`; the response reports `UiSystem` `UIToolkit`, the control's `Name` as
+`HitGameObjectName`, and its annotation `Path` as `HitPath`.
+
+## How a press is delivered
+
+- The point is mapped to each panel the same way the screenshot annotation maps controls to
+  `SimX`/`SimY`, so an annotated point lands on the annotated control. It does not depend on
+  which Editor view was drawn last.
+- Panels are searched front to back by their panel settings' `sortingOrder`; the first panel
+  with a control under the point gets the press. The reported control is the outermost one an
+  annotation would list, so a click on a scrollbar's thumb reports the scrollbar.
+- Where a uGUI element and a UI Toolkit panel are both under the point, the uGUI element wins
+  only when its Canvas sorts above the panel (raycaster sort priority greater than the panel's
+  `sortingOrder`), the same rule the EventSystem applies to real input. A uGUI image without
+  any pointer handler in front still blocks the panel, as real input would.
+- A full-screen container left at the default `pickingMode` (`Position`) counts as a hit, so
+  uGUI underneath it is not reached — real input behaves the same way.
+- UI Toolkit presses do not need an EventSystem. With neither an EventSystem nor a UI Toolkit
+  control under the point, the command fails and says so.
+- A disabled control receives the press but does not react, as with real input.
+
+## LongPress
+
+A UI Toolkit `Button` fires `clicked` once when the long press is released (UI Toolkit's
+`Clickable` behaviour); a uGUI long press sends no click. A `RepeatButton` fires repeatedly
+while held.
+
+## Not supported
+
+- `--bypass-raycast`, `--target-path`, and `--drop-target-path` take GameObject paths only;
+  a UI Toolkit `Path` (it contains `#`) is reported as not found.
+- Drag actions go through the uGUI EventSystem only.
+- World-space panels (Unity 6), as in the annotation.
+- Two panels with the same `sortingOrder` overlapping at the point: Unity orders them by
+  creation order, which is not exposed, so either one may be chosen.
+
+## Notes
+
+- Move the real mouse cursor out of the Game View while simulating. Real pointer input over
+  the Game View reaches the same panels and can interleave with the simulated press.
+- Device Simulator has the same limits as the annotation: coordinates use the simulated device
+  resolution.
diff --git a/Assets/Tests/Editor/MouseUiHitPriorityTests.cs b/Assets/Tests/Editor/MouseUiHitPriorityTests.cs
new file mode 100644
index 0000000000..8120869ec4
--- /dev/null
+++ b/Assets/Tests/Editor/MouseUiHitPriorityTests.cs
@@ -0,0 +1,64 @@
+using NUnit.Framework;
+
+using io.github.hatayama.UnityCliLoop.FirstPartyTools;
+
+namespace io.github.hatayama.UnityCliLoop.Tests.Editor
+{
+    /// <summary>
+    /// Verifies which of an overlapping uGUI hit and UI Toolkit hit takes the input, following the EventSystem's
+    /// raycast ordering.
+    /// </summary>
+    public sealed class MouseUiHitPriorityTests
+    {
+        /// <summary>
+        /// Verifies a Canvas sorted above the panel puts uGUI in front.
+        /// </summary>
+        [Test]
+        public void IsUguiInFront_WhenCanvasSortsAbovePanel_ReturnsTrue()
+        {
+            Assert.That(MouseUiHitPriority.IsUguiInFront(11, 10f), Is.True);
+        }
+
+        /// <summary>
+        /// Verifies equal sort priorities leave UI Toolkit in front, since the panel's render order priority is
+        /// nearly int.MaxValue.
+        /// </summary>
+        [TestCase(10, 10f)]
+        [TestCase(10, 10.5f)]
+        [TestCase(-1, -0.5f)]
+        public void IsUguiInFront_WhenSortPrioritiesAreEqual_ReturnsFalse(int uguiSortOrderPriority, float panelSortingOrder)
+        {
+            Assert.That(MouseUiHitPriority.IsUguiInFront(uguiSortOrderPriority, panelSortingOrder), Is.False);
+        }
+
+        /// <summary>
+        /// Verifies a fractional panel sorting order is rounded down, as PanelRaycaster does, so a Canvas just
+        /// above the rounded value comes in front; truncating or rounding up or to nearest would not.
+        /// </summary>
+        [TestCase(0, -0.5f)]
+        [TestCase(10, 9.5f)]
+        public void IsUguiInFront_WhenPanelSortingOrderIsFractional_RoundsDown(int uguiSortOrderPriority, float panelSortingOrder)
+        {
+            Assert.That(MouseUiHitPriority.IsUguiInFront(uguiSortOrderPriority, panelSortingOrder), Is.True);
+        }
+
+        /// <summary>
+        /// Verifies a panel sorted above the Canvas stays in front.
+        /// </summary>
+        [Test]
+        public void IsUguiInFront_WhenPanelSortsAboveCanvas_ReturnsFalse()
+        {
+            Assert.That(MouseUiHitPriority.IsUguiInFront(9, 10f), Is.False);
+        }
+
+        /// <summary>
+        /// Verifies raycasters that keep the base priority, such as physics raycasters and non-overlay Canvases,
+        /// never come in front of a panel.
+        /// </summary>
+        [Test]
+        public void IsUguiInFront_WithBaseRaycasterPriority_ReturnsFalse()
+        {
+            Assert.That(MouseUiHitPriority.IsUguiInFront(int.MinValue, -1000f), Is.False);
+        }
+    }
+}
diff --git a/Assets/Tests/Editor/MouseUiHitPriorityTests.cs.meta b/Assets/Tests/Editor/MouseUiHitPriorityTests.cs.meta
new file mode 100644
index 0000000000..f1d7b75805
--- /dev/null
+++ b/Assets/Tests/Editor/MouseUiHitPriorityTests.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 493c169e2fe5f485f956471f9840227a
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Tests/Editor/MouseUiPointerTargetResolverTests.cs b/Assets/Tests/Editor/MouseUiPointerTargetResolverTests.cs
index d3281f00f7..2f02091f9a 100644
--- a/Assets/Tests/Editor/MouseUiPointerTargetResolverTests.cs
+++ b/Assets/Tests/Editor/MouseUiPointerTargetResolverTests.cs
@@ -71,6 +71,28 @@ public void ResolveGameObjectPath_WithUniquePath_ReturnsTarget()
             Assert.That(failureResponse, Is.Null);
         }
 
+        /// <summary>
+        /// Verifies a GameObject whose name contains '#' still resolves by its path, so the UI Toolkit hint for
+        /// '#' paths only applies when nothing matches.
+        /// </summary>
+        [Test]
+        public void ResolveGameObjectPath_WithHashInGameObjectName_ReturnsTarget()
+        {
+            GameObject root = CreateGameObject("MouseUiTargetResolverTests_HashRoot");
+            GameObject expectedTarget = CreateGameObject("Menu#Play", root.transform);
+            string targetPath = GameObjectPathUtility.GetFullPath(expectedTarget);
+
+            (GameObject? target, SimulateMouseUiResponse? failureResponse) =
+                MouseUiPointerTargetResolver.ResolveGameObjectPath(
+                    targetPath,
+                    "TargetPath",
+                    MouseAction.Click,
+                    new Vector2(10f, 20f));
+
+            Assert.That(target, Is.SameAs(expectedTarget));
+            Assert.That(failureResponse, Is.Null);
+        }
+
         /// <summary>
         /// Verifies a missing hierarchy path returns the exact wire-visible failure response.
         /// </summary>
diff --git a/Assets/Tests/Editor/MouseUiSimulationResponseFactoryTests.cs b/Assets/Tests/Editor/MouseUiSimulationResponseFactoryTests.cs
index f7f9ab351b..f09de75b6b 100644
--- a/Assets/Tests/Editor/MouseUiSimulationResponseFactoryTests.cs
+++ b/Assets/Tests/Editor/MouseUiSimulationResponseFactoryTests.cs
@@ -103,7 +103,7 @@ public void CreateClickResult_WithHitMode_MapsMessageAndFields(
             Vector2 position = new(10.25f, 20.75f);
 
             SimulateMouseUiResponse response =
-                MouseUiSimulationResponseFactory.CreateClickResult(command, position, targetName, hitTarget);
+                MouseUiSimulationResponseFactory.CreateClickResult(command, position, CreateHit(hitTarget, targetName));
 
             Assert.That(response.Success, Is.True);
             Assert.That(response.Message, Is.EqualTo(expectedMessage));
@@ -136,7 +136,7 @@ public void CreateLongPressResult_WithHitMode_MapsMessageAndFields(
             Vector2 position = new(10.25f, 20.75f);
 
             SimulateMouseUiResponse response =
-                MouseUiSimulationResponseFactory.CreateLongPressResult(command, position, targetName, hitTarget);
+                MouseUiSimulationResponseFactory.CreateLongPressResult(command, position, CreateHit(hitTarget, targetName));
 
             Assert.That(response.Success, Is.True);
             Assert.That(response.Message, Is.EqualTo(expectedMessage));
@@ -146,6 +146,52 @@ public void CreateLongPressResult_WithHitMode_MapsMessageAndFields(
             Assert.That(response.PositionY, Is.EqualTo(position.y));
         }
 
+        /// <summary>
+        /// Verifies click and long-press results carry the hit's UI system and path, and name UI Toolkit hits as
+        /// such in the message.
+        /// </summary>
+        [Test]
+        public void CreatePressResults_WithUIToolkitHit_MapUiSystemAndPath()
+        {
+            MouseUiHitReport hit = new MouseUiHitReport("play", "Menu/Document#play", "UIToolkit");
+            Vector2 position = new(200f, 125f);
+
+            SimulateMouseUiResponse click = MouseUiSimulationResponseFactory.CreateClickResult(
+                CreateCommand(new SimulateMouseUiSchema { Action = UnityCliLoopMouseUiAction.Click }), position, hit);
+            SimulateMouseUiResponse longPress = MouseUiSimulationResponseFactory.CreateLongPressResult(
+                CreateCommand(new SimulateMouseUiSchema { Action = UnityCliLoopMouseUiAction.LongPress, Duration = 0.5f }), position, hit);
+
+            Assert.That(click.Message, Is.EqualTo("Clicked UI Toolkit element 'play' at (200.0, 125.0)"));
+            Assert.That(longPress.Message, Is.EqualTo("Long-pressed UI Toolkit element 'play' at (200.0, 125.0) for 0.5s"));
+            foreach (SimulateMouseUiResponse response in new[] { click, longPress })
+            {
+                Assert.That(response.HitGameObjectName, Is.EqualTo("play"));
+                Assert.That(response.UiSystem, Is.EqualTo("UIToolkit"));
+                Assert.That(response.HitPath, Is.EqualTo("Menu/Document#play"));
+            }
+        }
+
+        /// <summary>
+        /// Verifies a uGUI hit keeps its message and carries its UI system and path, and no hit leaves both null.
+        /// </summary>
+        [Test]
+        public void CreateClickResult_WithUguiHitOrNoHit_MapsUiSystemAndPath()
+        {
+            MouseUiSimulationCommand command = CreateCommand(new SimulateMouseUiSchema { Action = UnityCliLoopMouseUiAction.Click });
+            Vector2 position = new(10f, 20f);
+
+            SimulateMouseUiResponse ugui = MouseUiSimulationResponseFactory.CreateClickResult(
+                command, position, new MouseUiHitReport("Ok", "Canvas/Ok", "UGUI"));
+            SimulateMouseUiResponse none = MouseUiSimulationResponseFactory.CreateClickResult(
+                command, position, MouseUiHitReport.None);
+
+            Assert.That(ugui.Message, Is.EqualTo("Clicked 'Ok' at (10.0, 20.0)"));
+            Assert.That(ugui.UiSystem, Is.EqualTo("UGUI"));
+            Assert.That(ugui.HitPath, Is.EqualTo("Canvas/Ok"));
+            Assert.That(none.UiSystem, Is.Null);
+            Assert.That(none.HitPath, Is.Null);
+        }
+
         /// <summary>
         /// Verifies one-shot drag results retain normal and bypass message contracts.
         /// </summary>
@@ -218,5 +264,10 @@ private static MouseUiSimulationCommand CreateCommand(SimulateMouseUiSchema sche
             Assert.That(command, Is.Not.Null);
             return command!;
         }
+
+        private static MouseUiHitReport CreateHit(bool hitTarget, string? targetName)
+        {
+            return hitTarget ? new MouseUiHitReport(targetName, null, null) : MouseUiHitReport.None;
+        }
     }
 }
diff --git a/Assets/Tests/Editor/StaticFacadeStateGuardTests.cs b/Assets/Tests/Editor/StaticFacadeStateGuardTests.cs
index bbc231a349..56e2406c97 100644
--- a/Assets/Tests/Editor/StaticFacadeStateGuardTests.cs
+++ b/Assets/Tests/Editor/StaticFacadeStateGuardTests.cs
@@ -355,14 +355,19 @@ public void ExecuteDynamicCodeUseCase_WhenAwaitingWorkflow_DoesNotCaptureEditorS
         [Test]
         public void MouseUiPressActionExecutor_WhenReturningAfterTimeout_UsesCapturedUnityObjectState()
         {
-            // Tests that timeout result branches use plain captured bools instead of UnityEngine.Object null checks.
+            // Tests that timeout result branches use the hit report captured before the first await, and that
+            // the release decision is a captured bool, instead of UnityEngine.Object null checks after awaits.
             string source = ReadSourceFile(
                 "Packages/src/Editor/FirstPartyTools/SimulateMouseUi/MouseUiPressActionExecutor.cs");
-
-            Assert.That(source, Does.Contain("bool hitTarget = resolvedTargets.Target != null;"));
-            Assert.That(source, Does.Contain("bool shouldReleasePointer = resolvedTargets.RawTarget != null && resolvedTargets.Target != null;"));
-            Assert.That(source, Does.Not.Contain("CreateClickResult(parameters, inputPos, targetName, resolvedTargets.Target != null)"));
-            Assert.That(source, Does.Not.Contain("CreateLongPressResult(parameters, inputPos, targetName, resolvedTargets.Target != null)"));
+            string uguiTargetSource = ReadSourceFile(
+                "Packages/src/Editor/FirstPartyTools/SimulateMouseUi/UguiPressTarget.cs");
+
+            Assert.That(source, Does.Contain("MouseUiHitReport report = pressTarget.Report;"));
+            Assert.That(uguiTargetSource, Does.Contain("bool shouldReleasePointer = resolvedTargets.RawTarget != null && resolvedTargets.Target != null;"));
+            Assert.That(uguiTargetSource, Does.Contain("if (!_shouldReleasePointer)"));
+            Assert.That(source, Does.Not.Contain("CreateClickResult(parameters, inputPos, pressTarget.Report)"));
+            Assert.That(source, Does.Not.Contain("CreateLongPressResult(parameters, inputPos, pressTarget.Report)"));
+            Assert.That(source, Does.Not.Contain("resolvedTargets.Target"));
         }
 
         [Test]
diff --git a/Assets/Tests/Editor/UiRaycastHelperPanelSkipTests.cs b/Assets/Tests/Editor/UiRaycastHelperPanelSkipTests.cs
new file mode 100644
index 0000000000..aa67140458
--- /dev/null
+++ b/Assets/Tests/Editor/UiRaycastHelperPanelSkipTests.cs
@@ -0,0 +1,108 @@
+using System.Collections.Generic;
+using NUnit.Framework;
+using UnityEngine;
+using UnityEngine.EventSystems;
+using UnityEngine.UI;
+using UnityEngine.UIElements;
+
+using io.github.hatayama.UnityCliLoop.FirstPartyTools;
+
+namespace io.github.hatayama.UnityCliLoop.Tests.Editor
+{
+    /// <summary>
+    /// Verifies how EventSystem results that come from uGUI's UI Toolkit bridge are handled when choosing a hit.
+    /// The results are built by hand with real raycaster components as their module, because in EditMode the
+    /// bridge raycaster never registers and returns nothing. No Canvas-space hit is passed, since comparing one
+    /// reads Screen.
+    /// </summary>
+    public sealed class UiRaycastHelperPanelSkipTests
+    {
+        private readonly List<Object> _createdObjects = new List<Object>();
+
+        [TearDown]
+        public void TearDown()
+        {
+            foreach (Object createdObject in _createdObjects)
+            {
+                if (createdObject != null)
+                {
+                    Object.DestroyImmediate(createdObject);
+                }
+            }
+
+            _createdObjects.Clear();
+        }
+
+        /// <summary>
+        /// Verifies a bridge hit in first place is skipped and the next hit is chosen.
+        /// </summary>
+        [Test]
+        public void ChooseHitSkippingUIToolkitPanels_WhenFirstHitIsPanelRaycaster_ReturnsNextHit()
+        {
+            RaycastResult panelHit = CreatePanelHit();
+            RaycastResult graphicHit = CreateGraphicHit();
+
+            RaycastResult? chosen = UiRaycastHelper.ChooseHitSkippingUIToolkitPanels(
+                new List<RaycastResult> { panelHit, graphicHit }, null);
+
+            Assert.That(chosen.HasValue, Is.True);
+            Assert.That(chosen.Value.gameObject, Is.SameAs(graphicHit.gameObject));
+        }
+
+        /// <summary>
+        /// Verifies only bridge hits leave nothing to choose.
+        /// </summary>
+        [Test]
+        public void ChooseHitSkippingUIToolkitPanels_WhenOnlyPanelRaycaster_ReturnsNull()
+        {
+            RaycastResult? chosen = UiRaycastHelper.ChooseHitSkippingUIToolkitPanels(
+                new List<RaycastResult> { CreatePanelHit() }, null);
+
+            Assert.That(chosen.HasValue, Is.False);
+        }
+
+        /// <summary>
+        /// Verifies the unfiltered choice still returns a bridge hit in first place, so other callers keep their
+        /// current results.
+        /// </summary>
+        [Test]
+        public void ChooseHit_WhenFirstHitIsPanelRaycaster_ReturnsIt()
+        {
+            RaycastResult panelHit = CreatePanelHit();
+
+            RaycastResult? chosen = UiRaycastHelper.ChooseHit(
+                new List<RaycastResult> { panelHit, CreateGraphicHit() }, null);
+
+            Assert.That(chosen.HasValue, Is.True);
+            Assert.That(chosen.Value.gameObject, Is.SameAs(panelHit.gameObject));
+        }
+
+        /// <summary>
+        /// Verifies the type name the bridge results are recognised by matches the uGUI type.
+        /// </summary>
+        [Test]
+        public void PanelRaycasterTypeFullName_MatchesUguiType()
+        {
+            Assert.That(UiRaycastHelper.PanelRaycasterTypeFullName, Is.EqualTo(typeof(PanelRaycaster).FullName));
+        }
+
+        private RaycastResult CreatePanelHit()
+        {
+            GameObject panelObject = CreateGameObject("Panel");
+            return new RaycastResult { gameObject = panelObject, module = panelObject.AddComponent<PanelRaycaster>() };
+        }
+
+        private RaycastResult CreateGraphicHit()
+        {
+            GameObject canvasObject = CreateGameObject("Canvas");
+            return new RaycastResult { gameObject = canvasObject, module = canvasObject.AddComponent<GraphicRaycaster>() };
+        }
+
+        private GameObject CreateGameObject(string name)
+        {
+            GameObject gameObject = new GameObject("UiRaycastHelperPanelSkipTests_" + name);
+            _createdObjects.Add(gameObject);
+            return gameObject;
+        }
+    }
+}
diff --git a/Assets/Tests/Editor/UiRaycastHelperPanelSkipTests.cs.meta b/Assets/Tests/Editor/UiRaycastHelperPanelSkipTests.cs.meta
new file mode 100644
index 0000000000..20cc20769f
--- /dev/null
+++ b/Assets/Tests/Editor/UiRaycastHelperPanelSkipTests.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 2653f3ed2aaa646dc9186abf235ba686
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Tests/PlayMode/SimulateMouseUiToolkitTests.cs b/Assets/Tests/PlayMode/SimulateMouseUiToolkitTests.cs
new file mode 100644
index 0000000000..c27f38a486
--- /dev/null
+++ b/Assets/Tests/PlayMode/SimulateMouseUiToolkitTests.cs
@@ -0,0 +1,732 @@
+#nullable enable
+using System.Collections;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using io.github.hatayama.UnityCliLoop.FirstPartyTools;
+using io.github.hatayama.UnityCliLoop.Runtime;
+using io.github.hatayama.UnityCliLoop.ToolContracts;
+using Newtonsoft.Json.Linq;
+using NUnit.Framework;
+using UnityEditor;
+using UnityEngine;
+using UnityEngine.EventSystems;
+using UnityEngine.TestTools;
+using UnityEngine.UI;
+using UnityEngine.UIElements;
+
+using Image = UnityEngine.UI.Image;
+using MouseButton = io.github.hatayama.UnityCliLoop.Runtime.MouseButton;
+using UIToolkitButton = UnityEngine.UIElements.Button;
+
+namespace io.github.hatayama.UnityCliLoop.Tests.PlayMode
+{
+    /// <summary>
+    /// Verifies simulate-mouse-ui clicks and long presses reach UI Toolkit controls, choose between uGUI and UI
+    /// Toolkit where both are under the point as the EventSystem would, work without an EventSystem for UI
+    /// Toolkit, and report which UI system and path were hit. The UI Toolkit button sits at the centre of the
+    /// Game View, where the Canvas elements are anchored too. Each test decides whether an EventSystem exists.
+    /// </summary>
+    public sealed class SimulateMouseUiToolkitTests
+    {
+        private const string RuntimeThemePath = "Assets/UI Toolkit/UnityThemes/UnityDefaultRuntimeTheme.tss";
+        private const string DocumentName = "SimulateMouseUiToolkitTests_Document";
+        private const float ButtonWidth = 200f;
+        private const float ButtonHeight = 100f;
+        private const string NoEventSystemMessage = "No EventSystem found in the scene. Ensure an EventSystem GameObject exists.";
+
+        private readonly List<Object> _createdObjects = new List<Object>();
+        private ExistingEventSystemDisableScope _eventSystemDisableScope = null!;
+        private GameObject _canvasObject = null!;
+        private SimulateMouseUiTool _tool = null!;
+        private SimulateMouseUiResponse _lastResponse = null!;
+
+        [UnitySetUp]
+        public IEnumerator SetUp()
+        {
+            _eventSystemDisableScope = new ExistingEventSystemDisableScope();
+
+            _canvasObject = new GameObject("TestCanvas");
+            _createdObjects.Add(_canvasObject);
+            Canvas canvas = _canvasObject.AddComponent<Canvas>();
+            canvas.renderMode = RenderMode.ScreenSpaceOverlay;
+            _canvasObject.AddComponent<CanvasScaler>();
+            _canvasObject.AddComponent<GraphicRaycaster>();
+
+            _tool = new SimulateMouseUiTool();
+            yield return null;
+        }
+
+        [UnityTearDown]
+        public IEnumerator TearDown()
+        {
+            MouseDragState.Clear();
+            foreach (Object createdObject in _createdObjects)
+            {
+                if (createdObject != null)
+                {
+                    Object.Destroy(createdObject);
+                }
+            }
+
+            _createdObjects.Clear();
+            yield return null;
+
+            _eventSystemDisableScope.Restore();
+        }
+
+        /// <summary>
+        /// Verifies a uGUI click reports the UGUI system and the target's hierarchy path (#2).
+        /// </summary>
+        [UnityTest]
+        public IEnumerator Click_OnUgui_ReportsUguiSystemAndPath()
+        {
+            CreateEventSystem();
+            ClickTracker tracker = CreateCanvasClickTarget("UguiTarget");
+            yield return null;
+
+            yield return RunClick(GameViewCenter());
+
+            Assert.IsTrue(_lastResponse.Success, _lastResponse.Message);
+            Assert.IsTrue(tracker.PointerClickCalled);
+            Assert.AreEqual("UguiTarget", _lastResponse.HitGameObjectName);
+            Assert.AreEqual("UGUI", _lastResponse.UiSystem);
+            Assert.AreEqual("TestCanvas/UguiTarget", _lastResponse.HitPath);
+        }
+
+        /// <summary>
+        /// Verifies a click on a UI Toolkit button clicks it once, reports it, and leaves no pointer capture (#4).
+        /// </summary>
+        [UnityTest]
+        public IEnumerator Click_OnUIToolkitButtonWithEventSystem_ClicksIt()
+        {
+            CreateEventSystem();
+            UIDocument document = CreateDocumentWithCenteredButton(0f, out ClickCounter counter);
+            yield return WaitForLayout();
+
+            yield return RunClick(GameViewCenter());
+
+            Assert.IsTrue(_lastResponse.Success, _lastResponse.Message);
+            Assert.AreEqual(1, counter.Clicks);
+            Assert.AreEqual("play", _lastResponse.HitGameObjectName);
+            Assert.AreEqual("UIToolkit", _lastResponse.UiSystem);
+            Assert.AreEqual(DocumentName + "#play", _lastResponse.HitPath);
+            Assert.AreEqual(
+                $"Clicked UI Toolkit element 'play' at ({GameViewCenter().x:F1}, {GameViewCenter().y:F1})",
+                _lastResponse.Message);
+            Assert.IsNull(document.rootVisualElement.panel.GetCapturingElement(PointerId.mousePointerId));
+        }
+
+        /// <summary>
+        /// Verifies a Canvas sorted above the panel takes the click (#5).
+        /// </summary>
+        [UnityTest]
+        public IEnumerator Click_WhereUguiCanvasSortsAbovePanel_ClicksUgui()
+        {
+            yield return ClickOverlap(canvasSortingOrder: 11, panelSortingOrder: 10f);
+
+            Assert.IsTrue(_lastTracker.PointerClickCalled, "the Canvas element must be clicked");
+            Assert.AreEqual(0, _lastCounter.Clicks, "the UI Toolkit button must not be clicked");
+            Assert.AreEqual("UGUI", _lastResponse.UiSystem);
+        }
+
+        /// <summary>
+        /// Verifies a Canvas and a panel with the same sorting order leave UI Toolkit in front (#6).
+        /// </summary>
+        [UnityTest]
+        public IEnumerator Click_WhereCanvasAndPanelShareSortingOrder_ClicksUIToolkit()
+        {
+            yield return ClickOverlap(canvasSortingOrder: 10, panelSortingOrder: 10f);
+
+            Assert.IsFalse(_lastTracker.PointerClickCalled, "the Canvas element must not be clicked");
+            Assert.AreEqual(1, _lastCounter.Clicks, "the UI Toolkit button must be clicked");
+            Assert.AreEqual("UIToolkit", _lastResponse.UiSystem);
+        }
+
+        /// <summary>
+        /// Verifies a panel sorted above the Canvas takes the click (#7).
+        /// </summary>
+        [UnityTest]
+        public IEnumerator Click_WherePanelSortsAboveCanvas_ClicksUIToolkit()
+        {
+            yield return ClickOverlap(canvasSortingOrder: 9, panelSortingOrder: 10f);
+
+            Assert.IsFalse(_lastTracker.PointerClickCalled, "the Canvas element must not be clicked");
+            Assert.AreEqual(1, _lastCounter.Clicks, "the UI Toolkit button must be clicked");
+            Assert.AreEqual("UIToolkit", _lastResponse.UiSystem);
+        }
+
+        /// <summary>
+        /// Verifies a UI Toolkit button is clicked when the scene has no EventSystem (#9).
+        /// </summary>
+        [UnityTest]
+        public IEnumerator Click_OnUIToolkitButtonWithoutEventSystem_ClicksIt()
+        {
+            Assert.IsNull(EventSystem.current, "Setup: no EventSystem must be active.");
+            CreateDocumentWithCenteredButton(0f, out ClickCounter counter);
+            yield return WaitForLayout();
+
+            yield return RunClick(GameViewCenter());
+
+            Assert.IsTrue(_lastResponse.Success, _lastResponse.Message);
+            Assert.AreEqual(1, counter.Clicks);
+            Assert.AreEqual("UIToolkit", _lastResponse.UiSystem);
+        }
+
+        /// <summary>
+        /// Verifies a click with no EventSystem and no UI Toolkit element under the point fails and names both
+        /// UI systems (#10).
+        /// </summary>
+        [UnityTest]
+        public IEnumerator Click_WithoutEventSystemOnEmptyPoint_FailsNamingBothSystems()
+        {
+            Vector2 point = GameViewCenter();
+
+            yield return RunClick(point);
+
+            Assert.IsFalse(_lastResponse.Success);
+            Assert.AreEqual(
+                $"No EventSystem found in the scene, and no UI Toolkit element is at ({point.x:F1}, {point.y:F1}). Ensure an EventSystem GameObject exists for uGUI.",
+                _lastResponse.Message);
+        }
+
+        /// <summary>
+        /// Verifies a bypass click given a UI Toolkit path explains that such paths are not accepted (#15).
+        /// </summary>
+        [UnityTest]
+        public IEnumerator BypassClick_WithUIToolkitPath_ExplainsPathIsNotAccepted()
+        {
+            CreateEventSystem();
+            CreateDocumentWithCenteredButton(0f, out ClickCounter counter);
+            yield return WaitForLayout();
+            string path = DocumentName + "#play";
+
+            yield return RunTool(new JObject
+            {
+                ["action"] = MouseAction.Click.ToString(),
+                ["bypassRaycast"] = true,
+                ["targetPath"] = path
+            });
+
+            Assert.IsFalse(_lastResponse.Success);
+            Assert.AreEqual(
+                $"TargetPath '{path}' was not found. UI Toolkit element paths are not accepted here; click the element at its SimX/SimY without --bypass-raycast.",
+                _lastResponse.Message);
+            Assert.AreEqual(0, counter.Clicks);
+        }
+
+        /// <summary>
+        /// Verifies a bypass click still needs an EventSystem and fails with the same message as before (#17).
+        /// </summary>
+        [UnityTest]
+        public IEnumerator BypassClick_WithoutEventSystem_FailsAsBefore()
+        {
+            CreateCanvasClickTarget("BypassTarget");
+            yield return null;
+
+            yield return RunTool(new JObject
+            {
+                ["action"] = MouseAction.Click.ToString(),
+                ["bypassRaycast"] = true,
+                ["targetPath"] = "TestCanvas/BypassTarget"
+            });
+
+            Assert.IsFalse(_lastResponse.Success);
+            Assert.AreEqual(NoEventSystemMessage, _lastResponse.Message);
+        }
+
+        /// <summary>
+        /// Verifies option errors are reported before a missing EventSystem (#18).
+        /// </summary>
+        [UnityTest]
+        public IEnumerator Drag_WithNegativeDragSpeedAndNoEventSystem_ReportsDragSpeedError()
+        {
+            yield return RunTool(new JObject
+            {
+                ["action"] = MouseAction.Drag.ToString(),
+                ["dragSpeed"] = -1f
+            });
+
+            Assert.IsFalse(_lastResponse.Success);
+            Assert.AreEqual("DragSpeed must be non-negative, got: -1", _lastResponse.Message);
+        }
+
+        /// <summary>
+        /// Verifies a drag with no EventSystem still fails with the existing message.
+        /// </summary>
+        [UnityTest]
+        public IEnumerator Drag_WithoutEventSystem_FailsAsBefore()
+        {
+            CreateDocumentWithCenteredButton(0f, out ClickCounter _);
+            yield return WaitForLayout();
+            Vector2 point = GameViewCenter();
+
+            yield return RunTool(new JObject
+            {
+                ["action"] = MouseAction.Drag.ToString(),
+                ["fromX"] = point.x,
+                ["fromY"] = point.y,
+                ["x"] = point.x + 10f,
+                ["y"] = point.y
+            });
+
+            Assert.IsFalse(_lastResponse.Success);
+            Assert.AreEqual(NoEventSystemMessage, _lastResponse.Message);
+        }
+
+        /// <summary>
+        /// Verifies a right click reaches the UI Toolkit button as button 1 and does not click it (#20).
+        /// </summary>
+        [UnityTest]
+        public IEnumerator RightClick_OnUIToolkitButton_DoesNotClick()
+        {
+            CreateEventSystem();
+            CreateDocumentWithCenteredButton(0f, out ClickCounter counter);
+            yield return WaitForLayout();
+
+            yield return RunTool(new JObject
+            {
+                ["action"] = MouseAction.Click.ToString(),
+                ["x"] = GameViewCenter().x,
+                ["y"] = GameViewCenter().y,
+                ["button"] = MouseButton.Right.ToString()
+            });
+
+            Assert.IsTrue(_lastResponse.Success, _lastResponse.Message);
+            Assert.AreEqual(1, counter.LastPressedButton, "the press must arrive as the right button");
+            Assert.AreEqual(0, counter.Clicks);
+        }
+
+        /// <summary>
+        /// Verifies a click during a uGUI split drag is rejected as drag-active even after the EventSystem is
+        /// removed (#23).
+        /// </summary>
+        [UnityTest]
+        public IEnumerator Click_WhileSplitDragActiveWithoutEventSystem_IsRejectedAsDragActive()
+        {
+            GameObject eventSystemObject = CreateEventSystem();
+            GameObject dragObject = CreateCanvasElement("DragTarget");
+            dragObject.AddComponent<Image>();
+            dragObject.AddComponent<DragTracker>();
+            yield return null;
+            Vector2 point = GameViewCenter();
+            yield return RunTool(new JObject
+            {
+                ["action"] = MouseAction.DragStart.ToString(),
+                ["x"] = point.x,
+                ["y"] = point.y
+            });
+            Assert.IsTrue(_lastResponse.Success, "Setup: DragStart must succeed. " + _lastResponse.Message);
+            eventSystemObject.SetActive(false);
+            yield return null;
+
+            yield return RunClick(point);
+
+            Assert.IsFalse(_lastResponse.Success);
+            Assert.AreEqual("Cannot Click while a split drag is active. Call DragEnd first.", _lastResponse.Message);
+        }
+
+        /// <summary>
+        /// Verifies a handler-less uGUI image sorted above the panel stops the click from reaching UI Toolkit,
+        /// as it would for real input (#24).
+        /// </summary>
+        [UnityTest]
+        public IEnumerator Click_WhereHandlerlessUguiImageSortsAbovePanel_BlocksUIToolkit()
+        {
+            CreateEventSystem();
+            _canvasObject.GetComponent<Canvas>().sortingOrder = 11;
+            CreateCanvasElement("Blocker").AddComponent<Image>();
+            CreateDocumentWithCenteredButton(10f, out ClickCounter counter);
+            yield return WaitForLayout();
+
+            yield return RunClick(GameViewCenter());
+
+            Assert.IsTrue(_lastResponse.Success, _lastResponse.Message);
+            Assert.AreEqual(0, counter.Clicks, "the UI Toolkit button must not be clicked");
+            Assert.IsNull(_lastResponse.HitGameObjectName);
+            Assert.IsNull(_lastResponse.UiSystem);
+            Assert.IsNull(_lastResponse.HitPath);
+        }
+
+        /// <summary>
+        /// Verifies a click still succeeds without error when the UI Toolkit document is disabled after the
+        /// target is resolved and before the press is sent, and sends nothing: a document behind it on the same
+        /// panel would otherwise receive the press (#25).
+        /// </summary>
+        [UnityTest]
+        public IEnumerator Click_WhenUIToolkitDocumentDisabledBeforeDispatch_SkipsWithoutError()
+        {
+            CreateEventSystem();
+            UIDocument document = CreateDocumentWithCenteredButton(0f, out ClickCounter counter);
+            AddDocumentWithCenteredButton(document.panelSettings, "back", document.sortingOrder - 1f, out ClickCounter backCounter);
+            yield return WaitForLayout();
+            Task<UnityCliLoopToolResponse> task = StartTool(ClickParameters(GameViewCenter()));
+
+            yield return null;
+            Assert.IsFalse(task.IsCompleted, "Setup: the click must still be animating when the document is disabled.");
+            document.enabled = false;
+            yield return WaitForTask(task);
+
+            Assert.IsTrue(_lastResponse.Success, _lastResponse.Message);
+            Assert.AreEqual("play", _lastResponse.HitGameObjectName, "the front document must have been resolved");
+            Assert.AreEqual(0, counter.PointerDowns);
+            Assert.AreEqual(0, backCounter.PointerDowns, "no press may reach the document behind");
+        }
+
+        /// <summary>
+        /// Verifies a Canvas image with no pointer handler reports no hit (#26).
+        /// </summary>
+        [UnityTest]
+        public IEnumerator Click_OnUguiImageWithoutHandler_ReportsNoHit()
+        {
+            CreateEventSystem();
+            CreateCanvasElement("PlainImage").AddComponent<Image>();
+            yield return null;
+            Vector2 point = GameViewCenter();
+
+            yield return RunClick(point);
+
+            Assert.IsTrue(_lastResponse.Success, _lastResponse.Message);
+            Assert.AreEqual($"Clicked at ({point.x:F1}, {point.y:F1}) - no UI element hit", _lastResponse.Message);
+            Assert.IsNull(_lastResponse.HitGameObjectName);
+            Assert.IsNull(_lastResponse.UiSystem);
+            Assert.IsNull(_lastResponse.HitPath);
+        }
+
+        /// <summary>
+        /// Verifies a click on a physics target outside any Canvas reports an empty UI system and its path (#27).
+        /// </summary>
+        [UnityTest]
+        public IEnumerator Click_OnPhysics2DTarget_ReportsEmptyUiSystem()
+        {
+            CreateEventSystem();
+            GameObject physicsRoot = new GameObject("Physics2DRaycasterRoot");
+            _createdObjects.Add(physicsRoot);
+            GameObject cameraObject = new GameObject("Physics2DCamera");
+            cameraObject.transform.SetParent(physicsRoot.transform, false);
+            cameraObject.transform.position = new Vector3(0f, 0f, -10f);
+            Camera physicsCamera = cameraObject.AddComponent<Camera>();
+            physicsCamera.orthographic = true;
+            physicsCamera.orthographicSize = 5f;
+            cameraObject.AddComponent<HighPriorityPhysics2DRaycaster>();
+            GameObject physicsTarget = new GameObject("Physics2DTarget");
+            physicsTarget.transform.SetParent(physicsRoot.transform, false);
+            Vector3 screenPoint = new Vector3(Screen.width / 2f, Screen.height / 2f, 10f);
+            Vector3 worldPoint = physicsCamera.ScreenToWorldPoint(screenPoint);
+            physicsTarget.transform.position = new Vector3(worldPoint.x, worldPoint.y, 0f);
+            physicsTarget.AddComponent<BoxCollider2D>().size = new Vector2(2f, 2f);
+            ClickTracker tracker = physicsTarget.AddComponent<ClickTracker>();
+            yield return null;
+
+            yield return RunClick(GameViewCenter());
+
+            Assert.IsTrue(_lastResponse.Success, _lastResponse.Message);
+            Assert.IsTrue(tracker.PointerClickCalled);
+            Assert.AreEqual("Physics2DTarget", _lastResponse.HitGameObjectName);
+            Assert.AreEqual("", _lastResponse.UiSystem);
+            Assert.AreEqual("Physics2DRaycasterRoot/Physics2DTarget", _lastResponse.HitPath);
+        }
+
+        /// <summary>
+        /// Verifies a bypass click on a Canvas element reports the UGUI system and the target path (#28).
+        /// </summary>
+        [UnityTest]
+        public IEnumerator BypassClick_OnCanvasButton_ReportsUguiSystem()
+        {
+            CreateEventSystem();
+            ClickTracker tracker = CreateCanvasClickTarget("BypassTarget");
+            yield return null;
+
+            yield return RunTool(new JObject
+            {
+                ["action"] = MouseAction.Click.ToString(),
+                ["bypassRaycast"] = true,
+                ["targetPath"] = "TestCanvas/BypassTarget"
+            });
+
+            Assert.IsTrue(_lastResponse.Success, _lastResponse.Message);
+            Assert.IsTrue(tracker.PointerClickCalled);
+            Assert.AreEqual("UGUI", _lastResponse.UiSystem);
+            Assert.AreEqual("TestCanvas/BypassTarget", _lastResponse.HitPath);
+        }
+
+        /// <summary>
+        /// Verifies a long press on a UI Toolkit button clicks it once on release, as UI Toolkit buttons do, and
+        /// leaves no pointer capture.
+        /// </summary>
+        [UnityTest]
+        public IEnumerator LongPress_OnUIToolkitButton_ClicksOnReleaseAndLeavesNoCapture()
+        {
+            CreateEventSystem();
+            UIDocument document = CreateDocumentWithCenteredButton(0f, out ClickCounter counter);
+            yield return WaitForLayout();
+
+            yield return RunTool(LongPressParameters(GameViewCenter(), 0.2f));
+
+            Assert.IsTrue(_lastResponse.Success, _lastResponse.Message);
+            Assert.AreEqual(1, counter.Clicks);
+            Assert.AreEqual("UIToolkit", _lastResponse.UiSystem);
+            Assert.AreEqual(DocumentName + "#play", _lastResponse.HitPath);
+            Assert.IsNull(document.rootVisualElement.panel.GetCapturingElement(PointerId.mousePointerId));
+        }
+
+        /// <summary>
+        /// Verifies a click whose UI Toolkit press handler throws still releases the pointer, and the exception
+        /// ends the command instead of being swallowed.
+        /// </summary>
+        [UnityTest]
+        public IEnumerator Click_WhenUIToolkitPressHandlerThrows_ReleasesAndPropagates()
+        {
+            yield return RunWithThrowingPressHandler(ClickParameters(GameViewCenter()));
+        }
+
+        /// <summary>
+        /// Verifies a long press whose UI Toolkit press handler throws still releases the pointer, and the
+        /// exception ends the command instead of being swallowed.
+        /// </summary>
+        [UnityTest]
+        public IEnumerator LongPress_WhenUIToolkitPressHandlerThrows_ReleasesAndPropagates()
+        {
+            yield return RunWithThrowingPressHandler(LongPressParameters(GameViewCenter(), 0.2f));
+        }
+
+        /// <summary>
+        /// Verifies cancelling a long press while it holds still releases the UI Toolkit press, so no element is
+        /// left holding the pointer.
+        /// </summary>
+        [UnityTest]
+        public IEnumerator LongPress_OnUIToolkitButton_WhenCancelledDuringHold_ReleasesCapture()
+        {
+            CreateEventSystem();
+            UIDocument document = CreateDocumentWithCenteredButton(0f, out ClickCounter counter);
+            yield return WaitForLayout();
+            using CancellationTokenSource cancellation = new CancellationTokenSource();
+            Task<UnityCliLoopToolResponse> task = _tool.ExecuteAsync(LongPressParameters(GameViewCenter(), 5f), cancellation.Token);
+            float timeoutAt = Time.realtimeSinceStartup + 5f;
+            yield return new WaitUntil(() => counter.PointerDowns > 0 || Time.realtimeSinceStartup >= timeoutAt);
+            Assert.AreEqual(1, counter.PointerDowns, "Setup: the press must have arrived before cancelling.");
+
+            cancellation.Cancel();
+            timeoutAt = Time.realtimeSinceStartup + 5f;
+            yield return new WaitUntil(() => task.IsCompleted || Time.realtimeSinceStartup >= timeoutAt);
+            yield return null;
+
+            Assert.IsTrue(task.IsCompleted, "the long press must end after cancelling");
+            Assert.IsTrue(task.IsCanceled || task.Exception?.InnerException is System.OperationCanceledException,
+                $"the long press must end by cancellation, got {task.Status}: {task.Exception}");
+            Assert.IsNull(document.rootVisualElement.panel.GetCapturingElement(PointerId.mousePointerId));
+        }
+
+        /// <summary>
+        /// Verifies a long press whose UI Toolkit document is disabled while it holds ends successfully without
+        /// error.
+        /// </summary>
+        [UnityTest]
+        public IEnumerator LongPress_WhenDocumentDisabledDuringHold_ReleasesWithoutError()
+        {
+            CreateEventSystem();
+            UIDocument document = CreateDocumentWithCenteredButton(0f, out ClickCounter counter);
+            yield return WaitForLayout();
+            Task<UnityCliLoopToolResponse> task = StartTool(LongPressParameters(GameViewCenter(), 0.5f));
+            float timeoutAt = Time.realtimeSinceStartup + 5f;
+            yield return new WaitUntil(() => counter.PointerDowns > 0 || Time.realtimeSinceStartup >= timeoutAt);
+            Assert.AreEqual(1, counter.PointerDowns, "Setup: the press must have arrived before disabling.");
+
+            document.enabled = false;
+            yield return WaitForTask(task);
+
+            Assert.IsTrue(_lastResponse.Success, _lastResponse.Message);
+            Assert.AreEqual("play", _lastResponse.HitGameObjectName);
+        }
+
+        private IEnumerator RunWithThrowingPressHandler(JObject parameters)
+        {
+            CreateEventSystem();
+            UIDocument document = CreateDocumentWithCenteredButton(0f, out ClickCounter _);
+            UIToolkitButton button = document.rootVisualElement.Q<UIToolkitButton>("play");
+            int pointerUps = 0;
+            button.RegisterCallback<PointerDownEvent>(
+                _ => throw new System.InvalidOperationException("press handler failed"),
+                TrickleDown.TrickleDown);
+            button.RegisterCallback<PointerUpEvent>(_ => pointerUps++, TrickleDown.TrickleDown);
+            yield return WaitForLayout();
+
+            Task<UnityCliLoopToolResponse> task = StartTool(parameters);
+            float timeoutAt = Time.realtimeSinceStartup + 5f;
+            yield return new WaitUntil(() => task.IsCompleted || Time.realtimeSinceStartup >= timeoutAt);
+
+            Assert.IsTrue(task.IsCompleted, "Tool execution timed out.");
+            Assert.IsTrue(task.IsFaulted, $"the handler's exception must end the command, got {task.Status}");
+            Assert.IsInstanceOf<System.InvalidOperationException>(task.Exception!.InnerException);
+            Assert.AreEqual(1, pointerUps, "the release must still be sent");
+        }
+
+        private ClickTracker _lastTracker = null!;
+        private ClickCounter _lastCounter = null!;
+
+        private IEnumerator ClickOverlap(int canvasSortingOrder, float panelSortingOrder)
+        {
+            CreateEventSystem();
+            _canvasObject.GetComponent<Canvas>().sortingOrder = canvasSortingOrder;
+            _lastTracker = CreateCanvasClickTarget("UguiTarget");
+            CreateDocumentWithCenteredButton(panelSortingOrder, out _lastCounter);
+            yield return WaitForLayout();
+
+            yield return RunClick(GameViewCenter());
+
+            Assert.IsTrue(_lastResponse.Success, _lastResponse.Message);
+        }
+
+        private GameObject CreateEventSystem()
+        {
+            GameObject eventSystemObject = new GameObject("TestEventSystem");
+            _createdObjects.Add(eventSystemObject);
+            eventSystemObject.AddComponent<EventSystem>();
+            eventSystemObject.AddComponent<StandaloneInputModule>();
+            return eventSystemObject;
+        }
+
+        private ClickTracker CreateCanvasClickTarget(string name)
+        {
+            GameObject element = CreateCanvasElement(name);
+            element.AddComponent<Image>();
+            return element.AddComponent<ClickTracker>();
+        }
+
+        // Anchored at the Canvas centre, which is the Game View centre in PlayMode.
+        private GameObject CreateCanvasElement(string name)
+        {
+            GameObject element = new GameObject(name);
+            element.transform.SetParent(_canvasObject.transform, false);
+            RectTransform rect = element.AddComponent<RectTransform>();
+            rect.anchorMin = new Vector2(0.5f, 0.5f);
+            rect.anchorMax = new Vector2(0.5f, 0.5f);
+            rect.anchoredPosition = Vector2.zero;
+            rect.sizeDelta = new Vector2(ButtonWidth, ButtonHeight);
+            return element;
+        }
+
+        // The object starts inactive so the document sees its panel settings when it first enables.
+        private UIDocument CreateDocumentWithCenteredButton(float sortingOrder, out ClickCounter counter)
+        {
+            PanelSettings settings = ScriptableObject.CreateInstance<PanelSettings>();
+            settings.scaleMode = PanelScaleMode.ConstantPixelSize;
+            settings.scale = 1f;
+            settings.sortingOrder = sortingOrder;
+            settings.themeStyleSheet = AssetDatabase.LoadAssetAtPath<ThemeStyleSheet>(RuntimeThemePath);
+            Assert.IsNotNull(settings.themeStyleSheet, "the runtime theme must exist at " + RuntimeThemePath);
+            _createdObjects.Add(settings);
+
+            return AddDocumentWithCenteredButton(settings, "play", 0f, out counter);
+        }
+
+        // Documents sharing panel settings share one panel, ordered within it by the document's sorting order.
+        private UIDocument AddDocumentWithCenteredButton(
+            PanelSettings settings,
+            string buttonName,
+            float documentSortingOrder,
+            out ClickCounter counter)
+        {
+            GameObject documentObject = new GameObject(DocumentName);
+            documentObject.SetActive(false);
+            _createdObjects.Add(documentObject);
+            UIDocument document = documentObject.AddComponent<UIDocument>();
+            document.panelSettings = settings;
+            document.sortingOrder = documentSortingOrder;
+            documentObject.SetActive(true);
+
+            UIToolkitButton button = new UIToolkitButton { name = buttonName };
+            Vector2 center = GameViewCenter();
+            button.style.position = Position.Absolute;
+            button.style.left = center.x - ButtonWidth / 2f;
+            button.style.top = center.y - ButtonHeight / 2f;
+            button.style.width = ButtonWidth;
+            button.style.height = ButtonHeight;
+            button.style.marginLeft = 0f;
+            button.style.marginTop = 0f;
+            counter = new ClickCounter(button);
+            document.rootVisualElement.Add(button);
+            return document;
+        }
+
+        private static Vector2 GameViewCenter()
+        {
+            Vector2 size = Handles.GetMainGameViewSize();
+            return new Vector2(Mathf.Round(size.x / 2f), Mathf.Round(size.y / 2f));
+        }
+
+        private static JObject ClickParameters(Vector2 point)
+        {
+            return new JObject
+            {
+                ["action"] = MouseAction.Click.ToString(),
+                ["x"] = point.x,
+                ["y"] = point.y
+            };
+        }
+
+        private static JObject LongPressParameters(Vector2 point, float duration)
+        {
+            return new JObject
+            {
+                ["action"] = MouseAction.LongPress.ToString(),
+                ["x"] = point.x,
+                ["y"] = point.y,
+                ["duration"] = duration
+            };
+        }
+
+        private IEnumerator RunClick(Vector2 point)
+        {
+            yield return RunTool(ClickParameters(point));
+        }
+
+        private IEnumerator RunTool(JObject parameters)
+        {
+            yield return WaitForTask(StartTool(parameters));
+        }
+
+        private Task<UnityCliLoopToolResponse> StartTool(JObject parameters)
+        {
+            return _tool.ExecuteAsync(parameters, CancellationToken.None);
+        }
+
+        private IEnumerator WaitForTask(Task<UnityCliLoopToolResponse> task)
+        {
+            float timeoutAt = Time.realtimeSinceStartup + 5f;
+            yield return new WaitUntil(() => task.IsCompleted || Time.realtimeSinceStartup >= timeoutAt);
+            Assert.IsTrue(task.IsCompleted, "Tool execution timed out.");
+            Assert.AreEqual(TaskStatus.RanToCompletion, task.Status, $"Tool execution should complete: {task.Exception}");
+            _lastResponse = (SimulateMouseUiResponse)task.Result;
+        }
+
+        // The root's size is set by the runtime panel update in the player loop, so frames must pass.
+        private static IEnumerator WaitForLayout()
+        {
+            yield return null;
+            yield return null;
+        }
+
+        /// <summary>
+        /// Counts clicks and presses on a UI Toolkit button.
+        /// </summary>
+        private sealed class ClickCounter
+        {
+            internal ClickCounter(UIToolkitButton button)
+            {
+                button.clicked += () => Clicks++;
+                button.RegisterCallback<PointerDownEvent>(
+                    evt =>
+                    {
+                        PointerDowns++;
+                        LastPressedButton = evt.button;
+                    },
+                    TrickleDown.TrickleDown);
+            }
+
+            internal int Clicks { get; private set; }
+            internal int PointerDowns { get; private set; }
+            internal int LastPressedButton { get; private set; } = -1;
+        }
+    }
+}
diff --git a/Assets/Tests/PlayMode/SimulateMouseUiToolkitTests.cs.meta b/Assets/Tests/PlayMode/SimulateMouseUiToolkitTests.cs.meta
new file mode 100644
index 0000000000..c6d8b47635
--- /dev/null
+++ b/Assets/Tests/PlayMode/SimulateMouseUiToolkitTests.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: cbbacf9a9c5134f308de10793737999e
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Tests/PlayMode/UIToolkitScreenElementsPointerTests.cs b/Assets/Tests/PlayMode/UIToolkitScreenElementsPointerTests.cs
new file mode 100644
index 0000000000..f21a78079d
--- /dev/null
+++ b/Assets/Tests/PlayMode/UIToolkitScreenElementsPointerTests.cs
@@ -0,0 +1,397 @@
+using System.Collections;
+using System.Collections.Generic;
+using NUnit.Framework;
+using UnityEditor;
+using UnityEngine;
+using UnityEngine.TestTools;
+using UnityEngine.UIElements;
+
+using io.github.hatayama.UnityCliLoop.FirstPartyTools;
+using io.github.hatayama.UnityCliLoop.ToolContracts;
+
+namespace io.github.hatayama.UnityCliLoop.Tests.PlayMode
+{
+    /// <summary>
+    /// Verifies which UI Toolkit control a Game View point resolves to on live runtime panels, and that presses,
+    /// moves and releases sent through the result reach the panel like real mouse input. Points are top-left
+    /// Game View pixels; panels use a scale of 1, so they equal panel coordinates. Every object is destroyed in
+    /// TearDown.
+    /// </summary>
+    public sealed class UIToolkitScreenElementsPointerTests
+    {
+        private const string Prefix = "UIToolkitScreenElementsPointerTests_";
+        private const float Left = 100f;
+        private const float Top = 50f;
+        private const float Width = 200f;
+        private const float Height = 40f;
+        private const string RuntimeThemePath = "Assets/UI Toolkit/UnityThemes/UnityDefaultRuntimeTheme.tss";
+
+        private readonly List<Object> _createdObjects = new List<Object>();
+
+        [TearDown]
+        public void TearDown()
+        {
+            foreach (Object createdObject in _createdObjects)
+            {
+                if (createdObject != null)
+                {
+                    Object.Destroy(createdObject);
+                }
+            }
+
+            _createdObjects.Clear();
+        }
+
+        /// <summary>
+        /// Verifies that where two panels overlap, the control on the panel with the higher sorting order is
+        /// returned and the one behind it is not.
+        /// </summary>
+        [UnityTest]
+        public IEnumerator FindPointerTarget_WherePanelsOverlap_ReturnsFrontPanelControl()
+        {
+            UIDocument front = CreateDocument("Front", CreatePanelSettings(10f));
+            AddPlaced(front.rootVisualElement, new Button { name = "front" }, Left, Top, Width, Height);
+            UIDocument back = CreateDocument("Back", CreatePanelSettings(0f));
+            AddPlaced(back.rootVisualElement, new Button { name = "back" }, Left, Top, Width, Height);
+            yield return WaitForLayout();
+
+            UIToolkitPointerTarget target = UIToolkitScreenElements.FindPointerTarget(Center(Left, Top, Width, Height));
+
+            Assert.That(target, Is.Not.Null);
+            Assert.That(target.Name, Is.EqualTo("front"));
+            Assert.That(target.Path, Is.EqualTo(Prefix + "Front#front"));
+            Assert.That(target.SortingOrder, Is.EqualTo(10f));
+        }
+
+        /// <summary>
+        /// Verifies a point on a button reports the button's name and its annotation-style path.
+        /// </summary>
+        [UnityTest]
+        public IEnumerator FindPointerTarget_OnButton_ReportsNameAndPath()
+        {
+            UIDocument document = CreateDocument("Doc", CreatePanelSettings(0f));
+            AddPlaced(document.rootVisualElement, new Button { name = "play" }, Left, Top, Width, Height);
+            yield return WaitForLayout();
+
+            UIToolkitPointerTarget target = UIToolkitScreenElements.FindPointerTarget(Center(Left, Top, Width, Height));
+
+            Assert.That(target, Is.Not.Null);
+            Assert.That(target.Name, Is.EqualTo("play"));
+            Assert.That(target.Path, Is.EqualTo(Prefix + "Doc#play"));
+        }
+
+        /// <summary>
+        /// Verifies a point on a part inside a toggle still reports the toggle.
+        /// </summary>
+        [UnityTest]
+        public IEnumerator FindPointerTarget_OnPartInsideToggle_ReportsToggle()
+        {
+            UIDocument document = CreateDocument("Toggle", CreatePanelSettings(0f));
+            Toggle toggle = new Toggle { name = "sound" };
+            AddPlaced(document.rootVisualElement, toggle, Left, Top, Width, Height);
+            yield return WaitForLayout();
+            VisualElement checkmark = toggle.Q(className: Toggle.checkmarkUssClassName);
+            Vector2 point = checkmark.worldBound.center;
+            Assert.That(document.rootVisualElement.panel.Pick(point), Is.Not.SameAs(toggle), "the point must hit a part inside the toggle");
+
+            UIToolkitPointerTarget target = UIToolkitScreenElements.FindPointerTarget(point);
+
+            Assert.That(target, Is.Not.Null);
+            Assert.That(target.Name, Is.EqualTo("sound"));
+            Assert.That(target.Path, Is.EqualTo(Prefix + "Toggle#sound"));
+        }
+
+        /// <summary>
+        /// Verifies points on the dragger and both arrow buttons of a scroll view's scroller all report the
+        /// scroller with the same path screenshot annotations list for it, not the slider or buttons inside.
+        /// </summary>
+        [UnityTest]
+        public IEnumerator FindPointerTarget_OnScrollerParts_ReportsScrollerWithAnnotationPath()
+        {
+            UIDocument document = CreateDocument("Scroll", CreatePanelSettings(0f));
+            ScrollView scrollView = CreateScrollView(document.rootVisualElement);
+            yield return WaitForLayout();
+            Scroller scroller = scrollView.verticalScroller;
+            UIElementInfo annotated = FindAnnotated("Scroll", "Scrollbar");
+            VisualElement[] parts = { scroller.slider.Q("unity-dragger"), scroller.lowButton, scroller.highButton };
+
+            foreach (VisualElement part in parts)
+            {
+                Vector2 point = part.worldBound.center;
+                Assert.That(document.rootVisualElement.panel.Pick(point), Is.Not.SameAs(scroller), "the point must hit a part inside the scroller");
+
+                UIToolkitPointerTarget target = UIToolkitScreenElements.FindPointerTarget(point);
+
+                Assert.That(target, Is.Not.Null, part.name);
+                Assert.That(target.Path, Is.EqualTo(annotated.Path), part.name);
+                Assert.That(target.Name, Is.EqualTo(annotated.Name), part.name);
+            }
+        }
+
+        /// <summary>
+        /// Verifies a point on the input field of a slider that shows one reports the slider.
+        /// </summary>
+        [UnityTest]
+        public IEnumerator FindPointerTarget_OnSliderInputField_ReportsSlider()
+        {
+            UIDocument document = CreateDocument("Slider", CreatePanelSettings(0f));
+            Slider slider = new Slider(0f, 1f) { name = "volume", showInputField = true };
+            AddPlaced(document.rootVisualElement, slider, Left, Top, 300f, 30f);
+            yield return WaitForLayout();
+            TextField inputField = slider.Q<TextField>();
+            Vector2 point = inputField.worldBound.center;
+            VisualElement picked = document.rootVisualElement.panel.Pick(point);
+            Assert.That(picked == inputField || inputField.Contains(picked), Is.True, "the point must hit the input field");
+
+            UIToolkitPointerTarget target = UIToolkitScreenElements.FindPointerTarget(point);
+
+            Assert.That(target, Is.Not.Null);
+            Assert.That(target.Path, Is.EqualTo(Prefix + "Slider#volume"));
+        }
+
+        /// <summary>
+        /// Verifies a point with no element under it returns null.
+        /// </summary>
+        [UnityTest]
+        public IEnumerator FindPointerTarget_OnEmptyPoint_ReturnsNull()
+        {
+            UIDocument document = CreateDocument("Empty", CreatePanelSettings(0f));
+            AddPlaced(document.rootVisualElement, new Button { name = "play" }, Left, Top, Width, Height);
+            yield return WaitForLayout();
+
+            Assert.That(UIToolkitScreenElements.FindPointerTarget(new Vector2(Left + Width + 50f, Top + Height + 50f)), Is.Null);
+        }
+
+        /// <summary>
+        /// Verifies a front panel that renders into a texture still takes the point, as Unity still routes
+        /// screen input to it.
+        /// </summary>
+        [UnityTest]
+        public IEnumerator FindPointerTarget_FrontPanelWithTargetTexture_ReturnsItsControl()
+        {
+            UIDocument back = CreateDocument("TextureBack", CreatePanelSettings(0f));
+            AddPlaced(back.rootVisualElement, new Button { name = "target" }, Left, Top, Width, Height);
+            PanelSettings frontSettings = CreatePanelSettings(10f);
+            frontSettings.targetTexture = CreateScreenSizedTexture();
+            UIDocument front = CreateDocument("TextureFront", frontSettings);
+            AddPlaced(front.rootVisualElement, new Button { name = "cover" }, Left, Top, Width, Height);
+            yield return WaitForLayout();
+
+            UIToolkitPointerTarget target = UIToolkitScreenElements.FindPointerTarget(Center(Left, Top, Width, Height));
+
+            Assert.That(target, Is.Not.Null);
+            Assert.That(target.Name, Is.EqualTo("cover"));
+        }
+
+        /// <summary>
+        /// Verifies a left press and release click a button once and leave no element holding the pointer.
+        /// </summary>
+        [UnityTest]
+        public IEnumerator PressDownThenRelease_OnButton_ClicksOnceAndLeavesNoCapture()
+        {
+            UIDocument document = CreateDocument("Click", CreatePanelSettings(0f));
+            Button button = new Button { name = "play" };
+            int clicks = 0;
+            button.clicked += () => clicks++;
+            AddPlaced(document.rootVisualElement, button, Left, Top, Width, Height);
+            yield return WaitForLayout();
+            Vector2 point = Center(Left, Top, Width, Height);
+            UIToolkitPointerTarget target = UIToolkitScreenElements.FindPointerTarget(point);
+            Assert.That(target, Is.Not.Null);
+
+            target.PressDown(point, 0);
+            target.Release(point, 0);
+
+            Assert.That(clicks, Is.EqualTo(1));
+            Assert.That(document.rootVisualElement.panel.GetCapturingElement(PointerId.mousePointerId), Is.Null);
+        }
+
+        /// <summary>
+        /// Verifies that once the target's document is disabled the target reports itself unavailable, and
+        /// presses, moves and releases throw nothing and send nothing to the panel, which another document
+        /// still shows.
+        /// </summary>
+        [UnityTest]
+        public IEnumerator PointerCalls_AfterDocumentDisabled_SendNothing()
+        {
+            PanelSettings sharedSettings = CreatePanelSettings(0f);
+            UIDocument disabled = CreateDocument("Disabled", sharedSettings);
+            AddPlaced(disabled.rootVisualElement, new Button { name = "gone" }, Left, Top, Width, Height);
+            UIDocument remaining = CreateDocument("Remaining", sharedSettings);
+            Button witness = new Button { name = "witness" };
+            AddPlaced(remaining.rootVisualElement, witness, Left, Top + 100f, Width, Height);
+            int received = 0;
+            witness.RegisterCallback<PointerDownEvent>(_ => received++, TrickleDown.TrickleDown);
+            witness.RegisterCallback<PointerMoveEvent>(_ => received++, TrickleDown.TrickleDown);
+            witness.RegisterCallback<PointerUpEvent>(_ => received++, TrickleDown.TrickleDown);
+            yield return WaitForLayout();
+            UIToolkitPointerTarget target = UIToolkitScreenElements.FindPointerTarget(Center(Left, Top, Width, Height));
+            Assert.That(target, Is.Not.Null);
+            Vector2 witnessPoint = Center(Left, Top + 100f, Width, Height);
+
+            disabled.enabled = false;
+            yield return null;
+
+            Assert.That(target.IsAvailable, Is.False);
+            Assert.DoesNotThrow(() => target.PressDown(witnessPoint, 0));
+            Assert.DoesNotThrow(() => target.MoveTo(witnessPoint));
+            Assert.DoesNotThrow(() => target.Release(witnessPoint, 0));
+            Assert.That(received, Is.EqualTo(0));
+
+            // The callbacks do fire when a target that is still available sends to the same point.
+            UIToolkitPointerTarget witnessTarget = UIToolkitScreenElements.FindPointerTarget(witnessPoint);
+            witnessTarget.PressDown(witnessPoint, 0);
+            witnessTarget.Release(witnessPoint, 0);
+            Assert.That(received, Is.GreaterThan(0));
+        }
+
+        /// <summary>
+        /// Verifies a right press and release reach the button as button 1 and do not click it.
+        /// </summary>
+        [UnityTest]
+        public IEnumerator PressDownThenRelease_WithRightButton_DoesNotClick()
+        {
+            UIDocument document = CreateDocument("Right", CreatePanelSettings(0f));
+            Button button = new Button { name = "play" };
+            int clicks = 0;
+            int pressedButton = -1;
+            button.clicked += () => clicks++;
+            button.RegisterCallback<PointerDownEvent>(evt => pressedButton = evt.button, TrickleDown.TrickleDown);
+            AddPlaced(document.rootVisualElement, button, Left, Top, Width, Height);
+            yield return WaitForLayout();
+            Vector2 point = Center(Left, Top, Width, Height);
+            UIToolkitPointerTarget target = UIToolkitScreenElements.FindPointerTarget(point);
+            Assert.That(target, Is.Not.Null);
+
+            target.PressDown(point, 1);
+            target.Release(point, 1);
+
+            Assert.That(pressedButton, Is.EqualTo(1));
+            Assert.That(clicks, Is.EqualTo(0));
+        }
+
+        /// <summary>
+        /// Verifies an item of an open dropdown menu, which belongs to no document, resolves with a null path
+        /// and pressing it changes the dropdown's value.
+        /// </summary>
+        [UnityTest]
+        public IEnumerator PressOnOpenDropdownMenuItem_ChangesValueAndHasNoPath()
+        {
+            UIDocument document = CreateDocument("Dropdown", CreatePanelSettings(0f));
+            DropdownField dropdown = new DropdownField(new List<string> { "low", "high" }, 0) { name = "quality" };
+            AddPlaced(document.rootVisualElement, dropdown, Left, Top, Width, 30f);
+            yield return WaitForLayout();
+            Vector2 dropdownPoint = Center(Left, Top, Width, 30f);
+            UIToolkitPointerTarget opener = UIToolkitScreenElements.FindPointerTarget(dropdownPoint);
+            Assert.That(opener, Is.Not.Null);
+            Assert.That(opener.Path, Is.EqualTo(Prefix + "Dropdown#quality"));
+            opener.PressDown(dropdownPoint, 0);
+            opener.Release(dropdownPoint, 0);
+            yield return WaitForLayout();
+            List<VisualElement> items = document.rootVisualElement.panel.visualTree
+                .Query(className: GenericDropdownMenu.itemUssClassName).ToList();
+            Assert.That(items.Count, Is.EqualTo(2), "the dropdown menu must be open");
+            Vector2 itemPoint = items[1].worldBound.center;
+
+            UIToolkitPointerTarget item = UIToolkitScreenElements.FindPointerTarget(itemPoint);
+
+            Assert.That(item, Is.Not.Null);
+            Assert.That(item.Path, Is.Null);
+            item.PressDown(itemPoint, 0);
+            item.Release(itemPoint, 0);
+            Assert.That(dropdown.value, Is.EqualTo("high"));
+        }
+
+        private ScrollView CreateScrollView(VisualElement root)
+        {
+            ScrollView scrollView = new ScrollView { name = "list" };
+            scrollView.verticalScrollerVisibility = ScrollerVisibility.AlwaysVisible;
+            scrollView.horizontalScrollerVisibility = ScrollerVisibility.Hidden;
+            AddPlaced(root, scrollView, Left, Top, Width, 100f);
+            Scroller scroller = scrollView.verticalScroller;
+            SetSize(scroller, 20f, 100f);
+            SetSize(scroller.lowButton, 20f, 20f);
+            SetSize(scroller.highButton, 20f, 20f);
+            SetSize(scroller.slider, 20f, 60f);
+            // The scroll view disables a scroller whose content fits, so the viewport is sized and given
+            // content taller than itself that does not shrink to fit.
+            SetSize(scrollView.contentViewport, 180f, 100f);
+            VisualElement content = new VisualElement { name = "content" };
+            SetSize(content, 180f, 500f);
+            content.style.flexShrink = 0f;
+            scrollView.Add(content);
+            return scrollView;
+        }
+
+        private static UIElementInfo FindAnnotated(string documentName, string type)
+        {
+            List<UIElementInfo> elements = new List<UIElementInfo>();
+            UIToolkitElementCollector.Collect(elements, Handles.GetMainGameViewSize().y);
+            List<UIElementInfo> matches = elements.FindAll(
+                element => element.Type == type && element.Path.StartsWith(Prefix + documentName + "#"));
+            Assert.That(matches.Count, Is.EqualTo(1), "the annotation must list exactly one " + type);
+            return matches[0];
+        }
+
+        private PanelSettings CreatePanelSettings(float sortingOrder)
+        {
+            PanelSettings settings = ScriptableObject.CreateInstance<PanelSettings>();
+            settings.scaleMode = PanelScaleMode.ConstantPixelSize;
+            settings.scale = 1f;
+            settings.sortingOrder = sortingOrder;
+
+            // Without a theme, the parts inside controls get no size and the dropdown menu finds no root
+            // container to open in, so the points these tests aim at would not exist.
+            settings.themeStyleSheet = AssetDatabase.LoadAssetAtPath<ThemeStyleSheet>(RuntimeThemePath);
+            Assert.That(settings.themeStyleSheet, Is.Not.Null, "the runtime theme must exist at " + RuntimeThemePath);
+            _createdObjects.Add(settings);
+            return settings;
+        }
+
+        private RenderTexture CreateScreenSizedTexture()
+        {
+            RenderTexture texture = new RenderTexture(Screen.width, Screen.height, 0);
+            _createdObjects.Add(texture);
+            return texture;
+        }
+
+        // The object starts inactive so the document sees its panel settings when it first enables.
+        private UIDocument CreateDocument(string name, PanelSettings settings)
+        {
+            GameObject documentObject = new GameObject(Prefix + name);
+            documentObject.SetActive(false);
+            _createdObjects.Add(documentObject);
+            UIDocument document = documentObject.AddComponent<UIDocument>();
+            document.panelSettings = settings;
+            documentObject.SetActive(true);
+            return document;
+        }
+
+        private static void AddPlaced(VisualElement parent, VisualElement element, float left, float top, float width, float height)
+        {
+            element.style.position = Position.Absolute;
+            element.style.left = left;
+            element.style.top = top;
+            SetSize(element, width, height);
+            parent.Add(element);
+        }
+
+        private static void SetSize(VisualElement element, float width, float height)
+        {
+            element.style.width = width;
+            element.style.height = height;
+        }
+
+        private static Vector2 Center(float left, float top, float width, float height)
+        {
+            return new Vector2(left + width / 2f, top + height / 2f);
+        }
+
+        // The root's size is set by the runtime panel update in the player loop, so frames must pass.
+        private static IEnumerator WaitForLayout()
+        {
+            yield return null;
+            yield return null;
+        }
+    }
+}
diff --git a/Assets/Tests/PlayMode/UIToolkitScreenElementsPointerTests.cs.meta b/Assets/Tests/PlayMode/UIToolkitScreenElementsPointerTests.cs.meta
new file mode 100644
index 0000000000..12888fdd02
--- /dev/null
+++ b/Assets/Tests/PlayMode/UIToolkitScreenElementsPointerTests.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: f91b3eaa63d5945eea43a7aebdd41262
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Packages/src/Documentation~/tools.md b/Packages/src/Documentation~/tools.md
index efef7ade94..172653a7aa 100644
--- a/Packages/src/Documentation~/tools.md
+++ b/Packages/src/Documentation~/tools.md
@@ -158,7 +158,7 @@ When enabled, dynamic code execution runs with full Unity Editor process permiss
 ### 14. simulate-mouse-ui - Simulate Mouse Input on PlayMode UI
 Simulate mouse click, long-press, and drag on PlayMode UI elements. Uses EventSystem and ExecuteEvents to dispatch pointer events directly — works independently of both old and new Input System. For game logic that reads Input System (e.g. `Mouse.current.leftButton.wasPressedThisFrame`), use `simulate-mouse-input` instead.
 
-Supports 6 actions: Click, LongPress, Drag (one-shot), DragStart/DragMove/DragEnd (split drag).
+Supports 6 actions: Click, LongPress, Drag (one-shot), DragStart/DragMove/DragEnd (split drag). Click and LongPress also reach UI Toolkit controls at their annotated coordinates, without an EventSystem.
 
 ```text
 → screenshot (CaptureMode: rendering, AnnotateElements: true)
@@ -221,4 +221,4 @@ sh scripts/run-posix-e2e.sh --project-path /path/to/unity-project
 powershell -NoProfile -ExecutionPolicy Bypass -File .\scripts\run-windows-e2e.ps1
 ```
 
-`run-posix-e2e.sh` uses the built native CLI binary by default, passes an explicit `--project-path` to every `uloop` invocation, and runs CLI recovery/readiness, simulate-mouse UI coverage, and UI Toolkit screenshot annotation coverage in one sequence (skip the last with `--skip-uitoolkit-annotation`). To verify `replay-input` against a JSON created in the Recordings window, run `verify-replay-via-cli.sh` separately.
+`run-posix-e2e.sh` uses the built native CLI binary by default, passes an explicit `--project-path` to every `uloop` invocation, and runs CLI recovery/readiness, simulate-mouse UI coverage, and UI Toolkit screenshot annotation and click coverage in one sequence (skip the last with `--skip-uitoolkit-annotation`). To verify `replay-input` against a JSON created in the Recordings window, run `verify-replay-via-cli.sh` separately.
diff --git a/Packages/src/Documentation~/tools_ja.md b/Packages/src/Documentation~/tools_ja.md
index a336447c51..411720f305 100644
--- a/Packages/src/Documentation~/tools_ja.md
+++ b/Packages/src/Documentation~/tools_ja.md
@@ -158,7 +158,7 @@ Unity Editor内で動的にC#コードを実行します。
 ### 14. simulate-mouse-ui - PlayMode UI要素のマウス操作シミュレーション
 PlayMode中のUI要素に対してマウスクリック・長押し・ドラッグをシミュレーションします。EventSystemとExecuteEventsを使ってポインタイベントを直接ディスパッチするため、旧Input System・新Input Systemの両方に依存せず動作します。ゲームロジックがInput Systemを直接読み取る場合（例：`Mouse.current.leftButton.wasPressedThisFrame`）は、`simulate-mouse-input` を使用してください。
 
-6つのアクションに対応: Click、LongPress、Drag（ワンショット）、DragStart/DragMove/DragEnd（分割ドラッグ）
+6つのアクションに対応: Click、LongPress、Drag（ワンショット）、DragStart/DragMove/DragEnd（分割ドラッグ）。Click と LongPress は、注釈の座標で UI Toolkit のコントロールにも届きます（EventSystem は不要）。
 
 ```text
 → screenshot (CaptureMode: rendering, AnnotateElements: true)
@@ -221,4 +221,4 @@ sh scripts/run-posix-e2e.sh --project-path /path/to/unity-project
 powershell -NoProfile -ExecutionPolicy Bypass -File .\scripts\run-windows-e2e.ps1
 ```
 
-`run-posix-e2e.sh` は、デフォルトでチェックイン済みのネイティブCLIバイナリを使い、すべての `uloop` 呼び出しに明示的な `--project-path` を渡します。CLI recovery/readiness、simulate-mouse UI、UI Toolkit のスクリーンショット注釈を1つの流れで検証します（最後のものは `--skip-uitoolkit-annotation` で省けます）。Recordingsウィンドウで作成したJSONの replay-input 検証は `verify-replay-via-cli.sh` を個別に実行します。
+`run-posix-e2e.sh` は、デフォルトでチェックイン済みのネイティブCLIバイナリを使い、すべての `uloop` 呼び出しに明示的な `--project-path` を渡します。CLI recovery/readiness、simulate-mouse UI、UI Toolkit のスクリーンショット注釈とクリックを1つの流れで検証します（最後のものは `--skip-uitoolkit-annotation` で省けます）。Recordingsウィンドウで作成したJSONの replay-input 検証は `verify-replay-via-cli.sh` を個別に実行します。
diff --git a/Packages/src/Editor/FirstPartyTools/Common/MouseUi/UiRaycastHelper.cs b/Packages/src/Editor/FirstPartyTools/Common/MouseUi/UiRaycastHelper.cs
index 356af9dc14..b6774147d3 100644
--- a/Packages/src/Editor/FirstPartyTools/Common/MouseUi/UiRaycastHelper.cs
+++ b/Packages/src/Editor/FirstPartyTools/Common/MouseUi/UiRaycastHelper.cs
@@ -12,12 +12,58 @@ namespace io.github.hatayama.UnityCliLoop.FirstPartyTools
     /// </summary>
     internal static class UiRaycastHelper
     {
+        // Results from uGUI's bridge to UI Toolkit panels are recognised by type name because the type is
+        // compiled only when the UI Toolkit package is present. They are skipped where a caller resolves UI
+        // Toolkit itself: the bridge flips Y with Screen.height, which outside the player loop is the size of
+        // the last Editor view drawn, so its hits land at the wrong place on the panel.
+        internal const string PanelRaycasterTypeFullName = "UnityEngine.UIElements.PanelRaycaster";
+
         public static RaycastResult? RaycastUI(Vector2 screenPosition, EventSystem eventSystem)
         {
             RaycastContext context = new(eventSystem);
             return context.Raycast(screenPosition);
         }
 
+        internal static RaycastResult? RaycastUISkippingUIToolkitPanels(Vector2 screenPosition, EventSystem eventSystem)
+        {
+            RaycastContext context = new(eventSystem);
+            return context.RaycastSkippingUIToolkitPanels(screenPosition);
+        }
+
+        // Picks the EventSystem's first hit, unless the Canvas-space hit should win over it; with no
+        // EventSystem hit, the Canvas-space hit.
+        internal static RaycastResult? ChooseHit(List<RaycastResult> eventSystemResults, RaycastResult? canvasSpaceHit)
+        {
+            if (eventSystemResults.Count > 0)
+            {
+                RaycastResult firstHit = eventSystemResults[0];
+
+                if (canvasSpaceHit != null && ShouldPreferCanvasSpaceHit(canvasSpaceHit.Value, firstHit))
+                {
+                    return canvasSpaceHit;
+                }
+
+                return firstHit;
+            }
+
+            // EventSystem clips at Screen.width/height, which can be smaller than the
+            // Canvas layout space (Game view target resolution). Fall back to manual hit testing.
+            return canvasSpaceHit;
+        }
+
+        internal static RaycastResult? ChooseHitSkippingUIToolkitPanels(
+            List<RaycastResult> eventSystemResults,
+            RaycastResult? canvasSpaceHit)
+        {
+            List<RaycastResult> withoutPanels = eventSystemResults.FindAll(result => !IsPanelRaycasterHit(result));
+            return ChooseHit(withoutPanels, canvasSpaceHit);
+        }
+
+        private static bool IsPanelRaycasterHit(RaycastResult result)
+        {
+            return result.module != null && result.module.GetType().FullName == PanelRaycasterTypeFullName;
+        }
+
         private static List<CanvasRaycastSource> CollectCanvasRaycastSources()
         {
 #if UNITY_6000_4_OR_NEWER
@@ -106,27 +152,24 @@ internal RaycastContext(EventSystem eventSystem)
             }
 
             public RaycastResult? Raycast(Vector2 screenPosition)
+            {
+                RaycastResult? canvasSpaceHit = RaycastBothWays(screenPosition);
+                return ChooseHit(_eventSystemResults, canvasSpaceHit);
+            }
+
+            internal RaycastResult? RaycastSkippingUIToolkitPanels(Vector2 screenPosition)
+            {
+                RaycastResult? canvasSpaceHit = RaycastBothWays(screenPosition);
+                return ChooseHitSkippingUIToolkitPanels(_eventSystemResults, canvasSpaceHit);
+            }
+
+            // Fills the EventSystem results and returns the Canvas-space hit for the same point.
+            private RaycastResult? RaycastBothWays(Vector2 screenPosition)
             {
                 _eventSystemResults.Clear();
                 _pointerData.position = screenPosition;
                 _eventSystem.RaycastAll(_pointerData, _eventSystemResults);
-                RaycastResult? canvasSpaceHit = RaycastCanvasSpaceFromSources(screenPosition, _canvasRaycastSources);
-
-                if (_eventSystemResults.Count > 0)
-                {
-                    RaycastResult firstHit = _eventSystemResults[0];
-
-                    if (canvasSpaceHit != null && ShouldPreferCanvasSpaceHit(canvasSpaceHit.Value, firstHit))
-                    {
-                        return canvasSpaceHit;
-                    }
-
-                    return firstHit;
-                }
-
-                // EventSystem clips at Screen.width/height, which can be smaller than the
-                // Canvas layout space (Game view target resolution). Fall back to manual hit testing.
-                return canvasSpaceHit;
+                return RaycastCanvasSpaceFromSources(screenPosition, _canvasRaycastSources);
             }
         }
 
diff --git a/Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UIToolkitPointerEvents.cs b/Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UIToolkitPointerEvents.cs
new file mode 100644
index 0000000000..47e9bee2bd
--- /dev/null
+++ b/Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UIToolkitPointerEvents.cs
@@ -0,0 +1,55 @@
+#nullable enable
+using System;
+using UnityEngine;
+using UnityEngine.UIElements;
+
+namespace io.github.hatayama.UnityCliLoop.FirstPartyTools
+{
+    /// <summary>
+    /// Sends mouse pointer events to a runtime panel the way Unity turns real mouse input into them.
+    /// </summary>
+    internal static class UIToolkitPointerEvents
+    {
+        // No target is set, so the panel hands the event to the element holding the pointer or, failing that,
+        // the element under it, as it does for real input. GetPooled also records the press or release in the
+        // pointer device state, which fills pressedButtons for later events.
+        internal static void Send(IPanel panel, EventType type, Vector2 panelPoint, Vector2 delta, int button)
+        {
+            Event systemEvent = new Event
+            {
+                type = type,
+                mousePosition = panelPoint,
+                delta = delta,
+                button = button,
+                clickCount = type == EventType.MouseDown || type == EventType.MouseUp ? 1 : 0
+            };
+
+            switch (type)
+            {
+                case EventType.MouseDown:
+                    using (PointerDownEvent pointerDown = PointerDownEvent.GetPooled(systemEvent))
+                    {
+                        panel.visualTree.SendEvent(pointerDown);
+                    }
+
+                    return;
+                case EventType.MouseMove:
+                    using (PointerMoveEvent pointerMove = PointerMoveEvent.GetPooled(systemEvent))
+                    {
+                        panel.visualTree.SendEvent(pointerMove);
+                    }
+
+                    return;
+                case EventType.MouseUp:
+                    using (PointerUpEvent pointerUp = PointerUpEvent.GetPooled(systemEvent))
+                    {
+                        panel.visualTree.SendEvent(pointerUp);
+                    }
+
+                    return;
+                default:
+                    throw new ArgumentOutOfRangeException(nameof(type), type, "Only mouse down, move and up are sent.");
+            }
+        }
+    }
+}
diff --git a/Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UIToolkitPointerEvents.cs.meta b/Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UIToolkitPointerEvents.cs.meta
new file mode 100644
index 0000000000..a36928167a
--- /dev/null
+++ b/Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UIToolkitPointerEvents.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 2dfc472d65b414f7ca31681699b8e0f1
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UIToolkitPointerTarget.cs b/Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UIToolkitPointerTarget.cs
new file mode 100644
index 0000000000..0a4fb7fda4
--- /dev/null
+++ b/Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UIToolkitPointerTarget.cs
@@ -0,0 +1,108 @@
+#nullable enable
+using System;
+using UnityEngine;
+using UnityEngine.UIElements;
+
+namespace io.github.hatayama.UnityCliLoop.FirstPartyTools
+{
+    /// <summary>
+    /// The UI Toolkit control under a Game View point, and the panel that takes pointer input there. Presses,
+    /// moves and releases are sent to that panel the way real input reaches it, so they land on whichever
+    /// element is under the pointer or holds the pointer at that moment.
+    /// </summary>
+    public sealed class UIToolkitPointerTarget
+    {
+        private const int MaxMouseButton = 2;
+
+        private readonly IPanel _panel;
+        private readonly UIDocument _document;
+        private Vector2 _lastPanelPoint;
+
+        internal UIToolkitPointerTarget(IPanel panel, UIDocument document, string name, string? path, float sortingOrder)
+        {
+            if (string.IsNullOrEmpty(name))
+            {
+                // Callers treat a null name as "nothing was hit", so a hit must always carry one.
+                throw new ArgumentException("A UI Toolkit pointer target needs a display name.", nameof(name));
+            }
+
+            _panel = panel ?? throw new ArgumentNullException(nameof(panel));
+            _document = document != null ? document : throw new ArgumentNullException(nameof(document));
+            Name = name;
+            Path = path;
+            SortingOrder = sortingOrder;
+        }
+
+        /// <summary>The control's name, or its type name when it has none. Never null or empty.</summary>
+        public string Name { get; }
+
+        /// <summary>
+        /// The same path screenshot annotations report for the control, or null when the element belongs to no
+        /// document, as with the menu of an open dropdown.
+        /// </summary>
+        public string? Path { get; }
+
+        /// <summary>The sorting order of the panel the control is on, as set in its panel settings.</summary>
+        public float SortingOrder { get; }
+
+        /// <summary>False once the document that owns the panel has been disabled or destroyed.</summary>
+        public bool IsAvailable =>
+            _document != null && _document.isActiveAndEnabled && _document.rootVisualElement?.panel == _panel;
+
+        /// <summary>Presses a mouse button (0 left, 1 right, 2 middle) at a Game View point.</summary>
+        /// <remarks>Does nothing once the target is no longer available.</remarks>
+        public void PressDown(Vector2 gameViewTopLeft, int button)
+        {
+            ValidateButton(button);
+            if (!IsAvailable)
+            {
+                // The document can go away between resolving the target and pressing, a frame or more later;
+                // uGUI likewise sends nothing to a destroyed or inactive target.
+                return;
+            }
+
+            Vector2 panelPoint = RuntimePanelUtils.ScreenToPanel(_panel, gameViewTopLeft);
+            UIToolkitPointerEvents.Send(_panel, EventType.MouseDown, panelPoint, Vector2.zero, button);
+            _lastPanelPoint = panelPoint;
+        }
+
+        /// <summary>Moves the pointer to a Game View point, carrying any buttons still held.</summary>
+        /// <remarks>Does nothing once the target is no longer available.</remarks>
+        public void MoveTo(Vector2 gameViewTopLeft)
+        {
+            if (!IsAvailable)
+            {
+                return;
+            }
+
+            Vector2 panelPoint = RuntimePanelUtils.ScreenToPanel(_panel, gameViewTopLeft);
+
+            // The button is overwritten with "none" for moves; held buttons travel in pressedButtons.
+            UIToolkitPointerEvents.Send(_panel, EventType.MouseMove, panelPoint, panelPoint - _lastPanelPoint, 0);
+            _lastPanelPoint = panelPoint;
+        }
+
+        /// <summary>Releases a mouse button (0 left, 1 right, 2 middle) at a Game View point.</summary>
+        /// <remarks>Does nothing once the target is no longer available, so cleanup code can always call it.</remarks>
+        public void Release(Vector2 gameViewTopLeft, int button)
+        {
+            ValidateButton(button);
+            if (!IsAvailable)
+            {
+                return;
+            }
+
+            Vector2 panelPoint = RuntimePanelUtils.ScreenToPanel(_panel, gameViewTopLeft);
+            UIToolkitPointerEvents.Send(_panel, EventType.MouseUp, panelPoint, panelPoint - _lastPanelPoint, button);
+            _lastPanelPoint = panelPoint;
+        }
+
+        private static void ValidateButton(int button)
+        {
+            if (button < 0 || button > MaxMouseButton)
+            {
+                throw new ArgumentOutOfRangeException(nameof(button), button, "Mouse button must be 0, 1 or 2.");
+            }
+        }
+    }
+}
diff --git a/Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UIToolkitPointerTarget.cs.meta b/Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UIToolkitPointerTarget.cs.meta
new file mode 100644
index 0000000000..12ad95392c
--- /dev/null
+++ b/Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UIToolkitPointerTarget.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 71c2930e001654e8e8c062c127c171e3
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UIToolkitPointerTargetFinder.cs b/Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UIToolkitPointerTargetFinder.cs
new file mode 100644
index 0000000000..07a3c911cf
--- /dev/null
+++ b/Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UIToolkitPointerTargetFinder.cs
@@ -0,0 +1,82 @@
+#nullable enable
+using System.Collections.Generic;
+using System.Linq;
+using UnityEngine;
+using UnityEngine.UIElements;
+
+namespace io.github.hatayama.UnityCliLoop.FirstPartyTools
+{
+    /// <summary>
+    /// Decides which panel takes pointer input at a Game View point and which control to report for it.
+    /// </summary>
+    internal static class UIToolkitPointerTargetFinder
+    {
+        // Expects the panels' layouts to be settled already, because picking reads them. The first panel, front
+        // to back, that picks anything takes the input, as Unity routes it. Panels with the same sorting order
+        // keep the order they were gathered in, the same known limit as the annotation's cover check.
+        internal static UIToolkitPointerTarget? Find(List<UIToolkitScreenPanels.PanelEntry> panels, Vector2 gameViewTopLeft)
+        {
+            foreach (UIToolkitScreenPanels.PanelEntry entry in panels.OrderByDescending(panel => panel.SortingOrder))
+            {
+                VisualElement? picked = UIToolkitScreenPanels.PickInPanel(entry.Panel, gameViewTopLeft);
+                if (picked == null)
+                {
+                    continue;
+                }
+
+                return CreateTarget(entry, picked);
+            }
+
+            return null;
+        }
+
+        private static UIToolkitPointerTarget CreateTarget(UIToolkitScreenPanels.PanelEntry entry, VisualElement picked)
+        {
+            UIDocument? document = FindOwningDocument(entry, picked);
+            if (document == null)
+            {
+                // Elements outside every document, such as the menu of an open dropdown, have no annotation path.
+                // The panel's first document stands in to tell when the panel goes away.
+                return new UIToolkitPointerTarget(
+                    entry.Panel, entry.Documents[0], UIToolkitElementPath.GetDisplayName(picked), null, entry.SortingOrder);
+            }
+
+            VisualElement reported = FindOutermostControl(document.rootVisualElement, picked) ?? picked;
+            return new UIToolkitPointerTarget(
+                entry.Panel,
+                document,
+                UIToolkitElementPath.GetDisplayName(reported),
+                UIToolkitElementPath.Build(document, reported),
+                entry.SortingOrder);
+        }
+
+        private static UIDocument? FindOwningDocument(UIToolkitScreenPanels.PanelEntry entry, VisualElement picked)
+        {
+            for (VisualElement? current = picked; current != null; current = current.hierarchy.parent)
+            {
+                UIDocument? document = entry.Documents.Find(candidate => candidate.rootVisualElement == current);
+                if (document != null)
+                {
+                    return document;
+                }
+            }
+
+            return null;
+        }
+
+        // The outermost, not the nearest, control: annotations stop at the first control on the way down from
+        // the root and never list the parts inside it. A Scroller holds a Slider and two RepeatButtons, and a
+        // Slider with an input field holds a TextField; reporting those parts would not match the annotation.
+        private static VisualElement? FindOutermostControl(VisualElement root, VisualElement picked)
+        {
+            List<VisualElement> chain = new List<VisualElement>();
+            for (VisualElement? current = picked; current != null && current != root; current = current.hierarchy.parent)
+            {
+                chain.Add(current);
+            }
+
+            chain.Reverse();
+            return chain.Find(element => UIToolkitElementClassifier.Classify(element) != null);
+        }
+    }
+}
diff --git a/Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UIToolkitPointerTargetFinder.cs.meta b/Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UIToolkitPointerTargetFinder.cs.meta
new file mode 100644
index 0000000000..60e91f6c63
--- /dev/null
+++ b/Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UIToolkitPointerTargetFinder.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 644b0b96772bd4ed0bfd525bc25d378f
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UIToolkitScreenControl.cs b/Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UIToolkitScreenControl.cs
index c8d69dfe20..88c49d81da 100644
--- a/Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UIToolkitScreenControl.cs
+++ b/Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UIToolkitScreenControl.cs
@@ -8,7 +8,7 @@ namespace io.github.hatayama.UnityCliLoop.FirstPartyTools
     /// </summary>
     public sealed class UIToolkitScreenControl
     {
-        public UIToolkitScreenControl(
+        internal UIToolkitScreenControl(
             string name,
             string path,
             string type,
diff --git a/Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UIToolkitScreenElements.cs b/Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UIToolkitScreenElements.cs
index f3351c5714..25f57968a3 100644
--- a/Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UIToolkitScreenElements.cs
+++ b/Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UIToolkitScreenElements.cs
@@ -32,5 +32,17 @@ public static IReadOnlyList<UIToolkitScreenControl> CollectControls(
             UIToolkitScreenPanels.SettleLayouts(panels);
             return UIToolkitControlCollector.Collect(panels, probePointsForTopLeftBounds);
         }
+
+        /// <summary>
+        /// Returns the control that pointer input at a Game View point reaches, or null when no panel takes
+        /// input there. Panels are tried front to back, as Unity routes input. The control reported is the
+        /// outermost control around the element under the point, the one screenshot annotations list.
+        /// </summary>
+        public static UIToolkitPointerTarget? FindPointerTarget(Vector2 gameViewTopLeft)
+        {
+            List<UIToolkitScreenPanels.PanelEntry> panels = UIToolkitScreenPanels.Gather();
+            UIToolkitScreenPanels.SettleLayouts(panels);
+            return UIToolkitPointerTargetFinder.Find(panels, gameViewTopLeft);
+        }
     }
 }
diff --git a/Packages/src/Editor/FirstPartyTools/Screenshot/Skill/references/annotated-elements.md b/Packages/src/Editor/FirstPartyTools/Screenshot/Skill/references/annotated-elements.md
index 5e1338e01d..69466c0964 100644
--- a/Packages/src/Editor/FirstPartyTools/Screenshot/Skill/references/annotated-elements.md
+++ b/Packages/src/Editor/FirstPartyTools/Screenshot/Skill/references/annotated-elements.md
@@ -10,7 +10,7 @@ Device Simulator is supported for this flow: prefer `--capture-mode rendering` (
 
 - `Label`: Index label in JSON (`A` = first in that sort, `B` = next, ...). Treat it as a stable handle, not as proof of what is actually in front: when overlapping elements cross parents, pick the target by `Path` and confirm the result with `simulate-mouse-ui`'s `HitGameObjectName` — the handler that received the events, resolved up the hierarchy from the raycast hit (or from `--target-path` in bypass mode), so it can name an ancestor of the element you clicked. Screenshot labels also include the interaction hint, such as `A / CLICK` or `B / DRAG`.
 - `Name`: Element name
-- `Path`: Hierarchy path from the scene root, for example `Canvas/Panel/Button`. Use this as `simulate-mouse-ui --target-path` when bypassing raycast blockers. UI Toolkit entries use a different form that `--target-path` does not accept; see [UI Toolkit Elements](#ui-toolkit-elements).
+- `Path`: Hierarchy path from the scene root, for example `Canvas/Panel/Button`. Use this as `simulate-mouse-ui --target-path` when bypassing raycast blockers. UI Toolkit entries use a different form that `--target-path` does not accept; click them at `SimX`/`SimY` instead. See [UI Toolkit Elements](#ui-toolkit-elements).
 - `Type`: Element type (`Button`, `Toggle`, `Slider`, `Dropdown`, `InputField`, `Scrollbar`, `Draggable`, `DropTarget`, `Selectable`, `PhysicsCollider`)
 - `Interaction`: Derived interaction category (`Click`, `Drag`, `Drop`, `Text`) or `Raycast` for clustered physics collider entries. Use this to choose between `simulate-mouse-ui --action Click`, drag actions, or `simulate-mouse-input` (including `--dry-run`).
 - `UiSystem`: UI system the entry came from: `UGUI`, `UIToolkit`, or empty for `PhysicsCollider` entries.
@@ -53,9 +53,9 @@ Limits:
 
 Clicking:
 
-- `simulate-mouse-input --action Click --x <SimX> --y <SimY>` reaches UI Toolkit controls when the scene has an EventSystem with an Input System UI input module.
-- Without an EventSystem the click does not reach UI Toolkit controls.
-- `simulate-mouse-ui` does not reach UI Toolkit controls, and its `--target-path` does not accept UI Toolkit `Path` values.
+- `simulate-mouse-ui --action Click --x <SimX> --y <SimY>` (or `LongPress`) reaches UI Toolkit controls, with or without an EventSystem. Its `--target-path` does not accept UI Toolkit `Path` values.
+- `simulate-mouse-input --action Click --x <SimX> --y <SimY>` also reaches them when the scene has an EventSystem with an Input System UI input module.
+- Without an EventSystem the `simulate-mouse-input` click does not reach UI Toolkit controls.
 
 ### PhysicsCollider Entries Per Closed Region
 
diff --git a/Packages/src/Editor/FirstPartyTools/SimulateMouseInput/Skill/SKILL.md b/Packages/src/Editor/FirstPartyTools/SimulateMouseInput/Skill/SKILL.md
index d7c92b3d44..41723aa257 100644
--- a/Packages/src/Editor/FirstPartyTools/SimulateMouseInput/Skill/SKILL.md
+++ b/Packages/src/Editor/FirstPartyTools/SimulateMouseInput/Skill/SKILL.md
@@ -67,7 +67,7 @@ All rows below assume the New Input System is installed.
 
 | Scenario | Tool |
 |----------|------|
-| Click a Unity UI Button (IPointerClickHandler) | `simulate-mouse-ui` |
+| Click a uGUI or UI Toolkit button | `simulate-mouse-ui` |
 | Runtime logic reads `Mouse.current.leftButton` | `simulate-mouse-input` |
 | Runtime logic reads right-click | `simulate-mouse-input --button Right` |
 | Drag a UI slider | `simulate-mouse-ui --action Drag` |
@@ -110,7 +110,7 @@ uloop simulate-mouse-input --action SmoothDelta --delta-x 300 --delta-y 0 --dura
 ## Coordinate System
 
 `--x`/`--y` use top-left Game View coordinates: pass `AnnotatedElements[].SimX/SimY`
-directly (UI Toolkit entries need an EventSystem in the scene), convert raw screenshot pixels with `ScreenshotToInputFormula`, and never flip Y
+directly (UI Toolkit entries need an EventSystem with an Input System UI module here; `simulate-mouse-ui` reaches them without one), convert raw screenshot pixels with `ScreenshotToInputFormula`, and never flip Y
 in the caller (the tool converts internally). Conversion formula, Device Simulator
 notes, and how the injected position reads back inside Unity are in
 `references/output-and-coordinates.md`.
diff --git a/Packages/src/Editor/FirstPartyTools/SimulateMouseInput/Skill/references/output-and-coordinates.md b/Packages/src/Editor/FirstPartyTools/SimulateMouseInput/Skill/references/output-and-coordinates.md
index a5998020b4..979f721cb7 100644
--- a/Packages/src/Editor/FirstPartyTools/SimulateMouseInput/Skill/references/output-and-coordinates.md
+++ b/Packages/src/Editor/FirstPartyTools/SimulateMouseInput/Skill/references/output-and-coordinates.md
@@ -30,7 +30,7 @@ Verify visual outcome with a follow-up screenshot.
 
 - `--x` / `--y` use **top-left Game View coordinates**.
 - Raw image pixels from `uloop screenshot --capture-mode rendering` must be converted with `ScreenshotToInputFormula`.
-- `AnnotatedElements[].SimX/SimY` can be passed directly to this tool. For UI Toolkit entries (`UiSystem` `UIToolkit`), a `Click` reaches the control only when the scene has an EventSystem with an Input System UI input module; without one, nothing receives the click.
+- `AnnotatedElements[].SimX/SimY` can be passed directly to this tool. For UI Toolkit entries (`UiSystem` `UIToolkit`), a `Click` reaches the control only when the scene has an EventSystem with an Input System UI input module; without one, nothing receives the click. `simulate-mouse-ui` reaches them without an EventSystem.
 - Do not flip Y in the caller. The tool converts internally for Unity Input System:
 
 ```text
diff --git a/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/IMouseUiPressTarget.cs b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/IMouseUiPressTarget.cs
new file mode 100644
index 0000000000..2713295623
--- /dev/null
+++ b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/IMouseUiPressTarget.cs
@@ -0,0 +1,20 @@
+#nullable enable
+
+namespace io.github.hatayama.UnityCliLoop.FirstPartyTools
+{
+    /// <summary>
+    /// The thing a click or long press is delivered to, whichever UI system it belongs to.
+    /// </summary>
+    internal interface IMouseUiPressTarget
+    {
+        // Captured when the target is created, so it stays valid after the target goes away.
+        MouseUiHitReport Report { get; }
+
+        void Click();
+
+        void PressDown();
+
+        // Safe to call from cleanup even if nothing was pressed or the target has gone away.
+        void Release();
+    }
+}
diff --git a/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/IMouseUiPressTarget.cs.meta b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/IMouseUiPressTarget.cs.meta
new file mode 100644
index 0000000000..2aded9e5bf
--- /dev/null
+++ b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/IMouseUiPressTarget.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 88d3c4e6b86bb4441b21a9c7f9f2a2f7
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/MouseUiHitPriority.cs b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/MouseUiHitPriority.cs
new file mode 100644
index 0000000000..acdcb32cf0
--- /dev/null
+++ b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/MouseUiHitPriority.cs
@@ -0,0 +1,21 @@
+#nullable enable
+using UnityEngine;
+
+namespace io.github.hatayama.UnityCliLoop.FirstPartyTools
+{
+    /// <summary>
+    /// Decides whether a uGUI hit or a UI Toolkit hit at the same point takes the input, the way the
+    /// EventSystem orders them for real input.
+    /// </summary>
+    internal static class MouseUiHitPriority
+    {
+        // The EventSystem compares hits from different raycasters by camera depth only when both have a camera,
+        // and the UI Toolkit raycaster has none; then by sortOrderPriority, where a panel reports its sorting
+        // order rounded down; then by renderOrderPriority, where a panel reports nearly int.MaxValue. So uGUI is
+        // in front only when its sortOrderPriority is strictly greater.
+        internal static bool IsUguiInFront(int uguiSortOrderPriority, float panelSortingOrder)
+        {
+            return uguiSortOrderPriority > Mathf.FloorToInt(panelSortingOrder);
+        }
+    }
+}
diff --git a/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/MouseUiHitPriority.cs.meta b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/MouseUiHitPriority.cs.meta
new file mode 100644
index 0000000000..3f23b44815
--- /dev/null
+++ b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/MouseUiHitPriority.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 9f8021d3f2b704b10a0a03913c7c54bf
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/MouseUiHitReport.cs b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/MouseUiHitReport.cs
new file mode 100644
index 0000000000..86084e7cb2
--- /dev/null
+++ b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/MouseUiHitReport.cs
@@ -0,0 +1,26 @@
+#nullable enable
+
+namespace io.github.hatayama.UnityCliLoop.FirstPartyTools
+{
+    /// <summary>
+    /// What a simulated press hit, captured as plain strings so responses never read UnityEngine objects or
+    /// UI Toolkit elements after an await.
+    /// </summary>
+    internal sealed class MouseUiHitReport
+    {
+        internal MouseUiHitReport(string? name, string? path, string? uiSystem)
+        {
+            Name = name;
+            Path = path;
+            UiSystem = uiSystem;
+        }
+
+        internal static MouseUiHitReport None { get; } = new MouseUiHitReport(null, null, null);
+
+        // Null means nothing was hit; the wire contract of HitGameObjectName depends on that.
+        internal string? Name { get; }
+        internal string? Path { get; }
+        internal string? UiSystem { get; }
+        internal bool HasHit => Name != null;
+    }
+}
diff --git a/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/MouseUiHitReport.cs.meta b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/MouseUiHitReport.cs.meta
new file mode 100644
index 0000000000..527384fbe5
--- /dev/null
+++ b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/MouseUiHitReport.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 31881b37cb52e49c2a3ad40d2075254f
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/MouseUiHitSystem.cs b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/MouseUiHitSystem.cs
new file mode 100644
index 0000000000..d749af200c
--- /dev/null
+++ b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/MouseUiHitSystem.cs
@@ -0,0 +1,16 @@
+#nullable enable
+
+namespace io.github.hatayama.UnityCliLoop.FirstPartyTools
+{
+    /// <summary>
+    /// The UiSystem values simulate-mouse-ui reports, matching the ones screenshot annotations use.
+    /// </summary>
+    internal static class MouseUiHitSystem
+    {
+        internal const string UGUI = "UGUI";
+        internal const string UIToolkit = "UIToolkit";
+
+        // A target outside any Canvas, such as an object hit by a physics raycaster.
+        internal const string NonUi = "";
+    }
+}
diff --git a/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/MouseUiHitSystem.cs.meta b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/MouseUiHitSystem.cs.meta
new file mode 100644
index 0000000000..099173acd4
--- /dev/null
+++ b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/MouseUiHitSystem.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 6bf90b44c9012482a8ddbd660976fd13
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/MouseUiPointerTargetResolver.cs b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/MouseUiPointerTargetResolver.cs
index 2dedc3bd74..26b918ea03 100644
--- a/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/MouseUiPointerTargetResolver.cs
+++ b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/MouseUiPointerTargetResolver.cs
@@ -51,7 +51,9 @@ internal static ResolvedPointerTargets ResolvePressablePointerTargets(
                 return ResolveBypassPressablePointerTargets(parameters, inputPos, pointerData, action);
             }
 
-            RaycastResult? hit = UiRaycastHelper.RaycastUI(screenPos, eventSystem);
+            // UI Toolkit is resolved separately at the requested point; the bridge's panel hits are flipped with
+            // Screen.height and would land on the wrong element.
+            RaycastResult? hit = UiRaycastHelper.RaycastUISkippingUIToolkitPanels(screenPos, eventSystem);
             if (hit == null)
             {
                 return ResolvedPointerTargets.Empty;
diff --git a/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/MouseUiPressActionExecutor.cs b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/MouseUiPressActionExecutor.cs
index 116b3786c7..1587e24bf2 100644
--- a/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/MouseUiPressActionExecutor.cs
+++ b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/MouseUiPressActionExecutor.cs
@@ -17,22 +17,21 @@ internal static class MouseUiPressActionExecutor
     {
         internal static async Task<SimulateMouseUiResponse> ExecuteClick(
             MouseUiSimulationCommand parameters,
-            EventSystem eventSystem,
+            EventSystem? eventSystem,
             MouseUiMainThreadCleanupScheduler cleanupScheduler,
             CancellationToken ct)
         {
             Vector2 inputPos = new(parameters.X, parameters.Y);
-            Vector2 screenPos = MouseUiCoordinateConverter.InputToScreen(inputPos);
-            PointerEventData pointerData = MouseUiPointerTargetResolver.CreatePointerPressData(eventSystem, screenPos, parameters.Button);
-            MouseUiInputSystemSync.SyncMousePosition(screenPos);
-            ResolvedPointerTargets resolvedTargets =
-                MouseUiPointerTargetResolver.ResolvePressablePointerTargets(parameters, eventSystem, inputPos, screenPos, pointerData, MouseAction.Click);
-            if (resolvedTargets.FailureResponse != null)
+            (IMouseUiPressTarget? resolvedTarget, SimulateMouseUiResponse? failure) =
+                ResolvePressTarget(parameters, eventSystem, inputPos, MouseAction.Click);
+            if (failure != null)
             {
-                return resolvedTargets.FailureResponse;
+                return failure;
             }
 
-            if (parameters.BypassRaycast && resolvedTargets.Target == null)
+            IMouseUiPressTarget pressTarget = resolvedTarget!;
+            MouseUiHitReport report = pressTarget.Report;
+            if (parameters.BypassRaycast && !report.HasHit)
             {
                 return new SimulateMouseUiResponse
                 {
@@ -44,8 +43,7 @@ internal static async Task<SimulateMouseUiResponse> ExecuteClick(
                 };
             }
 
-            string? targetName = resolvedTargets.Target?.name;
-            bool hitTarget = resolvedTargets.Target != null;
+            string? targetName = report.Name;
             SimulateMouseUiOverlayState.Update(
                 MouseAction.Click, inputPos, null,
                 Handles.GetMainGameViewSize());
@@ -66,13 +64,13 @@ internal static async Task<SimulateMouseUiResponse> ExecuteClick(
             await MainThreadSwitcher.SwitchToMainThread(ct);
 
             // Fire click events after expand animation so the user sees where the click lands
-            ExecutePointerClickEvents(resolvedTargets, pointerData);
+            pressTarget.Click();
 
             MouseUiFrameWaitOutcome dissipateOutcome = await MouseUiOverlayAnimator.PlayDissipateAnimation(ct).ConfigureAwait(false);
             if (dissipateOutcome == MouseUiFrameWaitOutcome.TimedOut)
             {
                 cleanupScheduler.QueueOverlayClear();
-                return MouseUiSimulationResponseFactory.CreateClickResult(parameters, inputPos, targetName, hitTarget);
+                return MouseUiSimulationResponseFactory.CreateClickResult(parameters, inputPos, report);
             }
             if (dissipateOutcome == MouseUiFrameWaitOutcome.Paused)
             {
@@ -83,12 +81,12 @@ internal static async Task<SimulateMouseUiResponse> ExecuteClick(
             }
             await MainThreadSwitcher.SwitchToMainThread(ct);
 
-            return MouseUiSimulationResponseFactory.CreateClickResult(parameters, inputPos, targetName, hitTarget);
+            return MouseUiSimulationResponseFactory.CreateClickResult(parameters, inputPos, report);
         }
 
         internal static async Task<SimulateMouseUiResponse> ExecuteLongPress(
             MouseUiSimulationCommand parameters,
-            EventSystem eventSystem,
+            EventSystem? eventSystem,
             MouseUiMainThreadCleanupScheduler cleanupScheduler,
             CancellationToken ct)
         {
@@ -99,17 +97,16 @@ internal static async Task<SimulateMouseUiResponse> ExecuteLongPress(
             }
 
             Vector2 inputPos = new(parameters.X, parameters.Y);
-            Vector2 screenPos = MouseUiCoordinateConverter.InputToScreen(inputPos);
-            PointerEventData pointerData = MouseUiPointerTargetResolver.CreatePointerPressData(eventSystem, screenPos, parameters.Button);
-            MouseUiInputSystemSync.SyncMousePosition(screenPos);
-            ResolvedPointerTargets resolvedTargets =
-                MouseUiPointerTargetResolver.ResolvePressablePointerTargets(parameters, eventSystem, inputPos, screenPos, pointerData, MouseAction.LongPress);
-            if (resolvedTargets.FailureResponse != null)
+            (IMouseUiPressTarget? resolvedTarget, SimulateMouseUiResponse? failure) =
+                ResolvePressTarget(parameters, eventSystem, inputPos, MouseAction.LongPress);
+            if (failure != null)
             {
-                return resolvedTargets.FailureResponse;
+                return failure;
             }
 
-            if (parameters.BypassRaycast && resolvedTargets.Target == null)
+            IMouseUiPressTarget pressTarget = resolvedTarget!;
+            MouseUiHitReport report = pressTarget.Report;
+            if (parameters.BypassRaycast && !report.HasHit)
             {
                 return new SimulateMouseUiResponse
                 {
@@ -121,9 +118,7 @@ internal static async Task<SimulateMouseUiResponse> ExecuteLongPress(
                 };
             }
 
-            string? targetName = resolvedTargets.Target?.name;
-            bool hitTarget = resolvedTargets.Target != null;
-            bool shouldReleasePointer = resolvedTargets.RawTarget != null && resolvedTargets.Target != null;
+            string? targetName = report.Name;
             SimulateMouseUiOverlayState.Update(
                 MouseAction.LongPress, inputPos, null,
                 Handles.GetMainGameViewSize());
@@ -143,10 +138,11 @@ internal static async Task<SimulateMouseUiResponse> ExecuteLongPress(
             }
             await MainThreadSwitcher.SwitchToMainThread(ct);
 
-            ExecuteLongPressPointerDown(resolvedTargets, pointerData);
-
             try
             {
+                // Inside the try: a UI Toolkit handler that throws on the press still gets the release, which is
+                // safe to send when nothing was pressed.
+                pressTarget.PressDown();
                 SimulateMouseUiResponse? holdAbort = await HoldLongPressOrAbortAsync(
                     parameters.Duration, inputPos, targetName, cleanupScheduler, ct).ConfigureAwait(false);
                 if (holdAbort != null)
@@ -157,11 +153,7 @@ internal static async Task<SimulateMouseUiResponse> ExecuteLongPress(
             finally
             {
                 // Ensure pointerUp fires even if the hold loop is cancelled
-                if (shouldReleasePointer)
-                {
-                    cleanupScheduler.ExecuteCleanupOnMainThread(
-                        () => ExecuteEvents.Execute(resolvedTargets.Target!, pointerData, ExecuteEvents.pointerUpHandler));
-                }
+                cleanupScheduler.ExecuteCleanupOnMainThread(pressTarget.Release);
             }
 
             // Why switch after the helper: HoldLongPressOrAbortAsync ends on the main thread,
@@ -172,7 +164,7 @@ internal static async Task<SimulateMouseUiResponse> ExecuteLongPress(
             if (dissipateOutcome == MouseUiFrameWaitOutcome.TimedOut)
             {
                 cleanupScheduler.QueueOverlayClear();
-                return MouseUiSimulationResponseFactory.CreateLongPressResult(parameters, inputPos, targetName, hitTarget);
+                return MouseUiSimulationResponseFactory.CreateLongPressResult(parameters, inputPos, report);
             }
             if (dissipateOutcome == MouseUiFrameWaitOutcome.Paused)
             {
@@ -183,7 +175,7 @@ internal static async Task<SimulateMouseUiResponse> ExecuteLongPress(
             }
             await MainThreadSwitcher.SwitchToMainThread(ct);
 
-            return MouseUiSimulationResponseFactory.CreateLongPressResult(parameters, inputPos, targetName, hitTarget);
+            return MouseUiSimulationResponseFactory.CreateLongPressResult(parameters, inputPos, report);
         }
 
         private static SimulateMouseUiResponse? CreateInvalidLongPressDurationResponse(float duration)
@@ -249,53 +241,15 @@ internal static async Task<SimulateMouseUiResponse> ExecuteLongPress(
             return null;
         }
 
-        private static void ExecutePointerClickEvents(
-            ResolvedPointerTargets resolvedTargets,
-            PointerEventData pointerData)
-        {
-            if (resolvedTargets.RawTarget == null)
-            {
-                return;
-            }
-
-            if (resolvedTargets.PressTarget != null)
-            {
-                ExecuteEvents.ExecuteHierarchy(
-                    resolvedTargets.RawTarget,
-                    pointerData,
-                    ExecuteEvents.pointerDownHandler);
-            }
-
-            if (resolvedTargets.Target != null)
-            {
-                ExecuteEvents.Execute(
-                    resolvedTargets.Target,
-                    pointerData,
-                    ExecuteEvents.pointerUpHandler);
-            }
-
-            if (resolvedTargets.ClickTarget != null)
-            {
-                ExecuteEvents.Execute(
-                    resolvedTargets.ClickTarget,
-                    pointerData,
-                    ExecuteEvents.pointerClickHandler);
-            }
-        }
-
-        private static void ExecuteLongPressPointerDown(
-            ResolvedPointerTargets resolvedTargets,
-            PointerEventData pointerData)
+        private static (IMouseUiPressTarget? Target, SimulateMouseUiResponse? Failure) ResolvePressTarget(
+            MouseUiSimulationCommand parameters,
+            EventSystem? eventSystem,
+            Vector2 inputPos,
+            MouseAction action)
         {
-            if (resolvedTargets.RawTarget == null || resolvedTargets.Target == null)
-            {
-                return;
-            }
-
-            ExecuteEvents.ExecuteHierarchy(
-                resolvedTargets.RawTarget,
-                pointerData,
-                ExecuteEvents.pointerDownHandler);
+            Vector2 screenPos = MouseUiCoordinateConverter.InputToScreen(inputPos);
+            MouseUiInputSystemSync.SyncMousePosition(screenPos);
+            return MouseUiPressTargetResolver.Resolve(parameters, eventSystem, inputPos, screenPos, action);
         }
     }
 }
diff --git a/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/MouseUiPressTargetResolver.cs b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/MouseUiPressTargetResolver.cs
new file mode 100644
index 0000000000..718bab3b9a
--- /dev/null
+++ b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/MouseUiPressTargetResolver.cs
@@ -0,0 +1,102 @@
+#nullable enable
+using UnityEngine;
+using UnityEngine.EventSystems;
+
+using io.github.hatayama.UnityCliLoop.Runtime;
+
+namespace io.github.hatayama.UnityCliLoop.FirstPartyTools
+{
+    /// <summary>
+    /// Decides whether a click or long press goes to uGUI or to UI Toolkit. On success a target is always
+    /// returned, an empty uGUI one when nothing is under the point; on failure only the response is.
+    /// </summary>
+    internal static class MouseUiPressTargetResolver
+    {
+        private const string NoEventSystemMessage = "No EventSystem found in the scene. Ensure an EventSystem GameObject exists.";
+        private const string UIToolkitPathHint =
+            " UI Toolkit element paths are not accepted here; click the element at its SimX/SimY without --bypass-raycast.";
+
+        internal static (IMouseUiPressTarget? Target, SimulateMouseUiResponse? Failure) Resolve(
+            MouseUiSimulationCommand parameters,
+            EventSystem? eventSystem,
+            Vector2 inputPos,
+            Vector2 screenPos,
+            MouseAction action)
+        {
+            if (parameters.BypassRaycast)
+            {
+                return ResolveBypass(parameters, eventSystem, inputPos, screenPos, action);
+            }
+
+            // UI Toolkit is looked up at the requested point itself, which does not depend on Screen; the uGUI
+            // side leaves out the bridge's panel hits, which do.
+            UIToolkitPointerTarget? toolkit = UIToolkitScreenElements.FindPointerTarget(inputPos);
+            ResolvedPointerTargets uguiResolved = ResolvedPointerTargets.Empty;
+            PointerEventData? uguiPointerData = null;
+            if (eventSystem != null)
+            {
+                uguiPointerData = MouseUiPointerTargetResolver.CreatePointerPressData(eventSystem, screenPos, parameters.Button);
+                uguiResolved = MouseUiPointerTargetResolver.ResolvePressablePointerTargets(
+                    parameters, eventSystem, inputPos, screenPos, uguiPointerData, action);
+            }
+
+            // A raycast hit without a handler still counts: real input stops at it and never reaches the panel.
+            bool uguiHasRaycastHit = uguiResolved.RawTarget != null;
+            if (toolkit == null && !uguiHasRaycastHit)
+            {
+                if (eventSystem == null)
+                {
+                    return (null, MouseUiSimulationResponseFactory.CreateFailure(
+                        parameters,
+                        $"No EventSystem found in the scene, and no UI Toolkit element is at ({inputPos.x:F1}, {inputPos.y:F1}). Ensure an EventSystem GameObject exists for uGUI."));
+                }
+
+                return (new UguiPressTarget(ResolvedPointerTargets.Empty, uguiPointerData), null);
+            }
+
+            if (toolkit != null && (!uguiHasRaycastHit || !IsUguiHitInFront(uguiPointerData!, toolkit)))
+            {
+                return (new UIToolkitPressTarget(toolkit, inputPos, (int)parameters.Button), null);
+            }
+
+            return (new UguiPressTarget(uguiResolved, uguiPointerData), null);
+        }
+
+        private static (IMouseUiPressTarget? Target, SimulateMouseUiResponse? Failure) ResolveBypass(
+            MouseUiSimulationCommand parameters,
+            EventSystem? eventSystem,
+            Vector2 inputPos,
+            Vector2 screenPos,
+            MouseAction action)
+        {
+            if (eventSystem == null)
+            {
+                return (null, MouseUiSimulationResponseFactory.CreateFailure(parameters, NoEventSystemMessage));
+            }
+
+            PointerEventData pointerData = MouseUiPointerTargetResolver.CreatePointerPressData(eventSystem, screenPos, parameters.Button);
+            ResolvedPointerTargets resolved = MouseUiPointerTargetResolver.ResolvePressablePointerTargets(
+                parameters, eventSystem, inputPos, screenPos, pointerData, action);
+            SimulateMouseUiResponse? failure = resolved.FailureResponse;
+            if (failure == null)
+            {
+                return (new UguiPressTarget(resolved, pointerData), null);
+            }
+
+            // Annotation paths of UI Toolkit controls contain '#', which no GameObject path lookup can match.
+            if (failure.Message.EndsWith("was not found.", System.StringComparison.Ordinal) && parameters.TargetPath.Contains("#"))
+            {
+                failure.Message += UIToolkitPathHint;
+            }
+
+            return (null, failure);
+        }
+
+        // The press data carries the uGUI raycast hit, whose raycaster decides the order against the panel.
+        private static bool IsUguiHitInFront(PointerEventData uguiPointerData, UIToolkitPointerTarget toolkit)
+        {
+            BaseRaycaster raycaster = uguiPointerData.pointerPressRaycast.module;
+            return MouseUiHitPriority.IsUguiInFront(raycaster.sortOrderPriority, toolkit.SortingOrder);
+        }
+    }
+}
diff --git a/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/MouseUiPressTargetResolver.cs.meta b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/MouseUiPressTargetResolver.cs.meta
new file mode 100644
index 0000000000..5cc46dbef7
--- /dev/null
+++ b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/MouseUiPressTargetResolver.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 94dd6bfdafc504163afebc155ba0247d
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/MouseUiSimulationResponseFactory.cs b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/MouseUiSimulationResponseFactory.cs
index 32bf262603..4eb4db1682 100644
--- a/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/MouseUiSimulationResponseFactory.cs
+++ b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/MouseUiSimulationResponseFactory.cs
@@ -66,19 +66,21 @@ internal static SimulateMouseUiResponse CreateFrameTimeoutResult(
         internal static SimulateMouseUiResponse CreateClickResult(
             MouseUiSimulationCommand parameters,
             Vector2 inputPos,
-            string? targetName,
-            bool hitTarget)
+            MouseUiHitReport hit)
         {
+            string? targetName = hit.Name;
             return new SimulateMouseUiResponse
             {
                 Success = true,
-                Message = hitTarget
+                Message = hit.HasHit
                     ? parameters.BypassRaycast
                         ? $"Bypass-clicked '{targetName}' at ({inputPos.x:F1}, {inputPos.y:F1}) via '{parameters.TargetPath}'"
-                        : $"Clicked '{targetName}' at ({inputPos.x:F1}, {inputPos.y:F1})"
+                        : $"Clicked {DescribeHit(hit)} at ({inputPos.x:F1}, {inputPos.y:F1})"
                     : $"Clicked at ({inputPos.x:F1}, {inputPos.y:F1}) - no UI element hit",
                 Action = MouseAction.Click.ToString(),
                 HitGameObjectName = targetName,
+                UiSystem = hit.UiSystem,
+                HitPath = hit.Path,
                 PositionX = inputPos.x,
                 PositionY = inputPos.y
             };
@@ -87,24 +89,33 @@ internal static SimulateMouseUiResponse CreateClickResult(
         internal static SimulateMouseUiResponse CreateLongPressResult(
             MouseUiSimulationCommand parameters,
             Vector2 inputPos,
-            string? targetName,
-            bool hitTarget)
+            MouseUiHitReport hit)
         {
+            string? targetName = hit.Name;
             return new SimulateMouseUiResponse
             {
                 Success = true,
-                Message = hitTarget
+                Message = hit.HasHit
                     ? parameters.BypassRaycast
                         ? $"Bypass-long-pressed '{targetName}' at ({inputPos.x:F1}, {inputPos.y:F1}) via '{parameters.TargetPath}' for {parameters.Duration:F1}s"
-                        : $"Long-pressed '{targetName}' at ({inputPos.x:F1}, {inputPos.y:F1}) for {parameters.Duration:F1}s"
+                        : $"Long-pressed {DescribeHit(hit)} at ({inputPos.x:F1}, {inputPos.y:F1}) for {parameters.Duration:F1}s"
                     : $"Long-pressed at ({inputPos.x:F1}, {inputPos.y:F1}) for {parameters.Duration:F1}s - no UI element hit",
                 Action = MouseAction.LongPress.ToString(),
                 HitGameObjectName = targetName,
+                UiSystem = hit.UiSystem,
+                HitPath = hit.Path,
                 PositionX = inputPos.x,
                 PositionY = inputPos.y
             };
         }
 
+        private static string DescribeHit(MouseUiHitReport hit)
+        {
+            return hit.UiSystem == MouseUiHitSystem.UIToolkit
+                ? $"UI Toolkit element '{hit.Name}'"
+                : $"'{hit.Name}'";
+        }
+
         internal static SimulateMouseUiResponse CreateDragResult(
             MouseUiSimulationCommand parameters,
             Vector2 inputStart,
diff --git a/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/MouseUiSimulationValidator.cs b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/MouseUiSimulationValidator.cs
index 239600f464..4417ed5080 100644
--- a/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/MouseUiSimulationValidator.cs
+++ b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/MouseUiSimulationValidator.cs
@@ -1,6 +1,4 @@
 #nullable enable
-using UnityEngine.EventSystems;
-
 using io.github.hatayama.UnityCliLoop.Runtime;
 
 namespace io.github.hatayama.UnityCliLoop.FirstPartyTools
@@ -12,7 +10,6 @@ internal static class MouseUiSimulationValidator
     {
         internal static SimulateMouseUiResponse? ValidateSimulationStart(
             MouseUiSimulationCommand parameters,
-            EventSystem? eventSystem,
             string pausedActionDescription)
         {
             PlayModeToolPreflightResult playModeResult =
@@ -22,13 +19,6 @@ internal static class MouseUiSimulationValidator
                 return MouseUiSimulationResponseFactory.CreatePreflightFailure(parameters, playModeResult);
             }
 
-            if (eventSystem == null)
-            {
-                return MouseUiSimulationResponseFactory.CreateFailure(
-                    parameters,
-                    "No EventSystem found in the scene. Ensure an EventSystem GameObject exists.");
-            }
-
             return ValidateSimulationRequestOptions(parameters);
         }
 
@@ -91,7 +81,7 @@ private static bool RequiresBypassTargetPath(MouseAction action)
                 || action == MouseAction.DragStart;
         }
 
-        private static bool IsDragAction(MouseAction action)
+        internal static bool IsDragAction(MouseAction action)
         {
             return action == MouseAction.Drag
                 || action == MouseAction.DragStart
diff --git a/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/SimulateMouseUiResponse.cs b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/SimulateMouseUiResponse.cs
index 1c7354dc75..a4127095cd 100644
--- a/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/SimulateMouseUiResponse.cs
+++ b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/SimulateMouseUiResponse.cs
@@ -13,7 +13,24 @@ public class SimulateMouseUiResponse : UnityCliLoopToolResponse
     {
         public string Message { get; set; } = "";
         public string Action { get; set; } = "";
+        /// <summary>
+        /// Name of what received the press: the uGUI or physics GameObject that handles it, or the UI Toolkit
+        /// control under the point (its name, or its type name when it has none). Null when nothing was hit.
+        /// </summary>
         public string? HitGameObjectName { get; set; }
+
+        /// <summary>
+        /// Which UI system was hit: "UGUI" for a target under a Canvas, "" for a target outside any Canvas (a
+        /// physics hit), "UIToolkit" for a UI Toolkit control, or null when nothing was hit.
+        /// </summary>
+        public string? UiSystem { get; set; }
+
+        /// <summary>
+        /// Path of what was hit, in the form screenshot annotations use: the GameObject's hierarchy path for
+        /// uGUI and physics, or the document path, '#', and element chain for UI Toolkit. Null when nothing was
+        /// hit or when a UI Toolkit element belongs to no document, such as an open dropdown's menu.
+        /// </summary>
+        public string? HitPath { get; set; }
         public float PositionX { get; set; }
         public float PositionY { get; set; }
         public float? EndPositionX { get; set; }
diff --git a/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/SimulateMouseUiUseCase.cs b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/SimulateMouseUiUseCase.cs
index 1a711654fe..948a558427 100644
--- a/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/SimulateMouseUiUseCase.cs
+++ b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/SimulateMouseUiUseCase.cs
@@ -50,14 +50,20 @@ public async Task<SimulateMouseUiResponse> ExecuteAsync(
             EventSystem? eventSystem = EventSystem.current;
             SimulateMouseUiResponse? validationFailure = MouseUiSimulationValidator.ValidateSimulationStart(
                 parameters,
-                eventSystem,
                 PausedActionDescription);
             if (validationFailure != null)
             {
                 return validationFailure;
             }
-            Debug.Assert(eventSystem != null, "ValidateSimulationStart must reject a missing EventSystem.");
-            EventSystem activeEventSystem = eventSystem!;
+
+            // Clicks and long presses can reach UI Toolkit without an EventSystem and check for one when they
+            // resolve their target. DragMove and DragEnd executors never receive it, so drags are checked here.
+            if (MouseUiSimulationValidator.IsDragAction(parameters.Action) && eventSystem == null)
+            {
+                return MouseUiSimulationResponseFactory.CreateFailure(
+                    parameters,
+                    "No EventSystem found in the scene. Ensure an EventSystem GameObject exists.");
+            }
 
             MouseUiSimulationActivityLogger.LogSimulationStart(parameters, correlationId);
             OverlayCanvasFactory.EnsureExists();
@@ -70,7 +76,7 @@ public async Task<SimulateMouseUiResponse> ExecuteAsync(
             }
 
             SimulateMouseUiResponse response =
-                await ExecuteMouseAction(parameters, activeEventSystem, ct).ConfigureAwait(false);
+                await ExecuteMouseAction(parameters, eventSystem, ct).ConfigureAwait(false);
             MouseUiSimulationActivityLogger.LogSimulationComplete(parameters, response, correlationId);
 
             return response;
@@ -78,7 +84,7 @@ public async Task<SimulateMouseUiResponse> ExecuteAsync(
 
         private async Task<SimulateMouseUiResponse> ExecuteMouseAction(
             MouseUiSimulationCommand parameters,
-            EventSystem eventSystem,
+            EventSystem? eventSystem,
             CancellationToken ct)
         {
             switch (parameters.Action)
@@ -91,16 +97,18 @@ private async Task<SimulateMouseUiResponse> ExecuteMouseAction(
                         ct).ConfigureAwait(false);
 
                 case MouseAction.Drag:
+                    Debug.Assert(eventSystem != null, "Drags without an EventSystem must be rejected before dispatch.");
                     return await MouseUiOneShotDragExecutor.ExecuteDragOneShot(
                         parameters,
-                        eventSystem,
+                        eventSystem!,
                         _mainThreadCleanupScheduler,
                         ct).ConfigureAwait(false);
 
                 case MouseAction.DragStart:
+                    Debug.Assert(eventSystem != null, "Drags without an EventSystem must be rejected before dispatch.");
                     return await MouseUiIncrementalDragExecutor.ExecuteDragStart(
                         parameters,
-                        eventSystem,
+                        eventSystem!,
                         _mainThreadCleanupScheduler,
                         ct).ConfigureAwait(false);
 
diff --git a/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/Skill/SKILL.md b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/Skill/SKILL.md
index 03417c9713..0be9c8c4fb 100644
--- a/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/Skill/SKILL.md
+++ b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/Skill/SKILL.md
@@ -1,7 +1,7 @@
 ---
 name: uloop-simulate-mouse-ui
 toolName: simulate-mouse-ui
-description: "Simulate PlayMode EventSystem UI mouse actions using screen coordinates. Use for UI clicks, long-presses, or drags from annotated screenshots."
+description: "Simulate PlayMode UI mouse actions on uGUI and UI Toolkit using screen coordinates. Use for UI clicks, long-presses, or drags from annotated screenshots."
 ---
 
 # Task
@@ -64,7 +64,7 @@ uloop simulate-mouse-ui --action <action> --x <x> --y <y> [options]
 - Get coordinates from `AnnotatedElements` JSON (`SimX`/`SimY`) — do NOT look up GameObject positions
 - `--bypass-raycast` still uses coordinates for pointer event positions, but chooses the clicked, long-pressed, or dragged GameObject by `--target-path`
 - If `--target-path` or `--drop-target-path` matches multiple active GameObjects, the command fails instead of choosing an arbitrary duplicate
-- Not for UI Toolkit entries (`UiSystem` `UIToolkit`); see `references/output.md`.
+- UI Toolkit entries (`UiSystem` `UIToolkit`) can be clicked and long-pressed at `SimX`/`SimY`; `--bypass-raycast`, `--target-path`, and `--drop-target-path` take GameObjects only. Details: `references/ui-toolkit.md`.
 - Device Simulator play view is supported. Prefer `uloop screenshot --capture-mode rendering --annotate-elements` for coordinates; they use the simulated device resolution (`Handles.GetMainGameViewSize()` / `Screen`), not the Simulator chrome scale.
 
 ## Pause Point Inspection (Standard for E2E)
@@ -86,9 +86,6 @@ uloop simulate-mouse-ui --action Drag --from-x 400 --from-y 300 --x 600 --y 300
 # Long-press a button for 3 seconds
 uloop simulate-mouse-ui --action LongPress --x 400 --y 300 --duration 3.0
 
-# One-shot drag (start to end in one call)
-uloop simulate-mouse-ui --action Drag --from-x 400 --from-y 300 --x 600 --y 300
-
 # Slow drag for visual inspection
 uloop simulate-mouse-ui --action Drag --from-x 400 --from-y 300 --x 600 --y 300 --drag-speed 200
 
@@ -102,14 +99,14 @@ uloop simulate-mouse-ui --action DragEnd --x 600 --y 300
 ## Prerequisites
 
 - Unity must be in **PlayMode**
-- Target scene must have an **EventSystem** GameObject
-- UI elements must have a **GraphicRaycaster** on their Canvas
+- uGUI targets need an **EventSystem** and a **GraphicRaycaster** on their Canvas; UI Toolkit targets need neither
 - If you need runtime mouse input rather than UI pointer events, `simulate-mouse-input` assumes the project uses the New Input System; otherwise prefer `execute-dynamic-code`
 
 ## Output
 
 The response reports `Success`, `Message`, `Action`, `HitGameObjectName`, the used
-coordinates, and `InterruptedByPausePoint`/`PausePointHits`. Two readings that matter:
+coordinates, and `InterruptedByPausePoint`/`PausePointHits`; `UiSystem` and `HitPath` say
+which UI system was hit and give its path in the annotation's form. Two readings that matter:
 `Click`/`LongPress` on empty space still return `Success = true` with
 `HitGameObjectName = null` (drag actions on empty space fail), and on a pause-point
 interruption `Message` states whether the pointer event fired before the pause.
diff --git a/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/Skill/references/output.md b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/Skill/references/output.md
index 043b24d6aa..af20d8c00b 100644
--- a/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/Skill/references/output.md
+++ b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/Skill/references/output.md
@@ -5,7 +5,9 @@ Returns JSON with:
 - `Success`: Whether the operation succeeded
 - `Message`: Status message (e.g. "Hit element: ButtonStart" or "No UI element under (x, y)")
 - `Action`: Echoes which action was executed (`Click`, `Drag`, `DragStart`, `DragMove`, `DragEnd`, or `LongPress`)
-- `HitGameObjectName`: Name of the GameObject that received the pointer events (nullable string; null if nothing was hit). It is the event-handler target resolved up the hierarchy from the raycast hit (the first `IPointerDownHandler`, else the first `IPointerClickHandler`, for `Click`/`LongPress`; the first `IDragHandler` for drags), so it can be an ancestor of the topmost raycast hit — a Button's child Text reports the Button. With `--bypass-raycast` it is the handler resolved the same way from `--target-path` (also possibly an ancestor), not the raycast hit and not necessarily the raw path GameObject itself
+- `HitGameObjectName`: Name of the GameObject that received the pointer events (nullable string; null if nothing was hit). It is the event-handler target resolved up the hierarchy from the raycast hit (the first `IPointerDownHandler`, else the first `IPointerClickHandler`, for `Click`/`LongPress`; the first `IDragHandler` for drags), so it can be an ancestor of the topmost raycast hit — a Button's child Text reports the Button. With `--bypass-raycast` it is the handler resolved the same way from `--target-path` (also possibly an ancestor), not the raycast hit and not necessarily the raw path GameObject itself. For a UI Toolkit hit it is the control's `name`, the same as the annotation's `Name`
+- `UiSystem`: Which UI system received the press (nullable string; `Click`/`LongPress` only, null if nothing was hit): `UGUI` for a target under a Canvas, `UIToolkit` for a UI Toolkit control, and `""` for a non-UI target such as a physics object
+- `HitPath`: Path of the hit target in the form `AnnotatedElements[].Path` uses (nullable string; `Click`/`LongPress` only): a hierarchy path for GameObjects, `Document/Path#element` for UI Toolkit controls
 - `PositionX`: Target X coordinate that was used
 - `PositionY`: Target Y coordinate that was used
 - `EndPositionX`: Drag end X coordinate (nullable float; populated for drag actions only)
@@ -18,4 +20,4 @@ Note: Click and LongPress on empty space (no UI element) still return `Success =
 
 ## UI Toolkit Elements
 
-`simulate-mouse-ui` drives the uGUI EventSystem raycast path, so it does not reach UI Toolkit controls (`AnnotatedElements` entries with `UiSystem` `UIToolkit`): a click at their `SimX`/`SimY` lands on the panel's own GameObject instead. `--target-path` does not accept their `Path` either. Click them with `simulate-mouse-input` instead, which works when the scene has an EventSystem with an Input System UI input module.
+`Click` and `LongPress` reach UI Toolkit controls at their annotated `SimX`/`SimY`. How presses are delivered and what is not supported: `ui-toolkit.md`.
diff --git a/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/Skill/references/ui-toolkit.md b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/Skill/references/ui-toolkit.md
new file mode 100644
index 0000000000..ec3bb79d44
--- /dev/null
+++ b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/Skill/references/ui-toolkit.md
@@ -0,0 +1,46 @@
+# simulate-mouse-ui and UI Toolkit
+
+`Click` and `LongPress` reach UI Toolkit controls on screen-space panels — the
+`AnnotatedElements` entries with `UiSystem` `UIToolkit`. Pass the entry's `SimX`/`SimY` as
+`--x`/`--y`; the response reports `UiSystem` `UIToolkit`, the control's `Name` as
+`HitGameObjectName`, and its annotation `Path` as `HitPath`.
+
+## How a press is delivered
+
+- The point is mapped to each panel the same way the screenshot annotation maps controls to
+  `SimX`/`SimY`, so an annotated point lands on the annotated control. It does not depend on
+  which Editor view was drawn last.
+- Panels are searched front to back by their panel settings' `sortingOrder`; the first panel
+  with a control under the point gets the press. The reported control is the outermost one an
+  annotation would list, so a click on a scrollbar's thumb reports the scrollbar.
+- Where a uGUI element and a UI Toolkit panel are both under the point, the uGUI element wins
+  only when its Canvas sorts above the panel (raycaster sort priority greater than the panel's
+  `sortingOrder`), the same rule the EventSystem applies to real input. A uGUI image without
+  any pointer handler in front still blocks the panel, as real input would.
+- A full-screen container left at the default `pickingMode` (`Position`) counts as a hit, so
+  uGUI underneath it is not reached — real input behaves the same way.
+- UI Toolkit presses do not need an EventSystem. With neither an EventSystem nor a UI Toolkit
+  control under the point, the command fails and says so.
+- A disabled control receives the press but does not react, as with real input.
+
+## LongPress
+
+A UI Toolkit `Button` fires `clicked` once when the long press is released (UI Toolkit's
+`Clickable` behaviour); a uGUI long press sends no click. A `RepeatButton` fires repeatedly
+while held.
+
+## Not supported
+
+- `--bypass-raycast`, `--target-path`, and `--drop-target-path` take GameObject paths only;
+  a UI Toolkit `Path` (it contains `#`) is reported as not found.
+- Drag actions go through the uGUI EventSystem only.
+- World-space panels (Unity 6), as in the annotation.
+- Two panels with the same `sortingOrder` overlapping at the point: Unity orders them by
+  creation order, which is not exposed, so either one may be chosen.
+
+## Notes
+
+- Move the real mouse cursor out of the Game View while simulating. Real pointer input over
+  the Game View reaches the same panels and can interleave with the simulated press.
+- Device Simulator has the same limits as the annotation: coordinates use the simulated device
+  resolution.
diff --git a/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/Skill/references/ui-toolkit.md.meta b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/Skill/references/ui-toolkit.md.meta
new file mode 100644
index 0000000000..001f31d933
--- /dev/null
+++ b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/Skill/references/ui-toolkit.md.meta
@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 3aab865ee97bb4a55b610c7b9d4ac797
+TextScriptImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/UIToolkitPressTarget.cs b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/UIToolkitPressTarget.cs
new file mode 100644
index 0000000000..b56fed5019
--- /dev/null
+++ b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/UIToolkitPressTarget.cs
@@ -0,0 +1,50 @@
+#nullable enable
+using UnityEngine;
+
+namespace io.github.hatayama.UnityCliLoop.FirstPartyTools
+{
+    /// <summary>
+    /// Delivers a click or long press to a UI Toolkit control by sending pointer events to its panel at the
+    /// requested Game View point.
+    /// </summary>
+    internal sealed class UIToolkitPressTarget : IMouseUiPressTarget
+    {
+        private readonly UIToolkitPointerTarget _target;
+        private readonly Vector2 _gameViewTopLeft;
+        private readonly int _button;
+
+        internal UIToolkitPressTarget(UIToolkitPointerTarget target, Vector2 gameViewTopLeft, int button)
+        {
+            _target = target;
+            _gameViewTopLeft = gameViewTopLeft;
+            _button = button;
+            Report = new MouseUiHitReport(target.Name, target.Path, MouseUiHitSystem.UIToolkit);
+        }
+
+        public MouseUiHitReport Report { get; }
+
+        // UI Toolkit lets handler exceptions reach the sender, unlike uGUI's ExecuteEvents, so the release is
+        // sent even when the press throws, and the exception still reaches the caller.
+        public void Click()
+        {
+            try
+            {
+                _target.PressDown(_gameViewTopLeft, _button);
+            }
+            finally
+            {
+                _target.Release(_gameViewTopLeft, _button);
+            }
+        }
+
+        public void PressDown()
+        {
+            _target.PressDown(_gameViewTopLeft, _button);
+        }
+
+        public void Release()
+        {
+            _target.Release(_gameViewTopLeft, _button);
+        }
+    }
+}
diff --git a/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/UIToolkitPressTarget.cs.meta b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/UIToolkitPressTarget.cs.meta
new file mode 100644
index 0000000000..727772e4b7
--- /dev/null
+++ b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/UIToolkitPressTarget.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 2a98e11783c0f44ebaaffe60ea0219d2
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/UguiPressTarget.cs b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/UguiPressTarget.cs
new file mode 100644
index 0000000000..ada219b6d9
--- /dev/null
+++ b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/UguiPressTarget.cs
@@ -0,0 +1,101 @@
+#nullable enable
+using UnityEngine;
+using UnityEngine.EventSystems;
+
+namespace io.github.hatayama.UnityCliLoop.FirstPartyTools
+{
+    /// <summary>
+    /// Delivers a click or long press to uGUI or physics targets through the EventSystem's handlers. With no
+    /// resolved target it reports no hit and sends nothing.
+    /// </summary>
+    internal sealed class UguiPressTarget : IMouseUiPressTarget
+    {
+        private readonly ResolvedPointerTargets _resolvedTargets;
+        private readonly PointerEventData? _pointerData;
+        private readonly bool _shouldReleasePointer;
+
+        internal UguiPressTarget(ResolvedPointerTargets resolvedTargets, PointerEventData? pointerData)
+        {
+            _resolvedTargets = resolvedTargets;
+            _pointerData = pointerData;
+
+            // Captured as plain values: Release can run from cleanup after a timeout, where checking the
+            // UnityEngine.Object targets for null is not safe.
+            bool shouldReleasePointer = resolvedTargets.RawTarget != null && resolvedTargets.Target != null;
+            _shouldReleasePointer = shouldReleasePointer;
+            Report = CreateReport(resolvedTargets.Target);
+        }
+
+        public MouseUiHitReport Report { get; }
+
+        // Decided by whether the handler sits under a Canvas rather than by raycaster type, because a bypass
+        // press has no raycaster and both paths must report alike.
+        private static MouseUiHitReport CreateReport(GameObject? target)
+        {
+            if (target == null)
+            {
+                return MouseUiHitReport.None;
+            }
+
+            string uiSystem = target.GetComponentInParent<Canvas>() != null
+                ? MouseUiHitSystem.UGUI
+                : MouseUiHitSystem.NonUi;
+            return new MouseUiHitReport(target.name, GameObjectPathUtility.GetFullPath(target), uiSystem);
+        }
+
+        public void Click()
+        {
+            if (_resolvedTargets.RawTarget == null)
+            {
+                return;
+            }
+
+            if (_resolvedTargets.PressTarget != null)
+            {
+                ExecuteEvents.ExecuteHierarchy(
+                    _resolvedTargets.RawTarget,
+                    _pointerData,
+                    ExecuteEvents.pointerDownHandler);
+            }
+
+            if (_resolvedTargets.Target != null)
+            {
+                ExecuteEvents.Execute(
+                    _resolvedTargets.Target,
+                    _pointerData,
+                    ExecuteEvents.pointerUpHandler);
+            }
+
+            if (_resolvedTargets.ClickTarget != null)
+            {
+                ExecuteEvents.Execute(
+                    _resolvedTargets.ClickTarget,
+                    _pointerData,
+                    ExecuteEvents.pointerClickHandler);
+            }
+        }
+
+        public void PressDown()
+        {
+            if (_resolvedTargets.RawTarget == null || _resolvedTargets.Target == null)
+            {
+                return;
+            }
+
+            ExecuteEvents.ExecuteHierarchy(
+                _resolvedTargets.RawTarget,
+                _pointerData,
+                ExecuteEvents.pointerDownHandler);
+        }
+
+        public void Release()
+        {
+            if (!_shouldReleasePointer)
+            {
+                return;
+            }
+
+            ExecuteEvents.Execute(_resolvedTargets.Target!, _pointerData, ExecuteEvents.pointerUpHandler);
+        }
+    }
+}
diff --git a/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/UguiPressTarget.cs.meta b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/UguiPressTarget.cs.meta
new file mode 100644
index 0000000000..8dd0ea9ee2
--- /dev/null
+++ b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/UguiPressTarget.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: d99bca934334f489cb54b33b2dee12de
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/UnityCLILoop.FirstPartyTools.SimulateMouseUi.Editor.asmdef b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/UnityCLILoop.FirstPartyTools.SimulateMouseUi.Editor.asmdef
index 23bb2f8f5a..4c9e61822f 100644
--- a/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/UnityCLILoop.FirstPartyTools.SimulateMouseUi.Editor.asmdef
+++ b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/UnityCLILoop.FirstPartyTools.SimulateMouseUi.Editor.asmdef
@@ -6,6 +6,7 @@
         "GUID:fc3fd32eddbee40e39c2d76dc184957b",
         "GUID:f1a38fcd7e85047c5a86331a3e37ddfc",
         "GUID:a2d87883023de4cf59b7d1962d5dd8aa",
+        "GUID:569bba870e5e64d0d94144057b927001",
         "GUID:aa7cf56cc5f074e57ba35272b877e116",
         "GUID:c956a21f824994ef087b6de566690b3d",
         "GUID:33fef506e6744f2982e8c13b1196f696",
diff --git a/cli/common/tools/default-tools.json b/cli/common/tools/default-tools.json
index e82d40a13d..8711367b6a 100644
--- a/cli/common/tools/default-tools.json
+++ b/cli/common/tools/default-tools.json
@@ -521,7 +521,7 @@
     },
     {
       "name": "simulate-mouse-ui",
-      "description": "Simulate PlayMode EventSystem UI mouse actions using screen coordinates. Use for UI clicks, long-presses, or drags from annotated screenshots.",
+      "description": "Simulate PlayMode UI mouse actions on uGUI and UI Toolkit using screen coordinates. Use for UI clicks, long-presses, or drags from annotated screenshots.",
       "inputSchema": {
         "type": "object",
         "properties": {
diff --git a/scripts/test-screenshot-uitoolkit-annotation.ps1 b/scripts/test-screenshot-uitoolkit-annotation.ps1
index db01ae5431..a5371d6d4d 100644
--- a/scripts/test-screenshot-uitoolkit-annotation.ps1
+++ b/scripts/test-screenshot-uitoolkit-annotation.ps1
@@ -1,7 +1,8 @@
 <#
-E2E verification that screenshot --annotate-elements lists UI Toolkit controls, using the uloop CLI against
-UIToolkitAnnotationDemoScene. Safe to run repeatedly: it stops PlayMode and restores the Game View size on exit,
-and never saves the scene.
+E2E verification that screenshot --annotate-elements lists UI Toolkit controls and that simulate-mouse-ui and
+simulate-mouse-input press them at the annotated points, using the uloop CLI against UIToolkitAnnotationDemoScene.
+Safe to run repeatedly: it stops PlayMode and restores the Game View size on exit, and never saves the scene, so
+the listener and EventSystem changes made in PlayMode are discarded.
 
 Usage:
   powershell -NoProfile -ExecutionPolicy Bypass -File .\scripts\test-screenshot-uitoolkit-annotation.ps1
@@ -376,7 +377,8 @@ function Test-ElementsOnlyCapture {
     )
 
     [object[]]$first = Get-UiToolkitElements -Response $AnnotatedResponse
-    [object[]]$second = Get-UiToolkitElements -Response (Invoke-ElementsOnlyCapture)
+    [pscustomobject]$elementsOnly = Invoke-ElementsOnlyCapture
+    [object[]]$second = Get-UiToolkitElements -Response $elementsOnly
     [string]$firstPaths = (@($first | ForEach-Object { $_.Path }) | Sort-Object) -join "|"
     [string]$secondPaths = (@($second | ForEach-Object { $_.Path }) | Sort-Object) -join "|"
     Assert-EqualText -Actual $secondPaths -Expected $firstPaths -Context "UI Toolkit element paths in the elements-only capture"
@@ -387,48 +389,219 @@ function Test-ElementsOnlyCapture {
             Assert-Near -Actual $element.$field -Expected $match.$field -Context "$($element.Path) $field"
         }
     }
+
+    return $elementsOnly
 }
 
-function Get-PlayClickCount {
+function Get-ClickCount {
+    param(
+        [string]$Name
+    )
+
     [string]$code = @"
 UIToolkitAnnotationDemo demo = UnityEngine.Object.FindObjectOfType<UIToolkitAnnotationDemo>();
 if (demo == null) { return "ERROR: UIToolkitAnnotationDemo not found"; }
-return demo.GetClickCount("play");
+return demo.GetClickCount("$Name");
 "@
 
     [pscustomobject]$result = Invoke-UloopJson -CommandArguments @("execute-dynamic-code", "--code", $code)
-    Assert-Condition -Condition ($result.Success -eq $true) -Message "Read play click count failed: $($result.ErrorMessage)"
+    Assert-Condition -Condition ($result.Success -eq $true) -Message "Read $Name click count failed: $($result.ErrorMessage)"
     [string]$count = [string]$result.Result
     if ($count.StartsWith("ERROR:")) {
-        throw "Read play click count failed: $($count.Substring(6).Trim())"
+        throw "Read $Name click count failed: $($count.Substring(6).Trim())"
     }
 
     return $count
 }
 
-# simulate-mouse-input reaches UI Toolkit buttons through the EventSystem; simulate-mouse-ui does not.
-function Test-Click {
+function Invoke-DynamicCodeText {
     param(
-        [pscustomobject]$AnnotatedResponse
+        [string]$Code,
+        [string]$Context
     )
 
-    [object[]]$elements = Get-UiToolkitElements -Response $AnnotatedResponse
-    [pscustomobject]$play = @($elements | Where-Object { $_.Name -eq "play" })[0]
-    [int]$before = [int](Get-PlayClickCount)
+    [pscustomobject]$result = Invoke-UloopJson -CommandArguments @("execute-dynamic-code", "--code", $Code)
+    Assert-Condition -Condition ($result.Success -eq $true) -Message "$Context failed: $($result.ErrorMessage)"
+    return [string]$result.Result
+}
+
+function Format-Coordinate {
+    param(
+        [double]$Value
+    )
+
+    return $Value.ToString([Globalization.CultureInfo]::InvariantCulture)
+}
+
+function Get-AnnotatedElement {
+    param(
+        [pscustomobject]$Response,
+        [string]$UiSystem,
+        [string]$Name
+    )
+
+    return @($Response.Screenshots[0].AnnotatedElements | Where-Object { $_.UiSystem -eq $UiSystem -and $_.Name -eq $Name })[0]
+}
+
+# Returns the simulate-mouse-ui response after checking it succeeded.
+function Invoke-SimulateUi {
+    param(
+        [string]$Context,
+        [string[]]$Arguments
+    )
+
+    [pscustomobject]$response = Invoke-UloopJson -CommandArguments (@("simulate-mouse-ui") + $Arguments)
+    Assert-Condition -Condition ($response.Success -eq $true) -Message "$Context failed: $($response.Message)"
+    return $response
+}
+
+function Invoke-SimulateUiClick {
+    param(
+        [string]$Context,
+        [double]$X,
+        [double]$Y
+    )
+
+    return Invoke-SimulateUi -Context $Context -Arguments @("--action", "Click", "--x", (Format-Coordinate $X), "--y", (Format-Coordinate $Y))
+}
+
+# simulate-mouse-ui reaches the UI Toolkit button directly and reports it, including for a click inside a
+# scrollbar, where it must report the scrollbar rather than the part inside it.
+function Test-UiClick {
+    param(
+        [pscustomobject]$ElementsOnly
+    )
+
+    [pscustomobject]$play = Get-AnnotatedElement -Response $ElementsOnly -UiSystem "UIToolkit" -Name "play"
+    [int]$before = [int](Get-ClickCount -Name "play")
+
+    [pscustomobject]$response = Invoke-SimulateUiClick -Context "simulate-mouse-ui click on play" -X $play.SimX -Y $play.SimY
+    Assert-EqualText -Actual $response.UiSystem -Expected "UIToolkit" -Context "simulate-mouse-ui click on play UiSystem"
+    Assert-EqualText -Actual $response.HitPath -Expected "UIToolkitAnnotationDemo/BackDocument#play" -Context "simulate-mouse-ui click on play HitPath"
+    Assert-EqualText -Actual $response.HitGameObjectName -Expected "play" -Context "simulate-mouse-ui click on play HitGameObjectName"
+    Assert-EqualText -Actual (Get-ClickCount -Name "play") -Expected ([string]($before + 1)) -Context "play click count after simulate-mouse-ui"
+
+    [pscustomobject]$scrollbar = @($ElementsOnly.Screenshots[0].AnnotatedElements | Where-Object { $_.UiSystem -eq "UIToolkit" -and $_.Type -eq "Scrollbar" })[0]
+    $response = Invoke-SimulateUiClick -Context "simulate-mouse-ui click on the scrollbar" -X $scrollbar.SimX -Y $scrollbar.SimY
+    Assert-EqualText -Actual $response.HitPath -Expected $scrollbar.Path -Context "simulate-mouse-ui click on the scrollbar HitPath"
+}
+
+# simulate-mouse-input reaches UI Toolkit buttons through the EventSystem's Input System UI module.
+function Test-InputClick {
+    param(
+        [pscustomobject]$ElementsOnly
+    )
+
+    [pscustomobject]$play = Get-AnnotatedElement -Response $ElementsOnly -UiSystem "UIToolkit" -Name "play"
+    [int]$before = [int](Get-ClickCount -Name "play")
 
     [pscustomobject]$response = Invoke-UloopJson -CommandArguments @(
         "simulate-mouse-input",
         "--action",
         "Click",
         "--x",
-        ([double]$play.SimX).ToString([Globalization.CultureInfo]::InvariantCulture),
+        (Format-Coordinate $play.SimX),
         "--y",
-        ([double]$play.SimY).ToString([Globalization.CultureInfo]::InvariantCulture)
+        (Format-Coordinate $play.SimY)
     )
-    Assert-Condition -Condition ($response.Success -eq $true) -Message "Click play failed: $($response.Message)"
+    Assert-Condition -Condition ($response.Success -eq $true) -Message "simulate-mouse-input click on play failed: $($response.Message)"
     Start-Sleep -Seconds 1
 
-    Assert-EqualText -Actual (Get-PlayClickCount) -Expected ([string]($before + 1)) -Context "play click count"
+    Assert-EqualText -Actual (Get-ClickCount -Name "play") -Expected ([string]($before + 1)) -Context "play click count after simulate-mouse-input"
+}
+
+# The front panel takes a click on the covered part; the uncovered annotated point reaches the button.
+function Test-CoveredClick {
+    param(
+        [pscustomobject]$ElementsOnly
+    )
+
+    [pscustomobject]$partlyCovered = Get-AnnotatedElement -Response $ElementsOnly -UiSystem "UIToolkit" -Name "partly-covered"
+    [double]$coveredX = $partlyCovered.BoundsMinX + ($partlyCovered.BoundsMaxX - $partlyCovered.BoundsMinX) * 0.3
+    [double]$coveredY = ($partlyCovered.BoundsMinY + $partlyCovered.BoundsMaxY) / 2
+    [string]$before = Get-ClickCount -Name "partly-covered"
+
+    [pscustomobject]$response = Invoke-SimulateUiClick -Context "simulate-mouse-ui click on the covered part" -X $coveredX -Y $coveredY
+    Assert-EqualText -Actual $response.HitPath -Expected "UIToolkitAnnotationDemo/FrontDocument#cover" -Context "simulate-mouse-ui click on the covered part HitPath"
+    Assert-EqualText -Actual (Get-ClickCount -Name "partly-covered") -Expected $before -Context "partly-covered click count after clicking its cover"
+
+    Invoke-SimulateUiClick -Context "simulate-mouse-ui click on partly-covered" -X $partlyCovered.SimX -Y $partlyCovered.SimY | Out-Null
+    Assert-EqualText -Actual (Get-ClickCount -Name "partly-covered") -Expected ([string]([int]$before + 1)) -Context "partly-covered click count"
+}
+
+# The disabled button is not annotated, so its layout centre in the demo (100,440 200x50) is used. The press is
+# delivered but, as with real input, the disabled button does not react.
+function Test-DisabledClick {
+    [pscustomobject]$response = Invoke-SimulateUiClick -Context "simulate-mouse-ui click on locked" -X 200 -Y 465
+    Assert-EqualText -Actual $response.HitPath -Expected "UIToolkitAnnotationDemo/BackDocument#locked" -Context "simulate-mouse-ui click on locked HitPath"
+    Assert-EqualText -Actual (Get-ClickCount -Name "locked") -Expected "0" -Context "locked click count"
+}
+
+function Test-LongPress {
+    param(
+        [pscustomobject]$ElementsOnly
+    )
+
+    [pscustomobject]$play = Get-AnnotatedElement -Response $ElementsOnly -UiSystem "UIToolkit" -Name "play"
+    [int]$before = [int](Get-ClickCount -Name "play")
+
+    Invoke-SimulateUi -Context "simulate-mouse-ui long press on play" -Arguments @(
+        "--action", "LongPress", "--duration", "0.5", "--x", (Format-Coordinate $play.SimX), "--y", (Format-Coordinate $play.SimY)) | Out-Null
+
+    Assert-EqualText -Actual (Get-ClickCount -Name "play") -Expected ([string]($before + 1)) -Context "play click count after long press"
+}
+
+# The demo does not count uGUI clicks, so a listener added in PlayMode writes the count into the button label.
+function Test-UguiClick {
+    param(
+        [pscustomobject]$ElementsOnly
+    )
+
+    [string]$listenerCode = @'
+using UnityEngine;
+using UnityEngine.UI;
+GameObject buttonObject = GameObject.Find("ugui-button");
+if (buttonObject == null) { return "ERROR: ugui-button not found"; }
+Text label = buttonObject.GetComponentInChildren<Text>();
+if (label == null) { return "ERROR: ugui-button has no Text"; }
+int clicks = 0;
+buttonObject.GetComponent<Button>().onClick.AddListener(() => { clicks++; label.text = "clicked " + clicks; });
+label.text = "clicked 0";
+return label.text;
+'@
+    Assert-EqualText -Actual (Invoke-DynamicCodeText -Code $listenerCode -Context "Add ugui-button listener") -Expected "clicked 0" -Context "ugui-button listener"
+
+    [pscustomobject]$button = Get-AnnotatedElement -Response $ElementsOnly -UiSystem "UGUI" -Name "ugui-button"
+    [pscustomobject]$response = Invoke-SimulateUiClick -Context "simulate-mouse-ui click on ugui-button" -X $button.SimX -Y $button.SimY
+    Assert-EqualText -Actual $response.UiSystem -Expected "UGUI" -Context "simulate-mouse-ui click on ugui-button UiSystem"
+
+    [string]$labelCode = @'
+using UnityEngine;
+using UnityEngine.UI;
+return GameObject.Find("ugui-button").GetComponentInChildren<Text>().text;
+'@
+    Assert-EqualText -Actual (Invoke-DynamicCodeText -Code $labelCode -Context "Read ugui-button label") -Expected "clicked 1" -Context "ugui-button label"
+}
+
+# Runs last: the EventSystem stays disabled until PlayMode stops on exit.
+function Test-ClickWithoutEventSystem {
+    param(
+        [pscustomobject]$ElementsOnly
+    )
+
+    [string]$disableCode = @'
+using UnityEngine.EventSystems;
+if (EventSystem.current == null) { return "ERROR: no EventSystem"; }
+EventSystem.current.gameObject.SetActive(false);
+return EventSystem.current == null ? "disabled" : "ERROR: still active";
+'@
+    Assert-EqualText -Actual (Invoke-DynamicCodeText -Code $disableCode -Context "Disable EventSystem") -Expected "disabled" -Context "EventSystem"
+    [pscustomobject]$play = Get-AnnotatedElement -Response $ElementsOnly -UiSystem "UIToolkit" -Name "play"
+    [int]$before = [int](Get-ClickCount -Name "play")
+
+    Invoke-SimulateUiClick -Context "simulate-mouse-ui click on play without an EventSystem" -X $play.SimX -Y $play.SimY | Out-Null
+
+    Assert-EqualText -Actual (Get-ClickCount -Name "play") -Expected ([string]($before + 1)) -Context "play click count without an EventSystem"
 }
 
 if (Test-Path -LiteralPath $TempDirectory) {
@@ -445,25 +618,43 @@ Wait-UnityReady
 [pscustomobject]$originalGameViewSize = $null
 
 try {
-    Write-Host "[1/6] Loading UI Toolkit annotation demo scene..."
+    Write-Host "[1/12] Loading UI Toolkit annotation demo scene..."
     Initialize-DemoScene
 
-    Write-Host "[2/6] Selecting Full HD Game View resolution..."
+    Write-Host "[2/12] Selecting Full HD Game View resolution..."
     $originalGameViewSize = Select-FullHdGameView
 
-    Write-Host "[3/6] Starting PlayMode and waiting for UI Toolkit controls..."
+    Write-Host "[3/12] Starting PlayMode and waiting for UI Toolkit controls..."
     Invoke-UloopJson -CommandArguments @("control-play-mode", "--action", "Play") | Out-Null
     Wait-PlayMode
     Wait-UiToolkitPlay
 
-    Write-Host "[4/6] Checking the annotated capture..."
+    Write-Host "[4/12] Checking the annotated capture..."
     [pscustomobject]$annotated = Test-AnnotatedCapture
 
-    Write-Host "[5/6] Checking the elements-only capture matches..."
-    Test-ElementsOnlyCapture -AnnotatedResponse $annotated
+    Write-Host "[5/12] Checking the elements-only capture matches..."
+    [pscustomobject]$elementsOnly = Test-ElementsOnlyCapture -AnnotatedResponse $annotated
+
+    Write-Host "[6/12] Clicking UI Toolkit controls with simulate-mouse-ui..."
+    Test-UiClick -ElementsOnly $elementsOnly
+
+    Write-Host "[7/12] Clicking a UI Toolkit button with simulate-mouse-input..."
+    Test-InputClick -ElementsOnly $elementsOnly
+
+    Write-Host "[8/12] Clicking a partly covered UI Toolkit button..."
+    Test-CoveredClick -ElementsOnly $elementsOnly
+
+    Write-Host "[9/12] Clicking a disabled UI Toolkit button..."
+    Test-DisabledClick
+
+    Write-Host "[10/12] Long-pressing a UI Toolkit button..."
+    Test-LongPress -ElementsOnly $elementsOnly
+
+    Write-Host "[11/12] Clicking the uGUI button with simulate-mouse-ui..."
+    Test-UguiClick -ElementsOnly $elementsOnly
 
-    Write-Host "[6/6] Clicking a UI Toolkit button at its annotated point..."
-    Test-Click -AnnotatedResponse $annotated
+    Write-Host "[12/12] Clicking a UI Toolkit button without an EventSystem..."
+    Test-ClickWithoutEventSystem -ElementsOnly $elementsOnly
 
     Write-Host ""
     Write-Host "========================================="
diff --git a/scripts/test-screenshot-uitoolkit-annotation.sh b/scripts/test-screenshot-uitoolkit-annotation.sh
index 3798ad3b85..6c9359e017 100755
--- a/scripts/test-screenshot-uitoolkit-annotation.sh
+++ b/scripts/test-screenshot-uitoolkit-annotation.sh
@@ -1,7 +1,8 @@
 #!/bin/sh
-# E2E verification that screenshot --annotate-elements lists UI Toolkit controls, using the uloop CLI against
+# E2E verification that screenshot --annotate-elements lists UI Toolkit controls and that simulate-mouse-ui and
+# simulate-mouse-input press them at the annotated points, using the uloop CLI against
 # UIToolkitAnnotationDemoScene. Safe to run repeatedly: it stops PlayMode and restores the Game View size on
-# exit, and never saves the scene.
+# exit, and never saves the scene, so the listener and EventSystem changes made in PlayMode are discarded.
 
 set -eu
 
@@ -276,34 +277,164 @@ verify_elements_only_capture() {
         >/dev/null || fail "Elements-only coordinates differ from the annotated capture by more than 1 pixel"
 }
 
-get_play_click_count() {
-    json=$(run_uloop_json execute-dynamic-code --code '
+get_click_count() {
+    name=$1
+    json=$(run_uloop_json execute-dynamic-code --code "
 UIToolkitAnnotationDemo demo = UnityEngine.Object.FindObjectOfType<UIToolkitAnnotationDemo>();
-if (demo == null) { return "ERROR: UIToolkitAnnotationDemo not found"; }
-return demo.GetClickCount("play");
-')
-    assert_json_success "$json" "Read play click count"
+if (demo == null) { return \"ERROR: UIToolkitAnnotationDemo not found\"; }
+return demo.GetClickCount(\"$name\");
+")
+    assert_json_success "$json" "Read $name click count"
     count=$(printf '%s\n' "$json" | jq -r '.Result')
     case "$count" in
         ERROR:*)
-            fail "Read play click count failed: ${count#ERROR: }"
+            fail "Read $name click count failed: ${count#ERROR: }"
             ;;
     esac
     printf '%s\n' "$count"
 }
 
-# simulate-mouse-input reaches UI Toolkit buttons through the EventSystem; simulate-mouse-ui does not.
-verify_click() {
-    x=$(jq -r '[.Screenshots[0].AnnotatedElements[] | select(.UiSystem == "UIToolkit" and .Name == "play")][0].SimX' "$E1_JSON")
-    y=$(jq -r '[.Screenshots[0].AnnotatedElements[] | select(.UiSystem == "UIToolkit" and .Name == "play")][0].SimY' "$E1_JSON")
-    before=$(get_play_click_count)
+# Prints a field of the first annotated element matching the jq selector.
+annotated_field() {
+    selector=$1
+    field=$2
+    jq -r "[.Screenshots[0].AnnotatedElements[] | select($selector)][0].$field" "$E2_JSON"
+}
+
+assert_response_field() {
+    json=$1
+    field=$2
+    expected=$3
+    context=$4
+    assert_text_equals "$(printf '%s\n' "$json" | jq -r ".$field")" "$expected" "$context $field"
+}
+
+# Prints the simulate-mouse-ui response after checking it succeeded.
+simulate_ui() {
+    context=$1
+    shift
+    json=$(run_uloop_json simulate-mouse-ui "$@")
+    assert_json_success "$json" "$context"
+    printf '%s\n' "$json"
+}
+
+PLAY_SELECTOR='.UiSystem == "UIToolkit" and .Name == "play"'
+
+# simulate-mouse-ui reaches the UI Toolkit button directly and reports it, including for a click inside a
+# scrollbar, where it must report the scrollbar rather than the part inside it.
+verify_ui_click() {
+    x=$(annotated_field "$PLAY_SELECTOR" SimX)
+    y=$(annotated_field "$PLAY_SELECTOR" SimY)
+    before=$(get_click_count play)
+
+    json=$(simulate_ui "simulate-mouse-ui click on play" --action Click --x "$x" --y "$y")
+    assert_response_field "$json" UiSystem "UIToolkit" "simulate-mouse-ui click on play"
+    assert_response_field "$json" HitPath "UIToolkitAnnotationDemo/BackDocument#play" "simulate-mouse-ui click on play"
+    assert_response_field "$json" HitGameObjectName "play" "simulate-mouse-ui click on play"
+    assert_text_equals "$(get_click_count play)" "$((before + 1))" "play click count after simulate-mouse-ui"
+
+    scrollbar_selector='.UiSystem == "UIToolkit" and .Type == "Scrollbar"'
+    json=$(simulate_ui "simulate-mouse-ui click on the scrollbar" --action Click \
+        --x "$(annotated_field "$scrollbar_selector" SimX)" --y "$(annotated_field "$scrollbar_selector" SimY)")
+    assert_response_field "$json" HitPath "$(annotated_field "$scrollbar_selector" Path)" "simulate-mouse-ui click on the scrollbar"
+}
+
+# simulate-mouse-input reaches UI Toolkit buttons through the EventSystem's Input System UI module.
+verify_input_click() {
+    before=$(get_click_count play)
 
-    json=$(run_uloop_json simulate-mouse-input --action Click --x "$x" --y "$y")
-    assert_json_success "$json" "Click play"
+    json=$(run_uloop_json simulate-mouse-input --action Click \
+        --x "$(annotated_field "$PLAY_SELECTOR" SimX)" --y "$(annotated_field "$PLAY_SELECTOR" SimY)")
+    assert_json_success "$json" "simulate-mouse-input click on play"
     sleep 1
 
-    after=$(get_play_click_count)
-    assert_text_equals "$after" "$((before + 1))" "play click count"
+    assert_text_equals "$(get_click_count play)" "$((before + 1))" "play click count after simulate-mouse-input"
+}
+
+# The front panel takes a click on the covered part; the uncovered annotated point reaches the button.
+verify_covered_click() {
+    selector='.UiSystem == "UIToolkit" and .Name == "partly-covered"'
+    min_x=$(annotated_field "$selector" BoundsMinX)
+    max_x=$(annotated_field "$selector" BoundsMaxX)
+    min_y=$(annotated_field "$selector" BoundsMinY)
+    max_y=$(annotated_field "$selector" BoundsMaxY)
+    covered_x=$(jq -n --argjson min "$min_x" --argjson max "$max_x" '$min + ($max - $min) * 0.3')
+    covered_y=$(jq -n --argjson min "$min_y" --argjson max "$max_y" '($min + $max) / 2')
+    before=$(get_click_count partly-covered)
+
+    json=$(simulate_ui "simulate-mouse-ui click on the covered part" --action Click --x "$covered_x" --y "$covered_y")
+    assert_response_field "$json" HitPath "UIToolkitAnnotationDemo/FrontDocument#cover" "simulate-mouse-ui click on the covered part"
+    assert_text_equals "$(get_click_count partly-covered)" "$before" "partly-covered click count after clicking its cover"
+
+    simulate_ui "simulate-mouse-ui click on partly-covered" --action Click \
+        --x "$(annotated_field "$selector" SimX)" --y "$(annotated_field "$selector" SimY)" >/dev/null
+    assert_text_equals "$(get_click_count partly-covered)" "$((before + 1))" "partly-covered click count"
+}
+
+# The disabled button is not annotated, so its layout centre in the demo (100,440 200x50) is used. The press is
+# delivered but, as with real input, the disabled button does not react.
+verify_disabled_click() {
+    json=$(simulate_ui "simulate-mouse-ui click on locked" --action Click --x 200 --y 465)
+    assert_response_field "$json" HitPath "UIToolkitAnnotationDemo/BackDocument#locked" "simulate-mouse-ui click on locked"
+    assert_text_equals "$(get_click_count locked)" "0" "locked click count"
+}
+
+verify_long_press() {
+    before=$(get_click_count play)
+
+    simulate_ui "simulate-mouse-ui long press on play" --action LongPress --duration 0.5 \
+        --x "$(annotated_field "$PLAY_SELECTOR" SimX)" --y "$(annotated_field "$PLAY_SELECTOR" SimY)" >/dev/null
+
+    assert_text_equals "$(get_click_count play)" "$((before + 1))" "play click count after long press"
+}
+
+# The demo does not count uGUI clicks, so a listener added in PlayMode writes the count into the button label.
+verify_ugui_click() {
+    json=$(run_uloop_json execute-dynamic-code --code '
+using UnityEngine;
+using UnityEngine.UI;
+GameObject buttonObject = GameObject.Find("ugui-button");
+if (buttonObject == null) { return "ERROR: ugui-button not found"; }
+Text label = buttonObject.GetComponentInChildren<Text>();
+if (label == null) { return "ERROR: ugui-button has no Text"; }
+int clicks = 0;
+buttonObject.GetComponent<Button>().onClick.AddListener(() => { clicks++; label.text = "clicked " + clicks; });
+label.text = "clicked 0";
+return label.text;
+')
+    assert_json_success "$json" "Add ugui-button listener"
+    assert_text_equals "$(printf '%s\n' "$json" | jq -r '.Result')" "clicked 0" "ugui-button listener"
+
+    selector='.UiSystem == "UGUI" and .Name == "ugui-button"'
+    json=$(simulate_ui "simulate-mouse-ui click on ugui-button" --action Click \
+        --x "$(annotated_field "$selector" SimX)" --y "$(annotated_field "$selector" SimY)")
+    assert_response_field "$json" UiSystem "UGUI" "simulate-mouse-ui click on ugui-button"
+
+    json=$(run_uloop_json execute-dynamic-code --code '
+using UnityEngine;
+using UnityEngine.UI;
+return GameObject.Find("ugui-button").GetComponentInChildren<Text>().text;
+')
+    assert_json_success "$json" "Read ugui-button label"
+    assert_text_equals "$(printf '%s\n' "$json" | jq -r '.Result')" "clicked 1" "ugui-button label"
+}
+
+# Runs last: the EventSystem stays disabled until PlayMode stops on exit.
+verify_click_without_event_system() {
+    json=$(run_uloop_json execute-dynamic-code --code '
+using UnityEngine.EventSystems;
+if (EventSystem.current == null) { return "ERROR: no EventSystem"; }
+EventSystem.current.gameObject.SetActive(false);
+return EventSystem.current == null ? "disabled" : "ERROR: still active";
+')
+    assert_json_success "$json" "Disable EventSystem"
+    assert_text_equals "$(printf '%s\n' "$json" | jq -r '.Result')" "disabled" "EventSystem"
+    before=$(get_click_count play)
+
+    simulate_ui "simulate-mouse-ui click on play without an EventSystem" --action Click \
+        --x "$(annotated_field "$PLAY_SELECTOR" SimX)" --y "$(annotated_field "$PLAY_SELECTOR" SimY)" >/dev/null
+
+    assert_text_equals "$(get_click_count play)" "$((before + 1))" "play click count without an EventSystem"
 }
 
 rm -rf "$TMP_DIR"
@@ -317,25 +448,43 @@ printf '=========================================\n'
 
 wait_unity_ready
 
-printf '[1/6] Loading UI Toolkit annotation demo scene...\n'
+printf '[1/12] Loading UI Toolkit annotation demo scene...\n'
 initialize_demo_scene
 
-printf '[2/6] Selecting Full HD Game View resolution...\n'
+printf '[2/12] Selecting Full HD Game View resolution...\n'
 select_full_hd_game_view
 
-printf '[3/6] Starting PlayMode and waiting for UI Toolkit controls...\n'
+printf '[3/12] Starting PlayMode and waiting for UI Toolkit controls...\n'
 run_uloop_json control-play-mode --action Play >/dev/null
 wait_play_mode
 wait_for_uitoolkit_play
 
-printf '[4/6] Checking the annotated capture...\n'
+printf '[4/12] Checking the annotated capture...\n'
 verify_annotated_capture
 
-printf '[5/6] Checking the elements-only capture matches...\n'
+printf '[5/12] Checking the elements-only capture matches...\n'
 verify_elements_only_capture
 
-printf '[6/6] Clicking a UI Toolkit button at its annotated point...\n'
-verify_click
+printf '[6/12] Clicking UI Toolkit controls with simulate-mouse-ui...\n'
+verify_ui_click
+
+printf '[7/12] Clicking a UI Toolkit button with simulate-mouse-input...\n'
+verify_input_click
+
+printf '[8/12] Clicking a partly covered UI Toolkit button...\n'
+verify_covered_click
+
+printf '[9/12] Clicking a disabled UI Toolkit button...\n'
+verify_disabled_click
+
+printf '[10/12] Long-pressing a UI Toolkit button...\n'
+verify_long_press
+
+printf '[11/12] Clicking the uGUI button with simulate-mouse-ui...\n'
+verify_ugui_click
+
+printf '[12/12] Clicking a UI Toolkit button without an EventSystem...\n'
+verify_click_without_event_system
 
 printf '\n'
 printf '=========================================\n'

From 929385daf12d3340224a1af41fa46fefed0d8e1a Mon Sep 17 00:00:00 2001
From: Masamichi Hatayama <booqle@gmail.com>
Date: Wed, 14 Oct 2026 02:20:51 +0900
Subject: [PATCH 5/5] feat: simulate-mouse-ui drags reach UI Toolkit sliders
 and scrollbars (#3313)

---
 .../references/annotated-elements.md          |   2 +-
 .../skills/uloop-simulate-mouse-ui/SKILL.md   |   6 +-
 .../references/output.md                      |   8 +-
 .../references/ui-toolkit.md                  |  29 +-
 .../references/annotated-elements.md          |   2 +-
 .../skills/uloop-simulate-mouse-ui/SKILL.md   |   6 +-
 .../references/output.md                      |   8 +-
 .../references/ui-toolkit.md                  |  29 +-
 Assets/Tests/Demo/UIToolkitAnnotationDemo.cs  |  10 +-
 .../Editor/MouseUiDragTargetResolverTests.cs  |  18 +-
 .../MouseUiSimulationResponseFactoryTests.cs  |  32 +-
 Assets/Tests/PlayMode/SimulateMouseUiTests.cs |  36 +
 .../SimulateMouseUiToolkitDragTests.cs        | 843 ++++++++++++++++++
 .../SimulateMouseUiToolkitDragTests.cs.meta   |  11 +
 .../PlayMode/SimulateMouseUiToolkitTests.cs   |  23 -
 Packages/src/Documentation~/tools.md          |   2 +-
 Packages/src/Documentation~/tools_ja.md       |   2 +-
 .../UIToolkit/UIToolkitPointerTarget.cs       |   3 +
 .../Skill/references/annotated-elements.md    |   2 +-
 .../Application/MouseDragState.cs             |  23 +-
 .../SimulateMouseUi/IMouseUiDragSession.cs    |  35 +
 .../IMouseUiDragSession.cs.meta               |  11 +
 .../MouseUiDragEventExecutor.cs               |  33 +-
 .../SimulateMouseUi/MouseUiDragStartTarget.cs |  70 ++
 .../MouseUiDragStartTarget.cs.meta            |  11 +
 .../MouseUiDragTargetResolver.cs              | 111 ++-
 .../MouseUiGameObjectHitReport.cs             |  26 +
 .../MouseUiGameObjectHitReport.cs.meta        |  11 +
 .../MouseUiIncrementalDragExecutor.cs         | 116 +--
 .../MouseUiOneShotDragExecutor.cs             |  38 +-
 .../MouseUiPressTargetResolver.cs             |   9 +-
 .../MouseUiSimulationResponseFactory.cs       |  20 +-
 .../SimulateMouseUiResponse.cs                |   5 +-
 .../SimulateMouseUi/SimulateMouseUiUseCase.cs |  17 +-
 .../SimulateMouseUi/Skill/SKILL.md            |   6 +-
 .../Skill/references/output.md                |   8 +-
 .../Skill/references/ui-toolkit.md            |  29 +-
 .../SimulateMouseUi/UIToolkitDragSession.cs   |  78 ++
 .../UIToolkitDragSession.cs.meta              |  11 +
 .../SimulateMouseUi/UguiDragSession.cs        |  81 ++
 .../SimulateMouseUi/UguiDragSession.cs.meta   |  11 +
 .../SimulateMouseUi/UguiPressTarget.cs        |  17 +-
 .../test-screenshot-uitoolkit-annotation.ps1  |  89 +-
 .../test-screenshot-uitoolkit-annotation.sh   |  88 +-
 44 files changed, 1733 insertions(+), 293 deletions(-)
 create mode 100644 Assets/Tests/PlayMode/SimulateMouseUiToolkitDragTests.cs
 create mode 100644 Assets/Tests/PlayMode/SimulateMouseUiToolkitDragTests.cs.meta
 create mode 100644 Packages/src/Editor/FirstPartyTools/SimulateMouseUi/IMouseUiDragSession.cs
 create mode 100644 Packages/src/Editor/FirstPartyTools/SimulateMouseUi/IMouseUiDragSession.cs.meta
 create mode 100644 Packages/src/Editor/FirstPartyTools/SimulateMouseUi/MouseUiDragStartTarget.cs
 create mode 100644 Packages/src/Editor/FirstPartyTools/SimulateMouseUi/MouseUiDragStartTarget.cs.meta
 create mode 100644 Packages/src/Editor/FirstPartyTools/SimulateMouseUi/MouseUiGameObjectHitReport.cs
 create mode 100644 Packages/src/Editor/FirstPartyTools/SimulateMouseUi/MouseUiGameObjectHitReport.cs.meta
 create mode 100644 Packages/src/Editor/FirstPartyTools/SimulateMouseUi/UIToolkitDragSession.cs
 create mode 100644 Packages/src/Editor/FirstPartyTools/SimulateMouseUi/UIToolkitDragSession.cs.meta
 create mode 100644 Packages/src/Editor/FirstPartyTools/SimulateMouseUi/UguiDragSession.cs
 create mode 100644 Packages/src/Editor/FirstPartyTools/SimulateMouseUi/UguiDragSession.cs.meta

diff --git a/.agents/skills/uloop-screenshot/references/annotated-elements.md b/.agents/skills/uloop-screenshot/references/annotated-elements.md
index 69466c0964..69272a2bb2 100644
--- a/.agents/skills/uloop-screenshot/references/annotated-elements.md
+++ b/.agents/skills/uloop-screenshot/references/annotated-elements.md
@@ -53,7 +53,7 @@ Limits:
 
 Clicking:
 
-- `simulate-mouse-ui --action Click --x <SimX> --y <SimY>` (or `LongPress`) reaches UI Toolkit controls, with or without an EventSystem. Its `--target-path` does not accept UI Toolkit `Path` values.
+- `simulate-mouse-ui --action Click --x <SimX> --y <SimY>` (or `LongPress`, or a drag from that point) reaches UI Toolkit controls, with or without an EventSystem. Its `--target-path` does not accept UI Toolkit `Path` values.
 - `simulate-mouse-input --action Click --x <SimX> --y <SimY>` also reaches them when the scene has an EventSystem with an Input System UI input module.
 - Without an EventSystem the `simulate-mouse-input` click does not reach UI Toolkit controls.
 
diff --git a/.agents/skills/uloop-simulate-mouse-ui/SKILL.md b/.agents/skills/uloop-simulate-mouse-ui/SKILL.md
index 0be9c8c4fb..3d67862bbd 100644
--- a/.agents/skills/uloop-simulate-mouse-ui/SKILL.md
+++ b/.agents/skills/uloop-simulate-mouse-ui/SKILL.md
@@ -64,7 +64,7 @@ uloop simulate-mouse-ui --action <action> --x <x> --y <y> [options]
 - Get coordinates from `AnnotatedElements` JSON (`SimX`/`SimY`) — do NOT look up GameObject positions
 - `--bypass-raycast` still uses coordinates for pointer event positions, but chooses the clicked, long-pressed, or dragged GameObject by `--target-path`
 - If `--target-path` or `--drop-target-path` matches multiple active GameObjects, the command fails instead of choosing an arbitrary duplicate
-- UI Toolkit entries (`UiSystem` `UIToolkit`) can be clicked and long-pressed at `SimX`/`SimY`; `--bypass-raycast`, `--target-path`, and `--drop-target-path` take GameObjects only. Details: `references/ui-toolkit.md`.
+- UI Toolkit entries (`UiSystem` `UIToolkit`) can be clicked, long-pressed, and dragged at `SimX`/`SimY`; `--bypass-raycast`, `--target-path`, and `--drop-target-path` take GameObjects only. Details: `references/ui-toolkit.md`.
 - Device Simulator play view is supported. Prefer `uloop screenshot --capture-mode rendering --annotate-elements` for coordinates; they use the simulated device resolution (`Handles.GetMainGameViewSize()` / `Screen`), not the Simulator chrome scale.
 
 ## Pause Point Inspection (Standard for E2E)
@@ -86,8 +86,8 @@ uloop simulate-mouse-ui --action Drag --from-x 400 --from-y 300 --x 600 --y 300
 # Long-press a button for 3 seconds
 uloop simulate-mouse-ui --action LongPress --x 400 --y 300 --duration 3.0
 
-# Slow drag for visual inspection
-uloop simulate-mouse-ui --action Drag --from-x 400 --from-y 300 --x 600 --y 300 --drag-speed 200
+# One-shot drag (add --drag-speed 200 to slow it for visual inspection)
+uloop simulate-mouse-ui --action Drag --from-x 400 --from-y 300 --x 600 --y 300
 
 # Split drag with hold (for inspection between steps)
 uloop simulate-mouse-ui --action DragStart --x 400 --y 300
diff --git a/.agents/skills/uloop-simulate-mouse-ui/references/output.md b/.agents/skills/uloop-simulate-mouse-ui/references/output.md
index af20d8c00b..03086035fa 100644
--- a/.agents/skills/uloop-simulate-mouse-ui/references/output.md
+++ b/.agents/skills/uloop-simulate-mouse-ui/references/output.md
@@ -5,9 +5,9 @@ Returns JSON with:
 - `Success`: Whether the operation succeeded
 - `Message`: Status message (e.g. "Hit element: ButtonStart" or "No UI element under (x, y)")
 - `Action`: Echoes which action was executed (`Click`, `Drag`, `DragStart`, `DragMove`, `DragEnd`, or `LongPress`)
-- `HitGameObjectName`: Name of the GameObject that received the pointer events (nullable string; null if nothing was hit). It is the event-handler target resolved up the hierarchy from the raycast hit (the first `IPointerDownHandler`, else the first `IPointerClickHandler`, for `Click`/`LongPress`; the first `IDragHandler` for drags), so it can be an ancestor of the topmost raycast hit — a Button's child Text reports the Button. With `--bypass-raycast` it is the handler resolved the same way from `--target-path` (also possibly an ancestor), not the raycast hit and not necessarily the raw path GameObject itself. For a UI Toolkit hit it is the control's `name`, the same as the annotation's `Name`
-- `UiSystem`: Which UI system received the press (nullable string; `Click`/`LongPress` only, null if nothing was hit): `UGUI` for a target under a Canvas, `UIToolkit` for a UI Toolkit control, and `""` for a non-UI target such as a physics object
-- `HitPath`: Path of the hit target in the form `AnnotatedElements[].Path` uses (nullable string; `Click`/`LongPress` only): a hierarchy path for GameObjects, `Document/Path#element` for UI Toolkit controls
+- `HitGameObjectName`: Name of the GameObject that received the pointer events (nullable string; null if nothing was hit). It is the event-handler target resolved up the hierarchy from the raycast hit (the first `IPointerDownHandler`, else the first `IPointerClickHandler`, for `Click`/`LongPress`; the first `IDragHandler` for drags), so it can be an ancestor of the topmost raycast hit — a Button's child Text reports the Button. With `--bypass-raycast` it is the handler resolved the same way from `--target-path` (also possibly an ancestor), not the raycast hit and not necessarily the raw path GameObject itself. For a UI Toolkit hit it is the name of the outermost control an annotation would list (the same as the annotation's `Name`); when the picked element is not inside such a control (a bare `Label` or `VisualElement`), it is that element's own `name`, or its type name when empty, and the element is not annotated. Unlike uGUI, which reports null when no handler is found, UI Toolkit reports the picked element whether or not it handles pointer events
+- `UiSystem`: Which UI system received the press (nullable string; `Click`/`LongPress` and drags, null if nothing was hit): `UGUI` for a target under a Canvas, `UIToolkit` for a UI Toolkit control, and `""` for a non-UI target such as a physics object
+- `HitPath`: Path of the hit target in the form `AnnotatedElements[].Path` uses (nullable string; `Click`/`LongPress` and drags): a hierarchy path for GameObjects, `Document/Path#element` for UI Toolkit controls. Null when nothing was hit, or when the hit element belongs to no document, such as the menu of an open dropdown
 - `PositionX`: Target X coordinate that was used
 - `PositionY`: Target Y coordinate that was used
 - `EndPositionX`: Drag end X coordinate (nullable float; populated for drag actions only)
@@ -20,4 +20,4 @@ Note: Click and LongPress on empty space (no UI element) still return `Success =
 
 ## UI Toolkit Elements
 
-`Click` and `LongPress` reach UI Toolkit controls at their annotated `SimX`/`SimY`. How presses are delivered and what is not supported: `ui-toolkit.md`.
+`Click`, `LongPress`, and the drag actions reach UI Toolkit controls at their annotated `SimX`/`SimY` (`--from-x`/`--from-y` for `Drag`). How presses and drags are delivered and what is not supported: `ui-toolkit.md`.
diff --git a/.agents/skills/uloop-simulate-mouse-ui/references/ui-toolkit.md b/.agents/skills/uloop-simulate-mouse-ui/references/ui-toolkit.md
index ec3bb79d44..373a3deee1 100644
--- a/.agents/skills/uloop-simulate-mouse-ui/references/ui-toolkit.md
+++ b/.agents/skills/uloop-simulate-mouse-ui/references/ui-toolkit.md
@@ -1,9 +1,9 @@
 # simulate-mouse-ui and UI Toolkit
 
-`Click` and `LongPress` reach UI Toolkit controls on screen-space panels — the
-`AnnotatedElements` entries with `UiSystem` `UIToolkit`. Pass the entry's `SimX`/`SimY` as
-`--x`/`--y`; the response reports `UiSystem` `UIToolkit`, the control's `Name` as
-`HitGameObjectName`, and its annotation `Path` as `HitPath`.
+`Click`, `LongPress`, and the drag actions reach UI Toolkit controls on screen-space panels —
+the `AnnotatedElements` entries with `UiSystem` `UIToolkit`. Pass the entry's `SimX`/`SimY` as
+`--x`/`--y` (`--from-x`/`--from-y` for `Drag`); the response reports `UiSystem` `UIToolkit`, the
+control's `Name` as `HitGameObjectName`, and its annotation `Path` as `HitPath`.
 
 ## How a press is delivered
 
@@ -29,18 +29,33 @@ A UI Toolkit `Button` fires `clicked` once when the long press is released (UI T
 `Clickable` behaviour); a uGUI long press sends no click. A `RepeatButton` fires repeatedly
 while held.
 
+## Drags
+
+- A drag whose start point resolves to a UI Toolkit control (by the rule above) presses it
+  with the left button, moves the pointer, and releases at the end, so a `Slider` or a
+  `Scroller` follows the drag. The start point is what counts: the drag stays with that panel
+  wherever it moves.
+- A labelled slider's bounds include its label; start the drag on the track.
+- `--drop-target-path` applies to uGUI drags only. A `Drag` with it fails before anything is
+  sent; a `DragEnd` with it fails and leaves the drag in progress, so call `DragEnd` again
+  without it.
+- If the control's document is disabled or destroyed during a split drag, the next `DragMove`
+  or `DragEnd` fails and the drag ends. A one-shot `Drag` stops sending and still succeeds.
+- If a UI Toolkit handler throws, the button is released and the exception ends the command.
+  A `DragMove` that throws leaves the drag in progress, as a cancelled `DragMove` does.
+
 ## Not supported
 
 - `--bypass-raycast`, `--target-path`, and `--drop-target-path` take GameObject paths only;
   a UI Toolkit `Path` (it contains `#`) is reported as not found.
-- Drag actions go through the uGUI EventSystem only.
 - World-space panels (Unity 6), as in the annotation.
 - Two panels with the same `sortingOrder` overlapping at the point: Unity orders them by
   creation order, which is not exposed, so either one may be chosen.
 
 ## Notes
 
-- Move the real mouse cursor out of the Game View while simulating. Real pointer input over
-  the Game View reaches the same panels and can interleave with the simulated press.
+- Move the real mouse cursor out of the Game View while simulating, and keep it away between
+  `DragStart` and `DragEnd`. Real pointer input over the Game View reaches the same panels and
+  can interleave with the simulated press or move a held slider.
 - Device Simulator has the same limits as the annotation: coordinates use the simulated device
   resolution.
diff --git a/.claude/skills/uloop-screenshot/references/annotated-elements.md b/.claude/skills/uloop-screenshot/references/annotated-elements.md
index 69466c0964..69272a2bb2 100644
--- a/.claude/skills/uloop-screenshot/references/annotated-elements.md
+++ b/.claude/skills/uloop-screenshot/references/annotated-elements.md
@@ -53,7 +53,7 @@ Limits:
 
 Clicking:
 
-- `simulate-mouse-ui --action Click --x <SimX> --y <SimY>` (or `LongPress`) reaches UI Toolkit controls, with or without an EventSystem. Its `--target-path` does not accept UI Toolkit `Path` values.
+- `simulate-mouse-ui --action Click --x <SimX> --y <SimY>` (or `LongPress`, or a drag from that point) reaches UI Toolkit controls, with or without an EventSystem. Its `--target-path` does not accept UI Toolkit `Path` values.
 - `simulate-mouse-input --action Click --x <SimX> --y <SimY>` also reaches them when the scene has an EventSystem with an Input System UI input module.
 - Without an EventSystem the `simulate-mouse-input` click does not reach UI Toolkit controls.
 
diff --git a/.claude/skills/uloop-simulate-mouse-ui/SKILL.md b/.claude/skills/uloop-simulate-mouse-ui/SKILL.md
index 0be9c8c4fb..3d67862bbd 100644
--- a/.claude/skills/uloop-simulate-mouse-ui/SKILL.md
+++ b/.claude/skills/uloop-simulate-mouse-ui/SKILL.md
@@ -64,7 +64,7 @@ uloop simulate-mouse-ui --action <action> --x <x> --y <y> [options]
 - Get coordinates from `AnnotatedElements` JSON (`SimX`/`SimY`) — do NOT look up GameObject positions
 - `--bypass-raycast` still uses coordinates for pointer event positions, but chooses the clicked, long-pressed, or dragged GameObject by `--target-path`
 - If `--target-path` or `--drop-target-path` matches multiple active GameObjects, the command fails instead of choosing an arbitrary duplicate
-- UI Toolkit entries (`UiSystem` `UIToolkit`) can be clicked and long-pressed at `SimX`/`SimY`; `--bypass-raycast`, `--target-path`, and `--drop-target-path` take GameObjects only. Details: `references/ui-toolkit.md`.
+- UI Toolkit entries (`UiSystem` `UIToolkit`) can be clicked, long-pressed, and dragged at `SimX`/`SimY`; `--bypass-raycast`, `--target-path`, and `--drop-target-path` take GameObjects only. Details: `references/ui-toolkit.md`.
 - Device Simulator play view is supported. Prefer `uloop screenshot --capture-mode rendering --annotate-elements` for coordinates; they use the simulated device resolution (`Handles.GetMainGameViewSize()` / `Screen`), not the Simulator chrome scale.
 
 ## Pause Point Inspection (Standard for E2E)
@@ -86,8 +86,8 @@ uloop simulate-mouse-ui --action Drag --from-x 400 --from-y 300 --x 600 --y 300
 # Long-press a button for 3 seconds
 uloop simulate-mouse-ui --action LongPress --x 400 --y 300 --duration 3.0
 
-# Slow drag for visual inspection
-uloop simulate-mouse-ui --action Drag --from-x 400 --from-y 300 --x 600 --y 300 --drag-speed 200
+# One-shot drag (add --drag-speed 200 to slow it for visual inspection)
+uloop simulate-mouse-ui --action Drag --from-x 400 --from-y 300 --x 600 --y 300
 
 # Split drag with hold (for inspection between steps)
 uloop simulate-mouse-ui --action DragStart --x 400 --y 300
diff --git a/.claude/skills/uloop-simulate-mouse-ui/references/output.md b/.claude/skills/uloop-simulate-mouse-ui/references/output.md
index af20d8c00b..03086035fa 100644
--- a/.claude/skills/uloop-simulate-mouse-ui/references/output.md
+++ b/.claude/skills/uloop-simulate-mouse-ui/references/output.md
@@ -5,9 +5,9 @@ Returns JSON with:
 - `Success`: Whether the operation succeeded
 - `Message`: Status message (e.g. "Hit element: ButtonStart" or "No UI element under (x, y)")
 - `Action`: Echoes which action was executed (`Click`, `Drag`, `DragStart`, `DragMove`, `DragEnd`, or `LongPress`)
-- `HitGameObjectName`: Name of the GameObject that received the pointer events (nullable string; null if nothing was hit). It is the event-handler target resolved up the hierarchy from the raycast hit (the first `IPointerDownHandler`, else the first `IPointerClickHandler`, for `Click`/`LongPress`; the first `IDragHandler` for drags), so it can be an ancestor of the topmost raycast hit — a Button's child Text reports the Button. With `--bypass-raycast` it is the handler resolved the same way from `--target-path` (also possibly an ancestor), not the raycast hit and not necessarily the raw path GameObject itself. For a UI Toolkit hit it is the control's `name`, the same as the annotation's `Name`
-- `UiSystem`: Which UI system received the press (nullable string; `Click`/`LongPress` only, null if nothing was hit): `UGUI` for a target under a Canvas, `UIToolkit` for a UI Toolkit control, and `""` for a non-UI target such as a physics object
-- `HitPath`: Path of the hit target in the form `AnnotatedElements[].Path` uses (nullable string; `Click`/`LongPress` only): a hierarchy path for GameObjects, `Document/Path#element` for UI Toolkit controls
+- `HitGameObjectName`: Name of the GameObject that received the pointer events (nullable string; null if nothing was hit). It is the event-handler target resolved up the hierarchy from the raycast hit (the first `IPointerDownHandler`, else the first `IPointerClickHandler`, for `Click`/`LongPress`; the first `IDragHandler` for drags), so it can be an ancestor of the topmost raycast hit — a Button's child Text reports the Button. With `--bypass-raycast` it is the handler resolved the same way from `--target-path` (also possibly an ancestor), not the raycast hit and not necessarily the raw path GameObject itself. For a UI Toolkit hit it is the name of the outermost control an annotation would list (the same as the annotation's `Name`); when the picked element is not inside such a control (a bare `Label` or `VisualElement`), it is that element's own `name`, or its type name when empty, and the element is not annotated. Unlike uGUI, which reports null when no handler is found, UI Toolkit reports the picked element whether or not it handles pointer events
+- `UiSystem`: Which UI system received the press (nullable string; `Click`/`LongPress` and drags, null if nothing was hit): `UGUI` for a target under a Canvas, `UIToolkit` for a UI Toolkit control, and `""` for a non-UI target such as a physics object
+- `HitPath`: Path of the hit target in the form `AnnotatedElements[].Path` uses (nullable string; `Click`/`LongPress` and drags): a hierarchy path for GameObjects, `Document/Path#element` for UI Toolkit controls. Null when nothing was hit, or when the hit element belongs to no document, such as the menu of an open dropdown
 - `PositionX`: Target X coordinate that was used
 - `PositionY`: Target Y coordinate that was used
 - `EndPositionX`: Drag end X coordinate (nullable float; populated for drag actions only)
@@ -20,4 +20,4 @@ Note: Click and LongPress on empty space (no UI element) still return `Success =
 
 ## UI Toolkit Elements
 
-`Click` and `LongPress` reach UI Toolkit controls at their annotated `SimX`/`SimY`. How presses are delivered and what is not supported: `ui-toolkit.md`.
+`Click`, `LongPress`, and the drag actions reach UI Toolkit controls at their annotated `SimX`/`SimY` (`--from-x`/`--from-y` for `Drag`). How presses and drags are delivered and what is not supported: `ui-toolkit.md`.
diff --git a/.claude/skills/uloop-simulate-mouse-ui/references/ui-toolkit.md b/.claude/skills/uloop-simulate-mouse-ui/references/ui-toolkit.md
index ec3bb79d44..373a3deee1 100644
--- a/.claude/skills/uloop-simulate-mouse-ui/references/ui-toolkit.md
+++ b/.claude/skills/uloop-simulate-mouse-ui/references/ui-toolkit.md
@@ -1,9 +1,9 @@
 # simulate-mouse-ui and UI Toolkit
 
-`Click` and `LongPress` reach UI Toolkit controls on screen-space panels — the
-`AnnotatedElements` entries with `UiSystem` `UIToolkit`. Pass the entry's `SimX`/`SimY` as
-`--x`/`--y`; the response reports `UiSystem` `UIToolkit`, the control's `Name` as
-`HitGameObjectName`, and its annotation `Path` as `HitPath`.
+`Click`, `LongPress`, and the drag actions reach UI Toolkit controls on screen-space panels —
+the `AnnotatedElements` entries with `UiSystem` `UIToolkit`. Pass the entry's `SimX`/`SimY` as
+`--x`/`--y` (`--from-x`/`--from-y` for `Drag`); the response reports `UiSystem` `UIToolkit`, the
+control's `Name` as `HitGameObjectName`, and its annotation `Path` as `HitPath`.
 
 ## How a press is delivered
 
@@ -29,18 +29,33 @@ A UI Toolkit `Button` fires `clicked` once when the long press is released (UI T
 `Clickable` behaviour); a uGUI long press sends no click. A `RepeatButton` fires repeatedly
 while held.
 
+## Drags
+
+- A drag whose start point resolves to a UI Toolkit control (by the rule above) presses it
+  with the left button, moves the pointer, and releases at the end, so a `Slider` or a
+  `Scroller` follows the drag. The start point is what counts: the drag stays with that panel
+  wherever it moves.
+- A labelled slider's bounds include its label; start the drag on the track.
+- `--drop-target-path` applies to uGUI drags only. A `Drag` with it fails before anything is
+  sent; a `DragEnd` with it fails and leaves the drag in progress, so call `DragEnd` again
+  without it.
+- If the control's document is disabled or destroyed during a split drag, the next `DragMove`
+  or `DragEnd` fails and the drag ends. A one-shot `Drag` stops sending and still succeeds.
+- If a UI Toolkit handler throws, the button is released and the exception ends the command.
+  A `DragMove` that throws leaves the drag in progress, as a cancelled `DragMove` does.
+
 ## Not supported
 
 - `--bypass-raycast`, `--target-path`, and `--drop-target-path` take GameObject paths only;
   a UI Toolkit `Path` (it contains `#`) is reported as not found.
-- Drag actions go through the uGUI EventSystem only.
 - World-space panels (Unity 6), as in the annotation.
 - Two panels with the same `sortingOrder` overlapping at the point: Unity orders them by
   creation order, which is not exposed, so either one may be chosen.
 
 ## Notes
 
-- Move the real mouse cursor out of the Game View while simulating. Real pointer input over
-  the Game View reaches the same panels and can interleave with the simulated press.
+- Move the real mouse cursor out of the Game View while simulating, and keep it away between
+  `DragStart` and `DragEnd`. Real pointer input over the Game View reaches the same panels and
+  can interleave with the simulated press or move a held slider.
 - Device Simulator has the same limits as the annotation: coordinates use the simulated device
   resolution.
diff --git a/Assets/Tests/Demo/UIToolkitAnnotationDemo.cs b/Assets/Tests/Demo/UIToolkitAnnotationDemo.cs
index 78a82557e3..097387a995 100644
--- a/Assets/Tests/Demo/UIToolkitAnnotationDemo.cs
+++ b/Assets/Tests/Demo/UIToolkitAnnotationDemo.cs
@@ -21,6 +21,13 @@ public int GetClickCount(string elementName)
             return _clickCounts.TryGetValue(elementName, out int count) ? count : 0;
         }
 
+        // NaN when the back panel has no slider by that name, so a missing control cannot pass as a value.
+        public float GetSliderValue(string elementName)
+        {
+            Slider? slider = backDocument.rootVisualElement?.Q<Slider>(elementName);
+            return slider != null ? slider.value : float.NaN;
+        }
+
         // Start runs after every Awake and OnEnable, so both documents have created their roots by now
         // regardless of component order.
         private void Start()
@@ -33,7 +40,8 @@ private void BuildBackPanel(VisualElement root)
         {
             AddPlaced(root, CreateCountingButton("play"), 100f, 100f, 200f, 50f);
             AddPlaced(root, new Toggle("Sound") { name = "sound" }, 100f, 180f, 200f, 30f);
-            AddPlaced(root, new Slider("Volume", 0f, 1f) { name = "volume" }, 100f, 240f, 300f, 30f);
+            // No label, so the slider's bounds are its track and the E2E can drag between its edges.
+            AddPlaced(root, new Slider(0f, 1f) { name = "volume" }, 100f, 240f, 300f, 30f);
             AddPlaced(root, new TextField("Player") { name = "player-name" }, 100f, 300f, 300f, 40f);
             DropdownField quality = new DropdownField(
                 "Quality", new List<string> { "Low", "Medium", "High" }, 1) { name = "quality" };
diff --git a/Assets/Tests/Editor/MouseUiDragTargetResolverTests.cs b/Assets/Tests/Editor/MouseUiDragTargetResolverTests.cs
index 104754fb03..53081d07fc 100644
--- a/Assets/Tests/Editor/MouseUiDragTargetResolverTests.cs
+++ b/Assets/Tests/Editor/MouseUiDragTargetResolverTests.cs
@@ -47,7 +47,7 @@ public void Resolve_WithBypassPathBelowDragHandler_ReturnsHandlerAndRawRaycast()
                 GameObjectPathUtility.GetFullPath(rawTarget));
             Vector2 position = new(10f, 20f);
 
-            (RaycastResult startRaycast, GameObject? target, SimulateMouseUiResponse? failureResponse) =
+            (MouseUiDragStartTarget start, SimulateMouseUiResponse? failureResponse) =
                 MouseUiDragTargetResolver.Resolve(
                     command,
                     eventSystem,
@@ -55,8 +55,8 @@ public void Resolve_WithBypassPathBelowDragHandler_ReturnsHandlerAndRawRaycast()
                     position,
                     position);
 
-            Assert.That(startRaycast.gameObject, Is.SameAs(rawTarget));
-            Assert.That(target, Is.SameAs(expectedTarget));
+            Assert.That(start.StartRaycast.gameObject, Is.SameAs(rawTarget));
+            Assert.That(start.UguiTarget, Is.SameAs(expectedTarget));
             Assert.That(failureResponse, Is.Null);
         }
 
@@ -73,7 +73,7 @@ public void Resolve_WithBypassPathWithoutDragHandler_ReturnsRawRaycastWithoutFai
                 GameObjectPathUtility.GetFullPath(rawTarget));
             Vector2 position = new(30f, 40f);
 
-            (RaycastResult startRaycast, GameObject? target, SimulateMouseUiResponse? failureResponse) =
+            (MouseUiDragStartTarget start, SimulateMouseUiResponse? failureResponse) =
                 MouseUiDragTargetResolver.Resolve(
                     command,
                     eventSystem,
@@ -81,8 +81,8 @@ public void Resolve_WithBypassPathWithoutDragHandler_ReturnsRawRaycastWithoutFai
                     position,
                     position);
 
-            Assert.That(startRaycast.gameObject, Is.SameAs(rawTarget));
-            Assert.That(target, Is.Null);
+            Assert.That(start.StartRaycast.gameObject, Is.SameAs(rawTarget));
+            Assert.That(start.UguiTarget, Is.Null);
             Assert.That(failureResponse, Is.Null);
         }
 
@@ -99,7 +99,7 @@ public void Resolve_WithMissingBypassPath_ReturnsPathFailure()
                 targetPath);
             Vector2 position = new(50f, 60f);
 
-            (RaycastResult startRaycast, GameObject? target, SimulateMouseUiResponse? failureResponse) =
+            (MouseUiDragStartTarget start, SimulateMouseUiResponse? failureResponse) =
                 MouseUiDragTargetResolver.Resolve(
                     command,
                     eventSystem,
@@ -107,8 +107,8 @@ public void Resolve_WithMissingBypassPath_ReturnsPathFailure()
                     position,
                     position);
 
-            Assert.That(startRaycast.gameObject, Is.Null);
-            Assert.That(target, Is.Null);
+            Assert.That(start.StartRaycast.gameObject, Is.Null);
+            Assert.That(start.UguiTarget, Is.Null);
             Assert.That(failureResponse, Is.Not.Null);
             Assert.That(failureResponse!.Message, Is.EqualTo($"TargetPath '{targetPath}' was not found."));
             Assert.That(failureResponse.Action, Is.EqualTo(MouseAction.DragStart.ToString()));
diff --git a/Assets/Tests/Editor/MouseUiSimulationResponseFactoryTests.cs b/Assets/Tests/Editor/MouseUiSimulationResponseFactoryTests.cs
index f09de75b6b..22f357e89f 100644
--- a/Assets/Tests/Editor/MouseUiSimulationResponseFactoryTests.cs
+++ b/Assets/Tests/Editor/MouseUiSimulationResponseFactoryTests.cs
@@ -216,12 +216,14 @@ public void CreateDragResult_WithBypassMode_MapsMessageAndFields(
                 command,
                 startPosition,
                 endPosition,
-                "DragTarget");
+                new MouseUiHitReport("DragTarget", "Canvas/DragTarget", "UGUI"));
 
             Assert.That(response.Success, Is.True);
             Assert.That(response.Message, Is.EqualTo(expectedMessage));
             Assert.That(response.Action, Is.EqualTo(MouseAction.Drag.ToString()));
             Assert.That(response.HitGameObjectName, Is.EqualTo("DragTarget"));
+            Assert.That(response.UiSystem, Is.EqualTo("UGUI"));
+            Assert.That(response.HitPath, Is.EqualTo("Canvas/DragTarget"));
             Assert.That(response.PositionX, Is.EqualTo(startPosition.x));
             Assert.That(response.PositionY, Is.EqualTo(startPosition.y));
             Assert.That(response.EndPositionX, Is.EqualTo(endPosition.x));
@@ -244,18 +246,44 @@ public void CreateDragEndResult_WithFinalPosition_MapsMessageAndFields()
             SimulateMouseUiResponse response = MouseUiSimulationResponseFactory.CreateDragEndResult(
                 command,
                 endPosition,
-                "DragTarget");
+                new MouseUiHitReport("DragTarget", "Canvas/DragTarget", "UGUI"));
 
             Assert.That(response.Success, Is.True);
             Assert.That(
                 response.Message,
                 Is.EqualTo("Drag ended on 'DragTarget' at (30.5, 40.3) at 125 px/s"));
+            Assert.That(response.UiSystem, Is.EqualTo("UGUI"));
+            Assert.That(response.HitPath, Is.EqualTo("Canvas/DragTarget"));
             Assert.That(response.Action, Is.EqualTo(MouseAction.DragEnd.ToString()));
             Assert.That(response.HitGameObjectName, Is.EqualTo("DragTarget"));
             Assert.That(response.PositionX, Is.EqualTo(endPosition.x));
             Assert.That(response.PositionY, Is.EqualTo(endPosition.y));
         }
 
+        /// <summary>
+        /// Verifies drag results name a UI Toolkit start element as such and carry its UI system and path.
+        /// </summary>
+        [Test]
+        public void CreateDragResults_WithUIToolkitHit_NameUIToolkitElement()
+        {
+            MouseUiHitReport hit = new MouseUiHitReport("volume", "Menu/Document#volume", "UIToolkit");
+            Vector2 start = new(100f, 200f);
+            Vector2 end = new(300f, 200f);
+
+            SimulateMouseUiResponse drag = MouseUiSimulationResponseFactory.CreateDragResult(
+                CreateCommand(new SimulateMouseUiSchema { Action = UnityCliLoopMouseUiAction.Drag, DragSpeed = 100f }), start, end, hit);
+            SimulateMouseUiResponse dragEnd = MouseUiSimulationResponseFactory.CreateDragEndResult(
+                CreateCommand(new SimulateMouseUiSchema { Action = UnityCliLoopMouseUiAction.DragEnd, DragSpeed = 100f }), end, hit);
+
+            Assert.That(drag.Message, Is.EqualTo("Dragged UI Toolkit element 'volume' from (100.0, 200.0) to (300.0, 200.0) at 100 px/s"));
+            Assert.That(dragEnd.Message, Is.EqualTo("Drag ended on UI Toolkit element 'volume' at (300.0, 200.0) at 100 px/s"));
+            foreach (SimulateMouseUiResponse response in new[] { drag, dragEnd })
+            {
+                Assert.That(response.UiSystem, Is.EqualTo("UIToolkit"));
+                Assert.That(response.HitPath, Is.EqualTo("Menu/Document#volume"));
+            }
+        }
+
         private static MouseUiSimulationCommand CreateCommand(SimulateMouseUiSchema schema)
         {
             (MouseUiSimulationCommand? command, string? errorMessage) =
diff --git a/Assets/Tests/PlayMode/SimulateMouseUiTests.cs b/Assets/Tests/PlayMode/SimulateMouseUiTests.cs
index 2e4cb79f46..33ae6c3623 100644
--- a/Assets/Tests/PlayMode/SimulateMouseUiTests.cs
+++ b/Assets/Tests/PlayMode/SimulateMouseUiTests.cs
@@ -862,6 +862,42 @@ public IEnumerator DragSplit_Should_CompleteFullCycle()
             Assert.IsTrue(tracker.EndDragCalled, "EndDrag should be fired");
         }
 
+        /// <summary>
+        /// Verifies a split drag whose uGUI target was destroyed counts as ended: DragMove reports no drag, and
+        /// neither a click nor a new DragStart is refused as overlapping an active drag.
+        /// </summary>
+        [UnityTest]
+        public IEnumerator SplitDrag_WhenUguiTargetDestroyed_TreatsDragAsEnded()
+        {
+            ClickTracker clickTracker = CreateClickableElement("ClickTarget", new Vector2(0, 150), new Vector2(200, 80));
+            yield return StartDragOnNewElement();
+
+            Object.Destroy(lastDragTracker.gameObject);
+            yield return null;
+
+            yield return RunTool(new JObject
+            {
+                ["action"] = MouseAction.DragMove.ToString(),
+                ["x"] = lastDragScreenPos.x + 50f,
+                ["y"] = lastDragScreenPos.y
+            });
+            Assert.IsFalse(lastResponse.Success);
+            Assert.AreEqual("No drag in progress. Call DragStart first.", lastResponse.Message);
+
+            Vector2 clickPos = ScreenToInput(GetScreenPosition(clickTracker.gameObject));
+            yield return RunTool(new JObject
+            {
+                ["action"] = MouseAction.Click.ToString(),
+                ["x"] = clickPos.x,
+                ["y"] = clickPos.y
+            });
+            Assert.IsTrue(lastResponse.Success, lastResponse.Message);
+            Assert.IsTrue(clickTracker.PointerClickCalled, "the click must reach its target");
+
+            yield return StartDragOnNewElement();
+            Assert.AreEqual("DragTarget", lastResponse.HitGameObjectName);
+        }
+
         [UnityTest]
         public IEnumerator DragStart_WhenAlreadyDragging_Should_ReturnFailure()
         {
diff --git a/Assets/Tests/PlayMode/SimulateMouseUiToolkitDragTests.cs b/Assets/Tests/PlayMode/SimulateMouseUiToolkitDragTests.cs
new file mode 100644
index 0000000000..bc7499dc7a
--- /dev/null
+++ b/Assets/Tests/PlayMode/SimulateMouseUiToolkitDragTests.cs
@@ -0,0 +1,843 @@
+#nullable enable
+using System.Collections;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using io.github.hatayama.UnityCliLoop.FirstPartyTools;
+using io.github.hatayama.UnityCliLoop.Runtime;
+using io.github.hatayama.UnityCliLoop.ToolContracts;
+using Newtonsoft.Json.Linq;
+using NUnit.Framework;
+using UnityEditor;
+using UnityEngine;
+using UnityEngine.EventSystems;
+using UnityEngine.TestTools;
+using UnityEngine.UI;
+using UnityEngine.UIElements;
+
+using Image = UnityEngine.UI.Image;
+using Slider = UnityEngine.UIElements.Slider;
+using UIToolkitButton = UnityEngine.UIElements.Button;
+
+namespace io.github.hatayama.UnityCliLoop.Tests.PlayMode
+{
+    /// <summary>
+    /// Verifies simulate-mouse-ui drags reach UI Toolkit controls in one shot and split into steps, work without
+    /// an EventSystem for UI Toolkit, refuse drop targets on UI Toolkit, and release the pointer on every exit.
+    /// The UI Toolkit control sits at the centre of the Game View. Each test decides whether an EventSystem
+    /// exists.
+    /// </summary>
+    public sealed class SimulateMouseUiToolkitDragTests
+    {
+        private const string RuntimeThemePath = "Assets/UI Toolkit/UnityThemes/UnityDefaultRuntimeTheme.tss";
+        private const string DocumentName = "SimulateMouseUiToolkitDragTests_Document";
+        private const float SliderWidth = 300f;
+        private const float SliderHeight = 40f;
+        private const float EdgeInset = 5f;
+        private const string NoEventSystemMessage = "No EventSystem found in the scene. Ensure an EventSystem GameObject exists.";
+        private const string NoDragMessage = "No drag in progress. Call DragStart first.";
+
+        private readonly List<Object> _createdObjects = new List<Object>();
+        private ExistingEventSystemDisableScope _eventSystemDisableScope = null!;
+        private GameObject _canvasObject = null!;
+        private SimulateMouseUiTool _tool = null!;
+        private SimulateMouseUiResponse _lastResponse = null!;
+        private DragTracker _lastDragTracker = null!;
+        private Slider _lastSlider = null!;
+
+        [UnitySetUp]
+        public IEnumerator SetUp()
+        {
+            _eventSystemDisableScope = new ExistingEventSystemDisableScope();
+
+            _canvasObject = new GameObject("TestCanvas");
+            _createdObjects.Add(_canvasObject);
+            Canvas canvas = _canvasObject.AddComponent<Canvas>();
+            canvas.renderMode = RenderMode.ScreenSpaceOverlay;
+            _canvasObject.AddComponent<CanvasScaler>();
+            _canvasObject.AddComponent<GraphicRaycaster>();
+
+            _tool = new SimulateMouseUiTool();
+            yield return null;
+        }
+
+        [UnityTearDown]
+        public IEnumerator TearDown()
+        {
+            MouseDragState.Clear();
+            foreach (Object createdObject in _createdObjects)
+            {
+                if (createdObject != null)
+                {
+                    Object.Destroy(createdObject);
+                }
+            }
+
+            _createdObjects.Clear();
+            yield return null;
+
+            _eventSystemDisableScope.Restore();
+        }
+
+        /// <summary>
+        /// Verifies a one-shot drag across a UI Toolkit slider moves its value to the end, reports the slider,
+        /// and leaves no pointer capture (D1).
+        /// </summary>
+        [UnityTest]
+        public IEnumerator Drag_OnUIToolkitSlider_MovesValue()
+        {
+            CreateEventSystem();
+            UIDocument document = CreateDocumentWithSlider(out Slider slider);
+            yield return WaitForLayout();
+
+            yield return RunTool(DragParameters(SliderLeft(), SliderRight(), 0f));
+
+            Assert.IsTrue(_lastResponse.Success, _lastResponse.Message);
+            Assert.GreaterOrEqual(slider.value, 0.9f);
+            Assert.AreEqual("volume", _lastResponse.HitGameObjectName);
+            Assert.AreEqual("UIToolkit", _lastResponse.UiSystem);
+            Assert.AreEqual(DocumentName + "#volume", _lastResponse.HitPath);
+            Assert.IsNull(CapturingElement(document));
+        }
+
+        /// <summary>
+        /// Verifies a one-shot drag on a UI Toolkit slider works without an EventSystem (D2).
+        /// </summary>
+        [UnityTest]
+        public IEnumerator Drag_OnUIToolkitSliderWithoutEventSystem_MovesValue()
+        {
+            CreateDocumentWithSlider(out Slider slider);
+            yield return WaitForLayout();
+
+            yield return RunTool(DragParameters(SliderLeft(), SliderRight(), 0f));
+
+            Assert.IsTrue(_lastResponse.Success, _lastResponse.Message);
+            Assert.GreaterOrEqual(slider.value, 0.9f);
+        }
+
+        /// <summary>
+        /// Verifies a drag with neither an EventSystem nor a UI Toolkit control at the start fails naming both
+        /// (D5).
+        /// </summary>
+        [UnityTest]
+        public IEnumerator Drag_WithoutEventSystemOnEmptyPoint_Fails()
+        {
+            yield return null;
+            Vector2 start = new Vector2(10f, 10f);
+
+            yield return RunTool(DragParameters(start, new Vector2(60f, 10f), 0f));
+
+            Assert.IsFalse(_lastResponse.Success);
+            Assert.AreEqual(
+                "No EventSystem found in the scene, and no UI Toolkit element is at (10.0, 10.0). Ensure an EventSystem GameObject exists for uGUI.",
+                _lastResponse.Message);
+        }
+
+        /// <summary>
+        /// Verifies a drag on UI Toolkit with a drop target that exists fails before anything is sent (D6).
+        /// </summary>
+        [UnityTest]
+        public IEnumerator Drag_OnUIToolkitWithDropTargetPath_FailsBeforeDispatch()
+        {
+            CreateEventSystem();
+            UIDocument document = CreateDocumentWithSlider(out Slider slider);
+            GameObject dropZone = CreateCanvasElement("DropZone", new Vector2(0f, 300f));
+            yield return WaitForLayout();
+            JObject parameters = DragParameters(SliderLeft(), SliderRight(), 0f);
+            parameters["dropTargetPath"] = GameObjectPathUtility.GetFullPath(dropZone);
+
+            yield return RunTool(parameters);
+
+            Assert.IsFalse(_lastResponse.Success);
+            Assert.AreEqual(
+                "DropTargetPath applies to uGUI drags only; this drag starts on UI Toolkit element 'volume'.",
+                _lastResponse.Message);
+            Assert.AreEqual(0f, slider.value);
+            Assert.IsNull(CapturingElement(document));
+        }
+
+        /// <summary>
+        /// Verifies a drag on UI Toolkit with a drop target that does not exist reports the UI Toolkit
+        /// restriction rather than the missing path (D20).
+        /// </summary>
+        [UnityTest]
+        public IEnumerator Drag_OnUIToolkitWithMissingDropTargetPath_ReportsUIToolkitRestriction()
+        {
+            CreateEventSystem();
+            CreateDocumentWithSlider(out Slider slider);
+            yield return WaitForLayout();
+            JObject parameters = DragParameters(SliderLeft(), SliderRight(), 0f);
+            parameters["dropTargetPath"] = "Missing/DropZone";
+
+            yield return RunTool(parameters);
+
+            Assert.IsFalse(_lastResponse.Success);
+            Assert.AreEqual(
+                "DropTargetPath applies to uGUI drags only; this drag starts on UI Toolkit element 'volume'.",
+                _lastResponse.Message);
+            Assert.AreEqual(0f, slider.value);
+        }
+
+        /// <summary>
+        /// Verifies a split drag on a UI Toolkit slider moves the value at each step and ends with no drag in
+        /// progress and no pointer capture (D7).
+        /// </summary>
+        [UnityTest]
+        public IEnumerator SplitDrag_OnUIToolkitSlider_MovesStepwiseAndClears()
+        {
+            CreateEventSystem();
+            UIDocument document = CreateDocumentWithSlider(out Slider slider);
+            yield return WaitForLayout();
+
+            yield return RunSplitDrag(slider);
+
+            Assert.LessOrEqual(slider.value, 0.1f);
+            Assert.IsFalse(MouseDragState.IsDragging);
+            Assert.IsNull(CapturingElement(document));
+        }
+
+        /// <summary>
+        /// Verifies a split drag on UI Toolkit runs every step without an EventSystem (D8).
+        /// </summary>
+        [UnityTest]
+        public IEnumerator SplitDrag_OnUIToolkitWithoutEventSystem_Completes()
+        {
+            UIDocument document = CreateDocumentWithSlider(out Slider slider);
+            yield return WaitForLayout();
+
+            yield return RunSplitDrag(slider);
+
+            Assert.LessOrEqual(slider.value, 0.1f);
+            Assert.IsFalse(MouseDragState.IsDragging);
+            Assert.IsNull(CapturingElement(document));
+        }
+
+        /// <summary>
+        /// Verifies a uGUI split drag whose EventSystem goes away fails DragMove as before and keeps the drag
+        /// (D9).
+        /// </summary>
+        [UnityTest]
+        public IEnumerator SplitDrag_OnUguiWhenEventSystemRemoved_FailsAsBefore()
+        {
+            GameObject eventSystem = CreateEventSystem();
+            GameObject dragTarget = CreateCanvasElement("UguiDragTarget", Vector2.zero);
+            dragTarget.AddComponent<Image>();
+            dragTarget.AddComponent<DragTracker>();
+            yield return null;
+            Vector2 center = GameViewCenter();
+            yield return RunTool(SplitParameters(MouseAction.DragStart, center));
+            Assert.IsTrue(_lastResponse.Success, _lastResponse.Message);
+
+            eventSystem.SetActive(false);
+            yield return RunTool(SplitParameters(MouseAction.DragMove, center + new Vector2(50f, 0f)));
+
+            Assert.IsFalse(_lastResponse.Success);
+            Assert.AreEqual(NoEventSystemMessage, _lastResponse.Message);
+            Assert.IsTrue(MouseDragState.IsDragging, "the drag must stay in progress");
+        }
+
+        /// <summary>
+        /// Verifies a drag starting where a uGUI drag target's Canvas sorts above the panel drags the uGUI target
+        /// and leaves the slider alone.
+        /// </summary>
+        [UnityTest]
+        public IEnumerator Drag_WhereUguiCanvasSortsAbovePanel_DragsUgui()
+        {
+            yield return DragOverlap(canvasSortingOrder: 11, panelSortingOrder: 10f);
+
+            Assert.IsTrue(_lastResponse.Success, _lastResponse.Message);
+            Assert.AreEqual("UGUI", _lastResponse.UiSystem);
+            Assert.AreEqual("UguiDragTarget", _lastResponse.HitGameObjectName);
+            Assert.IsTrue(_lastDragTracker.BeginDragCalled, "the uGUI target must be dragged");
+            Assert.AreEqual(0f, _lastSlider.value, "the slider must not move");
+        }
+
+        /// <summary>
+        /// Verifies a drag starting where the panel sorts above a uGUI drag target's Canvas drags the slider and
+        /// leaves the uGUI target alone.
+        /// </summary>
+        [UnityTest]
+        public IEnumerator Drag_WherePanelSortsAboveUguiCanvas_DragsUIToolkit()
+        {
+            yield return DragOverlap(canvasSortingOrder: 9, panelSortingOrder: 10f);
+
+            Assert.IsTrue(_lastResponse.Success, _lastResponse.Message);
+            Assert.AreEqual("UIToolkit", _lastResponse.UiSystem);
+            Assert.GreaterOrEqual(_lastSlider.value, 0.9f);
+            Assert.IsFalse(_lastDragTracker.BeginDragCalled, "the uGUI target must not be dragged");
+            Assert.AreEqual(0, _lastDragTracker.DragCallCount, "the uGUI target must not be dragged");
+        }
+
+        /// <summary>
+        /// Verifies a bypass drag on an existing uGUI drag target fails without an EventSystem, for both a
+        /// one-shot Drag and a DragStart, and sends it nothing.
+        /// </summary>
+        [UnityTest]
+        public IEnumerator BypassDrag_WithoutEventSystem_FailsAsBefore()
+        {
+            Assert.IsNull(EventSystem.current, "Setup: no EventSystem must be active.");
+            GameObject dragTarget = CreateCanvasElement("UguiDragTarget", Vector2.zero);
+            dragTarget.AddComponent<Image>();
+            DragTracker tracker = dragTarget.AddComponent<DragTracker>();
+            yield return null;
+            Vector2 center = GameViewCenter();
+
+            JObject drag = DragParameters(center, center + new Vector2(50f, 0f), 0f);
+            drag["bypassRaycast"] = true;
+            drag["targetPath"] = "TestCanvas/UguiDragTarget";
+            yield return RunTool(drag);
+
+            Assert.IsFalse(_lastResponse.Success);
+            Assert.AreEqual(NoEventSystemMessage, _lastResponse.Message);
+
+            JObject dragStart = SplitParameters(MouseAction.DragStart, center);
+            dragStart["bypassRaycast"] = true;
+            dragStart["targetPath"] = "TestCanvas/UguiDragTarget";
+            yield return RunTool(dragStart);
+
+            Assert.IsFalse(_lastResponse.Success);
+            Assert.AreEqual(NoEventSystemMessage, _lastResponse.Message);
+            Assert.IsFalse(MouseDragState.IsDragging);
+            Assert.IsFalse(tracker.BeginDragCalled, "the uGUI target must receive nothing");
+            Assert.AreEqual(0, tracker.DragCallCount, "the uGUI target must receive nothing");
+        }
+
+        /// <summary>
+        /// Verifies a split drag whose UI Toolkit document was disabled fails the next step and ends the drag
+        /// (D10).
+        /// </summary>
+        [UnityTest]
+        public IEnumerator SplitDrag_WhenUIToolkitDocumentDisabled_FailsAndClears()
+        {
+            CreateEventSystem();
+            UIDocument document = CreateDocumentWithSlider(out Slider _);
+            yield return WaitForLayout();
+            yield return RunTool(SplitParameters(MouseAction.DragStart, SliderLeft()));
+            Assert.IsTrue(_lastResponse.Success, _lastResponse.Message);
+
+            document.enabled = false;
+            yield return RunTool(SplitParameters(MouseAction.DragMove, GameViewCenter()));
+
+            Assert.IsFalse(_lastResponse.Success);
+            Assert.AreEqual(
+                "Drag target UI Toolkit element is no longer available (its document was disabled or destroyed).",
+                _lastResponse.Message);
+            Assert.IsFalse(MouseDragState.IsDragging);
+        }
+
+        /// <summary>
+        /// Verifies a click and a one-shot drag are refused while a UI Toolkit split drag is in progress (D11).
+        /// </summary>
+        [UnityTest]
+        public IEnumerator Click_WhileUIToolkitSplitDragActive_IsRejected()
+        {
+            CreateEventSystem();
+            CreateDocumentWithSlider(out Slider _);
+            yield return WaitForLayout();
+            yield return RunTool(SplitParameters(MouseAction.DragStart, SliderLeft()));
+            Assert.IsTrue(_lastResponse.Success, _lastResponse.Message);
+
+            yield return RunTool(SplitParameters(MouseAction.Click, GameViewCenter()));
+            Assert.AreEqual("Cannot Click while a split drag is active. Call DragEnd first.", _lastResponse.Message);
+
+            yield return RunTool(DragParameters(SliderLeft(), SliderRight(), 0f));
+            Assert.AreEqual("Cannot Drag while a split drag is active. Call DragEnd first.", _lastResponse.Message);
+        }
+
+        /// <summary>
+        /// Verifies DragEnd with a drop target on a UI Toolkit drag fails without ending the drag, and DragEnd
+        /// without it then succeeds (D12).
+        /// </summary>
+        [UnityTest]
+        public IEnumerator DragEnd_OnUIToolkitWithDropTargetPath_FailsAndKeepsDrag()
+        {
+            CreateEventSystem();
+            UIDocument document = CreateDocumentWithSlider(out Slider _);
+            GameObject dropZone = CreateCanvasElement("DropZone", new Vector2(0f, 300f));
+            yield return WaitForLayout();
+            yield return RunTool(SplitParameters(MouseAction.DragStart, SliderLeft()));
+            Assert.IsTrue(_lastResponse.Success, _lastResponse.Message);
+
+            JObject dragEnd = SplitParameters(MouseAction.DragEnd, SliderRight());
+            dragEnd["dropTargetPath"] = GameObjectPathUtility.GetFullPath(dropZone);
+            yield return RunTool(dragEnd);
+
+            Assert.IsFalse(_lastResponse.Success);
+            Assert.AreEqual(
+                "DropTargetPath applies to uGUI drags only; this drag starts on UI Toolkit element 'volume'.",
+                _lastResponse.Message);
+            Assert.IsTrue(MouseDragState.IsDragging, "the drag must stay in progress");
+
+            yield return RunTool(SplitParameters(MouseAction.DragEnd, SliderRight()));
+            Assert.IsTrue(_lastResponse.Success, _lastResponse.Message);
+            Assert.IsNull(CapturingElement(document));
+        }
+
+        /// <summary>
+        /// Verifies a split drag whose UI Toolkit document was destroyed counts as ended, as a destroyed uGUI
+        /// target does (D17).
+        /// </summary>
+        [UnityTest]
+        public IEnumerator SplitDrag_WhenUIToolkitDocumentDestroyed_TreatsDragAsEnded()
+        {
+            CreateEventSystem();
+            UIDocument document = CreateDocumentWithSlider(out Slider _);
+            yield return WaitForLayout();
+            yield return RunTool(SplitParameters(MouseAction.DragStart, SliderLeft()));
+            Assert.IsTrue(_lastResponse.Success, _lastResponse.Message);
+
+            Object.Destroy(document.gameObject);
+            yield return null;
+
+            yield return RunTool(SplitParameters(MouseAction.DragMove, GameViewCenter()));
+            Assert.IsFalse(_lastResponse.Success);
+            Assert.AreEqual(NoDragMessage, _lastResponse.Message);
+
+            yield return RunTool(SplitParameters(MouseAction.Click, GameViewCenter()));
+            Assert.IsTrue(_lastResponse.Success, _lastResponse.Message);
+        }
+
+        /// <summary>
+        /// Verifies a drag from a UI Toolkit button to a point outside it sends the press and release without
+        /// clicking, as real input would (D18).
+        /// </summary>
+        [UnityTest]
+        public IEnumerator Drag_FromUIToolkitButtonToOutside_DoesNotClick()
+        {
+            CreateEventSystem();
+            UIToolkitButton button = CreateDocumentWithButton(out int[] clicks);
+            yield return WaitForLayout();
+            Vector2 center = GameViewCenter();
+
+            yield return RunTool(DragParameters(center, center + new Vector2(0f, 200f), 0f));
+
+            Assert.IsTrue(_lastResponse.Success, _lastResponse.Message);
+            Assert.AreEqual(0, clicks[0]);
+            Assert.AreEqual(DocumentName + "#" + button.name, _lastResponse.HitPath);
+        }
+
+        /// <summary>
+        /// Verifies DragMove without an EventSystem and without a drag reports that no drag is in progress (D19).
+        /// </summary>
+        [UnityTest]
+        public IEnumerator DragMove_WithoutEventSystemAndNoDrag_ReportsNoDrag()
+        {
+            yield return null;
+
+            yield return RunTool(SplitParameters(MouseAction.DragMove, GameViewCenter()));
+
+            Assert.IsFalse(_lastResponse.Success);
+            Assert.AreEqual(NoDragMessage, _lastResponse.Message);
+        }
+
+        /// <summary>
+        /// Verifies cancelling a one-shot UI Toolkit drag while it moves releases the pointer capture (D21).
+        /// </summary>
+        [UnityTest]
+        public IEnumerator Drag_OnUIToolkitSlider_WhenCancelledMidway_ReleasesCapture()
+        {
+            CreateEventSystem();
+            UIDocument document = CreateDocumentWithSlider(out Slider slider);
+            yield return WaitForLayout();
+            using CancellationTokenSource cancellation = new CancellationTokenSource();
+            Task<UnityCliLoopToolResponse> task = _tool.ExecuteAsync(DragParameters(SliderLeft(), SliderRight(), 50f), cancellation.Token);
+            yield return WaitUntilSliderMoves(slider);
+
+            cancellation.Cancel();
+            yield return WaitForCancelled(task);
+
+            Assert.IsNull(CapturingElement(document));
+        }
+
+        /// <summary>
+        /// Verifies cancelling a UI Toolkit DragEnd while it moves releases the pointer and ends the drag (D22).
+        /// </summary>
+        [UnityTest]
+        public IEnumerator DragEnd_OnUIToolkit_WhenCancelledMidway_ReleasesAndClears()
+        {
+            CreateEventSystem();
+            UIDocument document = CreateDocumentWithSlider(out Slider slider);
+            yield return WaitForLayout();
+            yield return RunTool(SplitParameters(MouseAction.DragStart, SliderLeft()));
+            Assert.IsTrue(_lastResponse.Success, _lastResponse.Message);
+            using CancellationTokenSource cancellation = new CancellationTokenSource();
+            Task<UnityCliLoopToolResponse> task = _tool.ExecuteAsync(SlowSplitParameters(MouseAction.DragEnd, SliderRight()), cancellation.Token);
+            yield return WaitUntilSliderMoves(slider);
+
+            cancellation.Cancel();
+            yield return WaitForCancelled(task);
+
+            Assert.IsNull(CapturingElement(document));
+            Assert.IsFalse(MouseDragState.IsDragging);
+        }
+
+        /// <summary>
+        /// Verifies cancelling a UI Toolkit DragMove keeps the button held and the drag in progress, and a later
+        /// DragEnd releases it (D23).
+        /// </summary>
+        [UnityTest]
+        public IEnumerator DragMove_OnUIToolkit_WhenCancelled_KeepsDrag()
+        {
+            CreateEventSystem();
+            UIDocument document = CreateDocumentWithSlider(out Slider slider);
+            yield return WaitForLayout();
+            yield return RunTool(SplitParameters(MouseAction.DragStart, SliderLeft()));
+            Assert.IsTrue(_lastResponse.Success, _lastResponse.Message);
+            using CancellationTokenSource cancellation = new CancellationTokenSource();
+            Task<UnityCliLoopToolResponse> task = _tool.ExecuteAsync(SlowSplitParameters(MouseAction.DragMove, SliderRight()), cancellation.Token);
+            yield return WaitUntilSliderMoves(slider);
+
+            cancellation.Cancel();
+            yield return WaitForCancelled(task);
+
+            Assert.IsTrue(MouseDragState.IsDragging, "the drag must stay in progress");
+            Assert.IsNotNull(CapturingElement(document), "the button must stay held");
+
+            yield return RunTool(SplitParameters(MouseAction.DragEnd, SliderRight()));
+            Assert.IsTrue(_lastResponse.Success, _lastResponse.Message);
+            Assert.IsNull(CapturingElement(document));
+        }
+
+        /// <summary>
+        /// Verifies a one-shot UI Toolkit drag whose document is disabled while it moves completes without error
+        /// and reports the element it started on (D24).
+        /// </summary>
+        [UnityTest]
+        public IEnumerator Drag_OnUIToolkitSlider_WhenDocumentDisabledMidway_CompletesWithoutError()
+        {
+            CreateEventSystem();
+            UIDocument document = CreateDocumentWithSlider(out Slider slider);
+            yield return WaitForLayout();
+            // Only logs during the drag count: creating panel settings warns before the test sets their theme.
+            List<string> errors = new List<string>();
+            UnityEngine.Application.LogCallback recordErrors = (condition, stackTrace, type) =>
+            {
+                if (type != LogType.Log && type != LogType.Warning)
+                {
+                    errors.Add($"{type}: {condition}");
+                }
+            };
+            UnityEngine.Application.logMessageReceived += recordErrors;
+            Task<UnityCliLoopToolResponse> task = _tool.ExecuteAsync(DragParameters(SliderLeft(), SliderRight(), 200f), CancellationToken.None);
+            yield return WaitUntilSliderMoves(slider);
+
+            document.enabled = false;
+            yield return WaitForTask(task);
+            UnityEngine.Application.logMessageReceived -= recordErrors;
+
+            Assert.IsTrue(_lastResponse.Success, _lastResponse.Message);
+            Assert.AreEqual(DocumentName + "#volume", _lastResponse.HitPath);
+            Assert.IsEmpty(errors);
+        }
+
+        /// <summary>
+        /// Verifies cancelling a UI Toolkit DragStart during its start animation releases the pointer and leaves
+        /// no drag in progress (D25).
+        /// </summary>
+        [UnityTest]
+        public IEnumerator DragStart_OnUIToolkitSlider_WhenCancelledDuringExpand_ReleasesAndClears()
+        {
+            CreateEventSystem();
+            UIDocument document = CreateDocumentWithSlider(out Slider _);
+            yield return WaitForLayout();
+            using CancellationTokenSource cancellation = new CancellationTokenSource();
+            Task<UnityCliLoopToolResponse> task = _tool.ExecuteAsync(SplitParameters(MouseAction.DragStart, SliderLeft()), cancellation.Token);
+
+            yield return null;
+            Assert.IsFalse(task.IsCompleted, "Setup: DragStart must still be animating when cancelled.");
+            Assert.IsNotNull(CapturingElement(document), "Setup: the press must have arrived before cancelling.");
+            cancellation.Cancel();
+            yield return WaitForCancelled(task);
+
+            Assert.IsNull(CapturingElement(document));
+            Assert.IsFalse(MouseDragState.IsDragging);
+        }
+
+        /// <summary>
+        /// Verifies a DragStart whose UI Toolkit press handler throws releases the pointer, leaves no drag in
+        /// progress, and ends with the exception.
+        /// </summary>
+        [UnityTest]
+        public IEnumerator DragStart_WhenUIToolkitPressHandlerThrows_ReleasesAndLeavesNoDrag()
+        {
+            CreateEventSystem();
+            CreateDocumentWithSlider(out Slider slider);
+            int pointerUps = 0;
+            slider.RegisterCallback<PointerDownEvent>(_ => throw new System.InvalidOperationException("press failed"), TrickleDown.TrickleDown);
+            slider.RegisterCallback<PointerUpEvent>(_ => pointerUps++, TrickleDown.TrickleDown);
+            yield return WaitForLayout();
+
+            yield return WaitForFaulted(_tool.ExecuteAsync(SplitParameters(MouseAction.DragStart, SliderLeft()), CancellationToken.None));
+
+            Assert.AreEqual(1, pointerUps, "the release must still be sent");
+            Assert.IsFalse(MouseDragState.IsDragging);
+        }
+
+        /// <summary>
+        /// Verifies a DragEnd whose UI Toolkit release handler throws still ends the drag and ends with the
+        /// exception.
+        /// </summary>
+        [UnityTest]
+        public IEnumerator DragEnd_WhenUIToolkitReleaseHandlerThrows_StillEndsDrag()
+        {
+            CreateEventSystem();
+            UIDocument document = CreateDocumentWithSlider(out Slider _);
+            yield return WaitForLayout();
+            yield return RunTool(SplitParameters(MouseAction.DragStart, SliderLeft()));
+            Assert.IsTrue(_lastResponse.Success, _lastResponse.Message);
+            CapturingControl(document).RegisterCallback<PointerUpEvent>(_ => throw new System.InvalidOperationException("release failed"));
+
+            yield return WaitForFaulted(_tool.ExecuteAsync(SplitParameters(MouseAction.DragEnd, SliderRight()), CancellationToken.None));
+
+            Assert.IsFalse(MouseDragState.IsDragging);
+        }
+
+        /// <summary>
+        /// Verifies a DragMove whose UI Toolkit move handler throws keeps the drag in progress and the button
+        /// held, as a cancelled DragMove does, so a later DragEnd releases it.
+        /// </summary>
+        [UnityTest]
+        public IEnumerator DragMove_WhenUIToolkitMoveHandlerThrows_KeepsDrag()
+        {
+            CreateEventSystem();
+            UIDocument document = CreateDocumentWithSlider(out Slider _);
+            yield return WaitForLayout();
+            yield return RunTool(SplitParameters(MouseAction.DragStart, SliderLeft()));
+            Assert.IsTrue(_lastResponse.Success, _lastResponse.Message);
+            bool throwOnMove = false;
+            CapturingControl(document).RegisterCallback<PointerMoveEvent>(_ =>
+            {
+                if (throwOnMove)
+                {
+                    throw new System.InvalidOperationException("move failed");
+                }
+            });
+
+            throwOnMove = true;
+            yield return WaitForFaulted(_tool.ExecuteAsync(SplitParameters(MouseAction.DragMove, GameViewCenter()), CancellationToken.None));
+
+            Assert.IsTrue(MouseDragState.IsDragging, "the drag must stay in progress");
+            Assert.IsNotNull(CapturingElement(document), "the button must stay held");
+            throwOnMove = false;
+            yield return RunTool(SplitParameters(MouseAction.DragEnd, SliderRight()));
+            Assert.IsTrue(_lastResponse.Success, _lastResponse.Message);
+            Assert.IsNull(CapturingElement(document));
+        }
+
+        // Steps right to the centre, then back to the left edge, checking the value after each step.
+        private IEnumerator RunSplitDrag(Slider slider)
+        {
+            yield return RunTool(SplitParameters(MouseAction.DragStart, SliderLeft()));
+            Assert.IsTrue(_lastResponse.Success, _lastResponse.Message);
+            Assert.AreEqual("UIToolkit", _lastResponse.UiSystem);
+
+            yield return RunTool(SplitParameters(MouseAction.DragMove, GameViewCenter()));
+            Assert.IsTrue(_lastResponse.Success, _lastResponse.Message);
+            Assert.That(slider.value, Is.InRange(0.3f, 0.7f));
+
+            yield return RunTool(SplitParameters(MouseAction.DragEnd, SliderLeft()));
+            Assert.IsTrue(_lastResponse.Success, _lastResponse.Message);
+            Assert.AreEqual("UIToolkit", _lastResponse.UiSystem);
+        }
+
+        private GameObject CreateEventSystem()
+        {
+            GameObject eventSystemObject = new GameObject("TestEventSystem");
+            _createdObjects.Add(eventSystemObject);
+            eventSystemObject.AddComponent<EventSystem>();
+            eventSystemObject.AddComponent<StandaloneInputModule>();
+            return eventSystemObject;
+        }
+
+        // A uGUI drag target laid exactly over the slider, so the drag start point hits both.
+        private IEnumerator DragOverlap(int canvasSortingOrder, float panelSortingOrder)
+        {
+            CreateEventSystem();
+            _canvasObject.GetComponent<Canvas>().sortingOrder = canvasSortingOrder;
+            CreateDocumentWithSlider(out Slider slider, panelSortingOrder);
+            GameObject dragTarget = CreateCanvasElement("UguiDragTarget", Vector2.zero);
+            dragTarget.AddComponent<Image>();
+            _lastDragTracker = dragTarget.AddComponent<DragTracker>();
+            _lastSlider = slider;
+            yield return WaitForLayout();
+
+            yield return RunTool(DragParameters(SliderLeft(), SliderRight(), 0f));
+        }
+
+        // Offset from the Canvas centre, which is the Game View centre in PlayMode; Canvas y grows upwards.
+        private GameObject CreateCanvasElement(string name, Vector2 offset)
+        {
+            GameObject element = new GameObject(name);
+            element.transform.SetParent(_canvasObject.transform, false);
+            RectTransform rect = element.AddComponent<RectTransform>();
+            rect.anchorMin = new Vector2(0.5f, 0.5f);
+            rect.anchorMax = new Vector2(0.5f, 0.5f);
+            rect.anchoredPosition = offset;
+            rect.sizeDelta = new Vector2(SliderWidth, SliderHeight);
+            return element;
+        }
+
+        private UIDocument CreateDocumentWithSlider(out Slider slider, float panelSortingOrder = 0f)
+        {
+            slider = new Slider(0f, 1f) { name = "volume" };
+            UIDocument document = CreateDocument(panelSortingOrder);
+            PlaceAtCenter(document, slider);
+            return document;
+        }
+
+        // The counter is an array so the click callback can update it after this method returns.
+        private UIToolkitButton CreateDocumentWithButton(out int[] clicks)
+        {
+            int[] counter = new int[1];
+            UIToolkitButton button = new UIToolkitButton { name = "play" };
+            button.clicked += () => counter[0]++;
+            PlaceAtCenter(CreateDocument(), button);
+            clicks = counter;
+            return button;
+        }
+
+        // The object starts inactive so the document sees its panel settings when it first enables.
+        private UIDocument CreateDocument(float panelSortingOrder = 0f)
+        {
+            PanelSettings settings = ScriptableObject.CreateInstance<PanelSettings>();
+            settings.scaleMode = PanelScaleMode.ConstantPixelSize;
+            settings.scale = 1f;
+            settings.sortingOrder = panelSortingOrder;
+            settings.themeStyleSheet = AssetDatabase.LoadAssetAtPath<ThemeStyleSheet>(RuntimeThemePath);
+            Assert.IsNotNull(settings.themeStyleSheet, "the runtime theme must exist at " + RuntimeThemePath);
+            _createdObjects.Add(settings);
+
+            GameObject documentObject = new GameObject(DocumentName);
+            documentObject.SetActive(false);
+            _createdObjects.Add(documentObject);
+            UIDocument document = documentObject.AddComponent<UIDocument>();
+            document.panelSettings = settings;
+            documentObject.SetActive(true);
+            return document;
+        }
+
+        private static void PlaceAtCenter(UIDocument document, VisualElement element)
+        {
+            Vector2 center = GameViewCenter();
+            element.style.position = Position.Absolute;
+            element.style.left = center.x - SliderWidth / 2f;
+            element.style.top = center.y - SliderHeight / 2f;
+            element.style.width = SliderWidth;
+            element.style.height = SliderHeight;
+            element.style.marginLeft = 0f;
+            element.style.marginTop = 0f;
+            element.style.marginRight = 0f;
+            element.style.marginBottom = 0f;
+            document.rootVisualElement.Add(element);
+        }
+
+        // While the pointer is captured, its events go to the capturing element only, so handlers that must see
+        // them are registered there.
+        private static VisualElement CapturingControl(UIDocument document)
+        {
+            VisualElement? capturing = CapturingElement(document) as VisualElement;
+            Assert.IsNotNull(capturing, "Setup: the drag must have captured the pointer.");
+            return capturing!;
+        }
+
+        private static IEventHandler? CapturingElement(UIDocument document)
+        {
+            return document.rootVisualElement.panel.GetCapturingElement(PointerId.mousePointerId);
+        }
+
+        private static Vector2 GameViewCenter()
+        {
+            Vector2 size = Handles.GetMainGameViewSize();
+            return new Vector2(Mathf.Round(size.x / 2f), Mathf.Round(size.y / 2f));
+        }
+
+        private static Vector2 SliderLeft()
+        {
+            return GameViewCenter() + new Vector2(-SliderWidth / 2f + EdgeInset, 0f);
+        }
+
+        private static Vector2 SliderRight()
+        {
+            return GameViewCenter() + new Vector2(SliderWidth / 2f - EdgeInset, 0f);
+        }
+
+        private static JObject DragParameters(Vector2 from, Vector2 to, float dragSpeed)
+        {
+            return new JObject
+            {
+                ["action"] = MouseAction.Drag.ToString(),
+                ["fromX"] = from.x,
+                ["fromY"] = from.y,
+                ["x"] = to.x,
+                ["y"] = to.y,
+                ["dragSpeed"] = dragSpeed
+            };
+        }
+
+        private static JObject SplitParameters(MouseAction action, Vector2 point)
+        {
+            return new JObject
+            {
+                ["action"] = action.ToString(),
+                ["x"] = point.x,
+                ["y"] = point.y,
+                ["dragSpeed"] = 0f
+            };
+        }
+
+        private static JObject SlowSplitParameters(MouseAction action, Vector2 point)
+        {
+            JObject parameters = SplitParameters(action, point);
+            parameters["dragSpeed"] = 50f;
+            return parameters;
+        }
+
+        private IEnumerator RunTool(JObject parameters)
+        {
+            yield return WaitForTask(_tool.ExecuteAsync(parameters, CancellationToken.None));
+        }
+
+        private IEnumerator WaitForTask(Task<UnityCliLoopToolResponse> task)
+        {
+            float timeoutAt = Time.realtimeSinceStartup + 5f;
+            yield return new WaitUntil(() => task.IsCompleted || Time.realtimeSinceStartup >= timeoutAt);
+            Assert.IsTrue(task.IsCompleted, "Tool execution timed out.");
+            Assert.AreEqual(TaskStatus.RanToCompletion, task.Status, $"Tool execution should complete: {task.Exception}");
+            _lastResponse = (SimulateMouseUiResponse)task.Result;
+        }
+
+        private static IEnumerator WaitForFaulted(Task<UnityCliLoopToolResponse> task)
+        {
+            float timeoutAt = Time.realtimeSinceStartup + 5f;
+            yield return new WaitUntil(() => task.IsCompleted || Time.realtimeSinceStartup >= timeoutAt);
+            Assert.IsTrue(task.IsCompleted, "Tool execution timed out.");
+            Assert.IsTrue(task.IsFaulted, $"the handler's exception must end the command, got {task.Status}");
+            Assert.IsInstanceOf<System.InvalidOperationException>(task.Exception!.InnerException);
+        }
+
+        private static IEnumerator WaitForCancelled(Task<UnityCliLoopToolResponse> task)
+        {
+            float timeoutAt = Time.realtimeSinceStartup + 5f;
+            yield return new WaitUntil(() => task.IsCompleted || Time.realtimeSinceStartup >= timeoutAt);
+            yield return null;
+            Assert.IsTrue(task.IsCompleted, "the drag must end after cancelling");
+            Assert.IsTrue(task.IsCanceled || task.Exception?.InnerException is System.OperationCanceledException,
+                $"the drag must end by cancellation, got {task.Status}: {task.Exception}");
+        }
+
+        // A press near the left edge leaves the value near 0, so reaching 0.2 means the interpolation is running.
+        private static IEnumerator WaitUntilSliderMoves(Slider slider)
+        {
+            float timeoutAt = Time.realtimeSinceStartup + 5f;
+            yield return new WaitUntil(() => slider.value >= 0.2f || Time.realtimeSinceStartup >= timeoutAt);
+            Assert.GreaterOrEqual(slider.value, 0.2f, "Setup: the drag must be moving before the step.");
+        }
+
+        // The root's size is set by the runtime panel update in the player loop, so frames must pass.
+        private static IEnumerator WaitForLayout()
+        {
+            yield return null;
+            yield return null;
+        }
+    }
+}
diff --git a/Assets/Tests/PlayMode/SimulateMouseUiToolkitDragTests.cs.meta b/Assets/Tests/PlayMode/SimulateMouseUiToolkitDragTests.cs.meta
new file mode 100644
index 0000000000..e07eaa1c5a
--- /dev/null
+++ b/Assets/Tests/PlayMode/SimulateMouseUiToolkitDragTests.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: ec8c2e4a0427848269f4d61bd4ddfbec
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Tests/PlayMode/SimulateMouseUiToolkitTests.cs b/Assets/Tests/PlayMode/SimulateMouseUiToolkitTests.cs
index c27f38a486..d5336b7318 100644
--- a/Assets/Tests/PlayMode/SimulateMouseUiToolkitTests.cs
+++ b/Assets/Tests/PlayMode/SimulateMouseUiToolkitTests.cs
@@ -251,29 +251,6 @@ public IEnumerator Drag_WithNegativeDragSpeedAndNoEventSystem_ReportsDragSpeedEr
             Assert.AreEqual("DragSpeed must be non-negative, got: -1", _lastResponse.Message);
         }
 
-        /// <summary>
-        /// Verifies a drag with no EventSystem still fails with the existing message.
-        /// </summary>
-        [UnityTest]
-        public IEnumerator Drag_WithoutEventSystem_FailsAsBefore()
-        {
-            CreateDocumentWithCenteredButton(0f, out ClickCounter _);
-            yield return WaitForLayout();
-            Vector2 point = GameViewCenter();
-
-            yield return RunTool(new JObject
-            {
-                ["action"] = MouseAction.Drag.ToString(),
-                ["fromX"] = point.x,
-                ["fromY"] = point.y,
-                ["x"] = point.x + 10f,
-                ["y"] = point.y
-            });
-
-            Assert.IsFalse(_lastResponse.Success);
-            Assert.AreEqual(NoEventSystemMessage, _lastResponse.Message);
-        }
-
         /// <summary>
         /// Verifies a right click reaches the UI Toolkit button as button 1 and does not click it (#20).
         /// </summary>
diff --git a/Packages/src/Documentation~/tools.md b/Packages/src/Documentation~/tools.md
index 172653a7aa..ede904bff7 100644
--- a/Packages/src/Documentation~/tools.md
+++ b/Packages/src/Documentation~/tools.md
@@ -158,7 +158,7 @@ When enabled, dynamic code execution runs with full Unity Editor process permiss
 ### 14. simulate-mouse-ui - Simulate Mouse Input on PlayMode UI
 Simulate mouse click, long-press, and drag on PlayMode UI elements. Uses EventSystem and ExecuteEvents to dispatch pointer events directly — works independently of both old and new Input System. For game logic that reads Input System (e.g. `Mouse.current.leftButton.wasPressedThisFrame`), use `simulate-mouse-input` instead.
 
-Supports 6 actions: Click, LongPress, Drag (one-shot), DragStart/DragMove/DragEnd (split drag). Click and LongPress also reach UI Toolkit controls at their annotated coordinates, without an EventSystem.
+Supports 6 actions: Click, LongPress, Drag (one-shot), DragStart/DragMove/DragEnd (split drag). Click, LongPress, and drags also reach UI Toolkit controls at their annotated coordinates, without an EventSystem.
 
 ```text
 → screenshot (CaptureMode: rendering, AnnotateElements: true)
diff --git a/Packages/src/Documentation~/tools_ja.md b/Packages/src/Documentation~/tools_ja.md
index 411720f305..9987e31ba9 100644
--- a/Packages/src/Documentation~/tools_ja.md
+++ b/Packages/src/Documentation~/tools_ja.md
@@ -158,7 +158,7 @@ Unity Editor内で動的にC#コードを実行します。
 ### 14. simulate-mouse-ui - PlayMode UI要素のマウス操作シミュレーション
 PlayMode中のUI要素に対してマウスクリック・長押し・ドラッグをシミュレーションします。EventSystemとExecuteEventsを使ってポインタイベントを直接ディスパッチするため、旧Input System・新Input Systemの両方に依存せず動作します。ゲームロジックがInput Systemを直接読み取る場合（例：`Mouse.current.leftButton.wasPressedThisFrame`）は、`simulate-mouse-input` を使用してください。
 
-6つのアクションに対応: Click、LongPress、Drag（ワンショット）、DragStart/DragMove/DragEnd（分割ドラッグ）。Click と LongPress は、注釈の座標で UI Toolkit のコントロールにも届きます（EventSystem は不要）。
+6つのアクションに対応: Click、LongPress、Drag（ワンショット）、DragStart/DragMove/DragEnd（分割ドラッグ）。Click・LongPress・ドラッグは、注釈の座標で UI Toolkit のコントロールにも届きます（EventSystem は不要）。
 
 ```text
 → screenshot (CaptureMode: rendering, AnnotateElements: true)
diff --git a/Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UIToolkitPointerTarget.cs b/Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UIToolkitPointerTarget.cs
index 0a4fb7fda4..853b280006 100644
--- a/Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UIToolkitPointerTarget.cs
+++ b/Packages/src/Editor/FirstPartyTools/Common/UIToolkit/UIToolkitPointerTarget.cs
@@ -49,6 +49,9 @@ internal UIToolkitPointerTarget(IPanel panel, UIDocument document, string name,
         public bool IsAvailable =>
             _document != null && _document.isActiveAndEnabled && _document.rootVisualElement?.panel == _panel;
 
+        /// <summary>True once the document that owns the panel has been destroyed, not merely disabled.</summary>
+        public bool IsDocumentDestroyed => _document == null;
+
         /// <summary>Presses a mouse button (0 left, 1 right, 2 middle) at a Game View point.</summary>
         /// <remarks>Does nothing once the target is no longer available.</remarks>
         public void PressDown(Vector2 gameViewTopLeft, int button)
diff --git a/Packages/src/Editor/FirstPartyTools/Screenshot/Skill/references/annotated-elements.md b/Packages/src/Editor/FirstPartyTools/Screenshot/Skill/references/annotated-elements.md
index 69466c0964..69272a2bb2 100644
--- a/Packages/src/Editor/FirstPartyTools/Screenshot/Skill/references/annotated-elements.md
+++ b/Packages/src/Editor/FirstPartyTools/Screenshot/Skill/references/annotated-elements.md
@@ -53,7 +53,7 @@ Limits:
 
 Clicking:
 
-- `simulate-mouse-ui --action Click --x <SimX> --y <SimY>` (or `LongPress`) reaches UI Toolkit controls, with or without an EventSystem. Its `--target-path` does not accept UI Toolkit `Path` values.
+- `simulate-mouse-ui --action Click --x <SimX> --y <SimY>` (or `LongPress`, or a drag from that point) reaches UI Toolkit controls, with or without an EventSystem. Its `--target-path` does not accept UI Toolkit `Path` values.
 - `simulate-mouse-input --action Click --x <SimX> --y <SimY>` also reaches them when the scene has an EventSystem with an Input System UI input module.
 - Without an EventSystem the `simulate-mouse-input` click does not reach UI Toolkit controls.
 
diff --git a/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/Application/MouseDragState.cs b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/Application/MouseDragState.cs
index 0b012fac0a..c8e1c8011b 100644
--- a/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/Application/MouseDragState.cs
+++ b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/Application/MouseDragState.cs
@@ -1,7 +1,5 @@
 #nullable enable
 using UnityEditor;
-using UnityEngine;
-using UnityEngine.EventSystems;
 
 using io.github.hatayama.UnityCliLoop.Runtime;
 
@@ -12,9 +10,9 @@ namespace io.github.hatayama.UnityCliLoop.FirstPartyTools
     /// </summary>
     internal sealed class MouseDragStateService
     {
-        internal bool IsDragging => Target != null && PointerData != null;
-        internal GameObject? Target { get; set; }
-        internal PointerEventData? PointerData { get; set; }
+        // A destroyed target ends the drag without a command, as Unity's null check on it already did.
+        internal bool IsDragging => Session != null && !Session.IsTargetDestroyed;
+        internal IMouseUiDragSession? Session { get; set; }
 
         internal void RegisterPlayModeCallbacks()
         {
@@ -25,8 +23,7 @@ internal void RegisterPlayModeCallbacks()
 
         internal void Clear()
         {
-            Target = null;
-            PointerData = null;
+            Session = null;
         }
 
         private void OnPlayModeStateChanged(PlayModeStateChange state)
@@ -53,16 +50,10 @@ internal static void InitializeForEditorStartup()
 
         internal static bool IsDragging => ServiceValue.IsDragging;
 
-        internal static GameObject? Target
+        internal static IMouseUiDragSession? Session
         {
-            get => ServiceValue.Target;
-            set => ServiceValue.Target = value;
-        }
-
-        internal static PointerEventData? PointerData
-        {
-            get => ServiceValue.PointerData;
-            set => ServiceValue.PointerData = value;
+            get => ServiceValue.Session;
+            set => ServiceValue.Session = value;
         }
 
         internal static void Clear()
diff --git a/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/IMouseUiDragSession.cs b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/IMouseUiDragSession.cs
new file mode 100644
index 0000000000..7d3307313b
--- /dev/null
+++ b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/IMouseUiDragSession.cs
@@ -0,0 +1,35 @@
+#nullable enable
+using UnityEngine;
+
+namespace io.github.hatayama.UnityCliLoop.FirstPartyTools
+{
+    /// <summary>
+    /// A drag in progress on one target: one-shot drags hold it for a single command, split drags keep it
+    /// between commands. Positions are Game View input coordinates with a top-left origin.
+    /// </summary>
+    internal interface IMouseUiDragSession
+    {
+        /// <summary>What the drag started on. Its name is never null.</summary>
+        MouseUiHitReport Report { get; }
+
+        /// <summary>Where the pointer is now.</summary>
+        Vector2 CurrentInputPosition { get; }
+
+        /// <summary>True once the target is destroyed; the drag then counts as no longer in progress.</summary>
+        bool IsTargetDestroyed { get; }
+
+        /// <summary>
+        /// True when the drag goes through the EventSystem, which then must exist and alone handles drop targets.
+        /// </summary>
+        bool UsesEventSystem { get; }
+
+        /// <summary>Returns why the drag cannot continue, or null when it can.</summary>
+        string? CheckStillActive();
+
+        /// <summary>Moves the pointer one step while the button stays held.</summary>
+        void MoveTo(Vector2 inputPosition);
+
+        /// <summary>Releases the button, dropping onto the explicit target when one is given.</summary>
+        void Finish(GameObject? explicitDropTarget);
+    }
+}
diff --git a/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/IMouseUiDragSession.cs.meta b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/IMouseUiDragSession.cs.meta
new file mode 100644
index 0000000000..e5208b6b34
--- /dev/null
+++ b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/IMouseUiDragSession.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 5e628bb72cf9f4df480ff925cca9378b
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/MouseUiDragEventExecutor.cs b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/MouseUiDragEventExecutor.cs
index ef9760cf70..05cd36921a 100644
--- a/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/MouseUiDragEventExecutor.cs
+++ b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/MouseUiDragEventExecutor.cs
@@ -81,17 +81,19 @@ private static void UpdatePointerRaycast(PointerEventData pointerData)
             pointerData.pointerCurrentRaycast = hit ?? new RaycastResult();
         }
 
+        // Interpolates in top-left input coordinates. The flip to screen space is affine and the Game View
+        // height cannot change within one command, so the screen points a uGUI drag passes match interpolating
+        // in screen space.
         internal static async Task<MouseUiFrameWaitOutcome> InterpolateDragPosition(
-            PointerEventData pointerData,
-            GameObject target,
-            Vector2 endPos,
+            IMouseUiDragSession session,
+            Vector2 endInput,
             float dragSpeed,
             CancellationToken ct)
         {
             Debug.Assert(dragSpeed >= 0f, "dragSpeed must be non-negative");
 
-            Vector2 startPos = pointerData.position;
-            float distance = Vector2.Distance(startPos, endPos);
+            Vector2 startInput = session.CurrentInputPosition;
+            float distance = Vector2.Distance(startInput, endInput);
             float duration = dragSpeed > 0f ? distance / dragSpeed : 0f;
 
             if (duration <= 0f)
@@ -103,13 +105,8 @@ internal static async Task<MouseUiFrameWaitOutcome> InterpolateDragPosition(
                 }
                 await MainThreadSwitcher.SwitchToMainThread(ct);
 
-                Vector2 previousPosition = pointerData.position;
-                pointerData.position = endPos;
-                pointerData.delta = endPos - previousPosition;
-                MouseUiInputSystemSync.SyncMousePosition(endPos);
-                ExecuteEvents.Execute(target, pointerData, ExecuteEvents.dragHandler);
-
-                SimulateMouseUiOverlayState.UpdatePosition(MouseUiCoordinateConverter.ScreenToInput(endPos));
+                session.MoveTo(endInput);
+                SimulateMouseUiOverlayState.UpdatePosition(endInput);
                 return MouseUiFrameWaitOutcome.Completed;
             }
 
@@ -127,16 +124,10 @@ internal static async Task<MouseUiFrameWaitOutcome> InterpolateDragPosition(
 
                 float elapsed = Time.realtimeSinceStartup - startTime;
                 t = Mathf.Clamp01(elapsed / duration);
-                Vector2 previousPosition = pointerData.position;
-                Vector2 currentPosition = Vector2.Lerp(startPos, endPos, t);
-
-                pointerData.position = currentPosition;
-                pointerData.delta = currentPosition - previousPosition;
-
-                MouseUiInputSystemSync.SyncMousePosition(currentPosition);
-                ExecuteEvents.Execute(target, pointerData, ExecuteEvents.dragHandler);
+                Vector2 currentInput = Vector2.Lerp(startInput, endInput, t);
 
-                SimulateMouseUiOverlayState.UpdatePosition(MouseUiCoordinateConverter.ScreenToInput(currentPosition));
+                session.MoveTo(currentInput);
+                SimulateMouseUiOverlayState.UpdatePosition(currentInput);
             }
             while (t < 1.0f);
 
diff --git a/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/MouseUiDragStartTarget.cs b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/MouseUiDragStartTarget.cs
new file mode 100644
index 0000000000..76103bcfa5
--- /dev/null
+++ b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/MouseUiDragStartTarget.cs
@@ -0,0 +1,70 @@
+#nullable enable
+using System;
+using UnityEngine;
+using UnityEngine.EventSystems;
+
+namespace io.github.hatayama.UnityCliLoop.FirstPartyTools
+{
+    /// <summary>
+    /// What a drag will start on, resolved before anything is sent so that refusals leave no button held.
+    /// </summary>
+    internal sealed class MouseUiDragStartTarget
+    {
+        private readonly EventSystem? _eventSystem;
+        private readonly RaycastResult _startRaycast;
+        private readonly GameObject? _uguiTarget;
+        private readonly UIToolkitPointerTarget? _uiToolkitTarget;
+
+        private MouseUiDragStartTarget(
+            EventSystem? eventSystem,
+            RaycastResult startRaycast,
+            GameObject? uguiTarget,
+            UIToolkitPointerTarget? uiToolkitTarget)
+        {
+            _eventSystem = eventSystem;
+            _startRaycast = startRaycast;
+            _uguiTarget = uguiTarget;
+            _uiToolkitTarget = uiToolkitTarget;
+        }
+
+        internal static MouseUiDragStartTarget None { get; } = new MouseUiDragStartTarget(null, new RaycastResult(), null, null);
+
+        /// <summary>A uGUI drag; a null target means the raycast hit has no drag handler.</summary>
+        internal static MouseUiDragStartTarget Ugui(EventSystem eventSystem, RaycastResult startRaycast, GameObject? target)
+        {
+            return new MouseUiDragStartTarget(eventSystem, startRaycast, target, null);
+        }
+
+        internal static MouseUiDragStartTarget UIToolkit(UIToolkitPointerTarget target)
+        {
+            return new MouseUiDragStartTarget(null, new RaycastResult(), null, target);
+        }
+
+        internal bool HasTarget => _uiToolkitTarget != null || _uguiTarget != null;
+
+        /// <summary>The raycast a uGUI drag presses on; empty for UI Toolkit and for no target.</summary>
+        internal RaycastResult StartRaycast => _startRaycast;
+
+        /// <summary>The uGUI drag handler, or null when the drag is not on uGUI or the hit has no handler.</summary>
+        internal GameObject? UguiTarget => _uguiTarget;
+
+        /// <summary>The UI Toolkit control's name, or null when the drag is not on UI Toolkit.</summary>
+        internal string? UIToolkitElementName => _uiToolkitTarget?.Name;
+
+        /// <summary>Presses on the target and returns the drag in progress.</summary>
+        internal IMouseUiDragSession Begin(Vector2 inputStart, Vector2 screenStart)
+        {
+            if (_uiToolkitTarget != null)
+            {
+                return UIToolkitDragSession.Begin(_uiToolkitTarget, inputStart);
+            }
+
+            if (_uguiTarget == null)
+            {
+                throw new InvalidOperationException("A drag cannot begin without a target; check HasTarget first.");
+            }
+
+            return UguiDragSession.Begin(_eventSystem!, screenStart, _startRaycast, _uguiTarget);
+        }
+    }
+}
diff --git a/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/MouseUiDragStartTarget.cs.meta b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/MouseUiDragStartTarget.cs.meta
new file mode 100644
index 0000000000..c1852ec5c1
--- /dev/null
+++ b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/MouseUiDragStartTarget.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: a0e6b014039bd4fffa364700f86c448b
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/MouseUiDragTargetResolver.cs b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/MouseUiDragTargetResolver.cs
index 316e68d608..a0e067b3a7 100644
--- a/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/MouseUiDragTargetResolver.cs
+++ b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/MouseUiDragTargetResolver.cs
@@ -7,54 +7,93 @@
 namespace io.github.hatayama.UnityCliLoop.FirstPartyTools
 {
     /// <summary>
-    /// Resolves the draggable target and starting raycast for mouse UI drag actions.
+    /// Decides what a Drag or DragStart starts on: a uGUI drag handler, a UI Toolkit control, or nothing. The
+    /// choice between uGUI and UI Toolkit follows the same rule as clicks.
     /// </summary>
     internal static class MouseUiDragTargetResolver
     {
-        internal static (
-            RaycastResult StartRaycast,
-            GameObject? Target,
-            SimulateMouseUiResponse? FailureResponse) Resolve(
-                MouseUiSimulationCommand parameters,
-                EventSystem eventSystem,
-                MouseAction action,
-                Vector2 inputPosition,
-                Vector2 screenPosition)
+        internal static (MouseUiDragStartTarget Start, SimulateMouseUiResponse? FailureResponse) Resolve(
+            MouseUiSimulationCommand parameters,
+            EventSystem? eventSystem,
+            MouseAction action,
+            Vector2 inputPosition,
+            Vector2 screenPosition)
         {
-            RaycastResult? hit = parameters.BypassRaycast
-                ? null
-                : UiRaycastHelper.RaycastUI(screenPosition, eventSystem);
-            RaycastResult startRaycast = new();
-            GameObject? rawTarget = null;
-
             if (parameters.BypassRaycast)
             {
-                (GameObject? Target, SimulateMouseUiResponse? FailureResponse) resolution =
-                    MouseUiPointerTargetResolver.ResolveGameObjectPath(
-                        parameters.TargetPath,
-                        "TargetPath",
-                        action,
-                        inputPosition);
-                if (resolution.FailureResponse != null)
-                {
-                    return (startRaycast, null, resolution.FailureResponse);
-                }
-
-                rawTarget = resolution.Target;
-                startRaycast = MouseUiPointerTargetResolver.CreateDirectRaycastResult(rawTarget!);
+                return ResolveBypass(parameters, eventSystem, action, inputPosition);
+            }
+
+            // As with clicks, UI Toolkit is looked up at the requested point itself and the uGUI side leaves out
+            // the bridge's panel hits, which depend on Screen.
+            UIToolkitPointerTarget? toolkit = UIToolkitScreenElements.FindPointerTarget(inputPosition);
+            RaycastResult? hit = eventSystem != null
+                ? UiRaycastHelper.RaycastUISkippingUIToolkitPanels(screenPosition, eventSystem)
+                : null;
+            if (toolkit == null && hit == null)
+            {
+                return eventSystem == null
+                    ? (MouseUiDragStartTarget.None, MouseUiSimulationResponseFactory.CreateFailure(
+                        parameters,
+                        MouseUiPressTargetResolver.NoEventSystemNorUIToolkitMessage(inputPosition)))
+                    : (MouseUiDragStartTarget.None, null);
             }
-            else if (hit != null)
+
+            if (toolkit != null &&
+                (hit == null || !MouseUiHitPriority.IsUguiInFront(hit.Value.module.sortOrderPriority, toolkit.SortingOrder)))
             {
-                rawTarget = hit.Value.gameObject;
-                startRaycast = hit.Value;
+                return (MouseUiDragStartTarget.UIToolkit(toolkit), null);
             }
 
             // Execute dispatches only to the exact target; resolve the actual drag handler up the hierarchy.
-            GameObject? target = rawTarget != null
-                ? ExecuteEvents.GetEventHandler<IDragHandler>(rawTarget)
-                : null;
+            GameObject? target = ExecuteEvents.GetEventHandler<IDragHandler>(hit!.Value.gameObject);
+            return (MouseUiDragStartTarget.Ugui(eventSystem!, hit.Value, target), null);
+        }
+
+        /// <summary>
+        /// Refuses a drop target for a drag on a UI Toolkit control, which has no EventSystem drop handling.
+        /// </summary>
+        internal static SimulateMouseUiResponse? RefuseDropTargetOnUIToolkit(
+            MouseUiSimulationCommand parameters,
+            string? uiToolkitElementName)
+        {
+            if (uiToolkitElementName == null || string.IsNullOrEmpty(parameters.DropTargetPath))
+            {
+                return null;
+            }
+
+            return MouseUiSimulationResponseFactory.CreateFailure(
+                parameters,
+                $"DropTargetPath applies to uGUI drags only; this drag starts on UI Toolkit element '{uiToolkitElementName}'.");
+        }
+
+        private static (MouseUiDragStartTarget Start, SimulateMouseUiResponse? FailureResponse) ResolveBypass(
+            MouseUiSimulationCommand parameters,
+            EventSystem? eventSystem,
+            MouseAction action,
+            Vector2 inputPosition)
+        {
+            if (eventSystem == null)
+            {
+                return (MouseUiDragStartTarget.None, MouseUiSimulationResponseFactory.CreateFailure(
+                    parameters, MouseUiPressTargetResolver.NoEventSystemMessage));
+            }
+
+            (GameObject? Target, SimulateMouseUiResponse? FailureResponse) resolution =
+                MouseUiPointerTargetResolver.ResolveGameObjectPath(
+                    parameters.TargetPath,
+                    "TargetPath",
+                    action,
+                    inputPosition);
+            if (resolution.FailureResponse != null)
+            {
+                return (MouseUiDragStartTarget.None, resolution.FailureResponse);
+            }
 
-            return (startRaycast, target, null);
+            GameObject rawTarget = resolution.Target!;
+            RaycastResult startRaycast = MouseUiPointerTargetResolver.CreateDirectRaycastResult(rawTarget);
+            GameObject? target = ExecuteEvents.GetEventHandler<IDragHandler>(rawTarget);
+            return (MouseUiDragStartTarget.Ugui(eventSystem, startRaycast, target), null);
         }
     }
 }
diff --git a/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/MouseUiGameObjectHitReport.cs b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/MouseUiGameObjectHitReport.cs
new file mode 100644
index 0000000000..b88102b10c
--- /dev/null
+++ b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/MouseUiGameObjectHitReport.cs
@@ -0,0 +1,26 @@
+#nullable enable
+using UnityEngine;
+
+namespace io.github.hatayama.UnityCliLoop.FirstPartyTools
+{
+    /// <summary>
+    /// Builds the hit report for a GameObject target reached through the EventSystem.
+    /// </summary>
+    internal static class MouseUiGameObjectHitReport
+    {
+        // Decided by whether the handler sits under a Canvas rather than by raycaster type, because a bypass
+        // press has no raycaster and both paths must report alike.
+        internal static MouseUiHitReport Create(GameObject? target)
+        {
+            if (target == null)
+            {
+                return MouseUiHitReport.None;
+            }
+
+            string uiSystem = target.GetComponentInParent<Canvas>() != null
+                ? MouseUiHitSystem.UGUI
+                : MouseUiHitSystem.NonUi;
+            return new MouseUiHitReport(target.name, GameObjectPathUtility.GetFullPath(target), uiSystem);
+        }
+    }
+}
diff --git a/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/MouseUiGameObjectHitReport.cs.meta b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/MouseUiGameObjectHitReport.cs.meta
new file mode 100644
index 0000000000..8e31b5df43
--- /dev/null
+++ b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/MouseUiGameObjectHitReport.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 8817fdc880f5740a8a6d71c005803f85
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/MouseUiIncrementalDragExecutor.cs b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/MouseUiIncrementalDragExecutor.cs
index 02832f459a..b8061262a9 100644
--- a/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/MouseUiIncrementalDragExecutor.cs
+++ b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/MouseUiIncrementalDragExecutor.cs
@@ -17,7 +17,7 @@ internal static class MouseUiIncrementalDragExecutor
     {
         internal static async Task<SimulateMouseUiResponse> ExecuteDragStart(
             MouseUiSimulationCommand parameters,
-            EventSystem eventSystem,
+            EventSystem? eventSystem,
             MouseUiMainThreadCleanupScheduler cleanupScheduler,
             CancellationToken ct)
         {
@@ -35,7 +35,7 @@ internal static async Task<SimulateMouseUiResponse> ExecuteDragStart(
 
             Vector2 inputPos = new(parameters.X, parameters.Y);
             Vector2 screenPos = MouseUiCoordinateConverter.InputToScreen(inputPos);
-            (RaycastResult startRaycast, GameObject? target, SimulateMouseUiResponse? targetFailureResponse) =
+            (MouseUiDragStartTarget start, SimulateMouseUiResponse? targetFailureResponse) =
                 MouseUiDragTargetResolver.Resolve(
                     parameters,
                     eventSystem,
@@ -47,7 +47,7 @@ internal static async Task<SimulateMouseUiResponse> ExecuteDragStart(
                 return targetFailureResponse;
             }
 
-            if (target == null)
+            if (!start.HasTarget)
             {
                 SimulateMouseUiOverlayState.Update(
                     MouseAction.DragStart, inputPos, null, Handles.GetMainGameViewSize());
@@ -93,14 +93,10 @@ internal static async Task<SimulateMouseUiResponse> ExecuteDragStart(
                 };
             }
 
-            PointerEventData pointerData = MouseUiDragEventExecutor.InitiateDrag(eventSystem, screenPos, startRaycast, target, PointerEventData.InputButton.Left);
-            ExecuteEvents.Execute(target, pointerData, ExecuteEvents.beginDragHandler);
-            pointerData.dragging = true;
+            IMouseUiDragSession session = start.Begin(inputPos, screenPos);
+            MouseDragState.Session = session;
 
-            MouseDragState.Target = target;
-            MouseDragState.PointerData = pointerData;
-
-            string targetName = target.name;
+            string targetName = session.Report.Name!;
             SimulateMouseUiOverlayState.Update(
                 MouseAction.DragStart, inputPos, inputPos, Handles.GetMainGameViewSize());
 
@@ -130,8 +126,15 @@ internal static async Task<SimulateMouseUiResponse> ExecuteDragStart(
                 {
                     cleanupScheduler.ExecuteCleanupOnMainThread(() =>
                     {
-                        MouseUiDragEventExecutor.FinalizeDrag(pointerData, target, null);
-                        MouseDragState.Clear();
+                        // Cleared even when the release throws, so no drag is left in progress.
+                        try
+                        {
+                            session.Finish(null);
+                        }
+                        finally
+                        {
+                            MouseDragState.Clear();
+                        }
                     });
                 }
             }
@@ -139,9 +142,11 @@ internal static async Task<SimulateMouseUiResponse> ExecuteDragStart(
             return new SimulateMouseUiResponse
             {
                 Success = true,
-                Message = $"Drag started on '{targetName}' at ({inputPos.x:F1}, {inputPos.y:F1})",
+                Message = $"Drag started on {MouseUiSimulationResponseFactory.DescribeHit(session.Report)} at ({inputPos.x:F1}, {inputPos.y:F1})",
                 Action = MouseAction.DragStart.ToString(),
                 HitGameObjectName = targetName,
+                UiSystem = session.Report.UiSystem,
+                HitPath = session.Report.Path,
                 PositionX = inputPos.x,
                 PositionY = inputPos.y
             };
@@ -164,30 +169,27 @@ internal static async Task<SimulateMouseUiResponse> ExecuteDragMove(
                 };
             }
 
-            Debug.Assert(MouseDragState.Target != null, "Target must not be null when IsDragging is true");
-            Debug.Assert(MouseDragState.PointerData != null, "PointerData must not be null when IsDragging is true");
+            Debug.Assert(MouseDragState.Session != null, "Session must not be null when IsDragging is true");
 
-            SimulateMouseUiResponse? invalidResponse = ValidateDragStillActive(parameters.Action);
+            SimulateMouseUiResponse? invalidResponse = ValidateDragStillActive(parameters);
             if (invalidResponse != null)
             {
                 return invalidResponse;
             }
 
             Vector2 inputEnd = new(parameters.X, parameters.Y);
-            Vector2 screenEnd = MouseUiCoordinateConverter.InputToScreen(inputEnd);
-            PointerEventData pointerData = MouseDragState.PointerData!;
-            GameObject target = MouseDragState.Target!;
-            string targetName = target.name;
+            IMouseUiDragSession session = MouseDragState.Session!;
+            string targetName = session.Report.Name!;
 
             SimulateMouseUiOverlayState.Update(
                 MouseAction.DragMove,
-                MouseUiCoordinateConverter.ScreenToInput(pointerData.position),
+                session.CurrentInputPosition,
                 SimulateMouseUiOverlayState.DragStartPosition,
                 Handles.GetMainGameViewSize());
 
             // Cancellation leaves drag state intact so the user can continue with DragMove/DragEnd
             MouseUiFrameWaitOutcome dragOutcome = await MouseUiDragEventExecutor.InterpolateDragPosition(
-                pointerData, target, screenEnd,
+                session, inputEnd,
                 parameters.DragSpeed, ct).ConfigureAwait(false);
             if (dragOutcome == MouseUiFrameWaitOutcome.TimedOut)
             {
@@ -208,9 +210,11 @@ internal static async Task<SimulateMouseUiResponse> ExecuteDragMove(
             return new SimulateMouseUiResponse
             {
                 Success = true,
-                Message = $"Drag moved on '{targetName}' to ({inputEnd.x:F1}, {inputEnd.y:F1}) at {parameters.DragSpeed:F0} px/s",
+                Message = $"Drag moved on {MouseUiSimulationResponseFactory.DescribeHit(session.Report)} to ({inputEnd.x:F1}, {inputEnd.y:F1}) at {parameters.DragSpeed:F0} px/s",
                 Action = MouseAction.DragMove.ToString(),
                 HitGameObjectName = targetName,
+                UiSystem = session.Report.UiSystem,
+                HitPath = session.Report.Path,
                 PositionX = inputEnd.x,
                 PositionY = inputEnd.y
             };
@@ -233,20 +237,26 @@ internal static async Task<SimulateMouseUiResponse> ExecuteDragEnd(
                 };
             }
 
-            Debug.Assert(MouseDragState.Target != null, "Target must not be null when IsDragging is true");
-            Debug.Assert(MouseDragState.PointerData != null, "PointerData must not be null when IsDragging is true");
+            Debug.Assert(MouseDragState.Session != null, "Session must not be null when IsDragging is true");
 
-            SimulateMouseUiResponse? invalidResponse = ValidateDragStillActive(parameters.Action);
+            SimulateMouseUiResponse? invalidResponse = ValidateDragStillActive(parameters);
             if (invalidResponse != null)
             {
                 return invalidResponse;
             }
 
             Vector2 inputEnd = new(parameters.X, parameters.Y);
-            Vector2 screenEnd = MouseUiCoordinateConverter.InputToScreen(inputEnd);
-            PointerEventData pointerData = MouseDragState.PointerData!;
-            GameObject target = MouseDragState.Target!;
-            string targetName = target.name;
+            IMouseUiDragSession session = MouseDragState.Session!;
+            string targetName = session.Report.Name!;
+            // The drag stays in progress so DragEnd can be retried without the option.
+            SimulateMouseUiResponse? dropRefusal = MouseUiDragTargetResolver.RefuseDropTargetOnUIToolkit(
+                parameters,
+                session.UsesEventSystem ? null : targetName);
+            if (dropRefusal != null)
+            {
+                return dropRefusal;
+            }
+
             (GameObject? explicitDropTarget, SimulateMouseUiResponse? dropFailureResponse) =
                 MouseUiPointerTargetResolver.ResolveDropTargetPath(
                     parameters,
@@ -259,7 +269,7 @@ internal static async Task<SimulateMouseUiResponse> ExecuteDragEnd(
 
             SimulateMouseUiOverlayState.Update(
                 MouseAction.DragEnd,
-                MouseUiCoordinateConverter.ScreenToInput(pointerData.position),
+                session.CurrentInputPosition,
                 SimulateMouseUiOverlayState.DragStartPosition,
                 Handles.GetMainGameViewSize());
 
@@ -271,7 +281,7 @@ internal static async Task<SimulateMouseUiResponse> ExecuteDragEnd(
             try
             {
                 MouseUiFrameWaitOutcome dragOutcome = await MouseUiDragEventExecutor.InterpolateDragPosition(
-                    pointerData, target, screenEnd,
+                    session, inputEnd,
                     parameters.DragSpeed, ct).ConfigureAwait(false);
                 if (dragOutcome == MouseUiFrameWaitOutcome.TimedOut)
                 {
@@ -304,8 +314,15 @@ internal static async Task<SimulateMouseUiResponse> ExecuteDragEnd(
             {
                 cleanupScheduler.ExecuteCleanupOnMainThread(() =>
                 {
-                    MouseUiDragEventExecutor.FinalizeDrag(pointerData, target, explicitDropTarget);
-                    MouseDragState.Clear();
+                    // Cleared even when the release throws, so no drag is left in progress.
+                    try
+                    {
+                        session.Finish(explicitDropTarget);
+                    }
+                    finally
+                    {
+                        MouseDragState.Clear();
+                    }
                 });
             }
 
@@ -316,7 +333,7 @@ internal static async Task<SimulateMouseUiResponse> ExecuteDragEnd(
             if (dissipateOutcome == MouseUiFrameWaitOutcome.TimedOut)
             {
                 cleanupScheduler.QueueOverlayClear();
-                return MouseUiSimulationResponseFactory.CreateDragEndResult(parameters, inputEnd, targetName);
+                return MouseUiSimulationResponseFactory.CreateDragEndResult(parameters, inputEnd, session.Report);
             }
             if (dissipateOutcome == MouseUiFrameWaitOutcome.Paused)
             {
@@ -327,36 +344,31 @@ internal static async Task<SimulateMouseUiResponse> ExecuteDragEnd(
             }
             await MainThreadSwitcher.SwitchToMainThread(ct);
 
-            return MouseUiSimulationResponseFactory.CreateDragEndResult(parameters, inputEnd, targetName);
+            return MouseUiSimulationResponseFactory.CreateDragEndResult(parameters, inputEnd, session.Report);
         }
 
-        // User input during a CLI drag can cause Unity's StandaloneInputModule to
-        // release or reassign the drag, leaving MouseDragState stale.
-        private static SimulateMouseUiResponse? ValidateDragStillActive(MouseAction action)
+        // A drag that can no longer continue is cleared; a missing EventSystem keeps the drag in progress so it
+        // can continue once one exists. UI Toolkit drags never use the EventSystem.
+        private static SimulateMouseUiResponse? ValidateDragStillActive(MouseUiSimulationCommand parameters)
         {
-            if (!MouseDragState.Target!.activeInHierarchy)
+            IMouseUiDragSession session = MouseDragState.Session!;
+            string? reason = session.CheckStillActive();
+            if (reason != null)
             {
                 MouseDragState.Clear();
                 SimulateMouseUiOverlayState.Clear();
                 return new SimulateMouseUiResponse
                 {
                     Success = false,
-                    Message = "Drag target was destroyed or deactivated during drag.",
-                    Action = action.ToString()
+                    Message = reason,
+                    Action = parameters.Action.ToString()
                 };
             }
 
-            if (!MouseDragState.PointerData!.dragging ||
-                MouseDragState.PointerData.pointerDrag != MouseDragState.Target)
+            if (session.UsesEventSystem && EventSystem.current == null)
             {
-                MouseDragState.Clear();
-                SimulateMouseUiOverlayState.Clear();
-                return new SimulateMouseUiResponse
-                {
-                    Success = false,
-                    Message = "Drag was interrupted by user input or system event.",
-                    Action = action.ToString()
-                };
+                return MouseUiSimulationResponseFactory.CreateFailure(
+                    parameters, MouseUiPressTargetResolver.NoEventSystemMessage);
             }
 
             return null;
diff --git a/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/MouseUiOneShotDragExecutor.cs b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/MouseUiOneShotDragExecutor.cs
index 33694a84f3..ee9ee6fb99 100644
--- a/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/MouseUiOneShotDragExecutor.cs
+++ b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/MouseUiOneShotDragExecutor.cs
@@ -17,15 +17,14 @@ internal static class MouseUiOneShotDragExecutor
     {
         internal static async Task<SimulateMouseUiResponse> ExecuteDragOneShot(
             MouseUiSimulationCommand parameters,
-            EventSystem eventSystem,
+            EventSystem? eventSystem,
             MouseUiMainThreadCleanupScheduler cleanupScheduler,
             CancellationToken ct)
         {
             Vector2 inputStart = new(parameters.FromX, parameters.FromY);
             Vector2 inputEnd = new(parameters.X, parameters.Y);
             Vector2 screenStart = MouseUiCoordinateConverter.InputToScreen(inputStart);
-            Vector2 screenEnd = MouseUiCoordinateConverter.InputToScreen(inputEnd);
-            (RaycastResult startRaycast, GameObject? target, SimulateMouseUiResponse? targetFailureResponse) =
+            (MouseUiDragStartTarget start, SimulateMouseUiResponse? targetFailureResponse) =
                 MouseUiDragTargetResolver.Resolve(
                     parameters,
                     eventSystem,
@@ -37,6 +36,14 @@ internal static async Task<SimulateMouseUiResponse> ExecuteDragOneShot(
                 return targetFailureResponse;
             }
 
+            // Ahead of the drop target lookup, so a missing drop target does not hide why the option is refused.
+            SimulateMouseUiResponse? dropRefusal =
+                MouseUiDragTargetResolver.RefuseDropTargetOnUIToolkit(parameters, start.UIToolkitElementName);
+            if (dropRefusal != null)
+            {
+                return dropRefusal;
+            }
+
             (GameObject? explicitDropTarget, SimulateMouseUiResponse? dropFailureResponse) =
                 MouseUiPointerTargetResolver.ResolveDropTargetPath(
                     parameters,
@@ -47,18 +54,15 @@ internal static async Task<SimulateMouseUiResponse> ExecuteDragOneShot(
                 return dropFailureResponse;
             }
 
-            if (target == null)
+            if (!start.HasTarget)
             {
                 return await ExecuteNoTargetDragAsync(
                     parameters, inputStart, inputEnd, cleanupScheduler, ct).ConfigureAwait(false);
             }
 
-            // uGUI drag controls (ScrollRect, Slider) only respond to left-button drags
-            PointerEventData pointerData = MouseUiDragEventExecutor.InitiateDrag(eventSystem, screenStart, startRaycast, target, PointerEventData.InputButton.Left);
-            ExecuteEvents.Execute(target, pointerData, ExecuteEvents.beginDragHandler);
-            pointerData.dragging = true;
+            IMouseUiDragSession session = start.Begin(inputStart, screenStart);
 
-            string targetName = target.name;
+            string targetName = session.Report.Name!;
             SimulateMouseUiOverlayState.Update(
                 MouseAction.Drag, inputStart, inputStart, Handles.GetMainGameViewSize());
 
@@ -72,11 +76,9 @@ internal static async Task<SimulateMouseUiResponse> ExecuteDragOneShot(
             {
                 SimulateMouseUiResponse? motionAbort = await AnimateDragMotionOrAbortAsync(
                     parameters,
-                    pointerData,
-                    target,
+                    session,
                     inputStart,
                     inputEnd,
-                    screenEnd,
                     targetName,
                     DragInterruptedDuringMotionMessage,
                     cleanupScheduler,
@@ -88,7 +90,7 @@ internal static async Task<SimulateMouseUiResponse> ExecuteDragOneShot(
             }
             finally
             {
-                cleanupScheduler.ExecuteCleanupOnMainThread(() => MouseUiDragEventExecutor.FinalizeDrag(pointerData, target, explicitDropTarget));
+                cleanupScheduler.ExecuteCleanupOnMainThread(() => session.Finish(explicitDropTarget));
             }
 
             // Why switch after the helper: AnimateDragMotionOrAbortAsync ends on the main
@@ -103,7 +105,7 @@ internal static async Task<SimulateMouseUiResponse> ExecuteDragOneShot(
             if (dissipateOutcome == MouseUiFrameWaitOutcome.TimedOut)
             {
                 cleanupScheduler.QueueOverlayClear();
-                return MouseUiSimulationResponseFactory.CreateDragResult(parameters, inputStart, inputEnd, targetName);
+                return MouseUiSimulationResponseFactory.CreateDragResult(parameters, inputStart, inputEnd, session.Report);
             }
             if (dissipateOutcome == MouseUiFrameWaitOutcome.Paused)
             {
@@ -114,7 +116,7 @@ internal static async Task<SimulateMouseUiResponse> ExecuteDragOneShot(
             }
             await MainThreadSwitcher.SwitchToMainThread(ct);
 
-            return MouseUiSimulationResponseFactory.CreateDragResult(parameters, inputStart, inputEnd, targetName);
+            return MouseUiSimulationResponseFactory.CreateDragResult(parameters, inputStart, inputEnd, session.Report);
         }
 
         private static async Task<SimulateMouseUiResponse> ExecuteNoTargetDragAsync(
@@ -172,11 +174,9 @@ await MouseUiOverlayAnimator.PlayDissipateAnimation(ct).ConfigureAwait(false),
 
         private static async Task<SimulateMouseUiResponse?> AnimateDragMotionOrAbortAsync(
             MouseUiSimulationCommand parameters,
-            PointerEventData pointerData,
-            GameObject target,
+            IMouseUiDragSession session,
             Vector2 inputStart,
             Vector2 inputEnd,
-            Vector2 screenEnd,
             string targetName,
             string interruptedMessage,
             MouseUiMainThreadCleanupScheduler cleanupScheduler,
@@ -197,7 +197,7 @@ await MouseUiOverlayAnimator.PlayExpandAnimation(ct).ConfigureAwait(false),
             await MainThreadSwitcher.SwitchToMainThread(ct);
 
             SimulateMouseUiResponse? dragAbort = AbortDragOnOverlayOutcome(
-                await MouseUiDragEventExecutor.InterpolateDragPosition(pointerData, target, screenEnd, parameters.DragSpeed, ct)
+                await MouseUiDragEventExecutor.InterpolateDragPosition(session, inputEnd, parameters.DragSpeed, ct)
                     .ConfigureAwait(false),
                 inputStart,
                 inputEnd,
diff --git a/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/MouseUiPressTargetResolver.cs b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/MouseUiPressTargetResolver.cs
index 718bab3b9a..16f6b6bd60 100644
--- a/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/MouseUiPressTargetResolver.cs
+++ b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/MouseUiPressTargetResolver.cs
@@ -12,7 +12,7 @@ namespace io.github.hatayama.UnityCliLoop.FirstPartyTools
     /// </summary>
     internal static class MouseUiPressTargetResolver
     {
-        private const string NoEventSystemMessage = "No EventSystem found in the scene. Ensure an EventSystem GameObject exists.";
+        internal const string NoEventSystemMessage = "No EventSystem found in the scene. Ensure an EventSystem GameObject exists.";
         private const string UIToolkitPathHint =
             " UI Toolkit element paths are not accepted here; click the element at its SimX/SimY without --bypass-raycast.";
 
@@ -48,7 +48,7 @@ internal static (IMouseUiPressTarget? Target, SimulateMouseUiResponse? Failure)
                 {
                     return (null, MouseUiSimulationResponseFactory.CreateFailure(
                         parameters,
-                        $"No EventSystem found in the scene, and no UI Toolkit element is at ({inputPos.x:F1}, {inputPos.y:F1}). Ensure an EventSystem GameObject exists for uGUI."));
+                        NoEventSystemNorUIToolkitMessage(inputPos)));
                 }
 
                 return (new UguiPressTarget(ResolvedPointerTargets.Empty, uguiPointerData), null);
@@ -92,6 +92,11 @@ private static (IMouseUiPressTarget? Target, SimulateMouseUiResponse? Failure) R
             return (null, failure);
         }
 
+        internal static string NoEventSystemNorUIToolkitMessage(Vector2 inputPos)
+        {
+            return $"No EventSystem found in the scene, and no UI Toolkit element is at ({inputPos.x:F1}, {inputPos.y:F1}). Ensure an EventSystem GameObject exists for uGUI.";
+        }
+
         // The press data carries the uGUI raycast hit, whose raycaster decides the order against the panel.
         private static bool IsUguiHitInFront(PointerEventData uguiPointerData, UIToolkitPointerTarget toolkit)
         {
diff --git a/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/MouseUiSimulationResponseFactory.cs b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/MouseUiSimulationResponseFactory.cs
index 4eb4db1682..d35ff3695e 100644
--- a/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/MouseUiSimulationResponseFactory.cs
+++ b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/MouseUiSimulationResponseFactory.cs
@@ -109,7 +109,7 @@ internal static SimulateMouseUiResponse CreateLongPressResult(
             };
         }
 
-        private static string DescribeHit(MouseUiHitReport hit)
+        internal static string DescribeHit(MouseUiHitReport hit)
         {
             return hit.UiSystem == MouseUiHitSystem.UIToolkit
                 ? $"UI Toolkit element '{hit.Name}'"
@@ -120,16 +120,18 @@ internal static SimulateMouseUiResponse CreateDragResult(
             MouseUiSimulationCommand parameters,
             Vector2 inputStart,
             Vector2 inputEnd,
-            string targetName)
+            MouseUiHitReport hit)
         {
             return new SimulateMouseUiResponse
             {
                 Success = true,
                 Message = parameters.BypassRaycast
-                    ? $"Bypass-dragged '{targetName}' from ({inputStart.x:F1}, {inputStart.y:F1}) to ({inputEnd.x:F1}, {inputEnd.y:F1}) via '{parameters.TargetPath}' at {parameters.DragSpeed:F0} px/s"
-                    : $"Dragged '{targetName}' from ({inputStart.x:F1}, {inputStart.y:F1}) to ({inputEnd.x:F1}, {inputEnd.y:F1}) at {parameters.DragSpeed:F0} px/s",
+                    ? $"Bypass-dragged '{hit.Name}' from ({inputStart.x:F1}, {inputStart.y:F1}) to ({inputEnd.x:F1}, {inputEnd.y:F1}) via '{parameters.TargetPath}' at {parameters.DragSpeed:F0} px/s"
+                    : $"Dragged {DescribeHit(hit)} from ({inputStart.x:F1}, {inputStart.y:F1}) to ({inputEnd.x:F1}, {inputEnd.y:F1}) at {parameters.DragSpeed:F0} px/s",
                 Action = MouseAction.Drag.ToString(),
-                HitGameObjectName = targetName,
+                HitGameObjectName = hit.Name,
+                UiSystem = hit.UiSystem,
+                HitPath = hit.Path,
                 PositionX = inputStart.x,
                 PositionY = inputStart.y,
                 EndPositionX = inputEnd.x,
@@ -140,14 +142,16 @@ internal static SimulateMouseUiResponse CreateDragResult(
         internal static SimulateMouseUiResponse CreateDragEndResult(
             MouseUiSimulationCommand parameters,
             Vector2 inputEnd,
-            string targetName)
+            MouseUiHitReport hit)
         {
             return new SimulateMouseUiResponse
             {
                 Success = true,
-                Message = $"Drag ended on '{targetName}' at ({inputEnd.x:F1}, {inputEnd.y:F1}) at {parameters.DragSpeed:F0} px/s",
+                Message = $"Drag ended on {DescribeHit(hit)} at ({inputEnd.x:F1}, {inputEnd.y:F1}) at {parameters.DragSpeed:F0} px/s",
                 Action = MouseAction.DragEnd.ToString(),
-                HitGameObjectName = targetName,
+                HitGameObjectName = hit.Name,
+                UiSystem = hit.UiSystem,
+                HitPath = hit.Path,
                 PositionX = inputEnd.x,
                 PositionY = inputEnd.y
             };
diff --git a/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/SimulateMouseUiResponse.cs b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/SimulateMouseUiResponse.cs
index a4127095cd..c94fdbc777 100644
--- a/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/SimulateMouseUiResponse.cs
+++ b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/SimulateMouseUiResponse.cs
@@ -14,8 +14,9 @@ public class SimulateMouseUiResponse : UnityCliLoopToolResponse
         public string Message { get; set; } = "";
         public string Action { get; set; } = "";
         /// <summary>
-        /// Name of what received the press: the uGUI or physics GameObject that handles it, or the UI Toolkit
-        /// control under the point (its name, or its type name when it has none). Null when nothing was hit.
+        /// Name of what received the press or drag: the uGUI or physics GameObject that handles it, or the UI
+        /// Toolkit control under the point (its name, or its type name when it has none). Null when nothing was
+        /// hit.
         /// </summary>
         public string? HitGameObjectName { get; set; }
 
diff --git a/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/SimulateMouseUiUseCase.cs b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/SimulateMouseUiUseCase.cs
index 948a558427..b4f2532848 100644
--- a/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/SimulateMouseUiUseCase.cs
+++ b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/SimulateMouseUiUseCase.cs
@@ -56,15 +56,8 @@ public async Task<SimulateMouseUiResponse> ExecuteAsync(
                 return validationFailure;
             }
 
-            // Clicks and long presses can reach UI Toolkit without an EventSystem and check for one when they
-            // resolve their target. DragMove and DragEnd executors never receive it, so drags are checked here.
-            if (MouseUiSimulationValidator.IsDragAction(parameters.Action) && eventSystem == null)
-            {
-                return MouseUiSimulationResponseFactory.CreateFailure(
-                    parameters,
-                    "No EventSystem found in the scene. Ensure an EventSystem GameObject exists.");
-            }
-
+            // UI Toolkit targets need no EventSystem, so each action checks for one only once it knows it is
+            // going through uGUI.
             MouseUiSimulationActivityLogger.LogSimulationStart(parameters, correlationId);
             OverlayCanvasFactory.EnsureExists();
 
@@ -97,18 +90,16 @@ private async Task<SimulateMouseUiResponse> ExecuteMouseAction(
                         ct).ConfigureAwait(false);
 
                 case MouseAction.Drag:
-                    Debug.Assert(eventSystem != null, "Drags without an EventSystem must be rejected before dispatch.");
                     return await MouseUiOneShotDragExecutor.ExecuteDragOneShot(
                         parameters,
-                        eventSystem!,
+                        eventSystem,
                         _mainThreadCleanupScheduler,
                         ct).ConfigureAwait(false);
 
                 case MouseAction.DragStart:
-                    Debug.Assert(eventSystem != null, "Drags without an EventSystem must be rejected before dispatch.");
                     return await MouseUiIncrementalDragExecutor.ExecuteDragStart(
                         parameters,
-                        eventSystem!,
+                        eventSystem,
                         _mainThreadCleanupScheduler,
                         ct).ConfigureAwait(false);
 
diff --git a/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/Skill/SKILL.md b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/Skill/SKILL.md
index 0be9c8c4fb..3d67862bbd 100644
--- a/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/Skill/SKILL.md
+++ b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/Skill/SKILL.md
@@ -64,7 +64,7 @@ uloop simulate-mouse-ui --action <action> --x <x> --y <y> [options]
 - Get coordinates from `AnnotatedElements` JSON (`SimX`/`SimY`) — do NOT look up GameObject positions
 - `--bypass-raycast` still uses coordinates for pointer event positions, but chooses the clicked, long-pressed, or dragged GameObject by `--target-path`
 - If `--target-path` or `--drop-target-path` matches multiple active GameObjects, the command fails instead of choosing an arbitrary duplicate
-- UI Toolkit entries (`UiSystem` `UIToolkit`) can be clicked and long-pressed at `SimX`/`SimY`; `--bypass-raycast`, `--target-path`, and `--drop-target-path` take GameObjects only. Details: `references/ui-toolkit.md`.
+- UI Toolkit entries (`UiSystem` `UIToolkit`) can be clicked, long-pressed, and dragged at `SimX`/`SimY`; `--bypass-raycast`, `--target-path`, and `--drop-target-path` take GameObjects only. Details: `references/ui-toolkit.md`.
 - Device Simulator play view is supported. Prefer `uloop screenshot --capture-mode rendering --annotate-elements` for coordinates; they use the simulated device resolution (`Handles.GetMainGameViewSize()` / `Screen`), not the Simulator chrome scale.
 
 ## Pause Point Inspection (Standard for E2E)
@@ -86,8 +86,8 @@ uloop simulate-mouse-ui --action Drag --from-x 400 --from-y 300 --x 600 --y 300
 # Long-press a button for 3 seconds
 uloop simulate-mouse-ui --action LongPress --x 400 --y 300 --duration 3.0
 
-# Slow drag for visual inspection
-uloop simulate-mouse-ui --action Drag --from-x 400 --from-y 300 --x 600 --y 300 --drag-speed 200
+# One-shot drag (add --drag-speed 200 to slow it for visual inspection)
+uloop simulate-mouse-ui --action Drag --from-x 400 --from-y 300 --x 600 --y 300
 
 # Split drag with hold (for inspection between steps)
 uloop simulate-mouse-ui --action DragStart --x 400 --y 300
diff --git a/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/Skill/references/output.md b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/Skill/references/output.md
index af20d8c00b..03086035fa 100644
--- a/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/Skill/references/output.md
+++ b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/Skill/references/output.md
@@ -5,9 +5,9 @@ Returns JSON with:
 - `Success`: Whether the operation succeeded
 - `Message`: Status message (e.g. "Hit element: ButtonStart" or "No UI element under (x, y)")
 - `Action`: Echoes which action was executed (`Click`, `Drag`, `DragStart`, `DragMove`, `DragEnd`, or `LongPress`)
-- `HitGameObjectName`: Name of the GameObject that received the pointer events (nullable string; null if nothing was hit). It is the event-handler target resolved up the hierarchy from the raycast hit (the first `IPointerDownHandler`, else the first `IPointerClickHandler`, for `Click`/`LongPress`; the first `IDragHandler` for drags), so it can be an ancestor of the topmost raycast hit — a Button's child Text reports the Button. With `--bypass-raycast` it is the handler resolved the same way from `--target-path` (also possibly an ancestor), not the raycast hit and not necessarily the raw path GameObject itself. For a UI Toolkit hit it is the control's `name`, the same as the annotation's `Name`
-- `UiSystem`: Which UI system received the press (nullable string; `Click`/`LongPress` only, null if nothing was hit): `UGUI` for a target under a Canvas, `UIToolkit` for a UI Toolkit control, and `""` for a non-UI target such as a physics object
-- `HitPath`: Path of the hit target in the form `AnnotatedElements[].Path` uses (nullable string; `Click`/`LongPress` only): a hierarchy path for GameObjects, `Document/Path#element` for UI Toolkit controls
+- `HitGameObjectName`: Name of the GameObject that received the pointer events (nullable string; null if nothing was hit). It is the event-handler target resolved up the hierarchy from the raycast hit (the first `IPointerDownHandler`, else the first `IPointerClickHandler`, for `Click`/`LongPress`; the first `IDragHandler` for drags), so it can be an ancestor of the topmost raycast hit — a Button's child Text reports the Button. With `--bypass-raycast` it is the handler resolved the same way from `--target-path` (also possibly an ancestor), not the raycast hit and not necessarily the raw path GameObject itself. For a UI Toolkit hit it is the name of the outermost control an annotation would list (the same as the annotation's `Name`); when the picked element is not inside such a control (a bare `Label` or `VisualElement`), it is that element's own `name`, or its type name when empty, and the element is not annotated. Unlike uGUI, which reports null when no handler is found, UI Toolkit reports the picked element whether or not it handles pointer events
+- `UiSystem`: Which UI system received the press (nullable string; `Click`/`LongPress` and drags, null if nothing was hit): `UGUI` for a target under a Canvas, `UIToolkit` for a UI Toolkit control, and `""` for a non-UI target such as a physics object
+- `HitPath`: Path of the hit target in the form `AnnotatedElements[].Path` uses (nullable string; `Click`/`LongPress` and drags): a hierarchy path for GameObjects, `Document/Path#element` for UI Toolkit controls. Null when nothing was hit, or when the hit element belongs to no document, such as the menu of an open dropdown
 - `PositionX`: Target X coordinate that was used
 - `PositionY`: Target Y coordinate that was used
 - `EndPositionX`: Drag end X coordinate (nullable float; populated for drag actions only)
@@ -20,4 +20,4 @@ Note: Click and LongPress on empty space (no UI element) still return `Success =
 
 ## UI Toolkit Elements
 
-`Click` and `LongPress` reach UI Toolkit controls at their annotated `SimX`/`SimY`. How presses are delivered and what is not supported: `ui-toolkit.md`.
+`Click`, `LongPress`, and the drag actions reach UI Toolkit controls at their annotated `SimX`/`SimY` (`--from-x`/`--from-y` for `Drag`). How presses and drags are delivered and what is not supported: `ui-toolkit.md`.
diff --git a/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/Skill/references/ui-toolkit.md b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/Skill/references/ui-toolkit.md
index ec3bb79d44..373a3deee1 100644
--- a/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/Skill/references/ui-toolkit.md
+++ b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/Skill/references/ui-toolkit.md
@@ -1,9 +1,9 @@
 # simulate-mouse-ui and UI Toolkit
 
-`Click` and `LongPress` reach UI Toolkit controls on screen-space panels — the
-`AnnotatedElements` entries with `UiSystem` `UIToolkit`. Pass the entry's `SimX`/`SimY` as
-`--x`/`--y`; the response reports `UiSystem` `UIToolkit`, the control's `Name` as
-`HitGameObjectName`, and its annotation `Path` as `HitPath`.
+`Click`, `LongPress`, and the drag actions reach UI Toolkit controls on screen-space panels —
+the `AnnotatedElements` entries with `UiSystem` `UIToolkit`. Pass the entry's `SimX`/`SimY` as
+`--x`/`--y` (`--from-x`/`--from-y` for `Drag`); the response reports `UiSystem` `UIToolkit`, the
+control's `Name` as `HitGameObjectName`, and its annotation `Path` as `HitPath`.
 
 ## How a press is delivered
 
@@ -29,18 +29,33 @@ A UI Toolkit `Button` fires `clicked` once when the long press is released (UI T
 `Clickable` behaviour); a uGUI long press sends no click. A `RepeatButton` fires repeatedly
 while held.
 
+## Drags
+
+- A drag whose start point resolves to a UI Toolkit control (by the rule above) presses it
+  with the left button, moves the pointer, and releases at the end, so a `Slider` or a
+  `Scroller` follows the drag. The start point is what counts: the drag stays with that panel
+  wherever it moves.
+- A labelled slider's bounds include its label; start the drag on the track.
+- `--drop-target-path` applies to uGUI drags only. A `Drag` with it fails before anything is
+  sent; a `DragEnd` with it fails and leaves the drag in progress, so call `DragEnd` again
+  without it.
+- If the control's document is disabled or destroyed during a split drag, the next `DragMove`
+  or `DragEnd` fails and the drag ends. A one-shot `Drag` stops sending and still succeeds.
+- If a UI Toolkit handler throws, the button is released and the exception ends the command.
+  A `DragMove` that throws leaves the drag in progress, as a cancelled `DragMove` does.
+
 ## Not supported
 
 - `--bypass-raycast`, `--target-path`, and `--drop-target-path` take GameObject paths only;
   a UI Toolkit `Path` (it contains `#`) is reported as not found.
-- Drag actions go through the uGUI EventSystem only.
 - World-space panels (Unity 6), as in the annotation.
 - Two panels with the same `sortingOrder` overlapping at the point: Unity orders them by
   creation order, which is not exposed, so either one may be chosen.
 
 ## Notes
 
-- Move the real mouse cursor out of the Game View while simulating. Real pointer input over
-  the Game View reaches the same panels and can interleave with the simulated press.
+- Move the real mouse cursor out of the Game View while simulating, and keep it away between
+  `DragStart` and `DragEnd`. Real pointer input over the Game View reaches the same panels and
+  can interleave with the simulated press or move a held slider.
 - Device Simulator has the same limits as the annotation: coordinates use the simulated device
   resolution.
diff --git a/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/UIToolkitDragSession.cs b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/UIToolkitDragSession.cs
new file mode 100644
index 0000000000..19c93776fb
--- /dev/null
+++ b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/UIToolkitDragSession.cs
@@ -0,0 +1,78 @@
+#nullable enable
+using UnityEngine;
+
+namespace io.github.hatayama.UnityCliLoop.FirstPartyTools
+{
+    /// <summary>
+    /// A drag on a UI Toolkit control: the left button is pressed on the control, moved, and released through
+    /// its panel, so controls that capture the pointer (Slider, Scroller) follow it as with real input.
+    /// </summary>
+    internal sealed class UIToolkitDragSession : IMouseUiDragSession
+    {
+        private const int LeftButton = 0;
+
+        private readonly UIToolkitPointerTarget _target;
+        private Vector2 _currentInputPosition;
+
+        private UIToolkitDragSession(UIToolkitPointerTarget target, Vector2 inputStart)
+        {
+            _target = target;
+            _currentInputPosition = inputStart;
+            Report = new MouseUiHitReport(target.Name, target.Path, MouseUiHitSystem.UIToolkit);
+        }
+
+        /// <summary>
+        /// Presses the left button on the control at the start point.
+        /// </summary>
+        // UI Toolkit passes handler exceptions on to the sender; a press that throws is released before the
+        // exception leaves, since no session exists yet to release it later.
+        internal static UIToolkitDragSession Begin(UIToolkitPointerTarget target, Vector2 inputStart)
+        {
+            bool pressed = false;
+            try
+            {
+                target.PressDown(inputStart, LeftButton);
+                pressed = true;
+            }
+            finally
+            {
+                if (!pressed)
+                {
+                    target.Release(inputStart, LeftButton);
+                }
+            }
+
+            return new UIToolkitDragSession(target, inputStart);
+        }
+
+        public MouseUiHitReport Report { get; }
+
+        // Stored as an input position: UI Toolkit maps Game View points itself and never goes through Screen.
+        public Vector2 CurrentInputPosition => _currentInputPosition;
+
+        public bool IsTargetDestroyed => _target.IsDocumentDestroyed;
+
+        public bool UsesEventSystem => false;
+
+        // No "interrupted" check as uGUI has: some controls never capture the pointer, so the lack of a capture
+        // cannot tell an interrupted drag from a normal one.
+        public string? CheckStillActive()
+        {
+            return _target.IsAvailable
+                ? null
+                : "Drag target UI Toolkit element is no longer available (its document was disabled or destroyed).";
+        }
+
+        public void MoveTo(Vector2 inputPosition)
+        {
+            _target.MoveTo(inputPosition);
+            _currentInputPosition = inputPosition;
+        }
+
+        // Callers refuse a drop target before a UI Toolkit drag starts or ends, so none reaches here.
+        public void Finish(GameObject? explicitDropTarget)
+        {
+            _target.Release(_currentInputPosition, LeftButton);
+        }
+    }
+}
diff --git a/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/UIToolkitDragSession.cs.meta b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/UIToolkitDragSession.cs.meta
new file mode 100644
index 0000000000..e57a5b28da
--- /dev/null
+++ b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/UIToolkitDragSession.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: b24745134b0d44ab6ad2ed49346d0edd
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/UguiDragSession.cs b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/UguiDragSession.cs
new file mode 100644
index 0000000000..4f05787a27
--- /dev/null
+++ b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/UguiDragSession.cs
@@ -0,0 +1,81 @@
+#nullable enable
+using UnityEngine;
+using UnityEngine.EventSystems;
+
+namespace io.github.hatayama.UnityCliLoop.FirstPartyTools
+{
+    /// <summary>
+    /// A drag on a uGUI or physics IDragHandler, driven through the EventSystem's pointer events.
+    /// </summary>
+    internal sealed class UguiDragSession : IMouseUiDragSession
+    {
+        private readonly PointerEventData _pointerData;
+        private readonly GameObject _target;
+
+        private UguiDragSession(PointerEventData pointerData, GameObject target)
+        {
+            _pointerData = pointerData;
+            _target = target;
+            Report = MouseUiGameObjectHitReport.Create(target);
+        }
+
+        /// <summary>
+        /// Presses on the start raycast and sends beginDrag to the drag handler.
+        /// </summary>
+        internal static UguiDragSession Begin(
+            EventSystem eventSystem,
+            Vector2 screenPos,
+            RaycastResult startRaycast,
+            GameObject target)
+        {
+            // uGUI drag controls (ScrollRect, Slider) only respond to left-button drags
+            PointerEventData pointerData = MouseUiDragEventExecutor.InitiateDrag(
+                eventSystem, screenPos, startRaycast, target, PointerEventData.InputButton.Left);
+            ExecuteEvents.Execute(target, pointerData, ExecuteEvents.beginDragHandler);
+            pointerData.dragging = true;
+            return new UguiDragSession(pointerData, target);
+        }
+
+        public MouseUiHitReport Report { get; }
+
+        // Derived from the stored screen position with the current Game View height rather than stored as an
+        // input position, so a split drag continues from the same screen point if the Game View is resized.
+        public Vector2 CurrentInputPosition => MouseUiCoordinateConverter.ScreenToInput(_pointerData.position);
+
+        public bool IsTargetDestroyed => _target == null;
+
+        public bool UsesEventSystem => true;
+
+        // User input during a CLI drag can cause Unity's StandaloneInputModule to
+        // release or reassign the drag, leaving the stored session stale.
+        public string? CheckStillActive()
+        {
+            if (!_target.activeInHierarchy)
+            {
+                return "Drag target was destroyed or deactivated during drag.";
+            }
+
+            if (!_pointerData.dragging || _pointerData.pointerDrag != _target)
+            {
+                return "Drag was interrupted by user input or system event.";
+            }
+
+            return null;
+        }
+
+        public void MoveTo(Vector2 inputPosition)
+        {
+            Vector2 screenPosition = MouseUiCoordinateConverter.InputToScreen(inputPosition);
+            Vector2 previousPosition = _pointerData.position;
+            _pointerData.position = screenPosition;
+            _pointerData.delta = screenPosition - previousPosition;
+            MouseUiInputSystemSync.SyncMousePosition(screenPosition);
+            ExecuteEvents.Execute(_target, _pointerData, ExecuteEvents.dragHandler);
+        }
+
+        public void Finish(GameObject? explicitDropTarget)
+        {
+            MouseUiDragEventExecutor.FinalizeDrag(_pointerData, _target, explicitDropTarget);
+        }
+    }
+}
diff --git a/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/UguiDragSession.cs.meta b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/UguiDragSession.cs.meta
new file mode 100644
index 0000000000..400210f5d3
--- /dev/null
+++ b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/UguiDragSession.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 148da36fe4aef42229f20a15a164c074
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/UguiPressTarget.cs b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/UguiPressTarget.cs
index ada219b6d9..808b9c7b5d 100644
--- a/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/UguiPressTarget.cs
+++ b/Packages/src/Editor/FirstPartyTools/SimulateMouseUi/UguiPressTarget.cs
@@ -23,26 +23,11 @@ internal UguiPressTarget(ResolvedPointerTargets resolvedTargets, PointerEventDat
             // UnityEngine.Object targets for null is not safe.
             bool shouldReleasePointer = resolvedTargets.RawTarget != null && resolvedTargets.Target != null;
             _shouldReleasePointer = shouldReleasePointer;
-            Report = CreateReport(resolvedTargets.Target);
+            Report = MouseUiGameObjectHitReport.Create(resolvedTargets.Target);
         }
 
         public MouseUiHitReport Report { get; }
 
-        // Decided by whether the handler sits under a Canvas rather than by raycaster type, because a bypass
-        // press has no raycaster and both paths must report alike.
-        private static MouseUiHitReport CreateReport(GameObject? target)
-        {
-            if (target == null)
-            {
-                return MouseUiHitReport.None;
-            }
-
-            string uiSystem = target.GetComponentInParent<Canvas>() != null
-                ? MouseUiHitSystem.UGUI
-                : MouseUiHitSystem.NonUi;
-            return new MouseUiHitReport(target.name, GameObjectPathUtility.GetFullPath(target), uiSystem);
-        }
-
         public void Click()
         {
             if (_resolvedTargets.RawTarget == null)
diff --git a/scripts/test-screenshot-uitoolkit-annotation.ps1 b/scripts/test-screenshot-uitoolkit-annotation.ps1
index a5371d6d4d..1795660cce 100644
--- a/scripts/test-screenshot-uitoolkit-annotation.ps1
+++ b/scripts/test-screenshot-uitoolkit-annotation.ps1
@@ -1,6 +1,6 @@
 <#
 E2E verification that screenshot --annotate-elements lists UI Toolkit controls and that simulate-mouse-ui and
-simulate-mouse-input press them at the annotated points, using the uloop CLI against UIToolkitAnnotationDemoScene.
+simulate-mouse-input press and drag them at the annotated points, using the uloop CLI against UIToolkitAnnotationDemoScene.
 Safe to run repeatedly: it stops PlayMode and restores the Game View size on exit, and never saves the scene, so
 the listener and EventSystem changes made in PlayMode are discarded.
 
@@ -583,6 +583,63 @@ return GameObject.Find("ugui-button").GetComponentInChildren<Text>().text;
     Assert-EqualText -Actual (Invoke-DynamicCodeText -Code $labelCode -Context "Read ugui-button label") -Expected "clicked 1" -Context "ugui-button label"
 }
 
+function Get-SliderValue {
+    [string]$code = @'
+UIToolkitAnnotationDemo demo = UnityEngine.Object.FindObjectOfType<UIToolkitAnnotationDemo>();
+if (demo == null) { return "ERROR: UIToolkitAnnotationDemo not found"; }
+return demo.GetSliderValue("volume").ToString(System.Globalization.CultureInfo.InvariantCulture);
+'@
+    [string]$value = Invoke-DynamicCodeText -Code $code -Context "Read volume value"
+    if ($value.StartsWith("ERROR:") -or $value -eq "NaN") {
+        throw "Read volume value failed: $value"
+    }
+
+    return [double]::Parse($value, [Globalization.CultureInfo]::InvariantCulture)
+}
+
+function Assert-InRange {
+    param(
+        [double]$Value,
+        [double]$Min,
+        [double]$Max,
+        [string]$Context
+    )
+
+    Assert-Condition -Condition ($Value -ge $Min -and $Value -le $Max) -Message "${Context}: expected $Min..$Max, got $Value"
+}
+
+function Test-OneShotDrag {
+    param(
+        [pscustomobject]$ElementsOnly
+    )
+
+    [pscustomobject]$volume = Get-AnnotatedElement -Response $ElementsOnly -UiSystem "UIToolkit" -Name "volume"
+    [pscustomobject]$response = Invoke-SimulateUi -Context "simulate-mouse-ui drag on volume" -Arguments @(
+        "--action", "Drag",
+        "--from-x", (Format-Coordinate ($volume.BoundsMinX + 5)), "--from-y", (Format-Coordinate $volume.SimY),
+        "--x", (Format-Coordinate ($volume.BoundsMaxX - 5)), "--y", (Format-Coordinate $volume.SimY))
+    Assert-EqualText -Actual $response.UiSystem -Expected "UIToolkit" -Context "simulate-mouse-ui drag on volume UiSystem"
+    Assert-InRange -Value (Get-SliderValue) -Min 0.9 -Max 1 -Context "volume after a drag to its right edge"
+}
+
+function Test-SplitDrag {
+    param(
+        [pscustomobject]$ElementsOnly
+    )
+
+    [pscustomobject]$volume = Get-AnnotatedElement -Response $ElementsOnly -UiSystem "UIToolkit" -Name "volume"
+    [string]$y = Format-Coordinate $volume.SimY
+    [double]$left = $volume.BoundsMinX + 5
+    [double]$right = $volume.BoundsMaxX - 5
+    [string]$center = Format-Coordinate (($left + $right) / 2)
+
+    Invoke-SimulateUi -Context "simulate-mouse-ui DragStart on volume" -Arguments @("--action", "DragStart", "--x", (Format-Coordinate $left), "--y", $y) | Out-Null
+    Invoke-SimulateUi -Context "simulate-mouse-ui DragMove on volume" -Arguments @("--action", "DragMove", "--x", $center, "--y", $y) | Out-Null
+    Assert-InRange -Value (Get-SliderValue) -Min 0.3 -Max 0.7 -Context "volume after DragMove to its centre"
+    Invoke-SimulateUi -Context "simulate-mouse-ui DragEnd on volume" -Arguments @("--action", "DragEnd", "--x", (Format-Coordinate $left), "--y", $y) | Out-Null
+    Assert-InRange -Value (Get-SliderValue) -Min 0 -Max 0.1 -Context "volume after DragEnd at its left edge"
+}
+
 # Runs last: the EventSystem stays disabled until PlayMode stops on exit.
 function Test-ClickWithoutEventSystem {
     param(
@@ -618,42 +675,48 @@ Wait-UnityReady
 [pscustomobject]$originalGameViewSize = $null
 
 try {
-    Write-Host "[1/12] Loading UI Toolkit annotation demo scene..."
+    Write-Host "[1/14] Loading UI Toolkit annotation demo scene..."
     Initialize-DemoScene
 
-    Write-Host "[2/12] Selecting Full HD Game View resolution..."
+    Write-Host "[2/14] Selecting Full HD Game View resolution..."
     $originalGameViewSize = Select-FullHdGameView
 
-    Write-Host "[3/12] Starting PlayMode and waiting for UI Toolkit controls..."
+    Write-Host "[3/14] Starting PlayMode and waiting for UI Toolkit controls..."
     Invoke-UloopJson -CommandArguments @("control-play-mode", "--action", "Play") | Out-Null
     Wait-PlayMode
     Wait-UiToolkitPlay
 
-    Write-Host "[4/12] Checking the annotated capture..."
+    Write-Host "[4/14] Checking the annotated capture..."
     [pscustomobject]$annotated = Test-AnnotatedCapture
 
-    Write-Host "[5/12] Checking the elements-only capture matches..."
+    Write-Host "[5/14] Checking the elements-only capture matches..."
     [pscustomobject]$elementsOnly = Test-ElementsOnlyCapture -AnnotatedResponse $annotated
 
-    Write-Host "[6/12] Clicking UI Toolkit controls with simulate-mouse-ui..."
+    Write-Host "[6/14] Clicking UI Toolkit controls with simulate-mouse-ui..."
     Test-UiClick -ElementsOnly $elementsOnly
 
-    Write-Host "[7/12] Clicking a UI Toolkit button with simulate-mouse-input..."
+    Write-Host "[7/14] Clicking a UI Toolkit button with simulate-mouse-input..."
     Test-InputClick -ElementsOnly $elementsOnly
 
-    Write-Host "[8/12] Clicking a partly covered UI Toolkit button..."
+    Write-Host "[8/14] Clicking a partly covered UI Toolkit button..."
     Test-CoveredClick -ElementsOnly $elementsOnly
 
-    Write-Host "[9/12] Clicking a disabled UI Toolkit button..."
+    Write-Host "[9/14] Clicking a disabled UI Toolkit button..."
     Test-DisabledClick
 
-    Write-Host "[10/12] Long-pressing a UI Toolkit button..."
+    Write-Host "[10/14] Long-pressing a UI Toolkit button..."
     Test-LongPress -ElementsOnly $elementsOnly
 
-    Write-Host "[11/12] Clicking the uGUI button with simulate-mouse-ui..."
+    Write-Host "[11/14] Clicking the uGUI button with simulate-mouse-ui..."
     Test-UguiClick -ElementsOnly $elementsOnly
 
-    Write-Host "[12/12] Clicking a UI Toolkit button without an EventSystem..."
+    Write-Host "[12/14] Dragging a UI Toolkit slider in one shot..."
+    Test-OneShotDrag -ElementsOnly $elementsOnly
+
+    Write-Host "[13/14] Dragging a UI Toolkit slider in steps..."
+    Test-SplitDrag -ElementsOnly $elementsOnly
+
+    Write-Host "[14/14] Clicking a UI Toolkit button without an EventSystem..."
     Test-ClickWithoutEventSystem -ElementsOnly $elementsOnly
 
     Write-Host ""
diff --git a/scripts/test-screenshot-uitoolkit-annotation.sh b/scripts/test-screenshot-uitoolkit-annotation.sh
index 6c9359e017..e198563289 100755
--- a/scripts/test-screenshot-uitoolkit-annotation.sh
+++ b/scripts/test-screenshot-uitoolkit-annotation.sh
@@ -1,6 +1,6 @@
 #!/bin/sh
 # E2E verification that screenshot --annotate-elements lists UI Toolkit controls and that simulate-mouse-ui and
-# simulate-mouse-input press them at the annotated points, using the uloop CLI against
+# simulate-mouse-input press and drag them at the annotated points, using the uloop CLI against
 # UIToolkitAnnotationDemoScene. Safe to run repeatedly: it stops PlayMode and restores the Game View size on
 # exit, and never saves the scene, so the listener and EventSystem changes made in PlayMode are discarded.
 
@@ -419,6 +419,62 @@ return GameObject.Find("ugui-button").GetComponentInChildren<Text>().text;
     assert_text_equals "$(printf '%s\n' "$json" | jq -r '.Result')" "clicked 1" "ugui-button label"
 }
 
+get_slider_value() {
+    json=$(run_uloop_json execute-dynamic-code --code '
+UIToolkitAnnotationDemo demo = UnityEngine.Object.FindObjectOfType<UIToolkitAnnotationDemo>();
+if (demo == null) { return "ERROR: UIToolkitAnnotationDemo not found"; }
+return demo.GetSliderValue("volume").ToString(System.Globalization.CultureInfo.InvariantCulture);
+')
+    assert_json_success "$json" "Read volume value"
+    value=$(printf '%s\n' "$json" | jq -r '.Result')
+    case "$value" in
+        ERROR:*|NaN)
+            fail "Read volume value failed: $value"
+            ;;
+    esac
+    printf '%s\n' "$value"
+}
+
+# Fails unless the number is within [min, max].
+assert_in_range() {
+    value=$1
+    min=$2
+    max=$3
+    context=$4
+    jq -e -n --argjson v "$value" --argjson min "$min" --argjson max "$max" '$v >= $min and $v <= $max' >/dev/null \
+        || fail "$context: expected $min..$max, got $value"
+}
+
+VOLUME_SELECTOR='.UiSystem == "UIToolkit" and .Name == "volume"'
+
+# Points 5 pixels inside the slider's left and right edges, on its annotated row.
+volume_left_x() {
+    jq -n --argjson min "$(annotated_field "$VOLUME_SELECTOR" BoundsMinX)" '$min + 5'
+}
+
+volume_right_x() {
+    jq -n --argjson max "$(annotated_field "$VOLUME_SELECTOR" BoundsMaxX)" '$max - 5'
+}
+
+verify_one_shot_drag() {
+    y=$(annotated_field "$VOLUME_SELECTOR" SimY)
+    json=$(simulate_ui "simulate-mouse-ui drag on volume" --action Drag \
+        --from-x "$(volume_left_x)" --from-y "$y" --x "$(volume_right_x)" --y "$y")
+    assert_response_field "$json" UiSystem "UIToolkit" "simulate-mouse-ui drag on volume"
+    assert_in_range "$(get_slider_value)" 0.9 1 "volume after a drag to its right edge"
+}
+
+verify_split_drag() {
+    y=$(annotated_field "$VOLUME_SELECTOR" SimY)
+    center_x=$(jq -n --argjson l "$(volume_left_x)" --argjson r "$(volume_right_x)" '($l + $r) / 2')
+
+    simulate_ui "simulate-mouse-ui DragStart on volume" --action DragStart --x "$(volume_left_x)" --y "$y" >/dev/null
+    simulate_ui "simulate-mouse-ui DragMove on volume" --action DragMove --x "$center_x" --y "$y" >/dev/null
+    assert_in_range "$(get_slider_value)" 0.3 0.7 "volume after DragMove to its centre"
+    simulate_ui "simulate-mouse-ui DragEnd on volume" --action DragEnd --x "$(volume_left_x)" --y "$y" >/dev/null
+    assert_in_range "$(get_slider_value)" 0 0.1 "volume after DragEnd at its left edge"
+}
+
 # Runs last: the EventSystem stays disabled until PlayMode stops on exit.
 verify_click_without_event_system() {
     json=$(run_uloop_json execute-dynamic-code --code '
@@ -448,42 +504,48 @@ printf '=========================================\n'
 
 wait_unity_ready
 
-printf '[1/12] Loading UI Toolkit annotation demo scene...\n'
+printf '[1/14] Loading UI Toolkit annotation demo scene...\n'
 initialize_demo_scene
 
-printf '[2/12] Selecting Full HD Game View resolution...\n'
+printf '[2/14] Selecting Full HD Game View resolution...\n'
 select_full_hd_game_view
 
-printf '[3/12] Starting PlayMode and waiting for UI Toolkit controls...\n'
+printf '[3/14] Starting PlayMode and waiting for UI Toolkit controls...\n'
 run_uloop_json control-play-mode --action Play >/dev/null
 wait_play_mode
 wait_for_uitoolkit_play
 
-printf '[4/12] Checking the annotated capture...\n'
+printf '[4/14] Checking the annotated capture...\n'
 verify_annotated_capture
 
-printf '[5/12] Checking the elements-only capture matches...\n'
+printf '[5/14] Checking the elements-only capture matches...\n'
 verify_elements_only_capture
 
-printf '[6/12] Clicking UI Toolkit controls with simulate-mouse-ui...\n'
+printf '[6/14] Clicking UI Toolkit controls with simulate-mouse-ui...\n'
 verify_ui_click
 
-printf '[7/12] Clicking a UI Toolkit button with simulate-mouse-input...\n'
+printf '[7/14] Clicking a UI Toolkit button with simulate-mouse-input...\n'
 verify_input_click
 
-printf '[8/12] Clicking a partly covered UI Toolkit button...\n'
+printf '[8/14] Clicking a partly covered UI Toolkit button...\n'
 verify_covered_click
 
-printf '[9/12] Clicking a disabled UI Toolkit button...\n'
+printf '[9/14] Clicking a disabled UI Toolkit button...\n'
 verify_disabled_click
 
-printf '[10/12] Long-pressing a UI Toolkit button...\n'
+printf '[10/14] Long-pressing a UI Toolkit button...\n'
 verify_long_press
 
-printf '[11/12] Clicking the uGUI button with simulate-mouse-ui...\n'
+printf '[11/14] Clicking the uGUI button with simulate-mouse-ui...\n'
 verify_ugui_click
 
-printf '[12/12] Clicking a UI Toolkit button without an EventSystem...\n'
+printf '[12/14] Dragging a UI Toolkit slider in one shot...\n'
+verify_one_shot_drag
+
+printf '[13/14] Dragging a UI Toolkit slider in steps...\n'
+verify_split_drag
+
+printf '[14/14] Clicking a UI Toolkit button without an EventSystem...\n'
 verify_click_without_event_system
 
 printf '\n'