feat(audience): normalize platform/osFamily wire values, add isEditor (SDK-343)

- platform now sends Windows, macOS, Linux, iOS, Android. WindowsPlayer/WindowsEditor and OSXPlayer/OSXEditor and LinuxPlayer/LinuxEditor each collapse to one OS string. Studios no longer need LIKE 'Windows%' to filter by OS.
- osFamily rewrites MacOSX to macOS so the wire value matches Apple's branding. Windows, Linux, Other unchanged.
- New isEditor bool on game_launch sources from Application.isEditor. Replaces the Player vs Editor signal previously buried inside platform, so studios can filter dev runs cleanly.
- Unmapped RuntimePlatform values (console, WebGL, server builds) still fall back to the raw enum string so console traffic is not silently dropped.
- DeviceCollectorTests covers the new mappings and isEditor true/false. ImmutableAudienceTests provider example updated to "Windows".

Breaking wire-format change. Blocks immutable/documentation#83 (SDK-319).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: ImmutableJeffrey

src/Packages/Audience/Runtime/Unity/DeviceCollector.cs

@@ -47,16 +47,21 @@ internal static Dictionary<string, object> CollectContext()
         }
 
         internal static Dictionary<string, object> CollectGameLaunchProperties(
-            RuntimePlatform? platformOverride = null)
+            RuntimePlatform? platformOverride = null,
+            OperatingSystemFamily? osFamilyOverride = null,
+            bool? isEditorOverride = null)
         {
             var platform = platformOverride ?? Application.platform;
+            var osFamily = osFamilyOverride ?? SystemInfo.operatingSystemFamily;
+            var isEditor = isEditorOverride ?? Application.isEditor;
             var props = new Dictionary<string, object>
             {
                 ["platform"] = PlatformName(platform),
+                ["isEditor"] = isEditor,
                 ["version"] = Truncate(Application.version, 256),
                 ["buildGuid"] = Truncate(Application.buildGUID, 256),
                 ["unityVersion"] = Truncate(Application.unityVersion, 256),
-                ["osFamily"] = SystemInfo.operatingSystemFamily.ToString(),
+                ["osFamily"] = OsFamilyName(osFamily),
                 ["deviceModel"] = Truncate(SystemInfo.deviceModel, 256),
                 ["gpu"] = Truncate(SystemInfo.graphicsDeviceName, 256),
                 ["gpuVendor"] = Truncate(SystemInfo.graphicsDeviceVendor, 256),
@@ -106,10 +111,20 @@ internal static Dictionary<string, object> CollectGameLaunchProperties(
 
         private static string PlatformName(RuntimePlatform platform) => platform switch
         {
+            RuntimePlatform.WindowsPlayer or RuntimePlatform.WindowsEditor => "Windows",
+            RuntimePlatform.OSXPlayer or RuntimePlatform.OSXEditor => "macOS",
+            RuntimePlatform.LinuxPlayer or RuntimePlatform.LinuxEditor => "Linux",
             RuntimePlatform.IPhonePlayer => "iOS",
+            RuntimePlatform.Android => "Android",
             _ => platform.ToString(),
         };
 
+        private static string OsFamilyName(OperatingSystemFamily family) => family switch
+        {
+            OperatingSystemFamily.MacOSX => "macOS",
+            _ => family.ToString(),
+        };
+
         private static string Truncate(string s, int max)
         {
             if (string.IsNullOrEmpty(s) || s.Length <= max) return s;

src/Packages/Audience/Tests/Runtime/ImmutableAudienceTests.cs

@@ -1187,7 +1187,7 @@ public void Init_GameLaunch_IncludesLaunchContextProviderFields()
         {
             ImmutableAudience.LaunchContextProvider = () => new Dictionary<string, object>
             {
-                ["platform"] = "WindowsPlayer",
+                ["platform"] = "Windows",
                 ["version"] = "1.2.3",
                 ["buildGuid"] = "a1b2c3d4e5f6",
                 ["unityVersion"] = "2022.3.20f1",
@@ -1201,7 +1201,7 @@ public void Init_GameLaunch_IncludesLaunchContextProviderFields()
                 .Select(File.ReadAllText)
                 .FirstOrDefault(c => c.Contains("\"game_launch\""));
             Assert.IsNotNull(launchFile, "game_launch should have been enqueued");
-            StringAssert.Contains("\"platform\":\"WindowsPlayer\"", launchFile);
+            StringAssert.Contains("\"platform\":\"Windows\"", launchFile);
             StringAssert.Contains("\"version\":\"1.2.3\"", launchFile);
             StringAssert.Contains("\"buildGuid\":\"a1b2c3d4e5f6\"", launchFile);
             StringAssert.Contains("\"unityVersion\":\"2022.3.20f1\"", launchFile);

src/Packages/Audience/Tests/Runtime/Unity/DeviceCollectorTests.cs

@@ -52,7 +52,7 @@ public void CollectGameLaunchProperties_AlwaysContainsCrossPlatformFields()
         {
             var props = DeviceCollector.CollectGameLaunchProperties();
             foreach (var key in new[] {
-                "platform", "version", "buildGuid", "unityVersion",
+                "platform", "isEditor", "version", "buildGuid", "unityVersion",
                 "osFamily", "deviceModel", "gpu", "gpuVendor",
                 "cpu", "cpuCores", "ramMb" })
             {
@@ -134,11 +134,67 @@ public void CollectGameLaunchProperties_NonIOS_DoesNotContainIdfv()
         }
 
         [Test]
-        public void CollectGameLaunchProperties_iOS_ContainsPlatformIPhonePlayer()
+        public void CollectGameLaunchProperties_iOS_PlatformIsIOS()
         {
             IDFVBridge.Impl = () => null;
             var props = DeviceCollector.CollectGameLaunchProperties(RuntimePlatform.IPhonePlayer);
             Assert.AreEqual("iOS", props["platform"]);
         }
+
+        // -----------------------------------------------------------------
+        // PlatformName mapping: collapse Player/Editor variants to OS name
+        // -----------------------------------------------------------------
+
+        [TestCase(RuntimePlatform.WindowsPlayer, "Windows")]
+        [TestCase(RuntimePlatform.WindowsEditor, "Windows")]
+        [TestCase(RuntimePlatform.OSXPlayer, "macOS")]
+        [TestCase(RuntimePlatform.OSXEditor, "macOS")]
+        [TestCase(RuntimePlatform.LinuxPlayer, "Linux")]
+        [TestCase(RuntimePlatform.LinuxEditor, "Linux")]
+        [TestCase(RuntimePlatform.IPhonePlayer, "iOS")]
+        [TestCase(RuntimePlatform.Android, "Android")]
+        public void CollectGameLaunchProperties_Platform_MapsToLaymanName(
+            RuntimePlatform input, string expected)
+        {
+            var props = DeviceCollector.CollectGameLaunchProperties(input);
+            Assert.AreEqual(expected, props["platform"]);
+        }
+
+        [Test]
+        public void CollectGameLaunchProperties_Platform_UnmappedFallsBackToEnumName()
+        {
+            // Console / unsupported targets must not be silently dropped.
+            var props = DeviceCollector.CollectGameLaunchProperties(RuntimePlatform.WebGLPlayer);
+            Assert.AreEqual("WebGLPlayer", props["platform"]);
+        }
+
+        // -----------------------------------------------------------------
+        // OsFamily mapping: rewrite Unity's MacOSX to Apple's macOS
+        // -----------------------------------------------------------------
+
+        [TestCase(OperatingSystemFamily.Windows, "Windows")]
+        [TestCase(OperatingSystemFamily.MacOSX, "macOS")]
+        [TestCase(OperatingSystemFamily.Linux, "Linux")]
+        [TestCase(OperatingSystemFamily.Other, "Other")]
+        public void CollectGameLaunchProperties_OsFamily_MapsToLaymanName(
+            OperatingSystemFamily input, string expected)
+        {
+            var props = DeviceCollector.CollectGameLaunchProperties(
+                osFamilyOverride: input);
+            Assert.AreEqual(expected, props["osFamily"]);
+        }
+
+        // -----------------------------------------------------------------
+        // isEditor: distinguishes dev runs from production player traffic
+        // -----------------------------------------------------------------
+
+        [TestCase(true)]
+        [TestCase(false)]
+        public void CollectGameLaunchProperties_IsEditor_ReflectsOverride(bool isEditor)
+        {
+            var props = DeviceCollector.CollectGameLaunchProperties(
+                isEditorOverride: isEditor);
+            Assert.AreEqual(isEditor, props["isEditor"]);
+        }
     }
 }