chore: state the DevicePixelRatio contract as a local guarantee

The fixture's class summary and the carried-over sdk7-test-scenes plan both
described DevicePixelRatio as the divisor scenes apply to resolve vh/vw and
virtual-scale sizing. js-sdk-toolchain #1489 (on main 2026-08-12) took the
ratio out of layout entirely: calcOnViewport now resolves vw/vh from width and
height alone and leaves ScaleContext.ratio unread, and scaleFontSize resolves
through that same call. The summary therefore asserted a consumer contract the
consumer no longer honours - the failure mode CLAUDE.md names when it bans
comments that narrate external behaviour, since that behaviour moved without
this file changing. The summary now states only what the system under test
guarantees: it reports the scene panel's own physical-pixels-per-UI-point
density and republishes when that density or the viewport moves.

The same stale premise would have made the skipped scene unfalsifiable: watching
a vw/vh box resize proves nothing about the ratio on a current SDK. FIXNOTES now
has the verification read the printed value, names Label (react-ecs exports no
UiText), and points at src/index.ts, which mirrors only width and height into
the scene's canvasInfo today.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_018c638dR1vPysCMbYt2qQg5

Also includes (squashed): fix: publish the ratio the device-pixel-ratio dirty check compared
WriteToCRDT() re-read the live panel through GetDevicePixelRatio() even though
UpdateUICanvasInformationComponent() had computed and cached that same value one
statement earlier, so the gate and the payload were two independent reads of a
mutable panel property - the ratio that passed the dirty check was not necessarily
the ratio scenes received. Initialize() now seeds lastDevicePixelRatio before its
unconditional publish, which lets both write paths emit the cached field and makes
the published ratio the one the gate is keyed on. It also removes a second panel
read per republish.

The fixture now covers the dirty check this change touches: no republish when
neither the viewport nor the panel ratio moves, and a republish carrying the new
ratio when the panel scale does, driven through the injectable UIDocument /
PanelSettings seam. That republish case is also what bounds the unattached-panel
window at startup - a panel that attaches after Initialize() is picked up by the
next tick. The class comment lost its incident narration and its citation of a
local investigation directory that exists in no repo, and the single captured
message became a published-message list, which drops the null-forgiving read.

The SDK-facing half - an sdk7-test-scenes scene plus two-monitor verification
steps for the changed DevicePixelRatio semantics - belongs in that separate public
repo; FIXNOTES.md carries the scene sketch and the manual steps.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_018c638dR1vPysCMbYt2qQg5

Author: eordano

Explorer/Assets/DCL/SDKComponents/SceneUI/Systems/UICanvasInformation/UICanvasInformationSystem.cs

@@ -30,6 +30,7 @@ public override void Initialize()
             base.Initialize();
 
             interactableArea = new BorderRect { Bottom = 0, Left = Screen.width * 0.25f, Right = 0, Top = 0 };
+            lastDevicePixelRatio = GetDevicePixelRatio();
 
             WriteToCRDT();
         }
@@ -81,7 +82,7 @@ private void WriteToCRDT()
                 component.InteractableArea = system.interactableArea;
                 component.Width = Screen.width;
                 component.Height = Screen.height;
-                component.DevicePixelRatio = system.GetDevicePixelRatio();
+                component.DevicePixelRatio = system.lastDevicePixelRatio;
             }, SpecialEntitiesID.SCENE_ROOT_ENTITY, this);
         }
     }

Explorer/Assets/DCL/SDKComponents/SceneUI/Tests/UICanvasInformationSystemShould.cs

@@ -1,6 +1,7 @@
 using Arch.Core;
 using Arch.SystemGroups;
 using CRDT;
+using CrdtEcsBridge.Components.Special;
 using CrdtEcsBridge.ECSToCRDTWriter;
 using DCL.ECSComponents;
 using DCL.SDKComponents.SceneUI.Systems.UICanvasInformation;
@@ -10,52 +11,42 @@
 using NUnit.Framework;
 using SceneRunner.Scene;
 using System;
