feat: new window gets 1/n ratio, existing windows scale proportionally

Previously addWindow() reset all ratios to equal splits, losing any custom sizing. Now _addRatioForNewWindow() gives the new window 1/n of the space and scales the existing windows by (n-1)/n, preserving their ratios relative to each other. e.g. [1/3, 1/6, 1/2] + new → [0.25, 0.125, 0.375, 0.25]
fix: min-window-size setting now read live from Gio.Settings on every boundary adjust
2026-02-24 19:23:16 -05:00 · 2026-02-24 17:46:20 -05:00 · 2026-02-24 17:33:30 -05:00 · 2026-02-24 17:26:27 -05:00
10 changed files with 723 additions and 201 deletions
@@ -15,11 +15,12 @@ export default class aerospike extends Extension {
        super(metadata);
        this.settings = this.getSettings('org.gnome.shell.extensions.aerospike');
        this.keyBindings = new Map();
-        this.windowManager = new WindowManager(this.settings);
+        this.windowManager = new WindowManager();
    }

    enable() {
        Logger.log("STARTING AEROSPIKE!")
+        this.windowManager._settings = this.settings;
        this.bindSettings();
        this.setupKeybindings();
        this.windowManager.enable()
@@ -30,25 +31,42 @@ export default class aerospike extends Extension {
        this.removeKeybindings()
    }

-    private keybindingActions(): Record<string, () => void> {
-        return {
-            'move-left':          () => { Logger.info('Keybinding 1 was pressed!'); },
-            'move-right':         () => { Logger.info('Keybinding 2 was pressed!'); },
-            'join-with-left':     () => { Logger.info('Keybinding 3 was pressed!'); },
-            'join-with-right':    () => { Logger.info('Keybinding 4 was pressed!'); },
-            'print-tree':         () => { this.windowManager.printTreeStructure(); },
-            'toggle-orientation': () => { this.windowManager.toggleActiveContainerOrientation(); },
-            'reset-ratios':       () => { this.windowManager.resetActiveContainerRatios(); },
-        };
-    }

    private bindSettings() {
-        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);
-            });
+        // Monitor settings changes
+        this.settings.connect('changed::move-left', () => {
+            log(`Keybinding 1 changed to: ${this.settings.get_strv('move-left')}`);
+            this.refreshKeybinding('move-left');
+        });
+
+        this.settings.connect('changed::move-right', () => {
+            log(`Keybinding 2 changed to: ${this.settings.get_strv('move-right')}`);
+            this.refreshKeybinding('move-right');
+        });
+
+        this.settings.connect('changed::join-with-left', () => {
+            log(`Keybinding 3 changed to: ${this.settings.get_strv('join-with-left')}`);
+            this.refreshKeybinding('join-with-left');
+        });
+
+        this.settings.connect('changed::join-with-right', () => {
+            log(`Keybinding 4 changed to: ${this.settings.get_strv('join-with-right')}`);
+            this.refreshKeybinding('join-with-right');
+        });
+
+        this.settings.connect('changed::print-tree', () => {
+            log(`Print tree keybinding changed to: ${this.settings.get_strv('print-tree')}`);
+            this.refreshKeybinding('print-tree');
+        });
+
+        this.settings.connect('changed::toggle-orientation', () => {
+            log(`Toggle orientation keybinding changed to: ${this.settings.get_strv('toggle-orientation')}`);
+            this.refreshKeybinding('toggle-orientation');
+        });
+
+        this.settings.connect('changed::reset-ratios', () => {
+            log(`Reset ratios keybinding changed to: ${this.settings.get_strv('reset-ratios')}`);
+            this.refreshKeybinding('reset-ratios');
        });

        this.settings.connect('changed::dropdown-option', () => {
@@ -59,15 +77,49 @@ 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);
        }

-        const action = this.keybindingActions()[settingName];
-        if (action) this.bindKeybinding(settingName, action);
+        switch (settingName) {
+            case 'move-left':
+                this.bindKeybinding('move-left', () => {
+                    Logger.info('Keybinding 1 was pressed!');
+                });
+                break;
+            case 'move-right':
+                this.bindKeybinding('move-right', () => {
+                    Logger.info('Keybinding 2 was pressed!');
+                });
+                break;
+            case 'join-with-left':
+                this.bindKeybinding('join-with-left', () => {
+                    Logger.info('Keybinding 3 was pressed!');
+                });
+                break;
+            case 'join-with-right':
+                this.bindKeybinding('join-with-right', () => {
+                    Logger.info('Keybinding 4 was pressed!');
+                });
+                break;
+            case 'print-tree':
+                this.bindKeybinding('print-tree', () => {
+                    this.windowManager.printTreeStructure();
+                });
+                break;
+            case 'toggle-orientation':
+                this.bindKeybinding('toggle-orientation', () => {
+                    this.windowManager.toggleActiveContainerOrientation();
+                });
+                break;
+            case 'reset-ratios':
+                this.bindKeybinding('reset-ratios', () => {
+                    this.windowManager.resetActiveContainerRatios();
+                });
+                break;
+        }
    }

    private removeKeybindings() {
@@ -78,10 +130,33 @@ export default class aerospike extends Extension {
    }

    private setupKeybindings() {
-        const actions = this.keybindingActions();
-        for (const [name, action] of Object.entries(actions)) {
-            this.bindKeybinding(name, action);
-        }
+        this.bindKeybinding('move-left', () => {
+            Logger.info('Keybinding 1 was pressed!');
+        });
+
+        this.bindKeybinding('move-right', () => {
+            Logger.info('Keybinding 2 was pressed!');
+        });
+
+        this.bindKeybinding('join-with-left', () => {
+            Logger.info('Keybinding 3 was pressed!');
+        });
+
+        this.bindKeybinding('join-with-right', () => {
+            Logger.info('Keybinding 4 was pressed!');
+        });
+
+        this.bindKeybinding('print-tree', () => {
+            this.windowManager.printTreeStructure();
+        });
+
+        this.bindKeybinding('toggle-orientation', () => {
+            this.windowManager.toggleActiveContainerOrientation();
+        });
+
+        this.bindKeybinding('reset-ratios', () => {
+            this.windowManager.resetActiveContainerRatios();
+        });
    }

    private bindKeybinding(settingName: string, callback: () => void) {
@@ -101,4 +176,7 @@ export default class aerospike extends Extension {

        this.keyBindings.set(settingName, keyBindingAction);
    }
-}
+
+
+
+}
@@ -25,7 +25,7 @@
    "@girs/gnome-shell": "49.1.0",
    "@jest/globals": "^30.0.0",
    "@types/jest": "^30.0.0",
-    "eslint": "^10.0.0",
+    "eslint": "^9.36.0",
    "eslint-plugin-jsdoc": "^62.0.0",
    "jest": "^30.0.0",
    "ts-jest": "^29.1.2",
@@ -43,11 +43,11 @@ importers:
        specifier: ^30.0.0
        version: 30.0.0
      eslint:
-        specifier: ^10.0.0
-        version: 10.0.0
+        specifier: ^9.36.0
+        version: 9.39.2
      eslint-plugin-jsdoc:
        specifier: ^62.0.0
-        version: 62.4.1(eslint@10.0.0)
+        version: 62.4.1(eslint@9.39.2)
      jest:
        specifier: ^30.0.0
        version: 30.2.0(@types/node@25.1.0)
@@ -252,25 +252,33 @@ packages:
    resolution: {integrity: sha512-EriSTlt5OC9/7SXkRSCAhfSxxoSUgBm33OH+IkwbdpgoqsSsUg7y3uh+IICI/Qg4BBWr3U2i39RpmycbxMq4ew==}
    engines: {node: ^12.0.0 || ^14.0.0 || >=16.0.0}

-  '@eslint/config-array@0.23.0':
-    resolution: {integrity: sha512-T5Swqd+PZxBekRuMsIFCySM3NUE8GjuqyksIIsXgkF2GCuiDaqpxKyPkv9VMEKpq5D7r5DLss1tM8tCsvRSjeg==}
-    engines: {node: ^20.19.0 || ^22.13.0 || >=24}
+  '@eslint/config-array@0.21.1':
+    resolution: {integrity: sha512-aw1gNayWpdI/jSYVgzN5pL0cfzU02GT3NBpeT/DXbx1/1x7ZKxFPd9bwrzygx/qiwIQiJ1sw/zD8qY/kRvlGHA==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}

-  '@eslint/config-helpers@0.5.2':
-    resolution: {integrity: sha512-a5MxrdDXEvqnIq+LisyCX6tQMPF/dSJpCfBgBauY+pNZ28yCtSsTvyTYrMhaI+LK26bVyCJfJkT0u8KIj2i1dQ==}
-    engines: {node: ^20.19.0 || ^22.13.0 || >=24}
+  '@eslint/config-helpers@0.4.2':
+    resolution: {integrity: sha512-gBrxN88gOIf3R7ja5K9slwNayVcZgK6SOUORm2uBzTeIEfeVaIhOpCtTox3P6R7o2jLFwLFTLnC7kU/RGcYEgw==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}

-  '@eslint/core@1.1.0':
-    resolution: {integrity: sha512-/nr9K9wkr3P1EzFTdFdMoLuo1PmIxjmwvPozwoSodjNBdefGujXQUF93u1DDZpEaTuDvMsIQddsd35BwtrW9Xw==}
-    engines: {node: ^20.19.0 || ^22.13.0 || >=24}
+  '@eslint/core@0.17.0':
+    resolution: {integrity: sha512-yL/sLrpmtDaFEiUj1osRP4TI2MDz1AddJL+jZ7KSqvBuliN4xqYY54IfdN8qD8Toa6g1iloph1fxQNkjOxrrpQ==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}

