diff --git a/Launcher.props b/Launcher.props
index a37c4ea..271e298 100644
--- a/Launcher.props
+++ b/Launcher.props
@@ -10,7 +10,7 @@
         5. publish-release.yml GitHub Actions workflow
         -->
         <TargetFramework>net10.0</TargetFramework>
-        <Version>0.38.0.50</Version>
+        <Version>0.38.0.52</Version>
         <UseRidGraph>true</UseRidGraph>
 
         <!--
diff --git a/Marsey.Tests/Hidesey/HideseyTest.cs b/Marsey.Tests/Hidesey/HideseyTest.cs
index 049a3c3..554b9c9 100644
--- a/Marsey.Tests/Hidesey/HideseyTest.cs
+++ b/Marsey.Tests/Hidesey/HideseyTest.cs
@@ -102,4 +102,85 @@ public void Hidesey_ManifestHidesCvars()
         Assert.That(filteredCvars, Does.Contain("normal_cvar"));
         Assert.That(filteredCvars, Does.Not.Contain("stealth_cvar"), "Cvar wasn't hidden by the manifest.");
     }
+
+
+
+    [Test]
+    public void Hidesey_HiddenExceptionStackTrace()
+    {
+        string mixedTrace = "   at Robust.Shared.GameObjects.EntitySystem.Update()\n" +
+                            "   at HarmonyLib.PatchFunctions.UpdateWrapper()\n" +
+                            "   at Marsey.Stealthsey.Hidesey.DoSomething()\n" +
+                            "   at Robust.Client.BaseClient.Main()";
+
+        // 1. Normal view (hidden caller) leaves stack trace unmodified
+        string normalTrace = Hidesey.LyingStackTrace(mixedTrace);
+        Assert.That(normalTrace, Is.EqualTo(mixedTrace),
+            "Stack trace should remain unmodified for hidden callers.");
+
+        // 2. Under engine view, hidden frames (Harmony, Marsey) are stripped
+        using (Hidesey.ForceEngineView())
+        {
+            Hidesey.ClearStackTraceCache();
+
+            string sanitized1 = Hidesey.LyingStackTrace(mixedTrace);
+            Assert.That(sanitized1, Does.Not.Contain("HarmonyLib"));
+            Assert.That(sanitized1, Does.Not.Contain("Marsey"));
+            Assert.That(sanitized1, Does.Contain("Robust.Shared.GameObjects.EntitySystem.Update()"));
+            Assert.That(sanitized1, Does.Contain("Robust.Client.BaseClient.Main()"));
+
+            // 3. Test caching: subsequent call with same input should return the cached instance
+            string sanitized2 = Hidesey.LyingStackTrace(mixedTrace);
+            Assert.That(ReferenceEquals(sanitized1, sanitized2), Is.True,
+                "LyingStackTrace must return cached string reference on repeat calls.");
+        }
+
+        // 4. Test actual Exception.StackTrace hook under engine view
+        Exception ex;
+        try
+        {
+            throw new InvalidOperationException("Test exception for stack trace verification");
+        }
+        catch (Exception caught)
+        {
+            ex = caught;
+        }
+
+        using (Hidesey.ForceEngineView())
+        {
+            string? stackTrace = ex.StackTrace;
+            if (!string.IsNullOrEmpty(stackTrace))
+            {
+                Assert.That(stackTrace, Does.Not.Contain("0Harmony"));
+                Assert.That(stackTrace, Does.Not.Contain("HarmonyLib"));
+            }
+        }
+    }
+
+    [Test]
+    public void Hidesey_HiddenTypeAssembly()
+    {
+        Type hiddenType = typeof(Hidesey);
+
+        // 1. Normal view: caller is hidden, returns real assembly
+        Assert.That(hiddenType.Assembly.GetName().Name, Is.EqualTo("Marsey"),
+            "Hidden caller should see real assembly name.");
+
+        // 2. Engine view: Type.Assembly should be spoofed and counter incremented
+        using (Hidesey.ForceEngineView())
+        {
+            int spoofCountBefore = HideseyPatches.TypeAssemblySpoofedCount;
+            Assembly spoofed = hiddenType.Assembly;
+
+            Assert.That(spoofed, Is.Not.Null);
+            Assert.That(spoofed.GetName().Name, Is.Not.EqualTo("Marsey"),
+                "Type.Assembly was not spoofed under engine view.");
+            Assert.That(HideseyPatches.TypeAssemblySpoofedCount, Is.GreaterThan(spoofCountBefore),
+                "TypeAssemblySpoofedCount should increment on spoofing.");
+
+            // 3. Non-hidden type: remains unchanged
+            Assert.That(typeof(string).Assembly, Is.EqualTo(typeof(object).Assembly),
+                "Non-hidden type's assembly must not be spoofed.");
+        }
+    }
 }
