diff --git a/src/js/game/hud/parts/entity_debugger.js b/src/js/game/hud/parts/entity_debugger.js
index 640ad4d6..debd456d 100644
--- a/src/js/game/hud/parts/entity_debugger.js
+++ b/src/js/game/hud/parts/entity_debugger.js
@@ -94,11 +94,12 @@ export class HUDEntityDebugger extends BaseHUDPart {
                             <div>`;
 
             for (const property in val) {
-                const isRoot = val[property] == this.root;
-                const isRecursive = recursion.includes(val[property]);
-
-                let hiddenValue = isRoot ? "<root>" : null;
-                if (isRecursive) {
+                let hiddenValue = null;
+                if (val[property] == this.root) {
+                    hiddenValue = "<root>";
+                } else if (val[property] instanceof Node) {
+                    hiddenValue = `<${val[property].constructor.name}>`;
+                } else if (recursion.includes(val[property])) {
                     // Avoid recursion by not "expanding" object more than once
                     hiddenValue = "<recursion>";
                 }
diff --git a/src/js/mods/mod_interface.js b/src/js/mods/mod_interface.js
index e3b9e59b..195c005b 100644
--- a/src/js/mods/mod_interface.js
+++ b/src/js/mods/mod_interface.js
@@ -31,6 +31,12 @@ import { BaseHUDPart } from "../game/hud/base_hud_part";
  * @typedef {{new(...args: any[]): any, prototype: any}} constructable
  */
 
+/**
+ * @template {(...args: any) => any} F The function
+ * @template {object} T  The value of this
+ * @typedef {(this: T, ...args: Parameters<F>) => ReturnType<F>} bindThis
+ */
+
 /**
  * @template {(...args: any[]) => any} F
  * @template P
@@ -400,7 +406,7 @@ export class ModInterface {
      * @template {extendsPrams<P[M]>} O the method that will override the old one
      * @param {C} classHandle
      * @param {M} methodName
-     * @param {beforePrams<O, P[M]>} override
+     * @param {bindThis<beforePrams<O, P[M]>, InstanceType<C>>} override
      */
     replaceMethod(classHandle, methodName, override) {
         const oldMethod = classHandle.prototype[methodName];
@@ -418,7 +424,7 @@ export class ModInterface {
      * @template {extendsPrams<P[M]>} O the method that will run before the old one
      * @param {C} classHandle
      * @param {M} methodName
-     * @param {O} executeBefore
+     * @param {bindThis<O, InstanceType<C>>} executeBefore
      */
     runBeforeMethod(classHandle, methodName, executeBefore) {
         const oldHandle = classHandle.prototype[methodName];
@@ -437,7 +443,7 @@ export class ModInterface {
      * @template {extendsPrams<P[M]>} O the method that will run before the old one
      * @param {C} classHandle
      * @param {M} methodName
-     * @param {O} executeAfter
+     * @param {bindThis<O, InstanceType<C>>} executeAfter
      */
     runAfterMethod(classHandle, methodName, executeAfter) {
         const oldHandle = classHandle.prototype[methodName];