chore(deps): update dependency eslint-plugin-jsdoc to v62.7.0

Reviewed-on: #18

.gitea/workflows/build.yaml

@@ -0,0 +1,99 @@
+name: Build and Test
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    branches:
+      - main
+
+jobs:
+  build:
+    runs-on: archlinux
+    container:
+      image: node:25
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v6
+
+      - name: Install pnpm and TypeScript
+        run: npm install -g pnpm typescript@5.8.3
+
+      - name: Install just
+        run: |
+          curl --proto '=https' --tlsv1.2 -sSf https://just.systems/install.sh | bash -s -- --to /usr/local/bin
+
+      - name: Install system dependencies
+        run: |
+          apt-get update
+          apt-get install -y libglib2.0-dev glib-networking zip
+
+      - name: Install project dependencies
+        run: pnpm install
+
+      - name: Run unit tests
+        run: just test
+
+      - name: Build and package extension
+        run: just build-package
+
+      - name: Upload extension package
+        uses: actions/upload-artifact@v3
+        with:
+          name: aerospike-extension
+          path: aerospike.zip
+          retention-days: 30
+
+  release:
+    needs: build
+    runs-on: archlinux
+    if: github.ref == 'refs/heads/main' && github.event_name == 'push'
+    environment:
+      name: production
+    container:
+      image: node:25
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v6
+
+      - name: Download artifact
+        uses: actions/download-artifact@v3
+        with:
+          name: aerospike-extension
+
+      - name: Get version from package.json
+        id: get_version
+        run: |
+          VERSION=$(node -p "require('./package.json').version")
+          echo "version=v${VERSION}" >> $GITHUB_OUTPUT
+
+      - name: Create Gitea Release
+        env:
+          GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}
+        run: |
+          curl -X POST \
+            -H "Authorization: token ${GITEA_TOKEN}" \
+            -H "Content-Type: application/json" \
+            -d '{
+              "tag_name": "${{ steps.get_version.outputs.version }}",
+              "name": "Release ${{ steps.get_version.outputs.version }}",
+              "body": "Automated release of aerospike GNOME extension ${{ steps.get_version.outputs.version }}\n\n## Installation\nDownload aerospike.zip and install it as a GNOME extension."
+            }' \
+            "${GITHUB_API_URL}/repos/${GITHUB_REPOSITORY}/releases"
+
+      - name: Upload Release Asset
+        env:
+          GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}
+        run: |
+          RELEASE_ID=$(curl -H "Authorization: token ${GITEA_TOKEN}" \
+            "${GITHUB_API_URL}/repos/${GITHUB_REPOSITORY}/releases/tags/${{ steps.get_version.outputs.version }}" | \
+            grep -Po '"id":\s*\K[0-9]+' | head -1)
+
+          curl -X POST \
+            -H "Authorization: token ${GITEA_TOKEN}" \
+            -H "Content-Type: multipart/form-data" \
+            -F "attachment=@aerospike.zip" \
+            "${GITHUB_API_URL}/repos/${GITHUB_REPOSITORY}/releases/${RELEASE_ID}/assets?name=aerospike.zip"

.gitignore

@@ -3,3 +3,4 @@ node_modules
 dist
 /schemas/gschemas.compiled
 /aerospike.zip
+/debug.log

.nvmrc

@@ -0,0 +1 @@
+24

ambient.d.ts

@@ -2,3 +2,10 @@ import "@girs/gjs";
 import "@girs/gjs/dom";
 import "@girs/gnome-shell/ambient";
 import "@girs/gnome-shell/extensions/global";
+
+// Extend Meta.Window with our custom property
+declare namespace Meta {
+    interface Window {
+        _aerospikeData?: any;
+    }
+}

extension.ts

@@ -1,88 +1,54 @@
-import GLib from 'gi://GLib';
-import St from 'gi://St';
 import Meta from 'gi://Meta';
-import {Extension, ExtensionMetadata} from 'resource:///org/gnome/shell/extensions/extension.js';
-import Mtk from "@girs/mtk-16";
-
+import {Extension} from 'resource:///org/gnome/shell/extensions/extension.js';
 import * as Main from 'resource:///org/gnome/shell/ui/main.js';
 import Gio from 'gi://Gio';
 import Shell from 'gi://Shell';
