chore(deps): update dependency eslint to v10.0.2

feat: equal-sized tabs and constantly updated tab titles
fix: tab bars showing when apps are fullscreen on same monitor
2026-03-02 14:13:04 +00:00 · 2026-02-27 12:24:58 -05:00 · 2026-02-26 22:06:30 -05:00 · 2026-02-26 21:45:40 -05:00 · 2026-02-26 01:54:49 -05:00 · 2026-02-25 17:18:42 -05:00
30 changed files with 5822 additions and 1608 deletions
--- a/.gitea/workflows/build.yaml
+++ b/.gitea/workflows/build.yaml
@@ -0,0 +1,99 @@
+name: Build and Test
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    branches:
+      - main
+
+jobs:
+  build:
+    runs-on: archlinux
+    container:
+      image: node:25
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v6
+
+      - name: Install pnpm and TypeScript
+        run: npm install -g pnpm typescript@5.8.3
+
+      - name: Install just
+        run: |
+          curl --proto '=https' --tlsv1.2 -sSf https://just.systems/install.sh | bash -s -- --to /usr/local/bin
+
+      - name: Install system dependencies
+        run: |
+          apt-get update
+          apt-get install -y libglib2.0-dev glib-networking zip
+
+      - name: Install project dependencies
+        run: pnpm install
+
+      - name: Run unit tests
+        run: just test
+
+      - name: Build and package extension
+        run: just build-package
+
+      - name: Upload extension package
+        uses: actions/upload-artifact@v3
+        with:
+          name: aerospike-extension
+          path: aerospike.zip
+          retention-days: 30
+
+  release:
+    needs: build
+    runs-on: archlinux
+    if: github.ref == 'refs/heads/main' && github.event_name == 'push'
+    environment:
+      name: production
+    container:
+      image: node:25
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v6
+
+      - name: Download artifact
+        uses: actions/download-artifact@v3
+        with:
+          name: aerospike-extension
+
+      - name: Get version from package.json
+        id: get_version
+        run: |
+          VERSION=$(node -p "require('./package.json').version")
+          echo "version=v${VERSION}" >> $GITHUB_OUTPUT
+
+      - name: Create Gitea Release
+        env:
+          GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}
+        run: |
+          curl -X POST \
+            -H "Authorization: token ${GITEA_TOKEN}" \
+            -H "Content-Type: application/json" \
+            -d '{
+              "tag_name": "${{ steps.get_version.outputs.version }}",
+              "name": "Release ${{ steps.get_version.outputs.version }}",
+              "body": "Automated release of aerospike GNOME extension ${{ steps.get_version.outputs.version }}\n\n## Installation\nDownload aerospike.zip and install it as a GNOME extension."
+            }' \
+            "${GITHUB_API_URL}/repos/${GITHUB_REPOSITORY}/releases"
+
+      - name: Upload Release Asset
+        env:
+          GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}
+        run: |
+          RELEASE_ID=$(curl -H "Authorization: token ${GITEA_TOKEN}" \
+            "${GITHUB_API_URL}/repos/${GITHUB_REPOSITORY}/releases/tags/${{ steps.get_version.outputs.version }}" | \
+            grep -Po '"id":\s*\K[0-9]+' | head -1)
+
+          curl -X POST \
+            -H "Authorization: token ${GITEA_TOKEN}" \
+            -H "Content-Type: multipart/form-data" \
+            -F "attachment=@aerospike.zip" \
+            "${GITHUB_API_URL}/repos/${GITHUB_REPOSITORY}/releases/${RELEASE_ID}/assets?name=aerospike.zip"
--- a/.gitignore
+++ b/.gitignore
@@ -3,3 +3,4 @@ node_modules
 dist
 /schemas/gschemas.compiled
 /aerospike.zip
+/debug.log
--- a/.nvmrc
+++ b/.nvmrc
@@ -0,0 +1 @@
+24
--- a/extension.ts
+++ b/extension.ts
@@ -1,9 +1,9 @@
 import Meta from 'gi://Meta';
-import {Extension, ExtensionMetadata} from 'resource:///org/gnome/shell/extensions/extension.js';
+import {Extension} from 'resource:///org/gnome/shell/extensions/extension.js';
 import * as Main from 'resource:///org/gnome/shell/ui/main.js';
 import Gio from 'gi://Gio';
 import Shell from 'gi://Shell';
