feat: resize bug fixing

.gitignore

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

.nvmrc

@@ -0,0 +1 @@
+v20

Makefile

@@ -1,36 +0,0 @@
-NAME=aerospike
-DOMAIN=lucaso.io
-
-.PHONY: all pack install clean
-
-all: dist/extension.js
-
-node_modules: package.json
-	pnpm install
-
-dist/extension.js : node_modules
-	tsc
-
-schemas/gschemas.compiled: schemas/org.gnome.shell.extensions.$(NAME).gschema.xml
-	glib-compile-schemas schemas
-
-$(NAME).zip: dist/extension.js dist/prefs.js schemas/gschemas.compiled
-	@rm -rf dist/*
-	@cp metadata.json dist/
-	@cp stylesheet.css dist/
-	@mkdir dist/schemas
-	@cp schemas/*.compiled dist/schemas/
-	@(cd dist && zip ../$(NAME).zip -9r .)
-
-pack: $(NAME).zip
-
-install: $(NAME).zip
-
-clean:
-	@rm -rf dist node_modules $(NAME).zip
-
-test:
-	@dbus-run-session -- gnome-shell --nested --wayland
-
-.PHONY: install-and-test
-install-and-test: install test

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,319 +1,153 @@
-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 * as Main from 'resource:///org/gnome/shell/ui/main.js';
-// import Gio from 'gi://Gio';
+import Gio from 'gi://Gio';
-// import cairo from "cairo";
+import Shell from 'gi://Shell';
-// import Shell from 'gi://Shell';
+import WindowManager from './src/wm/windowManager.js'
-// import * as Main from 'resource:///org/gnome/shell/ui/main.js';
+import {Logger} from "./src/utils/logger.js";
-
-type WinWrapper = {
-    window: Meta.Window | null;
-    signals: Signal[] | null;
-}
-
-type Signal = {
-    name: string;
-    id: number;
-}
 
 export default class aerospike extends Extension {
-
+    settings: Gio.Settings;
-    borderActor: St.Widget | null;
+    keyBindings: Map<string, number>;
-    focusWindowSignals: any[];
+    windowManager: WindowManager;
-    lastFocusedWindow: Meta.Window | null;
-    _focusSignal: number | null;
-    _windowCreateId: number | null;
-    _windows: Map<number, WinWrapper>;
-    _activeWindowId: number | null;
 
     constructor(metadata: ExtensionMetadata) {
         super(metadata);
-        // Initialize instance variables
+        this.settings = this.getSettings('org.gnome.shell.extensions.aerospike');
-        this.borderActor = null;
+        this.keyBindings = new Map();
-        this.focusWindowSignals = [];
+        this.windowManager = new WindowManager();
-        this.lastFocusedWindow = null;
-        this._focusSignal = null;
-        this._windowCreateId = null;
-        this._windows = new Map<number, WinWrapper>();
-        this._activeWindowId = null;
-
     }
 
     enable() {
-        console.log("STARTING AEROSPIKE!")
+        Logger.log("STARTING AEROSPIKE!")
-
+        this.bindSettings();
-        // this._captureExistingWindows();
+        this.setupKeybindings();
-        // Connect window signals
+        this.windowManager.enable()
-        this._windowCreateId = global.display.connect(
-            'window-created',
-            (display, window) => {
-                this.handleWindowCreated(window);
     }
-        );
-    }
-
-    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
-        };
-    }
-
-    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);
-        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) {
-
-        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.resizeWindow(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!")
+        this.windowManager.disable()
-        // Disconnect the focus signal and remove any existing borders
+        this.removeKeybindings()
-        if (this._focusSignal) {
-            global.display.disconnect(this._focusSignal);
-            this._focusSignal = null;
     }
 
-        // Clear the border on the last focused window if it exists
+
-        // this._clearBorder();
+    private bindSettings() {
-        this.lastFocusedWindow = null;
+        // 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::reset-window-sizes', () => {
+            log(`Reset window sizes keybinding changed to: ${this.settings.get_strv('reset-window-sizes')}`);
+            this.refreshKeybinding('reset-window-sizes');
+        });
+
+        this.settings.connect('changed::dropdown-option', () => {
+            log(`Dropdown option changed to: ${this.settings.get_string('dropdown-option')}`);
+        });
+
+        this.settings.connect('changed::color-selection', () => {
+            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 'reset-window-sizes':
+                this.bindKeybinding('reset-window-sizes', () => {
+                    this.windowManager.resetAllWindowSizes();
+                });
+                break;
+        }
+    }
+
+    private removeKeybindings() {
+        this.keyBindings.forEach((_, key) => {
+            Main.wm.removeKeybinding(key);
+        });
+        this.keyBindings.clear();
+    }
+
+    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('reset-window-sizes', () => {
+            this.windowManager.resetAllWindowSizes();
+        });
+    }
+
+    private bindKeybinding(settingName: string, callback: () => void) {
+        const keyBindingSettings = this.settings.get_strv(settingName);
+
+        if (keyBindingSettings.length === 0 || keyBindingSettings[0] === '') {
+            return;
+        }
+
+        const keyBindingAction = Main.wm.addKeybinding(
+            settingName,
+            this.settings,
+            Meta.KeyBindingFlags.NONE,
+            Shell.ActionMode.NORMAL,
+            callback
+        );
+
+        this.keyBindings.set(settingName, keyBindingAction);
+    }
+
 
 
 }

justfile

@@ -1,19 +1,22 @@
 set dotenv-load
 NAME:="aerospike"
 DOMAIN:="lucaso.io"
+FULL_NAME:=NAME + "@" + DOMAIN
 
 packages:
 	pnpm install
 
-build: packages
+build: packages && build-schemas
     rm -rf dist/*
     tsc
-    glib-compile-schemas schemas
     cp metadata.json dist/
     cp stylesheet.css dist/
-    mkdir dist/schemas
+    mkdir -p dist/schemas
-    cp schemas/*.compiled dist/schemas/
 
+build-schemas:
+    glib-compile-schemas schemas
+    cp schemas/org.gnome.shell.extensions.aerospike.gschema.xml dist/schemas/
+    cp schemas/gschemas.compiled dist/schemas/
 
 build-package: build
 	cd dist && zip ../{{NAME}}.zip -9r .
@@ -21,10 +24,22 @@ 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:
-    dbus-run-session -- gnome-shell --nested --wayland
+    env MUTTER_DEBUG_DUMMY_MODE_SPECS=1280x720 dbus-run-session -- gnome-shell --devkit
 
 install-and-run: install run
+
+live-debug:
+    journalctl /usr/bin/gnome-shell -f -o cat | tee debug.log
+
+#pack: build
+#    gnome-extensions pack dist \
+#        --force \
+#        --out-dir . \
+#        --schema ../schemas/org.gnome.shell.extensions.aerospike.gschema.xml
+#
+#install-pack: pack
+#    gnome-extensions install ./{{FULL_NAME}}.shell-extension.zip --force

metadata.json

@@ -1,9 +1,12 @@
 {
   "name": "aerospike",
-  "description": "Adds pretty rainbow or static borders to the active and inactive windows",
+  "description": "I3 Like Tiling Window Manager for Gnome",
   "uuid": "aerospike@lucaso.io",
+  "settings-schema": "org.gnome.shell.extensions.aerospike",
   "shell-version": [
-    "47",
+    "48",
-    "48"
+    "49"
-  ]
+  ],
+  "gettext-domain": "aerospike@lucaso.io",
+  "url": "https://gitea.chaosdev.gay/lucasoskorep/aerospike@lucaso.io"
 }

package.json

@@ -16,13 +16,33 @@
   "homepage": "https://github.com/example/my-extension#readme",
   "sideEffects": false,
   "devDependencies": {
-    "@girs/gjs": "^4.0.0-beta.23",
+    "@girs/gjs": "4.0.0-beta.38",
-    "@girs/gnome-shell": "^48.0.1",
+    "@girs/gnome-shell": "49.0.1",
-    "eslint": "^9.23.0",
+    "eslint": "^9.36.0",
-    "eslint-plugin-jsdoc": "^50.6.9",
+    "eslint-plugin-jsdoc": "^50.8.0",
-    "typescript": "^5.8.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,52 +1,4 @@
-import Gtk from 'gi://Gtk';
+// This file is just a wrapper around the compiled TypeScript code
-import Adw from 'gi://Adw';
+import AerospikeExtensions from './src/prefs/prefs.js';
-import Gio from 'gi://Gio';
-import { ExtensionPreferences, gettext as _ } from 'resource:///org/gnome/Shell/Extensions/js/extensions/prefs.js';
 
-export default class GnomeRectanglePreferences extends ExtensionPreferences {
+export default AerospikeExtensions;
-    _settings?: Gio.Settings
-
-    fillPreferencesWindow(window: Adw.PreferencesWindow): Promise<void> {
-        this._settings = this.getSettings();
-
-        const page = new Adw.PreferencesPage({
-            title: _('General'),
-            iconName: 'dialog-information-symbolic',
-        });
-
-        const animationGroup = new Adw.PreferencesGroup({
-            title: _('Animation'),
-            description: _('Configure move/resize animation'),
-        });
-        page.add(animationGroup);
-
-        const animationEnabled = new Adw.SwitchRow({
-            title: _('Enabled'),
-            subtitle: _('Wether to animate windows'),
-        });
-        animationGroup.add(animationEnabled);
-
-        const paddingGroup = new Adw.PreferencesGroup({
-            title: _('Paddings'),
-            description: _('Configure the padding between windows'),
-        });
-        page.add(paddingGroup);
-
-        const paddingInner = new Adw.SpinRow({
-            title: _('Inner'),
-            subtitle: _('Padding between windows'),
-            adjustment: new Gtk.Adjustment({
-                lower: 0,
-                upper: 1000,
-                stepIncrement: 1
-            })
-        });
-        paddingGroup.add(paddingInner);
-
-        window.add(page)
-
-        this._settings!.bind('animate', animationEnabled, 'active', Gio.SettingsBindFlags.DEFAULT);
-        this._settings!.bind('padding-inner', paddingInner, 'value', Gio.SettingsBindFlags.DEFAULT);
-        return Promise.resolve();
-    }
-}

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

@@ -1,10 +1,47 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <schemalist>
     <schema id="org.gnome.shell.extensions.aerospike" path="/org/gnome/shell/extensions/aerospike/">
-        <key name="tiling-type" type="s">
+        <key name="dropdown-option" type="s">
-            <default>"Horizontal"</default>
+            <default>'option1'</default>
-            <summary>Type of tiling</summary>
+            <summary>Dropdown selection</summary>
-            <description>The type of tiling provided by aerospace</description>
+            <description>Option selected from the dropdown menu</description>
         </key>
+
+        <key name="color-selection" type="s">
+            <default>'rgb(255,0,0)'</default>
+            <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="reset-window-sizes" type="as">
+            <default><![CDATA[['<Alt>z']]]></default>
+            <summary>Reset all window sizes</summary>
+            <description>Remove all custom window sizes and return to equal distribution</description>
+        </key>
+
     </schema>
 </schemalist>

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

@@ -0,0 +1,186 @@
+import Adw from 'gi://Adw';
+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 AerospikeExtensions extends ExtensionPreferences {
+    async fillPreferencesWindow(window: Adw.PreferencesWindow) {
+        // Create settings object
+        const settings = this.getSettings('org.gnome.shell.extensions.aerospike');
+
+        // Create a preferences page
+        const page = new Adw.PreferencesPage({
+            title: _('Settings'),
+            icon_name: 'preferences-system-symbolic',
+        });
+        window.add(page);
+
+
+        // Create options group
+        const optionsGroup = new Adw.PreferencesGroup({
+            title: _('Options'),
+        });
+        page.add(optionsGroup);
+
+        // Add dropdown
+        const dropdownRow = new Adw.ComboRow({
+            title: _('Select an option'),
+        });
+        optionsGroup.add(dropdownRow);
+
+        // Create dropdown model
+        const dropdownModel = new Gtk.StringList();
+        dropdownModel.append(_('Option 1'));
+        dropdownModel.append(_('Option 2'));
+        dropdownModel.append(_('Option 3'));
+        dropdownModel.append(_('Option 4'));
+
+        dropdownRow.set_model(dropdownModel);
+
+        // Set the active option based on settings
+        const currentOption = settings.get_string('dropdown-option');
+        switch (currentOption) {
+            case 'option1':
+                dropdownRow.set_selected(0);
+                break;
+            case 'option2':
+                dropdownRow.set_selected(1);
+                break;
+            case 'option3':
+                dropdownRow.set_selected(2);
+                break;
+            case 'option4':
+                dropdownRow.set_selected(3);
+                break;
+            default:
+                dropdownRow.set_selected(0);
+        }
+
+        // Connect dropdown change signal
+        dropdownRow.connect('notify::selected', () => {
+            const selected = dropdownRow.get_selected();
+            let optionValue: string;
+
+            switch (selected) {
+                case 0:
+                    optionValue = 'option1';
+                    break;
+                case 1:
+                    optionValue = 'option2';
+                    break;
+                case 2:
+                    optionValue = 'option3';
+                    break;
+                case 3:
+                    optionValue = 'option4';
+                    break;
+                default:
+                    optionValue = 'option1';
+            }
+
+            settings.set_string('dropdown-option', optionValue);
+        });
+
+        // Add color button
+        const colorRow = new Adw.ActionRow({
+            title: _('Choose a color'),
+        });
+        optionsGroup.add(colorRow);
+
+        const colorButton = new Gtk.ColorButton();
+        colorRow.add_suffix(colorButton);
+        colorRow.set_activatable_widget(colorButton);
+
+        // Set current color from settings
+        const colorStr = settings.get_string('color-selection');
+        const rgba = new Gdk.RGBA();
+        rgba.parse(colorStr);
+        colorButton.set_rgba(rgba);
+
+        // Connect color button signal
+        colorButton.connect('color-set', () => {
+            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
+            })
+        );
+
+
+    }
+
+    // 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, []);
+                }
+            },
+        };
+    }
+}

src/utils/events.ts

@@ -0,0 +1,20 @@
+import GLib from "gi://GLib";
+
+
+export type QueuedEvent = {
+    name: string;
+    callback: () => void;
+}
+
+const queuedEvents: QueuedEvent[] = [];
+
+export default function queueEvent(event: QueuedEvent, interval = 200) {
+    queuedEvents.push(event);
+    GLib.timeout_add(GLib.PRIORITY_DEFAULT, interval, () => {
+        const e = queuedEvents.pop()
+        if (e) {
+            e.callback();
+        }
+        return queuedEvents.length !== 0;
+    });
+}

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,484 @@
+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";
+
+enum Orientation {
+    HORIZONTAL = 0,
+    VERTICAL = 1,
+}
+
+
+export default class WindowContainer {
+
+    _tiledItems: (WindowWrapper | WindowContainer)[];
+    _tiledWindowLookup: Map<number, WindowWrapper>;
+    _orientation: Orientation = Orientation.HORIZONTAL;
+    _workArea: Rect;
+    _customSizes: Map<number, number>;  // Maps index to custom width (horizontal) or height (vertical)
+
+    constructor(workspaceArea: Rect,) {
+        this._tiledItems = [];
+        this._tiledWindowLookup = new Map<number, WindowWrapper>();
+        this._workArea = workspaceArea;
+        this._customSizes = new Map<number, number>();
+    }
+
+
+    move(rect: Rect): void {
+        this._workArea = rect;
+        this.tileWindows();
+    }
+
+    addWindow(winWrap: WindowWrapper): void {
+        // Add window to managed windows
+        this._tiledItems.push(winWrap);
+        this._tiledWindowLookup.set(winWrap.getWindowId(), winWrap);
+        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) {
+        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)) {
+            this._tiledWindowLookup.delete(win_id);
+            const index = this._getIndexOfWindow(win_id)
+            this._tiledItems.splice(index, 1);
+            // Shift custom sizes after removed index
+            this._shiftCustomSizesAfterRemoval(index);
+        } else {
+            for (const item of this._tiledItems) {
+                if (item instanceof WindowContainer) {
+                    item.removeWindow(win_id);
+                }
+            }
+        }
+        this.tileWindows()
+    }
+
+    _shiftCustomSizesAfterRemoval(removedIndex: number): void {
+        Logger.log(`=== _shiftCustomSizesAfterRemoval called ===`);
+        Logger.log(`Removed index: ${removedIndex}`);
+        Logger.log(`Total items after removal: ${this._tiledItems.length}`);
+        Logger.log(`Custom sizes Map size: ${this._customSizes.size}`);
+
+        // Convert Map to readable string
+        let customSizesStr = "{ ";
+        this._customSizes.forEach((size, index) => {
+            customSizesStr += `${index}: ${size}px, `;
+        });
+        customSizesStr += "}";
+        Logger.log(`Custom sizes before shift: ${customSizesStr}`);
+
+        // Calculate the removed window's size (could be custom or flexible)
+        let removedSize = this._customSizes.get(removedIndex);
+
+        if (removedSize === undefined) {
+            // Window didn't have custom size, calculate its flexible size
+            // Count items BEFORE removal (add 1 to current length)
+            const numItemsBeforeRemoval = this._tiledItems.length + 1;
+            let totalCustomSize = 0;
+            let numFlexibleItemsBeforeRemoval = 0;
+
+            this._customSizes.forEach((size, index) => {
+                totalCustomSize += size;
+                // Don't count this in flexible if it's the removed index
+            });
+            numFlexibleItemsBeforeRemoval = numItemsBeforeRemoval - this._customSizes.size;
+
+            const containerSize = this._orientation === Orientation.HORIZONTAL ? this._workArea.width : this._workArea.height;
+            const remainingSize = containerSize - totalCustomSize;
+            removedSize = numFlexibleItemsBeforeRemoval > 0 ? Math.floor(remainingSize / numFlexibleItemsBeforeRemoval) : 0;
+
+            Logger.log(`Removed window was flexible, calculated size: ${removedSize}px (${numFlexibleItemsBeforeRemoval} flexible windows before removal)`);
+        } else {
+            Logger.log(`Removed window had custom size: ${removedSize}px`);
+        }
+
+        // Rebuild the custom sizes map with shifted indices
+        const newCustomSizes = new Map<number, number>();
+        this._customSizes.forEach((size, index) => {
+            if (index < removedIndex) {
+                // Keep indices before removal
+                Logger.log(`Keeping index ${index} with size ${size}`);
+                newCustomSizes.set(index, size);
+            } else if (index > removedIndex) {
+                // Shift down indices after removal
+                Logger.log(`Shifting index ${index} -> ${index - 1} with size ${size}`);
+                newCustomSizes.set(index - 1, size);
+            }
+            // Skip the removed index
+        });
+
+        Logger.log(`New custom sizes Map size after shift: ${newCustomSizes.size}`);
+        let afterShiftStr = "{ ";
+        newCustomSizes.forEach((size, index) => {
+            afterShiftStr += `${index}: ${size}px, `;
+        });
+        afterShiftStr += "}";
+        Logger.log(`Custom sizes after index shift: ${afterShiftStr}`);
+
+        // Distribute removed window's size among remaining custom-sized windows only
+        // Flexible windows will naturally absorb their share through the bounds calculation
+        const remainingWindowCount = this._tiledItems.length;
+        const numCustomWindows = newCustomSizes.size;
+
+        if (removedSize > 0 && remainingWindowCount > 0 && numCustomWindows > 0) {
+            const sizePerCustomWindow = Math.floor(removedSize / numCustomWindows);
+
+            Logger.log(`Distributing ${removedSize}px among ${numCustomWindows} custom-sized windows (${sizePerCustomWindow}px each)`);
+            Logger.log(`Flexible windows will naturally absorb remaining space`);
+
+            // Add proportional size only to windows that already have custom sizes
+            newCustomSizes.forEach((size, index) => {
+                const newSize = size + sizePerCustomWindow;
+                Logger.log(`Index ${index}: ${size}px + ${sizePerCustomWindow}px = ${newSize}px`);
+                newCustomSizes.set(index, newSize);
+            });
+        } else {
+            Logger.log(`Not distributing space - removedSize: ${removedSize}, remainingWindows: ${remainingWindowCount}, customWindows: ${numCustomWindows}`);
+        }
+
+        let finalStr = "{ ";
+        newCustomSizes.forEach((size, index) => {
+            finalStr += `${index}: ${size}px, `;
+        });
+        finalStr += "}";
+        Logger.log(`Final custom sizes: ${finalStr}`);
+
+        this._customSizes = newCustomSizes;
+        Logger.log(`=== _shiftCustomSizesAfterRemoval complete ===`);
+    }
+
+    disconnectSignals(): void {
+        this._tiledItems.forEach((item) => {
+                if (item instanceof WindowContainer) {
+                    item.disconnectSignals()
+                } else {
+                    item.disconnectWindowSignals();
+                }
+            }
+        )
+    }
+
+    removeAllWindows(): void {
+        this._tiledItems = []
+        this._tiledWindowLookup.clear()
+    }
+
+    tileWindows(skipRetry: boolean = false) {
+        Logger.log("TILING WINDOWS IN CONTAINER")
+        Logger.log("WorkArea", this._workArea);
+        this._tileItems(skipRetry)
+
+        return true
+    }
+
+    _tileItems(skipRetry: boolean = false) {
+        if (this._tiledItems.length === 0) {
+            return;
+        }
+        const bounds = this.getBounds();
+        this._tiledItems.forEach((item, index) => {
+            const rect = bounds[index];
+            if (item instanceof WindowContainer) {
+                item.move(rect);
+            } else {
+                item.safelyResizeWindow(rect, 2, skipRetry);
+            }
+        })
+    }
+
+
+    getBounds(): Rect[] {
+        if (this._orientation === Orientation.HORIZONTAL) {
+            return this.getHorizontalBounds();
+        }
+        return this.getVerticalBounds();
+    }
+
+    getVerticalBounds(): Rect[] {
+        // Calculate available height after accounting for custom-sized windows
+        let totalCustomHeight = 0;
+        let numFlexibleItems = 0;
+
+        this._tiledItems.forEach((item, index) => {
+            if (this._customSizes.has(index)) {
+                totalCustomHeight += this._customSizes.get(index)!;
+            } else {
+                numFlexibleItems++;
+            }
+        });
+
+        // Ensure custom sizes don't exceed container height
+        if (totalCustomHeight > this._workArea.height) {
+            Logger.warn("Custom heights exceed container, resetting all sizes");
+            this._customSizes.clear();
+            totalCustomHeight = 0;
+            numFlexibleItems = this._tiledItems.length;
+        }
+
+        const remainingHeight = this._workArea.height - totalCustomHeight;
+        const flexHeight = numFlexibleItems > 0 ? Math.floor(remainingHeight / numFlexibleItems) : 0;
+
+        // Build the bounds array
+        let currentY = this._workArea.y;
+        return this._tiledItems.map((item, index) => {
+            let height = flexHeight;
+            if (this._customSizes.has(index)) {
+                height = this._customSizes.get(index)!;
+            }
+
+            const rect = {
+                x: this._workArea.x,
+                y: currentY,
+                width: this._workArea.width,
+                height: height
+            } as Rect;
+            currentY += height;
+            return rect;
+        });
+    }
+
+    getHorizontalBounds(): Rect[] {
+        // Calculate available width after accounting for custom-sized windows
+        let totalCustomWidth = 0;
+        let numFlexibleItems = 0;
+
+        this._tiledItems.forEach((item, index) => {
+            if (this._customSizes.has(index)) {
+                totalCustomWidth += this._customSizes.get(index)!;
+            } else {
+                numFlexibleItems++;
+            }
+        });
+
+        // Ensure custom sizes don't exceed container width
+        if (totalCustomWidth > this._workArea.width) {
+            Logger.warn("Custom widths exceed container, resetting all sizes");
+            this._customSizes.clear();
+            totalCustomWidth = 0;
+            numFlexibleItems = this._tiledItems.length;
+        }
+
+        const remainingWidth = this._workArea.width - totalCustomWidth;
+        const flexWidth = numFlexibleItems > 0 ? Math.floor(remainingWidth / numFlexibleItems) : 0;
+
+        // Build the bounds array
+        let currentX = this._workArea.x;
+        return this._tiledItems.map((item, index) => {
+            let width = flexWidth;
+            if (this._customSizes.has(index)) {
+                width = this._customSizes.get(index)!;
+            }
+
+            const rect = {
+                x: currentX,
+                y: this._workArea.y,
+                width: width,
+                height: this._workArea.height
+            } as Rect;
+            currentX += width;
+            return rect;
+        });
+    }
+
+    getIndexOfItemNested(item: WindowWrapper): number {
+        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;
+                }
+            } 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 {
+        let 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) {
+            this._tiledItems.splice(original_index, 1);
+            this._tiledItems.splice(new_index, 0, item);
+            this.tileWindows()
+        }
+
+    }
+
+    windowManuallyResized(win_id: number): void {
+        const window = this.getWindow(win_id);
+        if (!window) {
+            // Check nested containers
+            for (const item of this._tiledItems) {
+                if (item instanceof WindowContainer) {
+                    item.windowManuallyResized(win_id);
+                }
+            }
+            return;
+        }
+
+        // Find the index of the window
+        const index = this._getIndexOfWindow(win_id);
+        if (index === -1) {
+            Logger.error("Window not found in container during resize");
+            return;
+        }
+
+        const rect = window.getRect();
+        if (this._orientation === Orientation.HORIZONTAL) {
+            this._customSizes.set(index, rect.width);
+            Logger.log(`Window at index ${index} manually resized to width: ${rect.width}`);
+        } else {
+            this._customSizes.set(index, rect.height);
+            Logger.log(`Window at index ${index} manually resized to height: ${rect.height}`);
+        }
+    }
+
+    resetAllWindowSizes(): void {
+        Logger.log("Clearing all custom window sizes in container");
+        this._customSizes.clear();
+        // Also clear nested containers
+        for (const item of this._tiledItems) {
+            if (item instanceof WindowContainer) {
+                item.resetAllWindowSizes();
+            }
+        }
+    }
+
+    windowResizing(win_id: number, resizeOp: Meta.GrabOp): void {
+        const window = this.getWindow(win_id);
+        if (!window) {
+            // Check nested containers
+            for (const item of this._tiledItems) {
+                if (item instanceof WindowContainer) {
+                    item.windowResizing(win_id, resizeOp);
+                }
+            }
+            return;
+        }
+
+        // Check if the resize direction matches the container orientation
+        const isHorizontalResize = resizeOp === Meta.GrabOp.RESIZING_E || resizeOp === Meta.GrabOp.RESIZING_W;
+        const isVerticalResize = resizeOp === Meta.GrabOp.RESIZING_N || resizeOp === Meta.GrabOp.RESIZING_S;
+
+        if ((this._orientation === Orientation.HORIZONTAL && !isHorizontalResize) ||
+            (this._orientation === Orientation.VERTICAL && !isVerticalResize)) {
+            // Resize direction doesn't match container orientation, ignore
+            return;
+        }
+
+        // Find the index of the window
+        const index = this._getIndexOfWindow(win_id);
+        if (index === -1) {
+            return;
+        }
+
+        // Get the new size
+        const rect = window.getRect();
+        const newSize = this._orientation === Orientation.HORIZONTAL ? rect.width : rect.height;
+        const oldSize = this._customSizes.get(index);
+
+        if (oldSize === undefined) {
+            // First time resizing this window, just set the size
+            this._customSizes.set(index, newSize);
+            this.tileWindows(true);
+            return;
+        }
+
+        // Calculate the delta (how much the window changed)
+        const delta = newSize - oldSize;
+
+        // If delta is 0, the window didn't actually resize (hit its minimum)
+        if (delta === 0) {
+            return;
+        }
+
+        // Determine which adjacent window to adjust based on resize direction
+        let adjacentIndex = -1;
+        if (resizeOp === Meta.GrabOp.RESIZING_E || resizeOp === Meta.GrabOp.RESIZING_S) {
+            // Resizing right/down edge - adjust the next window
+            adjacentIndex = index + 1;
+        } else if (resizeOp === Meta.GrabOp.RESIZING_W || resizeOp === Meta.GrabOp.RESIZING_N) {
+            // Resizing left/up edge - adjust the previous window
+            adjacentIndex = index - 1;
+        }
+
+        // Update current window size
+        this._customSizes.set(index, newSize);
+
+        // Adjust adjacent window only if it has a custom size
+        // When both windows have custom sizes, always apply opposite delta to maintain total width
+        let oldAdjacentSize: number | undefined = undefined;
+        if (adjacentIndex >= 0 && adjacentIndex < this._tiledItems.length &&
+            this._customSizes.has(adjacentIndex)) {
+            const adjacentItem = this._tiledItems[adjacentIndex];
+            if (adjacentItem instanceof WindowWrapper) {
+                oldAdjacentSize = this._customSizes.get(adjacentIndex)!;
+                const newAdjacentSize = oldAdjacentSize - delta;
+
+                // Check if adjacent window allows resize
+                if (!adjacentItem.getWindow().allows_resize()) {
+                    Logger.log("Adjacent window doesn't allow resize, reverting");
+                    this._customSizes.set(index, oldSize);
+                } else {
+                    // Always apply the opposite delta to the adjacent window
+                    // This keeps the total width constant
+                    this._customSizes.set(adjacentIndex, newAdjacentSize);
+                }
+            }
+        }
+
+        // Call tileWindows during resize to update all window positions
+        // Skip retry logic during active resize to avoid jitter
+        this.tileWindows(true);
+    }
+
+
+}

src/wm/monitor.ts

@@ -0,0 +1,113 @@
+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 {
+
+    _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) {
+            const win = container.getWindow(windowId);
+            if (win) {
+                container.removeWindow(windowId);
+            }
+        }
+    }
+
+    addWindow(winWrap: WindowWrapper) {
+        const window_workspace = winWrap.getWindow().get_workspace().index();
+        this._workspaces[window_workspace].addWindow(winWrap);
+    }
+
+    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();
+        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);
+    }
+
+    windowManuallyResized(win_id: number): void {
+        // Find which workspace contains the window and notify it
+        for (const container of this._workspaces) {
+            const win = container.getWindow(win_id);
+            if (win) {
+                container.windowManuallyResized(win_id);
+                return;
+            }
+        }
+    }
+
+    resetAllWindowSizes(): void {
+        for (const container of this._workspaces) {
+            container.resetAllWindowSizes();
+        }
+    }
+
+    windowResizing(win_id: number, resizeOp: Meta.GrabOp): void {
+        // Find which workspace contains the window and notify it
+        for (const container of this._workspaces) {
+            const win = container.getWindow(win_id);
+            if (win) {
+                container.windowResizing(win_id, resizeOp);
+                return;
+            }
+        }
+    }
+
+}

src/wm/window.ts

@@ -0,0 +1,159 @@
+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 {
+    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;
+    }
+
+    // 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
+        this._signals.push(
+            this._window.connect('unmanaging', window => {
+                Logger.log("REMOVING WINDOW", windowId);
+                windowManager.handleWindowClosed(this)
+            }),
+            this._window.connect('notify::minimized', (we) => {
+                if (this._window.minimized) {
+                    Logger.log(`Window minimized: ${windowId}`);
+                    windowManager.handleWindowMinimized(this);
+
+                } else if (!this._window.minimized) {
+                    Logger.log(`Window unminimized: ${windowId}`);
+                    windowManager.handleWindowUnminimized(this);
+
+                }
+            }),
+            this._window.connect('notify::has-focus', () => {
+                if (this._window.has_focus()) {
+                    windowManager._activeWindowId = windowId;
+                }
+            }),
+            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", (_metaWindow) => {
+                Logger.log("WORKSPACE CHANGED FOR WINDOW", this._window.get_id());
+                windowManager.handleWindowChangedWorkspace(this);
+            }),
+            this._window.connect("position-changed", (_metaWindow) => {
+                windowManager.handleWindowPositionChanged(this);
+            }),
+            this._window.connect("size-changed", (_metaWindow) => {
+                windowManager.handleWindowSizeChanged(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 = 2, _skipRetry: boolean = false): void {
+        // Keep minimal logging
+        // Note: we allow resizing even during drag operations to support position updates
+        // The dragging flag only prevents REORDERING, not position/size changes
+        // Logger.log("SAFELY RESIZE", rect.x, rect.y, rect.width, rect.height);
+        const actor = this._window.get_compositor_private();
+
+        if (!actor) {
+            Logger.log("No actor available, can't resize safely yet");
+            return;
+        }
+        let windowActor = this._window.get_compositor_private() as Clutter.Actor;
+        if (!windowActor) return;
+        windowActor.remove_all_transitions();
+        // Logger.info("MOVING")
+        this._window.move_frame(true, rect.x, rect.y);
+        // Logger.info("RESIZING MOVING")
+        this._window.move_resize_frame(true, rect.x, rect.y, rect.width, rect.height);
+        let new_rect = this._window.get_frame_rect();
+        if (!_skipRetry && _retry > 0 && (new_rect.x != rect.x || rect.y != new_rect.y || rect.width < new_rect.width || rect.height < new_rect.height)) {
+            Logger.warn("RESIZING FAILED AS SMALLER", new_rect.x, new_rect.y, new_rect.width, new_rect.height, rect.x, rect.y, rect.width, rect.height);
+            queueEvent({
+                name: "attempting_delayed_resize",
+                callback: () => {
+                    this.safelyResizeWindow(rect, _retry-1, _skipRetry);
+                }
+            })
+        }
+    }
+
+
+}

src/wm/windowManager.ts

@@ -0,0 +1,487 @@
+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";
+
+
+export interface IWindowManager {
+    _activeWindowId: number | null;
+
+    // addWindow(window: Meta.Window): void;
+
+    handleWindowClosed(winWrap: WindowWrapper): void;
+
+    handleWindowMinimized(winWrap: WindowWrapper): void;
+
+    handleWindowUnminimized(winWrap: WindowWrapper): void;
+
+    handleWindowChangedWorkspace(winWrap: WindowWrapper): void;
+
+    handleWindowPositionChanged(winWrap: WindowWrapper): void;
+
+    handleWindowSizeChanged(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;
+    _resizingWindow: boolean = false;
+    _resizeOp: Meta.GrabOp | null = null;
+
+    _showingOverview: boolean = false;
+
+    constructor() {
+
+
+    }
+
+    public enable(): void {
+        Logger.log("Starting Aerospike Window Manager");
+        // Connect window signals
+        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();
+    }
+
+    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("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._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", () => {
+                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", () => {
+                // 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 {
+        this._monitors.forEach((monitor: Monitor) => {
+            monitor.removeAllWindows();
+        })
+        this._minimizedItems.clear();
+    }
+
+
+    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();
+        })
+    }
+
+
+    handleGrabOpBegin(display: Meta.Display, window: Meta.Window, op: Meta.GrabOp): void {
+        Logger.log("Grab Op Start", op);
+        Logger.log(display, window, op)
+        Logger.log(window.get_monitor())
+
+        const isResizing = this._isResizeOperation(op);
+        if (isResizing) {
+            this._resizingWindow = true;
+            this._resizeOp = op;
+            // Don't mark as dragging during resize - we need to update positions freely
+        } else {
+            this._getWrappedWindow(window)?.startDragging();
+        }
+
+        this._grabbedWindowMonitor = window.get_monitor();
+        this._grabbedWindowId = window.get_id();
+    }
+
+    _isResizeOperation(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;
+    }
+
+    handleGrabOpEnd(display: Meta.Display, window: Meta.Window, op: Meta.GrabOp): void {
+        Logger.log("Grab Op End ", op);
+        Logger.log("primary display", display.get_primary_monitor())
+
+        // Check if this was a resize operation
+        if (this._isResizeOperation(op)) {
+            const monitor = this._monitors.get(window.get_monitor());
+            if (monitor) {
+                monitor.windowManuallyResized(window.get_id());
+            }
+        }
+
+        this._resizingWindow = false;
+        this._resizeOp = null;
+        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 = 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 = 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, this.handleWindowMinimized.bind(this));
+            wrapped.connectWindowSignals(this);
+        }
+        let new_mon = this._monitors.get(monitorId);
+        new_mon?.addWindow(wrapped)
+        this._grabbedWindowMonitor = monitorId;
+    }
+
+    public handleWindowPositionChanged(winWrap: WindowWrapper): void {
+        if (this._changingGrabbedMonitor) {
+            return;
+        }
+        if (winWrap.getWindowId() === this._grabbedWindowId) {
+            // Check if we're doing a pure NSEW resize - if so, don't allow position-based swapping
+            if (this._resizingWindow && this._resizeOp) {
+                const isPureNSEWResize =
+                    this._resizeOp === Meta.GrabOp.RESIZING_E ||
+                    this._resizeOp === Meta.GrabOp.RESIZING_W ||
+                    this._resizeOp === Meta.GrabOp.RESIZING_N ||
+                    this._resizeOp === Meta.GrabOp.RESIZING_S;
+
+                if (isPureNSEWResize) {
+                    // Skip itemDragged - don't allow swaps during NSEW resize
+                    return;
+                }
+            }
+
+            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._monitors.get(monitorIndex)?.itemDragged(winWrap, mouseX, mouseY);
+        }
+    }
+
+    public handleWindowSizeChanged(winWrap: WindowWrapper): void {
+        if (this._resizingWindow && winWrap.getWindowId() === this._grabbedWindowId) {
+            // Check if this is a valid resize direction for the container
+            const monitor = this._monitors.get(winWrap.getWindow().get_monitor());
+            if (monitor && this._resizeOp) {
+                monitor.windowResizing(winWrap.getWindowId(), this._resizeOp);
+            }
+        }
+    }
+
+
+    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);
+    }
+
+
+    /**
+     * 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, this.handleWindowMinimized.bind(this))
+        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 {
+
+        for (const monitor of this._monitors.values()) {
+            monitor.tileWindows()
+        }
+    }
+
+    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",);
+
+        // 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;
+    }
+
+    /**
+     * 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 {
+        return null;
+    }
+
+    public resetAllWindowSizes(): void {
+        Logger.log("Resetting all custom window sizes");
+        this._monitors.forEach((monitor: Monitor) => {
+            monitor.resetAllWindowSizes();
+        });
+        this._tileMonitors();
+    }
+
+
+}

tsconfig.json

@@ -12,10 +12,10 @@
   },
   "include": [
     "ambient.d.ts",
+    "prefs.ts",
+    "src/**/*"
   ],
   "files": [
-    "extension.ts",
+    "extension.ts"
-    "winGroup.ts",
-    "prefs.ts"
   ],
 }