\ No newline at end of file
diff --git a/Marsey/Stealthsey/Hidesey.cs b/Marsey/Stealthsey/Hidesey.cs
index 50efc05..bf51f75 100644
--- a/Marsey/Stealthsey/Hidesey.cs
+++ b/Marsey/Stealthsey/Hidesey.cs
@@ -1,3 +1,4 @@
+using System.Collections.Concurrent;
 using System.Diagnostics;
 using System.Reflection;
 using System.Runtime.Loader;
@@ -32,6 +33,8 @@ public static partial class Hidesey
     private static bool _initialized;
     private static bool _caching;
     [ThreadStatic] private static bool _inFromHidden;
+    [ThreadStatic] private static bool _inLyingTypeAssembly;
+    [ThreadStatic] internal static bool InInternalInspection;
 
     // Fast-path cache for FromHidden: assemblies known to be engine/system, skip stack walk on these
     private static readonly HashSet<Assembly> _knownEngineAsms = new();
@@ -47,6 +50,11 @@ public static partial class Hidesey
         "HarmonySharedState",
     };
 
+    // Cache for sanitized stack trace strings to avoid repeated split/allocations
+    private static readonly ConcurrentDictionary<string, string> _stackTraceCache = new();
+    private const int MaxStackTraceCacheSize = 512;
+    private static Assembly? _cachedRobustClientAsm;
+
     public static void Initialize()
     {
         if (_initialized)
@@ -131,6 +139,7 @@ private static void Hide(Assembly marsey)
     {
         Facade.Cloak(marsey);
         _hideseys.Add(marsey);
+        ClearStackTraceCache();
     }
 
     [HideLevelRequirement(HideLevel.Normal)]
@@ -234,6 +243,12 @@ private static void Perjurize()
 
         // Closes Environment.StackTrace leak (whitelisted string property).
         PerjurizeStackTrace();
+
+        // Closes Exception.StackTrace leak.
+        PerjurizeExceptionStackTrace();
+
+        // Closes Type.Assembly (GetType().Assembly) leak.
+        PerjurizeTypeAssembly();
     }
 
     private static void PerjurizeTryLooseGetType()
@@ -407,6 +422,90 @@ private static void PerjurizeStackTrace()
         }
     }
 
