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