Added new stanok

.vsconfig

@@ -0,0 +1,6 @@
+{
+  "version": "1.0",
+  "components": [
+    "Microsoft.VisualStudio.Workload.ManagedGame"
+  ]
+}

Assets/CONTENT/Game/Scripts/Workstations/Processing.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 1d3dd768e3784bc6bc270a1ce57ce345
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/CONTENT/Game/Scripts/Workstations/Processing/ItemProcessingRecipe.cs

@@ -0,0 +1,29 @@
+using UnityEngine;
+
+[CreateAssetMenu(
+    fileName = "ItemProcessingRecipe",
+    menuName = "FORT-BO/Workstations/Item Processing Recipe")]
+public sealed class ItemProcessingRecipe : ScriptableObject
+{
+    [SerializeField] private string recipeId;
+    [SerializeField] private ItemDefinition inputItem;
+    [SerializeField] private ItemDefinition outputItem;
+    [SerializeField, Min(0.05f)] private float processingDuration = 3f;
+
+    public string RecipeId => recipeId;
+    public ItemDefinition InputItem => inputItem;
+    public ItemDefinition OutputItem => outputItem;
+    public float ProcessingDuration => processingDuration;
+
+    public bool Accepts(NetworkItem item)
+    {
+        if (item == null || item.Definition == null || inputItem == null)
+            return false;
+
+        return item.Definition == inputItem ||
+            (!string.IsNullOrEmpty(inputItem.ItemId) && item.ItemId == inputItem.ItemId);
+    }
+
+    private void OnValidate() =>
+        recipeId = recipeId?.Trim().ToLowerInvariant();
+}

Assets/CONTENT/Game/Scripts/Workstations/Processing/ItemProcessingRecipe.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: ea07d1502f6f4abc96ea949c7e688857
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/CONTENT/Game/Scripts/Workstations/Processing/ItemProcessingWorkstationView.cs

@@ -0,0 +1,124 @@
+using UnityEngine;
+using UnityEngine.Events;
+
+[DisallowMultipleComponent]
+public class ItemProcessingWorkstationView : MonoBehaviour
+{
+    [SerializeField] private NetworkItemProcessingWorkstation workstation;
+
+    [Header("State Events")]
+    [SerializeField] private UnityEvent onEmpty;
+    [SerializeField] private UnityEvent onProcessingStarted;
+    [SerializeField] private UnityEvent onOutputReady;
+
+    [Header("Continuous Progress")]
+    [SerializeField] private UnityEvent<float> onProcessingProgress;
+
+    private ItemProcessingWorkstationState previousState;
+    private bool hasAppliedState;
+
+    public NetworkItemProcessingWorkstation Workstation => workstation;
+
+    protected virtual void Reset() =>
+        workstation = GetComponentInParent<NetworkItemProcessingWorkstation>();
+
+    protected virtual void Awake()
+    {
+        if (workstation == null)
+            workstation = GetComponentInParent<NetworkItemProcessingWorkstation>();
+    }
+
+    protected virtual void OnEnable()
+    {
+        if (workstation != null)
+        {
+            workstation.Changed += HandleWorkstationChanged;
+            ApplyState();
+        }
+    }
+
+    protected virtual void Start() => ApplyState();
+
+    protected virtual void OnDisable()
+    {
+        if (workstation != null)
+            workstation.Changed -= HandleWorkstationChanged;
+
+        hasAppliedState = false;
+    }
+
+    protected virtual void Update()
+    {
+        if (workstation != null &&
+            workstation.State == ItemProcessingWorkstationState.Processing)
+        {
+            onProcessingProgress?.Invoke(workstation.ProcessProgress);
+        }
+    }
+
+    protected virtual void HandleStateApplied(ItemProcessingWorkstationState state)
+    {
+    }
+
+    [ContextMenu("Preview/Empty")]
+    private void PreviewEmpty()
+    {
+        onProcessingProgress?.Invoke(0f);
+        onEmpty?.Invoke();
+        HandleStateApplied(ItemProcessingWorkstationState.Empty);
+    }
+
+    [ContextMenu("Preview/Processing Started")]
+    private void PreviewProcessingStarted()
+    {
+        onProcessingProgress?.Invoke(0f);
+        onProcessingStarted?.Invoke();
+        HandleStateApplied(ItemProcessingWorkstationState.Processing);
+    }
+
+    [ContextMenu("Preview/Processing 50 Percent")]
+    private void PreviewProcessingHalfway() => onProcessingProgress?.Invoke(0.5f);
+
+    [ContextMenu("Preview/Output Ready")]
+    private void PreviewOutputReady()
+    {
+        onProcessingProgress?.Invoke(1f);
+        onOutputReady?.Invoke();
+        HandleStateApplied(ItemProcessingWorkstationState.OutputReady);
+    }
+
+    private void HandleWorkstationChanged() => ApplyState();
+
+    private void ApplyState()
+    {
+        if (workstation == null || !workstation.IsSpawned)
+            return;
+
+        ItemProcessingWorkstationState currentState = workstation.State;
+        if (hasAppliedState && currentState == previousState)
+            return;
+
+        previousState = currentState;
+        hasAppliedState = true;
+
+        switch (currentState)
+        {
+            case ItemProcessingWorkstationState.Processing:
+                onProcessingStarted?.Invoke();
+                onProcessingProgress?.Invoke(workstation.ProcessProgress);
+                break;
+
+            case ItemProcessingWorkstationState.OutputReady:
+                onProcessingProgress?.Invoke(1f);
+                onOutputReady?.Invoke();
+                break;
+
+            default:
+                onProcessingProgress?.Invoke(0f);
+                onEmpty?.Invoke();
+                break;
+        }
+
+        HandleStateApplied(currentState);
+    }
+}

