@jacques-ai/server 0.0.7-alpha.1

package/dist/window-manager/smart-layouts.d.ts

@@ -0,0 +1,116 @@
+/**
+ * Smart Layout Engine
+ *
+ * Calculates grid geometry for 1-8+ terminal windows, plans transitions
+ * when adding a window to an existing tiled layout, and finds free space
+ * for non-tiled placement.
+ *
+ * Grid progression (row-based, each row can have different column count):
+ *
+ *   n=1: [A]                        1 row, 1 col
+ *   n=2: [A][B]                     1 row, 2 cols
+ *   n=3: [A][B][C]                  1 row, 3 cols
+ *   n=4: [A][B] / [C][D]            2×2 equal grid
+ *   n=5: [A][B][C] / [D][E]         3 top, 2 bottom
+ *   n=6: [A][B][C] / [D][E][F]      3×2 equal grid
+ *   n=7: [A][B][C][D] / [E][F][G]   4 top, 3 bottom
+ *   n=8: [A][B][C][D] / [E][F][G][H] 4×2 equal grid
+ *
+ * Slot ordering is column-major: iterate columns L→R, rows top→bottom
+ * within each column. This ensures stable index-based transitions.
+ */
+import type { WindowGeometry } from './types.js';
+/**
+ * Grid specification: number of columns in each row.
+ * Index 0 = top row, index 1 = bottom row (if present).
+ */
+export interface GridSpec {
+    columnsPerRow: number[];
+}
+/**
+ * A slot in the grid with its position and geometry
+ */
+export interface GridSlot {
+    column: number;
+    row: number;
+    geometry: WindowGeometry;
+}
+/**
+ * A reposition instruction for an existing window
+ */
+export interface WindowReposition {
+    terminalKey: string;
+    sessionId: string;
+    newGeometry: WindowGeometry;
+    newColumn: number;
+    newRow: number;
+}
+/**
+ * Result of planning a smart tile transition
+ */
+export interface SmartTileTransition {
+    /** Existing windows that need to be repositioned */
+    repositions: WindowReposition[];
+    /** Geometry for the new window */
+    newWindowGeometry: WindowGeometry;
+    /** The new window's grid position */
+    newColumn: number;
+    newRow: number;
+    /** Updated grid spec after the transition */
+    newGrid: GridSpec;
+}
+/**
+ * Get the grid specification for a given number of windows.
+ *
+ * Progression:
+ *   1: [1]     — 1 fullscreen
+ *   2: [2]     — 2 side-by-side
+ *   3: [3]     — 3 side-by-side
+ *   4: [2,2]   — 2×2 equal grid
+ *   5: [3,2]   — 3 top, 2 bottom
+ *   6: [3,3]   — 3×2 equal grid
+ *   7: [4,3]   — 4 top, 3 bottom
+ *   8: [4,4]   — 4×2 equal grid
+ *   n≥4: [ceil(n/2), floor(n/2)]
+ */
+export declare function getGridSpec(windowCount: number): GridSpec;
+/**
+ * Calculate geometry for a single slot in the grid.
+ * Each row can have a different number of columns (and thus different widths).
+ */
+export declare function calculateSlotGeometry(workArea: WindowGeometry, grid: GridSpec, row: number, column: number): WindowGeometry;
+/**
+ * Calculate all slot geometries for n windows.
+ * Order: column-major (iterate columns L→R, rows top→bottom within each column).
+ */
+export declare function calculateAllSlots(workArea: WindowGeometry, windowCount: number): GridSlot[];
+/**
+ * Slot info from the current tile state (terminal + position).
+ */
+export interface ExistingSlot {
+    terminalKey: string;
+    sessionId: string;
+    column: number;
+    row: number;
+    geometry: WindowGeometry;
+}
+/**
+ * Plan a smart tile transition: adding one window to the current layout.
+ *
+ * Uses index-based mapping: window at slot index i maps to new slot index i.
+ * Returns null if beyond 8 (caller should use free-space).
+ */
+export declare function planSmartTileTransition(existingSlots: ExistingSlot[], workArea: WindowGeometry): SmartTileTransition | null;
+/**
+ * Compute the overlap area between two rectangles.
+ */
+export declare function computeOverlapArea(a: WindowGeometry, b: WindowGeometry): number;
+/**
+ * Find the least-occupied position on the work area for a new terminal.
+ * Used when terminals are not in a recognized tiled layout, or when count > 8.
+ *
+ * Target size: 1/4 width, 1/2 height of work area.
+ * Scans an 8×4 grid of candidate positions and picks the one with least overlap.
+ */
+export declare function findFreeSpace(workArea: WindowGeometry, existingWindows: WindowGeometry[]): WindowGeometry;
+//# sourceMappingURL=smart-layouts.d.ts.map

