feat: resize bug fixing

feat: adding resizing
2025-10-16 03:42:58 -04:00 · 2025-10-16 02:54:49 -04:00 · 2025-10-16 00:46:33 -04:00 · 2025-10-16 00:09:15 -04:00 · 2025-10-16 00:09:11 -04:00
21 changed files with 921 additions and 4444 deletions
--- a/.gitea/workflows/build.yaml
+++ b/.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"
--- a/.nvmrc
+++ b/.nvmrc
@@ -1 +1 @@
-24
+v20
--- a/extension.ts
+++ b/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,23 +11,18 @@ 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();
-        this.windowManager = new WindowManager(this.settings);
+        this.windowManager = new WindowManager();
    }

    enable() {
-        try {
-            Logger.log("STARTING AEROSPIKE!")
-            this.bindSettings();
-            this.setupKeybindings();
-            this.windowManager.enable()
-            Logger.log("AEROSPIKE ENABLED SUCCESSFULLY")
-        } catch (e) {
-            Logger.error("AEROSPIKE ENABLE FAILED", e);
-        }
+        Logger.log("STARTING AEROSPIKE!")
+        this.bindSettings();
+        this.setupKeybindings();
+        this.windowManager.enable()
    }

    disable() {
@@ -35,26 +30,32 @@ 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(); },
-            'toggle-tabbed':      () => { this.windowManager.toggleActiveContainerTabbed(); },
-        };
-    }

    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::reset-window-sizes', () => {
+            log(`Reset window sizes keybinding changed to: ${this.settings.get_strv('reset-window-sizes')}`);
+            this.refreshKeybinding('reset-window-sizes');
        });

        this.settings.connect('changed::dropdown-option', () => {
@@ -65,15 +66,39 @@ 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 'reset-window-sizes':
+                this.bindKeybinding('reset-window-sizes', () => {
+                    this.windowManager.resetAllWindowSizes();
+                });
+                break;
+        }
    }

    private removeKeybindings() {
@@ -84,10 +109,25 @@ 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('reset-window-sizes', () => {
+            this.windowManager.resetAllWindowSizes();
+        });
    }

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

        this.keyBindings.set(settingName, keyBindingAction);
    }
-}
+
+
+
+}
--- a/jest.config.js
+++ b/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/'],
-};
--- a/16
+++ b/16
@@ -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
@@ -28,25 +28,13 @@ install: build
 	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 --devkit

 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 \
--- a/package.json
+++ b/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",
-    "eslint": "^10.0.0",
-    "eslint-plugin-jsdoc": "^62.0.0",
-    "jest": "^30.0.0",
-    "ts-jest": "^29.1.2",
+    "@girs/gnome-shell": "49.0.1",
+    "eslint": "^9.36.0",
+    "eslint-plugin-jsdoc": "^50.8.0",
    "typescript": "^5.9.2"
  },
  "dependencies": {
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
--- a/prettyborders.zip
+++ b/prettyborders.zip
--- a/renovate.json
+++ b/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"
-    }
-  ]
-}
--- a/schemas/org.gnome.shell.extensions.aerospike.gschema.xml
+++ b/schemas/org.gnome.shell.extensions.aerospike.gschema.xml
@@ -37,28 +37,10 @@
            <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[['<Primary>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="toggle-tabbed" type="as">
-            <default><![CDATA[['<Primary>slash']]]></default>
-            <summary>Toggle tabbed container mode</summary>
-            <description>Toggles the active window's container between tabbed and accordion layout modes</description>
+        <key name="reset-window-sizes" type="as">
+            <default><![CDATA[['<Alt>z']]]></default>
+            <summary>Reset all window sizes</summary>
+            <description>Remove all custom window sizes and return to equal distribution</description>
        </key>

    </schema>
--- a/src/tests/container.test.ts
+++ b/src/tests/container.test.ts
@@ -1,260 +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 Layout {
-      HORIZONTAL = 0,
-      VERTICAL = 1,
-      TABBED = 2,
-    }
-
-    const toggleOrientation = (current: Layout): Layout => {
-      if (current === Layout.TABBED) return Layout.HORIZONTAL;
-      return current === Layout.HORIZONTAL
-        ? Layout.VERTICAL
-        : Layout.HORIZONTAL;
-    };
-
-    test('should toggle from HORIZONTAL to VERTICAL', () => {
-      const result = toggleOrientation(Layout.HORIZONTAL);
-      expect(result).toBe(Layout.VERTICAL);
-    });
-
-    test('should toggle from VERTICAL to HORIZONTAL', () => {
-      const result = toggleOrientation(Layout.VERTICAL);
-      expect(result).toBe(Layout.HORIZONTAL);
-    });
-
-    test('should toggle from TABBED to HORIZONTAL', () => {
-      const result = toggleOrientation(Layout.TABBED);
-      expect(result).toBe(Layout.HORIZONTAL);
-    });
-
-    test('enum reverse mapping should return string names', () => {
-      expect(Layout[Layout.HORIZONTAL]).toBe('HORIZONTAL');
-      expect(Layout[Layout.VERTICAL]).toBe('VERTICAL');
-      expect(Layout[Layout.TABBED]).toBe('TABBED');
-    });
-  });
-
-  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('Tabbed Bounds Calculation', () => {
-    const TAB_BAR_HEIGHT = 24;
-
-    test('should give all items the same content rect in tabbed mode', () => {
-      const workArea = { x: 100, y: 0, width: 1000, height: 500 };
-      const itemCount = 3;
-
-      const contentRect = {
-        x: workArea.x,
-        y: workArea.y + TAB_BAR_HEIGHT,
-        width: workArea.width,
-        height: workArea.height - TAB_BAR_HEIGHT,
-      };
-
-      const bounds = Array.from({ length: itemCount }, () => contentRect);
-
-      expect(bounds.length).toBe(3);
-      // All bounds should be identical
-      bounds.forEach(b => {
-        expect(b.x).toBe(100);
-        expect(b.y).toBe(TAB_BAR_HEIGHT);
-        expect(b.width).toBe(1000);
-        expect(b.height).toBe(500 - TAB_BAR_HEIGHT);
-      });
-    });
-
-    test('tab bar rect should occupy top of work area', () => {
-      const workArea = { x: 200, y: 50, width: 800, height: 600 };
-
-      const tabBarRect = {
-        x: workArea.x,
-        y: workArea.y,
-        width: workArea.width,
-        height: TAB_BAR_HEIGHT,
-      };
-
-      expect(tabBarRect.x).toBe(200);
-      expect(tabBarRect.y).toBe(50);
-      expect(tabBarRect.width).toBe(800);
-      expect(tabBarRect.height).toBe(TAB_BAR_HEIGHT);
-    });
-
-    test('active tab index should clamp after removal', () => {
-      let activeTabIndex = 2;
-      const itemCount = 2; // after removing one from 3
-
-      if (activeTabIndex >= itemCount) {
-        activeTabIndex = itemCount - 1;
-      }
-
-      expect(activeTabIndex).toBe(1);
-    });
-
-    test('active tab index should stay at 0 when first item removed', () => {
-      let activeTabIndex = 0;
-      const itemCount = 2; // after removing one from 3
-
-      if (activeTabIndex >= itemCount) {
-        activeTabIndex = itemCount - 1;
-      }
-
-      expect(activeTabIndex).toBe(0);
-    });
-  });
-
-  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']);
-    });
-  });
-});
--- a/src/tests/rect.test.ts
+++ b/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);
-  });
-});
--- a/src/prefs/prefs.ts
+++ b/src/prefs/prefs.ts
@@ -155,41 +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
-            })
-        );
-
-        keybindingsGroup.add(
-            new EntryRow({
-                title: _('Toggle Tabbed Mode'),
-                settings: settings,
-                bind: 'toggle-tabbed',
-                map: keybindingMap
-            })
-        );

    }

--- a/src/utils/events.ts
+++ b/src/utils/events.ts
@@ -1,21 +1,20 @@
 import GLib from "gi://GLib";

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

-const pendingEvents: Map<string, QueuedEvent> = new Map();
+const queuedEvents: QueuedEvent[] = [];

 export default function queueEvent(event: QueuedEvent, interval = 200) {
-    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) {
-            pendingEvents.delete(event.name);
+        const e = queuedEvents.pop()
+        if (e) {
            e.callback();
        }
-        return GLib.SOURCE_REMOVE;
+        return queuedEvents.length !== 0;
    });
-}
+}
--- a/src/wm/container.ts
+++ b/src/wm/container.ts
@@ -1,191 +1,47 @@
 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";
-import {TabBar, TAB_BAR_HEIGHT} from "./tabBar.js";

