diff --git a/packages/widgets/src/display/Breadcrumbs.ts b/packages/widgets/src/display/Breadcrumbs.ts
index 45891461..c9b2b3c9 100644
--- a/packages/widgets/src/display/Breadcrumbs.ts
+++ b/packages/widgets/src/display/Breadcrumbs.ts
@@ -8,8 +8,12 @@ import { Widget } from '../base/Widget.js';
 export interface BreadcrumbsOptions {
     /** Separator drawn between segments. Default: caps.unicode ? '❯' : '>' */
     separator?: string;
-    /** Color of the last (current) segment. Default: cyan */
+
+    /** Color of the active breadcrumb */
     activeColor?: Color;
+
+    /** Called when a breadcrumb is selected */
+    onSelect?: (index: number, label: string) => void;
 }
 
 /**
@@ -22,12 +26,15 @@ export class Breadcrumbs extends Widget {
     private _segments: string[];
     private _separator?: string;
     private _activeColor?: Color;
+    private _selectedIndex = 0;
+    private _onSelect?: (index: number, label: string) => void;
 
     constructor(segments: string[], style: Partial<Style> = {}, opts: BreadcrumbsOptions = {}) {
         super(style);
         this._segments = segments;
         this._separator = opts.separator;
         this._activeColor = opts.activeColor;
+        this._onSelect = opts.onSelect;
     }
 
     /** Update the trail of segments. */
@@ -42,6 +49,24 @@ export class Breadcrumbs extends Widget {
         this.markDirty();
     }
 