+    private static void PerjurizeExceptionStackTrace()
+    {
+        MethodInfo? postfix = typeof(HideseyPatches).GetMethod(nameof(HideseyPatches.LieExceptionStackTrace),
+            BindingFlags.Public | BindingFlags.Static);
+        if (postfix == null)
+        {
+            MarseyLogger.Log(MarseyLogger.LogType.WARN, "HideseyPatches.LieExceptionStackTrace not found");
+            return;
+        }
+
+        MethodInfo? target = typeof(Exception).GetProperty("StackTrace")?.GetGetMethod();
+        if (target == null)
+        {
+            MarseyLogger.Log(MarseyLogger.LogType.WARN, "Exception.StackTrace getter not found");
+            return;
+        }
+
+        try
+        {
+            var harm = HarmonyManager.GetHarmony();
+            var hm = new HarmonyMethod(postfix)
+            {
+                before = Array.Empty<string>(),
+                after = Array.Empty<string>(),
+                priority = Priority.Normal,
+            };
+            harm.Patch(target, postfix: hm);
+            MarseyLogger.Log(MarseyLogger.LogType.INFO, "Exception.StackTrace hook installed");
+        }
+        catch (Exception ex)
+        {
+            MarseyLogger.Log(MarseyLogger.LogType.FATL, $"Exception.StackTrace hook FAILED: {ex.Message}");
+        }
+    }
+
+
+    private static void PerjurizeTypeAssembly()
+    {
+        MethodInfo? postfix = typeof(HideseyPatches).GetMethod(nameof(HideseyPatches.LieTypeAssembly),
+            BindingFlags.Public | BindingFlags.Static);
+        if (postfix == null)
+        {
+            MarseyLogger.Log(MarseyLogger.LogType.WARN, "HideseyPatches.LieTypeAssembly not found");
+            return;
+        }
+
+        var targets = new List<MethodInfo>();
+        var baseGetter = typeof(Type).GetProperty("Assembly")?.GetGetMethod();
+        if (baseGetter != null && !baseGetter.IsAbstract) targets.Add(baseGetter);
+
+        var runtimeType = typeof(object).GetType();
+        var runtimeGetter = runtimeType.GetProperty("Assembly", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly)?.GetGetMethod()
+            ?? runtimeType.GetProperty("Assembly")?.GetGetMethod();
+        if (runtimeGetter != null && !runtimeGetter.IsAbstract && !targets.Contains(runtimeGetter))
+            targets.Add(runtimeGetter);
+
+        var harm = HarmonyManager.GetHarmony();
+        int hooked = 0;
+        foreach (var target in targets)
+        {
+            try
+            {
+                var hm = new HarmonyMethod(postfix)
+                {
+                    before = Array.Empty<string>(),
+                    after = Array.Empty<string>(),
+                    priority = Priority.Normal,
+                };
+                harm.Patch(target, postfix: hm);
+                MarseyLogger.Log(MarseyLogger.LogType.INFO, $"{target.DeclaringType?.Name}.Assembly hook installed");
+                hooked++;
+            }
+            catch (Exception ex)
+            {
+                MarseyLogger.Log(MarseyLogger.LogType.WARN, $"Assembly hook on {target.DeclaringType?.Name} failed: {ex.Message}");
+            }
+        }
+
+        if (hooked == 0)
+        {
+            MarseyLogger.Log(MarseyLogger.LogType.FATL, "PerjurizeTypeAssembly: no Type.Assembly targets hooked");
+        }
+    }
+
     /// <summary>
     /// Postfix on Robust's ReflectionManager.
     /// Must run AFTER engine load — Robust.Shared isn't in AppDomain during Perjurize().
@@ -701,22 +800,110 @@ public static string LyingLocation(string original, Assembly instance)
     /// Delegates the per-line decision to Hidesey.StackLineMentionsHidden (see HideseyRegistries),
     /// which sources hidden names dynamically from the hidden-assembly list + infra keywords +
     /// dynamic Harmony asm names + manifest StackNames.