Assets/CONTENT/Game/Scripts/Workstations/Processing/ItemProcessingWorkstationView.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: fddbd9f473234f27b85054ee55b89f69
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/CONTENT/Game/Scripts/Workstations/Processing/NetworkItemInputSlot.cs

@@ -0,0 +1,79 @@
+using System.Collections.Generic;
+using UnityEngine;
+
+[DisallowMultipleComponent]
+[RequireComponent(typeof(Collider))]
+public sealed class NetworkItemInputSlot : MonoBehaviour
+{
+    [SerializeField] private NetworkItemProcessingWorkstation workstation;
+
+    private readonly Dictionary<NetworkItem, HashSet<Collider>> overlaps = new();
+
+    private void Reset()
+    {
+        workstation = GetComponentInParent<NetworkItemProcessingWorkstation>();
+        GetComponent<Collider>().isTrigger = true;
+    }
+
+    private void Awake()
+    {
+        if (workstation == null)
+            workstation = GetComponentInParent<NetworkItemProcessingWorkstation>();
+    }
+
+    private void OnDisable() => overlaps.Clear();
+
+    private void OnTriggerEnter(Collider other)
+    {
+        RegisterOverlap(other);
+        TryAccept(other);
+    }
+
+    private void OnTriggerStay(Collider other)
+    {
+        RegisterOverlap(other);
+        TryAccept(other);
+    }
+
+    private void OnTriggerExit(Collider other)
+    {
+        if (workstation == null || !workstation.IsServer)
+            return;
+
+        NetworkItem item = other.GetComponentInParent<NetworkItem>();
+        if (item == null || !overlaps.TryGetValue(item, out HashSet<Collider> colliders))
+            return;
+
+        colliders.Remove(other);
+        if (colliders.Count > 0)
+            return;
+
+        overlaps.Remove(item);
+        workstation.NotifyItemExited(item);
+    }
+
+    private void TryAccept(Collider other)
+    {
+        if (workstation == null || !workstation.IsServer || !workstation.IsSpawned)
+            return;
+
+        NetworkItem item = other.GetComponentInParent<NetworkItem>();
+        if (item != null)
+            workstation.TryAcceptItem(item);
+    }
+
+    private void RegisterOverlap(Collider other)
+    {
+        NetworkItem item = other.GetComponentInParent<NetworkItem>();
+        if (item == null)
+            return;
+
+        if (!overlaps.TryGetValue(item, out HashSet<Collider> colliders))
+        {
+            colliders = new HashSet<Collider>();
+            overlaps.Add(item, colliders);
+        }
+
+        colliders.Add(other);
+    }
+}