+    handleKey(event: { key: string }): void {
+    if (event.key === 'left') {
+        this._selectedIndex = Math.max(0, this._selectedIndex - 1);
+        this.markDirty();
+    } else if (event.key === 'right') {
+        this._selectedIndex = Math.min(
+            this._segments.length - 1,
+            this._selectedIndex + 1
+        );
+        this.markDirty();
+    } else if (event.key === 'enter') {
+        this._onSelect?.(
+            this._selectedIndex,
+            this._segments[this._selectedIndex]
+        );
+    }
+}
+
     protected _renderSelf(screen: Screen): void {
         const { x, y, width, height } = this._getContentRect();
         if (width <= 0 || height <= 0 || this._segments.length === 0) return;
@@ -85,7 +110,10 @@ export class Breadcrumbs extends Widget {
             if (i > 0 || (showEllipsis && hasTruncated)) {
                 renderList.push({ type: 'separator', text: sep });
             }
-            const isLast = i === visibleSegments.length - 1;
+            const originalIndex =
+                this._segments.length - visibleSegments.length + i;
+
+            const isLast = originalIndex === this._selectedIndex;
             renderList.push({ 
                 type: isLast ? 'active' : 'normal', 
                 text: visibleSegments[i] 
diff --git a/packages/widgets/src/index.ts b/packages/widgets/src/index.ts
index 4c5ed171..998494c8 100644
--- a/packages/widgets/src/index.ts
+++ b/packages/widgets/src/index.ts
@@ -128,7 +128,14 @@ export type { DraggableOptions, DroppableOptions } from './layout/DragAndDrop.js
 export { Fill } from './layout/Fill.js';
 export type { FillOptions } from './layout/Fill.js';
 export { SplitPane } from './layout/SplitPane.js';
-export type { SplitPaneOptions, SplitDirection } from './layout/SplitPane.js';
+export type { SplitPaneOptions } from './layout/SplitPane.js';
+export { Workspace } from './layout/Workspace.js';
+
+export type {
+    WorkspaceLayout,
+    WorkspaceOptions,
+    WorkspaceStorage,
+} from './layout/Workspace.js';
 
 // ── Feedback Widgets ──────────────────────────────────
 export { ProgressBar } from './feedback/ProgressBar.js';
diff --git a/packages/widgets/src/input/TextInput.ts b/packages/widgets/src/input/TextInput.ts
index 5c68edd1..1839d8d4 100644
--- a/packages/widgets/src/input/TextInput.ts
+++ b/packages/widgets/src/input/TextInput.ts
@@ -6,11 +6,11 @@ import {
     type Screen,
     type Style,
     styleToCellAttrs,
-    stringWidth,
     truncate,
     type KeyEvent,
     splitGraphemes
 } from '@termuijs/core';
+
 import { Widget } from '../base/Widget.js';
 import { type VimMode } from './vim.js';
 
@@ -23,14 +23,29 @@ export type { VimMode };
 export class TextInput extends Widget {
     private _value = '';
     private _cursorPos = 0;
+
     private _placeholder: string;
     private _mask: string | null;
     private _maxLength: number;
+
     private _onChange?: (value: string) => void;
     private _onSubmit?: (value: string) => void;
+<<<<<<< HEAD
+
+    // Auto-complete
+    private _suggestions: string[] = [];
+    private _suggestionIndex = 0;
+
+    // Vim mode support
+    private _vimMode: VimMode =
+        process.env.TERMUI_KEYBINDINGS === 'vim'
+            ? 'normal'
+            : 'insert';
+=======
     private _vimMode: VimMode = process.env.TERMUI_KEYBINDINGS === 'vim' ? 'normal' : 'insert';
     private _suggestions: string[] = [];
     private _suggestionIndex = 0;
+>>>>>>> upstream/main
 
     constructor(
         style: Partial<Style> = {},
@@ -43,32 +58,52 @@ export class TextInput extends Widget {
             onSubmit?: (value: string) => void;
         } = {},
     ) {
-        super({ border: 'single', height: 3, ...style });
+        super({
+            border: 'single',
+            height: 3,
+            ...style,
+        });
 
         this._placeholder = options.placeholder ?? '';
         this._mask = options.mask ?? null;
         this._maxLength = options.maxLength ?? Infinity;
+
         this._onChange = options.onChange;
         this._onSubmit = options.onSubmit;
         this._suggestions = options.suggestions ?? [];
 
+        // Auto-complete data
+        this._suggestions = options.suggestions ?? [];
+
         this.focusable = true;
 
-        this.events.on('key', (event: KeyEvent) => this.handleKey(event));
+        this.events.on('key', (event: KeyEvent) =>
+            this.handleKey(event)
+        );
     }
 
+        // ── Getters & Setters ─────────────────────────────
+
     get value(): string {
         return this._value;
     }
 
     set value(v: string) {
         const graphemes = splitGraphemes(v);
+
         if (graphemes.length > this._maxLength) {
-            this._value = graphemes.slice(0, this._maxLength).join('');
+            this._value = graphemes
+                .slice(0, this._maxLength)
+                .join('');
         } else {
             this._value = v;
         }
-        this._cursorPos = Math.min(this._cursorPos, splitGraphemes(this._value).length);
+
+        this._cursorPos = Math.min(
+            this._cursorPos,
+            splitGraphemes(this._value).length
+        );
+
         this.markDirty();
     }
 
@@ -81,6 +116,10 @@ export class TextInput extends Widget {
         this.markDirty();
     }
 
+<<<<<<< HEAD
+
+    // ── Text Editing ──────────────────────────────────
+=======
     getSuggestions(input: string): string[] {
         return this._suggestions.filter(s => s.toLowerCase().includes(input.toLowerCase()));
     }
@@ -92,39 +131,97 @@ export class TextInput extends Widget {
         this._cursorPos = splitGraphemes(this._value).length;
         this.markDirty();
     }
+>>>>>>> upstream/main
 
     insertChar(char: string): void {
         const graphemes = splitGraphemes(this._value);
-        if (graphemes.length >= this._maxLength) return;
+
+        if (graphemes.length >= this._maxLength) {
+            return;
+        }
+
         graphemes.splice(this._cursorPos, 0, char);
+
         this._value = graphemes.join('');
         this._cursorPos++;
-        this._suggestionIndex = 0;
+<<<<<<< HEAD
+
         this._onChange?.(this._value);
+
+        // reset autocomplete selection
+        this._suggestionIndex = 0;
+
         this.markDirty();
     }
 
+
     deleteBack(): void {
-        if (this._cursorPos > 0) {
-            const graphemes = splitGraphemes(this._value);
-            graphemes.splice(this._cursorPos - 1, 1);
-            this._value = graphemes.join('');
-            this._cursorPos--;
-            this._onChange?.(this._value);
-            this.markDirty();
+        if (this._cursorPos <= 0) {
+            return;
         }
+
+        const graphemes = splitGraphemes(this._value);
+
+        graphemes.splice(this._cursorPos - 1, 1);
+
+        this._value = graphemes.join('');
+        this._cursorPos--;
+
+=======
+        this._suggestionIndex = 0;
+>>>>>>> upstream/main
+        this._onChange?.(this._value);
+        this.markDirty();
     }
 
+
     deleteForward(): void {
         const graphemes = splitGraphemes(this._value);
-        if (this._cursorPos < graphemes.length) {
-            graphemes.splice(this._cursorPos, 1);
-            this._value = graphemes.join('');
-            this._onChange?.(this._value);
-            this.markDirty();
+
+        if (this._cursorPos >= graphemes.length) {
+            return;
+        }
+
+        graphemes.splice(this._cursorPos, 1);
+
+        this._value = graphemes.join('');
+
+        this._onChange?.(this._value);
+        this.markDirty();
+    }
+
+<<<<<<< HEAD
+
+    // ── Auto Complete ─────────────────────────────────
+
+    getSuggestions(input: string): string[] {
+        return this._suggestions.filter(item =>
+            item
+                .toLowerCase()
+                .includes(input.toLowerCase())
+        );
+    }
+
+
+    acceptSuggestion(): void {
+        const suggestions = this.getSuggestions(this._value);
+
+        if (suggestions.length === 0) {
+            return;
         }
+
+        this.value = suggestions[this._suggestionIndex];
+
+        this._cursorPos = splitGraphemes(
+            this._value
+        ).length;
+
+        this.markDirty();
     }
 
+        // ── Cursor Movement ───────────────────────────────
+
+=======
     deleteWordBack(): void {
         if (this._cursorPos === 0) return;
 
@@ -150,6 +247,7 @@ export class TextInput extends Widget {
         this.markDirty();
     }
 
+>>>>>>> upstream/main
     moveCursorLeft(): void {
         const next = Math.max(0, this._cursorPos - 1);
 
@@ -161,9 +259,14 @@ export class TextInput extends Widget {
         this.markDirty();
     }
 
+
     moveCursorRight(): void {
         const graphemes = splitGraphemes(this._value);
-        const next = Math.min(graphemes.length, this._cursorPos + 1);
+
+        const next = Math.min(
+            graphemes.length,
+            this._cursorPos + 1
+        );
 
         if (next === this._cursorPos) {
             return;
@@ -173,6 +276,7 @@ export class TextInput extends Widget {
         this.markDirty();
     }
 
+
     moveCursorHome(): void {
         if (this._cursorPos === 0) {
             return;
@@ -182,8 +286,10 @@ export class TextInput extends Widget {
         this.markDirty();
     }
 
+
     moveCursorEnd(): void {
         const graphemes = splitGraphemes(this._value);
+
         if (this._cursorPos === graphemes.length) {
             return;
         }
@@ -192,13 +298,22 @@ export class TextInput extends Widget {
         this.markDirty();
     }
 
+
+    // ── Actions ───────────────────────────────────────
+
     submit(): void {
         this._onSubmit?.(this._value);
     }
 
+
     clear(): void {
         this._value = '';
         this._cursorPos = 0;
+<<<<<<< HEAD
+
+        this._suggestionIndex = 0;
+
+=======
         this._suggestionIndex = 0;
         this._onChange?.('');
         this.markDirty();
@@ -207,13 +322,16 @@ export class TextInput extends Widget {
     clearLine(): void {
         this._value = '';
         this._cursorPos = 0;
+>>>>>>> upstream/main
         this._onChange?.('');
+
         this.markDirty();
     }
 
-    handleKey(event: KeyEvent): void {
+        handleKey(event: KeyEvent): void {
         const isVim = process.env.TERMUI_KEYBINDINGS === 'vim';
 
+        // Vim mode handling
         if (isVim) {
             if (this._vimMode === 'normal') {
                 switch (event.key) {
@@ -222,87 +340,61 @@ export class TextInput extends Widget {
                         this.markDirty();
                         event.preventDefault();
                         event.stopPropagation();
-                        break;
+                        return;
+
                     case 'a':
                         this._vimMode = 'insert';
                         this.moveCursorRight();
                         this.markDirty();
                         event.preventDefault();
                         event.stopPropagation();
-                        break;
-                    case 'v':
-                        this._vimMode = 'visual';
-                        this.markDirty();
-                        event.preventDefault();
-                        event.stopPropagation();
-                        break;
+                        return;
+
                     case 'h':
                         this.moveCursorLeft();
                         event.preventDefault();
                         event.stopPropagation();
-                        break;
+                        return;
+
                     case 'l':
                         this.moveCursorRight();
                         event.preventDefault();
                         event.stopPropagation();
-                        break;
-                    case 'x': {
-                        const graphemes = splitGraphemes(this._value);
-                        if (this._cursorPos < graphemes.length) {
-                            graphemes.splice(this._cursorPos, 1);
-                            this._value = graphemes.join('');
-                            this._cursorPos = Math.min(this._cursorPos, graphemes.length - 1);
-                            this._cursorPos = Math.max(0, this._cursorPos);
-                            this._onChange?.(this._value);
-                            this.markDirty();
-                        }
+                        return;
+
+                    case 'x':
+                        this.deleteForward();
                         event.preventDefault();
                         event.stopPropagation();
-                        break;
-                    }
-                    case 'j':
-                        event.key = 'tab';
-                        event.shift = false;
-                        break;
-                    case 'k':
-                        event.key = 'tab';
-                        event.shift = true;
-                        break;
+                        return;
+
                     case 'enter':
                     case 'return':
                         this.submit();
                         event.preventDefault();
                         event.stopPropagation();
-                        break;
+                        return;
+
                     default:
                         event.preventDefault();
                         event.stopPropagation();
-                        break;
-                }
-                return;
-            } else if (this._vimMode === 'visual') {
-                if (event.key === 'escape') {
-                    this._vimMode = 'normal';
-                    this.markDirty();
-                    event.preventDefault();
-                    event.stopPropagation();
-                } else {
-                    event.preventDefault();
-                    event.stopPropagation();
+                        return;
                 }
+            }
+
+            if (this._vimMode === 'insert' && event.key === 'escape') {
+                this._vimMode = 'normal';
+                this.moveCursorLeft();
+
+                event.preventDefault();
+                event.stopPropagation();
                 return;
-            } else if (this._vimMode === 'insert') {
-                if (event.key === 'escape') {
-                    this._vimMode = 'normal';
-                    this.moveCursorLeft();
-                    this.markDirty();
-                    event.preventDefault();
-                    event.stopPropagation();
-                    return;
-                }
             }
         }
 
+<<<<<<< HEAD
+        // Normal input handling
+=======
         if (event.ctrl) {
             if (event.key === 'u') {
                 this.clearLine();
@@ -317,50 +409,67 @@ export class TextInput extends Widget {
             }
         }
 
+>>>>>>> upstream/main
         switch (event.key) {
             case 'tab':
                 this.acceptSuggestion();
                 event.preventDefault();
                 event.stopPropagation();
                 break;
+<<<<<<< HEAD
+
+=======
+>>>>>>> upstream/main
             case 'backspace':
                 this.deleteBack();
                 event.preventDefault();
                 event.stopPropagation();
                 break;
+
             case 'delete':
                 this.deleteForward();
                 event.preventDefault();
                 event.stopPropagation();
                 break;
+
             case 'left':
                 this.moveCursorLeft();
                 event.preventDefault();
                 event.stopPropagation();
                 break;
+
             case 'right':
                 this.moveCursorRight();
                 event.preventDefault();
                 event.stopPropagation();
                 break;
+
             case 'home':
                 this.moveCursorHome();
                 event.preventDefault();
                 event.stopPropagation();
                 break;
+
             case 'end':
                 this.moveCursorEnd();
                 event.preventDefault();
                 event.stopPropagation();
                 break;
-            case 'return':
+
             case 'enter':
+            case 'return':
                 this.submit();
                 event.preventDefault();
                 event.stopPropagation();
                 break;
+
             default:
-                if (event.key && splitGraphemes(event.key).length === 1 && !event.ctrl && !event.alt) {
+                if (
+                    event.key &&
+                    splitGraphemes(event.key).length === 1 &&
+                    !event.ctrl &&
+                    !event.alt
+                ) {
                     this.insertChar(event.key);
                     event.preventDefault();
                     event.stopPropagation();
@@ -368,82 +477,67 @@ export class TextInput extends Widget {
         }
     }
 
-    protected _renderSelf(screen: Screen): void {
+        protected _renderSelf(screen: Screen): void {
         const rect = this._getContentRect();
         const { x, y, width, height } = rect;
+
         if (width <= 0 || height <= 0) return;
 
         const attrs = styleToCellAttrs(this._style);
 
-        if (this._value.length === 0 && !this.isFocused) {
-            screen.writeString(x, y, truncate(this._placeholder, width), { ...attrs, dim: true });
-            return;
-        }
+        let display = this._value;
 
-        const graphemes = splitGraphemes(this._value);
-        const displayGraphemes = this._mask
-            ? Array(graphemes.length).fill(this._mask)
-            : graphemes;
-
-        let rightReserved = 0;
-        let modeIndicator = '';
-        if (process.env.TERMUI_KEYBINDINGS === 'vim' && this.isFocused && width > 15) {
-            modeIndicator = ` -- ${this._vimMode.toUpperCase()} -- `;
-            rightReserved = modeIndicator.length;
-        } else if (this.isFocused) {
-            const length = this._value.length;
-            const max = this._maxLength === Infinity ? null : this._maxLength;
-            const counterText = max ? `${length}/${max}` : `${length}`;
-            const counterWidth = stringWidth(counterText);
-            if (x + width - counterWidth >= x) {
-                rightReserved = counterWidth;
-            }
+        if (this._mask) {
+            display = splitGraphemes(this._value)
+                .map(() => this._mask!)
+                .join('');
         }
 
-        const maxVisibleWidth = width - rightReserved;
-        if (maxVisibleWidth <= 0) return;
-
-        // Calculate visual width prefix sums
-        const prefixWidths: number[] = [0];
-        for (let i = 0; i < displayGraphemes.length; i++) {
-            prefixWidths.push(prefixWidths[i] + stringWidth(displayGraphemes[i]));
+        if (display.length === 0 && !this.isFocused) {
+            display = this._placeholder;
         }
 
-        let scrollGraphemeIndex = 0;
-        const targetVisualEnd = this._cursorPos < displayGraphemes.length
-            ? prefixWidths[this._cursorPos + 1]
-            : prefixWidths[this._cursorPos];
+        const graphemes = splitGraphemes(display);
 
-        while (scrollGraphemeIndex < this._cursorPos && targetVisualEnd - prefixWidths[scrollGraphemeIndex] > maxVisibleWidth) {
-            scrollGraphemeIndex++;
-        }
+let scrollX = 0;
 
-        let endGraphemeIndex = scrollGraphemeIndex;
-        while (endGraphemeIndex < displayGraphemes.length && prefixWidths[endGraphemeIndex + 1] - prefixWidths[scrollGraphemeIndex] <= maxVisibleWidth) {
-            endGraphemeIndex++;
-        }
+if (this.isFocused && graphemes.length > width) {
+    scrollX = Math.max(0, this._cursorPos - width);
+}
 
-        const visibleGraphemes = displayGraphemes.slice(scrollGraphemeIndex, endGraphemeIndex);
-        const visibleText = visibleGraphemes.join('');
-        screen.writeString(x, y, visibleText, attrs);
+display = graphemes
+    .slice(scrollX, scrollX + width)
+    .join('');
 
-        if (this.isFocused) {
-            const cursorOffset = prefixWidths[this._cursorPos] - prefixWidths[scrollGraphemeIndex];
-            const cursorScreenPos = x + cursorOffset;
-            if (cursorScreenPos >= x && cursorScreenPos < x + maxVisibleWidth) {
-                const cursorChar = this._cursorPos < displayGraphemes.length
-                    ? displayGraphemes[this._cursorPos]
-                    : ' ';
-                const isBlock = this._vimMode === 'normal' || this._vimMode === 'visual';
-                screen.setCell(cursorScreenPos, y, {
-                    char: cursorChar[0] || ' ',
-                    ...attrs,
-                    inverse: isBlock,
-                    underline: !isBlock,
-                });
+
+        screen.writeString(
+            x,
+            y,
+            display,
+            {
+                ...attrs,
+                dim: this._value.length === 0,
             }
-        }
+        );
 
+        // Cursor
+        if (this.isFocused) {
+            if (this.isFocused) {
+    const cursorIndex = this._cursorPos - scrollX;
+
+<<<<<<< HEAD
+    if (cursorIndex >= 0 && cursorIndex < width) {
+        const charIndex = Math.min(
+            this._cursorPos,
+            graphemes.length - 1
+        );
+
+        screen.setCell(x + cursorIndex, y, {
+            char: graphemes[charIndex] ?? ' ',
+            ...attrs,
+            underline: true,
+        });
+=======
         if (modeIndicator) {
             screen.writeString(x + width - modeIndicator.length, y, modeIndicator, { ...attrs, dim: true });
         } else if (this.isFocused) {
@@ -462,5 +556,43 @@ export class TextInput extends Widget {
         for (let i = 0; i < suggestions.length; i++) {
             screen.writeString(x, y + i + 1, truncate(suggestions[i], width), { ...attrs, dim: true });
         }
+>>>>>>> upstream/main
     }
 }
+
+// Cursor
+if (this.isFocused) {
+    const cursorIndex = this._cursorPos - scrollX;
+
+    if (cursorIndex >= 0 && cursorIndex < width) {
+        const charIndex = Math.min(
+            this._cursorPos,
+            graphemes.length - 1
+        );
+
+        screen.setCell(x + cursorIndex, y, {
+            char: graphemes[charIndex] ?? ' ',
+            ...attrs,
+            underline: true,
+        });
+    }
+}
+        }
+
+        // Auto-complete suggestions
+        const suggestions = this.getSuggestions(this._value)
+            .slice(0, height - 1);
+
+        suggestions.forEach((suggestion, index) => {
+            screen.writeString(
+                x,
+                y + index + 1,
+                truncate(suggestion, width),
+                {
+                    ...attrs,
+                    dim: true,
+                }
+            );
+        });
+    }
+}
\ No newline at end of file
diff --git a/packages/widgets/src/layout/Workspace.test.ts b/packages/widgets/src/layout/Workspace.test.ts
new file mode 100644
index 00000000..6ed77dc6
--- /dev/null
+++ b/packages/widgets/src/layout/Workspace.test.ts
@@ -0,0 +1,85 @@
+import { describe, expect, it } from 'vitest';
+import { Workspace } from './Workspace.js';
+
+describe('Workspace', () => {
+    it('saves and loads layouts', () => {
+        const workspace = new Workspace();
+
+        const layout = {
+            id: 'dashboard',
+            panels: [{ id: 'logs' }, { id: 'stats' }],
+        };
+
+        workspace.saveLayout('dashboard', layout);
+
+        expect(workspace.loadLayout('dashboard')).toEqual(layout);
+    });
+
+    it('switches workspaces', () => {
+        const workspace = new Workspace();
+
+        workspace.saveLayout('default', {
+            id: 'default',
+            panels: [],
+        });
+
+        workspace.saveLayout('dev', {
+            id: 'dev',
+            panels: [],
+        });
+
+        workspace.switchWorkspace('dev');
+
+        expect(workspace.getCurrentWorkspace()).toBe('dev');
+    });
+
+    it('lists workspace names', () => {
+        const workspace = new Workspace();
+
+        workspace.saveLayout('default', {
+            id: 'default',
+            panels: [],
+        });
+
+        workspace.saveLayout('editor', {
+            id: 'editor',
+            panels: [],
+        });
+
+        expect(workspace.getWorkspaceNames()).toEqual([
+            'default',
+            'editor',
+        ]);
+    });
+
+    it('removes a workspace', () => {
+        const workspace = new Workspace();
+
+        workspace.saveLayout('temp', {
+            id: 'temp',
+            panels: [],
+        });
+
+        workspace.removeWorkspace('temp');
+
+        expect(workspace.loadLayout('temp')).toBeUndefined();
+    });
+
+    it('clears all workspaces', () => {
+        const workspace = new Workspace();
+
+        workspace.saveLayout('one', {
+            id: 'one',
+            panels: [],
+        });
+
+        workspace.saveLayout('two', {
+            id: 'two',
+            panels: [],
+        });
+
+        workspace.clear();
+
+        expect(workspace.getWorkspaceNames()).toEqual([]);
+    });
+});
\ No newline at end of file
diff --git a/packages/widgets/src/layout/Workspace.ts b/packages/widgets/src/layout/Workspace.ts
new file mode 100644
index 00000000..f6c60654
--- /dev/null
+++ b/packages/widgets/src/layout/Workspace.ts
@@ -0,0 +1,74 @@
+// ─────────────────────────────────────────────────────
+// @termuijs/widgets — Workspace
+// Layout persistence and workspace management
+// ─────────────────────────────────────────────────────
+
+export interface WorkspaceLayout {
+    id: string;
+    panels: unknown[];
+}
+
+export interface WorkspaceStorage {
+    save(name: string, data: string): void;
+    load(name: string): string | null;
+}
+
+export interface WorkspaceOptions {
+    defaultWorkspace?: string;
+}
+
+export class Workspace {
+    private layouts = new Map<string, WorkspaceLayout>();
+    private activeWorkspace: string;
+
+    constructor(options: WorkspaceOptions = {}) {
+        this.activeWorkspace = options.defaultWorkspace ?? "default";
+    }
+
+    saveLayout(name: string, layout: WorkspaceLayout): void {
+        this.layouts.set(name, layout);
+    }
+
+    loadLayout(name: string): WorkspaceLayout | undefined {
+        return this.layouts.get(name);
+    }
+
+    switchWorkspace(name: string): void {
+        if (this.layouts.has(name)) {
+            this.activeWorkspace = name;
+        }
+    }
+
+    getCurrentWorkspace(): string {
+        return this.activeWorkspace;
+    }
+
+    getWorkspaceNames(): string[] {
+        return [...this.layouts.keys()];
+    }
+
+    removeWorkspace(name: string): void {
+        this.layouts.delete(name);
+    }
+
+    clear(): void {
+        this.layouts.clear();
+    }
+
+    save(storage: WorkspaceStorage): void {
+        storage.save(
+            this.activeWorkspace,
+            JSON.stringify([...this.layouts])
+        );
+    }
+
+    restore(storage: WorkspaceStorage): void {
+        const data = storage.load(this.activeWorkspace);
+
+        if (!data) return;
+
+        this.layouts = new Map(
+            JSON.parse(data)
+        );
+    }
+}
\ No newline at end of file