package/dist/window-manager/smart-layouts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"smart-layouts.d.ts","sourceRoot":"","sources":["../../src/window-manager/smart-layouts.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAEjD;;;GAGG;AACH,MAAM,WAAW,QAAQ;IACvB,aAAa,EAAE,MAAM,EAAE,CAAC;CACzB;AAED;;GAEG;AACH,MAAM,WAAW,QAAQ;IACvB,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,cAAc,CAAC;CAC1B;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,cAAc,CAAC;IAC5B,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,oDAAoD;IACpD,WAAW,EAAE,gBAAgB,EAAE,CAAC;IAChC,kCAAkC;IAClC,iBAAiB,EAAE,cAAc,CAAC;IAClC,qCAAqC;IACrC,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,6CAA6C;IAC7C,OAAO,EAAE,QAAQ,CAAC;CACnB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,WAAW,CAAC,WAAW,EAAE,MAAM,GAAG,QAAQ,CAOzD;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,cAAc,EACxB,IAAI,EAAE,QAAQ,EACd,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,MAAM,GACb,cAAc,CAehB;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,cAAc,EACxB,WAAW,EAAE,MAAM,GAClB,QAAQ,EAAE,CAsBZ;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,cAAc,CAAC;CAC1B;AAED;;;;;GAKG;AACH,wBAAgB,uBAAuB,CACrC,aAAa,EAAE,YAAY,EAAE,EAC7B,QAAQ,EAAE,cAAc,GACvB,mBAAmB,GAAG,IAAI,CA8C5B;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,cAAc,EAAE,CAAC,EAAE,cAAc,GAAG,MAAM,CAI/E;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAC3B,QAAQ,EAAE,cAAc,EACxB,eAAe,EAAE,cAAc,EAAE,GAChC,cAAc,CA6ChB"}

package/dist/window-manager/smart-layouts.js