-export enum Layout {
-    ACC_HORIZONTAL = 0,
-    ACC_VERTICAL = 1,
-    TABBED = 2,
+enum Orientation {
+    HORIZONTAL = 0,
+    VERTICAL = 1,
 }

-// Returns equal ratios summing exactly to 1.0, with float drift absorbed by the last slot.
-function equalRatios(n: number): number[] {
-    if (n <= 0) return [];
-    const base = 1 / n;
-    const ratios = Array(n).fill(base);
-    const sumExceptLast = ratios.slice(0, -1).reduce((a, b) => a + b, 0);
-    ratios[n - 1] = 1 - sumExceptLast;
-    return ratios;
-}

 export default class WindowContainer {

    _tiledItems: (WindowWrapper | WindowContainer)[];
    _tiledWindowLookup: Map<number, WindowWrapper>;
-    _orientation: Layout = Layout.ACC_HORIZONTAL;
+    _orientation: Orientation = Orientation.HORIZONTAL;
    _workArea: Rect;
+    _customSizes: Map<number, number>;  // Maps index to custom width (horizontal) or height (vertical)

-    // -- Accordion Mode States
-
-    _splitRatios: number[];
-
-    // -- Tabbed mode state -----------------------------------------------------
-    _activeTabIndex: number = 0;
-    _tabBar: TabBar | null = null;
-
-    constructor(workspaceArea: Rect) {
+    constructor(workspaceArea: Rect,) {
        this._tiledItems = [];
        this._tiledWindowLookup = new Map<number, WindowWrapper>();
        this._workArea = workspaceArea;
-        this._splitRatios = [];
+        this._customSizes = new Map<number, number>();
    }

-    // --- Helpers ----------------------------------------------------------------
-
-    private _resetRatios(): void {
-        this._splitRatios = equalRatios(this._tiledItems.length);
-    }
-
-    private _addRatioForNewWindow(): void {
-        const n = this._tiledItems.length;
-        if (n <= 1) {
-            this._splitRatios = [1.0];
-            return;
-        }
-        const newRatio = 1 / n;
-        const scale = 1 - newRatio;
-        const scaled = this._splitRatios.map(r => r * scale);
-        const partialSum = scaled.reduce((a, b) => a + b, 0) + newRatio;
-        scaled[scaled.length - 1] += (1.0 - partialSum);
-        this._splitRatios = [...scaled, newRatio];
-    }
-
-    private _totalDimension(): number {
-        return this._orientation === Layout.ACC_HORIZONTAL
-            ? this._workArea.width
-            : this._workArea.height;
-    }
-
-    isTabbed(): boolean {
-        return this._orientation === Layout.TABBED;
-    }
-
-    // --- Public API -------------------------------------------------------------

    move(rect: Rect): void {
        this._workArea = rect;
-        this.drawWindows();
-    }
-
-    toggleOrientation(): void {
-        if (this._orientation === Layout.TABBED) {
-            // Tabbed → Horizontal: restore accordion mode
-            this.setAccordion(Layout.ACC_HORIZONTAL);
-        } else {
-            this._orientation = this._orientation === Layout.ACC_HORIZONTAL
-                ? Layout.ACC_VERTICAL
-                : Layout.ACC_HORIZONTAL;
-            Logger.info(`Container orientation toggled to ${Layout[this._orientation]}`);
-            this.drawWindows();
-        }
-    }
-
-    /**
-     * Switch this container to tabbed mode.
-     */
-    setTabbed(): void {
-        if (this._orientation === Layout.TABBED) return;
-
-        Logger.info("Container switching to TABBED mode");
-        this._orientation = Layout.TABBED;
-
-        // Clamp active tab index
-        if (this._activeTabIndex < 0 || this._activeTabIndex >= this._tiledItems.length) {
-            this._activeTabIndex = 0;
-        }
-
-        // Create tab bar
-        this._tabBar = new TabBar((index) => {
-            this.setActiveTab(index);
-        });
-
-        this.drawWindows();
-    }
-
-    /**
-     * Switch this container back to accordion (H or V) mode.
-     */
-    setAccordion(orientation: Layout.ACC_HORIZONTAL | Layout.ACC_VERTICAL): void {
-        if (this._orientation !== Layout.TABBED) {
-            // Already accordion — just set the orientation
-            this._orientation = orientation;
-            this.drawWindows();
-            return;
-        }
-
-        Logger.info(`Container switching from TABBED to ${Layout[orientation]}`);
-        this._orientation = orientation;
-
-        // Destroy tab bar
-        if (this._tabBar) {
-            this._tabBar.destroy();
-            this._tabBar = null;
-        }
-
-        // Show all windows (they may have been hidden in tabbed mode)
-        this._showAllWindows();
-
-        this.drawWindows();
-    }
-
-    /**
-     * Set the active tab by index. Shows that window, hides others, updates tab bar.
-     */
-    setActiveTab(index: number): void {
-        if (!this.isTabbed()) return;
-        if (index < 0 || index >= this._tiledItems.length) return;
-
-        this._activeTabIndex = index;
-        Logger.info(`Active tab set to ${index}`);
-
-        this._applyTabVisibility();
-        this._updateTabBar();
-
-        // Tile to resize the active window to the content area
-        this.drawWindows();
-    }
-
-    getActiveTabIndex(): number {
-        return this._activeTabIndex;
-    }
-
-    hideTabBar(): void {
-        this._tabBar?.hide();
-    }
-
-    showTabBar(): void {
-        if (this.isTabbed() && this._tabBar) {
-            this._tabBar.show();
-        }
+        this.tileWindows();
    }

    addWindow(winWrap: WindowWrapper): void {
+        // Add window to managed windows
        this._tiledItems.push(winWrap);
        this._tiledWindowLookup.set(winWrap.getWindowId(), winWrap);
-        this._addRatioForNewWindow();
-
-        if (this.isTabbed()) {
-            // TODO: make it so that when tabs are added they are made the current active tab
-            this._applyTabVisibility();
-            this._updateTabBar();
-        }
-
        queueEvent({
            name: "tiling-windows",
-            callback: () => this.drawWindows(),
-        }, 100);
+            callback: () => {
+                this.tileWindows();
+            }
+        }, 100)
+
    }

    getWindow(win_id: number): WindowWrapper | undefined {
@@ -195,48 +51,33 @@ 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;
            }
        }
