feat: adding support for multi-monitor window moving

feat: adding active window selection and refactoring keybindings
fix: when new items enter the tabbed view they should be the active window
2026-03-02 23:06:47 -05:00 · 2026-03-02 18:46:26 -05:00 · 2026-03-02 11:26:28 -05: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
22 changed files with 4920 additions and 1237 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/.nvmrc
+++ b/.nvmrc
@@ -1 +1 @@
-v20
+24
--- a/README.md
+++ b/README.md
@@ -1 +1 @@
-# Aerospike Gnome (Tiling Window Manager)
+# Aerospike Gnome (Tiling Window Manager)
--- a/extension.ts
+++ b/extension.ts
@@ -1,9 +1,10 @@
 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/wm/windowManager.js'
+import {Direction} from './src/wm/container.js'
 import {Logger} from "./src/utils/logger.js";

 export default class aerospike extends Extension {
@@ -11,18 +12,23 @@ 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() {
-        Logger.log("STARTING AEROSPIKE!")
-        this.bindSettings();
-        this.setupKeybindings();
-        this.windowManager.enable()
+        try {
+            Logger.log("STARTING AEROSPIKE!")
+            this.bindSettings();
+            this.setupKeybindings();
+            this.windowManager.enable()
+            Logger.log("AEROSPIKE ENABLED SUCCESSFULLY")
+        } catch (e) {
+            Logger.error("AEROSPIKE ENABLE FAILED", e);
+        }
    }

    disable() {
@@ -30,76 +36,41 @@ export default class aerospike extends Extension {
        this.removeKeybindings()
    }

+    private keybindingActions(): Record<string, () => void> {
+        return {
+            'print-tree':         () => { this.windowManager.printTreeStructure(); },
+            'toggle-orientation': () => { this.windowManager.toggleActiveContainerOrientation(); },
+            'reset-ratios':       () => { this.windowManager.resetActiveContainerRatios(); },
+            'toggle-tabbed':      () => { this.windowManager.toggleActiveContainerTabbed(); },
+            'focus-left':         () => { this.windowManager.focusInDirection(Direction.LEFT); },
+            'focus-right':        () => { this.windowManager.focusInDirection(Direction.RIGHT); },
+            'focus-up':           () => { this.windowManager.focusInDirection(Direction.UP); },
+            'focus-down':         () => { this.windowManager.focusInDirection(Direction.DOWN); },
+            'move-left':          () => { this.windowManager.moveInDirection(Direction.LEFT); },
+            'move-right':         () => { this.windowManager.moveInDirection(Direction.RIGHT); },
+            'move-up':            () => { this.windowManager.moveInDirection(Direction.UP); },
+            'move-down':          () => { this.windowManager.moveInDirection(Direction.DOWN); },
+        };
+    }

    private bindSettings() {
-        // Monitor settings changes
-        this.settings.connect('changed::move-left', () => {
-            log(`Keybinding 1 changed to: ${this.settings.get_strv('move-left')}`);
-            this.refreshKeybinding('move-left');
-        });
-
-        this.settings.connect('changed::move-right', () => {
-            log(`Keybinding 2 changed to: ${this.settings.get_strv('move-right')}`);
-            this.refreshKeybinding('move-right');
-        });
-
-        this.settings.connect('changed::join-with-left', () => {
-            log(`Keybinding 3 changed to: ${this.settings.get_strv('join-with-left')}`);
-            this.refreshKeybinding('join-with-left');
-        });
-
-        this.settings.connect('changed::join-with-right', () => {
-            log(`Keybinding 4 changed to: ${this.settings.get_strv('join-with-right')}`);
-            this.refreshKeybinding('join-with-right');
-        });
-
-        this.settings.connect('changed::remove-all-dividers', () => {
-            log(`Keybinding remove-all-dividers changed to: ${this.settings.get_strv('remove-all-dividers')}`);
-            this.refreshKeybinding('remove-all-dividers');
-        });
-
-        this.settings.connect('changed::dropdown-option', () => {
-            log(`Dropdown option changed to: ${this.settings.get_string('dropdown-option')}`);
-        });
-
-        this.settings.connect('changed::color-selection', () => {
-            log(`Color selection changed to: ${this.settings.get_string('color-selection')}`);
+        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);
+            });
        });
    }
