feat: gitea pipeline fix for upload

.gitea/workflows/build.yaml

@@ -0,0 +1,99 @@
+name: Build and Test
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    branches:
+      - main
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    container:
+      image: node:20
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - 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: ubuntu-latest
+    if: github.ref == 'refs/heads/main' && github.event_name == 'push'
+    environment:
+      name: production
+    container:
+      image: node:20
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - 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"

extension.ts

@@ -53,9 +53,14 @@ export default class aerospike extends Extension {
             this.refreshKeybinding('join-with-right');
         });
 
-        this.settings.connect('changed::reset-window-sizes', () => {
+        this.settings.connect('changed::print-tree', () => {
-            log(`Reset window sizes keybinding changed to: ${this.settings.get_strv('reset-window-sizes')}`);
+            log(`Print tree keybinding changed to: ${this.settings.get_strv('print-tree')}`);
-            this.refreshKeybinding('reset-window-sizes');
+            this.refreshKeybinding('print-tree');
+        });
+
+        this.settings.connect('changed::toggle-orientation', () => {
+            log(`Toggle orientation keybinding changed to: ${this.settings.get_strv('toggle-orientation')}`);
+            this.refreshKeybinding('toggle-orientation');
         });
 
         this.settings.connect('changed::dropdown-option', () => {
@@ -93,9 +98,14 @@ export default class aerospike extends Extension {
                     Logger.info('Keybinding 4 was pressed!');
                 });
                 break;
-            case 'reset-window-sizes':
+            case 'print-tree':
-                this.bindKeybinding('reset-window-sizes', () => {
+                this.bindKeybinding('print-tree', () => {
-                    this.windowManager.resetAllWindowSizes();
+                    this.windowManager.printTreeStructure();
+                });
+                break;
+            case 'toggle-orientation':
+                this.bindKeybinding('toggle-orientation', () => {
+                    this.windowManager.toggleActiveContainerOrientation();
                 });
                 break;
         }
@@ -125,8 +135,12 @@ export default class aerospike extends Extension {
             Logger.info('Keybinding 4 was pressed!');
         });
 
-        this.bindKeybinding('reset-window-sizes', () => {
+        this.bindKeybinding('print-tree', () => {
-            this.windowManager.resetAllWindowSizes();
+            this.windowManager.printTreeStructure();
+        });
+
+        this.bindKeybinding('toggle-orientation', () => {
+            this.windowManager.toggleActiveContainerOrientation();
         });
     }
 

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/'],
+};

justfile

@@ -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 --devkit
+    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 \

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",
+    "@jest/globals": "^29.7.0",
+    "@types/jest": "^29.5.12",
     "eslint": "^9.36.0",
     "eslint-plugin-jsdoc": "^50.8.0",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.1.2",
     "typescript": "^5.9.2"
   },
   "dependencies": {

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

@@ -37,10 +37,16 @@
             <description>Keyboard shortcut for triggering action 4</description>
         </key>
 
-        <key name="reset-window-sizes" type="as">
+        <key name="print-tree" type="as">
-            <default><![CDATA[['<Alt>z']]]></default>
+            <default><![CDATA[['<Super><Shift>x']]]></default>
-            <summary>Reset all window sizes</summary>
+            <summary>Print window tree structure</summary>
-            <description>Remove all custom window sizes and return to equal distribution</description>
+            <description>Prints the current tree of containers and windows per monitor to logs</description>
+        </key>
+
+        <key name="toggle-orientation" type="as">
+            <default><![CDATA[['<Super><Shift>comma']]]></default>
+            <summary>Toggle active container orientation</summary>
+            <description>Toggles the orientation of the container holding the active window between horizontal and vertical</description>
         </key>
 
     </schema>

src/__tests__/container.test.ts

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

src/__tests__/rect.test.ts

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

src/prefs/prefs.ts

@@ -155,6 +155,24 @@ export default class AerospikeExtensions extends ExtensionPreferences {
             })
         );
 
+        keybindingsGroup.add(
+            new EntryRow({
+                title: _('Print Tree Structure'),
+                settings: settings,
+                bind: 'print-tree',
+                map: keybindingMap
+            })
+        );
+
+        keybindingsGroup.add(
+            new EntryRow({
+                title: _('Toggle Orientation'),
+                settings: settings,
+                bind: 'toggle-orientation',
+                map: keybindingMap
+            })
+        );
+
 
     }
 

src/wm/container.ts

