feat: remove crap code

.gitea/workflows/build.yaml

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

.nvmrc

@@ -1 +1 @@
-24
+v20

extension.ts

@@ -1,5 +1,5 @@
 import Meta from 'gi://Meta';
-import {Extension} from 'resource:///org/gnome/shell/extensions/extension.js';
+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 Shell from 'gi://Shell';
@@ -11,7 +11,7 @@ export default class aerospike extends Extension {
     keyBindings: Map<string, number>;
     windowManager: WindowManager;
 
-    constructor(metadata: ConstructorParameters<typeof Extension>[0]) {
+    constructor(metadata: ExtensionMetadata) {
         super(metadata);
         this.settings = this.getSettings('org.gnome.shell.extensions.aerospike');
         this.keyBindings = new Map();
@@ -20,7 +20,6 @@ export default class aerospike extends Extension {
 
     enable() {
         Logger.log("STARTING AEROSPIKE!")
-        this.windowManager._settings = this.settings;
         this.bindSettings();
         this.setupKeybindings();
         this.windowManager.enable()
@@ -54,21 +53,6 @@ export default class aerospike extends Extension {
             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', () => {
             log(`Dropdown option changed to: ${this.settings.get_string('dropdown-option')}`);
         });
@@ -104,21 +88,6 @@ export default class aerospike extends Extension {
                     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;
         }
     }
 
@@ -145,18 +114,6 @@ export default class aerospike extends Extension {
         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) {

jest.config.js

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

justfile

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

package.json

@@ -15,20 +15,11 @@
   },
   "homepage": "https://github.com/example/my-extension#readme",
   "sideEffects": false,
-  "scripts": {
-    "test": "jest",
-    "test:watch": "jest --watch",
-    "test:coverage": "jest --coverage"
-  },
   "devDependencies": {
     "@girs/gjs": "4.0.0-beta.38",
-    "@girs/gnome-shell": "49.1.0",
-    "@jest/globals": "^30.0.0",
-    "@types/jest": "^30.0.0",
+    "@girs/gnome-shell": "49.0.1",
     "eslint": "^9.36.0",
-    "eslint-plugin-jsdoc": "^62.0.0",
-    "jest": "^30.0.0",
-    "ts-jest": "^29.1.2",
+    "eslint-plugin-jsdoc": "^50.8.0",
     "typescript": "^5.9.2"
   },
   "dependencies": {

renovate.json

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

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

@@ -37,30 +37,5 @@
             <description>Keyboard shortcut for triggering action 4</description>
         </key>
 
-        <key name="print-tree" type="as">
-            <default><![CDATA[['<Super><Shift>x']]]></default>
-            <summary>Print window tree structure</summary>
-            <description>Prints the current tree of containers and windows per monitor to logs</description>
-        </key>
-
-        <key name="toggle-orientation" type="as">
-            <default><![CDATA[['<Super><Shift>comma']]]></default>
-            <summary>Toggle active container orientation</summary>
-            <description>Toggles the orientation of the container holding the active window between horizontal and vertical</description>
-        </key>
-
-        <key name="reset-ratios" type="as">
-            <default><![CDATA[['<Primary>z']]]></default>
-            <summary>Reset container ratios to equal splits</summary>
-            <description>Resets all window size ratios in the active window's container to equal splits</description>
-        </key>
-
-        <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>

src/__tests__/container.test.ts

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

src/__tests__/rect.test.ts

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

src/prefs/prefs.ts

@@ -155,67 +155,6 @@ export default class AerospikeExtensions extends ExtensionPreferences {
             })
         );
 
-        keybindingsGroup.add(
-            new EntryRow({
-                title: _('Print Tree Structure'),
-                settings: settings,
-                bind: 'print-tree',
-                map: keybindingMap
-            })
-        );
-
-        keybindingsGroup.add(
-            new EntryRow({
-                title: _('Toggle Orientation'),
-                settings: settings,
-                bind: 'toggle-orientation',
-                map: keybindingMap
-            })
-        );
-
-        keybindingsGroup.add(
-            new EntryRow({
-                title: _('Reset Container Ratios to Equal'),
-                settings: settings,
-                bind: 'reset-ratios',
-                map: keybindingMap
-            })
-        );
-
-        // 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'));
-        });
 
     }
 