Assets/CONTENT/Game/Scripts/Workstations/Processing/NetworkItemInputSlot.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 67504197a13e4569ab17c8dcefaf8293
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/CONTENT/Game/Scripts/Workstations/Processing/NetworkItemProcessingWorkstation.cs

@@ -0,0 +1,236 @@
+using System;
+using Unity.Netcode;
+using UnityEngine;
+
+public enum ItemProcessingWorkstationState : byte
+{
+    Empty,
+    Processing,
+    OutputReady
+}
+
+public sealed class NetworkItemProcessingWorkstation : NetworkWorkstationController
+{
+    [Header("Recipe")]
+    [SerializeField] private ItemProcessingRecipe recipe;
+
+    [Header("Slot")]
+    [SerializeField] private Transform inputPoint;
+
+    private readonly NetworkVariable<ItemProcessingWorkstationState> state = new(
+        ItemProcessingWorkstationState.Empty,
+        NetworkVariableReadPermission.Everyone,
+        NetworkVariableWritePermission.Server);
+
+    private readonly NetworkVariable<double> processStartedAt = new(
+        0d,
+        NetworkVariableReadPermission.Everyone,
+        NetworkVariableWritePermission.Server);
+
+    private readonly NetworkVariable<double> processEndsAt = new(
+        0d,
+        NetworkVariableReadPermission.Everyone,
+        NetworkVariableWritePermission.Server);
+
+    private NetworkItem currentItem;
+
+    public override bool IsOperating => State == ItemProcessingWorkstationState.Processing;
+    public ItemProcessingWorkstationState State => state.Value;
+    public ItemProcessingRecipe Recipe => recipe;
+    public NetworkItem CurrentItem => currentItem;
+    public bool CanAcceptItem => IsServer && IsSpawned &&
+        State == ItemProcessingWorkstationState.Empty &&
+        recipe != null && recipe.InputItem != null &&
+        recipe.OutputItem != null && recipe.OutputItem.WorldPrefab != null;
+
+    public float ProcessProgress
+    {
+        get
+        {
+            if (State == ItemProcessingWorkstationState.OutputReady)
+                return 1f;
+
+            if (!IsOperating)
+                return 0f;
+
+            double duration = processEndsAt.Value - processStartedAt.Value;
+            if (duration <= 0d)
+                return 1f;
+
+            return Mathf.Clamp01((float)((GetNetworkTime() - processStartedAt.Value) / duration));
+        }
+    }
+
+    public float RemainingSeconds => !IsOperating
+        ? 0f
+        : Mathf.Max(0f, (float)(processEndsAt.Value - GetNetworkTime()));
+
+    public event Action Changed;
+
+    public override void OnNetworkSpawn()
+    {
+        state.OnValueChanged += HandleStateChanged;
+        processStartedAt.OnValueChanged += HandleProcessTimeChanged;
+        processEndsAt.OnValueChanged += HandleProcessTimeChanged;
+
+        if (IsServer)
+            ResetWorkstationOnServer();
+
+        Changed?.Invoke();
+    }
+
+    public override void OnNetworkDespawn()
+    {
+        state.OnValueChanged -= HandleStateChanged;
+        processStartedAt.OnValueChanged -= HandleProcessTimeChanged;
+        processEndsAt.OnValueChanged -= HandleProcessTimeChanged;
+    }
+
+    private void Update()
+    {
+        if (!IsServer || !IsSpawned)
+            return;
+
+        if (State == ItemProcessingWorkstationState.Processing)
+        {
+            if (currentItem == null || !currentItem.IsSpawned)
+            {
+                ResetWorkstationOnServer();
+                return;
+            }
+
+            if (GetNetworkTime() >= processEndsAt.Value)
+                CompleteProcessingOnServer();
+        }
+        else if (State == ItemProcessingWorkstationState.OutputReady &&
+                 (currentItem == null || !currentItem.IsSpawned))
+        {
+            ResetWorkstationOnServer();
+        }
+    }
+
+    private void LateUpdate()
+    {
+        if (!IsServer || !IsSpawned ||
+            State != ItemProcessingWorkstationState.Processing ||
+            currentItem == null || inputPoint == null)
+        {
+            return;
+        }
+
+        SnapToInputPoint(currentItem.transform);
+    }
+
+    public bool TryAcceptItem(NetworkItem item)
+    {
+        if (!CanAcceptItem || item == null || !item.IsSpawned || !recipe.Accepts(item))
+            return false;
+
+        NetworkCarryableInteractable carryable =
+            item.GetComponent<NetworkCarryableInteractable>();
+        if (carryable == null || !carryable.TryAcquireExternalControl())
+            return false;
+
+        currentItem = item;
+        SnapToInputPoint(item.transform);
+
+        double now = GetNetworkTime();
+        processStartedAt.Value = now;
+        processEndsAt.Value = now + recipe.ProcessingDuration;
+        state.Value = ItemProcessingWorkstationState.Processing;
+        Changed?.Invoke();
+        return true;
+    }
+
+    public void NotifyItemExited(NetworkItem item)
+    {
+        if (!IsServer || !IsSpawned ||
+            State != ItemProcessingWorkstationState.OutputReady ||
+            item == null || item != currentItem)
+        {
+            return;
+        }
+
+        ResetWorkstationOnServer();
+    }
+
+    private void CompleteProcessingOnServer()
+    {
+        if (currentItem == null || recipe == null ||
+            recipe.OutputItem == null || recipe.OutputItem.WorldPrefab == null)
+        {
+            ResetWorkstationOnServer();
+            return;
+        }
+
+        Transform slot = inputPoint != null ? inputPoint : transform;
+        Vector3 outputPosition = slot.position;
+        Quaternion outputRotation = slot.rotation;
+
+        NetworkObject inputObject = currentItem.NetworkObject;
+        currentItem = null;
+
+        if (inputObject != null && inputObject.IsSpawned)
+            inputObject.Despawn(true);
+
+        NetworkObject outputObject = Instantiate(
+            recipe.OutputItem.WorldPrefab,
+            outputPosition,
+            outputRotation);
+        outputObject.Spawn();
+
+        currentItem = outputObject.GetComponent<NetworkItem>();
+        if (currentItem == null ||
+            outputObject.GetComponent<NetworkCarryableInteractable>() == null)
+        {
+            Debug.LogError(
+                $"{name} cannot produce '{recipe.OutputItem.DisplayName}': " +
+                "the output prefab must contain NetworkItem and " +
+                "NetworkCarryableInteractable.",
+                this);
+            outputObject.Despawn(true);
+            currentItem = null;
+            ResetWorkstationOnServer();
+            return;
+        }
+
+        processStartedAt.Value = 0d;
+        processEndsAt.Value = 0d;
+        state.Value = ItemProcessingWorkstationState.OutputReady;
+        Changed?.Invoke();
+    }
+
+    private void ResetWorkstationOnServer()
+    {
+        if (!IsServer)
+            return;
+
+        if (State == ItemProcessingWorkstationState.Processing && currentItem != null &&
+            currentItem.TryGetComponent(out NetworkCarryableInteractable carryable))
+        {
+            carryable.TryReleaseExternalControl();
+        }
+
+        currentItem = null;
+        processStartedAt.Value = 0d;
+        processEndsAt.Value = 0d;
+        state.Value = ItemProcessingWorkstationState.Empty;
+        Changed?.Invoke();
+    }
+
+    private void SnapToInputPoint(Transform itemTransform)
+    {
+        Transform slot = inputPoint != null ? inputPoint : transform;
+        itemTransform.SetPositionAndRotation(slot.position, slot.rotation);
+    }
+
+    private double GetNetworkTime() => NetworkManager != null
+        ? NetworkManager.ServerTime.Time
+        : Time.timeAsDouble;
+
+    private void HandleStateChanged(
+        ItemProcessingWorkstationState _,
+        ItemProcessingWorkstationState __) => Changed?.Invoke();
+
+    private void HandleProcessTimeChanged(double _, double __) => Changed?.Invoke();
+}