-// import cairo from "cairo";
-// import Shell from 'gi://Shell';
-// import * as Main from 'resource:///org/gnome/shell/ui/main.js';
-
-type WinWrapper = {
-    window: Meta.Window | null;
-    signals: Signal[] | null;
-}
-
-type Signal = {
-    name: string;
-    id: number;
-}
-
-
+import WindowManager from './src/wm/windowManager.js'
+import {Logger} from "./src/utils/logger.js";
 
 export default class aerospike extends Extension {
     settings: Gio.Settings;
     keyBindings: Map<string, number>;
-    borderActor: St.Widget | null;
-    focusWindowSignals: any[];
-    lastFocusedWindow: Meta.Window | null;
-    _focusSignal: number | null;
-    _windowCreateId: number | null;
-    _windows: Map<number, WinWrapper>;
-    _activeWindowId: number | null;
+    windowManager: WindowManager;
 
-    constructor(metadata: ExtensionMetadata) {
+    constructor(metadata: ConstructorParameters<typeof Extension>[0]) {
         super(metadata);
         this.settings = this.getSettings('org.gnome.shell.extensions.aerospike');
         this.keyBindings = new Map();
-        // Initialize instance variables
-        this.borderActor = null;
-        this.focusWindowSignals = [];
-        this.lastFocusedWindow = null;
-        this._focusSignal = null;
-        this._windowCreateId = null;
-        this._windows = new Map<number, WinWrapper>();
-        this._activeWindowId = null;
-
+        this.windowManager = new WindowManager(this.settings);
     }
 
     enable() {
-        console.log("STARTING AEROSPIKE!")
-        this._captureExistingWindows();
-        // Connect window signals
-        this._windowCreateId = global.display.connect(
-            'window-created',
-            (display, window) => {
-                this.handleWindowCreated(window);
-            }
-        );
+        Logger.log("STARTING AEROSPIKE!")
         this.bindSettings();
+        this.setupKeybindings();
+        this.windowManager.enable()
     }
 
+    disable() {
+        this.windowManager.disable()
+        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::keybinding-1', () => {
-            log(`Keybinding 1 changed to: ${this.settings.get_strv('keybinding-1')}`);
-            this.refreshKeybinding('keybinding-1');
-        });
-
-        this.settings.connect('changed::keybinding-2', () => {
-            log(`Keybinding 2 changed to: ${this.settings.get_strv('keybinding-2')}`);
-            this.refreshKeybinding('keybinding-2');
-        });
-
-        this.settings.connect('changed::keybinding-3', () => {
-            log(`Keybinding 3 changed to: ${this.settings.get_strv('keybinding-3')}`);
-            this.refreshKeybinding('keybinding-3');
-        });
-
-        this.settings.connect('changed::keybinding-4', () => {
-            log(`Keybinding 4 changed to: ${this.settings.get_strv('keybinding-4')}`);
-            this.refreshKeybinding('keybinding-4');
+        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', () => {
@@ -93,34 +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 'keybinding-1':
-                this.bindKeybinding('keybinding-1', () => {
-                    log('Keybinding 1 was pressed!');
-                });
-                break;
-            case 'keybinding-2':
-                this.bindKeybinding('keybinding-2', () => {
-                    log('Keybinding 2 was pressed!');
-                });
-                break;
-            case 'keybinding-3':
-                this.bindKeybinding('keybinding-3', () => {
-                    log('Keybinding 3 was pressed!');
-                });
-                break;
-            case 'keybinding-4':
-                this.bindKeybinding('keybinding-4', () => {
-                    log('Keybinding 4 was pressed!');
-                });
-                break;
-        }
+        const action = this.keybindingActions()[settingName];
+        if (action) this.bindKeybinding(settingName, action);
     }
 
     private removeKeybindings() {
@@ -131,21 +78,10 @@ export default class aerospike extends Extension {
     }
 
     private setupKeybindings() {
-        this.bindKeybinding('keybinding-1', () => {
-            log('Keybinding 1 was pressed!');
-        });
-
-        this.bindKeybinding('keybinding-2', () => {
-            log('Keybinding 2 was pressed!');
-        });
-
-        this.bindKeybinding('keybinding-3', () => {
-            log('Keybinding 3 was pressed!');
-        });
-
-        this.bindKeybinding('keybinding-4', () => {
-            log('Keybinding 4 was pressed!');
-        });
+        const actions = this.keybindingActions();
+        for (const [name, action] of Object.entries(actions)) {
+            this.bindKeybinding(name, action);
+        }
     }
 
     private bindKeybinding(settingName: string, callback: () => void) {
@@ -158,323 +94,11 @@ export default class aerospike extends Extension {
         const keyBindingAction = Main.wm.addKeybinding(
             settingName,
             this.settings,
-            Meta.KeyBindingFlags.IGNORE_AUTOREPEAT,
+            Meta.KeyBindingFlags.NONE,
             Shell.ActionMode.NORMAL,
             callback
         );
 
         this.keyBindings.set(settingName, keyBindingAction);
     }
-
-    handleWindowCreated(window: Meta.Window) {
-        console.log("WINDOW CREATED", window);
-        if (!this._isWindowTileable(window)) {
-            return;
-        }
-        console.log("WINDOW IS TILABLE");
-        const actor = window.get_compositor_private();
-        if (!actor) {
-            return;
-        }
-
-
-        this._addWindow(window);
-    }
-
-    _captureExistingWindows() {
-        console.log("CAPTURING WINDOWS")
-        const workspace = global.workspace_manager.get_active_workspace();
-        const windows = global.display.get_tab_list(Meta.TabList.NORMAL, workspace);
-        console.log("WINDOWS", windows);
-        windows.forEach(window => {
-            if (this._isWindowTileable(window)) {
-                this._addWindow(window);
-            }
-        });
-
-        this._tileWindows();
-    }
-
-    getUsableMonitorSpace(window: Meta.Window) {
-        // Get the current workspace
-        const workspace = window.get_workspace();
-
-        // Get the monitor index that this window is on
-        const monitorIndex = window.get_monitor();
-
-        // Get the work area
-        const workArea = workspace.get_work_area_for_monitor(monitorIndex);
-
-        return {
-            x: workArea.x,
-            y: workArea.y,
-            width: workArea.width,
-            height: workArea.height
-        };
-    }
-
-
-    // Function to safely resize a window after it's ready
-    safelyResizeWindow(win: Meta.Window, x: number, y: number, width: number, height: number): void {
-        const actor = win.get_compositor_private();
-
-        if (!actor) {
-            console.log("No actor available, can't resize safely yet");
-            return;
-        }
-
-        // Set a flag to track if the resize has been done
-        let resizeDone = false;
-
-        // Connect to the first-frame signal
-        const id = actor.connect('first-frame', () => {
-            // Disconnect the signal handler
-            actor.disconnect(id);
-
-            if (!resizeDone) {
-                resizeDone = true;
-
-                // Add a small delay
-                GLib.timeout_add(GLib.PRIORITY_DEFAULT, 250, () => {
-                    try {
-                        this.resizeWindow(win, x, y, width, height);
-                    } catch (e) {
-                        console.error("Error resizing window:", e);
-                    }
-                    return GLib.SOURCE_REMOVE;
-                });
-            }
-        });
-
-        // Fallback timeout in case the first-frame signal doesn't fire
-        // (for windows that are already mapped)
-        GLib.timeout_add(GLib.PRIORITY_DEFAULT, 100, () => {
-            if (!resizeDone) {
-                resizeDone = true;
-                try {
-                    this.resizeWindow(win, x, y, width, height);
-                } catch (e) {
-                    console.error("Error resizing window (fallback):", e);
-                }
-            }
-            return GLib.SOURCE_REMOVE;
-        });
-    }
-
-    resizeWindow(win: Meta.Window, x:number, y:number, width:number, height:number) {
-        // First, ensure window is not maximized or fullscreen
-        if (win.get_maximized()) {
-            console.log("WINDOW MAXIMIZED")
-            win.unmaximize(Meta.MaximizeFlags.BOTH);
-        }
-
-        if (win.is_fullscreen()) {
-            console.log("WINDOW IS FULLSCREEN")
-            win.unmake_fullscreen();
-        }
-        console.log("WINDOW", win.get_window_type(), win.allows_move());
-        console.log("MONITOR INFO", this.getUsableMonitorSpace(win));
-        console.log("NEW_SIZE", x, y, width, height);
-        // win.move_resize_frame(false, 50, 50, 300, 300);
-        win.move_resize_frame(false, x, y, width, height);
-        console.log("RESIZED WINDOW", win.get_frame_rect().height, win.get_frame_rect().width, win.get_frame_rect().x, win.get_frame_rect().y);
-    }
-
-    _addWindow(window: Meta.Window) {
-        const windowId = window.get_id();
-
-        // Connect to window signals
-        const signals: Signal[] = [];
-        console.log("ADDING WINDOW", window);
-        // const act = window.get_compositor_private();
-        // const id = act.connect('first-frame', _ => {
-        //     this.resizeWindow(window);
-        //     act.disconnect(id);
-        // });
-
-        const destroyId = window.connect('unmanaging', () => {
-            console.log("REMOVING WINDOW", windowId);
-            this._handleWindowClosed(windowId);
-        });
-        signals.push({name: 'unmanaging', id: destroyId});
-
-        const focusId = window.connect('notify::has-focus', () => {
-            if (window.has_focus()) {
-                this._activeWindowId = windowId;
-            }
-        });
-        signals.push({name: 'notify::has-focus', id: focusId});
-
-        // Add window to managed windows
-        this._windows.set(windowId, {
-            window: window,
-            signals: signals
-        });
-
-        // If this is the first window, make it the active one
-        if (this._windows.size === 1 || window.has_focus()) {
-            this._activeWindowId = windowId;
-        }
-
-        this._tileWindows();
-    }
-
-    _handleWindowClosed(windowId: number) {
-        print("closing window", windowId);
-        const windowData = this._windows.get(windowId);
-        if (!windowData) {
-            return;
-        }
-
-        // Disconnect signals
-        if (windowData.signals) {
-            windowData.signals.forEach(signal => {
-                try {
-
-                    if (windowData.window != null) {
-                        windowData.window.disconnect(signal.id);
-                    }
-                } catch (e) {
-                    // Window might already be gone
-                }
-            });
-        }
-
-        // Remove from managed windows
-        this._windows.delete(windowId);
-
-        // If this was the active window, find a new one
-        if (this._activeWindowId === windowId && this._windows.size > 0) {
-            this._activeWindowId = Array.from(this._windows.keys())[0];
-        } else if (this._windows.size === 0) {
-            this._activeWindowId = null;
-        }
-
-        // Retile remaining windows
-        this._tileWindows();
-    }
-
-
-    _tileWindows() {
-        console.log("TILING WINDOWS")
-        const workspace = global.workspace_manager.get_active_workspace();
-        const workArea = workspace.get_work_area_for_monitor(
-            global.display.get_primary_monitor()
-        );
-        console.log("Workspace", workspace);
-        console.log("WorkArea", workArea);
-
-        // Get all windows for current workspace
-        const windows = Array.from(this._windows.values())
-            .filter(({window}) => {
-
-                if (window != null) {
-                    return window.get_workspace() === workspace;
-                }
-            })
-            .map(({window}) => window);
-
-        if (windows.length === 0) {
-            return;
-        }
-        this._tileHorizontally(windows, workArea)
-
-    }
-
-    _tileHorizontally(windows: (Meta.Window | null)[], workArea: Mtk.Rectangle) {
-        const windowWidth = Math.floor(workArea.width / windows.length);
-
-        windows.forEach((window, index) => {
-            const x = workArea.x + (index * windowWidth);
-            const rect = {
-                x: x,
-                y: workArea.y,
-                width: windowWidth,
-                height: workArea.height
-            };
-            if (window != null) {
-                this.safelyResizeWindow(window, rect.x, rect.y, rect.width, rect.height);
-            }
-        });
-    }
-
-    _isWindowTileable(window: Meta.Window) {
-        if (!window || !window.get_compositor_private()) {
-            return false;
-        }
-
-        const windowType = window.get_window_type();
-        console.log("WINDOW TYPE", windowType);
-        // Skip certain types of windows
-        return !window.is_skip_taskbar() &&
-            windowType !== Meta.WindowType.DESKTOP &&
-            windowType !== Meta.WindowType.DOCK &&
-            windowType !== Meta.WindowType.DIALOG &&
-            windowType !== Meta.WindowType.MODAL_DIALOG &&
-            windowType !== Meta.WindowType.UTILITY &&
-            windowType !== Meta.WindowType.MENU;
-    }
-
-    // _updateBorder(window: Meta.Window) {
-    //     console.log("UPDATING THE BORDER")
-    //     // Clear the previous border
-    //     this._clearBorder();
-    //     // Set a new border for the currently focused window
-    //     if (window) {
-    //         this._setBorder(window);
-    //         this.lastFocusedWindow = window;
-    //     }
-    // }
-    //
-    // _setBorder(window: Meta.Window) {
-    //     console.log("SETTING THE BORDER")
-    //     if (!window) return;
-    //
-    //     const rect = window.get_frame_rect();
-    //     if (!rect) return;
-    //
-    //     // Create a new actor for the border using St.Widget
-    //     this.borderActor = new St.Widget({
-    //         name: 'active-window-border',
-    //         // style_class: 'active-window-border',
-    //         reactive: false,
-    //         x: rect.x - 1, // Adjust for border width
-    //         y: rect.y - 1,
-    //         width: rect.width + 2, // Increased to accommodate border
-    //         height: rect.height + 2,
-    //         // Initial style with default color.ts
-    //         // style: `border: 4px solid hsl(${this.hue}, 100%, 50%); border-radius: 5px;`,
-    //         // style: `border: 2px solid rgba(0, 0, 0, 0.5); border-radius: 3px;`
-    //     });
-    //
-    //     // Add the border actor to the UI group
-    //     global.window_group.add_child(this.borderActor);
-    //     // Main.layoutManager.uiGroup.add_child(this.borderActor);
-    //
-    //     // Listen to window's changes in position and size
-    //     this.focusWindowSignals?.push(window.connect('position-changed', () => this._updateBorderPosition(window)));
-    //     this.focusWindowSignals?.push(window.connect('size-changed', () => this._updateBorderPosition(window)));
-    //     this.focusWindowSignals?.push(window.connect('unmanaged', () => this._clearBorder()));
-    //
-    //     this._updateBorderPosition(window);
-    //
-    //     // Start the color.ts cycling
-    //     this._startColorCycle();
-    // }
-
-
-    disable() {
-        console.log("DISABLED AEROSPIKE!")
-        // Disconnect the focus signal and remove any existing borders
-        if (this._focusSignal) {
-            global.display.disconnect(this._focusSignal);
-            this._focusSignal = null;
-        }
-
-        // Clear the border on the last focused window if it exists
-        // this._clearBorder();
-        this.lastFocusedWindow = null;
-    }
-
-
-}
+}

jest.config.js

@@ -0,0 +1,23 @@
+export default {
+  preset: 'ts-jest/presets/default-esm',
+  testEnvironment: 'node',
+  extensionsToTreatAsEsm: ['.ts'],
+  moduleNameMapper: {
+    '^(\\.{1,2}/.*)\\.js$': '$1',
+  },
+  transform: {
+    '^.+\\.ts$': [
+      'ts-jest',
+      {
+        useESM: true,
+      },
+    ],
+  },
+  testMatch: ['**/__tests__/**/*.test.ts', '**/?(*.)+(spec|test).ts'],
+  collectCoverageFrom: [
+    'src/**/*.ts',
+    '!src/**/*.d.ts',
+    '!src/**/__tests__/**',
+  ],
+  modulePathIgnorePatterns: ['<rootDir>/dist/', '<rootDir>/node_modules/'],
+};

justfile

@@ -8,7 +8,7 @@ packages:
 
 build: packages && build-schemas
     rm -rf dist/*
-    tsc
+    pnpm exec tsc
     cp metadata.json dist/
     cp stylesheet.css dist/
     mkdir -p dist/schemas
@@ -24,14 +24,29 @@ build-package: build
 
 install: build
 	mkdir -p ~/.local/share/gnome-shell/extensions/{{NAME}}@{{DOMAIN}}
-	rm -rf /.local/share/gnome-shell/extensions/{{NAME}}@{{DOMAIN}}/*
+	rm -rf ~/.local/share/gnome-shell/extensions/{{NAME}}@{{DOMAIN}}/*
 	cp -r dist/* ~/.local/share/gnome-shell/extensions/{{NAME}}@{{DOMAIN}}/
 
 run:
-    env MUTTER_DEBUG_DUMMY_MODE_SPECS=1280x720 dbus-run-session -- gnome-shell --nested --wayland
+    env MUTTER_DEBUG_DUMMY_MODE_SPECS=1280x720 dbus-run-session -- gnome-shell --devkit --wayland
 
 install-and-run: install run
 
+live-debug:
+    journalctl /usr/bin/gnome-shell -f -o cat | tee debug.log
+
+test:
+    pnpm test
+
+test-watch:
+    pnpm test:watch
+
+test-coverage:
+    pnpm test:coverage
+
+ci-local:
+    act -W .gitea/workflows/build.yaml
+
 #pack: build
 #    gnome-extensions pack dist \
 #        --force \

metadata.json

@@ -4,7 +4,8 @@
   "uuid": "aerospike@lucaso.io",
   "settings-schema": "org.gnome.shell.extensions.aerospike",
   "shell-version": [
-    "48"
+    "48",
+    "49"
   ],
   "gettext-domain": "aerospike@lucaso.io",
   "url": "https://gitea.chaosdev.gay/lucasoskorep/aerospike@lucaso.io"

package.json

@@ -15,14 +15,43 @@
   },
   "homepage": "https://github.com/example/my-extension#readme",
   "sideEffects": false,
+  "scripts": {
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage"
+  },
   "devDependencies": {
-    "@girs/gjs": "^4.0.0-beta.23",
-    "@girs/gnome-shell": "^48.0.1",
-    "eslint": "^9.23.0",
-    "eslint-plugin-jsdoc": "^50.6.9",
-    "typescript": "^5.8.2"
+    "@girs/gjs": "4.0.0-beta.38",
+    "@girs/gnome-shell": "49.1.0",
+    "@jest/globals": "^30.0.0",
+    "@types/jest": "^30.0.0",
+    "eslint": "^9.36.0",
+    "eslint-plugin-jsdoc": "^62.0.0",
+    "jest": "^30.0.0",
+    "ts-jest": "^29.1.2",
+    "typescript": "^5.9.2"
   },
   "dependencies": {
-    "@girs/mtk-16": "16.0.0-4.0.0-beta.23"
+    "@girs/mtk-17": "17.0.0-4.0.0-beta.38"
+  },
+  "pnpm": {
+    "overrides": {
+      "@girs/cairo-1.0": "1.0.0-4.0.0-beta.38",
+      "@girs/freetype2-2.0": "2.0.0-4.0.0-beta.38",
+      "@girs/gdk-4.0": "4.0.0-4.0.0-beta.38",
+      "@girs/gdkpixbuf-2.0": "2.0.0-4.0.0-beta.38",
+      "@girs/gio-2.0": "2.86.0-4.0.0-beta.38",
+      "@girs/gjs": "4.0.0-beta.38",
+      "@girs/glib-2.0": "2.86.0-4.0.0-beta.38",
+      "@girs/gmodule-2.0": "2.0.0-4.0.0-beta.38",
+      "@girs/gobject-2.0": "2.86.0-4.0.0-beta.38",
+      "@girs/graphene-1.0": "1.0.0-4.0.0-beta.38",
+      "@girs/gsk-4.0": "4.0.0-4.0.0-beta.38",
+      "@girs/gtk-4.0": "4.20.1-4.0.0-beta.38",
+      "@girs/harfbuzz-0.0": "11.5.0-4.0.0-beta.38",
+      "@girs/mtk-17": "17.0.0-4.0.0-beta.38",
+      "@girs/pango-1.0": "1.57.0-4.0.0-beta.38",
+      "@girs/pangocairo-1.0": "1.0.0-4.0.0-beta.38"
+    }
   }
 }

prefs.ts

@@ -1,4 +1,4 @@
 // This file is just a wrapper around the compiled TypeScript code
-import MyExtensionPreferences from './src/prefs.js';
+import AerospikeExtensions from './src/prefs/prefs.js';
 
-export default MyExtensionPreferences;
+export default AerospikeExtensions;

renovate.json

@@ -0,0 +1,12 @@
+{
+  "$schema": "https://docs.renovatebot.com/renovate-schema.json",
+  "extends": [
+    "config:recommended"
+  ],
+  "packageRules": [
+    {
+      "matchPackageNames": ["actions/upload-artifact", "actions/download-artifact"],
+      "allowedVersions": "<4"
+    }
+  ]
+}

schemas/org.gnome.shell.extensions.aerospike.gschema.xml

@@ -1,30 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <schemalist>
     <schema id="org.gnome.shell.extensions.aerospike" path="/org/gnome/shell/extensions/aerospike/">
-        <key name="keybinding-1" type="as">
-            <default><![CDATA[['<Super>1']]]></default>
-            <summary>Keybinding for action 1</summary>
-            <description>Keyboard shortcut for triggering action 1</description>
-        </key>
-
-        <key name="keybinding-2" type="as">
-            <default><![CDATA[['<Super>2']]]></default>
-            <summary>Keybinding for action 2</summary>
-            <description>Keyboard shortcut for triggering action 2</description>
-        </key>
-
-        <key name="keybinding-3" type="as">
-            <default><![CDATA[['<Super>3']]]></default>
-            <summary>Keybinding for action 3</summary>
-            <description>Keyboard shortcut for triggering action 3</description>
-        </key>
-
-        <key name="keybinding-4" type="as">
-            <default><![CDATA[['<Super>4']]]></default>
-            <summary>Keybinding for action 4</summary>
-            <description>Keyboard shortcut for triggering action 4</description>
-        </key>
-
         <key name="dropdown-option" type="s">
             <default>'option1'</default>
             <summary>Dropdown selection</summary>
@@ -36,5 +12,48 @@
             <summary>Selected color</summary>
             <description>Color chosen from the color picker</description>
         </key>
+
+        <key name="move-left" type="as">
+            <default><![CDATA[['<Super>1']]]></default>
+            <summary>Keybinding for action 1</summary>
+            <description>Keyboard shortcut for triggering action 1</description>
+        </key>
+
+        <key name="move-right" type="as">
+            <default><![CDATA[['<Super>2']]]></default>
+            <summary>Keybinding for action 2</summary>
+            <description>Keyboard shortcut for triggering action 2</description>
+        </key>
+
+        <key name="join-with-left" type="as">
+            <default><![CDATA[['<Super>3']]]></default>
+            <summary>Keybinding for action 3</summary>
+            <description>Keyboard shortcut for triggering action 3</description>
+        </key>
+
+        <key name="join-with-right" type="as">
+            <default><![CDATA[['<Super>4']]]></default>
+            <summary>Keybinding for action 4</summary>
+            <description>Keyboard shortcut for triggering action 4</description>
+        </key>
+
+        <key name="print-tree" type="as">
+            <default><![CDATA[['<Super><Shift>x']]]></default>
+            <summary>Print window tree structure</summary>
+            <description>Prints the current tree of containers and windows per monitor to logs</description>
+        </key>
+
+        <key name="toggle-orientation" type="as">
+            <default><![CDATA[['<Super><Shift>comma']]]></default>
+            <summary>Toggle active container orientation</summary>
+            <description>Toggles the orientation of the container holding the active window between horizontal and vertical</description>
+        </key>
+
+        <key name="reset-ratios" type="as">
+            <default><![CDATA[['<Primary>z']]]></default>
+            <summary>Reset container ratios to equal splits</summary>
+            <description>Resets all window size ratios in the active window's container to equal splits</description>
+        </key>
+
     </schema>
 </schemalist>

src/__tests__/container.test.ts

@@ -0,0 +1,182 @@
+import { describe, test, expect, jest, beforeEach } from '@jest/globals';
+
+// Mock the dependencies
+jest.mock('../utils/logger.js', () => ({
+  Logger: {
+    log: jest.fn(),
+    info: jest.fn(),
+    debug: jest.fn(),
+    warn: jest.fn(),
+    error: jest.fn(),
+  },
+}));
+
+jest.mock('../utils/events.js', () => ({
+  default: jest.fn(),
+}));
+
+// Since we can't import the actual WindowContainer that depends on GNOME APIs,
+// we'll test the logic patterns used in the container
+
+describe('Container Logic Tests', () => {
+  describe('Orientation Toggle Logic', () => {
+    enum Orientation {
+      HORIZONTAL = 0,
+      VERTICAL = 1,
+    }
+
+    const toggleOrientation = (current: Orientation): Orientation => {
+      return current === Orientation.HORIZONTAL
+        ? Orientation.VERTICAL
+        : Orientation.HORIZONTAL;
+    };
+
+    test('should toggle from HORIZONTAL to VERTICAL', () => {
+      const result = toggleOrientation(Orientation.HORIZONTAL);
+      expect(result).toBe(Orientation.VERTICAL);
+    });
+
+    test('should toggle from VERTICAL to HORIZONTAL', () => {
+      const result = toggleOrientation(Orientation.VERTICAL);
+      expect(result).toBe(Orientation.HORIZONTAL);
+    });
+  });
+
+  describe('Window Bounds Calculation', () => {
+    test('should calculate horizontal bounds correctly', () => {
+      const workArea = { x: 0, y: 0, width: 1000, height: 500 };
+      const itemCount = 3;
+      const windowWidth = Math.floor(workArea.width / itemCount);
+
+      const bounds = Array.from({ length: itemCount }, (_, index) => ({
+        x: workArea.x + (index * windowWidth),
+        y: workArea.y,
+        width: windowWidth,
+        height: workArea.height,
+      }));
+
+      expect(bounds.length).toBe(3);
+      expect(bounds[0].x).toBe(0);
+      expect(bounds[1].x).toBe(333);
+      expect(bounds[2].x).toBe(666);
+      expect(bounds[0].width).toBe(333);
+    });
+
+    test('should calculate vertical bounds correctly', () => {
+      const workArea = { x: 0, y: 0, width: 1000, height: 900 };
+      const itemCount = 3;
+      const windowHeight = Math.floor(workArea.height / itemCount);
+
+      const bounds = Array.from({ length: itemCount }, (_, index) => ({
+        x: workArea.x,
+        y: workArea.y + (index * windowHeight),
+        width: workArea.width,
+        height: windowHeight,
+      }));
+
+      expect(bounds.length).toBe(3);
+      expect(bounds[0].y).toBe(0);
+      expect(bounds[1].y).toBe(300);
+      expect(bounds[2].y).toBe(600);
+      expect(bounds[0].height).toBe(300);
+    });
+
+    test('should handle single window bounds', () => {
+      const workArea = { x: 100, y: 50, width: 800, height: 600 };
+      const itemCount = 1;
+      const windowWidth = Math.floor(workArea.width / itemCount);
+
+      const bounds = [{
+        x: workArea.x,
+        y: workArea.y,
+        width: windowWidth,
+        height: workArea.height,
+      }];
+
+      expect(bounds[0].x).toBe(100);
+      expect(bounds[0].y).toBe(50);
+      expect(bounds[0].width).toBe(800);
+      expect(bounds[0].height).toBe(600);
+    });
+  });
+
+  describe('Window Index Finding', () => {
+    test('should find window index in array', () => {
+      const windows = [
+        { id: 1, title: 'Window 1' },
+        { id: 2, title: 'Window 2' },
+        { id: 3, title: 'Window 3' },
+      ];
+
+      const findIndex = (id: number) => {
+        for (let i = 0; i < windows.length; i++) {
+          if (windows[i].id === id) {
+            return i;
+          }
+        }
+        return -1;
+      };
+
+      expect(findIndex(2)).toBe(1);
+      expect(findIndex(3)).toBe(2);
+      expect(findIndex(999)).toBe(-1);
+    });
+
+    test('should safely remove window by index', () => {
+      const windows = [
+        { id: 1, title: 'Window 1' },
+        { id: 2, title: 'Window 2' },
+        { id: 3, title: 'Window 3' },
+      ];
+
+      const removeWindow = (id: number) => {
+        const index = windows.findIndex(w => w.id === id);
+        if (index !== -1) {
+          windows.splice(index, 1);
+          return true;
+        }
+        return false;
+      };
+
+      const removed = removeWindow(2);
+      expect(removed).toBe(true);
+      expect(windows.length).toBe(2);
+      expect(windows.find(w => w.id === 2)).toBeUndefined();
+    });
+  });
+
+  describe('Container Item Reordering', () => {
+    test('should reorder items correctly', () => {
+      const items = ['A', 'B', 'C', 'D'];
+      const originalIndex = 1; // 'B'
+      const newIndex = 3;
+
+      // Remove from original position and insert at new position
+      const [item] = items.splice(originalIndex, 1);
+      items.splice(newIndex, 0, item);
+
+      expect(items).toEqual(['A', 'C', 'D', 'B']);
+    });
+
+    test('should handle reordering to same position', () => {
+      const items = ['A', 'B', 'C'];
+      const originalIndex = 1;
+      const newIndex = 1;
+
+      if (originalIndex !== newIndex) {
+        const [item] = items.splice(originalIndex, 1);
+        items.splice(newIndex, 0, item);
+      }
+
+      expect(items).toEqual(['A', 'B', 'C']);
+    });
+
+    test('should handle moving first item to last', () => {
+      const items = ['A', 'B', 'C'];
+      const [item] = items.splice(0, 1);
+      items.splice(2, 0, item);
+
+      expect(items).toEqual(['B', 'C', 'A']);
+    });
+  });
+});

src/__tests__/rect.test.ts

@@ -0,0 +1,75 @@
+import { describe, test, expect } from '@jest/globals';
+import type { Rect } from '../utils/rect.js';
+
+describe('Rect Type Tests', () => {
+  test('should create a valid Rect object', () => {
+    const rect: Rect = {
+      x: 10,
+      y: 20,
+      width: 100,
+      height: 200,
+    };
+
+    expect(rect.x).toBe(10);
+    expect(rect.y).toBe(20);
+    expect(rect.width).toBe(100);
+    expect(rect.height).toBe(200);
+  });
+
+  test('should handle zero dimensions', () => {
+    const rect: Rect = {
+      x: 0,
+      y: 0,
+      width: 0,
+      height: 0,
+    };
+
+    expect(rect.width).toBe(0);
+    expect(rect.height).toBe(0);
+  });
+
+  test('should handle negative coordinates', () => {
+    const rect: Rect = {
+      x: -50,
+      y: -100,
+      width: 200,
+      height: 300,
+    };
+
+    expect(rect.x).toBe(-50);
+    expect(rect.y).toBe(-100);
+  });
+
+  test('should calculate rect area correctly', () => {
+    const rect: Rect = {
+      x: 0,
+      y: 0,
+      width: 100,
+      height: 50,
+    };
+
+    const area = rect.width * rect.height;
+    expect(area).toBe(5000);
+  });
+
+  test('should determine if point is inside rect', () => {
+    const rect: Rect = {
+      x: 10,
+      y: 10,
+      width: 100,
+      height: 100,
+    };
+
+    const pointInside = { x: 50, y: 50 };
+    const pointOutside = { x: 200, y: 200 };
+
+    const isInside = (point: { x: number; y: number }, r: Rect) =>
+      point.x >= r.x &&
+      point.x <= r.x + r.width &&
+      point.y >= r.y &&
+      point.y <= r.y + r.height;
+
+    expect(isInside(pointInside, rect)).toBe(true);
+    expect(isInside(pointOutside, rect)).toBe(false);
+  });
+});

src/prefs/keybindings.ts

@@ -0,0 +1,83 @@
+// Gnome imports
+import Adw from 'gi://Adw';
+import Gtk from 'gi://Gtk';
+import Gio from 'gi://Gio';
+import GObject from 'gi://GObject';
+import { gettext as _ } from 'resource:///org/gnome/Shell/Extensions/js/extensions/prefs.js';
+import { Logger } from '../utils/logger.js';
+
+/**
+ * EntryRow class for handling text input including keybindings
+ */
+export class EntryRow extends Adw.EntryRow {
+    static {
+        GObject.registerClass(this);
+    }
+
+    constructor(params: {
+        title: string,
+        settings: Gio.Settings,
+        bind: string,
+        map?: {
+            from: (settings: Gio.Settings, bind: string) => string,
+            to: (settings: Gio.Settings, bind: string, value: string) => void
+        }
+    }) {
+        super({ title: params.title });
+        
+        const { settings, bind, map } = params;
+
+        // When text changes, update settings
+        this.connect('changed', () => {
+            const text = this.get_text();
+            if (typeof text === 'string') {
+                if (map) {
+                    map.to(settings, bind, text);
+                } else {
+                    settings.set_string(bind, text);
+                }
+            }
+        });
+
+        // Set initial text from settings
+        const current = map ? map.from(settings, bind) : settings.get_string(bind);
+        this.set_text(current ?? '');
+
+        // Add reset button
+        this.add_suffix(
+            new ResetButton({
+                settings,
+                bind,
+                onReset: () => {
+                    this.set_text((map ? map.from(settings, bind) : settings.get_string(bind)) ?? '');
+                },
+            })
+        );
+    }
+}
+
+/**
+ * Reset button for settings
+ */
+export class ResetButton extends Gtk.Button {
+    static {
+        GObject.registerClass(this);
+    }
+
+    constructor(params: {
+        settings?: Gio.Settings,
+        bind: string,
+        onReset?: () => void
+    }) {
+        super({
+            icon_name: 'edit-clear-symbolic',
+            tooltip_text: _('Reset'),
+            valign: Gtk.Align.CENTER,
+        });
+
+        this.connect('clicked', () => {
+            params.settings?.reset(params.bind);
+            params.onReset?.();
+        });
+    }
+}

src/prefs/prefs.ts

@@ -3,8 +3,10 @@ import Gio from 'gi://Gio';
 import Gtk from 'gi://Gtk';
 import Gdk from 'gi://Gdk';
 import { ExtensionPreferences, gettext as _ } from 'resource:///org/gnome/Shell/Extensions/js/extensions/prefs.js';
+import {Logger} from "../utils/logger.js";
+import {EntryRow} from "./keybindings.js";
 
-export default class MyExtensionPreferences extends ExtensionPreferences {
+export default class AerospikeExtensions extends ExtensionPreferences {
     async fillPreferencesWindow(window: Adw.PreferencesWindow) {
         // Create settings object
         const settings = this.getSettings('org.gnome.shell.extensions.aerospike');
@@ -16,17 +18,6 @@ export default class MyExtensionPreferences extends ExtensionPreferences {
         });
         window.add(page);
 
-        // Create keybindings group
-        const keybindingsGroup = new Adw.PreferencesGroup({
-            title: _('Keyboard Shortcuts'),
-        });
-        page.add(keybindingsGroup);
-
-        // Add keybinding rows
-        this.addKeybindingRow(keybindingsGroup, settings, 'keybinding-1', _('Action 1'));
-        this.addKeybindingRow(keybindingsGroup, settings, 'keybinding-2', _('Action 2'));
-        this.addKeybindingRow(keybindingsGroup, settings, 'keybinding-3', _('Action 3'));
-        this.addKeybindingRow(keybindingsGroup, settings, 'keybinding-4', _('Action 4'));
 
         // Create options group
         const optionsGroup = new Adw.PreferencesGroup({
@@ -114,79 +105,108 @@ export default class MyExtensionPreferences extends ExtensionPreferences {
             const color = colorButton.get_rgba().to_string();
             settings.set_string('color-selection', color);
         });
+
+        // Create keybindings group
+        const keybindingsGroup = new Adw.PreferencesGroup({
+            title: _('Keyboard Shortcuts'),
+            description: `${_("Syntax")}: <Super>h, <Shift>g, <Super><Shift>h
+            ${_("Legend")}: <Super> - ${_("Windows key")}, <Primary> - ${_("Control key")}
+            ${_("Delete text to unset. Press Return key to accept.")}`,
+        });
+        page.add(keybindingsGroup);
+
+        // Add keybinding rows as EntryRows with proper mapping
+        // Use the helper function to create the map object
+        const keybindingMap = this.createKeybindingMap();
+        
+        keybindingsGroup.add(
+            new EntryRow({
+                title: _('Action 1'),
+                settings: settings,
+                bind: 'move-left',
+                map: keybindingMap
+            })
+        );
+        
+        keybindingsGroup.add(
+            new EntryRow({
+                title: _('Action 2'),
+                settings: settings,
+                bind: 'move-right',
+                map: keybindingMap
+            })
+        );
+        
+        keybindingsGroup.add(
+            new EntryRow({
+                title: _('Action 3'),
+                settings: settings,
+                bind: 'join-with-left',
+                map: keybindingMap
+            })
+        );
+        
+        keybindingsGroup.add(
+            new EntryRow({
+                title: _('Action 4'),
+                settings: settings,
+                bind: 'join-with-right',
+                map: keybindingMap
+            })
+        );
+
+        keybindingsGroup.add(
+            new EntryRow({
+                title: _('Print Tree Structure'),
+                settings: settings,
+                bind: 'print-tree',
+                map: keybindingMap
+            })
+        );
+
+        keybindingsGroup.add(
+            new EntryRow({
+                title: _('Toggle Orientation'),
+                settings: settings,
+                bind: 'toggle-orientation',
+                map: keybindingMap
+            })
+        );
+
+        keybindingsGroup.add(
+            new EntryRow({
+                title: _('Reset Container Ratios to Equal'),
+                settings: settings,
+                bind: 'reset-ratios',
+                map: keybindingMap
+            })
+        );
+
     }
 
-    private addKeybindingRow(
-        group: Adw.PreferencesGroup,
-        settings: Gio.Settings,
-        key: string,
-        title: string
-    ) {
-        const shortcutsRow = new Adw.ActionRow({
-            title: title,
-        });
-
-        group.add(shortcutsRow);
-
-        // Create a button for setting shortcuts
-        const shortcutButton = new Gtk.Button({
-            valign: Gtk.Align.CENTER,
-            label: settings.get_strv(key)[0] || _("Disabled")
-        });
-
-        shortcutsRow.add_suffix(shortcutButton);
-        shortcutsRow.set_activatable_widget(shortcutButton);
-
-        // When clicking the button, show a dialog or start listening for keystroke
-        shortcutButton.connect('clicked', () => {
-            // Show a simple popup stating that the shortcut is being recorded
-            const dialog = new Gtk.MessageDialog({
-                modal: true,
-                text: _("Press a key combination to set as shortcut"),
-                secondary_text: _("Press Esc to cancel or Backspace to disable"),
-                buttons: Gtk.ButtonsType.CANCEL,
-                transient_for: group.get_root() as Gtk.Window
-            });
-
-            // Create a keypress event controller
-            const controller = new Gtk.EventControllerKey();
-            dialog.add_controller(controller);
-
-            controller.connect('key-pressed', (_controller, keyval, keycode, state) => {
-                // Get the key name
-                let keyName = Gdk.keyval_name(keyval);
-
-                // Handle special cases
-                if (keyName === 'Escape') {
-                    dialog.response(Gtk.ResponseType.CANCEL);
-                    return Gdk.EVENT_STOP;
-                } else if (keyName === 'BackSpace') {
-                    // Clear the shortcut
-                    settings.set_strv(key, []);
-                    shortcutButton.set_label(_("Disabled"));
-                    dialog.response(Gtk.ResponseType.OK);
-                    return Gdk.EVENT_STOP;
+    // Helper function to create a keybinding mapping object
+    private createKeybindingMap() {
+        return {
+            from(settings: Gio.Settings, bind: string) {
+                return settings.get_strv(bind).join(',');
+            },
+            to(settings: Gio.Settings, bind: string, value: string) {
+                if (!!value) {
+                    const mappings = value.split(',').map((x) => {
+                        const [, key, mods] = Gtk.accelerator_parse(x);
+                        return Gtk.accelerator_valid(key, mods) && Gtk.accelerator_name(key, mods);
+                    });
+                    // Filter out any false values to ensure we only have strings
+                    const stringMappings = mappings.filter((x): x is string => typeof x === 'string');
+                    if (stringMappings.length > 0) {
+                        Logger.debug("setting", bind, "to", stringMappings);
+                        settings.set_strv(bind, stringMappings);
+                    }
+                } else {
+                    // If value deleted, unset the mapping
+                    settings.set_strv(bind, []);
                 }
-
-                // Convert modifier state to keybinding modifiers
-                let modifiers = state & Gtk.accelerator_get_default_mod_mask();
-
-                // Ignore standalone modifier keys
-                if (Gdk.ModifierType.SHIFT_MASK <= keyval && keyval <= Gdk.ModifierType.META_MASK)
-                    return Gdk.EVENT_STOP;
-
-                // Create accelerator string
-                let accelerator = Gtk.accelerator_name(keyval, modifiers);
-                if (accelerator) {
-                    settings.set_strv(key, [accelerator]);
-                    shortcutButton.set_label(accelerator);
-                    dialog.response(Gtk.ResponseType.OK);
-                }
-
-                return Gdk.EVENT_STOP;
-            });
-
-            dialog.present();
-        });
+            },
+        };
     }
 }

src/utils.ts

@@ -1,20 +0,0 @@
-// Utility functions and type definitions
-
-/**
- * Interface for the extension settings
- */
-export interface ExtensionSettings {
-    keybinding1: string[];
-    keybinding2: string[];
-    keybinding3: string[];
-    keybinding4: string[];
-    dropdownOption: string;
-    colorSelection: string;
-}
-
-/**
- * Log a message with the extension name prefix
- */
-export function log(message: string): void {
-    console.log(`[MyExtension] ${message}`);
-}

src/utils/events.ts

@@ -0,0 +1,21 @@
+import GLib from "gi://GLib";
+
+export type QueuedEvent = {
+    name: string;
+    callback: () => void;
+}
+
+const pendingEvents: Map<string, QueuedEvent> = new Map();
+
+export default function queueEvent(event: QueuedEvent, interval = 200) {
+    pendingEvents.set(event.name, event);
+
+    GLib.timeout_add(GLib.PRIORITY_DEFAULT, interval, () => {
+        const e = pendingEvents.get(event.name);
+        if (e && e === event) {
+            pendingEvents.delete(event.name);
+            e.callback();
+        }
+        return GLib.SOURCE_REMOVE;
+    });
+}

src/utils/logger.ts

@@ -0,0 +1,30 @@
+export class Logger {
+
+    static fatal(...args: any[]) {
+        console.log(`[Aerospike] [FATAL]`, ...args);
+    }
+
+    static error(...args: any[]) {
+        console.log(`[Aerospike] [ERROR]`, ...args);
+    }
+
+    static warn(...args: any[]) {
+        console.log(`[Aerospike] [WARN]`, ...args);
+    }
+
+    static info(...args: any[]) {
+        console.log(`[Aerospike] [INFO]`, ...args);
+    }
+
+    static debug(...args: any[]) {
+        console.log(`[Aerospike] [DEBUG]`, ...args);
+    }
+
+    static trace(...args: any[]) {
+        console.log(`[Aerospike] [TRACE]`, ...args);
+    }
+
+    static log(...args: any[]) {
+        console.log(`[Aerospike] [LOG]`, ...args);
+    }
+}

src/utils/rect.ts

@@ -0,0 +1,6 @@
+export type Rect = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}

src/wm/container.ts

@@ -0,0 +1,277 @@
+import {WindowWrapper} from "./window.js";
+import {Logger} from "../utils/logger.js";
+import queueEvent from "../utils/events.js";
+import {Rect} from "../utils/rect.js";
+
+enum Orientation {
+    HORIZONTAL = 0,
+    VERTICAL = 1,
+}
+
+// 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);
+    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;
+    _splitRatios: number[];
+
+    constructor(workspaceArea: Rect) {
+        this._tiledItems = [];
+        this._tiledWindowLookup = new Map<number, WindowWrapper>();
+        this._workArea = workspaceArea;
+        this._splitRatios = [];
+    }
+
+    // ─── Helpers ────────────────────────────────────────────────────────────────
+
+    private _resetRatios(): void {
+        this._splitRatios = equalRatios(this._tiledItems.length);
+    }
+
+    private _addRatioForNewWindow(): void {
+        const n = this._tiledItems.length;
+        if (n <= 1) {
+            this._splitRatios = [1.0];
+            return;
+        }
+        const newRatio = 1 / n;
+        const scale    = 1 - newRatio;
+        const scaled   = this._splitRatios.map(r => r * scale);
+        const partialSum = scaled.reduce((a, b) => a + b, 0) + newRatio;
+        scaled[scaled.length - 1] += (1.0 - partialSum);
+        this._splitRatios = [...scaled, newRatio];
+    }
+
+    private _totalDimension(): number {
+        return this._orientation === Orientation.HORIZONTAL
+            ? this._workArea.width
+            : this._workArea.height;
+    }
+
+    // ─── Public API ─────────────────────────────────────────────────────────────
+
+    move(rect: Rect): void {
+        this._workArea = rect;
+        this.tileWindows();
+    }
+
+    toggleOrientation(): void {
+        this._orientation = this._orientation === Orientation.HORIZONTAL
+            ? Orientation.VERTICAL
+            : Orientation.HORIZONTAL;
+        Logger.info(`Container orientation toggled to ${this._orientation === Orientation.HORIZONTAL ? 'HORIZONTAL' : 'VERTICAL'}`);
+        this.tileWindows();
+    }
+
+    addWindow(winWrap: WindowWrapper): void {
+        this._tiledItems.push(winWrap);
+        this._tiledWindowLookup.set(winWrap.getWindowId(), winWrap);
+        this._addRatioForNewWindow();
+        queueEvent({
+            name: "tiling-windows",
+            callback: () => this.tileWindows(),
+        }, 100);
+    }
+
+    getWindow(win_id: number): WindowWrapper | undefined {
+        if (this._tiledWindowLookup.has(win_id)) {
+            return this._tiledWindowLookup.get(win_id);
+        }
+        for (const item of this._tiledItems) {
+            if (item instanceof WindowContainer) {
+                const win = item.getWindow(win_id);
+                if (win) return win;
+            } else if (item.getWindowId() === win_id) {
+                return item;
+            }
+        }
+        return undefined;
+    }
+
+    _getIndexOfWindow(win_id: number): number {
+        for (let i = 0; i < this._tiledItems.length; i++) {
+            const item = this._tiledItems[i];
+            if (item instanceof WindowWrapper && item.getWindowId() === win_id) {
+                return i;
+            }
+        }
+        return -1;
+    }
+
+    removeWindow(win_id: number): void {
+        if (this._tiledWindowLookup.has(win_id)) {
+            // Get index before deleting from lookup to avoid race condition
+            const index = this._getIndexOfWindow(win_id);
+            this._tiledWindowLookup.delete(win_id);
+            if (index !== -1) {
+                this._tiledItems.splice(index, 1);
+            }
+            this._resetRatios();
+        } else {
+            for (const item of this._tiledItems) {
+                if (item instanceof WindowContainer) {
+                    item.removeWindow(win_id);
+                }
+            }
+        }
+        this.tileWindows();
+    }
+
+    disconnectSignals(): void {
+        this._tiledItems.forEach((item) => {
+            if (item instanceof WindowContainer) {
+                item.disconnectSignals();
+            } else {
+                item.disconnectWindowSignals();
+            }
+        });
+    }
+
+    removeAllWindows(): void {
+        this._tiledItems = [];
+        this._tiledWindowLookup.clear();
+        this._splitRatios = [];
+    }
+
+    tileWindows(): void {
+        Logger.log("TILING WINDOWS IN CONTAINER");
+        Logger.log("WorkArea", this._workArea);
+        this._tileItems();
+    }
+
+    _tileItems() {
+        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) => {
+            const rect = bounds[index];
+            if (item instanceof WindowContainer) {
+                item.move(rect);
+            } else {
+                Logger.info(`_tileItems: window[${index}] id=${item.getWindowId()} dragging=${item._dragging} → rect=(${rect.x},${rect.y},${rect.width},${rect.height})`);
+                item.safelyResizeWindow(rect);
+            }
+        });
+    }
+
+    // ─── Bounds Calculation ──────────────────────────────────────────────────────
+
+    getBounds(): Rect[] {
+        return this._orientation === Orientation.HORIZONTAL
+            ? this._computeBounds('horizontal')
+            : this._computeBounds('vertical');
+    }
+
+    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 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 Adjustment ─────────────────────────────────────────────────────
+
+    adjustBoundary(boundaryIndex: number, deltaPixels: number): boolean {
+        if (boundaryIndex < 0 || boundaryIndex >= this._tiledItems.length - 1) {
+            Logger.warn(`adjustBoundary: invalid boundaryIndex ${boundaryIndex}`);
+            return false;
+        }
+
+        const totalDim = this._totalDimension();
+        if (totalDim === 0) return false;
+
+        const ratioDelta = deltaPixels / totalDim;
+        const newLeft    = this._splitRatios[boundaryIndex]     + ratioDelta;
+        const newRight   = this._splitRatios[boundaryIndex + 1] - ratioDelta;
+
+        if (newLeft <= 0 || newRight <= 0) {
+            Logger.log(`adjustBoundary: clamped — newLeft=${newLeft.toFixed(3)}, newRight=${newRight.toFixed(3)}`);
+            return false;
+        }
+
+        this._splitRatios[boundaryIndex]     = newLeft;
+        this._splitRatios[boundaryIndex + 1] = newRight;
+
+        Logger.info(`adjustBoundary: boundary=${boundaryIndex} ratios=[${this._splitRatios.map(r => r.toFixed(3)).join(', ')}]`);
+        return true;
+    }
+
+    // ─── Container Lookup ────────────────────────────────────────────────────────
+
+    getContainerForWindow(win_id: number): WindowContainer | null {
+        for (const item of this._tiledItems) {
+            if (item instanceof WindowWrapper && item.getWindowId() === win_id) {
+                return this;
+            }
+            if (item instanceof WindowContainer) {
+                const found = item.getContainerForWindow(win_id);
+                if (found !== null) return found;
+            }
+        }
+        return null;
+    }
+
+    getIndexOfItemNested(item: WindowWrapper): number {
+        for (let i = 0; i < this._tiledItems.length; i++) {
+            const container = this._tiledItems[i];
+            if (container instanceof WindowContainer) {
+                if (container.getIndexOfItemNested(item) !== -1) return i;
+            } else if (container.getWindowId() === item.getWindowId()) {
+                return i;
+            }
+        }
+        return -1;
+    }
+
+    // TODO: update this to work with nested containers - all other logic should already be working
+    itemDragged(item: WindowWrapper, x: number, y: number): void {
+        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) {
+            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]];
+            this.tileWindows();
+        }
+    }
+
+    resetRatios(): void {
+        this._resetRatios();
+        this.tileWindows();
+    }
+}

