feat(audience): auto-collect Epic account ID and detect Epic platform

- Calls AuthInterface.GetLoggedInAccountByIndex(0) after EOS login to get
  the player's EpicAccountId and fires an identify event with
  identity_type='epic'.
- Sets distribution_platform='epic' when the game was launched from EGS
  (detected via -EpicPortal / -epicapp= / -epicenv= CLI args).
- ResolveEosManagerType: added com.playeveryware.eos.core fallback so UPM
  installs of the PlayEveryWare plugin are found without Assembly-CSharp.
- TryGetEpicAccountId guard: checks com.Epic.OnlineServices first (UPM
  install), then falls back to EOSSDK (legacy DLL install); previously
  only checked EOSSDK so UPM installs were silently skipped.
- link.xml: changed from assembly-level to type-level preserve="all" for
  Epic types; assembly-level only protects type declarations, not method
  metadata, so GetLoggedInAccountsCount was stripped under IL2CPP High
  stripping and returned null from reflection. Added entries for both
  com.Epic.OnlineServices (UPM) and EOSSDK/PlayEveryWare (legacy).
- examples/audience/Assets/link.xml: mirrors the same Epic rules because
  Unity's linker skips package link.xml when the package is referenced
  via a file: path outside the project tree.
- examples: added MacOSBuilder headless build script, StandaloneAutoTest
  EOS Account Portal login path (--eos-account-portal), and .gitignore
  for EOS credential files.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: nattb8

examples/audience/.gitignore

@@ -0,0 +1,3 @@
+.env
+Assets/StreamingAssets/EOS/EpicOnlineServicesConfig.json
+Assets/StreamingAssets/EOS/eos_macos_config.json

examples/audience/Assets/Editor/MacOSBuilder.cs

@@ -0,0 +1,52 @@
+#nullable enable
+
+using System;
+using UnityEditor;
+using UnityEngine;
+
+namespace Immutable.Audience.Samples.SampleApp.Editor
+{
+    // Invoked by CI / local debugging via:
+    //   Unity -batchmode -buildTarget StandaloneOSX \
+    //         -executeMethod Immutable.Audience.Samples.SampleApp.Editor.MacOSBuilder.Build \
+    //         -quit
+    //
+    // Optional CLI arg:
+    //   --buildPath <path>   Output path for the .app (default: Builds/macOS/SampleApp.app)
+    internal static class MacOSBuilder
+    {
+        private const string DefaultBuildPath = "Builds/macOS/SampleApp.app";
+
+        public static void Build()
+        {
+            string buildPath = GetArgValue("--buildPath") ?? DefaultBuildPath;
+
+            var options = new BuildPlayerOptions
+            {
+                scenes = new[] { "Assets/SampleApp/Scenes/SampleApp.unity" },
+                locationPathName = buildPath,
+                target = BuildTarget.StandaloneOSX,
+                targetGroup = BuildTargetGroup.Standalone,
+                options = BuildOptions.None,
+            };
+
+            Debug.Log($"[MacOSBuilder] Building → {buildPath}");
+
+            var report = BuildPipeline.BuildPlayer(options);
+            var summary = report.summary;
+
+            if (summary.result == UnityEditor.Build.Reporting.BuildResult.Succeeded)
+                Debug.Log($"[MacOSBuilder] Build succeeded ({summary.totalSize / 1024 / 1024} MB).");
+            else
+                throw new Exception($"[MacOSBuilder] Build failed: {summary.result}");
+        }
+
+        private static string? GetArgValue(string key)
+        {
+            var args = Environment.GetCommandLineArgs();
+            for (int i = 0; i < args.Length - 1; i++)
+                if (args[i] == key) return args[i + 1];
+            return null;
+        }
+    }
+}

examples/audience/Assets/Editor/MacOSBuilder.cs.meta