-import WindowManager from './src/windowManager.js'
+import WindowManager from './src/wm/windowManager.js'
 import {Logger} from "./src/utils/logger.js";

 export default class aerospike extends Extension {
@@ -11,44 +11,50 @@ export default class aerospike extends Extension {
    keyBindings: Map<string, number>;
    windowManager: WindowManager;

-    constructor(metadata: ExtensionMetadata) {
+    constructor(metadata: ConstructorParameters<typeof Extension>[0]) {
        super(metadata);
        this.settings = this.getSettings('org.gnome.shell.extensions.aerospike');
        this.keyBindings = new Map();
-        this.windowManager = new WindowManager();
+        this.windowManager = new WindowManager(this.settings);
    }

    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);
+        }
    }

    disable() {
        this.windowManager.disable()
+        this.removeKeybindings()
    }

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

    private bindSettings() {
-        // Monitor settings changes
-        this.settings.connect('changed::keybinding-1', () => {
-            log(`Keybinding 1 changed to: ${this.settings.get_strv('keybinding-1')}`);
-            this.refreshKeybinding('keybinding-1');
+        const keybindings = Object.keys(this.keybindingActions());
+        keybindings.forEach(name => {
+            this.settings.connect(`changed::${name}`, () => {
+                log(`${name} keybinding changed to: ${this.settings.get_strv(name)}`);
+                this.refreshKeybinding(name);
            });
-
-        this.settings.connect('changed::keybinding-2', () => {
-            log(`Keybinding 2 changed to: ${this.settings.get_strv('keybinding-2')}`);
-            this.refreshKeybinding('keybinding-2');
-        });
-
-        this.settings.connect('changed::keybinding-3', () => {
-            log(`Keybinding 3 changed to: ${this.settings.get_strv('keybinding-3')}`);
-            this.refreshKeybinding('keybinding-3');
-        });
-
-        this.settings.connect('changed::keybinding-4', () => {
-            log(`Keybinding 4 changed to: ${this.settings.get_strv('keybinding-4')}`);
-            this.refreshKeybinding('keybinding-4');
        });

        this.settings.connect('changed::dropdown-option', () => {
@@ -59,34 +65,15 @@ export default class aerospike extends Extension {
            log(`Color selection changed to: ${this.settings.get_string('color-selection')}`);
        });
    }
+
    private refreshKeybinding(settingName: string) {
        if (this.keyBindings.has(settingName)) {
            Main.wm.removeKeybinding(settingName);
            this.keyBindings.delete(settingName);
        }

-        switch (settingName) {
-            case 'keybinding-1':
-                this.bindKeybinding('keybinding-1', () => {
-                    log('Keybinding 1 was pressed!');
-                });
-                break;
-            case 'keybinding-2':
-                this.bindKeybinding('keybinding-2', () => {
-                    log('Keybinding 2 was pressed!');
-                });
-                break;
-            case 'keybinding-3':
-                this.bindKeybinding('keybinding-3', () => {
-                    log('Keybinding 3 was pressed!');
-                });
-                break;
-            case 'keybinding-4':
-                this.bindKeybinding('keybinding-4', () => {
-                    log('Keybinding 4 was pressed!');
-                });
-                break;
-        }
+        const action = this.keybindingActions()[settingName];
+        if (action) this.bindKeybinding(settingName, action);
    }

    private removeKeybindings() {
@@ -97,21 +84,10 @@ export default class aerospike extends Extension {
    }

    private setupKeybindings() {
-        this.bindKeybinding('keybinding-1', () => {
-            log('Keybinding 1 was pressed!');
-        });
-
-        this.bindKeybinding('keybinding-2', () => {
-            log('Keybinding 2 was pressed!');
-        });
-
-        this.bindKeybinding('keybinding-3', () => {
-            log('Keybinding 3 was pressed!');
-        });
-
-        this.bindKeybinding('keybinding-4', () => {
-            log('Keybinding 4 was pressed!');
-        });
+        const actions = this.keybindingActions();
+        for (const [name, action] of Object.entries(actions)) {
+            this.bindKeybinding(name, action);
+        }
    }

    private bindKeybinding(settingName: string, callback: () => void) {
@@ -124,14 +100,11 @@ export default class aerospike extends Extension {
        const keyBindingAction = Main.wm.addKeybinding(
            settingName,
            this.settings,
-            Meta.KeyBindingFlags.IGNORE_AUTOREPEAT,
+            Meta.KeyBindingFlags.NONE,
            Shell.ActionMode.NORMAL,
            callback
        );

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

 build: packages && build-schemas
    rm -rf dist/*
-    tsc
+    pnpm exec tsc
    cp metadata.json dist/
    cp stylesheet.css dist/
    mkdir -p dist/schemas
@@ -24,16 +24,28 @@ build-package: build

 install: build
 	mkdir -p ~/.local/share/gnome-shell/extensions/{{NAME}}@{{DOMAIN}}
-	rm -rf /.local/share/gnome-shell/extensions/{{NAME}}@{{DOMAIN}}/*
+	rm -rf ~/.local/share/gnome-shell/extensions/{{NAME}}@{{DOMAIN}}/*
 	cp -r dist/* ~/.local/share/gnome-shell/extensions/{{NAME}}@{{DOMAIN}}/

 run:
-    env MUTTER_DEBUG_DUMMY_MODE_SPECS=1280x720 dbus-run-session -- gnome-shell --nested --wayland
+    env MUTTER_DEBUG_DUMMY_MODE_SPECS=1280x720 dbus-run-session -- gnome-shell --devkit --wayland

 install-and-run: install run

 live-debug:
-    journalctl /usr/bin/gnome-shell -f -o cat
+    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 \
--- a/metadata.json
+++ b/metadata.json
@@ -4,7 +4,8 @@
  "uuid": "aerospike@lucaso.io",
  "settings-schema": "org.gnome.shell.extensions.aerospike",
  "shell-version": [
-    "48"
+    "48",
+    "49"
  ],
  "gettext-domain": "aerospike@lucaso.io",
  "url": "https://gitea.chaosdev.gay/lucasoskorep/aerospike@lucaso.io"
--- a/package.json
+++ b/package.json
@@ -15,14 +15,43 @@
  },
  "homepage": "https://github.com/example/my-extension#readme",
  "sideEffects": false,
+  "scripts": {
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage"
+  },
  "devDependencies": {
-    "@girs/gjs": "^4.0.0-beta.23",
-    "@girs/gnome-shell": "^48.0.1",
-    "eslint": "^9.23.0",
-    "eslint-plugin-jsdoc": "^50.6.9",
-    "typescript": "^5.8.2"
+    "@girs/gjs": "4.0.0-beta.38",
+    "@girs/gnome-shell": "49.1.0",
+    "@jest/globals": "^30.0.0",
+    "@types/jest": "^30.0.0",
+    "eslint": "^10.0.0",
+    "eslint-plugin-jsdoc": "^62.0.0",
+    "jest": "^30.0.0",
+    "ts-jest": "^29.1.2",
+    "typescript": "^5.9.2"
  },
  "dependencies": {
-    "@girs/mtk-16": "16.0.0-4.0.0-beta.23"
+    "@girs/mtk-17": "17.0.0-4.0.0-beta.38"
+  },
+  "pnpm": {
+    "overrides": {
+      "@girs/cairo-1.0": "1.0.0-4.0.0-beta.38",
+      "@girs/freetype2-2.0": "2.0.0-4.0.0-beta.38",
+      "@girs/gdk-4.0": "4.0.0-4.0.0-beta.38",
+      "@girs/gdkpixbuf-2.0": "2.0.0-4.0.0-beta.38",
+      "@girs/gio-2.0": "2.86.0-4.0.0-beta.38",
+      "@girs/gjs": "4.0.0-beta.38",
+      "@girs/glib-2.0": "2.86.0-4.0.0-beta.38",
+      "@girs/gmodule-2.0": "2.0.0-4.0.0-beta.38",
+      "@girs/gobject-2.0": "2.86.0-4.0.0-beta.38",
+      "@girs/graphene-1.0": "1.0.0-4.0.0-beta.38",
+      "@girs/gsk-4.0": "4.0.0-4.0.0-beta.38",
+      "@girs/gtk-4.0": "4.20.1-4.0.0-beta.38",
+      "@girs/harfbuzz-0.0": "11.5.0-4.0.0-beta.38",
+      "@girs/mtk-17": "17.0.0-4.0.0-beta.38",
+      "@girs/pango-1.0": "1.57.0-4.0.0-beta.38",
+      "@girs/pangocairo-1.0": "1.0.0-4.0.0-beta.38"
+    }
  }
 }
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
--- a/prefs.ts
+++ b/prefs.ts
@@ -1,4 +1,4 @@
 // This file is just a wrapper around the compiled TypeScript code
-import MyExtensionPreferences from './src/prefs/prefs.js';
+import AerospikeExtensions from './src/prefs/prefs.js';

-export default MyExtensionPreferences;
+export default AerospikeExtensions;
--- a/prettyborders.zip
+++ b/prettyborders.zip
--- a/renovate.json
+++ b/renovate.json
@@ -0,0 +1,12 @@
+{
+  "$schema": "https://docs.renovatebot.com/renovate-schema.json",
+  "extends": [
+    "config:recommended"
+  ],
+  "packageRules": [
+    {
+      "matchPackageNames": ["actions/upload-artifact", "actions/download-artifact"],
+      "allowedVersions": "<4"
+    }
+  ]
+}
--- a/schemas/org.gnome.shell.extensions.aerospike.gschema.xml
+++ b/schemas/org.gnome.shell.extensions.aerospike.gschema.xml
@@ -1,30 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <schemalist>
    <schema id="org.gnome.shell.extensions.aerospike" path="/org/gnome/shell/extensions/aerospike/">
-        <key name="keybinding-1" type="as">
-            <default><![CDATA[['<Super>1']]]></default>
-            <summary>Keybinding for action 1</summary>
-            <description>Keyboard shortcut for triggering action 1</description>
-        </key>
-
-        <key name="keybinding-2" type="as">
-            <default><![CDATA[['<Super>2']]]></default>
-            <summary>Keybinding for action 2</summary>
-            <description>Keyboard shortcut for triggering action 2</description>
-        </key>
-
-        <key name="keybinding-3" type="as">
-            <default><![CDATA[['<Super>3']]]></default>
-            <summary>Keybinding for action 3</summary>
-            <description>Keyboard shortcut for triggering action 3</description>
-        </key>
-
-        <key name="keybinding-4" type="as">
-            <default><![CDATA[['<Super>4']]]></default>
-            <summary>Keybinding for action 4</summary>
-            <description>Keyboard shortcut for triggering action 4</description>
-        </key>
-
        <key name="dropdown-option" type="s">
            <default>'option1'</default>
            <summary>Dropdown selection</summary>
@@ -36,5 +12,54 @@
            <summary>Selected color</summary>
            <description>Color chosen from the color picker</description>
        </key>
+
+        <key name="move-left" type="as">
+            <default><![CDATA[['<Super>1']]]></default>
+            <summary>Keybinding for action 1</summary>
+            <description>Keyboard shortcut for triggering action 1</description>
+        </key>
+
+        <key name="move-right" type="as">
+            <default><![CDATA[['<Super>2']]]></default>
+            <summary>Keybinding for action 2</summary>
+            <description>Keyboard shortcut for triggering action 2</description>
+        </key>
+
+        <key name="join-with-left" type="as">
+            <default><![CDATA[['<Super>3']]]></default>
+            <summary>Keybinding for action 3</summary>
+            <description>Keyboard shortcut for triggering action 3</description>
+        </key>
+
+        <key name="join-with-right" type="as">
+            <default><![CDATA[['<Super>4']]]></default>
+            <summary>Keybinding for action 4</summary>
+            <description>Keyboard shortcut for triggering action 4</description>
+        </key>
+
+        <key name="print-tree" type="as">
+            <default><![CDATA[['<Super><Shift>x']]]></default>
+            <summary>Print window tree structure</summary>
+            <description>Prints the current tree of containers and windows per monitor to logs</description>
+        </key>
+
+        <key name="toggle-orientation" type="as">
+            <default><![CDATA[['<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>
+
    </schema>
 </schemalist>
--- a/src/tests/container.test.ts
+++ b/src/tests/container.test.ts
@@ -0,0 +1,260 @@
+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
@@ -0,0 +1,75 @@
+import { describe, test, expect } from '@jest/globals';
+import type { Rect } from '../utils/rect.js';
+
+describe('Rect Type Tests', () => {
+  test('should create a valid Rect object', () => {
+    const rect: Rect = {
+      x: 10,
+      y: 20,
+      width: 100,
+      height: 200,
+    };
+
+    expect(rect.x).toBe(10);
+    expect(rect.y).toBe(20);
+    expect(rect.width).toBe(100);
+    expect(rect.height).toBe(200);
+  });
+
+  test('should handle zero dimensions', () => {
+    const rect: Rect = {
+      x: 0,
+      y: 0,
+      width: 0,
+      height: 0,
+    };
+
+    expect(rect.width).toBe(0);
+    expect(rect.height).toBe(0);
+  });
+
+  test('should handle negative coordinates', () => {
+    const rect: Rect = {
+      x: -50,
+      y: -100,
+      width: 200,
+      height: 300,
+    };
+
+    expect(rect.x).toBe(-50);
+    expect(rect.y).toBe(-100);
+  });
+
+  test('should calculate rect area correctly', () => {
+    const rect: Rect = {
+      x: 0,
+      y: 0,
+      width: 100,
+      height: 50,
+    };
+
+    const area = rect.width * rect.height;
+    expect(area).toBe(5000);
+  });
+
+  test('should determine if point is inside rect', () => {
+    const rect: Rect = {
+      x: 10,
+      y: 10,
+      width: 100,
+      height: 100,
+    };
+
+    const pointInside = { x: 50, y: 50 };
+    const pointOutside = { x: 200, y: 200 };
+
+    const isInside = (point: { x: number; y: number }, r: Rect) =>
+      point.x >= r.x &&
+      point.x <= r.x + r.width &&
+      point.y >= r.y &&
+      point.y <= r.y + r.height;
+
+    expect(isInside(pointInside, rect)).toBe(true);
+    expect(isInside(pointOutside, rect)).toBe(false);
+  });
+});
--- a/src/monitor.ts
+++ b/src/monitor.ts
@@ -1,96 +0,0 @@
-import {WindowWrapper} from "./window.js";
-import {Logger} from "./utils/logger.js";
-import Mtk from "@girs/mtk-16";
-import Meta from "gi://Meta";
-
-
-export default class MonitorManager {
-
-    _id: number;
-    _windows: Map<number, WindowWrapper>;
-    _minimized: Map<number, WindowWrapper>;
-
-
-    constructor(monitorId: number) {
-        this._windows = new Map<number, WindowWrapper>();
-        this._minimized = new Map<number, WindowWrapper>();
-
-        this._id = monitorId;
-    }
-
-    addWindow(winWrap: WindowWrapper): void {
-        // Add window to managed windows
-        this._windows.set(winWrap.getWindowId(), winWrap);
-        this._tileWindows();
-    }
-
-    getWindow(win_id: number): WindowWrapper | undefined {
-        return this._windows.get(win_id)
-    }
-
-    removeWindow(win_id: number): void {
-        this._windows.delete(win_id)
-        this._tileWindows()
-    }
-
-    minimizeWindow(winWrap: WindowWrapper): void {
-        this._windows.delete(winWrap.getWindowId())
-        this._minimized.set(winWrap.getWindowId(), winWrap)
-    }
-
-    unminimizeWindow(winWrap: WindowWrapper): void {
-        if (this._minimized.has(winWrap.getWindowId())) {
-            this._windows.set(winWrap.getWindowId(), winWrap);
-            this._minimized.delete(winWrap.getWindowId());
-        }
-    }
-
-    removeAllWindows(): void {
-        this._windows.clear()
-    }
-
-    _tileWindows() {
-        Logger.log("TILING WINDOWS ON MONITOR", this._id)
-        const workspace = global.workspace_manager.get_active_workspace();
-        const workArea = workspace.get_work_area_for_monitor(
-            this._id
-        );
-        Logger.log("Workspace", workspace);
-        Logger.log("WorkArea", workArea);
-
-        // Get all windows for current workspace
-        const windows = Array.from(this._windows.values())
-            .filter(({_window}) => {
-
-                if (_window != null) {
-                    return _window.get_workspace() === workspace;
-                }
-            })
-            .map(x => x);
-
-        if (windows.length === 0) {
-            return;
-        }
-        this._tileHorizontally(windows, workArea)
-
-    }
-
-
-    _tileHorizontally(windows: (WindowWrapper | null)[], workArea: Mtk.Rectangle) {
-        const windowWidth = Math.floor(workArea.width / windows.length);
-
-        windows.forEach((window, index) => {
-            const x = workArea.x + (index * windowWidth);
-            const rect = {
-                x: x,
-                y: workArea.y,
-                width: windowWidth,
-                height: workArea.height
-            };
-            if (window != null) {
-                window.safelyResizeWindow(rect.x, rect.y, rect.width, rect.height);
-            }
-        });
-    }
-
-}
--- a/src/prefs/keybindings.ts
+++ b/src/prefs/keybindings.ts
@@ -0,0 +1,83 @@
+// Gnome imports
+import Adw from 'gi://Adw';
+import Gtk from 'gi://Gtk';
+import Gio from 'gi://Gio';
+import GObject from 'gi://GObject';
+import { gettext as _ } from 'resource:///org/gnome/Shell/Extensions/js/extensions/prefs.js';
+import { Logger } from '../utils/logger.js';
+
+/**
+ * EntryRow class for handling text input including keybindings
+ */
+export class EntryRow extends Adw.EntryRow {
+    static {
+        GObject.registerClass(this);
+    }
+
+    constructor(params: {
+        title: string,
+        settings: Gio.Settings,
+        bind: string,
+        map?: {
+            from: (settings: Gio.Settings, bind: string) => string,
+            to: (settings: Gio.Settings, bind: string, value: string) => void
+        }
+    }) {
+        super({ title: params.title });
+        
+        const { settings, bind, map } = params;
+
+        // When text changes, update settings
+        this.connect('changed', () => {
+            const text = this.get_text();
+            if (typeof text === 'string') {
+                if (map) {
+                    map.to(settings, bind, text);
+                } else {
+                    settings.set_string(bind, text);
+                }
+            }
+        });
+
+        // Set initial text from settings
+        const current = map ? map.from(settings, bind) : settings.get_string(bind);
+        this.set_text(current ?? '');
+
+        // Add reset button
+        this.add_suffix(
+            new ResetButton({
+                settings,
+                bind,
+                onReset: () => {
+                    this.set_text((map ? map.from(settings, bind) : settings.get_string(bind)) ?? '');
+                },
+            })
+        );
+    }
+}
+
+/**
+ * Reset button for settings
+ */
+export class ResetButton extends Gtk.Button {
+    static {
+        GObject.registerClass(this);
+    }
+
+    constructor(params: {
+        settings?: Gio.Settings,
+        bind: string,
+        onReset?: () => void
+    }) {
+        super({
+            icon_name: 'edit-clear-symbolic',
+            tooltip_text: _('Reset'),
+            valign: Gtk.Align.CENTER,
+        });
+
+        this.connect('clicked', () => {
+            params.settings?.reset(params.bind);
+            params.onReset?.();
+        });
+    }
+}
--- a/src/prefs/prefs.ts
+++ b/src/prefs/prefs.ts
@@ -3,8 +3,10 @@ import Gio from 'gi://Gio';
 import Gtk from 'gi://Gtk';
 import Gdk from 'gi://Gdk';
 import { ExtensionPreferences, gettext as _ } from 'resource:///org/gnome/Shell/Extensions/js/extensions/prefs.js';
+import {Logger} from "../utils/logger.js";
+import {EntryRow} from "./keybindings.js";

-export default class MyExtensionPreferences extends ExtensionPreferences {
+export default class AerospikeExtensions extends ExtensionPreferences {
    async fillPreferencesWindow(window: Adw.PreferencesWindow) {
        // Create settings object
        const settings = this.getSettings('org.gnome.shell.extensions.aerospike');
@@ -16,17 +18,6 @@ export default class MyExtensionPreferences extends ExtensionPreferences {
        });
        window.add(page);

-        // Create keybindings group
-        const keybindingsGroup = new Adw.PreferencesGroup({
-            title: _('Keyboard Shortcuts'),
-        });
-        page.add(keybindingsGroup);
-
-        // Add keybinding rows
-        this.addKeybindingRow(keybindingsGroup, settings, 'keybinding-1', _('Action 1'));
-        this.addKeybindingRow(keybindingsGroup, settings, 'keybinding-2', _('Action 2'));
-        this.addKeybindingRow(keybindingsGroup, settings, 'keybinding-3', _('Action 3'));
-        this.addKeybindingRow(keybindingsGroup, settings, 'keybinding-4', _('Action 4'));

        // Create options group
        const optionsGroup = new Adw.PreferencesGroup({
@@ -114,79 +105,117 @@ export default class MyExtensionPreferences extends ExtensionPreferences {
            const color = colorButton.get_rgba().to_string();
            settings.set_string('color-selection', color);
        });
+
+        // Create keybindings group
+        const keybindingsGroup = new Adw.PreferencesGroup({
+            title: _('Keyboard Shortcuts'),
+            description: `${_("Syntax")}: <Super>h, <Shift>g, <Super><Shift>h
+            ${_("Legend")}: <Super> - ${_("Windows key")}, <Primary> - ${_("Control key")}
+            ${_("Delete text to unset. Press Return key to accept.")}`,
+        });
+        page.add(keybindingsGroup);
+
+        // Add keybinding rows as EntryRows with proper mapping
+        // Use the helper function to create the map object
+        const keybindingMap = this.createKeybindingMap();
+        
+        keybindingsGroup.add(
+            new EntryRow({
+                title: _('Action 1'),
+                settings: settings,
+                bind: 'move-left',
+                map: keybindingMap
+            })
+        );
+        
+        keybindingsGroup.add(
+            new EntryRow({
+                title: _('Action 2'),
+                settings: settings,
+                bind: 'move-right',
+                map: keybindingMap
+            })
+        );
+        
+        keybindingsGroup.add(
+            new EntryRow({
+                title: _('Action 3'),
+                settings: settings,
+                bind: 'join-with-left',
+                map: keybindingMap
+            })
+        );
+        
+        keybindingsGroup.add(
+            new EntryRow({
+                title: _('Action 4'),
+                settings: settings,
+                bind: 'join-with-right',
+                map: keybindingMap
+            })
+        );
+
+        keybindingsGroup.add(
+            new EntryRow({
+                title: _('Print Tree Structure'),
+                settings: settings,
+                bind: 'print-tree',
+                map: keybindingMap
+            })
+        );
+
+        keybindingsGroup.add(
+            new EntryRow({
+                title: _('Toggle Orientation'),
+                settings: settings,
+                bind: 'toggle-orientation',
+                map: keybindingMap
+            })
+        );
+
+        keybindingsGroup.add(
+            new EntryRow({
+                title: _('Reset Container Ratios to Equal'),
+                settings: settings,
+                bind: 'reset-ratios',
+                map: keybindingMap
+            })
+        );
+
+        keybindingsGroup.add(
+            new EntryRow({
+                title: _('Toggle Tabbed Mode'),
+                settings: settings,
+                bind: 'toggle-tabbed',
+                map: keybindingMap
+            })
+        );
+
    }

-    private addKeybindingRow(
-        group: Adw.PreferencesGroup,
-        settings: Gio.Settings,
-        key: string,
-        title: string
-    ) {
-        const shortcutsRow = new Adw.ActionRow({
-            title: title,
+    // Helper function to create a keybinding mapping object
+    private createKeybindingMap() {
+        return {
+            from(settings: Gio.Settings, bind: string) {
+                return settings.get_strv(bind).join(',');
+            },
+            to(settings: Gio.Settings, bind: string, value: string) {
+                if (!!value) {
+                    const mappings = value.split(',').map((x) => {
+                        const [, key, mods] = Gtk.accelerator_parse(x);
+                        return Gtk.accelerator_valid(key, mods) && Gtk.accelerator_name(key, mods);
                    });
-
-        group.add(shortcutsRow);
-
-        // Create a button for setting shortcuts
-        const shortcutButton = new Gtk.Button({
-            valign: Gtk.Align.CENTER,
-            label: settings.get_strv(key)[0] || _("Disabled")
-        });
-
-        shortcutsRow.add_suffix(shortcutButton);
-        shortcutsRow.set_activatable_widget(shortcutButton);
-
-        // When clicking the button, show a dialog or start listening for keystroke
-        shortcutButton.connect('clicked', () => {
-            // Show a simple popup stating that the shortcut is being recorded
-            const dialog = new Gtk.MessageDialog({
-                modal: true,
-                text: _("Press a key combination to set as shortcut"),
-                secondary_text: _("Press Esc to cancel or Backspace to disable"),
-                buttons: Gtk.ButtonsType.CANCEL,
-                transient_for: group.get_root() as Gtk.Window
-            });
-
-            // Create a keypress event controller
-            const controller = new Gtk.EventControllerKey();
-            dialog.add_controller(controller);
-
-            controller.connect('key-pressed', (_controller, keyval, keycode, state) => {
-                // Get the key name
-                let keyName = Gdk.keyval_name(keyval);
-
-                // Handle special cases
-                if (keyName === 'Escape') {
-                    dialog.response(Gtk.ResponseType.CANCEL);
-                    return Gdk.EVENT_STOP;
-                } else if (keyName === 'BackSpace') {
-                    // Clear the shortcut
-                    settings.set_strv(key, []);
-                    shortcutButton.set_label(_("Disabled"));
-                    dialog.response(Gtk.ResponseType.OK);
-                    return Gdk.EVENT_STOP;
+                    // Filter out any false values to ensure we only have strings
+                    const stringMappings = mappings.filter((x): x is string => typeof x === 'string');
+                    if (stringMappings.length > 0) {
+                        Logger.debug("setting", bind, "to", stringMappings);
+                        settings.set_strv(bind, stringMappings);
                    }
-
-                // Convert modifier state to keybinding modifiers
-                let modifiers = state & Gtk.accelerator_get_default_mod_mask();
-
-                // Ignore standalone modifier keys
-                if (Gdk.ModifierType.SHIFT_MASK <= keyval && keyval <= Gdk.ModifierType.META_MASK)
-                    return Gdk.EVENT_STOP;
-
-                // Create accelerator string
-                let accelerator = Gtk.accelerator_name(keyval, modifiers);
-                if (accelerator) {
-                    settings.set_strv(key, [accelerator]);
-                    shortcutButton.set_label(accelerator);
-                    dialog.response(Gtk.ResponseType.OK);
+                } else {
+                    // If value deleted, unset the mapping
+                    settings.set_strv(bind, []);
                }
-
-                return Gdk.EVENT_STOP;
-            });
-
-            dialog.present();
-        });
+            },
+        };
    }
 }
--- a/src/utils/events.ts
+++ b/src/utils/events.ts
@@ -0,0 +1,21 @@
+import GLib from "gi://GLib";
+
+export type QueuedEvent = {
+    name: string;
+    callback: () => void;
+}
+
+const pendingEvents: Map<string, QueuedEvent> = new Map();
+
+export default function queueEvent(event: QueuedEvent, interval = 200) {
+    pendingEvents.set(event.name, event);
+
+    GLib.timeout_add(GLib.PRIORITY_DEFAULT, interval, () => {
+        const e = pendingEvents.get(event.name);
+        if (e && e === event) {
+            pendingEvents.delete(event.name);
+            e.callback();
+        }
+        return GLib.SOURCE_REMOVE;
+    });
+}
--- a/src/utils/rect.ts
+++ b/src/utils/rect.ts
@@ -0,0 +1,6 @@
+export type Rect = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
--- a/src/window.ts
+++ b/src/window.ts
@@ -1,231 +0,0 @@
-import Meta from 'gi://Meta';
-import GLib from "gi://GLib";
-import Clutter from "gi://Clutter";
-import {IWindowManager} from "./windowManager.js";
-import {Logger} from "./utils/logger.js";
-
-export type Signal = {
-    name: string;
-    id: number;
-}
-
-type WindowMinimizedHandler = (window: WindowWrapper) => void;
-
-export class WindowWrapper {
-    readonly _window: Meta.Window;
-    readonly _windowMinimizedHandler: WindowMinimizedHandler;
-    readonly _signals: Signal[];
-
-    constructor(window: Meta.Window, winMinimized: WindowMinimizedHandler) {
-        this._window = window;
-        this._signals = [];
-        this._windowMinimizedHandler = winMinimized;
-    }
-
-    getWindow(): Meta.Window {
-        return this._window;
-    }
-
-    getWindowId(): number {
-        return this._window.get_id();
-    }
-
-    connectWindowSignals(
-        windowManager: IWindowManager,
-    ): void {
-
-        const windowId = this._window.get_id();
-
-
-        // Handle window destruction
-        const destroyId = this._window.connect('unmanaging', window => {
-            Logger.log("REMOVING WINDOW", windowId);
-            windowManager.handleWindowClosed(this)
-        });
-        this._signals.push({name: 'unmanaging', id: destroyId});
-
-        // Handle focus changes
-        const focusId = this._window.connect('notify::has-focus', () => {
-            if (this._window.has_focus()) {
-                windowManager._activeWindowId = windowId;
-            }
-        });
-        this._signals.push({name: 'notify::has-focus', id: focusId});
-
-        // Track window movement using position-changed signal
-        let lastPositionChangeTime = 0;
-        let dragInProgress = false;
-        
-        // const positionChangedId = this._window.connect('position-changed', window => {
-        //     Logger.log("position-changed", window.get_id());
-        //     Logger.log(window.get_monitor())
-        //     // const currentTime = Date.now();
-        //     // const [x, y, _] = global.get_pointer();
-        //     //
-        //     // // If this is the first move or it's been a while since the last move, consider it the start of a drag
-        //     // if (!dragInProgress) {
-        //     //     dragInProgress = true;
-        //     //     Logger.log(`Window drag started for window ${windowId}. Mouse position: ${x}, ${y}`);
-        //     // }
-        //     //
-        //     // // Update the time of the last position change
-        //     // lastPositionChangeTime = currentTime;
-        //     //
-        //     // // Set a timeout to detect when dragging stops (when position changes stop coming in)
-        //     // GLib.timeout_add(GLib.PRIORITY_DEFAULT, 300, () => {
-        //     //     const timeSinceLastMove = Date.now() - lastPositionChangeTime;
-        //     //     // If it's been more than 200ms since the last move and we were dragging, consider the drag ended
-        //     //     if (timeSinceLastMove >= 200 && dragInProgress) {
-        //     //         dragInProgress = false;
-        //     //         const [endX, endY, _] = global.get_pointer();
-        //     //         Logger.log(`Window drag ended for window ${windowId}. Mouse position: ${endX}, ${endY}`);
-        //     //     }
-        //     //     return GLib.SOURCE_REMOVE; // Remove the timeout
-        //     // });
-        // });
-        // this._signals.push({name: 'position-changed', id: positionChangedId});
-
-        // Handle minimization
-        const minimizeId = this._window.connect('notify::minimized', () => {
-            if (this._window.minimized) {
-                Logger.log(`Window minimized: ${windowId}`);
-                // Remove window from managed windows temporarily
-                // windowManager.removeFromTree(this._window);
-                // If this was the active window, find a new one
-                // Retile remaining windows
-                windowManager.handleWindowMinimized(this);
-
-            } else if (!this._window.minimized) {
-                Logger.log(`Window unminimized: ${windowId}`);
-                // windowManager.addWindow(this._window);
-                windowManager.handleWindowUnminimized(this);
-
-            }
-        });
-        this._signals.push({name: 'notify::minimized', id: minimizeId});
-
-        // Handle maximization
-        const maximizeId = this._window.connect('notify::maximized-horizontally', () => {
-            if (this._window.get_maximized()) {
-                Logger.log(`Window maximized: ${windowId}`);
-            } else {
-                Logger.log(`Window unmaximized: ${windowId}`);
-            }
-        });
-        this._signals.push({name: 'notify::maximized-horizontally', id: maximizeId});
-    }
-
-    disconnectWindowSignals(): void {
-
-        // Disconnect signals
-        if (this._signals) {
-            this._signals.forEach(signal => {
-                try {
-                    if (this._window != null) {
-                        this._window.disconnect(signal.id);
-                    }
-                } catch (e) {
-                    // Window might already be gone
-                }
-            });
-        }
-    }
-
-    resizeWindow(x: number, y: number, width: number, height: number) {
-        // First, ensure window is not maximized or fullscreen
-        if (this._window.get_maximized()) {
-            Logger.log("WINDOW MAXIMIZED")
-            this._window.unmaximize(Meta.MaximizeFlags.BOTH);
-        }
-
-        if (this._window.is_fullscreen()) {
-            Logger.log("WINDOW IS FULLSCREEN")
-            this._window.unmake_fullscreen();
-        }
-        // Logger.log("WINDOW", this._window.get_window_type(), this._window.allows_move());
-        // Logger.log("MONITOR INFO", getUsableMonitorSpace(this._window));
-        // Logger.log("NEW_SIZE", x, y, width, height);
-        // win.move_resize_frame(false, 50, 50, 300, 300);
-        this._window.move_resize_frame(false, x, y, width, height);
-        // Logger.log("RESIZED WINDOW", this._window.get_frame_rect().height, this._window.get_frame_rect().width, this._window.get_frame_rect().x, this._window.get_frame_rect().y);
-    }
-
-    safelyResizeWindow(x: number, y: number, width: number, height: number): void {
-        Logger.log("SAFELY RESIZE", x, y, width, height);
-        const actor = this._window.get_compositor_private();
-
-        if (!actor) {
-            Logger.log("No actor available, can't resize safely yet");
-            return;
-        }
-
-// Set a flag to track if the resize has been done
-        let resizeDone = false;
-
-// Connect to the first-frame signal
-        const id = actor.connect('first-frame', () => {
-            // Disconnect the signal handler
-            actor.disconnect(id);
-
-            if (!resizeDone) {
-                resizeDone = true;
-
-                // Add a small delay
-                GLib.timeout_add(GLib.PRIORITY_DEFAULT, 50, () => {
-                    try {
-                        this.resizeWindow(x, y, width, height);
-                    } catch (e) {
-                        console.error("Error resizing window:", e);
-                    }
-                    return GLib.SOURCE_REMOVE;
-                });
-            }
-        });
-
-// Fallback timeout in case the first-frame signal doesn't fire
-// (for windows that are already mapped)
-        GLib.timeout_add(GLib.PRIORITY_DEFAULT, 50, () => {
-            if (!resizeDone) {
-                resizeDone = true;
-                try {
-                    this.resizeWindow(x, y, width, height);
-                } catch (e) {
-                    console.error("Error resizing window (fallback):", e);
-                }
-            }
-            return GLib.SOURCE_REMOVE;
-        });
-    }
-
-    // if (!this._window) return;
-    // this._window.unmaximize(Meta.MaximizeFlags.HORIZONTAL);
-    // this._window.unmaximize(Meta.MaximizeFlags.VERTICAL);
-    // this._window.unmaximize(Meta.MaximizeFlags.BOTH);
-    //
-    // let windowActor = this._window.get_compositor_private() as Clutter.Actor;
-    // if (!windowActor) return;
-    // windowActor.remove_all_transitions();
-    //
-    // this._window.move_frame(true, x, y);
-    // this._window.move_resize_frame(true, x, y, width, height);
-
-
-}
-
-function getUsableMonitorSpace(window: Meta.Window) {
-    // Get the current workspace
-    const workspace = window.get_workspace();
-
-    // Get the monitor index that this window is on
-    const monitorIndex = window.get_monitor();
-
-    // Get the work area
-    const workArea = workspace.get_work_area_for_monitor(monitorIndex);
-
-    return {
-        x: workArea.x,
-        y: workArea.y,
-        width: workArea.width,
-        height: workArea.height
-    };
-}
--- a/src/windowManager.ts
+++ b/src/windowManager.ts
@@ -1,377 +0,0 @@
-import Meta from "gi://Meta";
-import Gio from "gi://Gio";
-import GLib from "gi://GLib";
-
-import {WindowWrapper} from './window.js';
-import * as Main from "resource:///org/gnome/shell/ui/main.js";
-import Mtk from "@girs/mtk-16";
-import {Logger} from "./utils/logger.js";
-import MonitorManager from "./monitor.js";
-
-
-export interface IWindowManager {
-    _activeWindowId: number | null;
-
-    // addWindow(window: Meta.Window): void;
-
-    handleWindowClosed(winWrap: WindowWrapper): void;
-    handleWindowMinimized(winWrap: WindowWrapper): void;
-    handleWindowUnminimized(winWrap: WindowWrapper): void;
-
-
-    // removeFromTree(window: Meta.Window): void;
-    syncActiveWindow(): number | null;
-}
-
-const _UNUSED_MONITOR_ID = -1
-export default class WindowManager implements IWindowManager {
-    _displaySignals: number[];
-    _windowManagerSignals: number[];
-    _workspaceManagerSignals: number[];
-    _shieldScreenSignals: number[];
-    _overviewSignals: number[];
-    _activeWindowId: number | null;
-    _grabbedWindowMonitor: number;
-    _monitors: Map<number, MonitorManager>;
-    _sessionProxy: Gio.DBusProxy | null;
-    _lockedSignalId: number | null;
-    _isScreenLocked: boolean;
-
-    constructor() {
-        this._displaySignals = [];
-        this._windowManagerSignals = [];
-        this._workspaceManagerSignals = [];
-        this._overviewSignals = [];
-        this._shieldScreenSignals = [];
-        this._activeWindowId = null;
-        this._grabbedWindowMonitor = _UNUSED_MONITOR_ID;
-        this._monitors = new Map<number, MonitorManager>();
-        this._sessionProxy = null;
-        this._lockedSignalId = null;
-        this._isScreenLocked = false;
-
-    }
-
-    public enable(): void {
-        Logger.log("Starting Aerospike Window Manager");
-        this.captureExistingWindows();
-        // Connect window signals
-        this.instantiateDisplaySignals()
-
-        const mon_count = global.display.get_n_monitors();
-        for (let i = 0; i < mon_count; i++) {
-            this._monitors.set(i, new MonitorManager(i));
-        }
-    }
-
-    public disable(): void {
-        Logger.log("DISABLED AEROSPIKE WINDOW MANAGER!")
-        // Disconnect the focus signal and remove any existing borders
-        this.disconnectDisplaySignals();
-        this.removeAllWindows();
-    }
-
-    removeAllWindows(): void {
-        this._monitors.forEach((monitor: MonitorManager) => {
-            monitor.removeAllWindows();
-        })
-    }
-
-
-    instantiateDisplaySignals(): void {
-        this._displaySignals.push(
-            global.display.connect("grab-op-begin", (display, window, op) => {
-                this.handleGrabOpBegin(display, window, op)
-            }),
-            global.display.connect("grab-op-end", (display, window, op) => {
-                this.handleGrabOpEnd(display, window, op)
-            }),
-            global.display.connect("window-entered-monitor", (display, monitor, window) => {
-                Logger.log("WINDOW HAS ENTERED NEW MONITOR!")
-            }),
-            global.display.connect('window-created', (display, window) => {
-                this.handleWindowCreated(display, window);
-            }),
-            global.display.connect("showing-desktop-changed", () => {
-                Logger.log("SHOWING DESKTOP CHANGED");
-            }),
-            global.display.connect("workareas-changed", () => {
-                Logger.log("WORK AREAS CHANGED");
-            }),
-            global.display.connect("in-fullscreen-changed", () => {
-                Logger.log("IN FULL SCREEN CHANGED");
-            }),
-        )
-
-
-        this._windowManagerSignals = [
-            // global.window_manager.connect("minimize", (_source, window) => {
-            //     Logger.log("MINIMIZING WINDOW")
-            // }),
-            // global.window_manager.connect("unminimize", (_source, window) => {
-            //     Logger.log("WINDOW UNMINIMIZED");
-            // }),
-            global.window_manager.connect("show-tile-preview", (_, _metaWindow, _rect, _num) => {
-                Logger.log("SHOW TITLE PREVIEW!")
-            }),
-        ];
-
-
-        this._workspaceManagerSignals = [
-            global.workspace_manager.connect("showing-desktop-changed", () => {
-                Logger.log("SHOWING DESKTOP CHANGED AT WORKSPACE LEVEL");
-            }),
-            global.workspace_manager.connect("workspace-added", (_, wsIndex) => {
-                Logger.log("WORKSPACE ADDED");
-            }),
-            global.workspace_manager.connect("workspace-removed", (_, wsIndex) => {
-                Logger.log("WORKSPACE REMOVED");
-            }),
-            global.workspace_manager.connect("active-workspace-changed", () => {
-                Logger.log("Active workspace-changed");
-            }),
-        ];
-
-
-        this._overviewSignals = [
-            Main.overview.connect("hiding", () => {
-                // this.fromOverview = true;
-                Logger.log("HIDING OVERVIEW")
-                const eventObj = {
-                    name: "focus-after-overview",
-                    callback: () => {
-                        // const focusNodeWindow = this.tree.findNode(this.focusMetaWindow);
-                        // this.updateStackedFocus(focusNodeWindow);
-                        // this.updateTabbedFocus(focusNodeWindow);
-                        // this.movePointerWith(focusNodeWindow);
-                        Logger.log("FOCUSING AFTER OVERVIEW");
-                    },
-                };
-                // this.queueEvent(eventObj);
-            }),
-            Main.overview.connect("showing", () => {
-                // this.toOverview = true;
-                Logger.log("SHOWING OVERVIEW");
-            }),
-        ];
-
-        // Main.screenShield;
-
-        // Handler for lock event
-        this._shieldScreenSignals.push(Main.screenShield.connect('lock-screen', () => {
-                console.log('Session locked at:', new Date().toISOString());
-            }), Main.screenShield.connect('unlock-screen', () => {
-                console.log('Session unlocked at:', new Date().toISOString());
-            })
-        );
-
-        // Handler for unlock event
-
-        // this._signalsBound = true;
-
-    }
-
-    disconnectDisplaySignals(): void {
-        this._displaySignals.forEach((signal) => {
-            global.disconnect(signal)
-        })
-        this._windowManagerSignals.forEach((signal) => {
-            global.disconnect(signal)
-        })
-        this._workspaceManagerSignals.forEach((signal) => {
-            global.disconnect(signal)
-        })
-    }
-
-    handleGrabOpBegin(display: Meta.Display, window: Meta.Window, op: Meta.GrabOp): void {
-        Logger.log("Grab Op Start");
-        Logger.log(display, window, op)
-        Logger.log(window.get_monitor())
-        this._grabbedWindowMonitor = window.get_monitor();
-    }
-
-    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())
-        var rect = window.get_frame_rect()
-        Logger.info("Release Location", window.get_monitor(), rect.x, rect.y, rect.width, rect.height)
-        this._tileMonitors();
-        const old_mon_id = this._grabbedWindowMonitor;
-        const new_mon_id = window.get_monitor();
-
-        Logger.info("MONITOR MATCH", old_mon_id !== new_mon_id);
-        if (old_mon_id !== new_mon_id) {
-            Logger.trace("MOVING MONITOR");
-            let old_mon = this._monitors.get(old_mon_id);
-            let new_mon = this._monitors.get(new_mon_id);
-            if (old_mon === undefined || new_mon === undefined) {
-                return;
-            }
-            let wrapped = old_mon.getWindow(window.get_id())
-            if (wrapped === undefined) {
-                wrapped = new WindowWrapper(window, this.handleWindowMinimized);
-            } else {
-                old_mon.removeWindow(window.get_id())
-            }
-            new_mon.addWindow(wrapped)
-        }
-        Logger.info("monitor_start and monitor_end", this._grabbedWindowMonitor, window.get_monitor());
-    }
-
-    public handleWindowMinimized(winWrap: WindowWrapper): void {
-        Logger.warn("WARNING MINIMIZING WINDOW");
-        Logger.log("WARNING MINIMIZED", winWrap);
-        const monitor_id = winWrap.getWindow().get_monitor()
-        Logger.log("WARNING MINIMIZED", monitor_id);
-        Logger.warn("WARNING MINIMIZED", this._monitors);
-        this._monitors.get(monitor_id)?.minimizeWindow(winWrap);
-        this._tileMonitors()
-    }
-
-    public handleWindowUnminimized(winWrap: WindowWrapper): void {
-        Logger.log("WINDOW UNMINIMIZED");
-        const monitor_id = winWrap.getWindow().get_monitor()
-        this._monitors.get(monitor_id)?.unminimizeWindow(winWrap);
-        this._tileMonitors()
-    }
-
-    public captureExistingWindows() {
-        Logger.log("CAPTURING WINDOWS")
-        const workspace = global.workspace_manager.get_active_workspace();
-        const windows = global.display.get_tab_list(Meta.TabList.NORMAL, workspace);
-        Logger.log("WINDOWS", windows);
-        windows.forEach(window => {
-            if (this._isWindowTileable(window)) {
-                this.addWindowToMonitor(window);
-            }
-        });
-
-        this._tileMonitors();
-    }
-
-
-    handleWindowCreated(display: Meta.Display, window: Meta.Window) {
-        Logger.log("WINDOW CREATED ON DISPLAY", window, display);
-        if (!this._isWindowTileable(window)) {
-            return;
-        }
-        Logger.log("WINDOW IS TILABLE");
-        const actor = window.get_compositor_private();
-        if (!actor) {
-            return;
-        }
-        this.addWindowToMonitor(window);
-    }
-
-
-    /**
-     * Handle window closed event
-     */
-    handleWindowClosed(window: WindowWrapper): void {
-
-        window.disconnectWindowSignals()
-        const mon_id = window._window.get_monitor();
-        this._monitors.get(mon_id)?.removeWindow(window.getWindowId());
-
-        // Remove from managed windows
-        this.syncActiveWindow();
-        // Retile remaining windows
-        this._tileMonitors();
-    }
-
-
-    public addWindowToMonitor(window: Meta.Window) {
-        var wrapper = new WindowWrapper(window, this.handleWindowMinimized)
-        wrapper.connectWindowSignals(this)
-        this._monitors.get(window.get_monitor())?.addWindow(wrapper)
-    }
-
-    // public UnmanageWindow(window: Meta.Window) {
-    //     this._windows.delete(window.get_id());
-    //     this._unmanagedWindows.add(window.get_id())
-    // }
-    //
-    // public ManageWindow(window: Meta.Window) {
-    //     this._windows.set(window.get_id(), {
-    //         window,
-    //     })
-    // }
-
-    _tileMonitors(): void {
-        for (const monitor of this._monitors.values()) {
-            monitor._tileWindows()
-        }
-    }
-
-    _isWindowTileable(window: Meta.Window) {
-        if (!window || !window.get_compositor_private()) {
-            return false;
-        }
-
-        const windowType = window.get_window_type();
-        Logger.log("WINDOW TYPE", windowType);
-        // Skip certain types of windows
-        return !window.is_skip_taskbar() &&
-            windowType !== Meta.WindowType.DESKTOP &&
-            windowType !== Meta.WindowType.DOCK &&
-            windowType !== Meta.WindowType.DIALOG &&
-            windowType !== Meta.WindowType.MODAL_DIALOG &&
-            windowType !== Meta.WindowType.UTILITY &&
-            windowType !== Meta.WindowType.MENU;
-    }
-
-    /**
-     * 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 {
-        // // Get the active workspace
-        // const workspace = global.workspace_manager.get_active_workspace();
-        //
-        // // Check if there is an active window
-        // const activeWindow = global.display.get_focus_window();
-        //
-        // if (!activeWindow) {
-        //     Logger.log("No active window found in GNOME");
-        //     this._activeWindowId = null;
-        //     return null;
-        // }
-        //
-        // // Get the window ID
-        // const windowId = activeWindow.get_id();
-        //
-        // // Check if this window is being managed by our extension
-        // if (this._windows.has(windowId)) {
-        //     Logger.log(`Setting active window to ${windowId}`);
-        //     this._activeWindowId = windowId;
-        //     return windowId;
-        // } else {
-        //     Logger.log(`Window ${windowId} is not managed by this extension`);
-        //
-        //     // Try to find a managed window on the current workspace to make active
-        //     const managedWindows = Array.from(this._windows.entries())
-        //         .filter(([_, wrapper]) =>
-        //             wrapper.window && wrapper.window.get_workspace() === workspace);
-        //
-        //     if (managedWindows.length > 0) {
-        //         // Take the first managed window on this workspace
-        //         const firstWindowId = managedWindows[0][0];
-        //         Logger.log(`Using managed window ${firstWindowId} as active instead`);
-        //         this._activeWindowId = firstWindowId;
-        //         return firstWindowId;
-        //     }
-        //
-        //     // No managed windows on this workspace
-        //     Logger.log("No managed windows found on the active workspace");
-        //     this._activeWindowId = null;
-        //     return null;
-        // }
-        return null;
-    }
-
-
-}
--- a/src/wm/container.ts
+++ b/src/wm/container.ts
@@ -0,0 +1,525 @@
+import {WindowWrapper} from "./window.js";
+import {Logger} from "../utils/logger.js";
+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,
+}
+
+// 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;
+    _workArea: Rect;
+
+    // -- Accordion Mode States
+
+    _splitRatios: number[];
+
+    // -- Tabbed mode state -----------------------------------------------------
+    _activeTabIndex: number = 0;
+    _tabBar: TabBar | null = null;
+
+    constructor(workspaceArea: Rect) {
+        this._tiledItems = [];
+        this._tiledWindowLookup = new Map<number, WindowWrapper>();
+        this._workArea = workspaceArea;
+        this._splitRatios = [];
+    }
+
+    // --- Helpers ----------------------------------------------------------------
+
+    private _resetRatios(): void {
+        this._splitRatios = equalRatios(this._tiledItems.length);
+    }
+
+    private _addRatioForNewWindow(): void {
+        const n = this._tiledItems.length;
+        if (n <= 1) {
+            this._splitRatios = [1.0];
+            return;
+        }
+        const newRatio = 1 / n;
+        const scale = 1 - newRatio;
+        const scaled = this._splitRatios.map(r => r * scale);
+        const partialSum = scaled.reduce((a, b) => a + b, 0) + newRatio;
+        scaled[scaled.length - 1] += (1.0 - partialSum);
+        this._splitRatios = [...scaled, newRatio];
+    }
+
+    private _totalDimension(): number {
+        return this._orientation === 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();
+        }
+    }
+
+    addWindow(winWrap: WindowWrapper): void {
+        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);
+    }
+
+    getWindow(win_id: number): WindowWrapper | undefined {
+        if (this._tiledWindowLookup.has(win_id)) {
+            return this._tiledWindowLookup.get(win_id);
+        }
+        for (const item of this._tiledItems) {
+            if (item instanceof WindowContainer) {
+                const win = item.getWindow(win_id);
+                if (win) return win;
+            } else if (item.getWindowId() === win_id) {
+                return item;
+            }
+        }
+        return undefined;
+    }
+
+    _getIndexOfWindow(win_id: number): number {
+        for (let i = 0; i < this._tiledItems.length; i++) {
+            const item = this._tiledItems[i];
+            if (item instanceof WindowWrapper && item.getWindowId() === win_id) {
+                return i;
+            }
+        }
+        return -1;
+    }
+
+    removeWindow(win_id: number): void {
+        if (this._tiledWindowLookup.has(win_id)) {
+            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();
+            }
+        } else {
+            for (const item of this._tiledItems) {
+                if (item instanceof WindowContainer) {
+                    item.removeWindow(win_id);
+                }
+            }
+        }
+        this.drawWindows();
+    }
+
+    disconnectSignals(): void {
+        this._tiledItems.forEach((item) => {
+            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;
+    }
+
+    drawWindows(): void {
+        Logger.log("TILING WINDOWS IN CONTAINER");
+        Logger.log("WorkArea", this._workArea);
+
+        if (this.isTabbed()) {
+            this._tileTab();
+        } else {
+            this._tileAccordion();
+        }
+    }
+
+    _tileAccordion() {
+        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);
+            }
+        });
+    }
+
+    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);
+        }
+
+        return this._orientation === Layout.ACC_HORIZONTAL
+            ? this._computeBounds('horizontal')
+            : this._computeBounds('vertical');
+    }
+
+    private _computeBounds(axis: 'horizontal' | 'vertical'): Rect[] {
+        const isHorizontal = axis === 'horizontal';
+        const total = isHorizontal ? this._workArea.width : this._workArea.height;
+        let used = 0;
+
+        return this._tiledItems.map((_, index) => {
+            const offset = used;
+            const size = index === this._tiledItems.length - 1
+                ? total - used
+                : Math.floor(this._splitRatios[index] * total);
+            used += size;
+
+            return isHorizontal
+                ? {x: this._workArea.x + offset, y: this._workArea.y, width: size, height: this._workArea.height}
+                : {x: this._workArea.x, y: this._workArea.y + offset, width: this._workArea.width, height: size};
+        });
+    }
+
+    adjustBoundary(boundaryIndex: number, deltaPixels: number): boolean {
+        // No boundary adjustment in tabbed mode
+        if (this.isTabbed()) return false;
+
+        if (boundaryIndex < 0 || boundaryIndex >= this._tiledItems.length - 1) {
+            Logger.warn(`adjustBoundary: invalid boundaryIndex ${boundaryIndex}`);
+            return false;
+        }
+
+        const totalDim = this._totalDimension();
+        if (totalDim === 0) return false;
+
+        const ratioDelta = deltaPixels / totalDim;
+        const newLeft = this._splitRatios[boundaryIndex] + ratioDelta;
+        const newRight = this._splitRatios[boundaryIndex + 1] - ratioDelta;
+
+        if (newLeft <= 0 || newRight <= 0) {
+            Logger.log(`adjustBoundary: clamped — newLeft=${newLeft.toFixed(3)}, newRight=${newRight.toFixed(3)}`);
+            return false;
+        }
+
+        this._splitRatios[boundaryIndex] = newLeft;
+        this._splitRatios[boundaryIndex + 1] = newRight;
+
+        Logger.info(`adjustBoundary: boundary=${boundaryIndex} ratios=[${this._splitRatios.map(r => r.toFixed(3)).join(', ')}]`);
+        return true;
+    }
+
+    // --- Container Lookup --------------------------------------------------------
+
+    getContainerForWindow(win_id: number): WindowContainer | null {
+        for (const item of this._tiledItems) {
+            if (item instanceof WindowWrapper && item.getWindowId() === win_id) {
+                return this;
+            }
+            if (item instanceof WindowContainer) {
+                const found = item.getContainerForWindow(win_id);
+                if (found !== null) return found;
+            }
+        }
+        return null;
+    }
+
+    getIndexOfItemNested(item: WindowWrapper): number {
+        for (let i = 0; i < this._tiledItems.length; i++) {
+            const container = this._tiledItems[i];
+            if (container instanceof WindowContainer) {
+                if (container.getIndexOfItemNested(item) !== -1) return i;
+            } else if (container.getWindowId() === item.getWindowId()) {
+                return i;
+            }
+        }
+        return -1;
+    }
+
+    // TODO: update this to work with nested containers - all other logic should already be working
+    itemDragged(item: WindowWrapper, x: number, y: number): void {
+        // 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);
+
+        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();
+        }
+    }
+
+    resetRatios(): void {
+        this._resetRatios();
+        this.drawWindows();
+    }
+}
--- a/src/wm/monitor.ts
+++ b/src/wm/monitor.ts
@@ -0,0 +1,97 @@
+import {WindowWrapper} from "./window.js";
+import {Rect} from "../utils/rect.js";
+import {Logger} from "../utils/logger.js";
+
+import WindowContainer from "./container.js";
+
+export default class Monitor {
+
+    _id: number;
+    _workArea: Rect;
+    _workspaces: WindowContainer[] = [];
+
+    constructor(monitorId: number) {
+        this._id = monitorId;
+        const workspace = global.workspace_manager.get_active_workspace();
+        this._workArea = workspace.get_work_area_for_monitor(this._id);
+        Logger.log("CREATING MONITOR", monitorId);
+        Logger.log("WorkArea", this._workArea.x, this._workArea.y, this._workArea.width, this._workArea.height);
+        const workspaceCount = global.workspace_manager.get_n_workspaces();
+        Logger.log("Workspace Count", workspaceCount);
+        for (let i = 0; i < workspaceCount; i++) {
+            this._workspaces.push(new WindowContainer(this._workArea));
+        }
+    }
+
+    disconnectSignals() {
+        for (const container of this._workspaces) {
+            container.disconnectSignals();
+        }
+    }
+
+    removeAllWindows(): void {
+        for (const container of this._workspaces) {
+            container.removeAllWindows();
+        }
+    }
+
+    getWindow(windowId: number): WindowWrapper | undefined {
+        for (const container of this._workspaces) {
+            const win = container.getWindow(windowId);
+            if (win) return win;
+        }
+        return undefined;
+    }
+
+    removeWindow(winWrap: WindowWrapper) {
+        const windowId = winWrap.getWindowId();
+        for (const container of this._workspaces) {
+            if (container.getWindow(windowId)) {
+                container.removeWindow(windowId);
+            }
+        }
+    }
+
+    addWindow(winWrap: WindowWrapper) {
+        const window_workspace = winWrap.getWindow().get_workspace().index();
+        this._workspaces[window_workspace].addWindow(winWrap);
+    }
+
+    tileWindows(): void {
+        const activeWorkspace = global.workspace_manager.get_active_workspace();
+        this._workArea = activeWorkspace.get_work_area_for_monitor(this._id);
+        // move() calls tileWindows() internally
+        this._workspaces[activeWorkspace.index()].move(this._workArea);
+    }
+
+    removeWorkspace(workspaceId: number): void {
+        this._workspaces.splice(workspaceId, 1);
+    }
+
+    addWorkspace(): void {
+        this._workspaces.push(new WindowContainer(this._workArea));
+    }
+
+    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);
+    }
+}
--- a/src/wm/tabBar.ts
+++ b/src/wm/tabBar.ts
@@ -0,0 +1,131 @@
+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
@@ -0,0 +1,187 @@
+import Meta from 'gi://Meta';
+import Clutter from "gi://Clutter";
+import {IWindowManager} from "./windowManager.js";
+import {Logger} from "../utils/logger.js";
+import {Rect} from "../utils/rect.js";
+import WindowContainer from "./container.js";
+import queueEvent from "../utils/events.js";
+
+
+type WindowMinimizedHandler = (window: WindowWrapper) => void;
+type WindowWorkspaceChangedHandler = (window: WindowWrapper) => void;
+
+export class WindowWrapper {
+    private static readonly RESIZE_TOLERANCE = 2;
+
+    readonly _window: Meta.Window;
+    readonly _windowMinimizedHandler: WindowMinimizedHandler;
+    readonly _signals: number[] = [];
+    _parent: WindowContainer | null = null;
+    _dragging: boolean = false;
+
+    constructor(
+        window: Meta.Window,
+        winMinimized: WindowMinimizedHandler
+    ) {
+        this._window = window;
+        this._windowMinimizedHandler = winMinimized;
+    }
+
+    getWindow(): Meta.Window {
+        return this._window;
+    }
+
+    getWindowId(): number {
+        return this._window.get_id();
+    }
+
+    getWorkspace(): number {
+        return this._window.get_workspace().index();
+    }
+
+    getMonitor(): number {
+        return this._window.get_monitor();
+    }
+
+    getRect(): Rect {
+        return this._window.get_frame_rect();
+    }
+
+    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();
+        this._signals.push(
+            this._window.connect('unmanaging', () => {
+                Logger.log("REMOVING WINDOW", windowId);
+                windowManager.handleWindowClosed(this);
+            }),
+            this._window.connect('notify::minimized', () => {
+                if (this._window.minimized) {
+                    Logger.log(`Window minimized: ${windowId}`);
+                    windowManager.handleWindowMinimized(this);
+                } else {
+                    Logger.log(`Window unminimized: ${windowId}`);
+                    windowManager.handleWindowUnminimized(this);
+                }
+            }),
+            this._window.connect('notify::maximized-horizontally', () => {
+                if (this._window.is_maximized()) {
+                    Logger.log(`Window maximized: ${windowId}`);
+                } else {
+                    Logger.log(`Window unmaximized: ${windowId}`);
+                }
+            }),
+            this._window.connect("workspace-changed", () => {
+                Logger.log("WORKSPACE CHANGED FOR WINDOW", this._window.get_id());
+                windowManager.handleWindowChangedWorkspace(this);
+            }),
+            this._window.connect("position-changed", () => {
+                windowManager.handleWindowPositionChanged(this);
+            }),
+            this._window.connect("size-changed", () => {
+                windowManager.handleWindowPositionChanged(this);
+            }),
+            this._window.connect('notify::title', () => {
+                windowManager.handleWindowTitleChanged(this);
+            }),
+        );
+    }
+
+    disconnectWindowSignals(): void {
+        if (this._signals) {
+            this._signals.forEach(signal => {
+                try {
+                    if (this._window != null) {
+                        this._window.disconnect(signal);
+                    }
+                } catch (e) {
+                    Logger.warn("error disconnecting signal", signal, e);
+                }
+            });
+        }
+    }
+
+    safelyResizeWindow(rect: Rect, _retry: number = 3): void {
+        if (this._dragging) {
+            Logger.info("STOPPED RESIZE BECAUSE ITEM IS BEING DRAGGED");
+            return;
+        }
+
+        const actor = this._window.get_compositor_private() as Clutter.Actor | null;
+        if (!actor) {
+            Logger.log("No actor available, can't resize safely yet");
+            return;
+        }
+
+        actor.remove_all_transitions();
+
+        // Move first to guarantee the window reaches the correct position even
+        // if the subsequent resize is clamped by minimum-size hints.
+        this._window.move_frame(true, rect.x, rect.y);
+        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);
+            }
+        }
+    }
+}
--- a/src/wm/windowManager.ts
+++ b/src/wm/windowManager.ts
@@ -0,0 +1,616 @@
+import Meta from "gi://Meta";
+import Gio from "gi://Gio";
+
+import {WindowWrapper} from './window.js';
+import * as Main from "resource:///org/gnome/shell/ui/main.js";
+import {Logger} from "../utils/logger.js";
+import Monitor from "./monitor.js";
+import WindowContainer, {Layout} from "./container.js";
+import {Rect} from "../utils/rect.js";
+
+
+export interface IWindowManager {
+    _activeWindowId: number | null;
+
+    handleWindowClosed(winWrap: WindowWrapper): void;
+
+    handleWindowMinimized(winWrap: WindowWrapper): void;
+
+    handleWindowUnminimized(winWrap: WindowWrapper): void;
+
+    handleWindowChangedWorkspace(winWrap: WindowWrapper): void;
+
+    handleWindowPositionChanged(winWrap: WindowWrapper): void;
+
+    handleWindowTitleChanged(winWrap: WindowWrapper): void;
+
+    syncActiveWindow(): number | null;
+}
+
+
+const _UNUSED_MONITOR_ID = -1;
+const _UNUSED_WINDOW_ID  = -1;
+
+export default class WindowManager implements IWindowManager {
+    _displaySignals: number[] = [];
+    _windowManagerSignals: number[] = [];
+    _workspaceManagerSignals: number[] = [];
+    _overviewSignals: number[] = [];
+
+    _activeWindowId: number | null = null;
+    _monitors: Map<number, Monitor> = new Map<number, Monitor>();
+    _minimizedItems: Map<number, WindowWrapper> = new Map<number, WindowWrapper>();
+
+    _grabbedWindowMonitor: number = _UNUSED_MONITOR_ID;
+    _grabbedWindowId: number = _UNUSED_WINDOW_ID;
+    _changingGrabbedMonitor: boolean = false;
+    _showingOverview: boolean = false;
+
+    // -- Resize-drag tracking --------------------------------------------------
+    _isResizeDrag: boolean = false;
+    _resizeDragWindowId: number = _UNUSED_WINDOW_ID;
+    _resizeDragOp: Meta.GrabOp = Meta.GrabOp.NONE;
+    _resizeDragLastMouseX: number = 0;
+    _resizeDragLastMouseY: number = 0;
+    _isTiling: boolean = false;
+
+    private readonly _settings: Gio.Settings;
+
+    constructor(settings: Gio.Settings) {
+        this._settings = settings;
+    }
+
+    public enable(): void {
+        Logger.log("Starting Aerospike Window Manager");
+        this.instantiateDisplaySignals();
+
+        const mon_count = global.display.get_n_monitors();
+        for (let i = 0; i < mon_count; i++) {
+            this._monitors.set(i, new Monitor(i));
+        }
+
+        this.captureExistingWindows();
+        this.syncActiveWindow();
+    }
+
+    instantiateDisplaySignals(): void {
+        this._displaySignals.push(
+            global.display.connect("grab-op-begin", (display, window, op) => {
+                this.handleGrabOpBegin(display, window, op)
+            }),
+            global.display.connect("grab-op-end", (display, window, op) => {
+                this.handleGrabOpEnd(display, window, op)
+            }),
+            global.display.connect("window-entered-monitor", (display, monitor, window) => {
+                Logger.log("WINDOW HAS ENTERED NEW MONITOR!")
+                if (this._showingOverview) {
+                    if (this._getWrappedWindow(window) !== undefined) {
+                        Logger.log("OVERVIEW - MOVING")
+                        this._moveWindowToMonitor(window, monitor)
+                    }
+                }
+            }),
+            global.display.connect('window-created', (display, window) => {
+                this.handleWindowCreated(display, window);
+            }),
+            global.display.connect('notify::focus-window', () => {
+                this.syncActiveWindow();
+            }),
+            global.display.connect("showing-desktop-changed", () => {
+                Logger.log("SHOWING DESKTOP CHANGED");
+            }),
+            global.display.connect("workareas-changed", (display) => {
+                Logger.log("WORK AREAS CHANGED",);
+                console.log(display.get_workspace_manager().get_active_workspace_index())
+            }),
+            global.display.connect("in-fullscreen-changed", () => {
+                Logger.log("IN FULL SCREEN CHANGED");
+                this._syncFullscreenTabBars();
+            }),
+        );
+
+        this._workspaceManagerSignals = [
+            global.workspace_manager.connect("showing-desktop-changed", () => {
+                Logger.log("SHOWING DESKTOP CHANGED AT WORKSPACE LEVEL");
+            }),
+            global.workspace_manager.connect("workspace-added", (_, wsIndex) => {
+                Logger.log("WORKSPACE ADDED", wsIndex);
+                this._monitors.forEach((monitor: Monitor) => {
+                    monitor.addWorkspace();
+                })
+            }),
+            global.workspace_manager.connect("workspace-removed", (_, wsIndex) => {
+                Logger.log("WORKSPACE REMOVED", wsIndex);
+                this._monitors.forEach((monitor: Monitor) => {
+                    monitor.removeWorkspace(wsIndex);
+                })
+            }),
+            global.workspace_manager.connect("active-workspace-changed", (source) => {
+                Logger.log("Active workspace-changed", source.get_active_workspace().index());
+            }),
+        ];
+
+        this._overviewSignals = [
+            Main.overview.connect("hiding", () => {
+                Logger.log("HIDING OVERVIEW")
+                this._showingOverview = false;
+                this._tileMonitors();
+                for (const monitor of this._monitors.values()) {
+                    monitor.showTabBars();
+                }
+            }),
+            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!")
+        this.disconnectSignals();
+        this.removeAllWindows();
+    }
+
+    removeAllWindows(): void {
+        this.disconnectMinimizedSignals();
+        this._minimizedItems.clear();
+        this._monitors.forEach((monitor: Monitor) => {
+            monitor.removeAllWindows();
+        })
+    }
+
+    disconnectSignals(): void {
+        this.disconnectDisplaySignals();
+        this.disconnectMonitorSignals();
+        this.disconnectMinimizedSignals();
+    }
+
+    disconnectMonitorSignals(): void {
+        this._monitors.forEach((monitor: Monitor) => {
+            monitor.disconnectSignals();
+        })
+    }
+
+    disconnectDisplaySignals(): void {
+        this._displaySignals.forEach((signal) => {
+            global.display.disconnect(signal)
+        })
+        this._windowManagerSignals.forEach((signal) => {
+            global.window_manager.disconnect(signal)
+        })
+        this._workspaceManagerSignals.forEach((signal) => {
+            global.workspace_manager.disconnect(signal)
+        })
+        this._overviewSignals.forEach((signal) => {
+            Main.overview.disconnect(signal)
+        })
+    }
+
+    disconnectMinimizedSignals(): void {
+        this._minimizedItems.forEach((item) => {
+            item.disconnectWindowSignals();
+        })
+    }
+
+    _isResizeOp(op: Meta.GrabOp): boolean {
+        return op === Meta.GrabOp.RESIZING_E  ||
+               op === Meta.GrabOp.RESIZING_W  ||
+               op === Meta.GrabOp.RESIZING_N  ||
+               op === Meta.GrabOp.RESIZING_S  ||
+               op === Meta.GrabOp.RESIZING_NE ||
+               op === Meta.GrabOp.RESIZING_NW ||
+               op === Meta.GrabOp.RESIZING_SE ||
+               op === Meta.GrabOp.RESIZING_SW;
+    }
+
+    handleGrabOpBegin(display: Meta.Display, window: Meta.Window, op: Meta.GrabOp): void {
+        Logger.log("Grab Op Start", op);
+
+        if (this._isResizeOp(op)) {
+            Logger.log("Resize drag begin, op=", op);
+            this._isResizeDrag = true;
+            this._resizeDragWindowId = window.get_id();
+            this._resizeDragOp = op;
+            const [startMouseX, startMouseY] = global.get_pointer();
+            this._resizeDragLastMouseX = startMouseX;
+            this._resizeDragLastMouseY = startMouseY;
+            this._getWrappedWindow(window)?.startDragging();
+        } else {
+            this._getWrappedWindow(window)?.startDragging();
+            this._grabbedWindowMonitor = window.get_monitor();
+            this._grabbedWindowId = window.get_id();
+        }
+    }
+
+    handleGrabOpEnd(display: Meta.Display, window: Meta.Window, op: Meta.GrabOp): void {
+        Logger.log("Grab Op End ", op);
+
+        if (this._isResizeDrag) {
+            Logger.log("Resize drag end, op=", op);
+            this._isResizeDrag = false;
+            this._resizeDragWindowId = _UNUSED_WINDOW_ID;
+            this._resizeDragLastMouseX = 0;
+            this._resizeDragLastMouseY = 0;
+            this._resizeDragOp = Meta.GrabOp.NONE;
+            this._getWrappedWindow(window)?.stopDragging();
+            this._tileMonitors();
+        } else {
+            this._grabbedWindowId = _UNUSED_WINDOW_ID;
+            this._getWrappedWindow(window)?.stopDragging();
+            this._tileMonitors();
+            Logger.info("monitor_start and monitor_end", this._grabbedWindowMonitor, window.get_monitor());
+        }
+    }
+
+    _getWrappedWindow(window: Meta.Window): WindowWrapper | undefined {
+        let wrapped: WindowWrapper | undefined = undefined;
+        for (const monitor of this._monitors.values()) {
+            wrapped = monitor.getWindow(window.get_id());
+            if (wrapped !== undefined) break;
+        }
+        return wrapped;
+    }
+
+    _getAndRemoveWrappedWindow(window: Meta.Window): WindowWrapper | undefined {
+        let wrapped: WindowWrapper | undefined = undefined;
+        for (const monitor of this._monitors.values()) {
+            wrapped = monitor.getWindow(window.get_id());
+            if (wrapped !== undefined) {
+                monitor.removeWindow(wrapped);
+                break;
+            }
+        }
+        return wrapped;
+    }
+
+    _moveWindowToMonitor(window: Meta.Window, monitorId: number): void {
+        let wrapped = this._getAndRemoveWrappedWindow(window);
+        if (wrapped === undefined) {
+            Logger.error("WINDOW NOT DEFINED")
+            wrapped = new WindowWrapper(window, (winWrap) => this.handleWindowMinimized(winWrap));
+            wrapped.connectWindowSignals(this);
+        }
+        let new_mon = this._monitors.get(monitorId);
+        new_mon?.addWindow(wrapped)
+        this._grabbedWindowMonitor = monitorId;
+    }
+
+    public handleWindowPositionChanged(winWrap: WindowWrapper): void {
+        if (this._isTiling || this._changingGrabbedMonitor) return;
+
+        if (this._isResizeDrag && winWrap.getWindowId() === this._resizeDragWindowId) {
+            this._handleResizeDragUpdate(winWrap);
+            return;
+        }
+
+        if (winWrap.getWindowId() === this._grabbedWindowId) {
+            const [mouseX, mouseY, _] = global.get_pointer();
+
+            let monitorIndex = -1;
+            for (let i = 0; i < global.display.get_n_monitors(); i++) {
+                const workArea = global.workspace_manager.get_active_workspace().get_work_area_for_monitor(i);
+                if (mouseX >= workArea.x && mouseX < workArea.x + workArea.width &&
+                    mouseY >= workArea.y && mouseY < workArea.y + workArea.height) {
+                    monitorIndex = i;
+                    break;
+                }
+            }
+            if (monitorIndex === -1) return;
+
+            if (monitorIndex !== this._grabbedWindowMonitor) {
+                this._changingGrabbedMonitor = true;
+                this._moveWindowToMonitor(winWrap.getWindow(), monitorIndex);
+                this._changingGrabbedMonitor = false;
+            }
+
+            this._isTiling = true;
+            try {
+                this._monitors.get(monitorIndex)?.itemDragged(winWrap, mouseX, mouseY);
+            } finally {
+                this._isTiling = false;
+            }
+        }
+    }
+
+    private _handleResizeDragUpdate(winWrap: WindowWrapper): void {
+        const op    = this._resizeDragOp;
+        const winId = winWrap.getWindowId();
+
+        const [mouseX, mouseY] = global.get_pointer();
+        const dx = mouseX - this._resizeDragLastMouseX;
+        const dy = mouseY - this._resizeDragLastMouseY;
+
+        if (dx === 0 && dy === 0) return;
+
+        this._resizeDragLastMouseX = mouseX;
+        this._resizeDragLastMouseY = mouseY;
+
+        const container = this._findContainerForWindowAcrossMonitors(winId);
+        if (!container) {
+            Logger.warn("_handleResizeDragUpdate: no container found for window", winId);
+            return;
+        }
+
+        const itemIndex = container._getIndexOfWindow(winId);
+        if (itemIndex === -1) return;
+
+        const isHorizontal = container._orientation === 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()
+        this._minimizedItems.set(winWrap.getWindowId(), winWrap);
+        this._monitors.get(monitor_id)?.removeWindow(winWrap);
+        this._tileMonitors()
+    }
+
+    public handleWindowUnminimized(winWrap: WindowWrapper): void {
+        this._minimizedItems.delete(winWrap.getWindowId());
+        this._addWindowWrapperToMonitor(winWrap);
+        this._tileMonitors()
+    }
+
+    public handleWindowChangedWorkspace(winWrap: WindowWrapper): void {
+        const monitor = winWrap.getWindow().get_monitor();
+        this._monitors.get(monitor)?.removeWindow(winWrap);
+        this._monitors.get(monitor)?.addWindow(winWrap);
+    }
+
+    public captureExistingWindows() {
+        const workspace = global.workspace_manager.get_active_workspace();
+        const windows = global.display.get_tab_list(Meta.TabList.NORMAL, workspace);
+        windows.forEach(window => {
+            if (this._isWindowTileable(window)) {
+                this.addWindowToMonitor(window);
+            }
+        });
+
+        this._tileMonitors();
+    }
+
+    handleWindowCreated(display: Meta.Display, window: Meta.Window) {
+        Logger.log("WINDOW CREATED ON DISPLAY", window, display);
+        if (!this._isWindowTileable(window)) return;
+        Logger.log("WINDOW IS TILABLE");
+        this.addWindowToMonitor(window);
+    }
+
+    handleWindowClosed(window: WindowWrapper): void {
+        const mon_id = window._window.get_monitor();
+        this._monitors.get(mon_id)?.removeWindow(window);
+        window.disconnectWindowSignals()
+        this.syncActiveWindow();
+        this._tileMonitors();
+    }
+
+    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))
+        wrapper.connectWindowSignals(this);
+        this._addWindowWrapperToMonitor(wrapper);
+    }
+
+    _addWindowWrapperToMonitor(winWrap: WindowWrapper) {
+        if (winWrap.getWindow().minimized) {
+            this._minimizedItems.set(winWrap.getWindow().get_id(), winWrap);
+        } else {
+            this._monitors.get(winWrap.getWindow().get_monitor())?.addWindow(winWrap)
+        }
+    }
+
+    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;
+        }
+    }
+
+    block_titles = [
+        "org.gnome.Shell.Extensions",
+    ]
+
+    _isWindowTilingBlocked(window: Meta.Window): boolean {
+        Logger.info("title", window.get_title());
+        Logger.info("description", window.get_description());
+        Logger.info("class", window.get_wm_class());
+        Logger.info("class", window.get_wm_class_instance());
+        return this.block_titles.some((title) => {
+            if (window.get_wm_class() === title) {
+                Logger.log("WINDOW BLOCKED FROM TILING", window.get_title());
+                return true;
+            }
+            return false;
+        });
+    }
+
+    _isWindowTileable(window: Meta.Window) {
+        if (!window || !window.get_compositor_private()) return false;
+        if (this._isWindowTilingBlocked(window)) return false;
+
+        const windowType = window.get_window_type();
+        Logger.log("WINDOW TILING CHECK",);
+
+        return !window.is_skip_taskbar() &&
+            windowType !== Meta.WindowType.DESKTOP &&
+            windowType !== Meta.WindowType.DOCK &&
+            windowType !== Meta.WindowType.DIALOG &&
+            windowType !== Meta.WindowType.MODAL_DIALOG &&
+            windowType !== Meta.WindowType.UTILITY &&
+            windowType !== Meta.WindowType.MENU;
+    }
+
+    public syncActiveWindow(): number | null {
+        const focusWindow = global.display.focus_window;
+        if (focusWindow) {
+            this._activeWindowId = focusWindow.get_id();
+            Logger.debug(`Active window changed to: ${this._activeWindowId} (${focusWindow.get_title()})`);
+        } else {
+            this._activeWindowId = null;
+            Logger.debug('No active window');
+        }
+        return this._activeWindowId;
+    }
+
+    public toggleActiveContainerOrientation(): void {
+        if (this._activeWindowId === null) {
+            Logger.warn("No active window, cannot toggle container orientation");
+            return;
+        }
+        const container = this._findContainerForWindowAcrossMonitors(this._activeWindowId);
+        if (container) {
+            container.toggleOrientation();
+        } else {
+            Logger.warn("Could not find container for active window");
+        }
+    }
+
+    public resetActiveContainerRatios(): void {
+        if (this._activeWindowId === null) {
+            Logger.warn("No active window, cannot reset container ratios");
+            return;
+        }
+        const container = this._findContainerForWindowAcrossMonitors(this._activeWindowId);
+        if (container) {
+            Logger.info("Resetting container ratios to equal splits");
+            container.resetRatios();
+        } else {
+            Logger.warn("Could not find container for active window");
+        }
+    }
+
+    public 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);
+            });
+        });
+
+        Logger.info("=".repeat(80));
+    }
+
+    private _printContainerTree(container: WindowContainer, indentLevel: number): void {
+        const indent = " ".repeat(indentLevel);
+
+        container._tiledItems.forEach((item, index) => {
+            if (item instanceof WindowContainer) {
+                const containsActive = this._activeWindowId !== null &&
+                                       item.getWindow(this._activeWindowId) !== undefined;
+                Logger.info(`${indent}[${index}] Container (${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/src/workspace.ts
+++ b/src/workspace.ts
--- a/stylesheet.css
+++ b/stylesheet.css
@@ -1,37 +1,33 @@
-/* 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-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;
 }

-/*.border-gradient-purple {*/
-/*    border-image-source: linear-gradient(to left, #743ad5, #d53a9d);*/
-/*}*/
+.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;
+}

-/*@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:hover {
+    background-color: rgba(70, 70, 70, 0.9);
+    color: rgba(255, 255, 255, 0.8);
+}

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

-/*    !* 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;*/
-/*}*/
+.aerospike-tab-label {
+    font-size: 11px;
+    min-width: 0;
+}
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -5,6 +5,8 @@
    "outDir": "./dist",
    "sourceMap": false,
    "strict": true,
+    "noImplicitAny": false,
+    "skipLibCheck": true,
    "target": "ES2022",
    "lib": [
      "ES2022"
Author	SHA1	Message	Date
Renovate Bot	d73ed80a68	chore(deps): update dependency eslint to v10.0.2 All checks were successful Build and Test / build (pull_request) Successful in 26s Details Build and Test / release (pull_request) Has been skipped Details	2026-03-02 14:13:04 +00:00
Lucas Oskorep	cbaa802797	feat: equal-sized tabs and constantly updated tab titles All checks were successful Build and Test / build (push) Successful in 25s Details Build and Test / release (push) Successful in 3s Details	2026-02-27 12:24:58 -05:00
Lucas Oskorep	e2a1792388	fix: tab bars showing when apps are fullscreen on same monitor All checks were successful Build and Test / build (push) Successful in 25s Details Build and Test / release (push) Successful in 2s Details	2026-02-26 22:06:30 -05:00
Lucas Oskorep	656e448927	feat: add tabbed container layout mode with tab bar UI All checks were successful Build and Test / build (push) Successful in 25s Details Build and Test / release (push) Successful in 3s Details fix: tab bars no longer shown in overview. Tab bars show name of app with pipe and then title of the app	2026-02-26 21:45:40 -05:00
Lucas Oskorep	93516b31fb	fix: new bug from combining resize and move commands - if window has min-size set and resize goes smaller window would not move or resize causing vesktop and steam to frequently break when in arrays on a smaller monitors All checks were successful Build and Test / build (push) Successful in 39s Details Build and Test / release (push) Successful in 10s Details	2026-02-26 01:54:49 -05:00
Lucas Oskorep	918c07c419	Merge pull request 'chore(deps): update dependency eslint to v10' (#16 ) from renovate/major-eslint-monorepo into main All checks were successful Build and Test / build (push) Successful in 25s Details Build and Test / release (push) Successful in 2s Details Reviewed-on: #16	2026-02-25 17:18:42 -05:00
Lucas Oskorep	15188b9990	Merge branch 'main' into renovate/major-eslint-monorepo All checks were successful Build and Test / build (pull_request) Successful in 24s Details Build and Test / release (pull_request) Has been skipped Details	2026-02-25 17:02:44 -05:00
Lucas Oskorep	19696298d0	Merge pull request 'feat/percentage-based-container-sizing' (#18 ) from feat/percentage-based-container-sizing into main All checks were successful Build and Test / build (push) Successful in 23s Details Build and Test / release (push) Successful in 11s Details Reviewed-on: #18	2026-02-25 11:36:39 -05:00
Lucas Oskorep	4be7602316	feat: adding support for changing the size of windows during window resize events to aerospike. Also cleaning up imports and simplifying some of the settings logic. All checks were successful Build and Test / build (pull_request) Successful in 23s Details Build and Test / release (pull_request) Has been skipped Details	2026-02-25 11:35:59 -05:00
Renovate Bot	8f6e8582c9	chore(deps): update dependency eslint to v10 All checks were successful Build and Test / build (pull_request) Successful in 24s Details Build and Test / release (pull_request) Has been skipped Details	2026-02-06 23:13:10 +00:00
Lucas Oskorep	3d2da0a4bc	Update .gitea/workflows/build.yaml All checks were successful Build and Test / build (push) Successful in 24s Details Build and Test / release (push) Successful in 11s Details	2026-01-29 02:47:15 -05:00
Lucas Oskorep	a17441cda3	Merge pull request 'chore(deps): update all-dependencies' (#12 ) from renovate/all into main Some checks failed Build and Test / build (push) Successful in 24s Details Build and Test / release (push) Has been cancelled Details Reviewed-on: #12	2026-01-29 02:46:04 -05:00
Lucas Oskorep	c4f5835424	fix: renovate updating past v3 for upload when v4+ is unsupported in gitea Some checks failed Build and Test / build (pull_request) Successful in 33s Details Build and Test / release (pull_request) Has been cancelled Details	2026-01-29 02:45:04 -05:00
Lucas Oskorep	7773c3b808	feat: update code to work with new libs Some checks failed Build and Test / build (pull_request) Failing after 24s Details Build and Test / release (pull_request) Has been cancelled Details	2026-01-29 02:41:59 -05:00
Renovate Bot	b8e861cf9e	chore(deps): update all-dependencies Some checks failed Build and Test / build (pull_request) Failing after 24s Details Build and Test / release (pull_request) Has been cancelled Details	2026-01-29 02:38:21 -05:00
Lucas Oskorep	318ce6c064	Update .gitea/workflows/build.yaml Some checks failed Build and Test / build (push) Failing after 39s Details Build and Test / release (push) Has been cancelled Details	2026-01-29 02:36:39 -05:00
Lucas Oskorep	1a4d8253f7	Merge pull request 'chore(deps): update all-dependencies' (#10 ) from renovate/all into main Some checks failed Build and Test / build (push) Has been cancelled Details Build and Test / release (push) Has been cancelled Details Reviewed-on: #10	2026-01-29 01:57:18 -05:00
Renovate Bot	86786ba831	chore(deps): update all-dependencies Some checks failed renovate/artifacts Artifact file update failure Build and Test / build (pull_request) Has been cancelled Details Build and Test / release (pull_request) Has been cancelled Details	2026-01-29 06:55:32 +00:00
Lucas Oskorep	bfd027f6c3	Merge pull request 'chore: Configure Renovate' (#8 ) from renovate/configure into main Some checks failed Build and Test / build (push) Has been cancelled Details Build and Test / release (push) Has been cancelled Details Reviewed-on: #8 Reviewed-by: Lucas Oskorep <lucas.oskorep@gmail.com>	2026-01-29 01:46:16 -05:00
Renovate Bot	b46810bc0f	Add renovate.json Some checks failed Build and Test / build (pull_request) Has been cancelled Details Build and Test / release (pull_request) Has been cancelled Details	2026-01-29 06:45:35 +00:00
Lucas Oskorep	c4abd1e8e5	revert `df9bc3e1eb` Some checks failed Build and Test / build (push) Has been cancelled Details Build and Test / release (push) Has been cancelled Details revert Merge pull request 'chore: Configure Renovate' (#1) from renovate/configure into main Reviewed-on: #1	2026-01-29 01:36:37 -05:00
Lucas Oskorep	df9bc3e1eb	Merge pull request 'chore: Configure Renovate' (#1 ) from renovate/configure into main Some checks failed Build and Test / build (push) Has been cancelled Details Build and Test / release (push) Has been cancelled Details Reviewed-on: #1	2026-01-29 01:05:11 -05:00
Renovate Bot	90a4e19751	Add renovate.json Some checks failed Build and Test / build (pull_request) Has been cancelled Details Build and Test / release (pull_request) Has been cancelled Details	2026-01-29 05:44:36 +00:00
Lucas Oskorep	5da4001a32	feat: gitea pipeline fix for upload All checks were successful Build and Test / build (push) Successful in 27s Details Build and Test / release (push) Successful in 11s Details	2025-10-17 02:50:21 -04:00
Lucas Oskorep	9011cd48f2	feat: gitea pipeline fix for upload All checks were successful Build and Test / build (push) Successful in 36s Details	2025-10-17 02:46:56 -04:00
Lucas Oskorep	e065acd37d	feat: gitea pipeline Some checks failed Build and Test / build (push) Failing after 1m2s Details	2025-10-17 02:42:12 -04:00
Lucas Oskorep	b4afd6d4dc	feat: gitea pipeline Some checks failed Build and Test / build (push) Has been cancelled Details	2025-10-17 02:38:04 -04:00
Lucas Oskorep	1ae379868b	feat: adding basic unit tests and framework for them	2025-10-17 02:06:16 -04:00
Lucas Oskorep	8d4e51284d	bugfixes	2025-10-17 01:56:09 -04:00
Lucas Oskorep	9f46347179	feat: cleanup	2025-10-17 01:26:57 -04:00
Lucas Oskorep	5a6c3ccd72	Finish adding debugging command and ability to swap the orientation of a container	2025-10-17 01:25:47 -04:00
Lucas Oskorep	c977c61714	adding debug command	2025-10-17 01:09:13 -04:00
Lucas Oskorep	e615efceb9	feat: removing prettyborders zip	2025-10-17 00:08:57 -04:00
Lucas Oskorep	88623f32d7	feat: update devkit command	2025-10-16 03:44:33 -04:00
Lucas Oskorep	265ff05436	upgrade to gnome 49	2025-09-24 00:55:24 -04:00
Lucas Oskorep	2b86856a97	feat: remove crap code	2025-05-20 18:37:15 -04:00
Lucas Oskorep	a858af73f4	fix: allow windows to be moved in the overview	2025-05-20 01:59:08 -04:00
Lucas Oskorep	ecb5a568cd	fix: bug with window manager resizing a window during grab ops for 1 frame when the background had to be tiled	2025-05-20 01:48:34 -04:00
Lucas Oskorep	5e9bc796ea	feat: enable the window manager to be able to drag across monitors and support keybindings propperly in the extension settings	2025-05-20 01:20:48 -04:00
Lucas Oskorep	04f402c686	feat: upgrade packages and set parent for windows on add	2025-05-19 21:43:09 -04:00
Lucas Oskorep	1d3d9dc402	feat: add ability to change ordering of monitors	2025-05-16 02:58:51 -04:00
Lucas Oskorep	c7f45ecf3b	feat: refactored to monitor -> workspace -> container -> window workflow	2025-05-16 02:01:11 -04:00
Lucas Oskorep	c23b9113ab	feat: adding support for workspaces	2025-05-16 00:19:49 -04:00
Lucas Oskorep	50ceb02124	feat: refactoring	2025-05-04 17:17:33 -04:00
Lucas Oskorep	717c240d70	feat: fixed display signal handling on disable	2025-05-02 01:31:46 -04:00
Lucas Oskorep	822a7bd2e4	Merge branch 'feat/fix-login-issues'	2025-04-30 00:06:03 -04:00
Lucas Oskorep	d59a0fef6d	feat: set nvm version	2025-04-19 02:18:32 +00:00