Assets/CONTENT/Game/Scripts/Workstations/Processing/NetworkItemProcessingWorkstation.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 90c3cd35b32140ac86dec106c4bb5035
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/CONTENT/Scenes/MainBlocking.unity.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 4ab7e2daaafed0749b50551d8715902a
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/DefaultNetworkPrefabs.asset

@@ -84,3 +84,23 @@ MonoBehaviour:
     SourcePrefabToOverride: {fileID: 0}
     SourceHashToOverride: 0
     OverridingTargetPrefab: {fileID: 0}
+  - Override: 0
+    Prefab: {fileID: 4609832768900680681, guid: 5cf4d9e867c084847ba82c56bddc456b, type: 3}
+    SourcePrefabToOverride: {fileID: 0}
+    SourceHashToOverride: 0
+    OverridingTargetPrefab: {fileID: 0}
+  - Override: 0
+    Prefab: {fileID: 2182525189444712253, guid: 7f5a91b903d654342bfb77c0b9126aa3, type: 3}
+    SourcePrefabToOverride: {fileID: 0}
+    SourceHashToOverride: 0
+    OverridingTargetPrefab: {fileID: 0}
+  - Override: 0
+    Prefab: {fileID: 3006047789126627680, guid: 802af0722eb96ab46ae2cecf926bc6c9, type: 3}
+    SourcePrefabToOverride: {fileID: 0}
+    SourceHashToOverride: 0
+    OverridingTargetPrefab: {fileID: 0}
+  - Override: 0
+    Prefab: {fileID: 9206541098482503491, guid: 29519dc5d2cfae441b261f3ca68f2290, type: 3}
+    SourcePrefabToOverride: {fileID: 0}
+    SourceHashToOverride: 0
+    OverridingTargetPrefab: {fileID: 0}