@@ -0,0 +1,188 @@
+/**
+ * Smart Layout Engine
+ *
+ * Calculates grid geometry for 1-8+ terminal windows, plans transitions
+ * when adding a window to an existing tiled layout, and finds free space
+ * for non-tiled placement.
+ *
+ * Grid progression (row-based, each row can have different column count):
+ *
+ *   n=1: [A]                        1 row, 1 col
+ *   n=2: [A][B]                     1 row, 2 cols
+ *   n=3: [A][B][C]                  1 row, 3 cols
+ *   n=4: [A][B] / [C][D]            2×2 equal grid
+ *   n=5: [A][B][C] / [D][E]         3 top, 2 bottom
+ *   n=6: [A][B][C] / [D][E][F]      3×2 equal grid
+ *   n=7: [A][B][C][D] / [E][F][G]   4 top, 3 bottom
+ *   n=8: [A][B][C][D] / [E][F][G][H] 4×2 equal grid
+ *
+ * Slot ordering is column-major: iterate columns L→R, rows top→bottom
+ * within each column. This ensures stable index-based transitions.
+ */
+/**
+ * Get the grid specification for a given number of windows.
+ *
+ * Progression:
+ *   1: [1]     — 1 fullscreen
+ *   2: [2]     — 2 side-by-side
+ *   3: [3]     — 3 side-by-side
+ *   4: [2,2]   — 2×2 equal grid
+ *   5: [3,2]   — 3 top, 2 bottom
+ *   6: [3,3]   — 3×2 equal grid
+ *   7: [4,3]   — 4 top, 3 bottom
+ *   8: [4,4]   — 4×2 equal grid
+ *   n≥4: [ceil(n/2), floor(n/2)]
+ */
+export function getGridSpec(windowCount) {
+    if (windowCount <= 0)
+        return { columnsPerRow: [] };
+    if (windowCount === 1)
+        return { columnsPerRow: [1] };
+    if (windowCount === 2)
+        return { columnsPerRow: [2] };
+    if (windowCount === 3)
+        return { columnsPerRow: [3] };
+    // 4+: two rows, top row gets ceil, bottom gets floor
+    return { columnsPerRow: [Math.ceil(windowCount / 2), Math.floor(windowCount / 2)] };
+}
+/**
+ * Calculate geometry for a single slot in the grid.
+ * Each row can have a different number of columns (and thus different widths).
+ */
+export function calculateSlotGeometry(workArea, grid, row, column) {
+    const numRows = grid.columnsPerRow.length;
+    const colsInRow = grid.columnsPerRow[row];
+    const rowHeight = Math.floor(workArea.height / numRows);
+    const colWidth = Math.floor(workArea.width / colsInRow);
+    const isLastRow = row === numRows - 1;
+    const isLastCol = column === colsInRow - 1;
+    return {
+        x: workArea.x + column * colWidth,
+        y: workArea.y + row * rowHeight,
+        width: isLastCol ? workArea.width - column * colWidth : colWidth,
+        height: isLastRow ? workArea.height - row * rowHeight : rowHeight,
+    };
+}
+/**
+ * Calculate all slot geometries for n windows.
+ * Order: column-major (iterate columns L→R, rows top→bottom within each column).
+ */
+export function calculateAllSlots(workArea, windowCount) {
+    const grid = getGridSpec(windowCount);
+    if (grid.columnsPerRow.length === 0)
+        return [];
+    const slots = [];
+    const numRows = grid.columnsPerRow.length;
+    const maxCols = Math.max(...grid.columnsPerRow);
+    // Column-major: iterate columns, then rows within each column
+    for (let col = 0; col < maxCols; col++) {
+        for (let row = 0; row < numRows; row++) {
+            if (col < grid.columnsPerRow[row]) {
+                slots.push({
+                    column: col,
+                    row,
+                    geometry: calculateSlotGeometry(workArea, grid, row, col),
+                });
+            }
+        }
+    }
+    return slots;
+}
+/**
+ * Plan a smart tile transition: adding one window to the current layout.
+ *
+ * Uses index-based mapping: window at slot index i maps to new slot index i.
+ * Returns null if beyond 8 (caller should use free-space).
+ */
+export function planSmartTileTransition(existingSlots, workArea) {
+    const currentCount = existingSlots.length;
+    const newCount = currentCount + 1;
+    if (newCount > 8) {
+        return null; // Caller should use findFreeSpace
+    }
+    const newSlots = calculateAllSlots(workArea, newCount);
+    const newGrid = getGridSpec(newCount);
+    const repositions = [];
+    // Index-based mapping: existing slot at index i → new slot at index i
+    for (let i = 0; i < currentCount; i++) {
+        const existing = existingSlots[i];
+        const target = newSlots[i];
+        const geomChanged = (existing.geometry.x !== target.geometry.x ||
+            existing.geometry.y !== target.geometry.y ||
+            existing.geometry.width !== target.geometry.width ||
+            existing.geometry.height !== target.geometry.height);
+        if (geomChanged) {
+            repositions.push({
+                terminalKey: existing.terminalKey,
+                sessionId: existing.sessionId,
+                newGeometry: target.geometry,
+                newColumn: target.column,
+                newRow: target.row,
+            });
+        }
+    }
+    // The new window goes in the last slot
+    const newSlot = newSlots[currentCount];
+    return {
+        repositions,
+        newWindowGeometry: newSlot.geometry,
+        newColumn: newSlot.column,
+        newRow: newSlot.row,
+        newGrid,
+    };
+}
+/**
+ * Compute the overlap area between two rectangles.
+ */
+export function computeOverlapArea(a, b) {
+    const overlapX = Math.max(0, Math.min(a.x + a.width, b.x + b.width) - Math.max(a.x, b.x));
+    const overlapY = Math.max(0, Math.min(a.y + a.height, b.y + b.height) - Math.max(a.y, b.y));
+    return overlapX * overlapY;
+}
+/**
+ * Find the least-occupied position on the work area for a new terminal.
+ * Used when terminals are not in a recognized tiled layout, or when count > 8.
+ *
+ * Target size: 1/4 width, 1/2 height of work area.
+ * Scans an 8×4 grid of candidate positions and picks the one with least overlap.
+ */
+export function findFreeSpace(workArea, existingWindows) {
+    const targetW = Math.round(workArea.width / 4);
+    const targetH = Math.round(workArea.height / 2);
+    // If no existing windows, place at top-left
+    if (existingWindows.length === 0) {
+        return { x: workArea.x, y: workArea.y, width: targetW, height: targetH };
+    }
+    const GRID_COLS = 8;
+    const GRID_ROWS = 4;
+    const maxX = workArea.x + workArea.width - targetW;
+    const maxY = workArea.y + workArea.height - targetH;
+    // Avoid division by zero if work area is smaller than target
+    const stepX = GRID_COLS > 1 ? Math.max(1, Math.floor((maxX - workArea.x) / (GRID_COLS - 1))) : 0;
+    const stepY = GRID_ROWS > 1 ? Math.max(1, Math.floor((maxY - workArea.y) / (GRID_ROWS - 1))) : 0;
+    let bestX = workArea.x;
+    let bestY = workArea.y;
+    let bestOverlap = Infinity;
+    for (let gx = 0; gx < GRID_COLS; gx++) {
+        for (let gy = 0; gy < GRID_ROWS; gy++) {
+            const cx = Math.min(workArea.x + gx * stepX, maxX);
+            const cy = Math.min(workArea.y + gy * stepY, maxY);
+            const candidate = { x: cx, y: cy, width: targetW, height: targetH };
+            let overlapSum = 0;
+            for (const existing of existingWindows) {
+                overlapSum += computeOverlapArea(candidate, existing);
+            }
+            if (overlapSum < bestOverlap) {
+                bestOverlap = overlapSum;
+                bestX = cx;
+                bestY = cy;
+                if (overlapSum === 0)
+                    break; // Can't do better than zero overlap
+            }
+        }
+        if (bestOverlap === 0)
+            break;
+    }
+    return { x: bestX, y: bestY, width: targetW, height: targetH };
+}
+//# sourceMappingURL=smart-layouts.js.map