@@ -1,7 +1,7 @@
 {
     "name": "Immutable.Audience.Samples.SampleApp",
     "rootNamespace": "Immutable.Audience.Samples.SampleApp",
-    "references": ["Immutable.Audience.Runtime"],
+    "references": ["Immutable.Audience.Runtime", "com.playeveryware.eos.core", "com.Epic.OnlineServices"],
     "includePlatforms": [],
     "excludePlatforms": [],
     "allowUnsafeCode": false,

examples/audience/Assets/SampleApp/Scripts/Immutable.Audience.Samples.SampleApp.asmdef

@@ -0,0 +1,232 @@
+#nullable enable
+
+#if UNITY_STANDALONE_OSX || UNITY_STANDALONE_WIN || UNITY_STANDALONE_LINUX
+
+using System;
+using System.Threading.Tasks;
+using UnityEngine;
+using PlayEveryWare.EpicOnlineServices;
+using Epic.OnlineServices.Auth;
+using Epic.OnlineServices;
+
+namespace Immutable.Audience.Samples.SampleApp
+{
+    // Headless auto-test for standalone builds only. Activated by passing:
+    //   --auto-test <publishableKey>
+    // on the command line. Injects itself at runtime; no scene changes needed.
+    // Runs Init (Full consent) → Track → Flush → Quit.
+    public class StandaloneAutoTest : MonoBehaviour
+    {
+        [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.AfterSceneLoad)]
+        private static void Bootstrap()
+        {
+            if (string.IsNullOrEmpty(GetArgValue("--auto-test"))) return;
+            var go = new GameObject("[AutoTest]");
+            DontDestroyOnLoad(go);
+            go.AddComponent<StandaloneAutoTest>();
+        }
+
+        private async void Start()
+        {
+            var key = GetArgValue("--auto-test")!;
+            Debug.Log("[AutoTest] Starting headless test run");
+
+            // If Facepunch.Steamworks is present, call SteamClient.Init before the SDK runs.
+            TryInitFacepunch();
+
+            // EOS login: --eos-account-portal opens Epic portal in browser (no DevAuthTool needed).
+            // --eos-dev-auth <host:port> uses DevAuthTool with --eos-credential <name>.
+            if (HasFlag("--eos-account-portal"))
+            {
+                var ok = await InitEosWithAccountPortal();
+                if (!ok)
+                {
+                    Debug.LogError("[AutoTest] EOS init/login failed — aborting");
+                    Application.Quit(1);
+                    return;
+                }
+            }
+            else
+            {
+                var devAuthArg = GetArgValue("--eos-dev-auth");
+                if (devAuthArg != null)
+                {
+                    var parts = devAuthArg.Split(':');
+                    var host = parts[0];
+                    var port = parts.Length > 1 ? parts[1] : "7878";
+                    var credential = GetArgValue("--eos-credential") ?? "test";
+                    var ok = await InitEosWithDevAuthTool($"{host}:{port}", credential);
+                    if (!ok)
+                    {
+                        Debug.LogError("[AutoTest] EOS init/login failed — aborting");
+                        Application.Quit(1);
+                        return;
+                    }
+                }
+            }
+
+            var config = new AudienceConfig
+            {
+                PublishableKey = key,
+                Consent        = ConsentLevel.Full,
+                Debug          = true,
+                TestMode       = true,
+            };
+
+            ImmutableAudience.Init(config);
+            Debug.Log("[AutoTest] Init done, consent=Full");
+
+            ImmutableAudience.Track("auto_test_steam_detection");
+            Debug.Log("[AutoTest] Track sent");
+
+            await Task.Delay(2000);
+
+            try
+            {
+                await ImmutableAudience.FlushAsync();
+                Debug.Log("[AutoTest] Flush done");
+            }
+            catch (Exception ex)
+            {
+                Debug.LogError("[AutoTest] Flush failed: " + ex.Message);
+            }
+
+            await Task.Delay(1000);
+            Debug.Log("[AutoTest] Done. Check BQ for auto_test_steam_detection + identify.");
+            Application.Quit();
+        }
+
+        // Initialises EOSManager and logs in via Epic Account Portal (browser). Returns true on success.
+        private static async Task<bool> InitEosWithAccountPortal()
+        {
+            Debug.Log("[AutoTest] Initialising EOS, login via Account Portal (browser will open)");
+            var go = new GameObject("[EOSManager]");
+            UnityEngine.Object.DontDestroyOnLoad(go);
+            go.AddComponent<EOSManager>();
+
+            var deadline = DateTime.UtcNow.AddSeconds(10);
+            while (EOSManager.Instance.GetEOSPlatformInterface() == null)
+            {
+                if (DateTime.UtcNow > deadline)
+                {
+                    Debug.LogError("[AutoTest] Timed out waiting for EOS platform interface");
+                    return false;
+                }
+                await Task.Delay(200);
+            }
+            Debug.Log("[AutoTest] EOS platform interface ready — complete login in browser");
+
+            var tcs = new TaskCompletionSource<bool>();
+            EOSManager.Instance.StartLoginWithLoginTypeAndToken(
+                LoginCredentialType.AccountPortal,
+                null,
+                null,
+                (LoginCallbackInfo info) =>
+                {
+                    if (info.ResultCode == Result.Success)
+                    {
+                        Debug.Log("[AutoTest] EOS Account Portal login success");
+                        tcs.SetResult(true);
+                    }
+                    else
+                    {
+                        Debug.LogError($"[AutoTest] EOS login failed: {info.ResultCode}");
+                        tcs.SetResult(false);
+                    }
+                });
+
+            // Wait up to 5 minutes for the user to complete the browser login.
+            if (await Task.WhenAny(tcs.Task, Task.Delay(TimeSpan.FromMinutes(5))) != tcs.Task)
+            {
+                Debug.LogError("[AutoTest] Timed out waiting for Account Portal login");
+                return false;
+            }
+            return await tcs.Task;
+        }
+
+        // Initialises EOSManager and logs in via the DevAuthTool at host:port with the
+        // given credential name. Returns true on success.
+        private static async Task<bool> InitEosWithDevAuthTool(string hostPort, string credential)
+        {
+            Debug.Log($"[AutoTest] Initialising EOS, DevAuthTool={hostPort} credential={credential}");
+            var go = new GameObject("[EOSManager]");
+            UnityEngine.Object.DontDestroyOnLoad(go);
+            go.AddComponent<EOSManager>();
+
+            // Wait for platform interface (EOSManager.Awake calls Init synchronously).
+            var deadline = DateTime.UtcNow.AddSeconds(10);
+            while (EOSManager.Instance.GetEOSPlatformInterface() == null)
+            {
+                if (DateTime.UtcNow > deadline)
+                {
+                    Debug.LogError("[AutoTest] Timed out waiting for EOS platform interface");
+                    return false;
+                }
+                await Task.Delay(200);
+            }
+            Debug.Log("[AutoTest] EOS platform interface ready");
+
+            var tcs = new TaskCompletionSource<bool>();
+            EOSManager.Instance.StartLoginWithLoginTypeAndToken(
+                LoginCredentialType.Developer,
+                hostPort,
+                credential,
+                (LoginCallbackInfo info) =>
+                {
+                    if (info.ResultCode == Result.Success)
+                    {
+                        Debug.Log("[AutoTest] EOS DevAuthTool login success");
+                        tcs.SetResult(true);
+                    }
+                    else
+                    {
+                        Debug.LogError($"[AutoTest] EOS login failed: {info.ResultCode}");
+                        tcs.SetResult(false);
+                    }
+                });
+
+            return await tcs.Task;
+        }
+
+        // Initialises Facepunch.Steamworks via reflection so the test harness works
+        // without a direct compile-time dependency. No-ops if Facepunch is not present.
+        private static void TryInitFacepunch()
+        {
+            var steamClientType =
+                System.Type.GetType("Steamworks.SteamClient, Facepunch.Steamworks.Posix")
+                ?? System.Type.GetType("Steamworks.SteamClient, Facepunch.Steamworks.Win64")
+                ?? System.Type.GetType("Steamworks.SteamClient, Facepunch.Steamworks.Win32");
+
+            if (steamClientType == null) return;
+
+            try
+            {
+                var initMethod = steamClientType.GetMethod("Init", new Type[] { typeof(uint), typeof(bool) });
+                initMethod?.Invoke(null, new object[] { (uint)480, false });
+                Debug.Log("[AutoTest] Facepunch SteamClient.Init(480) called");
+            }
+            catch (Exception ex)
+            {
+                Debug.LogWarning("[AutoTest] Facepunch SteamClient.Init failed: " + ex.Message);
+            }
+        }
+
+        private static string? GetArgValue(string key)
+        {
+            var args = Environment.GetCommandLineArgs();
+            for (int i = 0; i < args.Length - 1; i++)
+                if (args[i] == key) return args[i + 1];
+            return null;
+        }
+
+        private static bool HasFlag(string key)
+        {
+            foreach (var arg in Environment.GetCommandLineArgs())
+                if (arg == key) return true;
+            return false;
+        }
+
+    }
+}
+
+#endif