-        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) {
-                // If removing the window that was hidden in tabbed mode,
-                // make sure to show it first so it doesn't stay invisible
-                const item = this._tiledItems[index];
-                if (item instanceof WindowWrapper) {
-                    item.showWindow();
-                }
-                this._tiledItems.splice(index, 1);
-            }
-            this._resetRatios();
-
-            if (this.isTabbed()) {
-                if (this._tiledItems.length === 0) {
-                    this._activeTabIndex = 0;
-                } else if (this._activeTabIndex >= this._tiledItems.length) {
-                    this._activeTabIndex = this._tiledItems.length - 1;
-                }
-                this._applyTabVisibility();
-                this._updateTabBar();
-            }
+            const index = this._getIndexOfWindow(win_id)
+            this._tiledItems.splice(index, 1);
+            // Shift custom sizes after removed index
+            this._shiftCustomSizesAfterRemoval(index);
        } else {
            for (const item of this._tiledItems) {
                if (item instanceof WindowContainer) {
@@ -244,243 +85,244 @@ export default class WindowContainer {
                }
            }
        }
-        this.drawWindows();
+        this.tileWindows()
+    }
+
+    _shiftCustomSizesAfterRemoval(removedIndex: number): void {
+        Logger.log(`=== _shiftCustomSizesAfterRemoval called ===`);
+        Logger.log(`Removed index: ${removedIndex}`);
+        Logger.log(`Total items after removal: ${this._tiledItems.length}`);
+        Logger.log(`Custom sizes Map size: ${this._customSizes.size}`);
+
+        // Convert Map to readable string
+        let customSizesStr = "{ ";
+        this._customSizes.forEach((size, index) => {
+            customSizesStr += `${index}: ${size}px, `;
+        });
+        customSizesStr += "}";
+        Logger.log(`Custom sizes before shift: ${customSizesStr}`);
+
+        // Calculate the removed window's size (could be custom or flexible)
+        let removedSize = this._customSizes.get(removedIndex);
+
+        if (removedSize === undefined) {
+            // Window didn't have custom size, calculate its flexible size
+            // Count items BEFORE removal (add 1 to current length)
+            const numItemsBeforeRemoval = this._tiledItems.length + 1;
+            let totalCustomSize = 0;
+            let numFlexibleItemsBeforeRemoval = 0;
+
+            this._customSizes.forEach((size, index) => {
+                totalCustomSize += size;
+                // Don't count this in flexible if it's the removed index
+            });
+            numFlexibleItemsBeforeRemoval = numItemsBeforeRemoval - this._customSizes.size;
+
+            const containerSize = this._orientation === Orientation.HORIZONTAL ? this._workArea.width : this._workArea.height;
+            const remainingSize = containerSize - totalCustomSize;
+            removedSize = numFlexibleItemsBeforeRemoval > 0 ? Math.floor(remainingSize / numFlexibleItemsBeforeRemoval) : 0;
+
+            Logger.log(`Removed window was flexible, calculated size: ${removedSize}px (${numFlexibleItemsBeforeRemoval} flexible windows before removal)`);
+        } else {
+            Logger.log(`Removed window had custom size: ${removedSize}px`);
+        }
+
+        // Rebuild the custom sizes map with shifted indices
+        const newCustomSizes = new Map<number, number>();
+        this._customSizes.forEach((size, index) => {
+            if (index < removedIndex) {
+                // Keep indices before removal
+                Logger.log(`Keeping index ${index} with size ${size}`);
+                newCustomSizes.set(index, size);
+            } else if (index > removedIndex) {
+                // Shift down indices after removal
+                Logger.log(`Shifting index ${index} -> ${index - 1} with size ${size}`);
+                newCustomSizes.set(index - 1, size);
+            }
+            // Skip the removed index
+        });
+
+        Logger.log(`New custom sizes Map size after shift: ${newCustomSizes.size}`);
+        let afterShiftStr = "{ ";
+        newCustomSizes.forEach((size, index) => {
+            afterShiftStr += `${index}: ${size}px, `;
+        });
+        afterShiftStr += "}";
+        Logger.log(`Custom sizes after index shift: ${afterShiftStr}`);
+
+        // Distribute removed window's size among remaining custom-sized windows only
+        // Flexible windows will naturally absorb their share through the bounds calculation
+        const remainingWindowCount = this._tiledItems.length;
+        const numCustomWindows = newCustomSizes.size;
+
+        if (removedSize > 0 && remainingWindowCount > 0 && numCustomWindows > 0) {
+            const sizePerCustomWindow = Math.floor(removedSize / numCustomWindows);
+
+            Logger.log(`Distributing ${removedSize}px among ${numCustomWindows} custom-sized windows (${sizePerCustomWindow}px each)`);
+            Logger.log(`Flexible windows will naturally absorb remaining space`);
+
+            // Add proportional size only to windows that already have custom sizes
+            newCustomSizes.forEach((size, index) => {
+                const newSize = size + sizePerCustomWindow;
+                Logger.log(`Index ${index}: ${size}px + ${sizePerCustomWindow}px = ${newSize}px`);
+                newCustomSizes.set(index, newSize);
+            });
+        } else {
+            Logger.log(`Not distributing space - removedSize: ${removedSize}, remainingWindows: ${remainingWindowCount}, customWindows: ${numCustomWindows}`);
+        }
+
+        let finalStr = "{ ";
+        newCustomSizes.forEach((size, index) => {
+            finalStr += `${index}: ${size}px, `;
+        });
+        finalStr += "}";
+        Logger.log(`Final custom sizes: ${finalStr}`);
+
+        this._customSizes = newCustomSizes;
+        Logger.log(`=== _shiftCustomSizesAfterRemoval complete ===`);
    }

    disconnectSignals(): void {
        this._tiledItems.forEach((item) => {
-            if (item instanceof WindowContainer) {
-                item.disconnectSignals();
-            } else {
-                item.disconnectWindowSignals();
+                if (item instanceof WindowContainer) {
+                    item.disconnectSignals()
+                } else {
+                    item.disconnectWindowSignals();
+                }
            }
-        });
+        )
    }

    removeAllWindows(): void {
-        // tabbed mode hides all windows - this ensures they are available before removal
-        this._showAllWindows();
-
-        if (this._tabBar) {
-            this._tabBar.destroy();
-            this._tabBar = null;
-        }
-
-        this._tiledItems = [];
-        this._tiledWindowLookup.clear();
-        this._splitRatios = [];
-        this._activeTabIndex = 0;
+        this._tiledItems = []
+        this._tiledWindowLookup.clear()
    }

