From 8091db33366b294b4ac0bae137d54eac4d2b1c4d Mon Sep 17 00:00:00 2001
From: hatayama <booqle@gmail.com>
Date: Tue, 13 Oct 2026 20:21:57 +0900
Subject: [PATCH 01/10] feat: tag annotated elements with the UI system they
 came from

Annotated screenshots are about to list UI Toolkit controls next to uGUI
ones, and a caller needs to tell them apart because only uGUI paths can
be fed back to simulate-mouse-ui --target-path. Add a UiSystem field to
UIElementInfo and set it to "UGUI" for every uGUI element; PhysicsCollider
elements leave it empty.

The value strings live in the Screenshot assembly rather than in
ToolContracts, which only holds the contract shape.
---
 .../Editor/UIElementAnnotatorCollectTests.cs  | 20 +++++++++++++++++++
 .../Screenshot/AnnotatedUiSystem.cs           | 12 +++++++++++
 .../Screenshot/AnnotatedUiSystem.cs.meta      | 11 ++++++++++
 .../Screenshot/UIElementAnnotator.cs          |  1 +
 .../src/Editor/ToolContracts/UIElementInfo.cs |  1 +
 5 files changed, 45 insertions(+)
 create mode 100644 Packages/src/Editor/FirstPartyTools/Screenshot/AnnotatedUiSystem.cs
 create mode 100644 Packages/src/Editor/FirstPartyTools/Screenshot/AnnotatedUiSystem.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/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..d3d5a8ad80 100644
--- a/Packages/src/Editor/FirstPartyTools/Screenshot/UIElementAnnotator.cs
+++ b/Packages/src/Editor/FirstPartyTools/Screenshot/UIElementAnnotator.cs
@@ -232,6 +232,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/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 8b144aaed8f568811aec0258d0f511fa783a34f2 Mon Sep 17 00:00:00 2001
From: hatayama <booqle@gmail.com>
Date: Tue, 13 Oct 2026 20:24:39 +0900
Subject: [PATCH 02/10] feat: invert UI Toolkit screen-to-panel functions for
 annotation bounds

Unity has no panel-to-screen API, and a PanelSettings can replace the
screen-to-panel function with an arbitrary one. To report a control's
bounds in screen pixels, sample the forward function at three points to
derive a per-axis scale and offset, and check a fourth point to reject
functions that are non-linear, sheared, rotated, swapped, or non-finite.
A rejected panel cannot have its controls placed on the screenshot.
---
 .../Editor/UIToolkitScreenMappingTests.cs     | 105 ++++++++++++++++++
 .../UIToolkitScreenMappingTests.cs.meta       |  11 ++
 .../Screenshot/UIToolkitAnnotation.meta       |   8 ++
 .../UIToolkitScreenMapping.cs                 |  80 +++++++++++++
 .../UIToolkitScreenMapping.cs.meta            |  11 ++
 5 files changed, 215 insertions(+)
 create mode 100644 Assets/Tests/Editor/UIToolkitScreenMappingTests.cs
 create mode 100644 Assets/Tests/Editor/UIToolkitScreenMappingTests.cs.meta
 create mode 100644 Packages/src/Editor/FirstPartyTools/Screenshot/UIToolkitAnnotation.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/UIToolkitScreenMappingTests.cs b/Assets/Tests/Editor/UIToolkitScreenMappingTests.cs