+using System.Collections.Generic;
 using UnityEngine;
 using UnityEngine.UIElements;
 
 namespace DCL.SDKComponents.SceneUI.Tests
 {
-    // Regression coverage for the dpr-vh-vw-positionunit bug: UICanvasInformationSystem used to
-    // publish DevicePixelRatio = Screen.mainWindowDisplayInfo.width / Screen.width (the
-    // monitor-native-width / window-client-width ratio). That quantity is not a device pixel
-    // ratio for unity-explorer's scene UI - the scene panel (DCLScenePanelSettings) is
-    // ConstantPixelSize @ scale 1, so 1 UI-Toolkit point == 1 framebuffer pixel regardless of
-    // which monitor hosts the window or its native resolution. Scenes derive vh/vw (and, since
-    // js-sdk-toolchain #1433, every virtual-screen-scaled px value and scaleFontSize) from this
-    // field via `points = (dim / 100) * (scale / devicePixelRatio)`, so the bogus ratio silently
-    // mis-sizes `vw`/`vh` elements and live-resizes them when the window crosses monitors.
-    //
-    // The fix plumbs the scene UIDocument into the system and reports the panel's own
-    // `scaledPixelsPerPoint` (1.0f fallback while unattached) instead of the monitor/window
-    // ratio - see report.md "## Patch" and potential-fix.patch in
-    // bugreports-late-jul/dpr-vh-vw-positionunit/.
+    /// <summary>
+    ///     Pins the contract of PBUiCanvasInformation.DevicePixelRatio: it reports the scene panel's own
+    ///     physical-pixels-per-UI-point density, republished whenever that density or the viewport moves.
+    /// </summary>
     public class UICanvasInformationSystemShould : UnitySystemTestBase<UICanvasInformationSystem>
     {
-        // Deliberately NOT 1.0 (the system's own unattached-panel fallback) and NOT a common OS
-        // DPI preset (100/125/150/175/200/225/250/300/350%): this isolates the injected-UIDocument
-        // seam from the OLD formula's monitorWidth/windowWidth ratio. Screen and
-        // Screen.mainWindowDisplayInfo are static Unity APIs with no injectable abstraction - the
-        // ROBUST patch variant is testable only because it additionally plumbs a UIDocument, which
-        // IS injectable. The OLD formula is a ratio of two real screen-pixel widths in the test
-        // runner's own window/monitor; landing on exactly 2.75 by coincidence is not realistic.
+        /// <summary>Panel scale the system is expected to report verbatim; deliberately not the unattached-panel fallback of 1.</summary>
         private const float SCENE_PANEL_SCALE = 2.75f;
 
+        /// <summary>Panel scale applied mid-test to move the ratio and trip the dirty check.</summary>
+        private const float RESCALED_SCENE_PANEL_SCALE = 1.5f;
+
+        /// <summary>Tolerance for comparing a reported ratio against the panel scale that produced it.</summary>
+        private const float RATIO_TOLERANCE = 0.001f;
+
+        private readonly List<PBUiCanvasInformation> publishedComponents = new ();
+
         private IECSToCRDTWriter ecsToCRDTWriter;
         private GameObject canvasGameObject;
         private PanelSettings panelSettings;
         private UIDocument canvas;
-        private PBUiCanvasInformation? capturedComponent;
 
         [SetUp]
         public void SetUp()
         {
+            publishedComponents.Clear();
             ecsToCRDTWriter = Substitute.For<IECSToCRDTWriter>();
-            capturedComponent = null;
 
-            // UICanvasInformationSystem.WriteToCRDT() rents the message from the writer and
-            // populates it via a static delegate - capture that delegate and invoke it against a
-            // fresh instance to observe what would have been written, exactly as the real
-            // IECSToCRDTWriter implementation would.
+            // The system never touches the message itself: it hands the writer a static delegate that
+            // fills a rented instance, so the delegate has to be run to observe what would be written.
             ecsToCRDTWriter
                .When(x => x.PutMessage(
                     Arg.Any<Action<PBUiCanvasInformation, UICanvasInformationSystem>>(),
@@ -67,11 +58,10 @@ public void SetUp()
                     var data = callInfo.Arg<UICanvasInformationSystem>();
                     var component = new PBUiCanvasInformation();
                     prepareMessage(component, data);
-                    capturedComponent = component;
+                    publishedComponents.Add(component);
                 });
 
-            // ConstantPixelSize mirrors the shipped DCLScenePanelSettings.asset (m_ScaleMode: 0)
-            // but with a scale the OLD Screen-ratio formula cannot plausibly reproduce.
+            // ConstantPixelSize mirrors the shipped DCLScenePanelSettings.asset (m_ScaleMode: 0).
             panelSettings = ScriptableObject.CreateInstance<PanelSettings>();
             panelSettings.scaleMode = PanelScaleMode.ConstantPixelSize;
             panelSettings.scale = SCENE_PANEL_SCALE;
@@ -80,14 +70,17 @@ public void SetUp()
             canvas = canvasGameObject.AddComponent<UIDocument>();
             canvas.panelSettings = panelSettings;
 
+            Assert.That(canvas.rootVisualElement?.panel, Is.Not.Null,
+                "The scene UIDocument must be attached to a live panel, otherwise the system reports its unattached fallback instead of the panel ratio.");
+
             var builder = new ArchSystemsWorldBuilder<World>(world);
 
-            // UICanvasInformationSystem is [UpdateInGroup(typeof(SyncedInitializationSystemGroup))] -
-            // a CUSTOM group, so it must be injected into the builder before the system is, exactly as
-            // production does in ECSWorldFactory.cs (InjectCustomGroup(new SyncedInitializationSystemGroup(...))).
-            // Otherwise InjectToWorld throws Arch.SystemGroups.GroupNotFoundException in SetUp.
+            // SyncedInitializationSystemGroup is a custom group: InjectToWorld throws GroupNotFoundException
+            // unless it is injected first, as production does in ECSWorldFactory.
             builder.InjectCustomGroup(new SyncedInitializationSystemGroup(Substitute.For<ISceneStateProvider>()));
             system = UICanvasInformationSystem.InjectToWorld(ref builder, ecsToCRDTWriter, canvas);
+
+            world.Create(new SceneRootComponent());
         }
 
         protected override void OnTearDown()
@@ -102,22 +95,36 @@ protected override void OnTearDown()
         [Test]
         public void ReportScenePanelPixelsPerPointAsDevicePixelRatio()
         {
-            // Arrange-time invariant: the seam only exercises the fixed code path once the
-            // UIDocument is actually attached to a live panel.
-            Assert.That(canvas.rootVisualElement, Is.Not.Null);
-            Assert.That(canvas.rootVisualElement.panel, Is.Not.Null);
+            system.Initialize();
+
+            Assert.That(publishedComponents, Is.Not.Empty, "Initialize() must publish a PBUiCanvasInformation via PutMessage.");
+            Assert.That(publishedComponents[0].DevicePixelRatio, Is.EqualTo(SCENE_PANEL_SCALE).Within(RATIO_TOLERANCE));
+        }
 
-            // Act - Initialize() publishes unconditionally (bypasses the dirty-check).
+        [Test]
+        public void NotRepublishWhenViewportAndPixelsPerPointAreUnchanged()
+        {
+            system.Initialize();
+            system.Update(0);
+
+            int publishedAfterFirstUpdate = publishedComponents.Count;
+            system.Update(0);
+
+            Assert.That(publishedComponents.Count, Is.EqualTo(publishedAfterFirstUpdate), "A tick that changes neither the viewport nor the panel ratio must not republish.");
+        }
+
+        [Test]
+        public void RepublishWhenScenePanelPixelsPerPointChanges()
+        {
             system.Initialize();
+            system.Update(0);
 
-            // Assert
-            Assert.That(capturedComponent, Is.Not.Null, "UICanvasInformationSystem.Initialize() must publish a PBUiCanvasInformation via PutMessage.");
+            int publishedAfterFirstUpdate = publishedComponents.Count;
+            panelSettings.scale = RESCALED_SCENE_PANEL_SCALE;
+            system.Update(0);
 
-            // Pre-fix: DevicePixelRatio = Screen.mainWindowDisplayInfo.width / Screen.width (the
-            // monitor/window ratio) - unrelated to SCENE_PANEL_SCALE, so this fails.
-            // Post-fix: DevicePixelRatio = canvas.rootVisualElement.scaledPixelsPerPoint, i.e.
-            // exactly the configured panel scale, so this passes.
-            Assert.That(capturedComponent!.DevicePixelRatio, Is.EqualTo(SCENE_PANEL_SCALE).Within(0.001f));
+            Assert.That(publishedComponents.Count, Is.EqualTo(publishedAfterFirstUpdate + 1));
+            Assert.That(publishedComponents[^1].DevicePixelRatio, Is.EqualTo(RESCALED_SCENE_PANEL_SCALE).Within(RATIO_TOLERANCE));
         }
     }
 }