-    drawWindows(): void {
-        Logger.log("TILING WINDOWS IN CONTAINER");
+    tileWindows(skipRetry: boolean = false) {
+        Logger.log("TILING WINDOWS IN CONTAINER")
        Logger.log("WorkArea", this._workArea);
+        this._tileItems(skipRetry)

-        if (this.isTabbed()) {
-            this._tileTab();
-        } else {
-            this._tileAccordion();
-        }
+        return true
    }

-    _tileAccordion() {
-        if (this._tiledItems.length === 0) return;
-
+    _tileItems(skipRetry: boolean = false) {
+        if (this._tiledItems.length === 0) {
+            return;
+        }
        const bounds = this.getBounds();
-        Logger.info(`_tileAccordion: 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(`_tileAccordion: window[${index}] id=${item.getWindowId()} dragging=${item._dragging} → rect=(${rect.x},${rect.y},${rect.width},${rect.height})`);
-                item.safelyResizeWindow(rect);
+                item.safelyResizeWindow(rect, 2, skipRetry);
            }
-        });
+        })
    }

-    private _tileTab(): void {
-        if (this._tiledItems.length === 0) return;
-
-        const tabBarRect: Rect = {
-            x: this._workArea.x,
-            y: this._workArea.y,
-            width: this._workArea.width,
-            height: TAB_BAR_HEIGHT,
-        };
-
-        const contentRect: Rect = {
-            x: this._workArea.x,
-            y: this._workArea.y + TAB_BAR_HEIGHT,
-            width: this._workArea.width,
-            height: this._workArea.height - TAB_BAR_HEIGHT,
-        };
-
-        // Position and show the tab bar
-        if (this._tabBar) {
-            this._tabBar.setPosition(tabBarRect);
-            if (!this._tabBar.isVisible()) {
-                this._rebuildAndShowTabBar();
-            }
-        }
-
-        this._applyTabVisibility();
-
-        const activeItem = this._tiledItems[this._activeTabIndex];
-        if (activeItem) {
-            if (activeItem instanceof WindowContainer) {
-                activeItem.move(contentRect);
-            } else {
-                Logger.info(`_tileTabbed: active tab[${this._activeTabIndex}] id=${activeItem.getWindowId()} → rect=(${contentRect.x},${contentRect.y},${contentRect.width},${contentRect.height})`);
-                activeItem.safelyResizeWindow(contentRect);
-            }
-        }
-    }
-
-    /**
-     * Show the active tab window, hide all others.
-     */
-    private _applyTabVisibility(): void {
-        this._tiledItems.forEach((item, index) => {
-            if (item instanceof WindowWrapper) {
-                if (index === this._activeTabIndex) {
-                    item.showWindow();
-                } else {
-                    item.hideWindow();
-                }
-            }
-        });
-    }
-
-    /**
-     * Show all windows (used when leaving tabbed mode).
-     */
-    private _showAllWindows(): void {
-        this._tiledItems.forEach((item) => {
-            if (item instanceof WindowWrapper) {
-                item.showWindow();
-            }
-        });
-    }
-
-    /**
-     * Rebuild the tab bar buttons and show it.
-     */
-    private _rebuildAndShowTabBar(): void {
-        if (!this._tabBar) return;
-
-        const windowItems = this._tiledItems.filter(
-            (item): item is WindowWrapper => item instanceof WindowWrapper
-        );
-
-        this._tabBar.rebuild(windowItems, this._activeTabIndex);
-        this._tabBar.show();
-    }
-
-    /**
-     * Public entry point to refresh tab titles (e.g. when a window title changes).
-     */
-    refreshTabTitles(): void {
-        this._updateTabBar();
-    }
-
-    /**
-     * Update tab bar state (active highlight, titles) without a full rebuild.
-     */
-    private _updateTabBar(): void {
-        if (!this._tabBar) return;
-
-        // Rebuild is cheap — just recreate buttons from the current items
-        const windowItems = this._tiledItems.filter(
-            (item): item is WindowWrapper => item instanceof WindowWrapper
-        );
-
-        this._tabBar.rebuild(windowItems, this._activeTabIndex);
-    }

    getBounds(): Rect[] {
-        if (this._orientation === Layout.TABBED) {
-            // In tabbed mode, all items share the same content rect
-            const contentRect: Rect = {
-                x: this._workArea.x,
-                y: this._workArea.y + TAB_BAR_HEIGHT,
-                width: this._workArea.width,
-                height: this._workArea.height - TAB_BAR_HEIGHT,
-            };
-            return this._tiledItems.map(() => contentRect);
+        if (this._orientation === Orientation.HORIZONTAL) {
+            return this.getHorizontalBounds();
        }
-
-        return this._orientation === Layout.ACC_HORIZONTAL
-            ? this._computeBounds('horizontal')
-            : this._computeBounds('vertical');
+        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[] {
+        // Calculate available height after accounting for custom-sized windows
+        let totalCustomHeight = 0;
+        let numFlexibleItems = 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;
+        this._tiledItems.forEach((item, index) => {
+            if (this._customSizes.has(index)) {
+                totalCustomHeight += this._customSizes.get(index)!;
+            } else {
+                numFlexibleItems++;
+            }
+        });

-            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};
+        // Ensure custom sizes don't exceed container height
+        if (totalCustomHeight > this._workArea.height) {
+            Logger.warn("Custom heights exceed container, resetting all sizes");
+            this._customSizes.clear();
+            totalCustomHeight = 0;
+            numFlexibleItems = this._tiledItems.length;
+        }
+
+        const remainingHeight = this._workArea.height - totalCustomHeight;
+        const flexHeight = numFlexibleItems > 0 ? Math.floor(remainingHeight / numFlexibleItems) : 0;
+
+        // Build the bounds array
+        let currentY = this._workArea.y;
+        return this._tiledItems.map((item, index) => {
+            let height = flexHeight;
+            if (this._customSizes.has(index)) {
+                height = this._customSizes.get(index)!;
+            }
+
+            const rect = {
+                x: this._workArea.x,
+                y: currentY,
+                width: this._workArea.width,
+                height: height
+            } as Rect;
+            currentY += height;
+            return rect;
        });
    }

-    adjustBoundary(boundaryIndex: number, deltaPixels: number): boolean {
-        // No boundary adjustment in tabbed mode
-        if (this.isTabbed()) return false;
+    getHorizontalBounds(): Rect[] {
+        // Calculate available width after accounting for custom-sized windows
+        let totalCustomWidth = 0;
+        let numFlexibleItems = 0;

-        if (boundaryIndex < 0 || boundaryIndex >= this._tiledItems.length - 1) {
-            Logger.warn(`adjustBoundary: invalid boundaryIndex ${boundaryIndex}`);
-            return false;
-        }
-
-        const totalDim = this._totalDimension();
-        if (totalDim === 0) return false;
-
-        const ratioDelta = deltaPixels / totalDim;
-        const newLeft = this._splitRatios[boundaryIndex] + ratioDelta;
-        const newRight = this._splitRatios[boundaryIndex + 1] - ratioDelta;
-
-        if (newLeft <= 0 || newRight <= 0) {
-            Logger.log(`adjustBoundary: clamped — newLeft=${newLeft.toFixed(3)}, newRight=${newRight.toFixed(3)}`);
-            return false;
-        }
-
-        this._splitRatios[boundaryIndex] = newLeft;
-        this._splitRatios[boundaryIndex + 1] = newRight;
-
-        Logger.info(`adjustBoundary: boundary=${boundaryIndex} ratios=[${this._splitRatios.map(r => r.toFixed(3)).join(', ')}]`);
-        return true;
-    }
-
-    // --- Container Lookup --------------------------------------------------------
-
-    getContainerForWindow(win_id: number): WindowContainer | null {
-        for (const item of this._tiledItems) {
-            if (item instanceof WindowWrapper && item.getWindowId() === win_id) {
-                return this;
-            }
-            if (item instanceof WindowContainer) {
-                const found = item.getContainerForWindow(win_id);
-                if (found !== null) return found;
+        this._tiledItems.forEach((item, index) => {
+            if (this._customSizes.has(index)) {
+                totalCustomWidth += this._customSizes.get(index)!;
+            } else {
+                numFlexibleItems++;
            }
+        });
+
+        // Ensure custom sizes don't exceed container width
+        if (totalCustomWidth > this._workArea.width) {
+            Logger.warn("Custom widths exceed container, resetting all sizes");
+            this._customSizes.clear();
+            totalCustomWidth = 0;
+            numFlexibleItems = this._tiledItems.length;
        }
-        return null;
+
+        const remainingWidth = this._workArea.width - totalCustomWidth;
+        const flexWidth = numFlexibleItems > 0 ? Math.floor(remainingWidth / numFlexibleItems) : 0;
+
+        // Build the bounds array
+        let currentX = this._workArea.x;
+        return this._tiledItems.map((item, index) => {
+            let width = flexWidth;
+            if (this._customSizes.has(index)) {
+                width = this._customSizes.get(index)!;
+            }
+
+            const rect = {
+                x: currentX,
+                y: this._workArea.y,
+                width: width,
+                height: this._workArea.height
+            } as Rect;
+            currentX += width;
+            return rect;
+        });
    }

    getIndexOfItemNested(item: WindowWrapper): number {
        for (let i = 0; i < this._tiledItems.length; i++) {
            const container = this._tiledItems[i];
            if (container instanceof WindowContainer) {
-                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;
            }
@@ -490,36 +332,153 @@ 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 {
-        // In tabbed mode, dragging reorders tabs but doesn't change layout
-        if (this.isTabbed()) {
-            // Don't reorder during tabbed mode — tabs have a fixed visual layout
-            return;
-        }
-
-        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(', ')}]`);
-            [this._tiledItems[original_index], this._tiledItems[new_index]] =
-                [this._tiledItems[new_index], this._tiledItems[original_index]];
-            this.drawWindows();
+            this._tiledItems.splice(original_index, 1);
+            this._tiledItems.splice(new_index, 0, item);
+            this.tileWindows()
+        }
+
+    }
+
+    windowManuallyResized(win_id: number): void {
+        const window = this.getWindow(win_id);
+        if (!window) {
+            // Check nested containers
+            for (const item of this._tiledItems) {
+                if (item instanceof WindowContainer) {
+                    item.windowManuallyResized(win_id);
+                }
+            }
+            return;
+        }
+
+        // Find the index of the window
+        const index = this._getIndexOfWindow(win_id);
+        if (index === -1) {
+            Logger.error("Window not found in container during resize");
+            return;
+        }
+
+        const rect = window.getRect();
+        if (this._orientation === Orientation.HORIZONTAL) {
+            this._customSizes.set(index, rect.width);
+            Logger.log(`Window at index ${index} manually resized to width: ${rect.width}`);
+        } else {
+            this._customSizes.set(index, rect.height);
+            Logger.log(`Window at index ${index} manually resized to height: ${rect.height}`);
        }
    }

-    resetRatios(): void {
-        this._resetRatios();
-        this.drawWindows();
+    resetAllWindowSizes(): void {
+        Logger.log("Clearing all custom window sizes in container");
+        this._customSizes.clear();
+        // Also clear nested containers
+        for (const item of this._tiledItems) {
+            if (item instanceof WindowContainer) {
+                item.resetAllWindowSizes();
+            }
+        }
    }
-}
+
+    windowResizing(win_id: number, resizeOp: Meta.GrabOp): void {
+        const window = this.getWindow(win_id);
+        if (!window) {
+            // Check nested containers
+            for (const item of this._tiledItems) {
+                if (item instanceof WindowContainer) {
+                    item.windowResizing(win_id, resizeOp);
+                }
+            }
+            return;
+        }
+
+        // Check if the resize direction matches the container orientation
+        const isHorizontalResize = resizeOp === Meta.GrabOp.RESIZING_E || resizeOp === Meta.GrabOp.RESIZING_W;
+        const isVerticalResize = resizeOp === Meta.GrabOp.RESIZING_N || resizeOp === Meta.GrabOp.RESIZING_S;
+
+        if ((this._orientation === Orientation.HORIZONTAL && !isHorizontalResize) ||
+            (this._orientation === Orientation.VERTICAL && !isVerticalResize)) {
+            // Resize direction doesn't match container orientation, ignore
+            return;
+        }
+
+        // Find the index of the window
+        const index = this._getIndexOfWindow(win_id);
+        if (index === -1) {
+            return;
+        }
+
+        // Get the new size
+        const rect = window.getRect();
+        const newSize = this._orientation === Orientation.HORIZONTAL ? rect.width : rect.height;
+        const oldSize = this._customSizes.get(index);
+
+        if (oldSize === undefined) {
+            // First time resizing this window, just set the size
+            this._customSizes.set(index, newSize);
+            this.tileWindows(true);
+            return;
+        }
+
+        // Calculate the delta (how much the window changed)
+        const delta = newSize - oldSize;
+
+        // If delta is 0, the window didn't actually resize (hit its minimum)
+        if (delta === 0) {
+            return;
+        }
+
+        // Determine which adjacent window to adjust based on resize direction
+        let adjacentIndex = -1;
+        if (resizeOp === Meta.GrabOp.RESIZING_E || resizeOp === Meta.GrabOp.RESIZING_S) {
+            // Resizing right/down edge - adjust the next window
+            adjacentIndex = index + 1;
+        } else if (resizeOp === Meta.GrabOp.RESIZING_W || resizeOp === Meta.GrabOp.RESIZING_N) {
+            // Resizing left/up edge - adjust the previous window
+            adjacentIndex = index - 1;
+        }
+
+        // Update current window size
+        this._customSizes.set(index, newSize);
+
+        // Adjust adjacent window only if it has a custom size
+        // When both windows have custom sizes, always apply opposite delta to maintain total width
+        let oldAdjacentSize: number | undefined = undefined;
+        if (adjacentIndex >= 0 && adjacentIndex < this._tiledItems.length &&
+            this._customSizes.has(adjacentIndex)) {
+            const adjacentItem = this._tiledItems[adjacentIndex];
+            if (adjacentItem instanceof WindowWrapper) {
+                oldAdjacentSize = this._customSizes.get(adjacentIndex)!;
+                const newAdjacentSize = oldAdjacentSize - delta;
+
+                // Check if adjacent window allows resize
+                if (!adjacentItem.getWindow().allows_resize()) {
+                    Logger.log("Adjacent window doesn't allow resize, reverting");
+                    this._customSizes.set(index, oldSize);
+                } else {
+                    // Always apply the opposite delta to the adjacent window
+                    // This keeps the total width constant
+                    this._customSizes.set(adjacentIndex, newAdjacentSize);
+                }
+            }
+        }
+
+        // Call tileWindows during resize to update all window positions
+        // Skip retry logic during active resize to avoid jitter
+        this.tileWindows(true);
+    }
+
+
+}
--- a/src/wm/monitor.ts
+++ b/src/wm/monitor.ts
@@ -1,8 +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 {

@@ -16,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));
@@ -38,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;
    }