new file mode 100644
index 0000000000..5ce410b264
--- /dev/null
+++ b/Assets/Tests/Editor/UIToolkitScreenMappingTests.cs
@@ -0,0 +1,105 @@
+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 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/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/UIToolkitScreenMapping.cs b/Packages/src/Editor/FirstPartyTools/Screenshot/UIToolkitAnnotation/UIToolkitScreenMapping.cs
new file mode 100644
index 0000000000..76685edd69
--- /dev/null
+++ b/Packages/src/Editor/FirstPartyTools/Screenshot/UIToolkitAnnotation/UIToolkitScreenMapping.cs
@@ -0,0 +1,80 @@
+#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, 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;
+            if (Mathf.Abs(scaleX) < MIN_SCALE || Mathf.Abs(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: 

From 2b63d9b744623bf63d7b0f8a315fb2a9cde29261 Mon Sep 17 00:00:00 2001
From: hatayama <booqle@gmail.com>
Date: Tue, 13 Oct 2026 20:24:40 +0900
Subject: [PATCH 03/10] feat: classify UI Toolkit controls with the uGUI
 annotation types

Map Button/RepeatButton, Toggle/RadioButton, Scroller, the sliders,
TextField, and DropdownField/EnumField to the same type words the uGUI
annotator uses, so the existing interaction mapping covers both UI
systems. Every other element, including plain elements with a Clickable,
is not annotated.
---
 .../Editor/UIToolkitElementClassifierTests.cs | 37 +++++++++++++++++++
 .../UIToolkitElementClassifierTests.cs.meta   | 11 ++++++
 .../UIToolkitElementClassifier.cs             | 24 ++++++++++++
 .../UIToolkitElementClassifier.cs.meta        | 11 ++++++
 4 files changed, 83 insertions(+)
 create mode 100644 Assets/Tests/Editor/UIToolkitElementClassifierTests.cs
 create mode 100644 Assets/Tests/Editor/UIToolkitElementClassifierTests.cs.meta
 create mode 100644 Packages/src/Editor/FirstPartyTools/Screenshot/UIToolkitAnnotation/UIToolkitElementClassifier.cs
 create mode 100644 Packages/src/Editor/FirstPartyTools/Screenshot/UIToolkitAnnotation/UIToolkitElementClassifier.cs.meta

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/Packages/src/Editor/FirstPartyTools/Screenshot/UIToolkitAnnotation/UIToolkitElementClassifier.cs b/Packages/src/Editor/FirstPartyTools/Screenshot/UIToolkitAnnotation/UIToolkitElementClassifier.cs
new file mode 100644
index 0000000000..848194cdd2
--- /dev/null
+++ b/Packages/src/Editor/FirstPartyTools/Screenshot/UIToolkitAnnotation/UIToolkitElementClassifier.cs
@@ -0,0 +1,24 @@
+#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: 

From 8ba0aa558d8ede4034aebea5ea6dbb47a19687aa Mon Sep 17 00:00:00 2001
From: hatayama <booqle@gmail.com>
Date: Tue, 13 Oct 2026 20:24:40 +0900
Subject: [PATCH 04/10] feat: find the probe point where input reaches a UI
 Toolkit control

Mirror the uGUI reachability check for UI Toolkit: walk the same probe
points, skip a point when any panel in front picks something there
(Unity routes the input to that panel), and accept the first point where
the control's own panel picks the control or one of its descendants.
The logic takes picker functions so it can be tested without a panel.
---
 .../Editor/UIToolkitReachabilityProbeTests.cs | 131 ++++++++++++++++++
 .../UIToolkitReachabilityProbeTests.cs.meta   |  11 ++
 .../UIToolkitReachabilityProbe.cs             |  76 ++++++++++
 .../UIToolkitReachabilityProbe.cs.meta        |  11 ++
 4 files changed, 229 insertions(+)
 create mode 100644 Assets/Tests/Editor/UIToolkitReachabilityProbeTests.cs
 create mode 100644 Assets/Tests/Editor/UIToolkitReachabilityProbeTests.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

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/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: 

From d6c60c80a36fd9aee27448102f0714ffe99feea0 Mon Sep 17 00:00:00 2001
From: hatayama <booqle@gmail.com>
Date: Tue, 13 Oct 2026 20:34:52 +0900
Subject: [PATCH 05/10] test: commit the default runtime theme Unity generates
 for new PanelSettings

Creating a PanelSettings in the Editor runs PanelSettings.Reset, which
assigns the first ThemeStyleSheet in Assets and, when there is none,
writes this default theme and refreshes the AssetDatabase. Committing it
keeps tests that create PanelSettings from regenerating it, and the
refresh, on every fresh checkout.
---
 Assets/UI Toolkit.meta                                |  8 ++++++++
 Assets/UI Toolkit/UnityThemes.meta                    |  8 ++++++++
 .../UnityThemes/UnityDefaultRuntimeTheme.tss          |  1 +
 .../UnityThemes/UnityDefaultRuntimeTheme.tss.meta     | 11 +++++++++++
 4 files changed, 28 insertions(+)
 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

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

From dcdfb83f80ca199dadff9b397ed6837be0eaa767 Mon Sep 17 00:00:00 2001
From: hatayama <booqle@gmail.com>
Date: Tue, 13 Oct 2026 20:34:52 +0900
Subject: [PATCH 06/10] feat: annotate UI Toolkit controls on screen-space
 panels

Annotated screenshots only listed uGUI elements, so controls on a
UIDocument were invisible to agents. Collect them alongside uGUI:

- Walk every active top-level UIDocument whose panel shows on the Game
  View's display and is not world-space; nested documents are reached
  through their parent's root so nothing is listed twice.
- Settle every panel's layout first (Pick is the only public call that
  validates it), so controls added in the same frame report real bounds.
- Report the controls UIToolkitElementClassifier recognizes, skipping
  disabled, hidden, and display:none subtrees and the parts inside a
  control such as a Scroller's buttons.
- Convert bounds to bottom-left screen pixels with the inverted panel
  mapping, then probe the same points as uGUI. Panels with a higher
  sorting order, including ones that render into a texture, cover the
  control because Unity routes screen input to them first.
- Panels rendering into a texture or without an invertible mapping list
  nothing but still cover others.

PlayMode tests build panels in code and pin each row of this behavior;
the PlayMode test assembly now references the Screenshot assembly.
---
 .../Tests/Editor/UIToolkitPanelKindTests.cs   |  29 ++
 .../Editor/UIToolkitPanelKindTests.cs.meta    |  11 +
 .../UIToolkitElementCollectorTests.cs         | 422 ++++++++++++++++++
 .../UIToolkitElementCollectorTests.cs.meta    |  11 +
 .../UnityCLILoop.Tests.PlayMode.asmdef        |   3 +-
 .../Screenshot/UIElementAnnotator.cs          |   1 +
 .../UIToolkitElementCollector.cs              | 319 +++++++++++++
 .../UIToolkitElementCollector.cs.meta         |  11 +
 .../UIToolkitAnnotation/UIToolkitPanelKind.cs |  31 ++
 .../UIToolkitPanelKind.cs.meta                |  11 +
 10 files changed, 848 insertions(+), 1 deletion(-)
 create mode 100644 Assets/Tests/Editor/UIToolkitPanelKindTests.cs
 create mode 100644 Assets/Tests/Editor/UIToolkitPanelKindTests.cs.meta
 create mode 100644 Assets/Tests/PlayMode/UIToolkitElementCollectorTests.cs
 create mode 100644 Assets/Tests/PlayMode/UIToolkitElementCollectorTests.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

diff --git a/Assets/Tests/Editor/UIToolkitPanelKindTests.cs b/Assets/Tests/Editor/UIToolkitPanelKindTests.cs
new file mode 100644
index 0000000000..8d13b56b0e
--- /dev/null
+++ b/Assets/Tests/Editor/UIToolkitPanelKindTests.cs
@@ -0,0 +1,29 @@
+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.
+    /// </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);
+        }
+    }
+}
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/PlayMode/UIToolkitElementCollectorTests.cs b/Assets/Tests/PlayMode/UIToolkitElementCollectorTests.cs
new file mode 100644
index 0000000000..e1ea0c169e
--- /dev/null
+++ b/Assets/Tests/PlayMode/UIToolkitElementCollectorTests.cs
@@ -0,0 +1,422 @@
+using System.Collections;
+using System.Collections.Generic;
+using NUnit.Framework;
+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. Panels are built in code without a theme, so every element size is
+    /// set explicitly, and 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 screenHeight = Screen.height;
+            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, screenHeight - (Top + Height), Left + Width, screenHeight - Top);
+            Assert.That(element.SimX, Is.EqualTo(Left + Width / 2f).Within(Tolerance));
+            Assert.That(element.SimY, Is.EqualTo(screenHeight - (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 screenHeight = Screen.height;
+            AssertBounds(matches[0], Left * 2f, screenHeight - (Top + Height) * 2f, (Left + Width) * 2f, screenHeight - Top * 2f);
+            Assert.That(matches[0].SimX, Is.EqualTo((Left + Width / 2f) * 2f).Within(Tolerance));
+            Assert.That(matches[0].SimY, Is.EqualTo(screenHeight - (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 screenHeight = Screen.height;
+            Assert.That(matches[0].SimX, Is.EqualTo(Left + Width * 0.75f).Within(Tolerance));
+            Assert.That(matches[0].SimY, Is.EqualTo(screenHeight - (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 screenHeight = Screen.height;
+            AssertBounds(matches[0], Left, screenHeight - (Top + Height), Left + Width, screenHeight - 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/Packages/src/Editor/FirstPartyTools/Screenshot/UIElementAnnotator.cs b/Packages/src/Editor/FirstPartyTools/Screenshot/UIElementAnnotator.cs
index d3d5a8ad80..cc5a0c5399 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);
 
             return elements;
         }
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..655fad7292
--- /dev/null
+++ b/Packages/src/Editor/FirstPartyTools/Screenshot/UIToolkitAnnotation/UIToolkitElementCollector.cs
@@ -0,0 +1,319 @@
+#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)
+        {
+            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(
+                    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;
+            }
+
+            // Screen.height, not the Game View size, because Unity flips input with Screen.height before handing
+            // it to the panel.
+            float screenHeight = Screen.height;
+            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,
+                screenHeight - topLeftMax.y,
+                topLeftMax.x,
+                screenHeight - topLeftMin.y);
+
+            Vector2? reachable = FindReachablePoint(element, bottomLeftBounds, screenHeight, context);
+            if (reachable == null)
+            {
+                return;
+            }
+
+            context.Elements.Add(CreateElementInfo(
+                element, type, document, context.Entry, bottomLeftBounds, new Vector2(reachable.Value.x, screenHeight - 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 screenHeight, VisitContext context)
+        {
+            Vector2[] bottomLeftProbes = UIElementAnnotator.GenerateReachabilityProbePoints(
+                bottomLeftBounds.xMin, bottomLeftBounds.yMin, bottomLeftBounds.xMax, bottomLeftBounds.yMax);
+            Vector2[] topLeftProbes = bottomLeftProbes
+                .Select(probe => new Vector2(probe.x, screenHeight - 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(
+                PanelEntry entry,
+                UIToolkitScreenMapping mapping,
+                List<Func<Vector2, VisualElement?>> frontPickers,
+                Func<Vector2, VisualElement?> ownPicker,
+                List<UIElementInfo> elements)
+            {
+                Entry = entry;
+                Mapping = mapping;
+                FrontPickers = frontPickers;
+                OwnPicker = ownPicker;
+                Elements = elements;
+            }
+
+            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..c41fd927f3
--- /dev/null
+++ b/Packages/src/Editor/FirstPartyTools/Screenshot/UIToolkitAnnotation/UIToolkitPanelKind.cs
@@ -0,0 +1,31 @@
+#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)
+        {
+            PropertyInfo? property = typeof(PanelSettings).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: 

From 962d51d654bdcf55513638e4c3e22c756e2150d8 Mon Sep 17 00:00:00 2001
From: hatayama <booqle@gmail.com>
Date: Tue, 13 Oct 2026 21:03:03 +0900
Subject: [PATCH 07/10] fix: reject mirrored UI Toolkit panel mappings

A screen-to-panel function that mirrors an axis has a negative scale.
Inverting it swaps the panel rectangle's minimum and maximum, so the
reported bounds had BoundsMin greater than BoundsMax. Treat a negative
scale like a zero one: the panel's controls are not listed.
---
 Assets/Tests/Editor/UIToolkitScreenMappingTests.cs  | 13 +++++++++++++
 .../UIToolkitAnnotation/UIToolkitScreenMapping.cs   |  6 ++++--
 2 files changed, 17 insertions(+), 2 deletions(-)

diff --git a/Assets/Tests/Editor/UIToolkitScreenMappingTests.cs b/Assets/Tests/Editor/UIToolkitScreenMappingTests.cs
index 5ce410b264..e320793d71 100644
--- a/Assets/Tests/Editor/UIToolkitScreenMappingTests.cs
+++ b/Assets/Tests/Editor/UIToolkitScreenMappingTests.cs
@@ -79,6 +79,19 @@ public void TryCreate_WithSwappedAxes_ShouldReturnNull()
             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>
diff --git a/Packages/src/Editor/FirstPartyTools/Screenshot/UIToolkitAnnotation/UIToolkitScreenMapping.cs b/Packages/src/Editor/FirstPartyTools/Screenshot/UIToolkitAnnotation/UIToolkitScreenMapping.cs
index 76685edd69..b0a2c3bc26 100644
--- a/Packages/src/Editor/FirstPartyTools/Screenshot/UIToolkitAnnotation/UIToolkitScreenMapping.cs
+++ b/Packages/src/Editor/FirstPartyTools/Screenshot/UIToolkitAnnotation/UIToolkitScreenMapping.cs
@@ -29,7 +29,7 @@ private UIToolkitScreenMapping(Vector2 origin, float scaleX, float 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, or non-finite), because no screen rectangle would
+        // 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)
         {
@@ -50,7 +50,9 @@ private UIToolkitScreenMapping(Vector2 origin, float scaleX, float scaleY)
 
             float scaleX = (unitX.x - origin.x) / SAMPLE;
             float scaleY = (unitY.y - origin.y) / SAMPLE;
-            if (Mathf.Abs(scaleX) < MIN_SCALE || Mathf.Abs(scaleY) < MIN_SCALE)
+            // 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;
             }

From 9ca85fff0e07a62a564ca54e648caa2949f755f4 Mon Sep 17 00:00:00 2001
From: hatayama <booqle@gmail.com>
Date: Tue, 13 Oct 2026 21:03:03 +0900
Subject: [PATCH 08/10] chore: brace classifier branches and correct the
 collector test summary

Write each classifier branch as a braced block like the rest of the
package, and state in the PlayMode test summary that PanelSettings.Reset
assigns the project's default theme, which is why element sizes are set
explicitly.
---
 .../UIToolkitElementCollectorTests.cs         |  5 +--
 .../UIToolkitElementClassifier.cs             | 36 +++++++++++++++----
 2 files changed, 33 insertions(+), 8 deletions(-)

diff --git a/Assets/Tests/PlayMode/UIToolkitElementCollectorTests.cs b/Assets/Tests/PlayMode/UIToolkitElementCollectorTests.cs
index e1ea0c169e..09b5289f41 100644
--- a/Assets/Tests/PlayMode/UIToolkitElementCollectorTests.cs
+++ b/Assets/Tests/PlayMode/UIToolkitElementCollectorTests.cs
@@ -12,8 +12,9 @@ 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. Panels are built in code without a theme, so every element size is
-    /// set explicitly, and every object is destroyed in TearDown.
+    /// 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
     {
diff --git a/Packages/src/Editor/FirstPartyTools/Screenshot/UIToolkitAnnotation/UIToolkitElementClassifier.cs b/Packages/src/Editor/FirstPartyTools/Screenshot/UIToolkitAnnotation/UIToolkitElementClassifier.cs
index 848194cdd2..10f2d19f36 100644
--- a/Packages/src/Editor/FirstPartyTools/Screenshot/UIToolkitAnnotation/UIToolkitElementClassifier.cs
+++ b/Packages/src/Editor/FirstPartyTools/Screenshot/UIToolkitAnnotation/UIToolkitElementClassifier.cs
@@ -12,12 +12,36 @@ 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";
+            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;
         }
     }

From b6f12386ac2d78d79259953590c22894e1d386e8 Mon Sep 17 00:00:00 2001
From: hatayama <booqle@gmail.com>
Date: Tue, 13 Oct 2026 21:11:02 +0900
Subject: [PATCH 09/10] test: check the world-space render mode lookup with
 stand-in types

The world-space check only ever ran its "no renderMode property" path:
the project's Unity 2022.3 has no PanelSettings.renderMode, and CI's
Unity 6 EditMode legs do not run these tests. Move the check into
HasWorldSpaceRenderMode, which looks the property up on the object's
runtime type, and test it with stand-in types for an internal WorldSpace
value, a public screen-space value, and a missing property.
---
 .../Tests/Editor/UIToolkitPanelKindTests.cs   | 62 ++++++++++++++++++-
 .../UIToolkitAnnotation/UIToolkitPanelKind.cs | 10 ++-
 2 files changed, 70 insertions(+), 2 deletions(-)

diff --git a/Assets/Tests/Editor/UIToolkitPanelKindTests.cs b/Assets/Tests/Editor/UIToolkitPanelKindTests.cs
index 8d13b56b0e..18c59d76a5 100644
--- a/Assets/Tests/Editor/UIToolkitPanelKindTests.cs
+++ b/Assets/Tests/Editor/UIToolkitPanelKindTests.cs
@@ -7,7 +7,8 @@
 namespace io.github.hatayama.UnityCliLoop.Tests.Editor
 {
     /// <summary>
-    /// Verifies how panels are told apart as world-space or screen-space.
+    /// 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
     {
@@ -25,5 +26,64 @@ public void IsWorldSpace_WithDefaultPanelSettings_ShouldReturnFalse()
             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/Packages/src/Editor/FirstPartyTools/Screenshot/UIToolkitAnnotation/UIToolkitPanelKind.cs b/Packages/src/Editor/FirstPartyTools/Screenshot/UIToolkitAnnotation/UIToolkitPanelKind.cs
index c41fd927f3..e1c26e1e7b 100644
--- a/Packages/src/Editor/FirstPartyTools/Screenshot/UIToolkitAnnotation/UIToolkitPanelKind.cs
+++ b/Packages/src/Editor/FirstPartyTools/Screenshot/UIToolkitAnnotation/UIToolkitPanelKind.cs
@@ -16,7 +16,15 @@ internal static class UIToolkitPanelKind
         // version defines cannot tell patch versions apart. 2022.3 has no such property and no world-space panels.
         internal static bool IsWorldSpace(PanelSettings settings)
         {
-            PropertyInfo? property = typeof(PanelSettings).GetProperty(
+            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)

From fc37c5a3237a1fa30cb0090966aeb72a29931a52 Mon Sep 17 00:00:00 2001
From: hatayama <booqle@gmail.com>
Date: Tue, 13 Oct 2026 21:14:45 +0900
Subject: [PATCH 10/10] fix: flip UI Toolkit annotation bounds with the Game
 View height

Annotated UI Toolkit controls came out with the wrong Y in a real
screenshot (a button at top 100 reported Y -218..-168 in a 1080-high
Game View). The collector flipped to a bottom-left origin with
Screen.height, but uloop commands run outside the player loop, where
Screen reports the last Editor view drawn (1398 high here), while
ConvertToSimCoordinates flips back with the Game View height.

Pass the Game View height into the collector, the same source the
overlay renderer and coordinate conversion use, and stop reading Screen
there. PlayMode tests ran inside the player loop, where both heights
match, so a new test passes a height unlike Screen.height.
---
 .../UIToolkitElementCollectorTests.cs         | 43 ++++++++++++++-----
 .../Screenshot/UIElementAnnotator.cs          |  2 +-
 .../UIToolkitElementCollector.cs              | 25 ++++++-----
 3 files changed, 49 insertions(+), 21 deletions(-)

diff --git a/Assets/Tests/PlayMode/UIToolkitElementCollectorTests.cs b/Assets/Tests/PlayMode/UIToolkitElementCollectorTests.cs
index 09b5289f41..a76444ee37 100644
--- a/Assets/Tests/PlayMode/UIToolkitElementCollectorTests.cs
+++ b/Assets/Tests/PlayMode/UIToolkitElementCollectorTests.cs
@@ -1,6 +1,7 @@
 using System.Collections;
 using System.Collections.Generic;
 using NUnit.Framework;
+using UnityEditor;
 using UnityEngine;
 using UnityEngine.TestTools;
 using UnityEngine.UIElements;
@@ -56,15 +57,37 @@ public IEnumerator Collect_ButtonOnOverlayPanel_ShouldReportBoundsAndCenter()
 
             Assert.That(matches.Count, Is.EqualTo(1));
             UIElementInfo element = matches[0];
-            float screenHeight = Screen.height;
+            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, screenHeight - (Top + Height), Left + Width, screenHeight - Top);
+            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(screenHeight - (Top + Height / 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>
@@ -82,10 +105,10 @@ public IEnumerator Collect_PanelScale_ShouldScaleBounds()
             List<UIElementInfo> matches = CollectFrom("Scaled");
 
             Assert.That(matches.Count, Is.EqualTo(1));
-            float screenHeight = Screen.height;
-            AssertBounds(matches[0], Left * 2f, screenHeight - (Top + Height) * 2f, (Left + Width) * 2f, screenHeight - Top * 2f);
+            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(screenHeight - (Top + Height / 2f) * 2f).Within(Tolerance));
+            Assert.That(matches[0].SimY, Is.EqualTo(gameViewHeight - (Top + Height / 2f) * 2f).Within(Tolerance));
         }
 
         /// <summary>
@@ -104,9 +127,9 @@ public IEnumerator Collect_FrontPanelCoversCenter_ShouldUseUncoveredProbe()
             List<UIElementInfo> matches = CollectFrom("PartlyCovered#");
 
             Assert.That(matches.Count, Is.EqualTo(1));
-            float screenHeight = Screen.height;
+            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(screenHeight - (Top + Height) + Height * 0.25f).Within(Tolerance));
+            Assert.That(matches[0].SimY, Is.EqualTo(gameViewHeight - (Top + Height) + Height * 0.25f).Within(Tolerance));
         }
 
         /// <summary>
@@ -248,8 +271,8 @@ public IEnumerator Collect_ButtonAddedInSameFrame_ShouldReportLaidOutBounds()
             List<UIElementInfo> matches = CollectFrom("SameFrame");
 
             Assert.That(matches.Count, Is.EqualTo(1));
-            float screenHeight = Screen.height;
-            AssertBounds(matches[0], Left, screenHeight - (Top + Height), Left + Width, screenHeight - Top);
+            float gameViewHeight = Handles.GetMainGameViewSize().y;
+            AssertBounds(matches[0], Left, gameViewHeight - (Top + Height), Left + Width, gameViewHeight - Top);
         }
 
         /// <summary>
diff --git a/Packages/src/Editor/FirstPartyTools/Screenshot/UIElementAnnotator.cs b/Packages/src/Editor/FirstPartyTools/Screenshot/UIElementAnnotator.cs
index cc5a0c5399..fdf2bcf9c7 100644
--- a/Packages/src/Editor/FirstPartyTools/Screenshot/UIElementAnnotator.cs
+++ b/Packages/src/Editor/FirstPartyTools/Screenshot/UIElementAnnotator.cs
@@ -28,7 +28,7 @@ public static List<UIElementInfo> CollectInteractiveElements()
 
             CollectSelectables(elements, processedObjects, raycastContext);
             CollectEventHandlers(elements, processedObjects, raycastContext);
-            UIToolkitElementCollector.Collect(elements);
+            UIToolkitElementCollector.Collect(elements, GameViewCoordinateUtility.GetMainGameViewSize().y);
 
             return elements;
         }
diff --git a/Packages/src/Editor/FirstPartyTools/Screenshot/UIToolkitAnnotation/UIToolkitElementCollector.cs b/Packages/src/Editor/FirstPartyTools/Screenshot/UIToolkitAnnotation/UIToolkitElementCollector.cs
index 655fad7292..86fe5059b9 100644
--- a/Packages/src/Editor/FirstPartyTools/Screenshot/UIToolkitAnnotation/UIToolkitElementCollector.cs
+++ b/Packages/src/Editor/FirstPartyTools/Screenshot/UIToolkitAnnotation/UIToolkitElementCollector.cs
@@ -19,7 +19,7 @@ internal static class UIToolkitElementCollector
         private const char PATH_SEPARATOR = '#';
         private const string CHAIN_SEPARATOR = "/";
 
-        internal static void Collect(List<UIElementInfo> elements)
+        internal static void Collect(List<UIElementInfo> elements, float gameViewHeight)
         {
             List<PanelEntry> panels = GatherPanels();
 
@@ -39,6 +39,7 @@ internal static void Collect(List<UIElementInfo> elements)
                 }
 
                 VisitContext context = new VisitContext(
+                    gameViewHeight,
                     entry,
                     entry.Mapping,
                     CreateFrontPickers(panels, entry),
@@ -183,35 +184,36 @@ private static void TryAdd(VisualElement element, string type, UIDocument docume
                 return;
             }
 
-            // Screen.height, not the Game View size, because Unity flips input with Screen.height before handing
-            // it to the panel.
-            float screenHeight = Screen.height;
+            // 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,
-                screenHeight - topLeftMax.y,
+                gameViewHeight - topLeftMax.y,
                 topLeftMax.x,
-                screenHeight - topLeftMin.y);
+                gameViewHeight - topLeftMin.y);
 
-            Vector2? reachable = FindReachablePoint(element, bottomLeftBounds, screenHeight, context);
+            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, screenHeight - reachable.Value.y)));
+                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 screenHeight, VisitContext context)
+            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, screenHeight - probe.y))
+                .Select(probe => new Vector2(probe.x, gameViewHeight - probe.y))
                 .ToArray();
             return UIToolkitReachabilityProbe.FindReachablePoint(
                 topLeftProbes, element, context.FrontPickers, context.OwnPicker);
@@ -296,12 +298,14 @@ internal PanelEntry(IPanel panel, float sortingOrder, UIToolkitScreenMapping? ma
         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;
@@ -309,6 +313,7 @@ internal VisitContext(
                 Elements = elements;
             }
 
+            internal float GameViewHeight { get; }
             internal PanelEntry Entry { get; }
             internal UIToolkitScreenMapping Mapping { get; }
             internal List<Func<Vector2, VisualElement?>> FrontPickers { get; }