src/wm/monitor.ts

@@ -0,0 +1,79 @@
+import {WindowWrapper} from "./window.js";
+import {Rect} from "../utils/rect.js";
+import {Logger} from "../utils/logger.js";
+import Meta from "gi://Meta";
+
+import WindowContainer from "./container.js";
+
+export default class Monitor {
+
+    _id: number;
+    _workArea: Rect;
+    _workspaces: WindowContainer[] = [];
+
+    constructor(monitorId: number) {
+        this._id = monitorId;
+        const workspace = global.workspace_manager.get_active_workspace();
+        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();
+        Logger.log("Workspace Count", workspaceCount);
+        for (let i = 0; i < workspaceCount; i++) {
+            this._workspaces.push(new WindowContainer(this._workArea));
+        }
+    }
+
+    disconnectSignals() {
+        for (const container of this._workspaces) {
+            container.disconnectSignals();
+        }
+    }
+
+    removeAllWindows(): void {
+        for (const container of this._workspaces) {
+            container.removeAllWindows();
+        }
+    }
+
+    getWindow(windowId: number): WindowWrapper | undefined {
+        for (const container of this._workspaces) {
+            const win = container.getWindow(windowId);
+            if (win) return win;
+        }
+        return undefined;
+    }
+
+    removeWindow(winWrap: WindowWrapper) {
+        const windowId = winWrap.getWindowId();
+        for (const container of this._workspaces) {
+            if (container.getWindow(windowId)) {
+                container.removeWindow(windowId);
+            }
+        }
+    }
+
+    addWindow(winWrap: WindowWrapper) {
+        const window_workspace = winWrap.getWindow().get_workspace().index();
+        this._workspaces[window_workspace].addWindow(winWrap);
+    }
+
+    tileWindows(): void {
+        const activeWorkspace = global.workspace_manager.get_active_workspace();
+        this._workArea = activeWorkspace.get_work_area_for_monitor(this._id);
+        // move() calls tileWindows() internally
+        this._workspaces[activeWorkspace.index()].move(this._workArea);
+    }
+
+    removeWorkspace(workspaceId: number): void {
+        this._workspaces.splice(workspaceId, 1);
+    }
+
+    addWorkspace(): void {
+        this._workspaces.push(new WindowContainer(this._workArea));
+    }
+
+    itemDragged(item: WindowWrapper, x: number, y: number): void {
+        this._workspaces[item.getWorkspace()].itemDragged(item, x, y);
+    }
+}