@@ -46,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);
            }
        }
@@ -58,9 +65,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();
-        this._workArea = activeWorkspace.get_work_area_for_monitor(this._id);
-        // move() calls tileWindows() internally
        this._workspaces[activeWorkspace.index()].move(this._workArea);
    }

@@ -72,26 +78,36 @@ export default class Monitor {
        this._workspaces.push(new WindowContainer(this._workArea));
    }

-    refreshTabTitlesForWindow(winWrap: WindowWrapper): void {
-        const wsId = winWrap.getWorkspace();
-        if (wsId >= 0 && wsId < this._workspaces.length) {
-            this._workspaces[wsId].refreshTabTitles();
-        }
-    }
-
-    hideTabBars(): void {
-        for (const container of this._workspaces) {
-            container.hideTabBar();
-        }
-    }
-
-    showTabBars(): void {
-        for (const container of this._workspaces) {
-            container.showTabBar();
-        }
-    }
-
    itemDragged(item: WindowWrapper, x: number, y: number): void {
        this._workspaces[item.getWorkspace()].itemDragged(item, x, y);
    }
-}
+
+    windowManuallyResized(win_id: number): void {
+        // Find which workspace contains the window and notify it
+        for (const container of this._workspaces) {
+            const win = container.getWindow(win_id);
+            if (win) {
+                container.windowManuallyResized(win_id);
+                return;
+            }
+        }
+    }
+
+    resetAllWindowSizes(): void {
+        for (const container of this._workspaces) {
+            container.resetAllWindowSizes();
+        }
+    }
+
+    windowResizing(win_id: number, resizeOp: Meta.GrabOp): void {
+        // Find which workspace contains the window and notify it
+        for (const container of this._workspaces) {
+            const win = container.getWindow(win_id);
+            if (win) {
+                container.windowResizing(win_id, resizeOp);
+                return;
+            }
+        }
+    }
+
+}
--- a/src/wm/tabBar.ts
+++ b/src/wm/tabBar.ts
@@ -1,131 +0,0 @@
-import Clutter from 'gi://Clutter';
-import Pango from 'gi://Pango';
-import St from 'gi://St';
-import * as Main from 'resource:///org/gnome/shell/ui/main.js';
-import {Logger} from "../utils/logger.js";
-import {WindowWrapper} from "./window.js";
-import {Rect} from "../utils/rect.js";
-
-export const TAB_BAR_HEIGHT = 24;
-
-type TabClickedCallback = (index: number) => void;
-
-export class TabBar {
-    private _bar: St.BoxLayout;
-    private _buttons: St.Button[] = [];
-    private _activeIndex: number = 0;
-    private _onTabClicked: TabClickedCallback;
-    private _visible: boolean = false;
-
-    constructor(onTabClicked: TabClickedCallback) {
-        this._onTabClicked = onTabClicked;
-        this._bar = new St.BoxLayout({
-            style_class: 'aerospike-tab-bar',
-            vertical: false,
-            reactive: true,
-            can_focus: false,
-            track_hover: false,
-        });
-        // Force all tabs to equal width regardless of text length
-        (this._bar.layout_manager as Clutter.BoxLayout).homogeneous = true;
-    }
-
-    /**
-     * Rebuild all tab buttons from the current list of window items.
-     */
-    rebuild(items: WindowWrapper[], activeIndex: number): void {
-        // Remove old buttons
-        this._bar.destroy_all_children();
-        this._buttons = [];
-
-        items.forEach((item, index) => {
-            const label = new St.Label({
-                text: item.getTabLabel(),
-                style_class: 'aerospike-tab-label',
-                y_align: Clutter.ActorAlign.CENTER,
-                x_align: Clutter.ActorAlign.CENTER,
-                x_expand: true,
-            });
-            label.clutter_text.ellipsize = Pango.EllipsizeMode.END;
-
-            const button = new St.Button({
-                style_class: 'aerospike-tab',
-                reactive: true,
-                can_focus: false,
-                track_hover: true,
-                x_expand: true,
-                child: label,
-            });
-
-            button.connect('clicked', () => {
-                this._onTabClicked(index);
-            });
-
-            this._bar.add_child(button);
-            this._buttons.push(button);
-        });
-
-        this.setActive(activeIndex);
-    }
-
-    /**
-     * Update just the title text of a single tab (e.g. when a window title changes).
-     */
-    updateTabTitle(index: number, title: string): void {
-        if (index < 0 || index >= this._buttons.length) return;
-        const label = this._buttons[index].get_child() as St.Label;
-        if (label) label.set_text(title);
-    }
-
-    /**
-     * Highlight the active tab and dim the rest.
-     */
-    setActive(index: number): void {
-        this._activeIndex = index;
-        this._buttons.forEach((btn, i) => {
-            if (i === index) {
-                btn.add_style_class_name('aerospike-tab-active');
-            } else {
-                btn.remove_style_class_name('aerospike-tab-active');
-            }
-        });
-    }
-
-    /**
-     * Position and size the tab bar at the given screen rect.
-     */
-    setPosition(rect: Rect): void {
-        this._bar.set_position(rect.x, rect.y);
-        this._bar.set_size(rect.width, rect.height);
-    }
-
-    show(): void {
-        if (this._visible) return;
-        this._visible = true;
-        Main.layoutManager.uiGroup.add_child(this._bar);
-        this._bar.show();
-        Logger.log("TabBar shown");
-    }
-
-    hide(): void {
-        if (!this._visible) return;
-        this._visible = false;
-        this._bar.hide();
-        if (this._bar.get_parent()) {
-            Main.layoutManager.uiGroup.remove_child(this._bar);
-        }
-        Logger.log("TabBar hidden");
-    }
-
-    destroy(): void {
-        this.hide();
-        this._bar.destroy_all_children();
-        this._buttons = [];
-        this._bar.destroy();
-        Logger.log("TabBar destroyed");
-    }
-
-    isVisible(): boolean {
-        return this._visible;
-    }
-}
--- a/src/wm/window.ts
+++ b/src/wm/window.ts
@@ -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[] = [];
@@ -47,54 +45,49 @@ export class WindowWrapper {
        return this._window.get_frame_rect();
    }

-    getTabLabel(): string {
-        const rawAppName = this._window.get_wm_class() ?? '';
-        // Strip reverse-domain prefix (e.g. "org.gnome.Nautilus" -> "Nautilus")
-        const lastName = rawAppName.includes('.')
-            ? (rawAppName.split('.').pop() ?? rawAppName)
-            : rawAppName;
-        // Capitalize first letter
-        const appName = lastName.charAt(0).toUpperCase() + lastName.slice(1);
-        const title = this._window.get_title() ?? 'Untitled';
-        if (appName && appName.toLowerCase() !== title.toLowerCase()) {
-            return `${appName} | ${title}`;
-        }
-        return title;
-    }
-
-    hideWindow(): void {
-        const actor = this._window.get_compositor_private() as Clutter.Actor | null;
-        if (actor) actor.hide();
-    }
-
-    showWindow(): void {
-        const actor = this._window.get_compositor_private() as Clutter.Actor | null;
-        if (actor) actor.show();
-    }
-
    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::has-focus', () => {