-  '@eslint/object-schema@3.0.0':
-    resolution: {integrity: sha512-nWl20RtHQP2A2yvKU6Fee62Xo1AoNRqBLixtyg45zJhU8ljPFCyBK90d8e8XTnPns1RggSf4HH3bM8AhevkPVg==}
-    engines: {node: ^20.19.0 || ^22.13.0 || >=24}
+  '@eslint/eslintrc@3.3.3':
+    resolution: {integrity: sha512-Kr+LPIUVKz2qkx1HAMH8q1q6azbqBAsXJUxBl/ODDuVPX45Z9DfwB8tPjTi6nNZ8BuM3nbJxC5zCAg5elnBUTQ==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}

-  '@eslint/plugin-kit@0.6.0':
-    resolution: {integrity: sha512-bIZEUzOI1jkhviX2cp5vNyXQc6olzb2ohewQubuYlMXZ2Q/XjBO0x0XhGPvc9fjSIiUN0vw+0hq53BJ4eQSJKQ==}
-    engines: {node: ^20.19.0 || ^22.13.0 || >=24}
+  '@eslint/js@9.39.2':
+    resolution: {integrity: sha512-q1mjIoW1VX4IvSocvM/vbTiveKC4k9eLrajNEuSsmjymSDEbpGddtpfOoN7YGAqBK3NG+uqo8ia4PDTt8buCYA==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+
+  '@eslint/object-schema@2.1.7':
+    resolution: {integrity: sha512-VtAOaymWVfZcmZbp6E2mympDIHvyjXs/12LqWYjVw6qjrfF+VK+fyG33kChz3nnK+SU5/NeHOqrTEHS8sXO3OA==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+
+  '@eslint/plugin-kit@0.4.1':
+    resolution: {integrity: sha512-43/qtrDUokr7LJqoF2c3+RInu/t4zfrpYdoSDfYyhg52rwLV6TnOvdG4fXm7IkSB3wErkcmJS9iEhjVtOSEjjA==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}

  '@girs/accountsservice-1.0@1.0.0-4.0.0-beta.38':
    resolution: {integrity: sha512-6QzytM5dztmMynF2bxN73EuNK9ArMFxkP2L8wUC7IH45zBeBOfYcqL85BFh2PmkGmqRk+Rli5EFR8dAkx3Ig5Q==}
@@ -417,14 +425,6 @@ packages:
    resolution: {integrity: sha512-bV0Tgo9K4hfPCek+aMAn81RppFKv2ySDQeMoSZuvTASywNTnVJCArCZE2FWqpvIatKu7VMRLWlR1EazvVhDyhQ==}
    engines: {node: '>=18.18'}

-  '@isaacs/balanced-match@4.0.1':
-    resolution: {integrity: sha512-yzMTt9lEb8Gv7zRioUilSglI0c0smZ9k5D65677DLWLtWJaXIS3CqcGyUFByYKlnUj6TkjLVs54fBl6+TiGQDQ==}
-    engines: {node: 20 || >=22}
-
-  '@isaacs/brace-expansion@5.0.1':
-    resolution: {integrity: sha512-WMz71T1JS624nWj2n2fnYAuPovhv7EUhk69R6i9dsVyzxt5eM3bjwvgk9L+APE1TRscGysAVMANkB0jh0LQZrQ==}
-    engines: {node: 20 || >=22}
-
  '@isaacs/cliui@8.0.2':
    resolution: {integrity: sha512-O8jcjabXaleOG9DQ0+ARXWZBTfnP4WNAqzuiJK7ll44AmxGKv/J2M4TPjxjY3znBCfvBXFzucm1twdyFybFqEA==}
    engines: {node: '>=12'}
@@ -574,9 +574,6 @@ packages:
  '@types/babel__traverse@7.28.0':
    resolution: {integrity: sha512-8PvcXf70gTDZBgt9ptxJ8elBeBjcLOAcOtoO/mPJjtji1+CdGbHgm77om1GrsPxsiE+uXIpNSK64UYaIwQXd4Q==}

-  '@types/esrecurse@4.3.1':
-    resolution: {integrity: sha512-xJBAbDifo5hpffDBuHl0Y8ywswbiAp/Wi7Y/GtAgSlZyIABppyurxVueOPE8LUQOxdlgi6Zqce7uoEpqNTeiUw==}
-
  '@types/estree@1.0.8':
    resolution: {integrity: sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==}

@@ -765,6 +762,9 @@ packages:
  argparse@1.0.10:
    resolution: {integrity: sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==}

+  argparse@2.0.1:
+    resolution: {integrity: sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==}
+
  babel-jest@30.2.0:
    resolution: {integrity: sha512-0YiBEOxWqKkSQWL9nNGGEgndoeL0ZpWrbLMNL5u/Kaxrli3Eaxlt3ZtIDktEvXt4L/R9r3ODr2zKwGM/2BjxVw==}
    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
@@ -949,21 +949,25 @@ packages:
    peerDependencies:
      eslint: ^7.0.0 || ^8.0.0 || ^9.0.0

-  eslint-scope@9.1.0:
-    resolution: {integrity: sha512-CkWE42hOJsNj9FJRaoMX9waUFYhqY4jmyLFdAdzZr6VaCg3ynLYx4WnOdkaIifGfH4gsUcBTn4OZbHXkpLD0FQ==}
-    engines: {node: ^20.19.0 || ^22.13.0 || >=24}
+  eslint-scope@8.4.0:
+    resolution: {integrity: sha512-sNXOfKCn74rt8RICKMvJS7XKV/Xk9kA7DyJr8mJik3S7Cwgy3qlkkmyS2uQB3jiJg6VNdZd/pDBJu0nvG2NlTg==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}

  eslint-visitor-keys@3.4.3:
    resolution: {integrity: sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag==}
    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}

+  eslint-visitor-keys@4.2.1:
+    resolution: {integrity: sha512-Uhdk5sfqcee/9H/rCOJikYz67o0a2Tw2hGRPOG2Y1R2dg7brRe1uG0yaNQDHu+TO/uQPF/5eCapvYSmHUjt7JQ==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+
  eslint-visitor-keys@5.0.0:
    resolution: {integrity: sha512-A0XeIi7CXU7nPlfHS9loMYEKxUaONu/hTEzHTGba9Huu94Cq1hPivf+DE5erJozZOky0LfvXAyrV/tcswpLI0Q==}
    engines: {node: ^20.19.0 || ^22.13.0 || >=24}

-  eslint@10.0.0:
-    resolution: {integrity: sha512-O0piBKY36YSJhlFSG8p9VUdPV/SxxS4FYDWVpr/9GJuMaepzwlf4J8I4ov1b+ySQfDTPhc3DtLaxcT1fN0yqCg==}
-    engines: {node: ^20.19.0 || ^22.13.0 || >=24}
+  eslint@9.39.2:
+    resolution: {integrity: sha512-LEyamqS7W5HB3ujJyvi0HQK/dtVINZvd5mAAp9eT5S/ujByGjiZLCzPcHVzuXbpJDJF/cxwHlfceVUDZ2lnSTw==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
    hasBin: true
    peerDependencies:
      jiti: '*'
@@ -971,6 +975,10 @@ packages:
      jiti:
        optional: true

+  espree@10.4.0:
+    resolution: {integrity: sha512-j6PAQ2uUr79PZhBjP5C5fhl8e39FmRnOjsD5lGnWrFU8i2G776tBK7+nP8KuQUTTyAZUwfQqXAgrVH5MbH9CYQ==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+
  espree@11.1.0:
    resolution: {integrity: sha512-WFWYhO1fV4iYkqOOvq8FbqIhr2pYfoDY0kCotMkDeNtGpiGGkZ1iov2u8ydjtgM8yF8rzK7oaTbw2NAzbAbehw==}
    engines: {node: ^20.19.0 || ^22.13.0 || >=24}
@@ -1077,12 +1085,15 @@ packages:

  glob@10.5.0:
    resolution: {integrity: sha512-DfXN8DfhJ7NH3Oe7cFmu3NCu1wKbkReJ8TorzSAFbSKrlNaQSKfIzqYqVY8zlbs2NLBbWpRiU52GX2PbaBVNkg==}
-    deprecated: Old versions of glob are not supported, and contain widely publicized security vulnerabilities, which have been fixed in the current version. Please update. Support for old versions may be purchased (at exorbitant rates) by contacting i@izs.me
    hasBin: true

  glob@7.2.3:
    resolution: {integrity: sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==}
-    deprecated: Old versions of glob are not supported, and contain widely publicized security vulnerabilities, which have been fixed in the current version. Please update. Support for old versions may be purchased (at exorbitant rates) by contacting i@izs.me
+    deprecated: Glob versions prior to v9 are no longer supported
+
+  globals@14.0.0:
+    resolution: {integrity: sha512-oahGvuMGQlPw/ivIYBjVSrWAfWLBeku5tpPE2fOPLi+WHffIWbuh2tCjhyQhTBPMf5E9jDEH4FOmTYgYwbKwtQ==}
+    engines: {node: '>=18'}

  graceful-fs@4.2.11:
    resolution: {integrity: sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==}
@@ -1110,6 +1121,10 @@ packages:
    resolution: {integrity: sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==}
    engines: {node: '>= 4'}

+  import-fresh@3.3.1:
+    resolution: {integrity: sha512-TR3KfrTZTYLPB6jUjfx6MF9WcWrHL9su5TObK4ZkYgBdWKPOFoSoQIdEuTuR82pmtxH2spWG9h6etwfr1pLBqQ==}
+    engines: {node: '>=6'}
+
  import-local@3.2.0:
    resolution: {integrity: sha512-2SPlun1JUPWoM6t3F0dw0FkCF/jWY8kttcY4f599GLTSjh2OCuuhdTkJQsEcZzBqbXZGKMK2OqW1oZsjtf/gQA==}
    engines: {node: '>=8'}
@@ -1314,6 +1329,10 @@ packages:
    resolution: {integrity: sha512-PMSmkqxr106Xa156c2M265Z+FTrPl+oxd/rgOQy2tijQeK5TxQ43psO1ZCwhVOSdnn+RzkzlRz/eY4BgJBYVpg==}
    hasBin: true

+  js-yaml@4.1.1:
+    resolution: {integrity: sha512-qQKT4zQxXl8lLwBtHMWwaTcGfFOZviOJet3Oy/xmGk2gZH677CJM9EvtfdSkgWcATZhj/55JZ0rmy3myCT5lsA==}
+    hasBin: true
+
  jsdoc-type-pratt-parser@7.1.0:
    resolution: {integrity: sha512-SX7q7XyCwzM/MEDCYz0l8GgGbJAACGFII9+WfNYr5SLEKukHWRy2Jk3iWRe7P+lpYJNs7oQ+OSei4JtKGUjd7A==}
    engines: {node: '>=20.0.0'}
@@ -1365,6 +1384,9 @@ packages:
  lodash.memoize@4.1.2:
    resolution: {integrity: sha512-t7j+NzmgnQzTAYXcsHYLgimltOV1MXHtlOWf6GjL9Kj8GK5FInw5JotxvbOs+IvV1/Dzo04/fCGfLVs7aXb4Ag==}

+  lodash.merge@4.6.2:
+    resolution: {integrity: sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==}
+
  lru-cache@10.4.3:
    resolution: {integrity: sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ==}

@@ -1392,10 +1414,6 @@ packages:
    resolution: {integrity: sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg==}
    engines: {node: '>=6'}

-  minimatch@10.1.2:
-    resolution: {integrity: sha512-fu656aJ0n2kcXwsnwnv9g24tkU5uSmOlTjd6WyyaKm2Z+h1qmY6bAjrcaIxF/BslFqbZ8UBtbJi7KgQOZD2PTw==}
-    engines: {node: 20 || >=22}
-
  minimatch@3.1.2:
    resolution: {integrity: sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==}

@@ -1475,6 +1493,10 @@ packages:
  package-json-from-dist@1.0.1:
    resolution: {integrity: sha512-UEZIS3/by4OC8vL3P2dTXRETpebLI2NiI5vIrjaD/5UtrkFX/tNbwjTSRAGC/+7CAo2pIcBaRgWmcBBHcsaCIw==}

+  parent-module@1.0.1:
+    resolution: {integrity: sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==}
+    engines: {node: '>=6'}
+
  parse-imports-exports@0.2.4:
    resolution: {integrity: sha512-4s6vd6dx1AotCx/RCI2m7t7GCh5bDRUtGNvRfHSP2wbBQdMi67pPe7mtzmgwcaQ8VKK/6IB7Glfyu3qdZJPybQ==}

@@ -1550,6 +1572,10 @@ packages:
    resolution: {integrity: sha512-OrZaX2Mb+rJCpH/6CpSqt9xFVpN++x01XnN2ie9g6P5/3xelLAkXWVADpdz1IHD/KFfEXyE6V0U01OQ3UO2rEg==}
    engines: {node: '>=8'}

+  resolve-from@4.0.0:
+    resolution: {integrity: sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==}
+    engines: {node: '>=4'}
+
  resolve-from@5.0.0:
    resolution: {integrity: sha512-qYg9KP24dD5qka9J47d0aVky0N+b4fTU89LN9iDnjB5waksiC49rvMB0PrUJQGoTmH50XPiqOvAjDfaijGxYZw==}
    engines: {node: '>=8'}
@@ -2005,34 +2031,50 @@ snapshots:

  '@es-joy/resolve.exports@1.2.0': {}

-  '@eslint-community/eslint-utils@4.9.1(eslint@10.0.0)':
+  '@eslint-community/eslint-utils@4.9.1(eslint@9.39.2)':
    dependencies:
-      eslint: 10.0.0
+      eslint: 9.39.2
      eslint-visitor-keys: 3.4.3

  '@eslint-community/regexpp@4.12.2': {}

-  '@eslint/config-array@0.23.0':
+  '@eslint/config-array@0.21.1':
    dependencies:
-      '@eslint/object-schema': 3.0.0
+      '@eslint/object-schema': 2.1.7
      debug: 4.4.3
-      minimatch: 10.1.2
+      minimatch: 3.1.2
    transitivePeerDependencies:
      - supports-color

-  '@eslint/config-helpers@0.5.2':
+  '@eslint/config-helpers@0.4.2':
    dependencies:
-      '@eslint/core': 1.1.0
+      '@eslint/core': 0.17.0

-  '@eslint/core@1.1.0':
+  '@eslint/core@0.17.0':
    dependencies:
      '@types/json-schema': 7.0.15

-  '@eslint/object-schema@3.0.0': {}
-
-  '@eslint/plugin-kit@0.6.0':
+  '@eslint/eslintrc@3.3.3':
    dependencies:
-      '@eslint/core': 1.1.0
+      ajv: 6.12.6
+      debug: 4.4.3
+      espree: 10.4.0
+      globals: 14.0.0
+      ignore: 5.3.2
+      import-fresh: 3.3.1
+      js-yaml: 4.1.1
+      minimatch: 3.1.2
+      strip-json-comments: 3.1.1
+    transitivePeerDependencies:
+      - supports-color
+
+  '@eslint/js@9.39.2': {}
+
+  '@eslint/object-schema@2.1.7': {}
+
+  '@eslint/plugin-kit@0.4.1':
+    dependencies:
+      '@eslint/core': 0.17.0
      levn: 0.4.1

  '@girs/accountsservice-1.0@1.0.0-4.0.0-beta.38':
@@ -2499,12 +2541,6 @@ snapshots:

  '@humanwhocodes/retry@0.4.3': {}

-  '@isaacs/balanced-match@4.0.1': {}
-
-  '@isaacs/brace-expansion@5.0.1':
-    dependencies:
-      '@isaacs/balanced-match': 4.0.1
-
  '@isaacs/cliui@8.0.2':
    dependencies:
      string-width: 5.1.2
@@ -2772,8 +2808,6 @@ snapshots:
    dependencies:
      '@babel/types': 7.28.6

-  '@types/esrecurse@4.3.1': {}
-
  '@types/estree@1.0.8': {}

  '@types/istanbul-lib-coverage@2.0.6': {}
@@ -2908,6 +2942,8 @@ snapshots:
    dependencies:
      sprintf-js: 1.0.3

+  argparse@2.0.1: {}
+
  babel-jest@30.2.0(@babel/core@7.28.6):
    dependencies:
      '@babel/core': 7.28.6
@@ -3074,7 +3110,7 @@ snapshots:

  escape-string-regexp@4.0.0: {}

-  eslint-plugin-jsdoc@62.4.1(eslint@10.0.0):
+  eslint-plugin-jsdoc@62.4.1(eslint@9.39.2):
    dependencies:
      '@es-joy/jsdoccomment': 0.83.0
      '@es-joy/resolve.exports': 1.2.0
@@ -3082,7 +3118,7 @@ snapshots:
      comment-parser: 1.4.5
      debug: 4.4.3
      escape-string-regexp: 4.0.0
-      eslint: 10.0.0
+      eslint: 9.39.2
      espree: 11.1.0
      esquery: 1.7.0
      html-entities: 2.6.0
@@ -3094,36 +3130,39 @@ snapshots:
    transitivePeerDependencies:
      - supports-color

-  eslint-scope@9.1.0:
+  eslint-scope@8.4.0:
    dependencies:
-      '@types/esrecurse': 4.3.1
-      '@types/estree': 1.0.8
      esrecurse: 4.3.0
      estraverse: 5.3.0

  eslint-visitor-keys@3.4.3: {}

+  eslint-visitor-keys@4.2.1: {}
+
  eslint-visitor-keys@5.0.0: {}

-  eslint@10.0.0:
+  eslint@9.39.2:
    dependencies:
-      '@eslint-community/eslint-utils': 4.9.1(eslint@10.0.0)
+      '@eslint-community/eslint-utils': 4.9.1(eslint@9.39.2)
      '@eslint-community/regexpp': 4.12.2
-      '@eslint/config-array': 0.23.0
-      '@eslint/config-helpers': 0.5.2
-      '@eslint/core': 1.1.0
-      '@eslint/plugin-kit': 0.6.0
+      '@eslint/config-array': 0.21.1
+      '@eslint/config-helpers': 0.4.2
+      '@eslint/core': 0.17.0
+      '@eslint/eslintrc': 3.3.3
+      '@eslint/js': 9.39.2
+      '@eslint/plugin-kit': 0.4.1
      '@humanfs/node': 0.16.7
      '@humanwhocodes/module-importer': 1.0.1
      '@humanwhocodes/retry': 0.4.3
      '@types/estree': 1.0.8
      ajv: 6.12.6
+      chalk: 4.1.2
      cross-spawn: 7.0.6
      debug: 4.4.3
      escape-string-regexp: 4.0.0
-      eslint-scope: 9.1.0
-      eslint-visitor-keys: 5.0.0
-      espree: 11.1.0
+      eslint-scope: 8.4.0
+      eslint-visitor-keys: 4.2.1
+      espree: 10.4.0
      esquery: 1.7.0
      esutils: 2.0.3
      fast-deep-equal: 3.1.3
@@ -3134,12 +3173,19 @@ snapshots:
      imurmurhash: 0.1.4
      is-glob: 4.0.3
      json-stable-stringify-without-jsonify: 1.0.1
-      minimatch: 10.1.2
+      lodash.merge: 4.6.2
+      minimatch: 3.1.2
      natural-compare: 1.4.0
      optionator: 0.9.4
    transitivePeerDependencies:
      - supports-color

+  espree@10.4.0:
+    dependencies:
+      acorn: 8.15.0
+      acorn-jsx: 5.3.2(acorn@8.15.0)
+      eslint-visitor-keys: 4.2.1
+
  espree@11.1.0:
    dependencies:
      acorn: 8.15.0
@@ -3258,6 +3304,8 @@ snapshots:
      once: 1.4.0
      path-is-absolute: 1.0.1

+  globals@14.0.0: {}
+
  graceful-fs@4.2.11: {}

  handlebars@4.7.8:
@@ -3279,6 +3327,11 @@ snapshots:

  ignore@5.3.2: {}

+  import-fresh@3.3.1:
+    dependencies:
+      parent-module: 1.0.1
+      resolve-from: 4.0.0
+
  import-local@3.2.0:
    dependencies:
      pkg-dir: 4.2.0
@@ -3666,6 +3719,10 @@ snapshots:
      argparse: 1.0.10
      esprima: 4.0.1

+  js-yaml@4.1.1:
+    dependencies:
+      argparse: 2.0.1
+
  jsdoc-type-pratt-parser@7.1.0: {}

  jsesc@3.1.0: {}
@@ -3703,6 +3760,8 @@ snapshots:

  lodash.memoize@4.1.2: {}

+  lodash.merge@4.6.2: {}
+
  lru-cache@10.4.3: {}

  lru-cache@5.1.1:
@@ -3728,10 +3787,6 @@ snapshots:

  mimic-fn@2.1.0: {}

-  minimatch@10.1.2:
-    dependencies:
-      '@isaacs/brace-expansion': 5.0.1
-
  minimatch@3.1.2:
    dependencies:
      brace-expansion: 1.1.12
@@ -3801,6 +3856,10 @@ snapshots:

  package-json-from-dist@1.0.1: {}

+  parent-module@1.0.1:
+    dependencies:
+      callsites: 3.1.0
+
  parse-imports-exports@0.2.4:
    dependencies:
      parse-statements: 1.0.11
@@ -3859,6 +3918,8 @@ snapshots:
    dependencies:
      resolve-from: 5.0.0

+  resolve-from@4.0.0: {}
+
  resolve-from@5.0.0: {}

  semver@6.3.1: {}
@@ -55,5 +55,12 @@
            <description>Resets all window size ratios in the active window's container to equal splits</description>
        </key>

+        <key name="min-window-size-percent" type="d">
+            <default>0.10</default>
+            <range min="0.01" max="0.49"/>
+            <summary>Minimum window size percentage</summary>
+            <description>Minimum fraction of a container that any single window may occupy when resizing boundaries</description>
+        </key>
+
    </schema>
 </schemalist>
@@ -182,6 +182,41 @@ export default class AerospikeExtensions extends ExtensionPreferences {
            })
        );

+        // Create sizing group
+        const sizingGroup = new Adw.PreferencesGroup({
+            title: _('Window Sizing'),
+        });
+        page.add(sizingGroup);
+
+        // Minimum window size percentage spinner
+        const minSizeRow = new Adw.ActionRow({
+            title: _('Minimum Window Size'),
+            subtitle: _('Smallest fraction of a container any window may occupy when resizing (e.g. 0.10 = 10%)'),
+        });
+        sizingGroup.add(minSizeRow);
+
+        const minSizeSpin = new Gtk.SpinButton({
+            adjustment: new Gtk.Adjustment({
+                lower: 0.01,
+                upper: 0.49,
+                step_increment: 0.01,
+                page_increment: 0.05,
+                value: settings.get_double('min-window-size-percent'),
+            }),
+            digits: 2,
+            valign: Gtk.Align.CENTER,
+        });
+        minSizeRow.add_suffix(minSizeSpin);
+        minSizeRow.set_activatable_widget(minSizeSpin);
+
+        minSizeSpin.connect('value-changed', () => {
+            settings.set_double('min-window-size-percent', minSizeSpin.get_value());
+        });
+
+        settings.connect('changed::min-window-size-percent', () => {
+            minSizeSpin.set_value(settings.get_double('min-window-size-percent'));
+        });
+
    }

    // Helper function to create a keybinding mapping object
@@ -1,18 +1,25 @@
 import GLib from "gi://GLib";

+
 export type QueuedEvent = {
    name: string;
    callback: () => void;
 }

+// Pending events indexed by name so that duplicate events collapse into one.
+// Only the most-recently-queued callback for a given name is kept.
 const pendingEvents: Map<string, QueuedEvent> = new Map();

 export default function queueEvent(event: QueuedEvent, interval = 200) {
+    // Overwrite any earlier pending event with the same name — the latest
+    // callback is always the most up-to-date one.
    pendingEvents.set(event.name, event);

    GLib.timeout_add(GLib.PRIORITY_DEFAULT, interval, () => {
        const e = pendingEvents.get(event.name);
        if (e && e === event) {
+            // Only fire if this is still the current callback for this name
+            // (a newer call may have replaced it).
            pendingEvents.delete(event.name);
            e.callback();
        }
@@ -1,5 +1,6 @@
 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";

@@ -8,22 +9,35 @@ enum Orientation {
    VERTICAL = 1,
 }

-// Returns equal ratios summing exactly to 1.0, with float drift absorbed by the last slot.
+/**
+ * Build a split-ratio array of length `n` where every element equals 1/n,
+ * with the last slot absorbing any floating-point remainder so the array
+ * always sums to exactly 1.0.
+ */
 function equalRatios(n: number): number[] {
    if (n <= 0) return [];
    const base = 1 / n;
    const ratios = Array(n).fill(base);
+    // Fix floating-point drift: make last slot exact
    const sumExceptLast = ratios.slice(0, -1).reduce((a, b) => a + b, 0);
    ratios[n - 1] = 1 - sumExceptLast;
    return ratios;
 }

+
 export default class WindowContainer {

    _tiledItems: (WindowWrapper | WindowContainer)[];
    _tiledWindowLookup: Map<number, WindowWrapper>;
    _orientation: Orientation = Orientation.HORIZONTAL;
    _workArea: Rect;
+
+    /**
+     * Per-child split ratios. Always satisfies:
+     *   _splitRatios.length === _tiledItems.length
+     *   _splitRatios.reduce((a,b) => a+b, 0) === 1.0  (within floating-point epsilon)
+     *   every element >= MIN_RATIO
+     */
    _splitRatios: number[];

    constructor(workspaceArea: Rect) {
@@ -35,10 +49,20 @@ export default class WindowContainer {

    // ─── Helpers ────────────────────────────────────────────────────────────────

+    /** Rebuild _splitRatios as equal fractions after any structural change. */
    private _resetRatios(): void {
        this._splitRatios = equalRatios(this._tiledItems.length);
    }

+    /**
+     * Called after a new item has been pushed onto _tiledItems.
+     * The new window (last slot) gets 1/n of the space; existing windows
+     * are scaled down proportionally so their ratios relative to each other
+     * are preserved and the total remains 1.0.
+     *
+     * e.g. [0.33, 0.166, 0.5] + new → new=0.25, existing scaled by 0.75
+     *      → [0.2475, 0.1245, 0.375, 0.25]
+     */
    private _addRatioForNewWindow(): void {
        const n = this._tiledItems.length;
        if (n <= 1) {
@@ -46,13 +70,15 @@ export default class WindowContainer {
            return;
        }
        const newRatio = 1 / n;
-        const scale    = 1 - newRatio;
+        const scale    = 1 - newRatio; // existing windows share this fraction
        const scaled   = this._splitRatios.map(r => r * scale);
+        // Absorb all floating-point drift into the last slot so sum is exactly 1.0
        const partialSum = scaled.reduce((a, b) => a + b, 0) + newRatio;
        scaled[scaled.length - 1] += (1.0 - partialSum);
        this._splitRatios = [...scaled, newRatio];
    }

+    /** Total dimension for the active orientation (width for H, height for V). */
    private _totalDimension(): number {
        return this._orientation === Orientation.HORIZONTAL
            ? this._workArea.width
@@ -80,7 +106,9 @@ export default class WindowContainer {
        this._addRatioForNewWindow();
        queueEvent({
            name: "tiling-windows",
-            callback: () => this.tileWindows(),
+            callback: () => {
+                this.tileWindows();
+            }
        }, 100);
    }

@@ -91,7 +119,9 @@ export default class WindowContainer {
        for (const item of this._tiledItems) {
            if (item instanceof WindowContainer) {
                const win = item.getWindow(win_id);
-                if (win) return win;
+                if (win) {
+                    return win;
+                }
            } else if (item.getWindowId() === win_id) {
                return item;
            }
@@ -111,7 +141,6 @@ export default class WindowContainer {

    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) {
@@ -144,15 +173,17 @@ export default class WindowContainer {
        this._splitRatios = [];
    }

-    tileWindows(): void {
+    tileWindows() {
        Logger.log("TILING WINDOWS IN CONTAINER");
        Logger.log("WorkArea", this._workArea);
        this._tileItems();
+        return true;
    }

    _tileItems() {
-        if (this._tiledItems.length === 0) return;
-
+        if (this._tiledItems.length === 0) {
+            return;
+        }
        const bounds = this.getBounds();
        Logger.info(`_tileItems: ratios=[${this._splitRatios.map(r => r.toFixed(3)).join(', ')}] bounds=[${bounds.map(b => `(${b.x},${b.y},${b.width},${b.height})`).join(', ')}]`);
        this._tiledItems.forEach((item, index) => {
@@ -169,32 +200,72 @@ export default class WindowContainer {
    // ─── Bounds Calculation ──────────────────────────────────────────────────────

    getBounds(): Rect[] {
-        return this._orientation === Orientation.HORIZONTAL
-            ? this._computeBounds('horizontal')
-            : this._computeBounds('vertical');
+        if (this._orientation === Orientation.HORIZONTAL) {
+            return this.getHorizontalBounds();
+        }
+        return this.getVerticalBounds();
    }

-    private _computeBounds(axis: 'horizontal' | 'vertical'): Rect[] {
-        const isHorizontal = axis === 'horizontal';
-        const total = isHorizontal ? this._workArea.width : this._workArea.height;
-        let used = 0;
+    getVerticalBounds(): Rect[] {
+        const items = this._tiledItems;
+        const totalHeight = this._workArea.height;
+        let usedHeight = 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 };
+        return items.map((_, index) => {
+            const y = this._workArea.y + usedHeight;
+            let height: number;
+            if (index === items.length - 1) {
+                // Last item gets the remainder to avoid pixel gaps from rounding
+                height = totalHeight - usedHeight;
+            } else {
+                height = Math.floor(this._splitRatios[index] * totalHeight);
+            }
+            usedHeight += height;
+            return {
+                x: this._workArea.x,
+                y: y,
+                width: this._workArea.width,
+                height: height,
+            } as Rect;
        });
    }

-    // ─── Boundary Adjustment ─────────────────────────────────────────────────────
+    getHorizontalBounds(): Rect[] {
+        const totalWidth = this._workArea.width;
+        let usedWidth = 0;

-    adjustBoundary(boundaryIndex: number, deltaPixels: number): boolean {
+        return this._tiledItems.map((_, index) => {
+            const x = this._workArea.x + usedWidth;
+            let width: number;
+            if (index === this._tiledItems.length - 1) {
+                // Last item gets the remainder to avoid pixel gaps from rounding
+                width = totalWidth - usedWidth;
+            } else {
+                width = Math.floor(this._splitRatios[index] * totalWidth);
+            }
+            usedWidth += width;
+            return {
+                x: x,
+                y: this._workArea.y,
+                width: width,
+                height: this._workArea.height,
+            } as Rect;
+        });
+    }
+
+    // ─── Boundary / Ratio Adjustment ─────────────────────────────────────────────
+
+    /**
+     * Adjust the boundary between item[boundaryIndex] and item[boundaryIndex+1]
+     * by deltaPixels (positive = move right/down, negative = move left/up).
+     *
+     * Both affected ratios are clamped to [_minRatio, 1 - _minRatio] so no
+     * window can be squashed below the configured minimum.
+     *
+     * Returns true if the adjustment was applied, false if it was rejected
+     * (e.g. out of bounds index or clamping would violate minimum).
+     */
+    adjustBoundary(boundaryIndex: number, deltaPixels: number, minRatio: number = 0.10): boolean {
        if (boundaryIndex < 0 || boundaryIndex >= this._tiledItems.length - 1) {
            Logger.warn(`adjustBoundary: invalid boundaryIndex ${boundaryIndex}`);
            return false;
@@ -204,11 +275,12 @@ export default class WindowContainer {
        if (totalDim === 0) return false;

        const ratioDelta = deltaPixels / totalDim;
-        const newLeft    = this._splitRatios[boundaryIndex]     + ratioDelta;
-        const newRight   = this._splitRatios[boundaryIndex + 1] - ratioDelta;

-        if (newLeft <= 0 || newRight <= 0) {
-            Logger.log(`adjustBoundary: clamped — newLeft=${newLeft.toFixed(3)}, newRight=${newRight.toFixed(3)}`);
+        const newLeft  = this._splitRatios[boundaryIndex]     + ratioDelta;
+        const newRight = this._splitRatios[boundaryIndex + 1] - ratioDelta;
+
+        if (newLeft < minRatio || newRight < minRatio) {
+            Logger.log(`adjustBoundary: clamped — newLeft=${newLeft.toFixed(3)}, newRight=${newRight.toFixed(3)}, min=${minRatio}`);
            return false;
        }

@@ -219,13 +291,38 @@ export default class WindowContainer {
        return true;
    }

+    /**
+     * Adjust boundaries on BOTH axes simultaneously for corner resize ops.
+     * horizontalDelta applies to this container if HORIZONTAL, verticalDelta if VERTICAL.
+     * For nested containers the perpendicular delta is forwarded to the child container.
+     *
+     * boundaryIndex: the slot index whose right/bottom edge is being dragged.
+     */
+    adjustBoundaryBothAxes(
+        boundaryIndex: number,
+        horizontalDelta: number,
+        verticalDelta: number,
+    ): void {
+        if (this._orientation === Orientation.HORIZONTAL) {
+            this.adjustBoundary(boundaryIndex, horizontalDelta);
+        } else {
+            this.adjustBoundary(boundaryIndex, verticalDelta);
+        }
+    }
+
    // ─── Container Lookup ────────────────────────────────────────────────────────

+    /**
+     * Returns the direct-parent WindowContainer that contains win_id as an
+     * immediate child (not recursed further). Returns null if not found.
+     */
    getContainerForWindow(win_id: number): WindowContainer | null {
        for (const item of this._tiledItems) {
            if (item instanceof WindowWrapper && item.getWindowId() === win_id) {
                return this;
            }
+        }
+        for (const item of this._tiledItems) {
            if (item instanceof WindowContainer) {
                const found = item.getContainerForWindow(win_id);
                if (found !== null) return found;
@@ -238,7 +335,10 @@ export default class WindowContainer {
        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;
+                const index = container.getIndexOfItemNested(item);
+                if (index !== -1) {
+                    return i;
+                }
            } else if (container.getWindowId() === item.getWindowId()) {
                return i;
            }
@@ -248,28 +348,34 @@ export default class WindowContainer {

    // TODO: update this to work with nested containers - all other logic should already be working
    itemDragged(item: WindowWrapper, x: number, y: number): void {
-        const original_index = this.getIndexOfItemNested(item);
+        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) {
-            Logger.info(`itemDragged: swapped slots ${original_index}<->${new_index}, ratios=[${this._splitRatios.map(r => r.toFixed(3)).join(', ')}]`);
+            // Swap only the items — ratios stay with their slots.
+            // e.g. slot 0 = 40%, slot 1 = 60%: when the window in slot 1 drags
+            // into slot 0, it takes slot 0's 40% size. The window it displaces
+            // moves to slot 1 and takes the 60% size. The slot ratios are unchanged.
            [this._tiledItems[original_index], this._tiledItems[new_index]] =
                [this._tiledItems[new_index], this._tiledItems[original_index]];
+            Logger.info(`itemDragged: swapped slots ${original_index}<->${new_index}, ratios=[${this._splitRatios.map(r => r.toFixed(3)).join(', ')}]`);
            this.tileWindows();
        }
    }

+    /**
+     * Reset all split ratios in this container to equal fractions.
+     * Called when the user explicitly requests an equal-split reset (e.g. Ctrl+Z).
+     */
    resetRatios(): void {
        this._resetRatios();
        this.tileWindows();
@@ -1,9 +1,12 @@
 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 {

@@ -17,7 +20,7 @@ export default class Monitor {
        this._workArea = workspace.get_work_area_for_monitor(this._id);
        Logger.log("CREATING MONITOR", monitorId);
        Logger.log("WorkArea", this._workArea.x, this._workArea.y, this._workArea.width, this._workArea.height);
-        const workspaceCount = global.workspace_manager.get_n_workspaces();
+        const workspaceCount = global.workspace_manager.get_n_workspaces()
        Logger.log("Workspace Count", workspaceCount);
        for (let i = 0; i < workspaceCount; i++) {
            this._workspaces.push(new WindowContainer(this._workArea));
@@ -39,7 +42,9 @@ export default class Monitor {
    getWindow(windowId: number): WindowWrapper | undefined {
        for (const container of this._workspaces) {
            const win = container.getWindow(windowId);
-            if (win) return win;
+            if (win) {
+                return win;
+            }
        }
        return undefined;
    }
@@ -47,7 +52,8 @@ export default class Monitor {
    removeWindow(winWrap: WindowWrapper) {
        const windowId = winWrap.getWindowId();
        for (const container of this._workspaces) {
-            if (container.getWindow(windowId)) {
+            const win = container.getWindow(windowId);
+            if (win) {
                container.removeWindow(windowId);
            }
        }
@@ -59,9 +65,9 @@ export default class Monitor {
    }

    tileWindows(): void {
+        this._workArea = global.workspace_manager.get_active_workspace().get_work_area_for_monitor(this._id);
        const activeWorkspace = global.workspace_manager.get_active_workspace();
-        this._workArea = activeWorkspace.get_work_area_for_monitor(this._id);
-        // move() calls tileWindows() internally
+        // move() already calls tileWindows() internally — don't call it again
        this._workspaces[activeWorkspace.index()].move(this._workArea);
    }

@@ -76,4 +82,5 @@ export default class Monitor {
    itemDragged(item: WindowWrapper, x: number, y: number): void {
        this._workspaces[item.getWorkspace()].itemDragged(item, x, y);
    }
-}
+
+}
@@ -11,8 +11,6 @@ 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[] = [];
@@ -50,26 +48,41 @@ export class WindowWrapper {
    startDragging(): void {
        this._dragging = true;
    }
-
    stopDragging(): void {
        Logger.log("STOPPED DRAGGING")
        this._dragging = false;
    }

-    connectWindowSignals(windowManager: IWindowManager): void {
-        const windowId = this._window.get_id();
+    // 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', () => {
+            this._window.connect('unmanaging', window => {
                Logger.log("REMOVING WINDOW", windowId);
-                windowManager.handleWindowClosed(this);
+                windowManager.handleWindowClosed(this)
            }),
-            this._window.connect('notify::minimized', () => {
+            this._window.connect('notify::minimized', (we) => {
                if (this._window.minimized) {
                    Logger.log(`Window minimized: ${windowId}`);
                    windowManager.handleWindowMinimized(this);
-                } else {
+
+                } else if (!this._window.minimized) {
                    Logger.log(`Window unminimized: ${windowId}`);
                    windowManager.handleWindowUnminimized(this);
+
                }
            }),
            this._window.connect('notify::maximized-horizontally', () => {
@@ -79,20 +92,21 @@ export class WindowWrapper {
                    Logger.log(`Window unmaximized: ${windowId}`);
                }
            }),
-            this._window.connect("workspace-changed", () => {
+            this._window.connect("workspace-changed", (_metaWindow) => {
                Logger.log("WORKSPACE CHANGED FOR WINDOW", this._window.get_id());
                windowManager.handleWindowChangedWorkspace(this);
            }),
-            this._window.connect("position-changed", () => {
+            this._window.connect("position-changed", (_metaWindow) => {
                windowManager.handleWindowPositionChanged(this);
            }),
-            this._window.connect("size-changed", () => {
+            this._window.connect("size-changed", (_metaWindow) => {
                windowManager.handleWindowPositionChanged(this);
            }),
        );
    }

    disconnectWindowSignals(): void {
+
        if (this._signals) {
            this._signals.forEach(signal => {
                try {
@@ -119,14 +133,17 @@ export class WindowWrapper {
        }

        actor.remove_all_transitions();
+
+        // Single call: move + resize atomically
        this._window.move_resize_frame(true, rect.x, rect.y, rect.width, rect.height);

        const new_rect = this._window.get_frame_rect();
+        const TOLERANCE = 2; // pixels — allow compositor rounding
        const mismatch =
-            Math.abs(new_rect.x      - rect.x)      > 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;
+            Math.abs(new_rect.x - rect.x) > TOLERANCE ||
+            Math.abs(new_rect.y - rect.y) > TOLERANCE ||
+            Math.abs(new_rect.width  - rect.width)  > TOLERANCE ||
+            Math.abs(new_rect.height - rect.height) > TOLERANCE;

        if (_retry > 0 && mismatch) {
            Logger.warn("RESIZE MISMATCH, retrying",
@@ -134,8 +151,12 @@ export class WindowWrapper {
                `got(${new_rect.x},${new_rect.y},${new_rect.width},${new_rect.height})`);
            queueEvent({
                name: `delayed_resize_${this.getWindowId()}`,
-                callback: () => this.safelyResizeWindow(rect, _retry - 1),
+                callback: () => {
+                    this.safelyResizeWindow(rect, _retry - 1);
+                }
            }, 50);
        }
    }
+
+
 }
@@ -1,8 +1,10 @@
 import Meta from "gi://Meta";
 import Gio from "gi://Gio";
+// import GLib from "gi://GLib";

 import {WindowWrapper} from './window.js';
 import * as Main from "resource:///org/gnome/shell/ui/main.js";
+// import Mtk from "@girs/mtk-16";
 import {Logger} from "../utils/logger.js";
 import Monitor from "./monitor.js";
 import WindowContainer from "./container.js";
@@ -12,6 +14,8 @@ import {Rect} from "../utils/rect.js";
 export interface IWindowManager {
    _activeWindowId: number | null;

+    // addWindow(window: Meta.Window): void;
+
    handleWindowClosed(winWrap: WindowWrapper): void;

    handleWindowMinimized(winWrap: WindowWrapper): void;
@@ -26,8 +30,8 @@ export interface IWindowManager {
 }


-const _UNUSED_MONITOR_ID = -1;
-const _UNUSED_WINDOW_ID  = -1;
+const _UNUSED_MONITOR_ID = -1
+const _UNUSED_WINDOW_ID = -1

 export default class WindowManager implements IWindowManager {
    _displaySignals: number[] = [];
@@ -37,29 +41,37 @@ export default class WindowManager implements IWindowManager {

    _activeWindowId: number | null = null;
    _monitors: Map<number, Monitor> = new Map<number, Monitor>();
+
    _minimizedItems: Map<number, WindowWrapper> = new Map<number, WindowWrapper>();

    _grabbedWindowMonitor: number = _UNUSED_MONITOR_ID;
    _grabbedWindowId: number = _UNUSED_WINDOW_ID;
    _changingGrabbedMonitor: boolean = false;
+
    _showingOverview: boolean = false;

    // ── Resize-drag tracking ──────────────────────────────────────────────────
    _isResizeDrag: boolean = false;
    _resizeDragWindowId: number = _UNUSED_WINDOW_ID;
    _resizeDragOp: Meta.GrabOp = Meta.GrabOp.NONE;
+    /** Mouse position at the start of each incremental resize step. */
    _resizeDragLastMouseX: number = 0;
    _resizeDragLastMouseY: number = 0;
+    /** Re-entrancy guard: true while tileWindows is propagating position-changed events. */
    _isTiling: boolean = false;

-    private readonly _settings: Gio.Settings;
+    _settings: Gio.Settings | null = null;

-    constructor(settings: Gio.Settings) {
-        this._settings = settings;
+    constructor() {}
+
+    /** Returns the live min-ratio value from settings, falling back to 0.10. */
+    private _getMinRatio(): number {
+        return this._settings?.get_double('min-window-size-percent') ?? 0.10;
    }

    public enable(): void {
        Logger.log("Starting Aerospike Window Manager");
+        // Connect window signals
        this.instantiateDisplaySignals();

        const mon_count = global.display.get_n_monitors();
@@ -68,6 +80,8 @@ export default class WindowManager implements IWindowManager {
        }

        this.captureExistingWindows();
+
+        // Sync the initially focused window
        this.syncActiveWindow();
    }

@@ -94,6 +108,7 @@ export default class WindowManager implements IWindowManager {
            global.display.connect('notify::focus-window', () => {
                this.syncActiveWindow();
            }),
+
            global.display.connect("showing-desktop-changed", () => {
                Logger.log("SHOWING DESKTOP CHANGED");
            }),
@@ -104,7 +119,13 @@ export default class WindowManager implements IWindowManager {
            global.display.connect("in-fullscreen-changed", () => {
                Logger.log("IN FULL SCREEN CHANGED");
            }),
-        );
+        )
+
+        // this._windowManagerSignals = [
+        //     global.window_manager.connect("show-tile-preview", (_, _metaWindow, _rect, _num) => {
+        //         Logger.log("SHOW TITLE PREVIEW!")
+        //     }),
+        // ];

        this._workspaceManagerSignals = [
            global.workspace_manager.connect("showing-desktop-changed", () => {
@@ -129,31 +150,45 @@ export default class WindowManager implements IWindowManager {

        this._overviewSignals = [
            Main.overview.connect("hiding", () => {
+                // this.fromOverview = true;
                Logger.log("HIDING OVERVIEW")
                this._showingOverview = false;
                this._tileMonitors();
+                // const eventObj = {
+                //     name: "focus-after-overview",
+                //     callback: () => {
+                //         Logger.log("FOCUSING AFTER OVERVIEW");
+                //     },
+                // };
+                // this.queueEvent(eventObj);
            }),
            Main.overview.connect("showing", () => {
                this._showingOverview = true;
                Logger.log("SHOWING OVERVIEW");
            }),
        ];
+
+
    }

    public disable(): void {
        Logger.log("DISABLED AEROSPIKE WINDOW MANAGER!")
+        // Disconnect the focus signal and remove any existing borders
        this.disconnectSignals();
        this.removeAllWindows();
    }

    removeAllWindows(): void {
+        // Disconnect signals from minimized windows before clearing
        this.disconnectMinimizedSignals();
        this._minimizedItems.clear();
+
        this._monitors.forEach((monitor: Monitor) => {
            monitor.removeAllWindows();
        })
    }

+
    disconnectSignals(): void {
        this.disconnectDisplaySignals();
        this.disconnectMonitorSignals();
@@ -187,6 +222,10 @@ export default class WindowManager implements IWindowManager {
        })
    }

+
+    /**
+     * Returns true if the grab op is a resize operation (any edge or corner).
+     */
    _isResizeOp(op: Meta.GrabOp): boolean {
        return op === Meta.GrabOp.RESIZING_E  ||
               op === Meta.GrabOp.RESIZING_W  ||
@@ -202,6 +241,7 @@ export default class WindowManager implements IWindowManager {
        Logger.log("Grab Op Start", op);

        if (this._isResizeOp(op)) {
+            // ── Resize drag ──────────────────────────────────────────────────
            Logger.log("Resize drag begin, op=", op);
            this._isResizeDrag = true;
            this._resizeDragWindowId = window.get_id();
@@ -209,8 +249,11 @@ export default class WindowManager implements IWindowManager {
            const [startMouseX, startMouseY] = global.get_pointer();
            this._resizeDragLastMouseX = startMouseX;
            this._resizeDragLastMouseY = startMouseY;
+            // Mark the window as dragging so safelyResizeWindow skips it while
+            // we tile the other windows in response to ratio changes.
            this._getWrappedWindow(window)?.startDragging();
        } else {
+            // ── Move drag (existing behaviour) ───────────────────────────────
            this._getWrappedWindow(window)?.startDragging();
            this._grabbedWindowMonitor = window.get_monitor();
            this._grabbedWindowId = window.get_id();
@@ -221,15 +264,19 @@ export default class WindowManager implements IWindowManager {
        Logger.log("Grab Op End ", op);

        if (this._isResizeDrag) {
+            // ── Resize drag end ──────────────────────────────────────────────
            Logger.log("Resize drag end, op=", op);
            this._isResizeDrag = false;
            this._resizeDragWindowId = _UNUSED_WINDOW_ID;
            this._resizeDragLastMouseX = 0;
            this._resizeDragLastMouseY = 0;
            this._resizeDragOp = Meta.GrabOp.NONE;
+            // Stop suppressing the window, then snap everything to computed ratios
            this._getWrappedWindow(window)?.stopDragging();
            this._tileMonitors();
        } else {
+            // ── Move drag end (existing behaviour) ───────────────────────────
+            Logger.log("primary display", display.get_primary_monitor())
            this._grabbedWindowId = _UNUSED_WINDOW_ID;
            this._getWrappedWindow(window)?.stopDragging();
            this._tileMonitors();
@@ -241,7 +288,9 @@ export default class WindowManager implements IWindowManager {
        let wrapped: WindowWrapper | undefined = undefined;
        for (const monitor of this._monitors.values()) {
            wrapped = monitor.getWindow(window.get_id());
-            if (wrapped !== undefined) break;
+            if (wrapped !== undefined) {
+                break;
+            }
        }
        return wrapped;
    }
@@ -271,13 +320,21 @@ export default class WindowManager implements IWindowManager {
    }

    public handleWindowPositionChanged(winWrap: WindowWrapper): void {
-        if (this._isTiling || this._changingGrabbedMonitor) return;
+        // Ignore position changes that we triggered ourselves via tileWindows
+        if (this._isTiling) {
+            return;
+        }
+        if (this._changingGrabbedMonitor) {
+            return;
+        }

+        // ── Live resize-drag handling ─────────────────────────────────────────
        if (this._isResizeDrag && winWrap.getWindowId() === this._resizeDragWindowId) {
            this._handleResizeDragUpdate(winWrap);
            return;
        }

+        // ── Move-drag handling (existing behaviour) ───────────────────────────
        if (winWrap.getWindowId() === this._grabbedWindowId) {
            const [mouseX, mouseY, _] = global.get_pointer();

@@ -290,14 +347,17 @@ export default class WindowManager implements IWindowManager {
                    break;
                }
            }
-            if (monitorIndex === -1) return;
+            if (monitorIndex === -1) {
+                return;
+            }

            if (monitorIndex !== this._grabbedWindowMonitor) {
                this._changingGrabbedMonitor = true;
                this._moveWindowToMonitor(winWrap.getWindow(), monitorIndex);
                this._changingGrabbedMonitor = false;
            }
-
+            // Guard _isTiling so that tileWindows() calls triggered by itemDragged
+            // (which repositions the displaced window) don't re-enter this handler.
            this._isTiling = true;
            try {
                this._monitors.get(monitorIndex)?.itemDragged(winWrap, mouseX, mouseY);
@@ -307,19 +367,29 @@ export default class WindowManager implements IWindowManager {
        }
    }

+    /**
+     * Called on every position-changed event while a resize drag is in progress.
+     * Computes the pixel delta from the drag-start rect, maps it to the correct
+     * container boundary, and calls adjustBoundary() for live feedback.
+     */
    private _handleResizeDragUpdate(winWrap: WindowWrapper): void {
        const op    = this._resizeDragOp;
        const winId = winWrap.getWindowId();

+        // Read the current mouse position — this is unclamped by the compositor
+        // and always reflects the true user intent, unlike the window's frame rect
+        // which gets clamped when adjacent windows block expansion.
        const [mouseX, mouseY] = global.get_pointer();
        const dx = mouseX - this._resizeDragLastMouseX;
        const dy = mouseY - this._resizeDragLastMouseY;

        if (dx === 0 && dy === 0) return;

+        // Update last position first so even if we return early the baseline advances
        this._resizeDragLastMouseX = mouseX;
        this._resizeDragLastMouseY = mouseY;

+        // Find the container that directly holds this window
        const container = this._findContainerForWindowAcrossMonitors(winId);
        if (!container) {
            Logger.warn("_handleResizeDragUpdate: no container found for window", winId);
@@ -329,24 +399,34 @@ export default class WindowManager implements IWindowManager {
        const itemIndex = container._getIndexOfWindow(winId);
        if (itemIndex === -1) return;

-        const isHorizontal = container._orientation === 0;
+        const isHorizontal = container._orientation === 0; // Orientation.HORIZONTAL

-        // E/S edge → boundary after the item; W/N edge → boundary before it.
+        // Map the mouse delta to the correct boundary.
+        //
+        // East/South edge → boundary AFTER  the item (boundaryIndex = itemIndex)
+        //   positive dx/dy grows this item, shrinks the next one.
+        // West/North edge → boundary BEFORE the item (boundaryIndex = itemIndex - 1)
+        //   positive dx/dy moves the left edge right, growing the left neighbour
+        //   and shrinking this item — so we negate the delta.
+
+        const minRatio = this._getMinRatio();
        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);
+                adjusted = container.adjustBoundary(itemIndex, dx, minRatio);
            } else if (op === Meta.GrabOp.RESIZING_W || op === Meta.GrabOp.RESIZING_NW || op === Meta.GrabOp.RESIZING_SW) {
-                adjusted = container.adjustBoundary(itemIndex - 1, dx);
+                adjusted = container.adjustBoundary(itemIndex - 1, dx, minRatio);
            }
        } else {
            if (op === Meta.GrabOp.RESIZING_S || op === Meta.GrabOp.RESIZING_SE || op === Meta.GrabOp.RESIZING_SW) {
-                adjusted = container.adjustBoundary(itemIndex, dy);
+                adjusted = container.adjustBoundary(itemIndex, dy, minRatio);
            } else if (op === Meta.GrabOp.RESIZING_N || op === Meta.GrabOp.RESIZING_NE || op === Meta.GrabOp.RESIZING_NW) {
-                adjusted = container.adjustBoundary(itemIndex - 1, dy);
+                adjusted = container.adjustBoundary(itemIndex - 1, dy, minRatio);
            }
        }

+        // Tile all windows with the updated ratios, guarded so the resulting
+        // position-changed events don't re-enter this handler.
        if (adjusted) {
            this._isTiling = true;
            try {
@@ -357,16 +437,21 @@ export default class WindowManager implements IWindowManager {
        }
    }

+    /**
+     * Searches all monitors for the WindowContainer that directly holds win_id.
+     */
    private _findContainerForWindowAcrossMonitors(winId: number): WindowContainer | null {
        const activeWorkspaceIndex = global.workspace_manager.get_active_workspace().index();
        for (const monitor of this._monitors.values()) {
            if (activeWorkspaceIndex >= monitor._workspaces.length) continue;
-            const container = monitor._workspaces[activeWorkspaceIndex].getContainerForWindow(winId);
+            const workspace = monitor._workspaces[activeWorkspaceIndex];
+            const container = workspace.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);
@@ -380,6 +465,7 @@ export default class WindowManager implements IWindowManager {
        this._tileMonitors()
    }

+
    public handleWindowChangedWorkspace(winWrap: WindowWrapper): void {
        const monitor = winWrap.getWindow().get_monitor();
        this._monitors.get(monitor)?.removeWindow(winWrap);
@@ -398,26 +484,41 @@ export default class WindowManager implements IWindowManager {
        this._tileMonitors();
    }

+
    handleWindowCreated(display: Meta.Display, window: Meta.Window) {
        Logger.log("WINDOW CREATED ON DISPLAY", window, display);
-        if (!this._isWindowTileable(window)) return;
+        if (!this._isWindowTileable(window)) {
+            return;
+        }
        Logger.log("WINDOW IS TILABLE");
        this.addWindowToMonitor(window);
    }

+
+    /**
+     * Handle window closed event
+     */
    handleWindowClosed(window: WindowWrapper): void {
+
        const mon_id = window._window.get_monitor();
+
        this._monitors.get(mon_id)?.removeWindow(window);
+
        window.disconnectWindowSignals()
+        // Remove from managed windows
        this.syncActiveWindow();
+        // Retile remaining windows
        this._tileMonitors();
    }

+
    public addWindowToMonitor(window: Meta.Window) {
+
        Logger.log("ADDING WINDOW TO MONITOR", window, window);
        var wrapper = new WindowWrapper(window, (winWrap) => this.handleWindowMinimized(winWrap))
        wrapper.connectWindowSignals(this);
        this._addWindowWrapperToMonitor(wrapper);
+
    }

    _addWindowWrapperToMonitor(winWrap: WindowWrapper) {
@@ -443,7 +544,7 @@ export default class WindowManager implements IWindowManager {
        "org.gnome.Shell.Extensions",
    ]

-    _isWindowTilingBlocked(window: Meta.Window): boolean {
+    _isWindowTilingBlocked(window: Meta.Window) : boolean {
        Logger.info("title", window.get_title());
        Logger.info("description", window.get_description());
        Logger.info("class", window.get_wm_class());
@@ -458,12 +559,17 @@ export default class WindowManager implements IWindowManager {
    }

    _isWindowTileable(window: Meta.Window) {
-        if (!window || !window.get_compositor_private()) return false;
-        if (this._isWindowTilingBlocked(window)) return false;

+        if (!window || !window.get_compositor_private()) {
+            return false;
+        }
+        if (this._isWindowTilingBlocked(window)) {
+            return false;
+        }
        const windowType = window.get_window_type();
        Logger.log("WINDOW TILING CHECK",);

+        // Skip certain types of windows
        return !window.is_skip_taskbar() &&
            windowType !== Meta.WindowType.DESKTOP &&
            windowType !== Meta.WindowType.DOCK &&
@@ -473,6 +579,14 @@ export default class WindowManager implements IWindowManager {
            windowType !== Meta.WindowType.MENU;
    }

+    /**
+     * Synchronizes the active window with GNOME's currently active window
+     *
+     * This function queries GNOME Shell for the current focused window and
+     * updates the extension's active window tracking to match.
+     *
+     * @returns The window ID of the active window, or null if no window is active
+     */
    public syncActiveWindow(): number | null {
        const focusWindow = global.display.focus_window;
        if (focusWindow) {
@@ -485,33 +599,102 @@ export default class WindowManager implements IWindowManager {
        return this._activeWindowId;
    }

+    /**
+     * Toggles the orientation of the active container (the container holding the active window)
+     */
    public toggleActiveContainerOrientation(): void {
        if (this._activeWindowId === null) {
            Logger.warn("No active window, cannot toggle container orientation");
            return;
        }
-        const container = this._findContainerForWindowAcrossMonitors(this._activeWindowId);
-        if (container) {
-            container.toggleOrientation();
+
+        // Find the active window's container
+        const activeContainer = this._findActiveContainer();
+        if (activeContainer) {
+            activeContainer.toggleOrientation();
        } else {
            Logger.warn("Could not find container for active window");
        }
    }

+    /**
+     * Resets all split ratios in the active window's container to equal fractions.
+     * Bound to Ctrl+Z by default.
+     */
    public resetActiveContainerRatios(): void {
        if (this._activeWindowId === null) {
            Logger.warn("No active window, cannot reset container ratios");
            return;
        }
-        const container = this._findContainerForWindowAcrossMonitors(this._activeWindowId);
-        if (container) {
+
+        const activeContainer = this._findActiveContainer();
+        if (activeContainer) {
            Logger.info("Resetting container ratios to equal splits");
-            container.resetRatios();
+            activeContainer.resetRatios();
        } else {
            Logger.warn("Could not find container for active window");
        }
    }

+    /**
+     * Finds the container that directly contains the active window
+     * @returns The container holding the active window, or null if not found
+     */
+    private _findActiveContainer(): WindowContainer | null {
+        if (this._activeWindowId === null) {
+            return null;
+        }
+
+        for (const monitor of this._monitors.values()) {
+            const activeWorkspaceIndex = global.workspace_manager.get_active_workspace().index();
+
+            // Bounds check to prevent accessing invalid workspace
+            if (activeWorkspaceIndex >= monitor._workspaces.length || activeWorkspaceIndex < 0) {
+                Logger.warn(`Active workspace index ${activeWorkspaceIndex} out of bounds for monitor with ${monitor._workspaces.length} workspaces`);
+                continue;
+            }
+
+            const workspace = monitor._workspaces[activeWorkspaceIndex];
+
+            // Check if the window is directly in the workspace container
+            const windowWrapper = workspace.getWindow(this._activeWindowId);
+            if (windowWrapper) {
+                // Try to find the parent container
+                const container = this._findContainerHoldingWindow(workspace, this._activeWindowId);
+                return container;
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * Recursively finds the container that directly contains a specific window
+     * @param container The container to search
+     * @param windowId The window ID to find
+     * @returns The container that directly contains the window, or null if not found
+     */
+    private _findContainerHoldingWindow(container: WindowContainer, windowId: number): WindowContainer | null {
+        // Check if this container directly contains the window
+        for (const item of container._tiledItems) {
+            if (item instanceof WindowContainer) {
+                // Recursively search nested containers
+                const result = this._findContainerHoldingWindow(item, windowId);
+                if (result) {
+                    return result;
+                }
+            } else if (item.getWindowId() === windowId) {
+                // Found it! Return this container as it directly holds the window
+                return container;
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * Prints the tree structure of all monitors, workspaces, containers, and windows to the logs
+     */
    public printTreeStructure(): void {
        Logger.info("=".repeat(80));
        Logger.info("WINDOW TREE STRUCTURE");
@@ -524,15 +707,19 @@ export default class WindowManager implements IWindowManager {
        this._monitors.forEach((monitor: Monitor, monitorId: number) => {
            const isActiveMonitor = this._activeWindowId !== null &&
                                   monitor.getWindow(this._activeWindowId) !== undefined;
+            const monitorMarker = isActiveMonitor ? ' *' : '';

-            Logger.info(`Monitor ${monitorId}${isActiveMonitor ? ' *' : ''}:`);
+            Logger.info(`Monitor ${monitorId}${monitorMarker}:`);
            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 ? ' *' : ''}:`);
+                const workspaceMarker = isActiveWorkspace && isActiveMonitor ? ' *' : '';
+
+                Logger.info(`  Workspace ${workspaceIndex}${workspaceMarker}:`);
                Logger.info(`    Orientation: ${workspace._orientation === 0 ? 'HORIZONTAL' : 'VERTICAL'}`);
                Logger.info(`    Items: ${workspace._tiledItems.length}`);
+
                this._printContainerTree(workspace, 4);
            });
        });
@@ -540,20 +727,31 @@ export default class WindowManager implements IWindowManager {
        Logger.info("=".repeat(80));
    }

-    private _printContainerTree(container: WindowContainer, indentLevel: number): void {
+    /**
+     * Recursively prints the container tree structure
+     * @param container The container to print
+     * @param indentLevel The indentation level (number of spaces)
+     */
+    private _printContainerTree(container: any, indentLevel: number): void {
        const indent = " ".repeat(indentLevel);

-        container._tiledItems.forEach((item, index) => {
+        container._tiledItems.forEach((item: any, index: number) => {
            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 ? ' *' : ''}:`);
+                // Check if this container contains the active window
+                const containsActiveWindow = this._activeWindowId !== null &&
+                                            item.getWindow(this._activeWindowId) !== undefined;
+                const containerMarker = containsActiveWindow ? ' *' : '';
+
+                Logger.info(`${indent}[${index}] Container (${item._orientation === 0 ? 'HORIZONTAL' : 'VERTICAL'})${containerMarker}:`);
                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() ? ' *' : ''}`);
+                const isActiveWindow = this._activeWindowId === item.getWindowId();
+                const windowMarker = isActiveWindow ? ' *' : '';
+
+                Logger.info(`${indent}[${index}] Window ID: ${item.getWindowId()}${windowMarker}`);
                Logger.info(`${indent}    Title: "${window.get_title()}"`);
                Logger.info(`${indent}    Class: ${window.get_wm_class()}`);
                const rect = item.getRect();
@@ -561,4 +759,6 @@ export default class WindowManager implements IWindowManager {
            }
        });
    }
+
+
 }
Author	SHA1	Message	Date
Lucas Oskorep	241f90299c	feat: new window gets 1/n ratio, existing windows scale proportionally Build and Test / build (pull_request) Successful in 25s Details Build and Test / release (pull_request) Has been skipped Details Previously addWindow() reset all ratios to equal splits, losing any custom sizing. Now _addRatioForNewWindow() gives the new window 1/n of the space and scales the existing windows by (n-1)/n, preserving their ratios relative to each other. e.g. [1/3, 1/6, 1/2] + new → [0.25, 0.125, 0.375, 0.25]	2026-02-24 19:23:16 -05:00
Lucas Oskorep	7083482d5c	fix: min-window-size setting now read live from Gio.Settings on every boundary adjust Previously _minRatio was baked into WindowContainer at construction time and never updated. Now adjustBoundary() takes minRatio as a parameter, WindowManager._getMinRatio() reads it from Gio.Settings on every call, and the settings reference is injected from extension.ts on enable().	2026-02-24 17:46:20 -05:00
Lucas Oskorep	99778f3ef2	feat: add reset-ratios keybinding and min-window-size setting to prefs UI	2026-02-24 17:33:30 -05:00
Lucas Oskorep	20bac71b45	feat: percentage-based container sizing with live boundary resize - Add _splitRatios[] to WindowContainer — each child owns a fraction of the parent that always sums to 1.0; bounds are computed via prefix-sum so the last item absorbs rounding remainder (no pixel gaps) - addWindow/removeWindow reset to equal splits; itemDragged swaps only items (ratios stay slot-based) so windows take the size of the slot they move into - Add adjustBoundary() for live edge-drag resizing clamped to a configurable minimum (default 10%, schema key min-window-size-percent) - Add reset-ratios keybinding (Ctrl+Z) that resets the active container to equal splits via WindowManager.resetActiveContainerRatios() - Connect size-changed signal alongside position-changed so east/south edge drags (width-only changes) are detected and the adjacent window is repositioned live - Replace LIFO pop() event queue with name-keyed Map so duplicate events collapse to the latest callback and timers never fight each other - Remove redundant move_frame() before move_resize_frame(); fix retry condition to use symmetric pixel tolerance - Add _isTiling re-entrancy guard around all tileWindows() call sites so compositor position-changed callbacks cannot recurse - Remove double tileWindows() call in monitor.tileWindows() (move() already calls it internally)	2026-02-24 17:26:27 -05:00