+    /// Uses thread-safe cache to avoid repeated split and string allocations.
     /// </summary>
     public static string LyingStackTrace(string original)
     {
         if (FromHidden()) return original;
         if (string.IsNullOrEmpty(original)) return original;
 
+        if (_stackTraceCache.TryGetValue(original, out var cached))
+            return cached;
+
         var sb = new System.Text.StringBuilder(original.Length);
         bool hadAny = false;
+        bool removedAny = false;
         foreach (var line in original.Split('\n'))
         {
-            if (StackLineMentionsHidden(line)) continue;
+            if (StackLineMentionsHidden(line))
+            {
+                removedAny = true;
+                continue;
+            }
             if (hadAny) sb.Append('\n');
             sb.Append(line);
             hadAny = true;
         }
-        return sb.ToString();
+
+        if (!removedAny)
+            return original;
+
+        var result = sb.ToString();
+        if (_stackTraceCache.Count < MaxStackTraceCacheSize)
+        {
+            _stackTraceCache.TryAdd(original, result);
+        }
+
+        return result;
+    }
+
+    public static void ClearStackTraceCache() => _stackTraceCache.Clear();
+
+
+    private static bool IsInternalReflectionCaller()
+    {
+        if (IsEngineViewForced()) return false;
+
+        var trace = new StackTrace(2, false);
+        var frames = trace.GetFrames();
+        if (frames == null) return false;
+
+        for (int i = 0; i < Math.Min(10, frames.Length); i++)
+        {
+            var method = frames[i].GetMethod();
+            var declType = method?.DeclaringType;
+            if (declType == null) continue;
+
+            var asmName = declType.Assembly?.GetName().Name ?? "";
+            if (asmName.Contains("Harmony") || asmName.Contains("MonoMod") || asmName.Contains("Mono.Cecil"))
+                return true;
+
+            if (declType.FullName != null &&
+                (declType.FullName.StartsWith("System.Reflection.") ||
+                 declType.FullName.StartsWith("System.RuntimeMethodHandle") ||
+                 declType.FullName.StartsWith("System.RuntimeType")))
+            {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /// <summary>
+    /// Filter for Type.Assembly getter — returns a legitimate surrogate (Robust.Client) for hidden types.
+    /// </summary>
+    public static Assembly LyingTypeAssembly(Assembly original, Type instance)
+    {
+        if (_inLyingTypeAssembly) return original;
+        if (InInternalInspection) return original;
+        if (FromHidden()) return original;
+
+        _inLyingTypeAssembly = true;
+        try
+        {
+            if (IsInternalReflectionCaller())
+                return original;
+
+            if (IsHiddenAsm(original) || IsHiddenType(instance))
+            {
+                if (_cachedRobustClientAsm == null || _cachedRobustClientAsm.IsDynamic)
+                {
+                    _cachedRobustClientAsm = AppDomain.CurrentDomain.GetAssemblies()
+                        .FirstOrDefault(a => a.GetName().Name == "Robust.Client" && !a.IsDynamic);
+                }
+                if (_cachedRobustClientAsm != null)
+                    return _cachedRobustClientAsm;
+
+                return typeof(object).Assembly;
+            }
+
+            return original;
+        }
+        finally
+        {
+            _inLyingTypeAssembly = false;
+        }
     }
 
     /// <summary>
diff --git a/Marsey/Stealthsey/HideseyPatches.cs b/Marsey/Stealthsey/HideseyPatches.cs
index 76ba5a8..febc431 100644
--- a/Marsey/Stealthsey/HideseyPatches.cs
+++ b/Marsey/Stealthsey/HideseyPatches.cs
@@ -54,6 +54,16 @@ public static partial class HideseyPatches
     public static string? LastContentFindFilesCaller { get; private set; }
     public static List<string> ContentFindFilesBlockedNames { get; } = new();
 
+    /// <summary>
+    /// Diagnostic: Exception.StackTrace filter count.
+    /// </summary>
+    public static int ExceptionStackTraceFilteredCount { get; internal set; }
+
+    /// <summary>
+    /// Diagnostic: Type.Assembly spoof count.
+    /// </summary>
+    public static int TypeAssemblySpoofedCount { get; internal set; }
+
     public static void Lie<T>(ref T __result)
     {
         __result = __result switch
@@ -90,9 +100,9 @@ public static void LieGetType(ref Type? __result, object[] __args)
 
         if (originalResult != null && __result == null && __args.Length > 0 && __args[0] is string probe)
         {
+            TypeGetTypeBlockedCount++;
             try
             {
-                TypeGetTypeBlockedCount++;
                 LastBlockedTypeGetTypeProbe = probe;
                 LastBlockedTypeGetTypeCaller = FindFirstBusinessCaller();
                 if (BlockedTypeGetTypeProbes.Count < 100)
@@ -125,9 +135,9 @@ public static void LieTryLooseGetType(ref bool __result, ref Type? __1, string?
                 __1 = null;
                 __result = false;
 
+                TypeGetTypeBlockedCount++;
                 try
                 {
-                    TypeGetTypeBlockedCount++;
                     LastBlockedTypeGetTypeProbe = __0 ?? "?";
                     LastBlockedTypeGetTypeCaller = FindFirstBusinessCaller();
                     if (BlockedTypeGetTypeProbes.Count < 100)
@@ -150,9 +160,9 @@ public static void LieLocation(ref string __result, Assembly __instance)
 
         if (!ReferenceEquals(originalResult, __result))
         {
+            LocationBlockedCount++;
             try
             {
-                LocationBlockedCount++;
                 LastBlockedLocationCaller = FindFirstBusinessCaller();
                 if (BlockedLocationProbes.Count < 100)
                 {
@@ -177,15 +187,49 @@ public static void LieStackTrace(ref string __result)
 
         if (!ReferenceEquals(original, __result) && original != __result)
         {
+            StackTraceFilteredCount++;
             try
             {
-                StackTraceFilteredCount++;
                 LastFilteredStackTraceCaller = FindFirstBusinessCaller();
             }
             catch { }
         }
     }
 
+    /// <summary>
+    /// Postfix on Exception.StackTrace getter.
+    /// Filters out lines that reference hidden assemblies or patches.
+    /// </summary>
+    public static void LieExceptionStackTrace(ref string? __result)
+    {
+        if (string.IsNullOrEmpty(__result)) return;
+
+        var original = __result;
+        __result = Hidesey.LyingStackTrace(__result);
+
+        if (!ReferenceEquals(original, __result) && original != __result)
+        {
+            ExceptionStackTraceFilteredCount++;
+        }
+    }
+
+    /// <summary>
+    /// Postfix on Type.Assembly getter.
+    /// Returns surrogate assembly (e.g. Robust.Client) if type is hidden.
+    /// </summary>
+    public static void LieTypeAssembly(ref Assembly __result, Type __instance)
+    {
+        if (__result == null || __instance == null) return;
+
+        var original = __result;
+        __result = Hidesey.LyingTypeAssembly(__result, __instance);
+
+        if (!ReferenceEquals(original, __result))
+        {
+            TypeAssemblySpoofedCount++;
+        }
+    }
+
     /// <summary>
     /// Postfix on IModLoader.LoadedModules getter.
     /// Returns enumerable of Assembly (concrete return type matters in postfix).
diff --git a/Marsey/Stealthsey/HideseyRegistries.cs b/Marsey/Stealthsey/HideseyRegistries.cs
index d1776c6..1f2f2d8 100644
--- a/Marsey/Stealthsey/HideseyRegistries.cs
+++ b/Marsey/Stealthsey/HideseyRegistries.cs
@@ -87,6 +87,7 @@ public static void Apply(HideManifest manifest)
             MergeInto(_stackHiddenExtra, manifest.StackNames);
 
             _anyHiddenTypeNames = _hiddenSystems.Count > 0 || _hiddenComps.Count > 0 || _hiddenIoc.Count > 0;
+            ClearStackTraceCache();
         }
 
         MarseyLogger.Log(MarseyLogger.LogType.DEBG,
@@ -146,29 +147,38 @@ public static void HideFromStackTrace(params string[] names)
     public static bool IsHiddenType(Type t)
     {
         if (t == null) return false;
-        if (IsHiddenAsm(t.Assembly)) return true;        // whole-assembly hiding (existing semantics)
-        if (!_anyHiddenTypeNames) return false;          // lock-free fast path: nothing registered
+        var prev = Hidesey.InInternalInspection;
+        Hidesey.InInternalInspection = true;
+        try
+        {
+            if (IsHiddenAsm(t.Assembly)) return true;        // whole-assembly hiding (existing semantics)
+            if (!_anyHiddenTypeNames) return false;          // lock-free fast path: nothing registered
 
-        var fn = t.FullName;
-        if (fn == null) return false;
+            var fn = t.FullName;
+            if (fn == null) return false;
 
-        bool inComps, inOther;
-        lock (_hideRegLock)
-        {
-            inOther = _hiddenSystems.Contains(fn) || _hiddenIoc.Contains(fn);
-            inComps = !inOther && _hiddenComps.Contains(fn);
-        }
+            bool inComps, inOther;
+            lock (_hideRegLock)
+            {
+                inOther = _hiddenSystems.Contains(fn) || _hiddenIoc.Contains(fn);
+                inComps = !inOther && _hiddenComps.Contains(fn);
+            }
 
-        if (inOther) return true;
-        if (!inComps) return false;
+            if (inOther) return true;
+            if (!inComps) return false;
 
-        // Component category — networked guard (reflection + logging done outside the lock).
-        if (IsNetworkedComponent(t))
+            // Component category — networked guard (reflection + logging done outside the lock).
+            if (IsNetworkedComponent(t))
+            {
+                WarnNetworkedRefusal(fn);
+                return false;                                // leave VISIBLE — hiding would break net hash
+            }
+            return true;
+        }
+        finally
         {
-            WarnNetworkedRefusal(fn);
-            return false;                                // leave VISIBLE — hiding would break net hash
+            Hidesey.InInternalInspection = prev;
         }
-        return true;
     }
 
     /// <summary>
@@ -198,7 +208,7 @@ public static IEnumerable<string> LyingCvars(IEnumerable<string> original)
         {
             bool hidden;
             lock (_hideRegLock) hidden = name != null && _hiddenCvars.Contains(name);
-            if (!hidden) result.Add(name);
+            if (!hidden && name != null) result.Add(name);
         }
         return result;
     }