+                if (this._window.has_focus()) {
+                    windowManager._activeWindowId = windowId;
                }
            }),
            this._window.connect('notify::maximized-horizontally', () => {
@@ -104,23 +97,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", () => {
-                windowManager.handleWindowPositionChanged(this);
-            }),
-            this._window.connect('notify::title', () => {
-                windowManager.handleWindowTitleChanged(this);
+            this._window.connect("size-changed", (_metaWindow) => {
+                windowManager.handleWindowSizeChanged(this);
            }),
        );
    }

    disconnectWindowSignals(): void {
+
        if (this._signals) {
            this._signals.forEach(signal => {
                try {
@@ -134,54 +125,35 @@ export class WindowWrapper {
        }
    }

-    safelyResizeWindow(rect: Rect, _retry: number = 3): void {
-        if (this._dragging) {
-            Logger.info("STOPPED RESIZE BECAUSE ITEM IS BEING DRAGGED");
-            return;
-        }
+    safelyResizeWindow(rect: Rect, _retry: number = 2, _skipRetry: boolean = false): void {
+        // Keep minimal logging
+        // Note: we allow resizing even during drag operations to support position updates
+        // The dragging flag only prevents REORDERING, not position/size changes
+        // Logger.log("SAFELY RESIZE", rect.x, rect.y, rect.width, rect.height);
+        const actor = this._window.get_compositor_private();

-        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();
-
-        // Move first to guarantee the window reaches the correct position even
-        // if the subsequent resize is clamped by minimum-size hints.
+        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 mismatch =
-            Math.abs(new_rect.x      - rect.x)      > WindowWrapper.RESIZE_TOLERANCE ||
-            Math.abs(new_rect.y      - rect.y)      > WindowWrapper.RESIZE_TOLERANCE ||
-            Math.abs(new_rect.width  - rect.width)  > WindowWrapper.RESIZE_TOLERANCE ||
-            Math.abs(new_rect.height - rect.height) > WindowWrapper.RESIZE_TOLERANCE;
-
-        if (_retry > 0 && mismatch) {
-            // If the window's actual size is larger than requested, it has a
-            // minimum-size constraint — retrying won't help.  Just make sure
-            // it's at the correct position with its actual size.
-            const sizeConstrained =
-                new_rect.width  > rect.width  + WindowWrapper.RESIZE_TOLERANCE ||
-                new_rect.height > rect.height + WindowWrapper.RESIZE_TOLERANCE;
-
-            if (sizeConstrained) {
-                Logger.info("Window has min-size constraint, accepting actual size",
-                    `want(${rect.x},${rect.y},${rect.width},${rect.height})`,
-                    `actual(${new_rect.x},${new_rect.y},${new_rect.width},${new_rect.height})`);
-                this._window.move_frame(true, rect.x, rect.y);
-            } else {
-                Logger.warn("RESIZE MISMATCH, retrying",
-                    `want(${rect.x},${rect.y},${rect.width},${rect.height})`,
-                    `got(${new_rect.x},${new_rect.y},${new_rect.width},${new_rect.height})`);
-                queueEvent({
-                    name: `delayed_resize_${this.getWindowId()}`,
-                    callback: () => this.safelyResizeWindow(rect, _retry - 1),
-                }, 50);
-            }
+        let new_rect = this._window.get_frame_rect();
+        if (!_skipRetry && _retry > 0 && (new_rect.x != rect.x || rect.y != new_rect.y || rect.width < new_rect.width || rect.height < new_rect.height)) {
+            Logger.warn("RESIZING FAILED AS SMALLER", new_rect.x, new_rect.y, new_rect.width, new_rect.height, rect.x, rect.y, rect.width, rect.height);
+            queueEvent({
+                name: "attempting_delayed_resize",
+                callback: () => {
+                    this.safelyResizeWindow(rect, _retry-1, _skipRetry);
+                }
+            })
        }
    }
+
+
 }
--- a/src/wm/windowManager.ts
+++ b/src/wm/windowManager.ts
@@ -1,17 +1,19 @@
 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';
 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, {Layout} from "./container.js";
-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;
@@ -22,14 +24,14 @@ export interface IWindowManager {

    handleWindowPositionChanged(winWrap: WindowWrapper): void;

-    handleWindowTitleChanged(winWrap: WindowWrapper): void;
+    handleWindowSizeChanged(winWrap: WindowWrapper): void;

    syncActiveWindow(): number | null;
 }


-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[] = [];
@@ -39,29 +41,25 @@ 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;
+    _resizingWindow: boolean = false;
+    _resizeOp: Meta.GrabOp | null = null;
+
    _showingOverview: boolean = false;

-    // -- Resize-drag tracking --------------------------------------------------
-    _isResizeDrag: boolean = false;
-    _resizeDragWindowId: number = _UNUSED_WINDOW_ID;
-    _resizeDragOp: Meta.GrabOp = Meta.GrabOp.NONE;
-    _resizeDragLastMouseX: number = 0;
-    _resizeDragLastMouseY: number = 0;
-    _isTiling: boolean = false;
+    constructor() {

-    private readonly _settings: Gio.Settings;

-    constructor(settings: Gio.Settings) {
-        this._settings = settings;
    }

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

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

        this.captureExistingWindows();
-        this.syncActiveWindow();
    }

    instantiateDisplaySignals(): void {
@@ -93,9 +90,7 @@ 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");
            }),
@@ -105,9 +100,14 @@ export default class WindowManager implements IWindowManager {
            }),
            global.display.connect("in-fullscreen-changed", () => {
                Logger.log("IN FULL SCREEN CHANGED");
-                this._syncFullscreenTabBars();
            }),
-        );
+        )
+
+        // 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", () => {
@@ -132,37 +132,42 @@ export default class WindowManager implements IWindowManager {

        this._overviewSignals = [
            Main.overview.connect("hiding", () => {
+                // this.fromOverview = true;
                Logger.log("HIDING OVERVIEW")
                this._showingOverview = false;
                this._tileMonitors();
-                for (const monitor of this._monitors.values()) {
-                    monitor.showTabBars();
-                }
+                // 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");
-                for (const monitor of this._monitors.values()) {
-                    monitor.hideTabBars();
-                }
            }),
        ];
+
+
    }

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

    removeAllWindows(): void {
-        this.disconnectMinimizedSignals();
-        this._minimizedItems.clear();
        this._monitors.forEach((monitor: Monitor) => {
            monitor.removeAllWindows();
        })
+        this._minimizedItems.clear();
    }

+
    disconnectSignals(): void {
        this.disconnectDisplaySignals();
        this.disconnectMonitorSignals();
@@ -196,67 +201,69 @@ export default class WindowManager implements IWindowManager {
        })
    }

-    _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())
+
+        const isResizing = this._isResizeOperation(op);
+        if (isResizing) {
+            this._resizingWindow = true;
+            this._resizeOp = op;
+            // Don't mark as dragging during resize - we need to update positions freely
+        } else {
+            this._getWrappedWindow(window)?.startDragging();
+        }
+
+        this._grabbedWindowMonitor = window.get_monitor();
+        this._grabbedWindowId = window.get_id();
+    }
+
+    _isResizeOperation(op: Meta.GrabOp): boolean {
+        return op === Meta.GrabOp.RESIZING_E ||
+               op === Meta.GrabOp.RESIZING_W ||
+               op === Meta.GrabOp.RESIZING_N ||
+               op === Meta.GrabOp.RESIZING_S ||
               op === Meta.GrabOp.RESIZING_NE ||
               op === Meta.GrabOp.RESIZING_NW ||
               op === Meta.GrabOp.RESIZING_SE ||
               op === Meta.GrabOp.RESIZING_SW;
    }

