diff --git a/extension.ts b/extension.ts
index 2ad046a..c675673 100644
--- a/extension.ts
+++ b/extension.ts
@@ -15,12 +15,11 @@ export default class aerospike extends Extension {
         super(metadata);
         this.settings = this.getSettings('org.gnome.shell.extensions.aerospike');
         this.keyBindings = new Map();
-        this.windowManager = new WindowManager();
+        this.windowManager = new WindowManager(this.settings);
     }
 
     enable() {
         Logger.log("STARTING AEROSPIKE!")
-        this.windowManager._settings = this.settings;
         this.bindSettings();
         this.setupKeybindings();
         this.windowManager.enable()
@@ -31,42 +30,25 @@ export default class aerospike extends Extension {
         this.removeKeybindings()
     }
 
+    private keybindingActions(): Record<string, () => void> {
+        return {
+            'move-left':          () => { Logger.info('Keybinding 1 was pressed!'); },
+            'move-right':         () => { Logger.info('Keybinding 2 was pressed!'); },
+            'join-with-left':     () => { Logger.info('Keybinding 3 was pressed!'); },
+            'join-with-right':    () => { Logger.info('Keybinding 4 was pressed!'); },
+            'print-tree':         () => { this.windowManager.printTreeStructure(); },
+            'toggle-orientation': () => { this.windowManager.toggleActiveContainerOrientation(); },
+            'reset-ratios':       () => { this.windowManager.resetActiveContainerRatios(); },
+        };
+    }
 
     private bindSettings() {
-        // Monitor settings changes
-        this.settings.connect('changed::move-left', () => {
-            log(`Keybinding 1 changed to: ${this.settings.get_strv('move-left')}`);
-            this.refreshKeybinding('move-left');
-        });
-
-        this.settings.connect('changed::move-right', () => {
-            log(`Keybinding 2 changed to: ${this.settings.get_strv('move-right')}`);
-            this.refreshKeybinding('move-right');
-        });
-
-        this.settings.connect('changed::join-with-left', () => {
-            log(`Keybinding 3 changed to: ${this.settings.get_strv('join-with-left')}`);
-            this.refreshKeybinding('join-with-left');
-        });
-
-        this.settings.connect('changed::join-with-right', () => {
-            log(`Keybinding 4 changed to: ${this.settings.get_strv('join-with-right')}`);
-            this.refreshKeybinding('join-with-right');
-        });
-
-        this.settings.connect('changed::print-tree', () => {
-            log(`Print tree keybinding changed to: ${this.settings.get_strv('print-tree')}`);
-            this.refreshKeybinding('print-tree');
-        });
-
-        this.settings.connect('changed::toggle-orientation', () => {
-            log(`Toggle orientation keybinding changed to: ${this.settings.get_strv('toggle-orientation')}`);
-            this.refreshKeybinding('toggle-orientation');
-        });
-
-        this.settings.connect('changed::reset-ratios', () => {
-            log(`Reset ratios keybinding changed to: ${this.settings.get_strv('reset-ratios')}`);
-            this.refreshKeybinding('reset-ratios');
+        const keybindings = Object.keys(this.keybindingActions());
+        keybindings.forEach(name => {
+            this.settings.connect(`changed::${name}`, () => {
+                log(`${name} keybinding changed to: ${this.settings.get_strv(name)}`);
+                this.refreshKeybinding(name);
+            });
         });
 
         this.settings.connect('changed::dropdown-option', () => {
@@ -77,49 +59,15 @@ export default class aerospike extends Extension {
             log(`Color selection changed to: ${this.settings.get_string('color-selection')}`);
         });
     }
+
     private refreshKeybinding(settingName: string) {
         if (this.keyBindings.has(settingName)) {
             Main.wm.removeKeybinding(settingName);
             this.keyBindings.delete(settingName);
         }
 
-        switch (settingName) {
-            case 'move-left':
-                this.bindKeybinding('move-left', () => {
-                    Logger.info('Keybinding 1 was pressed!');
-                });
-                break;
-            case 'move-right':
-                this.bindKeybinding('move-right', () => {
-                    Logger.info('Keybinding 2 was pressed!');
-                });
-                break;
-            case 'join-with-left':
-                this.bindKeybinding('join-with-left', () => {
-                    Logger.info('Keybinding 3 was pressed!');
-                });
-                break;
-            case 'join-with-right':
-                this.bindKeybinding('join-with-right', () => {
-                    Logger.info('Keybinding 4 was pressed!');
-                });
-                break;
-            case 'print-tree':
-                this.bindKeybinding('print-tree', () => {
-                    this.windowManager.printTreeStructure();
-                });
-                break;
-            case 'toggle-orientation':
-                this.bindKeybinding('toggle-orientation', () => {
-                    this.windowManager.toggleActiveContainerOrientation();
-                });
-                break;
-            case 'reset-ratios':
-                this.bindKeybinding('reset-ratios', () => {
-                    this.windowManager.resetActiveContainerRatios();
-                });
-                break;
-        }
+        const action = this.keybindingActions()[settingName];
+        if (action) this.bindKeybinding(settingName, action);
     }
 
     private removeKeybindings() {
@@ -130,33 +78,10 @@ export default class aerospike extends Extension {
     }
 
     private setupKeybindings() {
-        this.bindKeybinding('move-left', () => {
-            Logger.info('Keybinding 1 was pressed!');
-        });
-
-        this.bindKeybinding('move-right', () => {
-            Logger.info('Keybinding 2 was pressed!');
-        });
-
-        this.bindKeybinding('join-with-left', () => {
-            Logger.info('Keybinding 3 was pressed!');
-        });
-
-        this.bindKeybinding('join-with-right', () => {
-            Logger.info('Keybinding 4 was pressed!');
-        });
-
-        this.bindKeybinding('print-tree', () => {
-            this.windowManager.printTreeStructure();
-        });
-
-        this.bindKeybinding('toggle-orientation', () => {
-            this.windowManager.toggleActiveContainerOrientation();
-        });
-
-        this.bindKeybinding('reset-ratios', () => {
-            this.windowManager.resetActiveContainerRatios();
-        });
+        const actions = this.keybindingActions();
+        for (const [name, action] of Object.entries(actions)) {
+            this.bindKeybinding(name, action);
+        }
     }
 
     private bindKeybinding(settingName: string, callback: () => void) {
@@ -176,7 +101,4 @@ export default class aerospike extends Extension {
 
         this.keyBindings.set(settingName, keyBindingAction);
     }
-
-
-
-}
\ No newline at end of file
+}
diff --git a/src/utils/events.ts b/src/utils/events.ts
index 6329129..49a4404 100644
--- a/src/utils/events.ts
+++ b/src/utils/events.ts
@@ -1,25 +1,18 @@
 import GLib from "gi://GLib";
 
-
 export type QueuedEvent = {
     name: string;
     callback: () => void;
 }
 
-// Pending events indexed by name so that duplicate events collapse into one.
-// Only the most-recently-queued callback for a given name is kept.
 const pendingEvents: Map<string, QueuedEvent> = new Map();
 
 export default function queueEvent(event: QueuedEvent, interval = 200) {
-    // Overwrite any earlier pending event with the same name — the latest
-    // callback is always the most up-to-date one.
     pendingEvents.set(event.name, event);
 
     GLib.timeout_add(GLib.PRIORITY_DEFAULT, interval, () => {
         const e = pendingEvents.get(event.name);
         if (e && e === event) {
-            // Only fire if this is still the current callback for this name
-            // (a newer call may have replaced it).
             pendingEvents.delete(event.name);
             e.callback();
         }
diff --git a/src/wm/container.ts b/src/wm/container.ts
index 4653856..34b71d5 100644
--- a/src/wm/container.ts
+++ b/src/wm/container.ts
@@ -1,6 +1,5 @@
 import {WindowWrapper} from "./window.js";
 import {Logger} from "../utils/logger.js";
-import Meta from "gi://Meta";
 import queueEvent from "../utils/events.js";
 import {Rect} from "../utils/rect.js";
 
@@ -9,35 +8,22 @@ enum Orientation {
     VERTICAL = 1,
 }
 
-/**
- * Build a split-ratio array of length `n` where every element equals 1/n,
- * with the last slot absorbing any floating-point remainder so the array
- * always sums to exactly 1.0.
- */
+// Returns equal ratios summing exactly to 1.0, with float drift absorbed by the last slot.
 function equalRatios(n: number): number[] {
     if (n <= 0) return [];
     const base = 1 / n;
     const ratios = Array(n).fill(base);
-    // Fix floating-point drift: make last slot exact
     const sumExceptLast = ratios.slice(0, -1).reduce((a, b) => a + b, 0);
     ratios[n - 1] = 1 - sumExceptLast;
     return ratios;
 }
 
-
 export default class WindowContainer {
 
     _tiledItems: (WindowWrapper | WindowContainer)[];
     _tiledWindowLookup: Map<number, WindowWrapper>;
     _orientation: Orientation = Orientation.HORIZONTAL;
     _workArea: Rect;
-
-    /**
-     * Per-child split ratios. Always satisfies:
-     *   _splitRatios.length === _tiledItems.length
-     *   _splitRatios.reduce((a,b) => a+b, 0) === 1.0  (within floating-point epsilon)
-     *   every element >= MIN_RATIO
-     */
     _splitRatios: number[];
 
     constructor(workspaceArea: Rect) {
@@ -49,20 +35,10 @@ export default class WindowContainer {
 
     // ─── Helpers ────────────────────────────────────────────────────────────────
 
-    /** Rebuild _splitRatios as equal fractions after any structural change. */
     private _resetRatios(): void {
         this._splitRatios = equalRatios(this._tiledItems.length);
     }
 
-    /**
-     * Called after a new item has been pushed onto _tiledItems.
-     * The new window (last slot) gets 1/n of the space; existing windows
-     * are scaled down proportionally so their ratios relative to each other
-     * are preserved and the total remains 1.0.
-     *
-     * e.g. [0.33, 0.166, 0.5] + new → new=0.25, existing scaled by 0.75
-     *      → [0.2475, 0.1245, 0.375, 0.25]
-     */
     private _addRatioForNewWindow(): void {
         const n = this._tiledItems.length;
         if (n <= 1) {
@@ -70,15 +46,13 @@ export default class WindowContainer {
             return;
         }
         const newRatio = 1 / n;
-        const scale    = 1 - newRatio; // existing windows share this fraction
+        const scale    = 1 - newRatio;
         const scaled   = this._splitRatios.map(r => r * scale);
-        // Absorb all floating-point drift into the last slot so sum is exactly 1.0
         const partialSum = scaled.reduce((a, b) => a + b, 0) + newRatio;
         scaled[scaled.length - 1] += (1.0 - partialSum);
         this._splitRatios = [...scaled, newRatio];
     }
 
-    /** Total dimension for the active orientation (width for H, height for V). */
     private _totalDimension(): number {
         return this._orientation === Orientation.HORIZONTAL
             ? this._workArea.width
@@ -106,9 +80,7 @@ export default class WindowContainer {
         this._addRatioForNewWindow();
         queueEvent({
             name: "tiling-windows",
-            callback: () => {
-                this.tileWindows();
-            }
+            callback: () => this.tileWindows(),
         }, 100);
     }
 
@@ -119,9 +91,7 @@ export default class WindowContainer {
         for (const item of this._tiledItems) {
             if (item instanceof WindowContainer) {
                 const win = item.getWindow(win_id);
-                if (win) {
-                    return win;
-                }
+                if (win) return win;
             } else if (item.getWindowId() === win_id) {
                 return item;
             }
@@ -173,17 +143,15 @@ export default class WindowContainer {
         this._splitRatios = [];
     }
 
-    tileWindows() {
+    tileWindows(): void {
         Logger.log("TILING WINDOWS IN CONTAINER");
         Logger.log("WorkArea", this._workArea);
         this._tileItems();
-        return true;
     }
 
     _tileItems() {
-        if (this._tiledItems.length === 0) {
-            return;
-        }
+        if (this._tiledItems.length === 0) return;
+
         const bounds = this.getBounds();
         Logger.info(`_tileItems: ratios=[${this._splitRatios.map(r => r.toFixed(3)).join(', ')}] bounds=[${bounds.map(b => `(${b.x},${b.y},${b.width},${b.height})`).join(', ')}]`);
         this._tiledItems.forEach((item, index) => {
@@ -200,71 +168,33 @@ export default class WindowContainer {
     // ─── Bounds Calculation ──────────────────────────────────────────────────────
 
     getBounds(): Rect[] {
-        if (this._orientation === Orientation.HORIZONTAL) {
-            return this.getHorizontalBounds();
-        }
-        return this.getVerticalBounds();
+        return this._orientation === Orientation.HORIZONTAL
+            ? this._computeBounds('horizontal')
+            : this._computeBounds('vertical');
     }
 
-    getVerticalBounds(): Rect[] {
-        const items = this._tiledItems;
-        const totalHeight = this._workArea.height;
-        let usedHeight = 0;
-
-        return items.map((_, index) => {
-            const y = this._workArea.y + usedHeight;
-            let height: number;
-            if (index === items.length - 1) {
-                // Last item gets the remainder to avoid pixel gaps from rounding
-                height = totalHeight - usedHeight;
-            } else {
-                height = Math.floor(this._splitRatios[index] * totalHeight);
-            }
-            usedHeight += height;
-            return {
-                x: this._workArea.x,
-                y: y,
-                width: this._workArea.width,
-                height: height,
-            } as Rect;
-        });
-    }
-
-    getHorizontalBounds(): Rect[] {
-        const totalWidth = this._workArea.width;
-        let usedWidth = 0;
+    private _computeBounds(axis: 'horizontal' | 'vertical'): Rect[] {
+        const isHorizontal = axis === 'horizontal';
+        const total = isHorizontal ? this._workArea.width : this._workArea.height;
+        let used = 0;
 
         return this._tiledItems.map((_, index) => {
-            const x = this._workArea.x + usedWidth;
-            let width: number;
-            if (index === this._tiledItems.length - 1) {
-                // Last item gets the remainder to avoid pixel gaps from rounding
-                width = totalWidth - usedWidth;
-            } else {
-                width = Math.floor(this._splitRatios[index] * totalWidth);
-            }
-            usedWidth += width;
-            return {
-                x: x,
-                y: this._workArea.y,
-                width: width,
-                height: this._workArea.height,
-            } as Rect;
+            const offset = used;
+            const size = index === this._tiledItems.length - 1
+                ? total - used
+                : Math.floor(this._splitRatios[index] * total);
+            used += size;
+
+            return isHorizontal
+                ? { x: this._workArea.x + offset, y: this._workArea.y, width: size, height: this._workArea.height }
+                : { x: this._workArea.x, y: this._workArea.y + offset, width: this._workArea.width, height: size };
         });
     }
 
-    // ─── Boundary / Ratio Adjustment ─────────────────────────────────────────────
+    // ─── Boundary Adjustment ─────────────────────────────────────────────────────
 
-    /**
-     * Adjust the boundary between item[boundaryIndex] and item[boundaryIndex+1]
-     * by deltaPixels (positive = move right/down, negative = move left/up).
-     *
-     * Both affected ratios are clamped to [_minRatio, 1 - _minRatio] so no
-     * window can be squashed below the configured minimum.
-     *
-     * Returns true if the adjustment was applied, false if it was rejected
-     * (e.g. out of bounds index or clamping would violate minimum).
-     */
+    // Shifts the boundary between item[boundaryIndex] and item[boundaryIndex+1] by
+    // deltaPixels. Returns false if the delta would violate minRatio on either side.
     adjustBoundary(boundaryIndex: number, deltaPixels: number, minRatio: number = 0.10): boolean {
         if (boundaryIndex < 0 || boundaryIndex >= this._tiledItems.length - 1) {
             Logger.warn(`adjustBoundary: invalid boundaryIndex ${boundaryIndex}`);
@@ -275,9 +205,8 @@ export default class WindowContainer {
         if (totalDim === 0) return false;
 
         const ratioDelta = deltaPixels / totalDim;
-
-        const newLeft  = this._splitRatios[boundaryIndex]     + ratioDelta;
-        const newRight = this._splitRatios[boundaryIndex + 1] - ratioDelta;
+        const newLeft    = this._splitRatios[boundaryIndex]     + ratioDelta;
+        const newRight   = this._splitRatios[boundaryIndex + 1] - ratioDelta;
 
         if (newLeft < minRatio || newRight < minRatio) {
             Logger.log(`adjustBoundary: clamped — newLeft=${newLeft.toFixed(3)}, newRight=${newRight.toFixed(3)}, min=${minRatio}`);
@@ -291,38 +220,13 @@ export default class WindowContainer {
         return true;
     }
 
-    /**
-     * Adjust boundaries on BOTH axes simultaneously for corner resize ops.
-     * horizontalDelta applies to this container if HORIZONTAL, verticalDelta if VERTICAL.
-     * For nested containers the perpendicular delta is forwarded to the child container.
-     *
-     * boundaryIndex: the slot index whose right/bottom edge is being dragged.
-     */
-    adjustBoundaryBothAxes(
-        boundaryIndex: number,
-        horizontalDelta: number,
-        verticalDelta: number,
-    ): void {
-        if (this._orientation === Orientation.HORIZONTAL) {
-            this.adjustBoundary(boundaryIndex, horizontalDelta);
-        } else {
-            this.adjustBoundary(boundaryIndex, verticalDelta);
-        }
-    }
-
     // ─── Container Lookup ────────────────────────────────────────────────────────
 
-    /**
-     * Returns the direct-parent WindowContainer that contains win_id as an
-     * immediate child (not recursed further). Returns null if not found.
-     */
     getContainerForWindow(win_id: number): WindowContainer | null {
         for (const item of this._tiledItems) {
             if (item instanceof WindowWrapper && item.getWindowId() === win_id) {
                 return this;
             }
-        }
-        for (const item of this._tiledItems) {
             if (item instanceof WindowContainer) {
                 const found = item.getContainerForWindow(win_id);
                 if (found !== null) return found;
@@ -335,10 +239,7 @@ export default class WindowContainer {
         for (let i = 0; i < this._tiledItems.length; i++) {
             const container = this._tiledItems[i];
             if (container instanceof WindowContainer) {
-                const index = container.getIndexOfItemNested(item);
-                if (index !== -1) {
-                    return i;
-                }
+                if (container.getIndexOfItemNested(item) !== -1) return i;
             } else if (container.getWindowId() === item.getWindowId()) {
                 return i;
             }
@@ -348,34 +249,28 @@ export default class WindowContainer {
 
     // TODO: update this to work with nested containers - all other logic should already be working
     itemDragged(item: WindowWrapper, x: number, y: number): void {
-        let original_index = this.getIndexOfItemNested(item);
+        const original_index = this.getIndexOfItemNested(item);
 
         if (original_index === -1) {
             Logger.error("Item not found in container during drag op", item.getWindowId());
             return;
         }
+
         let new_index = original_index;
         this.getBounds().forEach((rect, index) => {
             if (rect.x < x && rect.x + rect.width > x && rect.y < y && rect.y + rect.height > y) {
                 new_index = index;
             }
         });
+
         if (original_index !== new_index) {
-            // Swap only the items — ratios stay with their slots.
-            // e.g. slot 0 = 40%, slot 1 = 60%: when the window in slot 1 drags
-            // into slot 0, it takes slot 0's 40% size. The window it displaces
-            // moves to slot 1 and takes the 60% size. The slot ratios are unchanged.
+            Logger.info(`itemDragged: swapped slots ${original_index}<->${new_index}, ratios=[${this._splitRatios.map(r => r.toFixed(3)).join(', ')}]`);
             [this._tiledItems[original_index], this._tiledItems[new_index]] =
                 [this._tiledItems[new_index], this._tiledItems[original_index]];
-            Logger.info(`itemDragged: swapped slots ${original_index}<->${new_index}, ratios=[${this._splitRatios.map(r => r.toFixed(3)).join(', ')}]`);
             this.tileWindows();
         }
     }
 
-    /**
-     * Reset all split ratios in this container to equal fractions.
-     * Called when the user explicitly requests an equal-split reset (e.g. Ctrl+Z).
-     */
     resetRatios(): void {
         this._resetRatios();
         this.tileWindows();
diff --git a/src/wm/monitor.ts b/src/wm/monitor.ts
index 48135e3..b020cb7 100644
--- a/src/wm/monitor.ts
+++ b/src/wm/monitor.ts
@@ -1,12 +1,9 @@
 import {WindowWrapper} from "./window.js";
 import {Rect} from "../utils/rect.js";
-import queueEvent from "../utils/events.js";
 import {Logger} from "../utils/logger.js";
 import Meta from "gi://Meta";
-import Mtk from "@girs/mtk-17";
 
 import WindowContainer from "./container.js";
-import Window = Meta.Window;
 
 export default class Monitor {
 
@@ -20,7 +17,7 @@ export default class Monitor {
         this._workArea = workspace.get_work_area_for_monitor(this._id);
         Logger.log("CREATING MONITOR", monitorId);
         Logger.log("WorkArea", this._workArea.x, this._workArea.y, this._workArea.width, this._workArea.height);
-        const workspaceCount = global.workspace_manager.get_n_workspaces()
+        const workspaceCount = global.workspace_manager.get_n_workspaces();
         Logger.log("Workspace Count", workspaceCount);
         for (let i = 0; i < workspaceCount; i++) {
             this._workspaces.push(new WindowContainer(this._workArea));
@@ -42,9 +39,7 @@ export default class Monitor {
     getWindow(windowId: number): WindowWrapper | undefined {
         for (const container of this._workspaces) {
             const win = container.getWindow(windowId);
-            if (win) {
-                return win;
-            }
+            if (win) return win;
         }
         return undefined;
     }
@@ -52,8 +47,7 @@ export default class Monitor {
     removeWindow(winWrap: WindowWrapper) {
         const windowId = winWrap.getWindowId();
         for (const container of this._workspaces) {
-            const win = container.getWindow(windowId);
-            if (win) {
+            if (container.getWindow(windowId)) {
                 container.removeWindow(windowId);
             }
         }
@@ -65,9 +59,9 @@ export default class Monitor {
     }
 
     tileWindows(): void {
-        this._workArea = global.workspace_manager.get_active_workspace().get_work_area_for_monitor(this._id);
         const activeWorkspace = global.workspace_manager.get_active_workspace();
-        // move() already calls tileWindows() internally — don't call it again
+        this._workArea = activeWorkspace.get_work_area_for_monitor(this._id);
+        // move() calls tileWindows() internally
         this._workspaces[activeWorkspace.index()].move(this._workArea);
     }
 
@@ -82,5 +76,4 @@ export default class Monitor {
     itemDragged(item: WindowWrapper, x: number, y: number): void {
         this._workspaces[item.getWorkspace()].itemDragged(item, x, y);
     }
-
-}
\ No newline at end of file
+}
diff --git a/src/wm/window.ts b/src/wm/window.ts
index bba005f..1f96b9e 100644
--- a/src/wm/window.ts
+++ b/src/wm/window.ts
@@ -11,6 +11,8 @@ type WindowMinimizedHandler = (window: WindowWrapper) => void;
 type WindowWorkspaceChangedHandler = (window: WindowWrapper) => void;
 
 export class WindowWrapper {
+    private static readonly RESIZE_TOLERANCE = 2;
+
     readonly _window: Meta.Window;
     readonly _windowMinimizedHandler: WindowMinimizedHandler;
     readonly _signals: number[] = [];
@@ -48,41 +50,26 @@ export class WindowWrapper {
     startDragging(): void {
         this._dragging = true;
     }
+
     stopDragging(): void {
         Logger.log("STOPPED DRAGGING")
         this._dragging = false;
     }
 
-    // setParent(parent: WindowContainer): void {
-    //     this._parent = parent;
-    // }
-    //
-    // getParent(): WindowContainer | null {
-    //     if (this._parent == null) {
-    //         Logger.warn(`Attempting to get parent for window without parent ${JSON.stringify(this)}`);
-    //     }
-    //     return this._parent
-    // }
-
-    connectWindowSignals(
-        windowManager: IWindowManager,
-    ): void {
-        const windowId = this._window.get_id()
-        // Handle window destruction
+    connectWindowSignals(windowManager: IWindowManager): void {
+        const windowId = this._window.get_id();
         this._signals.push(
-            this._window.connect('unmanaging', window => {
+            this._window.connect('unmanaging', () => {
                 Logger.log("REMOVING WINDOW", windowId);
-                windowManager.handleWindowClosed(this)
+                windowManager.handleWindowClosed(this);
             }),
-            this._window.connect('notify::minimized', (we) => {
+            this._window.connect('notify::minimized', () => {
                 if (this._window.minimized) {
                     Logger.log(`Window minimized: ${windowId}`);
                     windowManager.handleWindowMinimized(this);
-
-                } else if (!this._window.minimized) {
+                } else {
                     Logger.log(`Window unminimized: ${windowId}`);
                     windowManager.handleWindowUnminimized(this);
-
                 }
             }),
             this._window.connect('notify::maximized-horizontally', () => {
@@ -92,21 +79,20 @@ export class WindowWrapper {
                     Logger.log(`Window unmaximized: ${windowId}`);
                 }
             }),
-            this._window.connect("workspace-changed", (_metaWindow) => {
+            this._window.connect("workspace-changed", () => {
                 Logger.log("WORKSPACE CHANGED FOR WINDOW", this._window.get_id());
                 windowManager.handleWindowChangedWorkspace(this);
             }),
-            this._window.connect("position-changed", (_metaWindow) => {
+            this._window.connect("position-changed", () => {
                 windowManager.handleWindowPositionChanged(this);
             }),
-            this._window.connect("size-changed", (_metaWindow) => {
+            this._window.connect("size-changed", () => {
                 windowManager.handleWindowPositionChanged(this);
             }),
         );
     }
 
     disconnectWindowSignals(): void {
-
         if (this._signals) {
             this._signals.forEach(signal => {
                 try {
@@ -133,17 +119,14 @@ export class WindowWrapper {
         }
 
         actor.remove_all_transitions();
-
-        // Single call: move + resize atomically
         this._window.move_resize_frame(true, rect.x, rect.y, rect.width, rect.height);
 
         const new_rect = this._window.get_frame_rect();
-        const TOLERANCE = 2; // pixels — allow compositor rounding
         const mismatch =
-            Math.abs(new_rect.x - rect.x) > TOLERANCE ||
-            Math.abs(new_rect.y - rect.y) > TOLERANCE ||
-            Math.abs(new_rect.width  - rect.width)  > TOLERANCE ||
-            Math.abs(new_rect.height - rect.height) > TOLERANCE;
+            Math.abs(new_rect.x      - rect.x)      > WindowWrapper.RESIZE_TOLERANCE ||
+            Math.abs(new_rect.y      - rect.y)      > WindowWrapper.RESIZE_TOLERANCE ||
+            Math.abs(new_rect.width  - rect.width)  > WindowWrapper.RESIZE_TOLERANCE ||
+            Math.abs(new_rect.height - rect.height) > WindowWrapper.RESIZE_TOLERANCE;
 
         if (_retry > 0 && mismatch) {
             Logger.warn("RESIZE MISMATCH, retrying",
@@ -151,12 +134,8 @@ export class WindowWrapper {
                 `got(${new_rect.x},${new_rect.y},${new_rect.width},${new_rect.height})`);
             queueEvent({
                 name: `delayed_resize_${this.getWindowId()}`,
-                callback: () => {
-                    this.safelyResizeWindow(rect, _retry - 1);
-                }
+                callback: () => this.safelyResizeWindow(rect, _retry - 1),
             }, 50);
         }
     }
-
-
 }
diff --git a/src/wm/windowManager.ts b/src/wm/windowManager.ts
index 5655337..5be1abb 100644
--- a/src/wm/windowManager.ts
+++ b/src/wm/windowManager.ts
@@ -1,10 +1,8 @@
 import Meta from "gi://Meta";
 import Gio from "gi://Gio";
-// import GLib from "gi://GLib";
 
 import {WindowWrapper} from './window.js';
 import * as Main from "resource:///org/gnome/shell/ui/main.js";
-// import Mtk from "@girs/mtk-16";
 import {Logger} from "../utils/logger.js";
 import Monitor from "./monitor.js";
 import WindowContainer from "./container.js";
@@ -14,8 +12,6 @@ import {Rect} from "../utils/rect.js";
 export interface IWindowManager {
     _activeWindowId: number | null;
 
-    // addWindow(window: Meta.Window): void;
-
     handleWindowClosed(winWrap: WindowWrapper): void;
 
     handleWindowMinimized(winWrap: WindowWrapper): void;
@@ -30,8 +26,8 @@ export interface IWindowManager {
 }
 
 
-const _UNUSED_MONITOR_ID = -1
-const _UNUSED_WINDOW_ID = -1
+const _UNUSED_MONITOR_ID = -1;
+const _UNUSED_WINDOW_ID  = -1;
 
 export default class WindowManager implements IWindowManager {
     _displaySignals: number[] = [];
@@ -41,37 +37,33 @@ export default class WindowManager implements IWindowManager {
 
     _activeWindowId: number | null = null;
     _monitors: Map<number, Monitor> = new Map<number, Monitor>();
-
     _minimizedItems: Map<number, WindowWrapper> = new Map<number, WindowWrapper>();
 
     _grabbedWindowMonitor: number = _UNUSED_MONITOR_ID;
     _grabbedWindowId: number = _UNUSED_WINDOW_ID;
     _changingGrabbedMonitor: boolean = false;
-
     _showingOverview: boolean = false;
 
     // ── Resize-drag tracking ──────────────────────────────────────────────────
     _isResizeDrag: boolean = false;
     _resizeDragWindowId: number = _UNUSED_WINDOW_ID;
     _resizeDragOp: Meta.GrabOp = Meta.GrabOp.NONE;
-    /** Mouse position at the start of each incremental resize step. */
     _resizeDragLastMouseX: number = 0;
     _resizeDragLastMouseY: number = 0;
-    /** Re-entrancy guard: true while tileWindows is propagating position-changed events. */
     _isTiling: boolean = false;
 
-    _settings: Gio.Settings | null = null;
+    private readonly _settings: Gio.Settings;
 
-    constructor() {}
+    constructor(settings: Gio.Settings) {
+        this._settings = settings;
+    }
 
-    /** Returns the live min-ratio value from settings, falling back to 0.10. */
     private _getMinRatio(): number {
-        return this._settings?.get_double('min-window-size-percent') ?? 0.10;
+        return this._settings.get_double('min-window-size-percent');
     }
 
     public enable(): void {
         Logger.log("Starting Aerospike Window Manager");
-        // Connect window signals
         this.instantiateDisplaySignals();
 
         const mon_count = global.display.get_n_monitors();
@@ -80,8 +72,6 @@ export default class WindowManager implements IWindowManager {
         }
 
         this.captureExistingWindows();
-
-        // Sync the initially focused window
         this.syncActiveWindow();
     }
 
@@ -108,7 +98,6 @@ export default class WindowManager implements IWindowManager {
             global.display.connect('notify::focus-window', () => {
                 this.syncActiveWindow();
             }),
-
             global.display.connect("showing-desktop-changed", () => {
                 Logger.log("SHOWING DESKTOP CHANGED");
             }),
@@ -119,13 +108,7 @@ export default class WindowManager implements IWindowManager {
             global.display.connect("in-fullscreen-changed", () => {
                 Logger.log("IN FULL SCREEN CHANGED");
             }),
-        )
-
-        // this._windowManagerSignals = [
-        //     global.window_manager.connect("show-tile-preview", (_, _metaWindow, _rect, _num) => {
-        //         Logger.log("SHOW TITLE PREVIEW!")
-        //     }),
-        // ];
+        );
 
         this._workspaceManagerSignals = [
             global.workspace_manager.connect("showing-desktop-changed", () => {
@@ -150,45 +133,31 @@ export default class WindowManager implements IWindowManager {
 
         this._overviewSignals = [
             Main.overview.connect("hiding", () => {
-                // this.fromOverview = true;
                 Logger.log("HIDING OVERVIEW")
                 this._showingOverview = false;
                 this._tileMonitors();
-                // const eventObj = {
-                //     name: "focus-after-overview",
-                //     callback: () => {
-                //         Logger.log("FOCUSING AFTER OVERVIEW");
-                //     },
-                // };
-                // this.queueEvent(eventObj);
             }),
             Main.overview.connect("showing", () => {
                 this._showingOverview = true;
                 Logger.log("SHOWING OVERVIEW");
             }),
         ];
-
-
     }
 
     public disable(): void {
         Logger.log("DISABLED AEROSPIKE WINDOW MANAGER!")
-        // Disconnect the focus signal and remove any existing borders
         this.disconnectSignals();
         this.removeAllWindows();
     }
 
     removeAllWindows(): void {
-        // Disconnect signals from minimized windows before clearing
         this.disconnectMinimizedSignals();
         this._minimizedItems.clear();
-
         this._monitors.forEach((monitor: Monitor) => {
             monitor.removeAllWindows();
         })
     }
 
-
     disconnectSignals(): void {
         this.disconnectDisplaySignals();
         this.disconnectMonitorSignals();
@@ -222,10 +191,6 @@ export default class WindowManager implements IWindowManager {
         })
     }
 
-
-    /**
-     * Returns true if the grab op is a resize operation (any edge or corner).
-     */
     _isResizeOp(op: Meta.GrabOp): boolean {
         return op === Meta.GrabOp.RESIZING_E  ||
                op === Meta.GrabOp.RESIZING_W  ||
@@ -241,7 +206,6 @@ export default class WindowManager implements IWindowManager {
         Logger.log("Grab Op Start", op);
 
         if (this._isResizeOp(op)) {
-            // ── Resize drag ──────────────────────────────────────────────────
             Logger.log("Resize drag begin, op=", op);
             this._isResizeDrag = true;
             this._resizeDragWindowId = window.get_id();
@@ -249,11 +213,8 @@ export default class WindowManager implements IWindowManager {
             const [startMouseX, startMouseY] = global.get_pointer();
             this._resizeDragLastMouseX = startMouseX;
             this._resizeDragLastMouseY = startMouseY;
-            // Mark the window as dragging so safelyResizeWindow skips it while
-            // we tile the other windows in response to ratio changes.
             this._getWrappedWindow(window)?.startDragging();
         } else {
-            // ── Move drag (existing behaviour) ───────────────────────────────
             this._getWrappedWindow(window)?.startDragging();
             this._grabbedWindowMonitor = window.get_monitor();
             this._grabbedWindowId = window.get_id();
@@ -264,19 +225,15 @@ export default class WindowManager implements IWindowManager {
         Logger.log("Grab Op End ", op);
 
         if (this._isResizeDrag) {
-            // ── Resize drag end ──────────────────────────────────────────────
             Logger.log("Resize drag end, op=", op);
             this._isResizeDrag = false;
             this._resizeDragWindowId = _UNUSED_WINDOW_ID;
             this._resizeDragLastMouseX = 0;
             this._resizeDragLastMouseY = 0;
             this._resizeDragOp = Meta.GrabOp.NONE;
-            // Stop suppressing the window, then snap everything to computed ratios
             this._getWrappedWindow(window)?.stopDragging();
             this._tileMonitors();
         } else {
-            // ── Move drag end (existing behaviour) ───────────────────────────
-            Logger.log("primary display", display.get_primary_monitor())
             this._grabbedWindowId = _UNUSED_WINDOW_ID;
             this._getWrappedWindow(window)?.stopDragging();
             this._tileMonitors();
@@ -288,9 +245,7 @@ export default class WindowManager implements IWindowManager {
         let wrapped: WindowWrapper | undefined = undefined;
         for (const monitor of this._monitors.values()) {
             wrapped = monitor.getWindow(window.get_id());
-            if (wrapped !== undefined) {
-                break;
-            }
+            if (wrapped !== undefined) break;
         }
         return wrapped;
     }
@@ -320,21 +275,13 @@ export default class WindowManager implements IWindowManager {
     }
 
     public handleWindowPositionChanged(winWrap: WindowWrapper): void {
-        // Ignore position changes that we triggered ourselves via tileWindows
-        if (this._isTiling) {
-            return;
-        }
-        if (this._changingGrabbedMonitor) {
-            return;
-        }
+        if (this._isTiling || this._changingGrabbedMonitor) return;
 
-        // ── Live resize-drag handling ─────────────────────────────────────────
         if (this._isResizeDrag && winWrap.getWindowId() === this._resizeDragWindowId) {
             this._handleResizeDragUpdate(winWrap);
             return;
         }
 
-        // ── Move-drag handling (existing behaviour) ───────────────────────────
         if (winWrap.getWindowId() === this._grabbedWindowId) {
             const [mouseX, mouseY, _] = global.get_pointer();
 
@@ -347,17 +294,14 @@ export default class WindowManager implements IWindowManager {
                     break;
                 }
             }
-            if (monitorIndex === -1) {
-                return;
-            }
+            if (monitorIndex === -1) return;
 
             if (monitorIndex !== this._grabbedWindowMonitor) {
                 this._changingGrabbedMonitor = true;
                 this._moveWindowToMonitor(winWrap.getWindow(), monitorIndex);
                 this._changingGrabbedMonitor = false;
             }
-            // Guard _isTiling so that tileWindows() calls triggered by itemDragged
-            // (which repositions the displaced window) don't re-enter this handler.
+
             this._isTiling = true;
             try {
                 this._monitors.get(monitorIndex)?.itemDragged(winWrap, mouseX, mouseY);
@@ -367,29 +311,19 @@ export default class WindowManager implements IWindowManager {
         }
     }
 
-    /**
-     * Called on every position-changed event while a resize drag is in progress.
-     * Computes the pixel delta from the drag-start rect, maps it to the correct
-     * container boundary, and calls adjustBoundary() for live feedback.
-     */
     private _handleResizeDragUpdate(winWrap: WindowWrapper): void {
         const op    = this._resizeDragOp;
         const winId = winWrap.getWindowId();
 
-        // Read the current mouse position — this is unclamped by the compositor
-        // and always reflects the true user intent, unlike the window's frame rect
-        // which gets clamped when adjacent windows block expansion.
         const [mouseX, mouseY] = global.get_pointer();
         const dx = mouseX - this._resizeDragLastMouseX;
         const dy = mouseY - this._resizeDragLastMouseY;
 
         if (dx === 0 && dy === 0) return;
 
-        // Update last position first so even if we return early the baseline advances
         this._resizeDragLastMouseX = mouseX;
         this._resizeDragLastMouseY = mouseY;
 
-        // Find the container that directly holds this window
         const container = this._findContainerForWindowAcrossMonitors(winId);
         if (!container) {
             Logger.warn("_handleResizeDragUpdate: no container found for window", winId);
@@ -399,17 +333,10 @@ export default class WindowManager implements IWindowManager {
         const itemIndex = container._getIndexOfWindow(winId);
         if (itemIndex === -1) return;
 
-        const isHorizontal = container._orientation === 0; // Orientation.HORIZONTAL
-
-        // Map the mouse delta to the correct boundary.
-        //
-        // East/South edge → boundary AFTER  the item (boundaryIndex = itemIndex)
-        //   positive dx/dy grows this item, shrinks the next one.
-        // West/North edge → boundary BEFORE the item (boundaryIndex = itemIndex - 1)
-        //   positive dx/dy moves the left edge right, growing the left neighbour
-        //   and shrinking this item — so we negate the delta.
-
+        const isHorizontal = container._orientation === 0;
         const minRatio = this._getMinRatio();
+
+        // E/S edge → boundary after the item; W/N edge → boundary before it.
         let adjusted = false;
         if (isHorizontal) {
             if (op === Meta.GrabOp.RESIZING_E || op === Meta.GrabOp.RESIZING_NE || op === Meta.GrabOp.RESIZING_SE) {
@@ -425,8 +352,6 @@ export default class WindowManager implements IWindowManager {
             }
         }
 
-        // Tile all windows with the updated ratios, guarded so the resulting
-        // position-changed events don't re-enter this handler.
         if (adjusted) {
             this._isTiling = true;
             try {
@@ -437,21 +362,16 @@ export default class WindowManager implements IWindowManager {
         }
     }
 
-    /**
-     * Searches all monitors for the WindowContainer that directly holds win_id.
-     */
     private _findContainerForWindowAcrossMonitors(winId: number): WindowContainer | null {
         const activeWorkspaceIndex = global.workspace_manager.get_active_workspace().index();
         for (const monitor of this._monitors.values()) {
             if (activeWorkspaceIndex >= monitor._workspaces.length) continue;
-            const workspace = monitor._workspaces[activeWorkspaceIndex];
-            const container = workspace.getContainerForWindow(winId);
+            const container = monitor._workspaces[activeWorkspaceIndex].getContainerForWindow(winId);
             if (container !== null) return container;
         }
         return null;
     }
 
-
     public handleWindowMinimized(winWrap: WindowWrapper): void {
         const monitor_id = winWrap.getWindow().get_monitor()
         this._minimizedItems.set(winWrap.getWindowId(), winWrap);
@@ -465,7 +385,6 @@ export default class WindowManager implements IWindowManager {
         this._tileMonitors()
     }
 
-
     public handleWindowChangedWorkspace(winWrap: WindowWrapper): void {
         const monitor = winWrap.getWindow().get_monitor();
         this._monitors.get(monitor)?.removeWindow(winWrap);
@@ -484,41 +403,26 @@ export default class WindowManager implements IWindowManager {
         this._tileMonitors();
     }
 
-
     handleWindowCreated(display: Meta.Display, window: Meta.Window) {
         Logger.log("WINDOW CREATED ON DISPLAY", window, display);
-        if (!this._isWindowTileable(window)) {
-            return;
-        }
+        if (!this._isWindowTileable(window)) return;
         Logger.log("WINDOW IS TILABLE");
         this.addWindowToMonitor(window);
     }
 
-
-    /**
-     * Handle window closed event
-     */
     handleWindowClosed(window: WindowWrapper): void {
-
         const mon_id = window._window.get_monitor();
-
         this._monitors.get(mon_id)?.removeWindow(window);
-
         window.disconnectWindowSignals()
-        // Remove from managed windows
         this.syncActiveWindow();
-        // Retile remaining windows
         this._tileMonitors();
     }
 
-
     public addWindowToMonitor(window: Meta.Window) {
-
         Logger.log("ADDING WINDOW TO MONITOR", window, window);
         var wrapper = new WindowWrapper(window, (winWrap) => this.handleWindowMinimized(winWrap))
         wrapper.connectWindowSignals(this);
         this._addWindowWrapperToMonitor(wrapper);
-
     }
 
     _addWindowWrapperToMonitor(winWrap: WindowWrapper) {
@@ -544,7 +448,7 @@ export default class WindowManager implements IWindowManager {
         "org.gnome.Shell.Extensions",
     ]
 
-    _isWindowTilingBlocked(window: Meta.Window) : boolean {
+    _isWindowTilingBlocked(window: Meta.Window): boolean {
         Logger.info("title", window.get_title());
         Logger.info("description", window.get_description());
         Logger.info("class", window.get_wm_class());
@@ -559,17 +463,12 @@ export default class WindowManager implements IWindowManager {
     }
 
     _isWindowTileable(window: Meta.Window) {
+        if (!window || !window.get_compositor_private()) return false;
+        if (this._isWindowTilingBlocked(window)) return false;
 
-        if (!window || !window.get_compositor_private()) {
-            return false;
-        }
-        if (this._isWindowTilingBlocked(window)) {
-            return false;
-        }
         const windowType = window.get_window_type();
         Logger.log("WINDOW TILING CHECK",);
 
-        // Skip certain types of windows
         return !window.is_skip_taskbar() &&
             windowType !== Meta.WindowType.DESKTOP &&
             windowType !== Meta.WindowType.DOCK &&
@@ -579,14 +478,6 @@ export default class WindowManager implements IWindowManager {
             windowType !== Meta.WindowType.MENU;
     }
 
-    /**
-     * Synchronizes the active window with GNOME's currently active window
-     *
-     * This function queries GNOME Shell for the current focused window and
-     * updates the extension's active window tracking to match.
-     *
-     * @returns The window ID of the active window, or null if no window is active
-     */
     public syncActiveWindow(): number | null {
         const focusWindow = global.display.focus_window;
         if (focusWindow) {
@@ -599,102 +490,33 @@ export default class WindowManager implements IWindowManager {
         return this._activeWindowId;
     }
 
-    /**
-     * Toggles the orientation of the active container (the container holding the active window)
-     */
     public toggleActiveContainerOrientation(): void {
         if (this._activeWindowId === null) {
             Logger.warn("No active window, cannot toggle container orientation");
             return;
         }
-
-        // Find the active window's container
-        const activeContainer = this._findActiveContainer();
-        if (activeContainer) {
-            activeContainer.toggleOrientation();
+        const container = this._findContainerForWindowAcrossMonitors(this._activeWindowId);
+        if (container) {
+            container.toggleOrientation();
         } else {
             Logger.warn("Could not find container for active window");
         }
     }
 
-    /**
-     * Resets all split ratios in the active window's container to equal fractions.
-     * Bound to Ctrl+Z by default.
-     */
     public resetActiveContainerRatios(): void {
         if (this._activeWindowId === null) {
             Logger.warn("No active window, cannot reset container ratios");
             return;
         }
-
-        const activeContainer = this._findActiveContainer();
-        if (activeContainer) {
+        const container = this._findContainerForWindowAcrossMonitors(this._activeWindowId);
+        if (container) {
             Logger.info("Resetting container ratios to equal splits");
-            activeContainer.resetRatios();
+            container.resetRatios();
         } else {
             Logger.warn("Could not find container for active window");
         }
     }
 
-    /**
-     * Finds the container that directly contains the active window
-     * @returns The container holding the active window, or null if not found
-     */
-    private _findActiveContainer(): WindowContainer | null {
-        if (this._activeWindowId === null) {
-            return null;
-        }
-
-        for (const monitor of this._monitors.values()) {
-            const activeWorkspaceIndex = global.workspace_manager.get_active_workspace().index();
-
-            // Bounds check to prevent accessing invalid workspace
-            if (activeWorkspaceIndex >= monitor._workspaces.length || activeWorkspaceIndex < 0) {
-                Logger.warn(`Active workspace index ${activeWorkspaceIndex} out of bounds for monitor with ${monitor._workspaces.length} workspaces`);
-                continue;
-            }
-
-            const workspace = monitor._workspaces[activeWorkspaceIndex];
-
-            // Check if the window is directly in the workspace container
-            const windowWrapper = workspace.getWindow(this._activeWindowId);
-            if (windowWrapper) {
-                // Try to find the parent container
-                const container = this._findContainerHoldingWindow(workspace, this._activeWindowId);
-                return container;
-            }
-        }
-
-        return null;
-    }
-
-    /**
-     * Recursively finds the container that directly contains a specific window
-     * @param container The container to search
-     * @param windowId The window ID to find
-     * @returns The container that directly contains the window, or null if not found
-     */
-    private _findContainerHoldingWindow(container: WindowContainer, windowId: number): WindowContainer | null {
-        // Check if this container directly contains the window
-        for (const item of container._tiledItems) {
-            if (item instanceof WindowContainer) {
-                // Recursively search nested containers
-                const result = this._findContainerHoldingWindow(item, windowId);
-                if (result) {
-                    return result;
-                }
-            } else if (item.getWindowId() === windowId) {
-                // Found it! Return this container as it directly holds the window
-                return container;
-            }
-        }
-
-        return null;
-    }
-
-    /**
-     * Prints the tree structure of all monitors, workspaces, containers, and windows to the logs
-     */
     public printTreeStructure(): void {
         Logger.info("=".repeat(80));
         Logger.info("WINDOW TREE STRUCTURE");
@@ -707,19 +529,15 @@ export default class WindowManager implements IWindowManager {
         this._monitors.forEach((monitor: Monitor, monitorId: number) => {
             const isActiveMonitor = this._activeWindowId !== null &&
                                    monitor.getWindow(this._activeWindowId) !== undefined;
-            const monitorMarker = isActiveMonitor ? ' *' : '';
 
-            Logger.info(`Monitor ${monitorId}${monitorMarker}:`);
+            Logger.info(`Monitor ${monitorId}${isActiveMonitor ? ' *' : ''}:`);
             Logger.info(`  Work Area: x=${monitor._workArea.x}, y=${monitor._workArea.y}, w=${monitor._workArea.width}, h=${monitor._workArea.height}`);
 
             monitor._workspaces.forEach((workspace, workspaceIndex) => {
                 const isActiveWorkspace = workspaceIndex === activeWorkspaceIndex;
-                const workspaceMarker = isActiveWorkspace && isActiveMonitor ? ' *' : '';
-
-                Logger.info(`  Workspace ${workspaceIndex}${workspaceMarker}:`);
+                Logger.info(`  Workspace ${workspaceIndex}${isActiveWorkspace && isActiveMonitor ? ' *' : ''}:`);
                 Logger.info(`    Orientation: ${workspace._orientation === 0 ? 'HORIZONTAL' : 'VERTICAL'}`);
                 Logger.info(`    Items: ${workspace._tiledItems.length}`);
-
                 this._printContainerTree(workspace, 4);
             });
         });
@@ -727,31 +545,20 @@ export default class WindowManager implements IWindowManager {
         Logger.info("=".repeat(80));
     }
 
-    /**
-     * Recursively prints the container tree structure
-     * @param container The container to print
-     * @param indentLevel The indentation level (number of spaces)
-     */
-    private _printContainerTree(container: any, indentLevel: number): void {
+    private _printContainerTree(container: WindowContainer, indentLevel: number): void {
         const indent = " ".repeat(indentLevel);
 
-        container._tiledItems.forEach((item: any, index: number) => {
+        container._tiledItems.forEach((item, index) => {
             if (item instanceof WindowContainer) {
-                // Check if this container contains the active window
-                const containsActiveWindow = this._activeWindowId !== null &&
-                                            item.getWindow(this._activeWindowId) !== undefined;
-                const containerMarker = containsActiveWindow ? ' *' : '';
-
-                Logger.info(`${indent}[${index}] Container (${item._orientation === 0 ? 'HORIZONTAL' : 'VERTICAL'})${containerMarker}:`);
+                const containsActive = this._activeWindowId !== null &&
+                                       item.getWindow(this._activeWindowId) !== undefined;
+                Logger.info(`${indent}[${index}] Container (${item._orientation === 0 ? 'HORIZONTAL' : 'VERTICAL'})${containsActive ? ' *' : ''}:`);
                 Logger.info(`${indent}    Items: ${item._tiledItems.length}`);
                 Logger.info(`${indent}    Work Area: x=${item._workArea.x}, y=${item._workArea.y}, w=${item._workArea.width}, h=${item._workArea.height}`);
                 this._printContainerTree(item, indentLevel + 4);
             } else {
                 const window = item.getWindow();
-                const isActiveWindow = this._activeWindowId === item.getWindowId();
-                const windowMarker = isActiveWindow ? ' *' : '';
-
-                Logger.info(`${indent}[${index}] Window ID: ${item.getWindowId()}${windowMarker}`);
+                Logger.info(`${indent}[${index}] Window ID: ${item.getWindowId()}${this._activeWindowId === item.getWindowId() ? ' *' : ''}`);
                 Logger.info(`${indent}    Title: "${window.get_title()}"`);
                 Logger.info(`${indent}    Class: ${window.get_wm_class()}`);
                 const rect = item.getRect();
@@ -759,6 +566,4 @@ export default class WindowManager implements IWindowManager {
             }
         });
     }
-
-
 }