Assets/Editor/x64/Bakery/.uvgblog.txt

@@ -1633,3 +1633,131 @@ Symbol file LoadedFromMemory is not a mono symbol file
 [main 2026-08-11T13:56:24.373Z] update#setState checking for updates
 [main 2026-08-11T13:56:24.934Z] update#setState idle
 Symbol file LoadedFromMemory is not a mono symbol file
+Symbol file LoadedFromMemory is not a mono symbol file
+[main 2026-08-11T14:58:24.308Z] update#setState checking for updates
+[main 2026-08-11T14:58:24.868Z] update#setState idle
+[main 2026-08-11T15:53:13.620Z] update#setState checking for updates
+[main 2026-08-11T15:53:17.966Z] update#setState idle
+[main 2026-08-11T16:51:42.901Z] update#setState checking for updates
+[main 2026-08-11T16:51:47.046Z] update#setState idle
+[main 2026-08-11T17:48:11.758Z] [CursorProclistService] Config enabled feature (subsample every 10s; memoryPressureMonitorEnabled=true)
+[main 2026-08-11T17:51:46.979Z] update#setState checking for updates
+[main 2026-08-11T17:51:47.511Z] update#setState idle
+[main 2026-08-11T18:50:48.698Z] update#setState checking for updates
+[main 2026-08-11T18:50:49.271Z] update#setState idle
+[main 2026-08-11T18:59:29.824Z] [WorktreeCleanupMainService] Granted cleanup lease id=1 owner=window:1 reason="scheduled-worktree-cleanup"
+[main 2026-08-11T18:59:34.828Z] [WorktreeCleanupMainService] Releasing cleanup lease id=1 owner=window:1 reason="scheduled-worktree-cleanup" releaseReason="released" heldForMs=5004
+[main 2026-08-11T19:56:42.264Z] update#setState checking for updates
+[main 2026-08-11T19:56:43.265Z] update#setState idle
+[main 2026-08-11T20:52:22.556Z] update#setState checking for updates
+[main 2026-08-11T20:52:23.946Z] update#setState idle
+[main 2026-08-11T21:49:48.523Z] update#setState checking for updates
+[main 2026-08-11T21:49:49.052Z] update#setState idle
+[main 2026-08-11T22:46:15.604Z] update#setState checking for updates
+[main 2026-08-11T22:46:16.129Z] update#setState idle
+[main 2026-08-11T23:51:19.717Z] update#setState checking for updates
+[main 2026-08-11T23:51:22.693Z] update#setState idle
+[main 2026-08-12T00:48:34.377Z] update#setState checking for updates
+[main 2026-08-12T00:48:37.209Z] update#setState idle
+[main 2026-08-12T00:59:29.823Z] [WorktreeCleanupMainService] Granted cleanup lease id=2 owner=window:1 reason="scheduled-worktree-cleanup"
+[main 2026-08-12T00:59:34.827Z] [WorktreeCleanupMainService] Releasing cleanup lease id=2 owner=window:1 reason="scheduled-worktree-cleanup" releaseReason="released" heldForMs=5004
+[main 2026-08-12T01:48:43.467Z] update#setState checking for updates
+[main 2026-08-12T01:48:43.989Z] update#setState idle
+[main 2026-08-12T02:45:40.670Z] update#setState checking for updates
+[main 2026-08-12T02:45:41.218Z] update#setState idle
+[main 2026-08-12T03:44:45.205Z] update#setState checking for updates
+[main 2026-08-12T03:44:50.429Z] update#setState idle
+[main 2026-08-12T04:45:24.271Z] update#setState checking for updates
+[main 2026-08-12T04:45:28.863Z] update#setState idle
+Symbol file LoadedFromMemory is not a mono symbol file
+Symbol file LoadedFromMemory is not a mono symbol file
+Symbol file LoadedFromMemory is not a mono symbol file
+Symbol file LoadedFromMemory is not a mono symbol file
+
+
+Symbol file LoadedFromMemory is not a mono symbol file
+Symbol file LoadedFromMemory is not a mono symbol file
+Symbol file LoadedFromMemory is not a mono symbol file
+
+[main 2026-08-12T05:49:25.533Z] update#setState checking for updates
+[main 2026-08-12T05:49:26.070Z] update#setState idle
+Symbol file LoadedFromMemory is not a mono symbol file
+Symbol file LoadedFromMemory is not a mono symbol file
+Symbol file LoadedFromMemory is not a mono symbol file
+Symbol file LoadedFromMemory is not a mono symbol file
+Symbol file LoadedFromMemory is not a mono symbol file
+Symbol file LoadedFromMemory is not a mono symbol file
+Symbol file LoadedFromMemory is not a mono symbol file
+Symbol file LoadedFromMemory is not a mono symbol file
+Symbol file LoadedFromMemory is not a mono symbol file
+Symbol file LoadedFromMemory is not a mono symbol file
+Symbol file LoadedFromMemory is not a mono symbol file
+Symbol file LoadedFromMemory is not a mono symbol file
+Symbol file LoadedFromMemory is not a mono symbol file
+[main 2026-08-12T06:45:15.570Z] update#setState checking for updates
+[main 2026-08-12T06:45:17.345Z] update#setState idle
+[main 2026-08-12T06:59:29.825Z] [WorktreeCleanupMainService] Granted cleanup lease id=3 owner=window:1 reason="scheduled-worktree-cleanup"
+[main 2026-08-12T06:59:34.828Z] [WorktreeCleanupMainService] Releasing cleanup lease id=3 owner=window:1 reason="scheduled-worktree-cleanup" releaseReason="released" heldForMs=5003
+Symbol file LoadedFromMemory is not a mono symbol file
+[main 2026-08-12T07:43:02.489Z] update#setState checking for updates
+[main 2026-08-12T07:43:05.316Z] update#setState idle
+Symbol file LoadedFromMemory is not a mono symbol file
+Symbol file LoadedFromMemory is not a mono symbol file
+Symbol file LoadedFromMemory is not a mono symbol file
+Symbol file LoadedFromMemory is not a mono symbol file
+Symbol file LoadedFromMemory is not a mono symbol file
+Symbol file LoadedFromMemory is not a mono symbol file
+[main 2026-08-12T08:45:05.944Z] update#setState checking for updates
+[main 2026-08-12T08:45:06.490Z] update#setState idle
+Symbol file LoadedFromMemory is not a mono symbol file
+Symbol file LoadedFromMemory is not a mono symbol file
+Symbol file LoadedFromMemory is not a mono symbol file
+Symbol file LoadedFromMemory is not a mono symbol file
+Symbol file LoadedFromMemory is not a mono symbol file
+Symbol file LoadedFromMemory is not a mono symbol file
+[main 2026-08-12T09:40:26.030Z] update#setState checking for updates
+[main 2026-08-12T09:40:31.046Z] update#setState idle
+Symbol file LoadedFromMemory is not a mono symbol file
+Symbol file LoadedFromMemory is not a mono symbol file
+abort_threads: Failed aborting id: 0000000000005198, mono_thread_manage will ignore it
+
+abort_threads: Failed aborting id: 0000000000005408, mono_thread_manage will ignore it
+
+abort_threads: Failed aborting id: 0000000000005198, mono_thread_manage will ignore it
+
+abort_threads: Failed aborting id: 0000000000005408, mono_thread_manage will ignore it
+
+Done
+Done
+Done
+Done
+Error reading command from socketError reading command from socketError reading command from socketError reading command from socketError reading command from socketError reading command from socketError reading command from socketError reading command from socketError reading command from socketError reading command from socket[main 2026-08-12T10:44:06.348Z] update#setState checking for updates
+[main 2026-08-12T10:44:06.936Z] update#setState idle
+[main 2026-08-12T11:47:53.297Z] update#setState checking for updates
+[main 2026-08-12T11:47:53.846Z] update#setState idle
+[main 2026-08-12T12:48:55.457Z] update#setState checking for updates
+[main 2026-08-12T12:49:00.973Z] update#setState idle
+[main 2026-08-12T12:59:30.201Z] [WorktreeCleanupMainService] Granted cleanup lease id=4 owner=window:1 reason="scheduled-worktree-cleanup"
+[main 2026-08-12T12:59:36.169Z] [WorktreeCleanupMainService] Releasing cleanup lease id=4 owner=window:1 reason="scheduled-worktree-cleanup" releaseReason="released" heldForMs=5968
+[main 2026-08-12T13:53:48.819Z] update#setState checking for updates
+[main 2026-08-12T13:53:54.667Z] update#setState idle
+[main 2026-08-12T14:54:19.552Z] update#setState checking for updates
+[main 2026-08-12T14:54:24.633Z] update#setState idle
+[main 2026-08-12T15:59:34.590Z] update#setState checking for updates
+[main 2026-08-12T15:59:35.141Z] update#setState idle
+[main 2026-08-12T16:55:04.018Z] update#setState checking for updates
+[main 2026-08-12T16:55:04.565Z] update#setState idle
+[main 2026-08-12T17:58:09.758Z] update#setState checking for updates
+[main 2026-08-12T17:58:10.292Z] update#setState idle
+[main 2026-08-12T18:54:24.027Z] update#setState checking for updates
+[main 2026-08-12T18:54:24.658Z] update#setState idle
+[main 2026-08-12T18:59:30.196Z] [WorktreeCleanupMainService] Granted cleanup lease id=5 owner=window:1 reason="scheduled-worktree-cleanup"
+[main 2026-08-12T18:59:36.166Z] [WorktreeCleanupMainService] Releasing cleanup lease id=5 owner=window:1 reason="scheduled-worktree-cleanup" releaseReason="released" heldForMs=5970
+[main 2026-08-12T19:50:42.539Z] update#setState checking for updates
+[main 2026-08-12T19:50:45.988Z] update#setState downloading
+[main 2026-08-12T19:51:03.312Z] update#setState downloaded
+[main 2026-08-12T19:51:03.523Z] update#setState updating
+[main 2026-08-12T19:51:33.712Z] update#setState ready
+[main 2026-08-13T00:59:30.197Z] [WorktreeCleanupMainService] Granted cleanup lease id=6 owner=window:1 reason="scheduled-worktree-cleanup"
+[main 2026-08-13T00:59:36.167Z] [WorktreeCleanupMainService] Releasing cleanup lease id=6 owner=window:1 reason="scheduled-worktree-cleanup" releaseReason="released" heldForMs=5970
+[main 2026-08-13T05:22:24.497Z] update#recheckOutdatedUpdateOnResume - re-checking pending update freshness unlock-screen

Assets/Plugins/RootMotion.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: d9bd989d8fda8564eb25fc8a1f22a110
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/RootMotion/FinalIK.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 934bb813ebad34517a1b22565370b2af
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/RootMotion/FinalIK/_Integration.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: fd35cb16d5e64408eb3f5b252bc0c154
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: