update

Adding support within NetworkPrefabs and NetworkPrefab to handle the registration of hybrid spawned objects (i.e. no more hacky-way  of registering).
Moving the hybrid spawn registration into the Start method of the NetworkObject to provide time for everything to run through Awake.
Added some script (defined out) that was helping to debug why NetworkObject was being disabled sometimes (moving the initialization to Start resolved the issue).

Author: NoelStephensUnity

com.unity.netcode.gameobjects/Runtime/Configuration/NetworkPrefab.cs

@@ -57,6 +57,14 @@ public class NetworkPrefab
         /// </summary>
         public GameObject OverridingTargetPrefab;
 
+#if UNIFIED_NETCODE
+        /// <summary>
+        /// Used to determine if this prefab needs to be registered
+        /// via the unified API.
+        /// </summary>
+        internal bool HasGhost { get; private set; }
+#endif
+
         /// <summary>
         /// Compares this NetworkPrefab with another to determine equality
         /// </summary>
@@ -166,6 +174,11 @@ public bool Validate(int index = -1)
                     return false;
                 }
 
+#if UNIFIED_NETCODE
+                // Mark this network prefab as having to be registered via the unified API
+                HasGhost = networkObject.HasGhost;
+#endif
+
                 return true;
             }
 
@@ -183,7 +196,6 @@ public bool Validate(int index = -1)
 
                             return false;
                         }
-
                         break;
                     }
                 case NetworkPrefabOverride.Prefab:

com.unity.netcode.gameobjects/Runtime/Configuration/NetworkPrefabs.cs

@@ -277,6 +277,48 @@ public bool Contains(NetworkPrefab prefab)
             return false;
         }
 
+#if UNIFIED_NETCODE
+        internal bool HasPendingGhostPrefabs { get; private set; }
+        private List<NetworkPrefab> m_PendingGhostRegistration = new List<NetworkPrefab>();
+
+        /// <summary>
+        /// UNIFIED-POC<br />
+        /// Hybrid NetworkObject-Ghost Prefab Registration<br />
+        /// </summary>
+        /// <remarks>
+        /// When <see cref="NetworkObject.HasGhost"/> is true, <see cref="NetworkPrefab"/>s
+        /// will mark themselves as having a ghost during <see cref="NetworkPrefab.Validate(int)"/>.
+        /// After validation, if a network prefab's <see cref="NetworkPrefab.HasGhost"/> value is
+        /// set, then it is added to <see cref="m_PendingGhostRegistration"/>.
+        /// Within <see cref="NetworkManager.NetworkUpdate(NetworkUpdateStage)"/> during the <see cref="NetworkUpdateStage.EarlyUpdate"/>,
+        /// if <see cref="HasPendingGhostPrefabs"/> is true then <see cref="RegisterGhostPrefabs(NetworkManager)"/> will be invoked.
+        /// This will repeat until the hosted single world instance is created.
+        /// </remarks>
+        /// <param name="networkManager"></param>
+        internal void RegisterGhostPrefabs(NetworkManager networkManager)
+        {
+            if (!HasPendingGhostPrefabs)
+            {
+                Debug.LogWarning($"Should not be invoking!");
+                return;
+            }
+            var isHost = networkManager.IsHost;
+            for (int i = m_PendingGhostRegistration.Count - 1; i >= 0; i--)
+            {
+                var networkPrefab = m_PendingGhostRegistration[i];
+
+                // Returns false if the single world is not available yet
+                if (NetCode.Netcode.RegisterPrefabSingleWorld(networkPrefab.Prefab, isHost))
+                {
+                    Debug.Log($"[{nameof(NetworkPrefabs)}][{nameof(RegisterGhostPrefabs)}] Registered hybrid spawned object: {networkPrefab.Prefab.name}");
+                    m_PendingGhostRegistration.RemoveAt(i);
+                }
+            }
+            HasPendingGhostPrefabs = m_PendingGhostRegistration.Count > 0;
+        }
+#endif
+
+
         /// <summary>
         /// Configures <see cref="NetworkPrefabOverrideLinks"/> for the given <see cref="NetworkPrefab"/>
         /// </summary>
@@ -295,6 +337,14 @@ private bool AddPrefabRegistration(NetworkPrefab networkPrefab)
             uint source = networkPrefab.SourcePrefabGlobalObjectIdHash;
             uint target = networkPrefab.TargetPrefabGlobalObjectIdHash;
 
+#if UNIFIED_NETCODE
+            if (networkPrefab.HasGhost)
+            {
+                HasPendingGhostPrefabs = true;
+                m_PendingGhostRegistration.Add(networkPrefab);
+            }
+#endif
+
             // Make sure the prefab isn't already registered.
             if (NetworkPrefabOverrideLinks.ContainsKey(source))
             {

com.unity.netcode.gameobjects/Runtime/Core/NetworkBehaviour.cs

@@ -1,6 +1,5 @@
 using System;
 using System.Collections.Generic;
-using System.Runtime.CompilerServices;
 using Unity.Collections;
 using UnityEngine;
 

com.unity.netcode.gameobjects/Runtime/Core/NetworkManager.cs

@@ -333,6 +333,15 @@ public void NetworkUpdate(NetworkUpdateStage updateStage)
             {
                 case NetworkUpdateStage.EarlyUpdate:
                     {
+#if UNIFIED_NETCODE
+                        // Temporary work around for handling the registration
+                        // of hybrid spawned objects.
+                        if (NetworkConfig.Prefabs.HasPendingGhostPrefabs)
+                        {
+                            NetworkConfig.Prefabs.RegisterGhostPrefabs(this);
+                        }
+#endif
+
                         UpdateTopology();
 
                         // Handle processing any new connections or transport events

com.unity.netcode.gameobjects/Runtime/Core/NetworkObject.cs

@@ -3534,35 +3534,53 @@ private void Awake()
 #endif
             SetCachedParent(transform.parent);
             SceneOrigin = gameObject.scene;
-#if UNIFIED_NETCODE
-            InitGhost();
-#endif
 
         }
 
-        //private void OnEnable()
-        //{
-        //    Debug.Log("Enabled!");
-        //}
+#if UNIFIED_NETCODE
 
-        //private void OnDisable()
-        //{
-        //    Debug.Log("Disabled!");
-        //}
+#if DEBUG_ENABLE_DISABLE
+        private void OnEnable()
+        {
+            Debug.Log("Enabled!");
+        }
 
-#if UNIFIED_NETCODE
+        private void OnDisable()
+        {
+            Debug.Log("Disabled!");
+            if (IsSpawned)
+            {
+                enabled = true;
+            }
+
+            try
+            {
+                throw new Exception("Disabled trap!");
+            }
+            catch (Exception ex)
+            {
+                Debug.LogWarning($"[{name}][{ex.Message}] Callstack:\n{ex.StackTrace}");
+            }
+        }
+#endif
 
         private void Start()
         {
-            enabled = true;
+            // TODO-UNIFIED: Remove once the prefab registration is in place.
+            if (!enabled)
+            {
+                Debug.LogWarning($"[{nameof(NetworkObject)}][{name}] Was not enabled on start! Enabling.");
+                enabled = true;
+            }
+            
+            InitGhost();
         }
         [SerializeField]
         [HideInInspector]
         internal NetworkObjectBridge NetworkObjectBridge;
 
         private void InitGhost()
         {
-            enabled = true;
             // All instances with Ghosts are automatically registered
             if (HasGhost && NetworkObjectBridge)
             {