-    handleGrabOpBegin(display: Meta.Display, window: Meta.Window, op: Meta.GrabOp): void {
-        Logger.log("Grab Op Start", op);
-
-        if (this._isResizeOp(op)) {
-            Logger.log("Resize drag begin, op=", op);
-            this._isResizeDrag = true;
-            this._resizeDragWindowId = window.get_id();
-            this._resizeDragOp = op;
-            const [startMouseX, startMouseY] = global.get_pointer();
-            this._resizeDragLastMouseX = startMouseX;
-            this._resizeDragLastMouseY = startMouseY;
-            this._getWrappedWindow(window)?.startDragging();
-        } else {
-            this._getWrappedWindow(window)?.startDragging();
-            this._grabbedWindowMonitor = window.get_monitor();
-            this._grabbedWindowId = window.get_id();
-        }
-    }
-
    handleGrabOpEnd(display: Meta.Display, window: Meta.Window, op: Meta.GrabOp): void {
        Logger.log("Grab Op End ", op);
+        Logger.log("primary display", display.get_primary_monitor())

-        if (this._isResizeDrag) {
-            Logger.log("Resize drag end, op=", op);
-            this._isResizeDrag = false;
-            this._resizeDragWindowId = _UNUSED_WINDOW_ID;
-            this._resizeDragLastMouseX = 0;
-            this._resizeDragLastMouseY = 0;
-            this._resizeDragOp = Meta.GrabOp.NONE;
-            this._getWrappedWindow(window)?.stopDragging();
-            this._tileMonitors();
-        } else {
-            this._grabbedWindowId = _UNUSED_WINDOW_ID;
-            this._getWrappedWindow(window)?.stopDragging();
-            this._tileMonitors();
-            Logger.info("monitor_start and monitor_end", this._grabbedWindowMonitor, window.get_monitor());
+        // Check if this was a resize operation
+        if (this._isResizeOperation(op)) {
+            const monitor = this._monitors.get(window.get_monitor());
+            if (monitor) {
+                monitor.windowManuallyResized(window.get_id());
+            }
        }
+
+        this._resizingWindow = false;
+        this._resizeOp = null;
+        this._grabbedWindowId = _UNUSED_WINDOW_ID;
+        this._getWrappedWindow(window)?.stopDragging();
+        this._tileMonitors();
+        Logger.info("monitor_start and monitor_end", this._grabbedWindowMonitor, window.get_monitor());
    }

    _getWrappedWindow(window: Meta.Window): WindowWrapper | undefined {
-        let wrapped: WindowWrapper | undefined = undefined;
+        let wrapped = undefined;
        for (const monitor of this._monitors.values()) {
            wrapped = monitor.getWindow(window.get_id());
-            if (wrapped !== undefined) break;
+            if (wrapped !== undefined) {
+                break;
+            }
        }
        return wrapped;
    }

    _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) {
@@ -271,7 +278,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.bind(this));
            wrapped.connectWindowSignals(this);
        }
        let new_mon = this._monitors.get(monitorId);
@@ -280,14 +287,24 @@ export default class WindowManager implements IWindowManager {
    }

    public handleWindowPositionChanged(winWrap: WindowWrapper): void {
-        if (this._isTiling || this._changingGrabbedMonitor) return;
-
-        if (this._isResizeDrag && winWrap.getWindowId() === this._resizeDragWindowId) {
-            this._handleResizeDragUpdate(winWrap);
+        if (this._changingGrabbedMonitor) {
            return;
        }
-
        if (winWrap.getWindowId() === this._grabbedWindowId) {
+            // Check if we're doing a pure NSEW resize - if so, don't allow position-based swapping
+            if (this._resizingWindow && this._resizeOp) {
+                const isPureNSEWResize =
+                    this._resizeOp === Meta.GrabOp.RESIZING_E ||
+                    this._resizeOp === Meta.GrabOp.RESIZING_W ||
+                    this._resizeOp === Meta.GrabOp.RESIZING_N ||
+                    this._resizeOp === Meta.GrabOp.RESIZING_S;
+
+                if (isPureNSEWResize) {
+                    // Skip itemDragged - don't allow swaps during NSEW resize
+                    return;
+                }
+            }
+
            const [mouseX, mouseY, _] = global.get_pointer();

            let monitorIndex = -1;
@@ -299,82 +316,29 @@ 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;
+                this._changingGrabbedMonitor = false
            }
+            this._monitors.get(monitorIndex)?.itemDragged(winWrap, mouseX, mouseY);
+        }
+    }

-            this._isTiling = true;
-            try {
-                this._monitors.get(monitorIndex)?.itemDragged(winWrap, mouseX, mouseY);
-            } finally {
-                this._isTiling = false;
+    public handleWindowSizeChanged(winWrap: WindowWrapper): void {
+        if (this._resizingWindow && winWrap.getWindowId() === this._grabbedWindowId) {
+            // Check if this is a valid resize direction for the container
+            const monitor = this._monitors.get(winWrap.getWindow().get_monitor());
+            if (monitor && this._resizeOp) {
+                monitor.windowResizing(winWrap.getWindowId(), this._resizeOp);
            }
        }
    }

-    private _handleResizeDragUpdate(winWrap: WindowWrapper): void {
-        const op    = this._resizeDragOp;
-        const winId = winWrap.getWindowId();
-
-        const [mouseX, mouseY] = global.get_pointer();
-        const dx = mouseX - this._resizeDragLastMouseX;
-        const dy = mouseY - this._resizeDragLastMouseY;
-
-        if (dx === 0 && dy === 0) return;
-
-        this._resizeDragLastMouseX = mouseX;
-        this._resizeDragLastMouseY = mouseY;
-
-        const container = this._findContainerForWindowAcrossMonitors(winId);
-        if (!container) {
-            Logger.warn("_handleResizeDragUpdate: no container found for window", winId);
-            return;
-        }
-
-        const itemIndex = container._getIndexOfWindow(winId);
-        if (itemIndex === -1) return;
-
-        const isHorizontal = container._orientation === Layout.ACC_HORIZONTAL;
-
-        // E/S edge → boundary after the item; W/N edge → boundary before it.
-        let adjusted = false;
-        if (isHorizontal) {
-            if (op === Meta.GrabOp.RESIZING_E || op === Meta.GrabOp.RESIZING_NE || op === Meta.GrabOp.RESIZING_SE) {
-                adjusted = container.adjustBoundary(itemIndex, dx);
-            } else if (op === Meta.GrabOp.RESIZING_W || op === Meta.GrabOp.RESIZING_NW || op === Meta.GrabOp.RESIZING_SW) {
-                adjusted = container.adjustBoundary(itemIndex - 1, dx);
-            }
-        } else {
-            if (op === Meta.GrabOp.RESIZING_S || op === Meta.GrabOp.RESIZING_SE || op === Meta.GrabOp.RESIZING_SW) {
-                adjusted = container.adjustBoundary(itemIndex, dy);
-            } else if (op === Meta.GrabOp.RESIZING_N || op === Meta.GrabOp.RESIZING_NE || op === Meta.GrabOp.RESIZING_NW) {
-                adjusted = container.adjustBoundary(itemIndex - 1, dy);
-            }
-        }
-
-        if (adjusted) {
-            this._isTiling = true;
-            try {
-                container.drawWindows();
-            } finally {
-                this._isTiling = false;
-            }
-        }
-    }
-
-    private _findContainerForWindowAcrossMonitors(winId: number): WindowContainer | null {
-        const activeWorkspaceIndex = global.workspace_manager.get_active_workspace().index();
-        for (const monitor of this._monitors.values()) {
-            if (activeWorkspaceIndex >= monitor._workspaces.length) continue;
-            const container = monitor._workspaces[activeWorkspaceIndex].getContainerForWindow(winId);
-            if (container !== null) return container;
-        }
-        return null;
-    }

    public handleWindowMinimized(winWrap: WindowWrapper): void {
        const monitor_id = winWrap.getWindow().get_monitor()
@@ -389,6 +353,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);
@@ -407,31 +372,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();
    }

-    handleWindowTitleChanged(window: WindowWrapper): void {
-        const mon_id = window._window.get_monitor();
-        this._monitors.get(mon_id)?.refreshTabTitlesForWindow(window);
-    }

    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.bind(this))
        wrapper.connectWindowSignals(this);
        this._addWindowWrapperToMonitor(wrapper);
+
    }

    _addWindowWrapperToMonitor(winWrap: WindowWrapper) {
@@ -442,26 +417,10 @@ export default class WindowManager implements IWindowManager {
        }
    }

-    private _syncFullscreenTabBars(): void {
-        for (const [monitorId, monitor] of this._monitors.entries()) {
-            if (global.display.get_monitor_in_fullscreen(monitorId)) {
-                monitor.hideTabBars();
-            } else if (!this._showingOverview) {
-                monitor.showTabBars();
-            }
-        }
-    }
-
    _tileMonitors(): void {
-        this._isTiling = true;
-        try {
-            for (const monitor of this._monitors.values()) {
-                monitor.tileWindows();
-            }
-        } catch (e) {
-            Logger.error("_tileMonitors FAILED", e);
-        } finally {
-            this._isTiling = false;
+
+        for (const monitor of this._monitors.values()) {
+            monitor.tileWindows()
        }
    }

@@ -469,7 +428,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());
@@ -484,12 +443,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 &&
@@ -499,118 +463,25 @@ 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) {
-            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;
+        return null;
    }