src/utils/events.ts

@@ -6,23 +6,15 @@ export type QueuedEvent = {
     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();
+const queuedEvents: QueuedEvent[] = [];
 
 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);
-
+    queuedEvents.push(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);
+        const e = queuedEvents.pop()
+        if (e) {
             e.callback();
         }
-        return GLib.SOURCE_REMOVE;
+        return queuedEvents.length !== 0;
     });
-}
+}

src/wm/container.ts

@@ -9,21 +9,6 @@ enum Orientation {
     VERTICAL = 1,
 }
 
-/**
- * Build a split-ratio array of length `n` where every element equals 1/n,
- * with the last slot absorbing any floating-point remainder so the array
- * always sums to exactly 1.0.
- */
-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 {
 
@@ -31,85 +16,34 @@ export default class WindowContainer {
     _tiledWindowLookup: Map<number, WindowWrapper>;
     _orientation: Orientation = Orientation.HORIZONTAL;
     _workArea: Rect;
+    _customSizes: Map<number, number>;  // Maps window ID to custom width (horizontal) or height (vertical)
 
-    /**
-     * 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) {
+    constructor(workspaceArea: Rect,) {
+        // this._id = monitorId;
         this._tiledItems = [];
         this._tiledWindowLookup = new Map<number, WindowWrapper>();
         this._workArea = workspaceArea;
-        this._splitRatios = [];
+        this._customSizes = new Map<number, number>();
     }
 
-    // ─── 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) {
-            this._splitRatios = [1.0];
-            return;
-        }
-        const newRatio = 1 / n;
-        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
-            : this._workArea.height;
-    }
-
-    // ─── Public API ─────────────────────────────────────────────────────────────
 
     move(rect: Rect): void {
         this._workArea = rect;
         this.tileWindows();
     }
 
-    toggleOrientation(): void {
-        this._orientation = this._orientation === Orientation.HORIZONTAL
-            ? Orientation.VERTICAL
-            : Orientation.HORIZONTAL;
-        Logger.info(`Container orientation toggled to ${this._orientation === Orientation.HORIZONTAL ? 'HORIZONTAL' : 'VERTICAL'}`);
-        this.tileWindows();
-    }
-
     addWindow(winWrap: WindowWrapper): void {
+        // Add window to managed windows
         this._tiledItems.push(winWrap);
         this._tiledWindowLookup.set(winWrap.getWindowId(), winWrap);
-        this._addRatioForNewWindow();
+        // winWrap.setParent(this);
         queueEvent({
             name: "tiling-windows",
             callback: () => {
                 this.tileWindows();
             }
-        }, 100);
+        }, 100)
+
     }
 
     getWindow(win_id: number): WindowWrapper | undefined {
@@ -126,27 +60,25 @@ export default class WindowContainer {
                 return item;
             }
         }
-        return undefined;
+        return undefined
     }
 
-    _getIndexOfWindow(win_id: number): number {
+    _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;
+        return -1
     }
 
     removeWindow(win_id: number): void {
         if (this._tiledWindowLookup.has(win_id)) {
-            const index = this._getIndexOfWindow(win_id);
             this._tiledWindowLookup.delete(win_id);
-            if (index !== -1) {
-                this._tiledItems.splice(index, 1);
-            }
-            this._resetRatios();
+            this._customSizes.delete(win_id);
+            const index = this._getIndexOfWindow(win_id)
+            this._tiledItems.splice(index, 1);
         } else {
             for (const item of this._tiledItems) {
                 if (item instanceof WindowContainer) {
@@ -154,30 +86,34 @@ export default class WindowContainer {
                 }
             }
         }
-        this.tileWindows();
+        this.tileWindows()
     }
 
     disconnectSignals(): void {
         this._tiledItems.forEach((item) => {
-            if (item instanceof WindowContainer) {
-                item.disconnectSignals();
-            } else {
-                item.disconnectWindowSignals();
+                if (item instanceof WindowContainer) {
+                    item.disconnectSignals()
+                } else {
+                    item.disconnectWindowSignals();
+                }
             }
-        });
+        )
     }
 
     removeAllWindows(): void {
-        this._tiledItems = [];
-        this._tiledWindowLookup.clear();
-        this._splitRatios = [];
+        this._tiledItems = []
+        this._tiledWindowLookup.clear()
     }
 
     tileWindows() {
-        Logger.log("TILING WINDOWS IN CONTAINER");
+        Logger.log("TILING WINDOWS IN CONTAINER")
+
         Logger.log("WorkArea", this._workArea);
-        this._tileItems();
-        return true;
+
+        // Get all windows for current workspaceArea
+        this._tileItems()
+
+        return true
     }
 
     _tileItems() {
@@ -185,19 +121,16 @@ export default class WindowContainer {
             return;
         }
         const bounds = this.getBounds();
-        Logger.info(`_tileItems: ratios=[${this._splitRatios.map(r => r.toFixed(3)).join(', ')}] bounds=[${bounds.map(b => `(${b.x},${b.y},${b.width},${b.height})`).join(', ')}]`);
         this._tiledItems.forEach((item, index) => {
             const rect = bounds[index];
             if (item instanceof WindowContainer) {
                 item.move(rect);
             } else {
-                Logger.info(`_tileItems: window[${index}] id=${item.getWindowId()} dragging=${item._dragging} → rect=(${rect.x},${rect.y},${rect.width},${rect.height})`);
                 item.safelyResizeWindow(rect);
             }
-        });
+        })
     }
 
-    // ─── Bounds Calculation ──────────────────────────────────────────────────────
 
     getBounds(): Rect[] {
         if (this._orientation === Orientation.HORIZONTAL) {
@@ -207,130 +140,33 @@ export default class WindowContainer {
     }
 
     getVerticalBounds(): Rect[] {
-        const items = this._tiledItems;
-        const totalHeight = this._workArea.height;
-        let usedHeight = 0;
-
+        const items = this._tiledItems
+        const containerHeight = Math.floor(this._workArea.height / items.length);
         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;
+            const y = this._workArea.y + (index * containerHeight);
             return {
                 x: this._workArea.x,
                 y: y,
                 width: this._workArea.width,
-                height: height,
+                height: containerHeight
             } as Rect;
         });
     }
 
     getHorizontalBounds(): Rect[] {
-        const totalWidth = this._workArea.width;
-        let usedWidth = 0;
+        const windowWidth = Math.floor(this._workArea.width / this._tiledItems.length);
 
         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;
+            const x = this._workArea.x + (index * windowWidth);
             return {
                 x: x,
                 y: this._workArea.y,
-                width: width,
-                height: this._workArea.height,
+                width: windowWidth,
+                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;
-        }
-
-        const totalDim = this._totalDimension();
-        if (totalDim === 0) return false;
-
-        const ratioDelta = deltaPixels / totalDim;
-
-        const newLeft  = this._splitRatios[boundaryIndex]     + ratioDelta;
-        const newRight = this._splitRatios[boundaryIndex + 1] - ratioDelta;
-
-        if (newLeft < minRatio || newRight < minRatio) {
-            Logger.log(`adjustBoundary: clamped — newLeft=${newLeft.toFixed(3)}, newRight=${newRight.toFixed(3)}, min=${minRatio}`);
-            return false;
-        }
-
-        this._splitRatios[boundaryIndex]     = newLeft;
-        this._splitRatios[boundaryIndex + 1] = newRight;
-
-        Logger.info(`adjustBoundary: boundary=${boundaryIndex} ratios=[${this._splitRatios.map(r => r.toFixed(3)).join(', ')}]`);
-        return true;
-    }
-
-    /**
-     * 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;
-            }
-        }
-        return null;
-    }
-
     getIndexOfItemNested(item: WindowWrapper): number {
         for (let i = 0; i < this._tiledItems.length; i++) {
             const container = this._tiledItems[i];
@@ -354,30 +190,41 @@ export default class WindowContainer {
             Logger.error("Item not found in container during drag op", item.getWindowId());
             return;
         }
-        let new_index = original_index;
+        let new_index = this.getIndexOfItemNested(item);
         this.getBounds().forEach((rect, index) => {
             if (rect.x < x && rect.x + rect.width > x && rect.y < y && rect.y + rect.height > y) {
                 new_index = index;
             }
-        });
+        })
         if (original_index !== new_index) {
-            // Swap only the items — ratios stay with their slots.
-            // e.g. slot 0 = 40%, slot 1 = 60%: when the window in slot 1 drags
-            // into slot 0, it takes slot 0's 40% size. The window it displaces
-            // moves to slot 1 and takes the 60% size. The slot ratios are unchanged.
-            [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();
+            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;
+        }
+
+        const rect = window.getRect();
+        if (this._orientation === Orientation.HORIZONTAL) {
+            this._customSizes.set(win_id, rect.width);
+            Logger.log(`Window ${win_id} manually resized to width: ${rect.width}`);
+        } else {
+            this._customSizes.set(win_id, rect.height);
+            Logger.log(`Window ${win_id} manually resized to height: ${rect.height}`);
         }
     }
 
-    /**
-     * 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();
-    }
-}
+
+}

src/wm/monitor.ts

@@ -67,8 +67,8 @@ export default class Monitor {
     tileWindows(): void {
         this._workArea = global.workspace_manager.get_active_workspace().get_work_area_for_monitor(this._id);
         const activeWorkspace = global.workspace_manager.get_active_workspace();
-        // move() already calls tileWindows() internally — don't call it again
         this._workspaces[activeWorkspace.index()].move(this._workArea);
+        this._workspaces[activeWorkspace.index()].tileWindows()
     }
 
     removeWorkspace(workspaceId: number): void {
@@ -83,4 +83,15 @@ export default class Monitor {
         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;
+            }
+        }
+    }
+
 }

src/wm/window.ts

@@ -85,6 +85,11 @@ export class WindowWrapper {
 
                 }
             }),
+            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}`);
@@ -99,9 +104,6 @@ export class WindowWrapper {
             this._window.connect("position-changed", (_metaWindow) => {
                 windowManager.handleWindowPositionChanged(this);
             }),
-            this._window.connect("size-changed", (_metaWindow) => {
-                windowManager.handleWindowPositionChanged(this);
-            }),
         );
     }
 
@@ -120,41 +122,35 @@ export class WindowWrapper {
         }
     }
 
-    safelyResizeWindow(rect: Rect, _retry: number = 3): void {
+    safelyResizeWindow(rect: Rect, _retry: number = 2): void {
+        // Keep minimal logging
         if (this._dragging) {
-            Logger.info("STOPPED RESIZE BECAUSE ITEM IS BEING DRAGGED");
+            Logger.info("STOPPED RESIZE BECAUSE ITEM IS BEING DRAGGED")
             return;
         }
+        // Logger.log("SAFELY RESIZE", rect.x, rect.y, rect.width, rect.height);
+        const actor = this._window.get_compositor_private();
 
-        const actor = this._window.get_compositor_private() as Clutter.Actor | null;
         if (!actor) {
             Logger.log("No actor available, can't resize safely yet");
             return;
         }
-
-        actor.remove_all_transitions();
-
-        // Single call: move + resize atomically
+        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);
-
-        const new_rect = this._window.get_frame_rect();
-        const TOLERANCE = 2; // pixels — allow compositor rounding
-        const mismatch =
-            Math.abs(new_rect.x - rect.x) > TOLERANCE ||
-            Math.abs(new_rect.y - rect.y) > TOLERANCE ||
-            Math.abs(new_rect.width  - rect.width)  > TOLERANCE ||
-            Math.abs(new_rect.height - rect.height) > TOLERANCE;
-
-        if (_retry > 0 && mismatch) {
-            Logger.warn("RESIZE MISMATCH, retrying",
-                `want(${rect.x},${rect.y},${rect.width},${rect.height})`,
-                `got(${new_rect.x},${new_rect.y},${new_rect.width},${new_rect.height})`);
+        let new_rect = this._window.get_frame_rect();
+        if ( _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: `delayed_resize_${this.getWindowId()}`,
+                name: "attempting_delayed_resize",
                 callback: () => {
-                    this.safelyResizeWindow(rect, _retry - 1);
+                    this.safelyResizeWindow(rect, _retry-1);
                 }
-            }, 50);
+            })
         }
     }
 

src/wm/windowManager.ts

@@ -1,5 +1,5 @@
 import Meta from "gi://Meta";
-import Gio from "gi://Gio";
+// import Gio from "gi://Gio";
 // import GLib from "gi://GLib";
 
 import {WindowWrapper} from './window.js';
@@ -7,8 +7,6 @@ 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";
-import {Rect} from "../utils/rect.js";
 
 
 export interface IWindowManager {
@@ -50,23 +48,9 @@ export default class WindowManager implements IWindowManager {
 
     _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;
+    constructor() {
 
-    _settings: Gio.Settings | null = null;
 
-    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 {
@@ -80,9 +64,6 @@ export default class WindowManager implements IWindowManager {
         }
 
         this.captureExistingWindows();
-
-        // Sync the initially focused window
-        this.syncActiveWindow();
     }
 
     instantiateDisplaySignals(): void {
@@ -105,9 +86,6 @@ export default class WindowManager implements IWindowManager {
             global.display.connect('window-created', (display, window) => {
                 this.handleWindowCreated(display, window);
             }),
-            global.display.connect('notify::focus-window', () => {
-                this.syncActiveWindow();
-            }),
 
             global.display.connect("showing-desktop-changed", () => {
                 Logger.log("SHOWING DESKTOP CHANGED");
@@ -179,13 +157,10 @@ export default class WindowManager implements IWindowManager {
     }
 
     removeAllWindows(): void {
-        // Disconnect signals from minimized windows before clearing
-        this.disconnectMinimizedSignals();
-        this._minimizedItems.clear();
-
         this._monitors.forEach((monitor: Monitor) => {
             monitor.removeAllWindows();
         })
+        this._minimizedItems.clear();
     }
 
 
@@ -223,69 +198,49 @@ 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  ||
-               op === Meta.GrabOp.RESIZING_N  ||
-               op === Meta.GrabOp.RESIZING_S  ||
+    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())
+        this._getWrappedWindow(window)?.startDragging();
+        this._grabbedWindowMonitor = window.get_monitor();
+        this._grabbedWindowId = window.get_id();
+    }
+
+    _isResizeOperation(op: Meta.GrabOp): boolean {
+        // Check if the operation is any kind of resize
+        return op === Meta.GrabOp.RESIZING_E ||
+               op === Meta.GrabOp.RESIZING_W ||
+               op === Meta.GrabOp.RESIZING_N ||
+               op === Meta.GrabOp.RESIZING_S ||
                op === Meta.GrabOp.RESIZING_NE ||
                op === Meta.GrabOp.RESIZING_NW ||
                op === Meta.GrabOp.RESIZING_SE ||
                op === Meta.GrabOp.RESIZING_SW;
     }
 
-    handleGrabOpBegin(display: Meta.Display, window: Meta.Window, op: Meta.GrabOp): void {
-        Logger.log("Grab Op Start", op);
-
-        if (this._isResizeOp(op)) {
-            // ── Resize drag ──────────────────────────────────────────────────
-            Logger.log("Resize drag begin, op=", op);
-            this._isResizeDrag = true;
-            this._resizeDragWindowId = window.get_id();
-            this._resizeDragOp = op;
-            const [startMouseX, startMouseY] = global.get_pointer();
-            this._resizeDragLastMouseX = startMouseX;
-            this._resizeDragLastMouseY = startMouseY;
-            // 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();
-        }
-    }
-
     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())
 
-        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();
-            Logger.info("monitor_start and monitor_end", this._grabbedWindowMonitor, window.get_monitor());
+        const isResizing = this._isResizeOperation(op);
+
+        if (isResizing) {
+            // Window was manually resized - capture the new size
+            const monitor = this._monitors.get(window.get_monitor());
+            if (monitor) {
+                monitor.windowManuallyResized(window.get_id());
+            }
         }
+
+        this._grabbedWindowId = _UNUSED_WINDOW_ID;
+        this._getWrappedWindow(window)?.stopDragging();
+        this._tileMonitors();
+        Logger.info("monitor_start and monitor_end", this._grabbedWindowMonitor, window.get_monitor());
     }
 
     _getWrappedWindow(window: Meta.Window): WindowWrapper | undefined {
-        let wrapped: WindowWrapper | undefined = undefined;
+        let wrapped = undefined;
         for (const monitor of this._monitors.values()) {
             wrapped = monitor.getWindow(window.get_id());
             if (wrapped !== undefined) {
@@ -296,7 +251,7 @@ export default class WindowManager implements IWindowManager {
     }
 
     _getAndRemoveWrappedWindow(window: Meta.Window): WindowWrapper | undefined {
-        let wrapped: WindowWrapper | undefined = undefined;
+        let wrapped = undefined;
         for (const monitor of this._monitors.values()) {
             wrapped = monitor.getWindow(window.get_id());
             if (wrapped !== undefined) {
@@ -311,7 +266,7 @@ export default class WindowManager implements IWindowManager {
         let wrapped = this._getAndRemoveWrappedWindow(window);
         if (wrapped === undefined) {
             Logger.error("WINDOW NOT DEFINED")
-            wrapped = new WindowWrapper(window, (winWrap) => this.handleWindowMinimized(winWrap));
+            wrapped = new WindowWrapper(window, this.handleWindowMinimized);
             wrapped.connectWindowSignals(this);
         }
         let new_mon = this._monitors.get(monitorId);
@@ -320,21 +275,9 @@ export default class WindowManager implements IWindowManager {
     }
 
     public handleWindowPositionChanged(winWrap: WindowWrapper): void {
-        // Ignore position changes that we triggered ourselves via tileWindows
-        if (this._isTiling) {
-            return;
-        }
         if (this._changingGrabbedMonitor) {
             return;
         }
-
-        // ── 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();
 
@@ -348,109 +291,18 @@ export default class WindowManager implements IWindowManager {
                 }
             }
             if (monitorIndex === -1) {
-                return;
+                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);
-            } finally {
-                this._isTiling = false;
+                this._changingGrabbedMonitor = false
             }
+            this._monitors.get(monitorIndex)?.itemDragged(winWrap, mouseX, mouseY);
         }
     }
 
-    /**
-     * 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);
-            return;
-        }
-
-        const itemIndex = container._getIndexOfWindow(winId);
-        if (itemIndex === -1) return;
-
-        const isHorizontal = container._orientation === 0; // Orientation.HORIZONTAL
-
-        // Map the mouse delta to the correct boundary.
-        //
-        // East/South edge → boundary AFTER  the item (boundaryIndex = itemIndex)
-        //   positive dx/dy grows this item, shrinks the next one.
-        // West/North edge → boundary BEFORE the item (boundaryIndex = itemIndex - 1)
-        //   positive dx/dy moves the left edge right, growing the left neighbour
-        //   and shrinking this item — so we negate the delta.
-
-        const 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, minRatio);
-            } else if (op === Meta.GrabOp.RESIZING_W || op === Meta.GrabOp.RESIZING_NW || op === Meta.GrabOp.RESIZING_SW) {
-                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, minRatio);
-            } else if (op === Meta.GrabOp.RESIZING_N || op === Meta.GrabOp.RESIZING_NE || op === Meta.GrabOp.RESIZING_NW) {
-                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 {
-                container.tileWindows();
-            } finally {
-                this._isTiling = false;
-            }
-        }
-    }
-
-    /**
-     * Searches all monitors for the WindowContainer that directly holds win_id.
-     */
-    private _findContainerForWindowAcrossMonitors(winId: number): WindowContainer | null {
-        const activeWorkspaceIndex = global.workspace_manager.get_active_workspace().index();
-        for (const monitor of this._monitors.values()) {
-            if (activeWorkspaceIndex >= monitor._workspaces.length) continue;
-            const workspace = monitor._workspaces[activeWorkspaceIndex];
-            const container = workspace.getContainerForWindow(winId);
-            if (container !== null) return container;
-        }
-        return null;
-    }
-
 
     public handleWindowMinimized(winWrap: WindowWrapper): void {
         const monitor_id = winWrap.getWindow().get_monitor()
@@ -515,7 +367,7 @@ export default class WindowManager implements IWindowManager {
     public addWindowToMonitor(window: Meta.Window) {
 
         Logger.log("ADDING WINDOW TO MONITOR", window, window);
-        var wrapper = new WindowWrapper(window, (winWrap) => this.handleWindowMinimized(winWrap))
+        var wrapper = new WindowWrapper(window, this.handleWindowMinimized)
         wrapper.connectWindowSignals(this);
         this._addWindowWrapperToMonitor(wrapper);
 
@@ -530,13 +382,9 @@ export default class WindowManager implements IWindowManager {
     }
 
     _tileMonitors(): void {
-        this._isTiling = true;
-        try {
-            for (const monitor of this._monitors.values()) {
-                monitor.tileWindows();
-            }
-        } finally {
-            this._isTiling = false;
+
+        for (const monitor of this._monitors.values()) {
+            monitor.tileWindows()
         }
     }
 
@@ -588,177 +436,8 @@ export default class WindowManager implements IWindowManager {
      * @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) {
-            this._activeWindowId = focusWindow.get_id();
-            Logger.debug(`Active window changed to: ${this._activeWindowId} (${focusWindow.get_title()})`);
-        } else {
-            this._activeWindowId = null;
-            Logger.debug('No active window');
-        }
-        return this._activeWindowId;
-    }
-
-    /**
-     * Toggles the orientation of the active container (the container holding the active window)
-     */
-    public toggleActiveContainerOrientation(): void {
-        if (this._activeWindowId === null) {
-            Logger.warn("No active window, cannot toggle container orientation");
-            return;
-        }
-
-        // Find the active window's container
-        const activeContainer = this._findActiveContainer();
-        if (activeContainer) {
-            activeContainer.toggleOrientation();
-        } else {
-            Logger.warn("Could not find container for active window");
-        }
-    }
-
-    /**
-     * Resets all split ratios in the active window's container to equal fractions.
-     * Bound to Ctrl+Z by default.
-     */
-    public resetActiveContainerRatios(): void {
-        if (this._activeWindowId === null) {
-            Logger.warn("No active window, cannot reset container ratios");
-            return;
-        }
-
-        const activeContainer = this._findActiveContainer();
-        if (activeContainer) {
-            Logger.info("Resetting container ratios to equal splits");
-            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");
-        Logger.info("=".repeat(80));
-        Logger.info(`Active Window ID: ${this._activeWindowId ?? 'none'}`);
-        Logger.info("=".repeat(80));
-
-        const activeWorkspaceIndex = global.workspace_manager.get_active_workspace().index();
-
-        this._monitors.forEach((monitor: Monitor, monitorId: number) => {
-            const isActiveMonitor = this._activeWindowId !== null &&
-                                   monitor.getWindow(this._activeWindowId) !== undefined;
-            const monitorMarker = 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;
-                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);
-            });
-        });
-
-        Logger.info("=".repeat(80));
-    }
-
-    /**
-     * Recursively prints the container tree structure
-     * @param container The container to print
-     * @param indentLevel The indentation level (number of spaces)
-     */
-    private _printContainerTree(container: any, indentLevel: number): void {
-        const indent = " ".repeat(indentLevel);
-
-        container._tiledItems.forEach((item: any, index: number) => {
-            if (item instanceof WindowContainer) {
-                // Check if this container contains the active window
-                const containsActiveWindow = this._activeWindowId !== null &&
-                                            item.getWindow(this._activeWindowId) !== undefined;
-                const containerMarker = containsActiveWindow ? ' *' : '';
-
-                Logger.info(`${indent}[${index}] Container (${item._orientation === 0 ? 'HORIZONTAL' : 'VERTICAL'})${containerMarker}:`);
-                Logger.info(`${indent}    Items: ${item._tiledItems.length}`);
-                Logger.info(`${indent}    Work Area: x=${item._workArea.x}, y=${item._workArea.y}, w=${item._workArea.width}, h=${item._workArea.height}`);
-                this._printContainerTree(item, indentLevel + 4);
-            } else {
-                const window = item.getWindow();
-                const isActiveWindow = this._activeWindowId === item.getWindowId();
-                const windowMarker = isActiveWindow ? ' *' : '';
-
-                Logger.info(`${indent}[${index}] Window ID: ${item.getWindowId()}${windowMarker}`);
-                Logger.info(`${indent}    Title: "${window.get_title()}"`);
-                Logger.info(`${indent}    Class: ${window.get_wm_class()}`);
-                const rect = item.getRect();
-                Logger.info(`${indent}    Rect: x=${rect.x}, y=${rect.y}, w=${rect.width}, h=${rect.height}`);
-            }
-        });
-    }
-
 
 }

tsconfig.json

@@ -5,8 +5,6 @@
     "outDir": "./dist",
     "sourceMap": false,
     "strict": true,
-    "noImplicitAny": false,
-    "skipLibCheck": true,
     "target": "ES2022",
     "lib": [
       "ES2022"