+
    private refreshKeybinding(settingName: string) {
        if (this.keyBindings.has(settingName)) {
            Main.wm.removeKeybinding(settingName);
            this.keyBindings.delete(settingName);
        }

-        switch (settingName) {
-            case 'move-left':
-                this.bindKeybinding('move-left', () => {
-                    Logger.info('Keybinding 1 was pressed!');
-                });
-                break;
-            case 'move-right':
-                this.bindKeybinding('move-right', () => {
-                    Logger.info('Keybinding 2 was pressed!');
-                });
-                break;
-            case 'join-with-left':
-                this.bindKeybinding('join-with-left', () => {
-                    Logger.info('Keybinding 3 was pressed!');
-                });
-                break;
-            case 'join-with-right':
-                this.bindKeybinding('join-with-right', () => {
-                    Logger.info('Keybinding 4 was pressed!');
-                });
-                break;
-            case 'remove-all-dividers':
-                this.bindKeybinding('remove-all-dividers', () => {
-                    Logger.info('Remove all dividers keybinding pressed!');
-                    this.windowManager.removeAllDividersFromActiveContainer();
-                });
-                break;
-        }
+        const action = this.keybindingActions()[settingName];
+        if (action) this.bindKeybinding(settingName, action);
    }

    private removeKeybindings() {
@@ -110,26 +81,10 @@ export default class aerospike extends Extension {
    }

    private setupKeybindings() {
-        this.bindKeybinding('move-left', () => {
-            Logger.info('Keybinding 1 was pressed!');
-        });
-
-        this.bindKeybinding('move-right', () => {
-            Logger.info('Keybinding 2 was pressed!');
-        });
-
-        this.bindKeybinding('join-with-left', () => {
-            Logger.info('Keybinding 3 was pressed!');
-        });
-
-        this.bindKeybinding('join-with-right', () => {
-            Logger.info('Keybinding 4 was pressed!');
-        });
-
-        this.bindKeybinding('remove-all-dividers', () => {
-            Logger.info('Remove all dividers keybinding pressed!');
-            this.windowManager.removeAllDividersFromActiveContainer();
-        });
+        const actions = this.keybindingActions();
+        for (const [name, action] of Object.entries(actions)) {
+            this.bindKeybinding(name, action);
+        }
    }

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

        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/18
+++ b/18
@@ -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
@@ -28,13 +28,25 @@ install: build
 	cp -r dist/* ~/.local/share/gnome-shell/extensions/{{NAME}}@{{DOMAIN}}/

 run:
-    env MUTTER_DEBUG_DUMMY_MODE_SPECS=1280x720 dbus-run-session -- gnome-shell --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 | tee debug.log

+test:
+    pnpm test
+
+test-watch:
+    pnpm test:watch
+
+test-coverage:
+    pnpm test:coverage
+
+ci-local:
+    act -W .gitea/workflows/build.yaml
+
 #pack: build
 #    gnome-extensions pack dist \
 #        --force \
@@ -42,4 +54,4 @@ live-debug:
 #        --schema ../schemas/org.gnome.shell.extensions.aerospike.gschema.xml
 #
 #install-pack: pack
-#    gnome-extensions install ./{{FULL_NAME}}.shell-extension.zip --force
+#    gnome-extensions install ./{{FULL_NAME}}.shell-extension.zip --force
--- a/package.json
+++ b/package.json
@@ -15,11 +15,20 @@
  },
  "homepage": "https://github.com/example/my-extension#readme",
  "sideEffects": false,
+  "scripts": {
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage"
+  },
  "devDependencies": {
    "@girs/gjs": "4.0.0-beta.38",
-    "@girs/gnome-shell": "49.0.1",
-    "eslint": "^9.36.0",
-    "eslint-plugin-jsdoc": "^50.8.0",
+    "@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": {
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
--- 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,46 +1,78 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <schemalist>
    <schema id="org.gnome.shell.extensions.aerospike" path="/org/gnome/shell/extensions/aerospike/">
-        <key name="dropdown-option" type="s">
-            <default>'option1'</default>
-            <summary>Dropdown selection</summary>
-            <description>Option selected from the dropdown menu</description>
+
+        <key name="focus-left" type="as">
+            <default><![CDATA[['<Super>h']]]></default>
+            <summary>Focus window to the left</summary>
+            <description>Move focus to the window to the left of the current window. In tabbed mode, switches to the previous tab.</description>
        </key>

-        <key name="color-selection" type="s">
-            <default>'rgb(255,0,0)'</default>
-            <summary>Selected color</summary>
-            <description>Color chosen from the color picker</description>
+        <key name="focus-right" type="as">
+            <default><![CDATA[['<Super>l']]]></default>
+            <summary>Focus window to the right</summary>
+            <description>Move focus to the window to the right of the current window. In tabbed mode, switches to the next tab.</description>
        </key>

+        <key name="focus-up" type="as">
+            <default><![CDATA[['<Super>k']]]></default>
+            <summary>Focus window above</summary>
+            <description>Move focus to the window above the current window.</description>
+        </key>
+
+        <key name="focus-down" type="as">
+            <default><![CDATA[['<Super>j']]]></default>
+            <summary>Focus window below</summary>
+            <description>Move focus to the window below the current window.</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>
+            <default><![CDATA[['<Super><Shift>h']]]></default>
+            <summary>Move window to the left</summary>
+            <description>Move the active window one position to the left within its container</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>
+            <default><![CDATA[['<Super><Shift>l']]]></default>
+            <summary>Move window to the right</summary>
+            <description>Move the active window one position to the right within its container</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 name="move-up" type="as">
+            <default><![CDATA[['<Super><Shift>k']]]></default>
+            <summary>Move window up</summary>
+            <description>Move the active window one position up within its container</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 name="move-down" type="as">
+            <default><![CDATA[['<Super><Shift>j']]]></default>
+            <summary>Move window down</summary>
+            <description>Move the active window one position down within its container</description>
        </key>

-        <key name="remove-all-dividers" type="as">
-            <default><![CDATA[['<Alt>z']]]></default>
-            <summary>Remove all dividers from active container</summary>
-            <description>Keyboard shortcut for removing all dividers from the container with the active window</description>
+        <key name="toggle-orientation" type="as">
+            <default><![CDATA[['<Super>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[['<Super>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[['<Super>slash']]]></default>
+            <summary>Toggle tabbed container mode</summary>
+            <description>Toggles the active window's container between tabbed and accordion layout modes</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>

    </schema>
--- 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/prefs/prefs.ts
+++ b/src/prefs/prefs.ts
@@ -2,7 +2,7 @@ import Adw from 'gi://Adw';
 import Gio from 'gi://Gio';
 import Gtk from 'gi://Gtk';
 import Gdk from 'gi://Gdk';
-import { ExtensionPreferences, gettext as _ } from 'resource:///org/gnome/Shell/Extensions/js/extensions/prefs.js';
+import {ExtensionPreferences, gettext as _} from 'resource:///org/gnome/Shell/Extensions/js/extensions/prefs.js';
 import {Logger} from "../utils/logger.js";
 import {EntryRow} from "./keybindings.js";

@@ -11,150 +11,155 @@ export default class AerospikeExtensions extends ExtensionPreferences {
        // Create settings object
        const settings = this.getSettings('org.gnome.shell.extensions.aerospike');

-        // Create a preferences page
-        const page = new Adw.PreferencesPage({
-            title: _('Settings'),
-            icon_name: 'preferences-system-symbolic',
+        // Create keybindings page (top-level)
+        const keybindingsPage = new Adw.PreferencesPage({
+            title: _('Keybindings'),
+            icon_name: 'input-keyboard-symbolic',
        });
-        window.add(page);
+        window.add(keybindingsPage);

+        const keybindingMap = this.createKeybindingMap();

-        // Create options group
-        const optionsGroup = new Adw.PreferencesGroup({
-            title: _('Options'),
-        });
-        page.add(optionsGroup);
-
-        // Add dropdown
-        const dropdownRow = new Adw.ComboRow({
-            title: _('Select an option'),
-        });
-        optionsGroup.add(dropdownRow);
-
-        // Create dropdown model
-        const dropdownModel = new Gtk.StringList();
-        dropdownModel.append(_('Option 1'));
-        dropdownModel.append(_('Option 2'));
-        dropdownModel.append(_('Option 3'));
-        dropdownModel.append(_('Option 4'));
-
-        dropdownRow.set_model(dropdownModel);
-
-        // Set the active option based on settings
-        const currentOption = settings.get_string('dropdown-option');
-        switch (currentOption) {
-            case 'option1':
-                dropdownRow.set_selected(0);
-                break;
-            case 'option2':
-                dropdownRow.set_selected(1);
-                break;
-            case 'option3':
-                dropdownRow.set_selected(2);
-                break;
-            case 'option4':
-                dropdownRow.set_selected(3);
-                break;
-            default:
-                dropdownRow.set_selected(0);
-        }
-
-        // Connect dropdown change signal
-        dropdownRow.connect('notify::selected', () => {
-            const selected = dropdownRow.get_selected();
-            let optionValue: string;
-
-            switch (selected) {
-                case 0:
-                    optionValue = 'option1';
-                    break;
-                case 1:
-                    optionValue = 'option2';
-                    break;
-                case 2:
-                    optionValue = 'option3';
-                    break;
-                case 3:
-                    optionValue = 'option4';
-                    break;
-                default:
-                    optionValue = 'option1';
-            }
-
-            settings.set_string('dropdown-option', optionValue);
-        });
-
-        // Add color button
-        const colorRow = new Adw.ActionRow({
-            title: _('Choose a color'),
-        });
-        optionsGroup.add(colorRow);
-
-        const colorButton = new Gtk.ColorButton();
-        colorRow.add_suffix(colorButton);
-        colorRow.set_activatable_widget(colorButton);
-
-        // Set current color from settings
-        const colorStr = settings.get_string('color-selection');
-        const rgba = new Gdk.RGBA();
-        rgba.parse(colorStr);
-        colorButton.set_rgba(rgba);
-
-        // Connect color button signal
-        colorButton.connect('color-set', () => {
-            const color = colorButton.get_rgba().to_string();
-            settings.set_string('color-selection', color);
-        });
-
-        // Create keybindings group
-        const keybindingsGroup = new Adw.PreferencesGroup({
-            title: _('Keyboard Shortcuts'),
+        // Top-level Keybindings header group with syntax help
+        const keybindingsHeader = new Adw.PreferencesGroup({
+            title: _('Keybindings'),
            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);
+        keybindingsPage.add(keybindingsHeader);

-        // Add keybinding rows as EntryRows with proper mapping
-        // Use the helper function to create the map object
-        const keybindingMap = this.createKeybindingMap();
-        
-        keybindingsGroup.add(
+        // --- Focus group ---
+        const focusGroup = new Adw.PreferencesGroup({
+            title: _('Focus'),
+        });
+        keybindingsPage.add(focusGroup);
+
+        focusGroup.add(
            new EntryRow({
-                title: _('Action 1'),
+                title: _('Focus Left'),
+                settings: settings,
+                bind: 'focus-left',
+                map: keybindingMap
+            })
+        );
+
+        focusGroup.add(
+            new EntryRow({
+                title: _('Focus Right'),
+                settings: settings,
+                bind: 'focus-right',
+                map: keybindingMap
+            })
+        );
+
+        focusGroup.add(
+            new EntryRow({
+                title: _('Focus Up'),
+                settings: settings,
+                bind: 'focus-up',
+                map: keybindingMap
+            })
+        );
+
+        focusGroup.add(
+            new EntryRow({
+                title: _('Focus Down'),
+                settings: settings,
+                bind: 'focus-down',
+                map: keybindingMap
+            })
+        );
+
+        // --- Move group ---
+        const moveGroup = new Adw.PreferencesGroup({
+            title: _('Move'),
+        });
+        keybindingsPage.add(moveGroup);
+
+        moveGroup.add(
+            new EntryRow({
+                title: _('Move Left'),
                settings: settings,
                bind: 'move-left',
                map: keybindingMap
            })
        );
-        
-        keybindingsGroup.add(
+
+        moveGroup.add(
            new EntryRow({
-                title: _('Action 2'),
+                title: _('Move Right'),
                settings: settings,
                bind: 'move-right',
                map: keybindingMap
            })
        );
-        
-        keybindingsGroup.add(
+
+        moveGroup.add(
            new EntryRow({
-                title: _('Action 3'),
+                title: _('Move Up'),
                settings: settings,
-                bind: 'join-with-left',
-                map: keybindingMap
-            })
-        );
-        
-        keybindingsGroup.add(
-            new EntryRow({
-                title: _('Action 4'),
-                settings: settings,
-                bind: 'join-with-right',
+                bind: 'move-up',
                map: keybindingMap
            })
        );

+        moveGroup.add(
+            new EntryRow({
+                title: _('Move Down'),
+                settings: settings,
+                bind: 'move-down',
+                map: keybindingMap
+            })
+        );
+
+        // --- Container Interactions group ---
+        const containerGroup = new Adw.PreferencesGroup({
+            title: _('Container Interactions'),
+        });
+        keybindingsPage.add(containerGroup);
+
+        containerGroup.add(
+            new EntryRow({
+                title: _('Toggle Orientation'),
+                settings: settings,
+                bind: 'toggle-orientation',
+                map: keybindingMap
+            })
+        );
+
+        containerGroup.add(
+            new EntryRow({
+                title: _('Reset Container Ratios to Equal'),
+                settings: settings,
+                bind: 'reset-ratios',
+                map: keybindingMap
+            })
+        );
+
+        containerGroup.add(
+            new EntryRow({
+                title: _('Toggle Tabbed Mode'),
+                settings: settings,
+                bind: 'toggle-tabbed',
+                map: keybindingMap
+            })
+        );
+
+        // --- Debugging group ---
+        const debuggingGroup = new Adw.PreferencesGroup({
+            title: _('Debugging'),
+        });
+        keybindingsPage.add(debuggingGroup);
+
+        debuggingGroup.add(
+            new EntryRow({
+                title: _('Print Tree Structure'),
+                settings: settings,
+                bind: 'print-tree',
+                map: keybindingMap
+            })
+        );

    }

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

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

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

 export default function queueEvent(event: QueuedEvent, interval = 200) {
-    queuedEvents.push(event);
+    pendingEvents.set(event.name, event);
+
    GLib.timeout_add(GLib.PRIORITY_DEFAULT, interval, () => {
-        const e = queuedEvents.pop()
-        if (e) {
+        const e = pendingEvents.get(event.name);
+        if (e && e === event) {
+            pendingEvents.delete(event.name);
            e.callback();
        }
-        return queuedEvents.length !== 0;
+        return GLib.SOURCE_REMOVE;
    });
-}
+}
--- a/src/wm/container.ts
+++ b/src/wm/container.ts
--- a/src/wm/divider.ts
+++ b/src/wm/divider.ts
@@ -1,45 +0,0 @@
-import {Logger} from "../utils/logger.js";
-
-enum Orientation {
-    HORIZONTAL = 0,
-    VERTICAL = 1,
-}
-
-/**
- * Represents a divider between windows in a container.
- * Dividers track the split position as a ratio (0-1) of the container's size.
- */
-export class Divider {
-    private _position: number; // Position as ratio 0-1
-    private _orientation: Orientation;
-
-    /**
-     * Creates a new divider
-     * @param position - Position as ratio between 0 and 1
-     * @param orientation - Orientation of the divider (HORIZONTAL or VERTICAL)
-     */
-    constructor(position: number, orientation: Orientation) {
-        this._position = Math.max(0, Math.min(1, position)); // Clamp between 0 and 1
-        this._orientation = orientation;
-    }
-
-    getPosition(): number {
-        return this._position;
-    }
-
-    setPosition(position: number): void {
-        this._position = Math.max(0, Math.min(1, position)); // Clamp between 0 and 1
-        Logger.log(`Divider position updated to ${this._position}`);
-    }
-
-    getOrientation(): Orientation {
-        return this._orientation;
-    }
-
-    /**
-     * Check if this is a divider instance
-     */
-    static isDivider(item: any): item is Divider {
-        return item instanceof Divider;
-    }
-}
--- a/src/wm/monitor.ts
+++ b/src/wm/monitor.ts
@@ -1,12 +1,8 @@
 import {WindowWrapper} from "./window.js";
 import {Rect} from "../utils/rect.js";
-import queueEvent from "../utils/events.js";
 import {Logger} from "../utils/logger.js";
-import Meta from "gi://Meta";
-import Mtk from "@girs/mtk-17";

 import WindowContainer from "./container.js";
-import Window = Meta.Window;

 export default class Monitor {

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

-    addWindow(winWrap: WindowWrapper) {
+    addWindow(winWrap: WindowWrapper, index?: number) {
        const window_workspace = winWrap.getWindow().get_workspace().index();
-        this._workspaces[window_workspace].addWindow(winWrap);
+        this._workspaces[window_workspace].addWindow(winWrap, index);
    }

    tileWindows(): void {
-        this._workArea = global.workspace_manager.get_active_workspace().get_work_area_for_monitor(this._id);
        const activeWorkspace = global.workspace_manager.get_active_workspace();
+        this._workArea = activeWorkspace.get_work_area_for_monitor(this._id);
+        // move() calls tileWindows() internally
        this._workspaces[activeWorkspace.index()].move(this._workArea);
-        this._workspaces[activeWorkspace.index()].tileWindows()
    }

    removeWorkspace(workspaceId: number): void {
@@ -79,21 +72,32 @@ export default class Monitor {
        this._workspaces.push(new WindowContainer(this._workArea));
    }

+    focusWindowTab(windowId: number): void {
+        for (const container of this._workspaces) {
+            if (container.focusWindowTab(windowId)) return;
+        }
+    }
+
+    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);
    }
-
-    handleWindowResize(item: WindowWrapper, resizeEdge: Meta.GrabOp, newRect: Rect): void {
-        this._workspaces[item.getWorkspace()].handleWindowResize(item, resizeEdge, newRect);
-    }
-
-    updateDividerDuringResize(item: WindowWrapper, resizeEdge: Meta.GrabOp, newRect: Rect): void {
-        this._workspaces[item.getWorkspace()].updateDividerDuringResize(item, resizeEdge, newRect);
-    }
-
-    removeAllDividersFromActiveContainer(): void {
-        const activeWorkspace = global.workspace_manager.get_active_workspace();
-        this._workspaces[activeWorkspace.index()].removeAllDividers();
-    }
-
-}
+}
--- 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
@@ -11,12 +11,13 @@ 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;
-    _resizing: boolean = false;

    constructor(
        window: Meta.Window,
@@ -46,56 +47,54 @@ export class WindowWrapper {
        return this._window.get_frame_rect();
    }

+    getTabLabel(): string {
+        const rawAppName = this._window.get_wm_class() ?? '';
+        // Strip reverse-domain prefix (e.g. "org.gnome.Nautilus" -> "Nautilus")
+        const lastName = rawAppName.includes('.')
+            ? (rawAppName.split('.').pop() ?? rawAppName)
+            : rawAppName;
+        // Capitalize first letter
+        const appName = lastName.charAt(0).toUpperCase() + lastName.slice(1);
+        const title = this._window.get_title() ?? 'Untitled';
+        if (appName && appName.toLowerCase() !== title.toLowerCase()) {
+            return `${appName} | ${title}`;
+        }
+        return title;
+    }
+
+    hideWindow(): void {
+        const actor = this._window.get_compositor_private() as Clutter.Actor | null;
+        if (actor) actor.hide();
+    }
+
+    showWindow(): void {
+        const actor = this._window.get_compositor_private() as Clutter.Actor | null;
+        if (actor) actor.show();
+    }
+
    startDragging(): void {
        this._dragging = true;
    }
+
    stopDragging(): void {
        Logger.log("STOPPED DRAGGING")
        this._dragging = false;
    }

-    startResizing(): void {
-        this._resizing = true;
-    }
-    stopResizing(): void {
-        this._resizing = false;
-    }
-
-    // setParent(parent: WindowContainer): void {
-    //     this._parent = parent;
-    // }
-    //
-    // getParent(): WindowContainer | null {
-    //     if (this._parent == null) {
-    //         Logger.warn(`Attempting to get parent for window without parent ${JSON.stringify(this)}`);
-    //     }
-    //     return this._parent
-    // }
-
-    connectWindowSignals(
-        windowManager: IWindowManager,
-    ): void {
-        const windowId = this._window.get_id()
-        // Handle window destruction
+    connectWindowSignals(windowManager: IWindowManager): void {
+        const windowId = this._window.get_id();
        this._signals.push(
-            this._window.connect('unmanaging', window => {
+            this._window.connect('unmanaging', () => {
                Logger.log("REMOVING WINDOW", windowId);
-                windowManager.handleWindowClosed(this)
+                windowManager.handleWindowClosed(this);
            }),
-            this._window.connect('notify::minimized', (we) => {
+            this._window.connect('notify::minimized', () => {
                if (this._window.minimized) {
                    Logger.log(`Window minimized: ${windowId}`);
                    windowManager.handleWindowMinimized(this);
-
-                } else if (!this._window.minimized) {
+                } else {
                    Logger.log(`Window unminimized: ${windowId}`);
                    windowManager.handleWindowUnminimized(this);
-
-                }
-            }),
-            this._window.connect('notify::has-focus', () => {
-                if (this._window.has_focus()) {
-                    windowManager._activeWindowId = windowId;
                }
            }),
            this._window.connect('notify::maximized-horizontally', () => {
@@ -105,18 +104,23 @@ export class WindowWrapper {
                    Logger.log(`Window unmaximized: ${windowId}`);
                }
            }),
-            this._window.connect("workspace-changed", (_metaWindow) => {
+            this._window.connect("workspace-changed", () => {
                Logger.log("WORKSPACE CHANGED FOR WINDOW", this._window.get_id());
                windowManager.handleWindowChangedWorkspace(this);
            }),
-            this._window.connect("position-changed", (_metaWindow) => {
+            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 {
@@ -130,43 +134,54 @@ export class WindowWrapper {
        }
    }

-    safelyResizeWindow(rect: Rect, _retry: number = 2): void {
-        // Keep minimal logging
-        if (this._dragging && !this._resizing) {
-            // During drag operations (not resize), skip this entirely
+    safelyResizeWindow(rect: Rect, _retry: number = 3): void {
+        if (this._dragging) {
+            Logger.info("STOPPED RESIZE BECAUSE ITEM IS BEING DRAGGED");
            return;
        }
-        // Logger.log("SAFELY RESIZE", rect.x, rect.y, rect.width, rect.height);
-        const actor = this._window.get_compositor_private();

+        const actor = this._window.get_compositor_private() as Clutter.Actor | null;
        if (!actor) {
            Logger.log("No actor available, can't resize safely yet");
            return;
        }
-        let windowActor = this._window.get_compositor_private() as Clutter.Actor;
-        if (!windowActor) return;
-        windowActor.remove_all_transitions();
-        // Logger.info("MOVING")
+
+        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);
-        // Logger.info("RESIZING MOVING")
        this._window.move_resize_frame(true, rect.x, rect.y, rect.width, rect.height);

-        // Don't retry during live resize operations - it causes spam and isn't needed
-        if (this._resizing) {
-            return;
-        }
+        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;

-        let new_rect = this._window.get_frame_rect();
-        if ( _retry > 0 && (new_rect.x != rect.x || rect.y != new_rect.y || rect.width < new_rect.width || rect.height < new_rect.height)) {
-            Logger.warn("RESIZING FAILED AS SMALLER", new_rect.x, new_rect.y, new_rect.width, new_rect.height, rect.x, rect.y, rect.width, rect.height);
-            queueEvent({
-                name: "attempting_delayed_resize",
-                callback: () => {
-                    this.safelyResizeWindow(rect, _retry-1);
-                }
-            })
+        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
@@ -1,19 +1,17 @@
 import Meta from "gi://Meta";
-// import Gio from "gi://Gio";
-// import GLib from "gi://GLib";
+import Gio from "gi://Gio";

 import {WindowWrapper} from './window.js';
 import * as Main from "resource:///org/gnome/shell/ui/main.js";
-// import Mtk from "@girs/mtk-16";
 import {Logger} from "../utils/logger.js";
 import Monitor from "./monitor.js";
+import WindowContainer, {Direction, Layout} from "./container.js";
+import {Rect} from "../utils/rect.js";


 export interface IWindowManager {
    _activeWindowId: number | null;

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

    handleWindowMinimized(winWrap: WindowWrapper): void;
@@ -24,12 +22,14 @@ export interface IWindowManager {

    handleWindowPositionChanged(winWrap: WindowWrapper): void;

+    handleWindowTitleChanged(winWrap: WindowWrapper): void;
+
    syncActiveWindow(): number | null;
 }


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

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

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

    _grabbedWindowMonitor: number = _UNUSED_MONITOR_ID;
    _grabbedWindowId: number = _UNUSED_WINDOW_ID;
-    _grabbedOp: Meta.GrabOp | null = null;
    _changingGrabbedMonitor: boolean = false;
-
    _showingOverview: boolean = false;

-    constructor() {
+    // -- 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");
-        // Connect window signals
        this.instantiateDisplaySignals();

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

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

    instantiateDisplaySignals(): void {
@@ -87,7 +93,9 @@ export default class WindowManager implements IWindowManager {
            global.display.connect('window-created', (display, window) => {
                this.handleWindowCreated(display, window);
            }),
-
+            global.display.connect('notify::focus-window', () => {
+                this.syncActiveWindow();
+            }),
            global.display.connect("showing-desktop-changed", () => {
                Logger.log("SHOWING DESKTOP CHANGED");
            }),
@@ -97,14 +105,9 @@ export default class WindowManager implements IWindowManager {
            }),
            global.display.connect("in-fullscreen-changed", () => {
                Logger.log("IN FULL SCREEN CHANGED");
+                this._syncFullscreenTabBars();
            }),
-        )
-
-        // this._windowManagerSignals = [
-        //     global.window_manager.connect("show-tile-preview", (_, _metaWindow, _rect, _num) => {
-        //         Logger.log("SHOW TITLE PREVIEW!")
-        //     }),
-        // ];
+        );

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

        this._overviewSignals = [
            Main.overview.connect("hiding", () => {
-                // this.fromOverview = true;
                Logger.log("HIDING OVERVIEW")
                this._showingOverview = false;
                this._tileMonitors();
-                // const eventObj = {
-                //     name: "focus-after-overview",
-                //     callback: () => {
-                //         Logger.log("FOCUSING AFTER OVERVIEW");
-                //     },
-                // };
-                // this.queueEvent(eventObj);
+                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!")
-        // Disconnect the focus signal and remove any existing borders
        this.disconnectSignals();
        this.removeAllWindows();
    }

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

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

-
-    handleGrabOpBegin(display: Meta.Display, window: Meta.Window, op: Meta.GrabOp): void {
-        if (op === Meta.GrabOp.MOVING_UNCONSTRAINED){
-
-        }
-        Logger.log("Grab Op Start", op);
-        Logger.log(display, window, op)
-        Logger.log(window.get_monitor())
-
-        const winWrap = this._getWrappedWindow(window);
-        if (this._isResizeOp(op)) {
-            winWrap?.startResizing();
-        } else {
-            winWrap?.startDragging();
-        }
-
-        this._grabbedWindowMonitor = window.get_monitor();
-        this._grabbedWindowId = window.get_id();
-        this._grabbedOp = op;
-    }
-
-    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())
-
-        // Handle resize operations
-        if (this._isResizeOp(op)) {
-            const winWrap = this._getWrappedWindow(window);
-            if (winWrap && this._grabbedOp) {
-                const newRect = window.get_frame_rect();
-                const monitorId = window.get_monitor();
-                Logger.log(`Handling resize operation: ${op}, new rect:`, newRect);
-                this._monitors.get(monitorId)?.handleWindowResize(winWrap, this._grabbedOp, newRect);
-                winWrap.stopResizing();
-            }
-        } else {
-            this._getWrappedWindow(window)?.stopDragging();
-        }
-
-        this._grabbedWindowId = _UNUSED_WINDOW_ID;
-        this._grabbedOp = null;
-        this._tileMonitors();
-        Logger.info("monitor_start and monitor_end", this._grabbedWindowMonitor, window.get_monitor());
-    }
-
-    private _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 ||
+    _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 = undefined;
+        let wrapped: WindowWrapper | undefined = undefined;
        for (const monitor of this._monitors.values()) {
            wrapped = monitor.getWindow(window.get_id());
-            if (wrapped !== undefined) {
-                break;
-            }
+            if (wrapped !== undefined) break;
        }
        return wrapped;
    }

    _getAndRemoveWrappedWindow(window: Meta.Window): WindowWrapper | undefined {
-        let wrapped = undefined;
+        let wrapped: WindowWrapper | undefined = undefined;
        for (const monitor of this._monitors.values()) {
            wrapped = monitor.getWindow(window.get_id());
            if (wrapped !== undefined) {
@@ -281,7 +271,7 @@ export default class WindowManager implements IWindowManager {
        let wrapped = this._getAndRemoveWrappedWindow(window);
        if (wrapped === undefined) {
            Logger.error("WINDOW NOT DEFINED")
-            wrapped = new WindowWrapper(window, this.handleWindowMinimized);
+            wrapped = new WindowWrapper(window, (winWrap) => this.handleWindowMinimized(winWrap));
            wrapped.connectWindowSignals(this);
        }
        let new_mon = this._monitors.get(monitorId);
@@ -290,16 +280,10 @@ export default class WindowManager implements IWindowManager {
    }

    public handleWindowPositionChanged(winWrap: WindowWrapper): void {
-        if (this._changingGrabbedMonitor) {
-            return;
-        }
+        if (this._isTiling || this._changingGrabbedMonitor) return;

-        // Handle resize operations - update dividers in real-time
-        if (this._grabbedOp && this._isResizeOp(this._grabbedOp)) {
-            const window = winWrap.getWindow();
-            const newRect = window.get_frame_rect();
-            const monitorId = window.get_monitor();
-            this._monitors.get(monitorId)?.updateDividerDuringResize(winWrap, this._grabbedOp, newRect);
+        if (this._isResizeDrag && winWrap.getWindowId() === this._resizeDragWindowId) {
+            this._handleResizeDragUpdate(winWrap);
            return;
        }

@@ -315,19 +299,82 @@ export default class WindowManager implements IWindowManager {
                    break;
                }
            }
-            if (monitorIndex === -1) {
-                return
-            }
+            if (monitorIndex === -1) return;

            if (monitorIndex !== this._grabbedWindowMonitor) {
                this._changingGrabbedMonitor = true;
                this._moveWindowToMonitor(winWrap.getWindow(), monitorIndex);
-                this._changingGrabbedMonitor = false
+                this._changingGrabbedMonitor = false;
+            }
+
+            this._isTiling = true;
+            try {
+                this._monitors.get(monitorIndex)?.itemDragged(winWrap, mouseX, mouseY);
+            } finally {
+                this._isTiling = false;
            }
-            this._monitors.get(monitorIndex)?.itemDragged(winWrap, mouseX, mouseY);
        }
    }

+    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()
@@ -342,7 +389,6 @@ export default class WindowManager implements IWindowManager {
        this._tileMonitors()
    }

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

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

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

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

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

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

-    _tileMonitors(): void {
+    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();
+            }
+        }
+    }

-        for (const monitor of this._monitors.values()) {
-            monitor.tileWindows()
+    _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;
        }
    }

@@ -417,7 +469,7 @@ export default class WindowManager implements IWindowManager {
        "org.gnome.Shell.Extensions",
    ]

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

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

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

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

-    /**
-     * Synchronizes the active window with GNOME's currently active window
-     *
-     * This function queries GNOME Shell for the current focused window and
-     * updates the extension's active window tracking to match.
-     *
-     * @returns The window ID of the active window, or null if no window is active
-     */
    public syncActiveWindow(): number | null {
+        const focusWindow = global.display.focus_window;
+        if (focusWindow) {
+            this._activeWindowId = focusWindow.get_id();
+            Logger.debug(`Active window changed to: ${this._activeWindowId} (${focusWindow.get_title()})`);
+
+            // If the focused window is inside a tabbed container, make it the active tab
+            const monId = focusWindow.get_monitor();
+            this._monitors.get(monId)?.focusWindowTab(this._activeWindowId);
+        } 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");
+        }
+    }
+
+    /**
+     * Move the active window in the given direction.
+     *
+     * 1. Find the container holding the active window.
+     * 2. Try to swap within the container (adjacent neighbour).
+     * 3. If already at the container edge, move the window to the
+     *    nearest monitor in that direction instead.
+     * 4. Re-tile to apply the new layout.
+     */
+    public moveInDirection(direction: Direction): void {
+        if (this._activeWindowId === null) {
+            Logger.warn("No active window, cannot move in direction");
+            return;
+        }
+
+        const container = this._findContainerForWindowAcrossMonitors(this._activeWindowId);
+        if (!container) {
+            Logger.warn("Could not find container for active window");
+            return;
+        }
+
+        const swapped = container.swapWindowInDirection(this._activeWindowId, direction);
+        if (swapped) {
+            Logger.info(`Moved window ${this._activeWindowId} ${direction}`);
+            this._tileMonitors();
+            return;
+        }
+
+        this._moveWindowCrossMonitor(this._activeWindowId, direction);
+    }
+
+    /**
+     * Move focus to the adjacent window in the given direction.
+     *
+     * 1. Find the container holding the active window.
+     * 2. Ask the container for the adjacent window in that direction.
+     * 3. If the container returns null (at the edge), try cross-monitor navigation.
+     * 4. Activate (focus) the target window.
+     */
+    public focusInDirection(direction: Direction): void {
+        if (this._activeWindowId === null) {
+            Logger.warn("No active window, cannot focus in direction");
+            return;
+        }
+
+        const container = this._findContainerForWindowAcrossMonitors(this._activeWindowId);
+        if (!container) {
+            Logger.warn("Could not find container for active window");
+            return;
+        }
+
+        const targetId = container.getAdjacentWindowId(this._activeWindowId, direction);
+        if (targetId !== null) {
+            this._activateWindowById(targetId);
+            return;
+        }
+
+        // At the edge of the container — try cross-monitor navigation
+        const crossMonitorId = this._findCrossMonitorWindow(direction);
+        if (crossMonitorId !== null) {
+            this._activateWindowById(crossMonitorId);
+        }
+    }
+
+    /**
+     * Focus a window by its ID. Finds the Meta.Window and calls activate().
+     */
+    private _activateWindowById(windowId: number): void {
+        for (const monitor of this._monitors.values()) {
+            const wrapped = monitor.getWindow(windowId);
+            if (wrapped) {
+                const metaWindow = wrapped.getWindow();
+                metaWindow.activate(global.get_current_time());
+                return;
+            }
+        }
+        Logger.warn(`_activateWindowById: window ${windowId} not found in any monitor`);
+    }
+
+    /**
+     * Find the adjacent monitor in the given direction from a current monitor.
+     * Returns the monitor ID or null if none exists in that direction.
+     */
+    private _findAdjacentMonitorId(currentMonitorId: number, direction: Direction): number | null {
+        const currentMonitor = this._monitors.get(currentMonitorId)!;
+        const currentArea = currentMonitor._workArea;
+        const currentCenterX = currentArea.x + currentArea.width / 2;
+        const currentCenterY = currentArea.y + currentArea.height / 2;
+
+        let bestMonitorId: number | null = null;
+        let bestDistance = Infinity;
+
+        for (const [monId, monitor] of this._monitors.entries()) {
+            if (monId === currentMonitorId) continue;
+
+            const area = monitor._workArea;
+            const centerX = area.x + area.width / 2;
+            const centerY = area.y + area.height / 2;
+
+            let isInDirection = false;
+            let distance = Infinity;
+
+            switch (direction) {
+                case Direction.LEFT:
+                    isInDirection = centerX < currentCenterX;
+                    distance = currentCenterX - centerX;
+                    break;
+                case Direction.RIGHT:
+                    isInDirection = centerX > currentCenterX;
+                    distance = centerX - currentCenterX;
+                    break;
+                case Direction.UP:
+                    isInDirection = centerY < currentCenterY;
+                    distance = currentCenterY - centerY;
+                    break;
+                case Direction.DOWN:
+                    isInDirection = centerY > currentCenterY;
+                    distance = centerY - currentCenterY;
+                    break;
+            }
+
+            if (isInDirection && distance < bestDistance) {
+                bestDistance = distance;
+                bestMonitorId = monId;
+            }
+        }
+
+        return bestMonitorId;
+    }
+
+    /**
+     * Return the monitor ID that contains the given window, or null.
+     */
+    private _findMonitorIdForWindow(windowId: number): number | null {
+        for (const [monId, monitor] of this._monitors.entries()) {
+            if (monitor.getWindow(windowId) !== undefined) return monId;
+        }
        return null;
    }

    /**
-     * Removes all dividers from the container with the currently active window
+     * When at the edge of a container, find the nearest window on the adjacent
+     * monitor in the given direction.
+     *
+     * On the target monitor, picks the edge-most window:
+     *   - Navigating LEFT/UP   → last (far-edge) leaf window
+     *   - Navigating RIGHT/DOWN → first (near-edge) leaf window
     */
-    public removeAllDividersFromActiveContainer(): void {
-        const activeWindow = global.display.focus_window;
-        if (!activeWindow) {
-            Logger.log("No active window, cannot remove dividers");
-            return;
-        }
+    private _findCrossMonitorWindow(direction: Direction): number | null {
+        if (this._activeWindowId === null) return null;

-        const monitorId = activeWindow.get_monitor();
-        const monitor = this._monitors.get(monitorId);
+        const currentMonitorId = this._findMonitorIdForWindow(this._activeWindowId);
+        if (currentMonitorId === null) return null;

-        if (monitor) {
-            Logger.log(`Removing all dividers from monitor ${monitorId}`);
-            monitor.removeAllDividersFromActiveContainer();
-        } else {
-            Logger.warn(`Monitor ${monitorId} not found`);
-        }
+        const targetMonitorId = this._findAdjacentMonitorId(currentMonitorId, direction);
+        if (targetMonitorId === null) return null;
+
+        const targetMonitor = this._monitors.get(targetMonitorId)!;
+        const activeWorkspaceIndex = global.workspace_manager.get_active_workspace().index();
+        if (activeWorkspaceIndex >= targetMonitor._workspaces.length) return null;
+
+        const targetContainer = targetMonitor._workspaces[activeWorkspaceIndex];
+        if (targetContainer._tiledItems.length === 0) return null;
+
+        return (direction === Direction.LEFT || direction === Direction.UP)
+            ? targetContainer._lastLeafWindowId()
+            : targetContainer._firstLeafWindowId();
    }

+    /**
+     * Move a window to the adjacent monitor in the given direction.
+     *
+     * The window is inserted at the "entry edge" of the target container:
+     *   - Moving RIGHT/DOWN → position 0 (near edge)
+     *   - Moving LEFT/UP    → end of the container (far edge)
+     */
+    private _moveWindowCrossMonitor(windowId: number, direction: Direction): void {
+        const currentMonitorId = this._findMonitorIdForWindow(windowId);
+        if (currentMonitorId === null) return;

+        const targetMonitorId = this._findAdjacentMonitorId(currentMonitorId, direction);
+        if (targetMonitorId === null) return;
+
+        const currentMonitor = this._monitors.get(currentMonitorId)!;
+        const wrapped = currentMonitor.getWindow(windowId);
+        if (!wrapped) return;
+
+        const targetMonitor = this._monitors.get(targetMonitorId)!;
+        const insertIndex = (direction === Direction.RIGHT || direction === Direction.DOWN) ? 0 : undefined;
+
+        currentMonitor.removeWindow(wrapped);
+        targetMonitor.addWindow(wrapped, insertIndex);
+
+        this._tileMonitors();
+        Logger.info(`Moved window ${windowId} to monitor ${targetMonitorId} (${direction})`);
+    }
+
+    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/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
Lucas Oskorep	696269d8b8	feat: adding support for multi-monitor window moving Some checks failed Build and Test / release (push) Has been cancelled Details Build and Test / build (push) Has been cancelled Details Build and Test / build (pull_request) Successful in 24s Details Build and Test / release (pull_request) Has been skipped Details	2026-03-02 23:06:47 -05:00
Lucas Oskorep	fa021b08eb	feat: adding active window selection and refactoring keybindings	2026-03-02 18:46:26 -05:00
Lucas Oskorep	8ed5f104b2	fix: when new items enter the tabbed view they should be the active window All checks were successful Build and Test / build (push) Successful in 25s Details Build and Test / release (push) Successful in 3s Details	2026-03-02 11:26:28 -05: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