@@ -16,13 +16,11 @@ export default class WindowContainer {
     _tiledWindowLookup: Map<number, WindowWrapper>;
     _orientation: Orientation = Orientation.HORIZONTAL;
     _workArea: Rect;
-    _customSizes: Map<number, number>;  // Maps index to custom width (horizontal) or height (vertical)
 
     constructor(workspaceArea: Rect,) {
         this._tiledItems = [];
         this._tiledWindowLookup = new Map<number, WindowWrapper>();
         this._workArea = workspaceArea;
-        this._customSizes = new Map<number, number>();
     }
 
 
@@ -31,8 +29,15 @@ export default class WindowContainer {
         this.tileWindows();
     }
 
+    toggleOrientation(): void {
+        this._orientation = this._orientation === Orientation.HORIZONTAL
+            ? Orientation.VERTICAL
+            : Orientation.HORIZONTAL;
+        Logger.info(`Container orientation toggled to ${this._orientation === Orientation.HORIZONTAL ? 'HORIZONTAL' : 'VERTICAL'}`);
+        this.tileWindows();
+    }
+
     addWindow(winWrap: WindowWrapper): void {
-        // Add window to managed windows
         this._tiledItems.push(winWrap);
         this._tiledWindowLookup.set(winWrap.getWindowId(), winWrap);
         queueEvent({
@@ -73,11 +78,12 @@ export default class WindowContainer {
 
     removeWindow(win_id: number): void {
         if (this._tiledWindowLookup.has(win_id)) {
+            // Get index before deleting from lookup to avoid race condition
+            const index = this._getIndexOfWindow(win_id);
             this._tiledWindowLookup.delete(win_id);
-            const index = this._getIndexOfWindow(win_id)
+            if (index !== -1) {
-            this._tiledItems.splice(index, 1);
+                this._tiledItems.splice(index, 1);
-            // Shift custom sizes after removed index
+            }
-            this._shiftCustomSizesAfterRemoval(index);
         } else {
             for (const item of this._tiledItems) {
                 if (item instanceof WindowContainer) {
@@ -88,100 +94,6 @@ export default class WindowContainer {
         this.tileWindows()
     }
 
-    _shiftCustomSizesAfterRemoval(removedIndex: number): void {
-        Logger.log(`=== _shiftCustomSizesAfterRemoval called ===`);
-        Logger.log(`Removed index: ${removedIndex}`);
-        Logger.log(`Total items after removal: ${this._tiledItems.length}`);
-        Logger.log(`Custom sizes Map size: ${this._customSizes.size}`);
-
-        // Convert Map to readable string
-        let customSizesStr = "{ ";
-        this._customSizes.forEach((size, index) => {
-            customSizesStr += `${index}: ${size}px, `;
-        });
-        customSizesStr += "}";
-        Logger.log(`Custom sizes before shift: ${customSizesStr}`);
-
-        // Calculate the removed window's size (could be custom or flexible)
-        let removedSize = this._customSizes.get(removedIndex);
-
-        if (removedSize === undefined) {
-            // Window didn't have custom size, calculate its flexible size
-            // Count items BEFORE removal (add 1 to current length)
-            const numItemsBeforeRemoval = this._tiledItems.length + 1;
-            let totalCustomSize = 0;
-            let numFlexibleItemsBeforeRemoval = 0;
-
-            this._customSizes.forEach((size, index) => {
-                totalCustomSize += size;
-                // Don't count this in flexible if it's the removed index
-            });
-            numFlexibleItemsBeforeRemoval = numItemsBeforeRemoval - this._customSizes.size;
-
-            const containerSize = this._orientation === Orientation.HORIZONTAL ? this._workArea.width : this._workArea.height;
-            const remainingSize = containerSize - totalCustomSize;
-            removedSize = numFlexibleItemsBeforeRemoval > 0 ? Math.floor(remainingSize / numFlexibleItemsBeforeRemoval) : 0;
-
-            Logger.log(`Removed window was flexible, calculated size: ${removedSize}px (${numFlexibleItemsBeforeRemoval} flexible windows before removal)`);
-        } else {
-            Logger.log(`Removed window had custom size: ${removedSize}px`);
-        }
-
-        // Rebuild the custom sizes map with shifted indices
-        const newCustomSizes = new Map<number, number>();
-        this._customSizes.forEach((size, index) => {
-            if (index < removedIndex) {
-                // Keep indices before removal
-                Logger.log(`Keeping index ${index} with size ${size}`);
-                newCustomSizes.set(index, size);
-            } else if (index > removedIndex) {
-                // Shift down indices after removal
-                Logger.log(`Shifting index ${index} -> ${index - 1} with size ${size}`);
-                newCustomSizes.set(index - 1, size);
-            }
-            // Skip the removed index
-        });
-
-        Logger.log(`New custom sizes Map size after shift: ${newCustomSizes.size}`);
-        let afterShiftStr = "{ ";
-        newCustomSizes.forEach((size, index) => {
-            afterShiftStr += `${index}: ${size}px, `;
-        });
-        afterShiftStr += "}";
-        Logger.log(`Custom sizes after index shift: ${afterShiftStr}`);
-
-        // Distribute removed window's size among remaining custom-sized windows only
-        // Flexible windows will naturally absorb their share through the bounds calculation
-        const remainingWindowCount = this._tiledItems.length;
-        const numCustomWindows = newCustomSizes.size;
-
-        if (removedSize > 0 && remainingWindowCount > 0 && numCustomWindows > 0) {
-            const sizePerCustomWindow = Math.floor(removedSize / numCustomWindows);
-
-            Logger.log(`Distributing ${removedSize}px among ${numCustomWindows} custom-sized windows (${sizePerCustomWindow}px each)`);
-            Logger.log(`Flexible windows will naturally absorb remaining space`);
-
-            // Add proportional size only to windows that already have custom sizes
-            newCustomSizes.forEach((size, index) => {
-                const newSize = size + sizePerCustomWindow;
-                Logger.log(`Index ${index}: ${size}px + ${sizePerCustomWindow}px = ${newSize}px`);
-                newCustomSizes.set(index, newSize);
-            });
-        } else {
-            Logger.log(`Not distributing space - removedSize: ${removedSize}, remainingWindows: ${remainingWindowCount}, customWindows: ${numCustomWindows}`);
-        }
-
-        let finalStr = "{ ";
-        newCustomSizes.forEach((size, index) => {
-            finalStr += `${index}: ${size}px, `;
-        });
-        finalStr += "}";
-        Logger.log(`Final custom sizes: ${finalStr}`);
-
-        this._customSizes = newCustomSizes;
-        Logger.log(`=== _shiftCustomSizesAfterRemoval complete ===`);
-    }
-
     disconnectSignals(): void {
         this._tiledItems.forEach((item) => {
                 if (item instanceof WindowContainer) {
@@ -198,15 +110,17 @@ export default class WindowContainer {
         this._tiledWindowLookup.clear()
     }
 
-    tileWindows(skipRetry: boolean = false) {
+    tileWindows() {
         Logger.log("TILING WINDOWS IN CONTAINER")
+
         Logger.log("WorkArea", this._workArea);
-        this._tileItems(skipRetry)
+
+        this._tileItems()
 
         return true
     }
 
-    _tileItems(skipRetry: boolean = false) {
+    _tileItems() {
         if (this._tiledItems.length === 0) {
             return;
         }
@@ -216,7 +130,7 @@ export default class WindowContainer {
             if (item instanceof WindowContainer) {
                 item.move(rect);
             } else {
-                item.safelyResizeWindow(rect, 2, skipRetry);
+                item.safelyResizeWindow(rect);
             }
         })
     }
@@ -230,88 +144,30 @@ export default class WindowContainer {
     }
 
     getVerticalBounds(): Rect[] {
-        // Calculate available height after accounting for custom-sized windows
+        const items = this._tiledItems
-        let totalCustomHeight = 0;
+        const containerHeight = Math.floor(this._workArea.height / items.length);
-        let numFlexibleItems = 0;
+        return items.map((_, index) => {
-
+            const y = this._workArea.y + (index * containerHeight);
-        this._tiledItems.forEach((item, index) => {
+            return {
-            if (this._customSizes.has(index)) {
-                totalCustomHeight += this._customSizes.get(index)!;
-            } else {
-                numFlexibleItems++;
-            }
-        });
-
-        // Ensure custom sizes don't exceed container height
-        if (totalCustomHeight > this._workArea.height) {
-            Logger.warn("Custom heights exceed container, resetting all sizes");
-            this._customSizes.clear();
-            totalCustomHeight = 0;
-            numFlexibleItems = this._tiledItems.length;
-        }
-
-        const remainingHeight = this._workArea.height - totalCustomHeight;
-        const flexHeight = numFlexibleItems > 0 ? Math.floor(remainingHeight / numFlexibleItems) : 0;
-
-        // Build the bounds array
-        let currentY = this._workArea.y;
-        return this._tiledItems.map((item, index) => {
-            let height = flexHeight;
-            if (this._customSizes.has(index)) {
-                height = this._customSizes.get(index)!;
-            }
-
-            const rect = {
                 x: this._workArea.x,
-                y: currentY,
+                y: y,
                 width: this._workArea.width,
-                height: height
+                height: containerHeight
             } as Rect;
-            currentY += height;
-            return rect;
         });
     }
 
     getHorizontalBounds(): Rect[] {
-        // Calculate available width after accounting for custom-sized windows
+        const windowWidth = Math.floor(this._workArea.width / this._tiledItems.length);
-        let totalCustomWidth = 0;
-        let numFlexibleItems = 0;
 
-        this._tiledItems.forEach((item, index) => {
+        return this._tiledItems.map((_, index) => {
-            if (this._customSizes.has(index)) {
+            const x = this._workArea.x + (index * windowWidth);
-                totalCustomWidth += this._customSizes.get(index)!;
+            return {
-            } else {
+                x: x,
-                numFlexibleItems++;
-            }
-        });
-
-        // Ensure custom sizes don't exceed container width
-        if (totalCustomWidth > this._workArea.width) {
-            Logger.warn("Custom widths exceed container, resetting all sizes");
-            this._customSizes.clear();
-            totalCustomWidth = 0;
-            numFlexibleItems = this._tiledItems.length;
-        }
-
-        const remainingWidth = this._workArea.width - totalCustomWidth;
-        const flexWidth = numFlexibleItems > 0 ? Math.floor(remainingWidth / numFlexibleItems) : 0;
-
-        // Build the bounds array
-        let currentX = this._workArea.x;
-        return this._tiledItems.map((item, index) => {
-            let width = flexWidth;
-            if (this._customSizes.has(index)) {
-                width = this._customSizes.get(index)!;
-            }
-
-            const rect = {
-                x: currentX,
                 y: this._workArea.y,
-                width: width,
+                width: windowWidth,
                 height: this._workArea.height
             } as Rect;
-            currentX += width;
-            return rect;
         });
     }
 
@@ -338,7 +194,7 @@ export default class WindowContainer {
             Logger.error("Item not found in container during drag op", item.getWindowId());
             return;
         }
-        let new_index = original_index;
+        let new_index = this.getIndexOfItemNested(item);
         this.getBounds().forEach((rect, index) => {
             if (rect.x < x && rect.x + rect.width > x && rect.y < y && rect.y + rect.height > y) {
                 new_index = index;
@@ -352,133 +208,5 @@ export default class WindowContainer {
 
     }
 
-    windowManuallyResized(win_id: number): void {
-        const window = this.getWindow(win_id);
-        if (!window) {
-            // Check nested containers
-            for (const item of this._tiledItems) {
-                if (item instanceof WindowContainer) {
-                    item.windowManuallyResized(win_id);
-                }
-            }
-            return;
-        }
-
-        // Find the index of the window
-        const index = this._getIndexOfWindow(win_id);
-        if (index === -1) {
-            Logger.error("Window not found in container during resize");
-            return;
-        }
-
-        const rect = window.getRect();
-        if (this._orientation === Orientation.HORIZONTAL) {
-            this._customSizes.set(index, rect.width);
-            Logger.log(`Window at index ${index} manually resized to width: ${rect.width}`);
-        } else {
-            this._customSizes.set(index, rect.height);
-            Logger.log(`Window at index ${index} manually resized to height: ${rect.height}`);
-        }
-    }
-
-    resetAllWindowSizes(): void {
-        Logger.log("Clearing all custom window sizes in container");
-        this._customSizes.clear();
-        // Also clear nested containers
-        for (const item of this._tiledItems) {
-            if (item instanceof WindowContainer) {
-                item.resetAllWindowSizes();
-            }
-        }
-    }
-
-    windowResizing(win_id: number, resizeOp: Meta.GrabOp): void {
-        const window = this.getWindow(win_id);
-        if (!window) {
-            // Check nested containers
-            for (const item of this._tiledItems) {
-                if (item instanceof WindowContainer) {
-                    item.windowResizing(win_id, resizeOp);
-                }
-            }
-            return;
-        }
-
-        // Check if the resize direction matches the container orientation
-        const isHorizontalResize = resizeOp === Meta.GrabOp.RESIZING_E || resizeOp === Meta.GrabOp.RESIZING_W;
-        const isVerticalResize = resizeOp === Meta.GrabOp.RESIZING_N || resizeOp === Meta.GrabOp.RESIZING_S;
-
-        if ((this._orientation === Orientation.HORIZONTAL && !isHorizontalResize) ||
-            (this._orientation === Orientation.VERTICAL && !isVerticalResize)) {
-            // Resize direction doesn't match container orientation, ignore
-            return;
-        }
-
-        // Find the index of the window
-        const index = this._getIndexOfWindow(win_id);
-        if (index === -1) {
-            return;
-        }
-
-        // Get the new size
-        const rect = window.getRect();
-        const newSize = this._orientation === Orientation.HORIZONTAL ? rect.width : rect.height;
-        const oldSize = this._customSizes.get(index);
-
-        if (oldSize === undefined) {
-            // First time resizing this window, just set the size
-            this._customSizes.set(index, newSize);
-            this.tileWindows(true);
-            return;
-        }
-
-        // Calculate the delta (how much the window changed)
-        const delta = newSize - oldSize;
-
-        // If delta is 0, the window didn't actually resize (hit its minimum)
-        if (delta === 0) {
-            return;
-        }
-
-        // Determine which adjacent window to adjust based on resize direction
-        let adjacentIndex = -1;
-        if (resizeOp === Meta.GrabOp.RESIZING_E || resizeOp === Meta.GrabOp.RESIZING_S) {
-            // Resizing right/down edge - adjust the next window
-            adjacentIndex = index + 1;
-        } else if (resizeOp === Meta.GrabOp.RESIZING_W || resizeOp === Meta.GrabOp.RESIZING_N) {
-            // Resizing left/up edge - adjust the previous window
-            adjacentIndex = index - 1;
-        }
-
-        // Update current window size
-        this._customSizes.set(index, newSize);
-
-        // Adjust adjacent window only if it has a custom size
-        // When both windows have custom sizes, always apply opposite delta to maintain total width
-        let oldAdjacentSize: number | undefined = undefined;
-        if (adjacentIndex >= 0 && adjacentIndex < this._tiledItems.length &&
-            this._customSizes.has(adjacentIndex)) {
-            const adjacentItem = this._tiledItems[adjacentIndex];
-            if (adjacentItem instanceof WindowWrapper) {
-                oldAdjacentSize = this._customSizes.get(adjacentIndex)!;
-                const newAdjacentSize = oldAdjacentSize - delta;
-
-                // Check if adjacent window allows resize
-                if (!adjacentItem.getWindow().allows_resize()) {
-                    Logger.log("Adjacent window doesn't allow resize, reverting");
-                    this._customSizes.set(index, oldSize);
-                } else {
-                    // Always apply the opposite delta to the adjacent window
-                    // This keeps the total width constant
-                    this._customSizes.set(adjacentIndex, newAdjacentSize);
-                }
-            }
-        }
-
-        // Call tileWindows during resize to update all window positions
-        // Skip retry logic during active resize to avoid jitter
-        this.tileWindows(true);
-    }
-
 
 }

src/wm/monitor.ts

@@ -68,6 +68,7 @@ export default class Monitor {
         this._workArea = global.workspace_manager.get_active_workspace().get_work_area_for_monitor(this._id);
         const activeWorkspace = global.workspace_manager.get_active_workspace();
         this._workspaces[activeWorkspace.index()].move(this._workArea);
+        this._workspaces[activeWorkspace.index()].tileWindows()
     }
 
     removeWorkspace(workspaceId: number): void {
@@ -82,32 +83,4 @@ export default class Monitor {
         this._workspaces[item.getWorkspace()].itemDragged(item, x, y);
     }
 
-    windowManuallyResized(win_id: number): void {
-        // Find which workspace contains the window and notify it
-        for (const container of this._workspaces) {
-            const win = container.getWindow(win_id);
-            if (win) {
-                container.windowManuallyResized(win_id);
-                return;
-            }
-        }
-    }
-
-    resetAllWindowSizes(): void {
-        for (const container of this._workspaces) {
-            container.resetAllWindowSizes();
-        }
-    }
-
-    windowResizing(win_id: number, resizeOp: Meta.GrabOp): void {
-        // Find which workspace contains the window and notify it
-        for (const container of this._workspaces) {
-            const win = container.getWindow(win_id);
-            if (win) {
-                container.windowResizing(win_id, resizeOp);
-                return;
-            }
-        }
-    }
-
 }

src/wm/window.ts

@@ -85,11 +85,6 @@ export class WindowWrapper {
 
                 }
             }),
-            this._window.connect('notify::has-focus', () => {
-                if (this._window.has_focus()) {
-                    windowManager._activeWindowId = windowId;
-                }
-            }),
             this._window.connect('notify::maximized-horizontally', () => {
                 if (this._window.is_maximized()) {
                     Logger.log(`Window maximized: ${windowId}`);
@@ -104,9 +99,6 @@ export class WindowWrapper {
             this._window.connect("position-changed", (_metaWindow) => {
                 windowManager.handleWindowPositionChanged(this);
             }),
-            this._window.connect("size-changed", (_metaWindow) => {
-                windowManager.handleWindowSizeChanged(this);
-            }),
         );
     }
 
@@ -125,10 +117,12 @@ export class WindowWrapper {
         }
     }
 
-    safelyResizeWindow(rect: Rect, _retry: number = 2, _skipRetry: boolean = false): void {
+    safelyResizeWindow(rect: Rect, _retry: number = 2): void {
         // Keep minimal logging
-        // Note: we allow resizing even during drag operations to support position updates
+        if (this._dragging) {
-        // The dragging flag only prevents REORDERING, not position/size changes
+            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();
 
@@ -144,12 +138,12 @@ export class WindowWrapper {
         // Logger.info("RESIZING MOVING")
         this._window.move_resize_frame(true, rect.x, rect.y, rect.width, rect.height);
         let new_rect = this._window.get_frame_rect();
-        if (!_skipRetry && _retry > 0 && (new_rect.x != rect.x || rect.y != new_rect.y || rect.width < new_rect.width || rect.height < new_rect.height)) {
+        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, _skipRetry);
+                    this.safelyResizeWindow(rect, _retry-1);
                 }
             })
         }

src/wm/windowManager.ts

@@ -7,6 +7,7 @@ import * as Main from "resource:///org/gnome/shell/ui/main.js";
 // import Mtk from "@girs/mtk-16";
 import {Logger} from "../utils/logger.js";
 import Monitor from "./monitor.js";
+import WindowContainer from "./container.js";
 
 
 export interface IWindowManager {
@@ -24,8 +25,6 @@ export interface IWindowManager {
 
     handleWindowPositionChanged(winWrap: WindowWrapper): void;
 
-    handleWindowSizeChanged(winWrap: WindowWrapper): void;
-
     syncActiveWindow(): number | null;
 }
 
@@ -47,8 +46,6 @@ export default class WindowManager implements IWindowManager {
     _grabbedWindowMonitor: number = _UNUSED_MONITOR_ID;
     _grabbedWindowId: number = _UNUSED_WINDOW_ID;
     _changingGrabbedMonitor: boolean = false;
-    _resizingWindow: boolean = false;
-    _resizeOp: Meta.GrabOp | null = null;
 
     _showingOverview: boolean = false;
 
@@ -68,6 +65,9 @@ export default class WindowManager implements IWindowManager {
         }
 
         this.captureExistingWindows();
+
+        // Sync the initially focused window
+        this.syncActiveWindow();
     }
 
     instantiateDisplaySignals(): void {
@@ -90,6 +90,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");
@@ -161,10 +164,13 @@ export default class WindowManager implements IWindowManager {
     }
 
     removeAllWindows(): void {
+        // Disconnect signals from minimized windows before clearing
+        this.disconnectMinimizedSignals();
+        this._minimizedItems.clear();
+
         this._monitors.forEach((monitor: Monitor) => {
             monitor.removeAllWindows();
         })
-        this._minimizedItems.clear();
     }
 
 
@@ -203,48 +209,20 @@ 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())
-
+        this._getWrappedWindow(window)?.startDragging();
-        const isResizing = this._isResizeOperation(op);
-        if (isResizing) {
-            this._resizingWindow = true;
-            this._resizeOp = op;
-            // Don't mark as dragging during resize - we need to update positions freely
-        } else {
-            this._getWrappedWindow(window)?.startDragging();
-        }
-
         this._grabbedWindowMonitor = window.get_monitor();
         this._grabbedWindowId = window.get_id();
     }
 
-    _isResizeOperation(op: Meta.GrabOp): boolean {
-        return op === Meta.GrabOp.RESIZING_E ||
-               op === Meta.GrabOp.RESIZING_W ||
-               op === Meta.GrabOp.RESIZING_N ||
-               op === Meta.GrabOp.RESIZING_S ||
-               op === Meta.GrabOp.RESIZING_NE ||
-               op === Meta.GrabOp.RESIZING_NW ||
-               op === Meta.GrabOp.RESIZING_SE ||
-               op === Meta.GrabOp.RESIZING_SW;
-    }
-
     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())
-
-        // Check if this was a resize operation
-        if (this._isResizeOperation(op)) {
-            const monitor = this._monitors.get(window.get_monitor());
-            if (monitor) {
-                monitor.windowManuallyResized(window.get_id());
-            }
-        }
-
-        this._resizingWindow = false;
-        this._resizeOp = null;
         this._grabbedWindowId = _UNUSED_WINDOW_ID;
         this._getWrappedWindow(window)?.stopDragging();
         this._tileMonitors();
@@ -252,7 +230,7 @@ export default class WindowManager implements IWindowManager {
     }
 
     _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) {
@@ -263,7 +241,7 @@ export default class WindowManager implements IWindowManager {
     }
 
     _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) {
@@ -278,7 +256,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.bind(this));
+            wrapped = new WindowWrapper(window, (winWrap) => this.handleWindowMinimized(winWrap));
             wrapped.connectWindowSignals(this);
         }
         let new_mon = this._monitors.get(monitorId);
@@ -291,20 +269,6 @@ export default class WindowManager implements IWindowManager {
             return;
         }
         if (winWrap.getWindowId() === this._grabbedWindowId) {
-            // Check if we're doing a pure NSEW resize - if so, don't allow position-based swapping
-            if (this._resizingWindow && this._resizeOp) {
-                const isPureNSEWResize =
-                    this._resizeOp === Meta.GrabOp.RESIZING_E ||
-                    this._resizeOp === Meta.GrabOp.RESIZING_W ||
-                    this._resizeOp === Meta.GrabOp.RESIZING_N ||
-                    this._resizeOp === Meta.GrabOp.RESIZING_S;
-
-                if (isPureNSEWResize) {
-                    // Skip itemDragged - don't allow swaps during NSEW resize
-                    return;
-                }
-            }
-
             const [mouseX, mouseY, _] = global.get_pointer();
 
             let monitorIndex = -1;
@@ -329,16 +293,6 @@ export default class WindowManager implements IWindowManager {
         }
     }
 
-    public handleWindowSizeChanged(winWrap: WindowWrapper): void {
-        if (this._resizingWindow && winWrap.getWindowId() === this._grabbedWindowId) {
-            // Check if this is a valid resize direction for the container
-            const monitor = this._monitors.get(winWrap.getWindow().get_monitor());
-            if (monitor && this._resizeOp) {
-                monitor.windowResizing(winWrap.getWindowId(), this._resizeOp);
-            }
-        }
-    }
-
 
     public handleWindowMinimized(winWrap: WindowWrapper): void {
         const monitor_id = winWrap.getWindow().get_monitor()
@@ -403,7 +357,7 @@ export default class WindowManager implements IWindowManager {
     public addWindowToMonitor(window: Meta.Window) {
 
         Logger.log("ADDING WINDOW TO MONITOR", window, window);
-        var wrapper = new WindowWrapper(window, this.handleWindowMinimized.bind(this))
+        var wrapper = new WindowWrapper(window, (winWrap) => this.handleWindowMinimized(winWrap))
         wrapper.connectWindowSignals(this);
         this._addWindowWrapperToMonitor(wrapper);
 
@@ -472,15 +426,157 @@ export default class WindowManager implements IWindowManager {
      * @returns The window ID of the active window, or null if no window is active
      */
     public syncActiveWindow(): number | null {
+        const focusWindow = global.display.focus_window;
+        if (focusWindow) {
+            this._activeWindowId = focusWindow.get_id();
+            Logger.debug(`Active window changed to: ${this._activeWindowId} (${focusWindow.get_title()})`);
+        } else {
+            this._activeWindowId = null;
+            Logger.debug('No active window');
+        }
+        return this._activeWindowId;
+    }
+
+    /**
+     * Toggles the orientation of the active container (the container holding the active window)
+     */
+    public toggleActiveContainerOrientation(): void {
+        if (this._activeWindowId === null) {
+            Logger.warn("No active window, cannot toggle container orientation");
+            return;
+        }
+
+        // Find the active window's container
+        const activeContainer = this._findActiveContainer();
+        if (activeContainer) {
+            activeContainer.toggleOrientation();
+        } else {
+            Logger.warn("Could not find container for active window");
+        }
+    }
+
+    /**
+     * Finds the container that directly contains the active window
+     * @returns The container holding the active window, or null if not found
+     */
+    private _findActiveContainer(): WindowContainer | null {
+        if (this._activeWindowId === null) {
+            return null;
+        }
+
+        for (const monitor of this._monitors.values()) {
+            const activeWorkspaceIndex = global.workspace_manager.get_active_workspace().index();
+
+            // Bounds check to prevent accessing invalid workspace
+            if (activeWorkspaceIndex >= monitor._workspaces.length || activeWorkspaceIndex < 0) {
+                Logger.warn(`Active workspace index ${activeWorkspaceIndex} out of bounds for monitor with ${monitor._workspaces.length} workspaces`);
+                continue;
+            }
+
+            const workspace = monitor._workspaces[activeWorkspaceIndex];
+
+            // Check if the window is directly in the workspace container
+            const windowWrapper = workspace.getWindow(this._activeWindowId);
+            if (windowWrapper) {
+                // Try to find the parent container
+                const container = this._findContainerHoldingWindow(workspace, this._activeWindowId);
+                return container;
+            }
+        }
+
         return null;
     }
 
-    public resetAllWindowSizes(): void {
+    /**
-        Logger.log("Resetting all custom window sizes");
+     * Recursively finds the container that directly contains a specific window
-        this._monitors.forEach((monitor: Monitor) => {
+     * @param container The container to search
-            monitor.resetAllWindowSizes();
+     * @param windowId The window ID to find
+     * @returns The container that directly contains the window, or null if not found
+     */
+    private _findContainerHoldingWindow(container: WindowContainer, windowId: number): WindowContainer | null {
+        // Check if this container directly contains the window
+        for (const item of container._tiledItems) {
+            if (item instanceof WindowContainer) {
+                // Recursively search nested containers
+                const result = this._findContainerHoldingWindow(item, windowId);
+                if (result) {
+                    return result;
+                }
+            } else if (item.getWindowId() === windowId) {
+                // Found it! Return this container as it directly holds the window
+                return container;
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * Prints the tree structure of all monitors, workspaces, containers, and windows to the logs
+     */
+    public printTreeStructure(): void {
+        Logger.info("=".repeat(80));
+        Logger.info("WINDOW TREE STRUCTURE");
+        Logger.info("=".repeat(80));
+        Logger.info(`Active Window ID: ${this._activeWindowId ?? 'none'}`);
+        Logger.info("=".repeat(80));
+
+        const activeWorkspaceIndex = global.workspace_manager.get_active_workspace().index();
+
+        this._monitors.forEach((monitor: Monitor, monitorId: number) => {
+            const isActiveMonitor = this._activeWindowId !== null &&
+                                   monitor.getWindow(this._activeWindowId) !== undefined;
+            const monitorMarker = isActiveMonitor ? ' *' : '';
+
+            Logger.info(`Monitor ${monitorId}${monitorMarker}:`);
+            Logger.info(`  Work Area: x=${monitor._workArea.x}, y=${monitor._workArea.y}, w=${monitor._workArea.width}, h=${monitor._workArea.height}`);
+
+            monitor._workspaces.forEach((workspace, workspaceIndex) => {
+                const isActiveWorkspace = workspaceIndex === activeWorkspaceIndex;
+                const workspaceMarker = isActiveWorkspace && isActiveMonitor ? ' *' : '';
+
+                Logger.info(`  Workspace ${workspaceIndex}${workspaceMarker}:`);
+                Logger.info(`    Orientation: ${workspace._orientation === 0 ? 'HORIZONTAL' : 'VERTICAL'}`);
+                Logger.info(`    Items: ${workspace._tiledItems.length}`);
+
+                this._printContainerTree(workspace, 4);
+            });
+        });
+
+        Logger.info("=".repeat(80));
+    }
+
+    /**
+     * Recursively prints the container tree structure
+     * @param container The container to print
+     * @param indentLevel The indentation level (number of spaces)
+     */
+    private _printContainerTree(container: any, indentLevel: number): void {
+        const indent = " ".repeat(indentLevel);
+
+        container._tiledItems.forEach((item: any, index: number) => {
+            if (item instanceof WindowContainer) {
+                // Check if this container contains the active window
+                const containsActiveWindow = this._activeWindowId !== null &&
+                                            item.getWindow(this._activeWindowId) !== undefined;
+                const containerMarker = containsActiveWindow ? ' *' : '';
+
+                Logger.info(`${indent}[${index}] Container (${item._orientation === 0 ? 'HORIZONTAL' : 'VERTICAL'})${containerMarker}:`);
+                Logger.info(`${indent}    Items: ${item._tiledItems.length}`);
+                Logger.info(`${indent}    Work Area: x=${item._workArea.x}, y=${item._workArea.y}, w=${item._workArea.width}, h=${item._workArea.height}`);
+                this._printContainerTree(item, indentLevel + 4);
+            } else {
+                const window = item.getWindow();
+                const isActiveWindow = this._activeWindowId === item.getWindowId();
+                const windowMarker = isActiveWindow ? ' *' : '';
+
+                Logger.info(`${indent}[${index}] Window ID: ${item.getWindowId()}${windowMarker}`);
+                Logger.info(`${indent}    Title: "${window.get_title()}"`);
+                Logger.info(`${indent}    Class: ${window.get_wm_class()}`);
+                const rect = item.getRect();
+                Logger.info(`${indent}    Rect: x=${rect.x}, y=${rect.y}, w=${rect.width}, h=${rect.height}`);
+            }
         });
-        this._tileMonitors();
     }
 
 

tsconfig.json

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