-    public toggleActiveContainerOrientation(): void {
-        if (this._activeWindowId === null) {
-            Logger.warn("No active window, cannot toggle container orientation");
-            return;
-        }
-        const container = this._findContainerForWindowAcrossMonitors(this._activeWindowId);
-        if (container) {
-            container.toggleOrientation();
-        } else {
-            Logger.warn("Could not find container for active window");
-        }
-    }
-
-    public resetActiveContainerRatios(): void {
-        if (this._activeWindowId === null) {
-            Logger.warn("No active window, cannot reset container ratios");
-            return;
-        }
-        const container = this._findContainerForWindowAcrossMonitors(this._activeWindowId);
-        if (container) {
-            Logger.info("Resetting container ratios to equal splits");
-            container.resetRatios();
-        } else {
-            Logger.warn("Could not find container for active window");
-        }
-    }
-
-    public toggleActiveContainerTabbed(): void {
-        if (this._activeWindowId === null) {
-            Logger.warn("No active window, cannot toggle tabbed mode");
-            return;
-        }
-        const container = this._findContainerForWindowAcrossMonitors(this._activeWindowId);
-        if (container) {
-            if (container.isTabbed()) {
-                container.setAccordion(Layout.ACC_HORIZONTAL);
-            } else {
-                // Set the active tab to the focused window
-                const activeIndex = container._getIndexOfWindow(this._activeWindowId);
-                if (activeIndex !== -1) {
-                    container._activeTabIndex = activeIndex;
-                }
-                container.setTabbed();
-            }
-            this._tileMonitors();
-        } else {
-            Logger.warn("Could not find container for active window");
-        }
-    }
-
-    public printTreeStructure(): void {
-        Logger.info("=".repeat(80));
-        Logger.info("WINDOW TREE STRUCTURE");
-        Logger.info("=".repeat(80));
-        Logger.info(`Active Window ID: ${this._activeWindowId ?? 'none'}`);
-        Logger.info("=".repeat(80));
-
-        const activeWorkspaceIndex = global.workspace_manager.get_active_workspace().index();
-
-        this._monitors.forEach((monitor: Monitor, monitorId: number) => {
-            const isActiveMonitor = this._activeWindowId !== null &&
-                                   monitor.getWindow(this._activeWindowId) !== undefined;
-
-            Logger.info(`Monitor ${monitorId}${isActiveMonitor ? ' *' : ''}:`);
-            Logger.info(`  Work Area: x=${monitor._workArea.x}, y=${monitor._workArea.y}, w=${monitor._workArea.width}, h=${monitor._workArea.height}`);
-
-            monitor._workspaces.forEach((workspace, workspaceIndex) => {
-                const isActiveWorkspace = workspaceIndex === activeWorkspaceIndex;
-                Logger.info(`  Workspace ${workspaceIndex}${isActiveWorkspace && isActiveMonitor ? ' *' : ''}:`);
-                Logger.info(`    Orientation: ${Layout[workspace._orientation]}`);
-                Logger.info(`    Items: ${workspace._tiledItems.length}`);
-                if (workspace.isTabbed()) {
-                    Logger.info(`    Active Tab: ${workspace._activeTabIndex}`);
-                }
-                this._printContainerTree(workspace, 4);
-            });
+    public resetAllWindowSizes(): void {
+        Logger.log("Resetting all custom window sizes");
+        this._monitors.forEach((monitor: Monitor) => {
+            monitor.resetAllWindowSizes();
        });
-
-        Logger.info("=".repeat(80));
+        this._tileMonitors();
    }

-    private _printContainerTree(container: WindowContainer, indentLevel: number): void {
-        const indent = " ".repeat(indentLevel);

-        container._tiledItems.forEach((item, index) => {
-            if (item instanceof WindowContainer) {
-                const containsActive = this._activeWindowId !== null &&
-                                       item.getWindow(this._activeWindowId) !== undefined;
-                Logger.info(`${indent}[${index}] Container (${Layout[item._orientation]})${containsActive ? ' *' : ''}:`);
-                Logger.info(`${indent}    Items: ${item._tiledItems.length}`);
-                Logger.info(`${indent}    Work Area: x=${item._workArea.x}, y=${item._workArea.y}, w=${item._workArea.width}, h=${item._workArea.height}`);
-                this._printContainerTree(item, indentLevel + 4);
-            } else {
-                const window = item.getWindow();
-                Logger.info(`${indent}[${index}] Window ID: ${item.getWindowId()}${this._activeWindowId === item.getWindowId() ? ' *' : ''}`);
-                Logger.info(`${indent}    Title: "${window.get_title()}"`);
-                Logger.info(`${indent}    Class: ${window.get_wm_class()}`);
-                const rect = item.getRect();
-                Logger.info(`${indent}    Rect: x=${rect.x}, y=${rect.y}, w=${rect.width}, h=${rect.height}`);
-            }
-        });
-    }
 }
--- a/stylesheet.css
+++ b/stylesheet.css
@@ -1,33 +1,37 @@
-.aerospike-tab-bar {
-    background-color: rgba(30, 30, 30, 0.95);
-    border-bottom: 1px solid rgba(255, 255, 255, 0.08);
-    spacing: 1px;
-    padding: 2px 2px 0 2px;
+/* Add your custom extension styling here */
+.active-window-border {
+    /*border: 2px solid rgba(191, 0, 255, 0.8);*/
+    /*border-radius: 3px;*/
+
+/*    border-image-source: linear-gradient(to left, #743ad5, #d53a9d);*/
+/*    !*border: 4px solid transparent;*!*/
+/*    !*border-radius: 5px;*!*/
+
+/*    !*!* Gradient border using border-image *!*/
+/*    border-image: linear-gradient(45deg, red, orange, yellow, green, blue, indigo, violet) 1;*/
+
 }

-.aerospike-tab {
-    background-color: rgba(50, 50, 50, 0.8);
-    border-radius: 6px 6px 0 0;
-    padding: 2px 12px;
-    margin: 0 1px;
-    color: rgba(255, 255, 255, 0.5);
-    font-size: 11px;
-    font-weight: 400;
-    min-width: 0;
-}
+/*.border-gradient-purple {*/
+/*    border-image-source: linear-gradient(to left, #743ad5, #d53a9d);*/
+/*}*/

-.aerospike-tab:hover {
-    background-color: rgba(70, 70, 70, 0.9);
-    color: rgba(255, 255, 255, 0.8);
-}
+/*@keyframes rainbow-border {*/
+/*    0% {*/
+/*        border-image: linear-gradient(0deg, red, orange, yellow, green, blue, indigo, violet, red) 1;*/
+/*    }*/
+/*    100% {*/
+/*        border-image: linear-gradient(360deg, red, orange, yellow, green, blue, indigo, violet, red) 1;*/
+/*    }*/
+/*}*/

-.aerospike-tab-active {
-    background-color: rgba(80, 80, 80, 1);
-    color: rgba(255, 255, 255, 1);
-    font-weight: 500;
-}
+/*.active-window-border {*/
+/*    border: 4px solid transparent;*/
+/*    border-radius: 5px;*/

-.aerospike-tab-label {
-    font-size: 11px;
-    min-width: 0;
-}
+/*    !* Initial gradient border *!*/
+/*    border-image: linear-gradient(0deg, red, orange, yellow, green, blue, indigo, violet, red) 1;*/
+
+/*    !* Apply animation *!*/
+/*    animation: rainbow-border 5s linear infinite;*/
+/*}*/
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -5,8 +5,6 @@
    "outDir": "./dist",
    "sourceMap": false,
    "strict": true,
-    "noImplicitAny": false,
-    "skipLibCheck": true,
    "target": "ES2022",
    "lib": [
      "ES2022"
Author	SHA1	Message	Date
Lucas Oskorep	d911f434af	feat: resize bug fixing	2025-10-16 03:42:58 -04:00
Lucas Oskorep	5aef762e5f	feat: resize bug fixing	2025-10-16 02:54:49 -04:00
Lucas Oskorep	c4d4768d29	feat: adding resizing	2025-10-16 00:46:33 -04:00
Lucas Oskorep	fe069b1de0	feat: adding in ability to resize windows in a container	2025-10-16 00:09:15 -04:00
Lucas Oskorep	2446520ced	feat: adding in ability to resize windows in a container	2025-10-16 00:09:11 -04:00
@@ -1 +1 @@
 
 v20