src/wm/window.ts

@@ -0,0 +1,141 @@
+import Meta from 'gi://Meta';
+import Clutter from "gi://Clutter";
+import {IWindowManager} from "./windowManager.js";
+import {Logger} from "../utils/logger.js";
+import {Rect} from "../utils/rect.js";
+import WindowContainer from "./container.js";
+import queueEvent from "../utils/events.js";
+
+
+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[] = [];
+    _parent: WindowContainer | null = null;
+    _dragging: boolean = false;
+
+    constructor(
+        window: Meta.Window,
+        winMinimized: WindowMinimizedHandler
+    ) {
+        this._window = window;
+        this._windowMinimizedHandler = winMinimized;
+    }
+
+    getWindow(): Meta.Window {
+        return this._window;
+    }
+
+    getWindowId(): number {
+        return this._window.get_id();
+    }
+
+    getWorkspace(): number {
+        return this._window.get_workspace().index();
+    }
+
+    getMonitor(): number {
+        return this._window.get_monitor();
+    }
+
+    getRect(): Rect {
+        return this._window.get_frame_rect();
+    }
+
+    startDragging(): void {
+        this._dragging = true;
+    }
+
+    stopDragging(): void {
+        Logger.log("STOPPED DRAGGING")
+        this._dragging = false;
+    }
+
+    connectWindowSignals(windowManager: IWindowManager): void {
+        const windowId = this._window.get_id();
+        this._signals.push(
+            this._window.connect('unmanaging', () => {
+                Logger.log("REMOVING WINDOW", windowId);
+                windowManager.handleWindowClosed(this);
+            }),
+            this._window.connect('notify::minimized', () => {
+                if (this._window.minimized) {
+                    Logger.log(`Window minimized: ${windowId}`);
+                    windowManager.handleWindowMinimized(this);
+                } else {
+                    Logger.log(`Window unminimized: ${windowId}`);
+                    windowManager.handleWindowUnminimized(this);
+                }
+            }),
+            this._window.connect('notify::maximized-horizontally', () => {
+                if (this._window.is_maximized()) {
+                    Logger.log(`Window maximized: ${windowId}`);
+                } else {
+                    Logger.log(`Window unmaximized: ${windowId}`);
+                }
+            }),
+            this._window.connect("workspace-changed", () => {
+                Logger.log("WORKSPACE CHANGED FOR WINDOW", this._window.get_id());
+                windowManager.handleWindowChangedWorkspace(this);
+            }),
+            this._window.connect("position-changed", () => {
+                windowManager.handleWindowPositionChanged(this);
+            }),
+            this._window.connect("size-changed", () => {
+                windowManager.handleWindowPositionChanged(this);
+            }),
+        );
+    }
+
+    disconnectWindowSignals(): void {
+        if (this._signals) {
+            this._signals.forEach(signal => {
+                try {
+                    if (this._window != null) {
+                        this._window.disconnect(signal);
+                    }
+                } catch (e) {
+                    Logger.warn("error disconnecting signal", signal, e);
+                }
+            });
+        }
+    }
+
+    safelyResizeWindow(rect: Rect, _retry: number = 3): void {
+        if (this._dragging) {
+            Logger.info("STOPPED RESIZE BECAUSE ITEM IS BEING DRAGGED");
+            return;
+        }
+
+        const actor = this._window.get_compositor_private() as Clutter.Actor | null;
+        if (!actor) {
+            Logger.log("No actor available, can't resize safely yet");
+            return;
+        }
+
+        actor.remove_all_transitions();
+        this._window.move_resize_frame(true, rect.x, rect.y, rect.width, rect.height);
+
+        const new_rect = this._window.get_frame_rect();
+        const mismatch =
+            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",
+                `want(${rect.x},${rect.y},${rect.width},${rect.height})`,
+                `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),
+            }, 50);
+        }
+    }
+}

src/wm/windowManager.ts

@@ -0,0 +1,564 @@
+import Meta from "gi://Meta";
+import Gio from "gi://Gio";
+
+import {WindowWrapper} from './window.js';
+import * as Main from "resource:///org/gnome/shell/ui/main.js";
+import {Logger} from "../utils/logger.js";
+import Monitor from "./monitor.js";
+import WindowContainer from "./container.js";
+import {Rect} from "../utils/rect.js";
+
+
+export interface IWindowManager {
+    _activeWindowId: number | null;
+
+    handleWindowClosed(winWrap: WindowWrapper): void;
+
+    handleWindowMinimized(winWrap: WindowWrapper): void;
+
+    handleWindowUnminimized(winWrap: WindowWrapper): void;
+
+    handleWindowChangedWorkspace(winWrap: WindowWrapper): void;
+
+    handleWindowPositionChanged(winWrap: WindowWrapper): void;
+
+    syncActiveWindow(): number | null;
+}
+
+
+const _UNUSED_MONITOR_ID = -1;
+const _UNUSED_WINDOW_ID  = -1;
+
+export default class WindowManager implements IWindowManager {
+    _displaySignals: number[] = [];
+    _windowManagerSignals: number[] = [];
+    _workspaceManagerSignals: number[] = [];
+    _overviewSignals: number[] = [];
+
+    _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;
+    _resizeDragLastMouseX: number = 0;
+    _resizeDragLastMouseY: number = 0;
+    _isTiling: boolean = false;
+
+    private readonly _settings: Gio.Settings;
+
+    constructor(settings: Gio.Settings) {
+        this._settings = settings;
+    }
+
+    public enable(): void {
+        Logger.log("Starting Aerospike Window Manager");
+        this.instantiateDisplaySignals();
+
+        const mon_count = global.display.get_n_monitors();
+        for (let i = 0; i < mon_count; i++) {
+            this._monitors.set(i, new Monitor(i));
+        }
+
+        this.captureExistingWindows();
+        this.syncActiveWindow();
+    }
+
+    instantiateDisplaySignals(): void {
+        this._displaySignals.push(
+            global.display.connect("grab-op-begin", (display, window, op) => {
+                this.handleGrabOpBegin(display, window, op)
+            }),
+            global.display.connect("grab-op-end", (display, window, op) => {
+                this.handleGrabOpEnd(display, window, op)
+            }),
+            global.display.connect("window-entered-monitor", (display, monitor, window) => {
+                Logger.log("WINDOW HAS ENTERED NEW MONITOR!")
+                if (this._showingOverview) {
+                    if (this._getWrappedWindow(window) !== undefined) {
+                        Logger.log("OVERVIEW - MOVING")
+                        this._moveWindowToMonitor(window, monitor)
+                    }
+                }
+            }),
+            global.display.connect('window-created', (display, window) => {
+                this.handleWindowCreated(display, window);
+            }),
+            global.display.connect('notify::focus-window', () => {
+                this.syncActiveWindow();
+            }),
+            global.display.connect("showing-desktop-changed", () => {
+                Logger.log("SHOWING DESKTOP CHANGED");
+            }),
+            global.display.connect("workareas-changed", (display) => {
+                Logger.log("WORK AREAS CHANGED",);
+                console.log(display.get_workspace_manager().get_active_workspace_index())
+            }),
+            global.display.connect("in-fullscreen-changed", () => {
+                Logger.log("IN FULL SCREEN CHANGED");
+            }),
+        );
+
+        this._workspaceManagerSignals = [
+            global.workspace_manager.connect("showing-desktop-changed", () => {
+                Logger.log("SHOWING DESKTOP CHANGED AT WORKSPACE LEVEL");
+            }),
+            global.workspace_manager.connect("workspace-added", (_, wsIndex) => {
+                Logger.log("WORKSPACE ADDED", wsIndex);
+                this._monitors.forEach((monitor: Monitor) => {
+                    monitor.addWorkspace();
+                })
+            }),
+            global.workspace_manager.connect("workspace-removed", (_, wsIndex) => {
+                Logger.log("WORKSPACE REMOVED", wsIndex);
+                this._monitors.forEach((monitor: Monitor) => {
+                    monitor.removeWorkspace(wsIndex);
+                })
+            }),
+            global.workspace_manager.connect("active-workspace-changed", (source) => {
+                Logger.log("Active workspace-changed", source.get_active_workspace().index());
+            }),
+        ];
+
+        this._overviewSignals = [
+            Main.overview.connect("hiding", () => {
+                Logger.log("HIDING OVERVIEW")
+                this._showingOverview = false;
+                this._tileMonitors();
+            }),
+            Main.overview.connect("showing", () => {
+                this._showingOverview = true;
+                Logger.log("SHOWING OVERVIEW");
+            }),
+        ];
+    }
+
+    public disable(): void {
+        Logger.log("DISABLED AEROSPIKE WINDOW MANAGER!")
+        this.disconnectSignals();
+        this.removeAllWindows();
+    }
+
+    removeAllWindows(): void {
+        this.disconnectMinimizedSignals();
+        this._minimizedItems.clear();
+        this._monitors.forEach((monitor: Monitor) => {
+            monitor.removeAllWindows();
+        })
+    }
+
+    disconnectSignals(): void {
+        this.disconnectDisplaySignals();
+        this.disconnectMonitorSignals();
+        this.disconnectMinimizedSignals();
+    }
+
+    disconnectMonitorSignals(): void {
+        this._monitors.forEach((monitor: Monitor) => {
+            monitor.disconnectSignals();
+        })
+    }
+
+    disconnectDisplaySignals(): void {
+        this._displaySignals.forEach((signal) => {
+            global.display.disconnect(signal)
+        })
+        this._windowManagerSignals.forEach((signal) => {
+            global.window_manager.disconnect(signal)
+        })
+        this._workspaceManagerSignals.forEach((signal) => {
+            global.workspace_manager.disconnect(signal)
+        })
+        this._overviewSignals.forEach((signal) => {
+            Main.overview.disconnect(signal)
+        })
+    }
+
+    disconnectMinimizedSignals(): void {
+        this._minimizedItems.forEach((item) => {
+            item.disconnectWindowSignals();
+        })
+    }
+
+    _isResizeOp(op: Meta.GrabOp): boolean {
+        return op === Meta.GrabOp.RESIZING_E  ||
+               op === Meta.GrabOp.RESIZING_W  ||
+               op === Meta.GrabOp.RESIZING_N  ||
+               op === Meta.GrabOp.RESIZING_S  ||
+               op === Meta.GrabOp.RESIZING_NE ||
+               op === Meta.GrabOp.RESIZING_NW ||
+               op === Meta.GrabOp.RESIZING_SE ||
+               op === Meta.GrabOp.RESIZING_SW;
+    }
+
+    handleGrabOpBegin(display: Meta.Display, window: Meta.Window, op: Meta.GrabOp): void {
+        Logger.log("Grab Op Start", op);
+
+        if (this._isResizeOp(op)) {
+            Logger.log("Resize drag begin, op=", op);
+            this._isResizeDrag = true;
+            this._resizeDragWindowId = window.get_id();
+            this._resizeDragOp = op;
+            const [startMouseX, startMouseY] = global.get_pointer();
+            this._resizeDragLastMouseX = startMouseX;
+            this._resizeDragLastMouseY = startMouseY;
+            this._getWrappedWindow(window)?.startDragging();
+        } else {
+            this._getWrappedWindow(window)?.startDragging();
+            this._grabbedWindowMonitor = window.get_monitor();
+            this._grabbedWindowId = window.get_id();
+        }
+    }
+
+    handleGrabOpEnd(display: Meta.Display, window: Meta.Window, op: Meta.GrabOp): void {
+        Logger.log("Grab Op End ", op);
+
+        if (this._isResizeDrag) {
+            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;
+            this._getWrappedWindow(window)?.stopDragging();
+            this._tileMonitors();
+        } else {
+            this._grabbedWindowId = _UNUSED_WINDOW_ID;
+            this._getWrappedWindow(window)?.stopDragging();
+            this._tileMonitors();
+            Logger.info("monitor_start and monitor_end", this._grabbedWindowMonitor, window.get_monitor());
+        }
+    }
+
+    _getWrappedWindow(window: Meta.Window): WindowWrapper | undefined {
+        let wrapped: WindowWrapper | undefined = undefined;
+        for (const monitor of this._monitors.values()) {
+            wrapped = monitor.getWindow(window.get_id());
+            if (wrapped !== undefined) break;
+        }
+        return wrapped;
+    }
+
+    _getAndRemoveWrappedWindow(window: Meta.Window): WindowWrapper | undefined {
+        let wrapped: WindowWrapper | undefined = undefined;
+        for (const monitor of this._monitors.values()) {
+            wrapped = monitor.getWindow(window.get_id());
+            if (wrapped !== undefined) {
+                monitor.removeWindow(wrapped);
+                break;
+            }
+        }
+        return wrapped;
+    }
+
+    _moveWindowToMonitor(window: Meta.Window, monitorId: number): void {
+        let wrapped = this._getAndRemoveWrappedWindow(window);
+        if (wrapped === undefined) {
+            Logger.error("WINDOW NOT DEFINED")
+            wrapped = new WindowWrapper(window, (winWrap) => this.handleWindowMinimized(winWrap));
+            wrapped.connectWindowSignals(this);
+        }
+        let new_mon = this._monitors.get(monitorId);
+        new_mon?.addWindow(wrapped)
+        this._grabbedWindowMonitor = monitorId;
+    }
+
+    public handleWindowPositionChanged(winWrap: WindowWrapper): void {
+        if (this._isTiling || this._changingGrabbedMonitor) return;
+
+        if (this._isResizeDrag && winWrap.getWindowId() === this._resizeDragWindowId) {
+            this._handleResizeDragUpdate(winWrap);
+            return;
+        }
+
+        if (winWrap.getWindowId() === this._grabbedWindowId) {
+            const [mouseX, mouseY, _] = global.get_pointer();
+
+            let monitorIndex = -1;
+            for (let i = 0; i < global.display.get_n_monitors(); i++) {
+                const workArea = global.workspace_manager.get_active_workspace().get_work_area_for_monitor(i);
+                if (mouseX >= workArea.x && mouseX < workArea.x + workArea.width &&
+                    mouseY >= workArea.y && mouseY < workArea.y + workArea.height) {
+                    monitorIndex = i;
+                    break;
+                }
+            }
+            if (monitorIndex === -1) return;
+
+            if (monitorIndex !== this._grabbedWindowMonitor) {
+                this._changingGrabbedMonitor = true;
+                this._moveWindowToMonitor(winWrap.getWindow(), monitorIndex);
+                this._changingGrabbedMonitor = false;
+            }
+
+            this._isTiling = true;
+            try {
+                this._monitors.get(monitorIndex)?.itemDragged(winWrap, mouseX, mouseY);
+            } finally {
+                this._isTiling = false;
+            }
+        }
+    }
+
+    private _handleResizeDragUpdate(winWrap: WindowWrapper): void {
+        const op    = this._resizeDragOp;
+        const winId = winWrap.getWindowId();
+
+        const [mouseX, mouseY] = global.get_pointer();
+        const dx = mouseX - this._resizeDragLastMouseX;
+        const dy = mouseY - this._resizeDragLastMouseY;
+
+        if (dx === 0 && dy === 0) return;
+
+        this._resizeDragLastMouseX = mouseX;
+        this._resizeDragLastMouseY = mouseY;
+
+        const container = this._findContainerForWindowAcrossMonitors(winId);
+        if (!container) {
+            Logger.warn("_handleResizeDragUpdate: no container found for window", winId);
+            return;
+        }
+
+        const itemIndex = container._getIndexOfWindow(winId);
+        if (itemIndex === -1) return;
+
+        const isHorizontal = container._orientation === 0;
+
+        // 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) {
+                adjusted = container.adjustBoundary(itemIndex, dx);
+            } else if (op === Meta.GrabOp.RESIZING_W || op === Meta.GrabOp.RESIZING_NW || op === Meta.GrabOp.RESIZING_SW) {
+                adjusted = container.adjustBoundary(itemIndex - 1, dx);
+            }
+        } else {
+            if (op === Meta.GrabOp.RESIZING_S || op === Meta.GrabOp.RESIZING_SE || op === Meta.GrabOp.RESIZING_SW) {
+                adjusted = container.adjustBoundary(itemIndex, dy);
+            } else if (op === Meta.GrabOp.RESIZING_N || op === Meta.GrabOp.RESIZING_NE || op === Meta.GrabOp.RESIZING_NW) {
+                adjusted = container.adjustBoundary(itemIndex - 1, dy);
+            }
+        }
+
+        if (adjusted) {
+            this._isTiling = true;
+            try {
+                container.tileWindows();
+            } finally {
+                this._isTiling = false;
+            }
+        }
+    }
+
+    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 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);
+        this._monitors.get(monitor_id)?.removeWindow(winWrap);
+        this._tileMonitors()
+    }
+
+    public handleWindowUnminimized(winWrap: WindowWrapper): void {
+        this._minimizedItems.delete(winWrap.getWindowId());
+        this._addWindowWrapperToMonitor(winWrap);
+        this._tileMonitors()
+    }
+
+    public handleWindowChangedWorkspace(winWrap: WindowWrapper): void {
+        const monitor = winWrap.getWindow().get_monitor();
+        this._monitors.get(monitor)?.removeWindow(winWrap);
+        this._monitors.get(monitor)?.addWindow(winWrap);
+    }
+
+    public captureExistingWindows() {
+        const workspace = global.workspace_manager.get_active_workspace();
+        const windows = global.display.get_tab_list(Meta.TabList.NORMAL, workspace);
+        windows.forEach(window => {
+            if (this._isWindowTileable(window)) {
+                this.addWindowToMonitor(window);
+            }
+        });
+
+        this._tileMonitors();
+    }
+
+    handleWindowCreated(display: Meta.Display, window: Meta.Window) {
+        Logger.log("WINDOW CREATED ON DISPLAY", window, display);
+        if (!this._isWindowTileable(window)) return;
+        Logger.log("WINDOW IS TILABLE");
+        this.addWindowToMonitor(window);
+    }
+
+    handleWindowClosed(window: WindowWrapper): void {
+        const mon_id = window._window.get_monitor();
+        this._monitors.get(mon_id)?.removeWindow(window);
+        window.disconnectWindowSignals()
+        this.syncActiveWindow();
+        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) {
+        if (winWrap.getWindow().minimized) {
+            this._minimizedItems.set(winWrap.getWindow().get_id(), winWrap);
+        } else {
+            this._monitors.get(winWrap.getWindow().get_monitor())?.addWindow(winWrap)
+        }
+    }
+
+    _tileMonitors(): void {
+        this._isTiling = true;
+        try {
+            for (const monitor of this._monitors.values()) {
+                monitor.tileWindows();
+            }
+        } finally {
+            this._isTiling = false;
+        }
+    }
+
+    block_titles = [
+        "org.gnome.Shell.Extensions",
+    ]
+
+    _isWindowTilingBlocked(window: Meta.Window): boolean {
+        Logger.info("title", window.get_title());
+        Logger.info("description", window.get_description());
+        Logger.info("class", window.get_wm_class());
+        Logger.info("class", window.get_wm_class_instance());
+        return this.block_titles.some((title) => {
+            if (window.get_wm_class() === title) {
+                Logger.log("WINDOW BLOCKED FROM TILING", window.get_title());
+                return true;
+            }
+            return false;
+        });
+    }
+
+    _isWindowTileable(window: Meta.Window) {
+        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",);
+
+        return !window.is_skip_taskbar() &&
+            windowType !== Meta.WindowType.DESKTOP &&
+            windowType !== Meta.WindowType.DOCK &&
+            windowType !== Meta.WindowType.DIALOG &&
+            windowType !== Meta.WindowType.MODAL_DIALOG &&
+            windowType !== Meta.WindowType.UTILITY &&
+            windowType !== Meta.WindowType.MENU;
+    }
+
+    public syncActiveWindow(): number | null {
+        const focusWindow = global.display.focus_window;
+        if (focusWindow) {
+            this._activeWindowId = focusWindow.get_id();
+            Logger.debug(`Active window changed to: ${this._activeWindowId} (${focusWindow.get_title()})`);
+        } else {
+            this._activeWindowId = null;
+            Logger.debug('No active window');
+        }
+        return this._activeWindowId;
+    }
+
+    public toggleActiveContainerOrientation(): void {
+        if (this._activeWindowId === null) {
+            Logger.warn("No active window, cannot toggle container orientation");
+            return;
+        }
+        const container = this._findContainerForWindowAcrossMonitors(this._activeWindowId);
+        if (container) {
+            container.toggleOrientation();
+        } else {
+            Logger.warn("Could not find container for active window");
+        }
+    }
+
+    public resetActiveContainerRatios(): void {
+        if (this._activeWindowId === null) {
+            Logger.warn("No active window, cannot reset container ratios");
+            return;
+        }
+        const container = this._findContainerForWindowAcrossMonitors(this._activeWindowId);
+        if (container) {
+            Logger.info("Resetting container ratios to equal splits");
+            container.resetRatios();
+        } else {
+            Logger.warn("Could not find container for active window");
+        }
+    }
+
+    public printTreeStructure(): void {
+        Logger.info("=".repeat(80));
+        Logger.info("WINDOW TREE STRUCTURE");
+        Logger.info("=".repeat(80));
+        Logger.info(`Active Window ID: ${this._activeWindowId ?? 'none'}`);
+        Logger.info("=".repeat(80));
+
+        const activeWorkspaceIndex = global.workspace_manager.get_active_workspace().index();
+
+        this._monitors.forEach((monitor: Monitor, monitorId: number) => {
+            const isActiveMonitor = this._activeWindowId !== null &&
+                                   monitor.getWindow(this._activeWindowId) !== undefined;
+
+            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;
+                Logger.info(`  Workspace ${workspaceIndex}${isActiveWorkspace && isActiveMonitor ? ' *' : ''}:`);
+                Logger.info(`    Orientation: ${workspace._orientation === 0 ? 'HORIZONTAL' : 'VERTICAL'}`);
+                Logger.info(`    Items: ${workspace._tiledItems.length}`);
+                this._printContainerTree(workspace, 4);
+            });
+        });
+
+        Logger.info("=".repeat(80));
+    }
+
+    private _printContainerTree(container: WindowContainer, indentLevel: number): void {
+        const indent = " ".repeat(indentLevel);
+
+        container._tiledItems.forEach((item, index) => {
+            if (item instanceof WindowContainer) {
+                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();
+                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();
+                Logger.info(`${indent}    Rect: x=${rect.x}, y=${rect.y}, w=${rect.width}, h=${rect.height}`);
+            }
+        });
+    }
+}

tsconfig.json

@@ -5,6 +5,8 @@
     "outDir": "./dist",
     "sourceMap": false,
     "strict": true,
+    "noImplicitAny": false,
+    "skipLibCheck": true,
     "target": "ES2022",
     "lib": [
       "ES2022"
@@ -16,7 +18,6 @@
     "src/**/*"
   ],
   "files": [
-    "extension.ts",
-    "winGroup.ts"
+    "extension.ts"
   ],
 }