package/dist/window-manager/smart-layouts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"smart-layouts.js","sourceRoot":"","sources":["../../src/window-manager/smart-layouts.ts"],"names":[],"mappings":"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"}

package/dist/window-manager/smart-layouts.test.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Smart Layout Engine Tests
+ *
+ * Tests grid specifications, slot geometry calculations, transition planning,
+ * and free-space placement for the smart tiling system.
+ */
+export {};
+//# sourceMappingURL=smart-layouts.test.d.ts.map

package/dist/window-manager/smart-layouts.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"smart-layouts.test.d.ts","sourceRoot":"","sources":["../../src/window-manager/smart-layouts.test.ts"],"names":[],"mappings":"AAAA;;;;;GAKG"}

package/dist/window-manager/smart-layouts.test.js

@@ -0,0 +1,311 @@
+/**
+ * Smart Layout Engine Tests
+ *
+ * Tests grid specifications, slot geometry calculations, transition planning,
+ * and free-space placement for the smart tiling system.
+ */
+import { describe, it, expect } from '@jest/globals';
+import { getGridSpec, calculateSlotGeometry, calculateAllSlots, planSmartTileTransition, findFreeSpace, computeOverlapArea, } from './smart-layouts.js';
+// Standard test work area (1920×1057 after dock/menubar on a 1080p display)
+const WORK_AREA = { x: 0, y: 23, width: 1920, height: 1057 };
+// ─── getGridSpec ─────────────────────────────────────────────
+describe('getGridSpec', () => {
+    it('returns empty grid for 0 windows', () => {
+        expect(getGridSpec(0)).toEqual({ columnsPerRow: [] });
+    });
+    it('returns [1] for 1 window', () => {
+        expect(getGridSpec(1)).toEqual({ columnsPerRow: [1] });
+    });
+    it('returns [2] for 2 windows', () => {
+        expect(getGridSpec(2)).toEqual({ columnsPerRow: [2] });
+    });
+    it('returns [3] for 3 windows', () => {
+        expect(getGridSpec(3)).toEqual({ columnsPerRow: [3] });
+    });
+    it('returns [2,2] for 4 windows (2×2 grid)', () => {
+        expect(getGridSpec(4)).toEqual({ columnsPerRow: [2, 2] });
+    });
+    it('returns [3,2] for 5 windows (3 top, 2 bottom)', () => {
+        expect(getGridSpec(5)).toEqual({ columnsPerRow: [3, 2] });
+    });
+    it('returns [3,3] for 6 windows (3×2 grid)', () => {
+        expect(getGridSpec(6)).toEqual({ columnsPerRow: [3, 3] });
+    });
+    it('returns [4,3] for 7 windows', () => {
+        expect(getGridSpec(7)).toEqual({ columnsPerRow: [4, 3] });
+    });
+    it('returns [4,4] for 8 windows (4×2 grid)', () => {
+        expect(getGridSpec(8)).toEqual({ columnsPerRow: [4, 4] });
+    });
+    it('handles beyond 8 (9 = [5,4])', () => {
+        expect(getGridSpec(9)).toEqual({ columnsPerRow: [5, 4] });
+    });
+    it('handles 12 = [6,6]', () => {
+        expect(getGridSpec(12)).toEqual({ columnsPerRow: [6, 6] });
+    });
+});
+// ─── calculateSlotGeometry ───────────────────────────────────
+describe('calculateSlotGeometry', () => {
+    it('returns full work area for 1×1 grid', () => {
+        const grid = getGridSpec(1);
+        const slot = calculateSlotGeometry(WORK_AREA, grid, 0, 0);
+        expect(slot).toEqual(WORK_AREA);
+    });
+    it('splits horizontally for 2 windows', () => {
+        const grid = getGridSpec(2);
+        const left = calculateSlotGeometry(WORK_AREA, grid, 0, 0);
+        const right = calculateSlotGeometry(WORK_AREA, grid, 0, 1);
+        expect(left.x).toBe(0);
+        expect(left.width).toBe(960);
+        expect(right.x).toBe(960);
+        expect(right.width).toBe(960);
+        expect(left.height).toBe(WORK_AREA.height);
+        expect(right.height).toBe(WORK_AREA.height);
+    });
+    it('last column gets remainder pixels', () => {
+        // 1920 / 3 = 640
+        const grid = getGridSpec(3);
+        const last = calculateSlotGeometry(WORK_AREA, grid, 0, 2);
+        expect(last.width).toBe(1920 - 640 * 2);
+    });
+    it('2×2 grid has equal-sized slots', () => {
+        const grid = getGridSpec(4); // [2, 2]
+        const topLeft = calculateSlotGeometry(WORK_AREA, grid, 0, 0);
+        const topRight = calculateSlotGeometry(WORK_AREA, grid, 0, 1);
+        const bottomLeft = calculateSlotGeometry(WORK_AREA, grid, 1, 0);
+        const bottomRight = calculateSlotGeometry(WORK_AREA, grid, 1, 1);
+        // All same width and height
+        expect(topLeft.width).toBe(960);
+        expect(topRight.width).toBe(960);
+        expect(bottomLeft.width).toBe(960);
+        expect(bottomRight.width).toBe(960);
+        expect(topLeft.height + bottomLeft.height).toBe(WORK_AREA.height);
+    });
+    it('5-window grid has different widths per row', () => {
+        const grid = getGridSpec(5); // [3, 2]
+        const topCol = calculateSlotGeometry(WORK_AREA, grid, 0, 0);
+        const bottomCol = calculateSlotGeometry(WORK_AREA, grid, 1, 0);
+        // Top row: 1/3 width, bottom row: 1/2 width
+        expect(topCol.width).toBe(640);
+        expect(bottomCol.width).toBe(960);
+    });
+});
+// ─── calculateAllSlots ──────────────────────────────────────
+describe('calculateAllSlots', () => {
+    it('returns empty for 0 windows', () => {
+        expect(calculateAllSlots(WORK_AREA, 0)).toEqual([]);
+    });
+    it('returns 1 slot for 1 window', () => {
+        const slots = calculateAllSlots(WORK_AREA, 1);
+        expect(slots).toHaveLength(1);
+        expect(slots[0].column).toBe(0);
+        expect(slots[0].row).toBe(0);
+    });
+    it('returns column-major order for 4 windows (2×2)', () => {
+        const slots = calculateAllSlots(WORK_AREA, 4);
+        expect(slots).toHaveLength(4);
+        // Column-major: col 0 top, col 0 bottom, col 1 top, col 1 bottom
+        expect(slots[0]).toMatchObject({ column: 0, row: 0 });
+        expect(slots[1]).toMatchObject({ column: 0, row: 1 });
+        expect(slots[2]).toMatchObject({ column: 1, row: 0 });
+        expect(slots[3]).toMatchObject({ column: 1, row: 1 });
+    });
+    it('returns column-major order for 5 windows [3,2]', () => {
+        const slots = calculateAllSlots(WORK_AREA, 5);
+        expect(slots).toHaveLength(5);
+        // Col 0: (r0,c0), (r1,c0); Col 1: (r0,c1), (r1,c1); Col 2: (r0,c2)
+        expect(slots[0]).toMatchObject({ column: 0, row: 0 });
+        expect(slots[1]).toMatchObject({ column: 0, row: 1 });
+        expect(slots[2]).toMatchObject({ column: 1, row: 0 });
+        expect(slots[3]).toMatchObject({ column: 1, row: 1 });
+        expect(slots[4]).toMatchObject({ column: 2, row: 0 });
+    });
+    it('returns column-major order for 6 windows (3×2)', () => {
+        const slots = calculateAllSlots(WORK_AREA, 6);
+        expect(slots).toHaveLength(6);
+        expect(slots[0]).toMatchObject({ column: 0, row: 0 });
+        expect(slots[1]).toMatchObject({ column: 0, row: 1 });
+        expect(slots[2]).toMatchObject({ column: 1, row: 0 });
+        expect(slots[3]).toMatchObject({ column: 1, row: 1 });
+        expect(slots[4]).toMatchObject({ column: 2, row: 0 });
+        expect(slots[5]).toMatchObject({ column: 2, row: 1 });
+    });
+    it('returns column-major order for 7 windows [4,3]', () => {
+        const slots = calculateAllSlots(WORK_AREA, 7);
+        expect(slots).toHaveLength(7);
+        // Col 3 only has top row (bottom row has 3 cols)
+        expect(slots[0]).toMatchObject({ column: 0, row: 0 });
+        expect(slots[1]).toMatchObject({ column: 0, row: 1 });
+        expect(slots[2]).toMatchObject({ column: 1, row: 0 });
+        expect(slots[3]).toMatchObject({ column: 1, row: 1 });
+        expect(slots[4]).toMatchObject({ column: 2, row: 0 });
+        expect(slots[5]).toMatchObject({ column: 2, row: 1 });
+        expect(slots[6]).toMatchObject({ column: 3, row: 0 });
+    });
+    it('slots cover the entire work area without gaps for 6 windows', () => {
+        const slots = calculateAllSlots(WORK_AREA, 6);
+        const totalArea = slots.reduce((sum, s) => sum + s.geometry.width * s.geometry.height, 0);
+        const workAreaTotal = WORK_AREA.width * WORK_AREA.height;
+        // Allow small rounding difference (max 1 pixel per slot dimension)
+        expect(Math.abs(totalArea - workAreaTotal)).toBeLessThan(WORK_AREA.width + WORK_AREA.height);
+    });
+    it('no slots overlap for 8 windows', () => {
+        const slots = calculateAllSlots(WORK_AREA, 8);
+        for (let i = 0; i < slots.length; i++) {
+            for (let j = i + 1; j < slots.length; j++) {
+                const overlap = computeOverlapArea(slots[i].geometry, slots[j].geometry);
+                expect(overlap).toBe(0);
+            }
+        }
+    });
+    it('5-window grid has correct mixed widths', () => {
+        const slots = calculateAllSlots(WORK_AREA, 5);
+        // Top row slots: 1/3 width
+        expect(slots[0].geometry.width).toBe(640); // col 0, row 0
+        expect(slots[2].geometry.width).toBe(640); // col 1, row 0
+        expect(slots[4].geometry.width).toBe(640); // col 2, row 0
+        // Bottom row slots: 1/2 width
+        expect(slots[1].geometry.width).toBe(960); // col 0, row 1
+        expect(slots[3].geometry.width).toBe(960); // col 1, row 1
+    });
+});
+// ─── planSmartTileTransition ─────────────────────────────────
+describe('planSmartTileTransition', () => {
+    function makeSlots(count) {
+        const slots = calculateAllSlots(WORK_AREA, count);
+        return slots.map((s, i) => ({
+            terminalKey: `ITERM:session-${i}`,
+            sessionId: `session-${i}`,
+            ...s,
+        }));
+    }
+    it('0→1: no repositions, full work area', () => {
+        const result = planSmartTileTransition([], WORK_AREA);
+        expect(result).not.toBeNull();
+        expect(result.repositions).toHaveLength(0);
+        expect(result.newWindowGeometry).toEqual(WORK_AREA);
+    });
+    it('1→2: 1 reposition (split to half)', () => {
+        const existing = makeSlots(1);
+        const result = planSmartTileTransition(existing, WORK_AREA);
+        expect(result).not.toBeNull();
+        expect(result.repositions).toHaveLength(1);
+        expect(result.repositions[0].newGeometry.width).toBe(960);
+        expect(result.newWindowGeometry.x).toBe(960);
+    });
+    it('2→3: 2 repositions (half → third)', () => {
+        const existing = makeSlots(2);
+        const result = planSmartTileTransition(existing, WORK_AREA);
+        expect(result).not.toBeNull();
+        expect(result.repositions).toHaveLength(2);
+    });
+    it('3→4: all 3 reposition (single row → 2×2 grid)', () => {
+        const existing = makeSlots(3);
+        const result = planSmartTileTransition(existing, WORK_AREA);
+        expect(result).not.toBeNull();
+        // All 3 existing windows change size/position
+        expect(result.repositions).toHaveLength(3);
+        // New window goes to last slot: (r1,c1) bottom-right
+        expect(result.newColumn).toBe(1);
+        expect(result.newRow).toBe(1);
+    });
+    it('4→5: 2 repositions (top row shrinks from 1/2 to 1/3 width)', () => {
+        const existing = makeSlots(4);
+        const result = planSmartTileTransition(existing, WORK_AREA);
+        expect(result).not.toBeNull();
+        // Top row windows shrink width (1/2→1/3), bottom row stays (1/2→1/2)
+        expect(result.repositions).toHaveLength(2);
+        // New window at top-right: (r0,c2)
+        expect(result.newColumn).toBe(2);
+        expect(result.newRow).toBe(0);
+    });
+    it('5→6: 2 repositions (bottom row shrinks from 1/2 to 1/3 width)', () => {
+        const existing = makeSlots(5);
+        const result = planSmartTileTransition(existing, WORK_AREA);
+        expect(result).not.toBeNull();
+        // Bottom row: 1/2→1/3 width (2 repos). Top row already half-height, no change.
+        expect(result.repositions).toHaveLength(2);
+        // New window: (r1,c2) bottom-right
+        expect(result.newColumn).toBe(2);
+        expect(result.newRow).toBe(1);
+    });
+    it('6→7: 3 repositions (top row shrinks from 1/3 to 1/4 width)', () => {
+        const existing = makeSlots(6);
+        const result = planSmartTileTransition(existing, WORK_AREA);
+        expect(result).not.toBeNull();
+        // Only top row windows change width (1/3→1/4), bottom row stays (1/3)
+        expect(result.repositions).toHaveLength(3);
+        // New window at top-right: (r0,c3)
+        expect(result.newColumn).toBe(3);
+        expect(result.newRow).toBe(0);
+    });
+    it('7→8: 3 repositions (bottom row shrinks from 1/3 to 1/4 width)', () => {
+        const existing = makeSlots(7);
+        const result = planSmartTileTransition(existing, WORK_AREA);
+        expect(result).not.toBeNull();
+        // Bottom row: 1/3→1/4 width (3 repos). Top row already half-height, no change.
+        expect(result.repositions).toHaveLength(3);
+        // New window: (r1,c3) bottom-right
+        expect(result.newColumn).toBe(3);
+        expect(result.newRow).toBe(1);
+    });
+    it('returns null for 8→9 (beyond limit)', () => {
+        const existing = makeSlots(8);
+        const result = planSmartTileTransition(existing, WORK_AREA);
+        expect(result).toBeNull();
+    });
+    it('new window geometry matches expected slot', () => {
+        const existing = makeSlots(3);
+        const result = planSmartTileTransition(existing, WORK_AREA);
+        const allSlotsFor4 = calculateAllSlots(WORK_AREA, 4);
+        // New window should be the last slot (index 3)
+        expect(result.newWindowGeometry).toEqual(allSlotsFor4[3].geometry);
+    });
+});
+// ─── computeOverlapArea ──────────────────────────────────────
+describe('computeOverlapArea', () => {
+    it('returns 0 for non-overlapping rectangles', () => {
+        const a = { x: 0, y: 0, width: 100, height: 100 };
+        const b = { x: 200, y: 0, width: 100, height: 100 };
+        expect(computeOverlapArea(a, b)).toBe(0);
+    });
+    it('returns correct overlap for partially overlapping rectangles', () => {
+        const a = { x: 0, y: 0, width: 100, height: 100 };
+        const b = { x: 50, y: 50, width: 100, height: 100 };
+        // Overlap: 50×50 = 2500
+        expect(computeOverlapArea(a, b)).toBe(2500);
+    });
+    it('returns full area for identical rectangles', () => {
+        const a = { x: 10, y: 20, width: 100, height: 200 };
+        expect(computeOverlapArea(a, a)).toBe(20000);
+    });
+});
+// ─── findFreeSpace ──────────────────────────────────────────
+describe('findFreeSpace', () => {
+    it('returns top-left for no existing windows', () => {
+        const result = findFreeSpace(WORK_AREA, []);
+        expect(result.x).toBe(WORK_AREA.x);
+        expect(result.y).toBe(WORK_AREA.y);
+        expect(result.width).toBe(Math.round(WORK_AREA.width / 4));
+        expect(result.height).toBe(Math.round(WORK_AREA.height / 2));
+    });
+    it('avoids a window in the top-left', () => {
+        const existing = [{ x: 0, y: 23, width: 960, height: 1057 }];
+        const result = findFreeSpace(WORK_AREA, existing);
+        // Should be placed somewhere on the right half
+        expect(result.x).toBeGreaterThan(0);
+    });
+    it('finds zero-overlap position when possible', () => {
+        // One small window in the center
+        const existing = [{ x: 800, y: 400, width: 320, height: 260 }];
+        const result = findFreeSpace(WORK_AREA, existing);
+        const overlap = computeOverlapArea(result, existing[0]);
+        expect(overlap).toBe(0);
+    });
+    it('returns correct target size', () => {
+        const result = findFreeSpace(WORK_AREA, []);
+        expect(result.width).toBe(480); // 1920/4
+        expect(result.height).toBe(529); // round(1057/2)
+    });
+});
+//# sourceMappingURL=smart-layouts.test.js.map