Core Components

type OS struct {
    Windows            []*terminal.Window  // All terminal windows
    FocusedWindow      int                 // Index of focused window
    Mode               Mode                // WindowManagementMode or TerminalMode
    CurrentWorkspace   int                 // Active workspace (1-9)
    WorkspaceFocus     map[int]int         // Focused window per workspace
    AutoTiling         bool                // Tiling mode enabled
    WorkspaceTrees     map[int]*layout.BSPTree  // BSP tree per workspace
    Animations         []*ui.Animation     // Active animations
    // ... 50+ more fields
}

func (m *OS) AddWindow(title string) *OS {
    // 1. Generate unique ID
    // 2. Allocate PTY and spawn shell
    // 3. Create VT emulator instance
    // 4. Add to current workspace
    // 5. Auto-tile if enabled
    // 6. Focus new window
}

func (m *OS) DeleteWindow(i int) *OS {
    // 1. Close PTY and kill shell
    // 2. Clean up VT emulator
    // 3. Remove from window list
    // 4. Update focus to next visible window
    // 5. Retile if in tiling mode
}

type Window struct {
    ID          string          // Unique identifier
    Title       string          // Window title
    X, Y        int             // Position
    Width, Height int           // Dimensions
    Z           int             // Z-index for stacking
    Terminal    *vt.Emulator    // VT100 emulator
    Pty         *os.File        // Pseudo-terminal
    Workspace   int             // Workspace number (1-9)
    Minimized   bool            // Minimized state
    // ... 40+ more fields
}

type Emulator struct {
    scrs     [2]Screen    // Main and alternate screen buffers
    scr      *Screen      // Currently active screen
    parser   *ansi.Parser // ANSI escape sequence parser
    modes    ansi.Modes   // Terminal modes (origin, wraparound, etc.)
    // ... more fields
}

func (m *OS) GetCanvas(render bool) *lipgloss.Canvas {
    canvas := lipgloss.NewCanvas(m.Width, m.Height)
    layers := []*lipgloss.Layer{}

    // 1. Render visible windows
    for i, window := range m.Windows {
        if window.Workspace != m.CurrentWorkspace { continue }
        if window.Minimized { continue }

        // Viewport culling
        if !isVisible(window) { continue }

        // Render window content
        content := m.renderTerminal(window, isFocused, ...)
        layer := lipgloss.NewLayer(content)
            .X(window.X)
            .Y(window.Y)
            .Z(window.Z)
        layers = append(layers, layer)
    }

    // 2. Add overlays (dock, status, notifications)
    // 3. Compose all layers
    canvas.Compose(lipgloss.NewCompositor(layers...))
    return canvas
}

type StyleCache struct {
    cache   map[uint64]lipgloss.Style  // Hash -> Style mapping
    maxSize int                        // Max entries (default: 1024)
    hits    atomic.Uint64              // Cache hits
    misses  atomic.Uint64              // Cache misses
}

cache := app.GetGlobalStyleCache()
style := cache.Get(cell, isCursor, optimized)

func HandleInput(msg tea.Msg, o *app.OS) (tea.Model, tea.Cmd) {
    switch msg := msg.(type) {
    case tea.KeyPressMsg:
        return HandleKeyPress(msg, o)
    case tea.MouseClickMsg:
        return handleMouseClick(msg, o)
    case tea.MouseMotionMsg:
        return handleMouseMotion(msg, o)
    }
}

func HandleKeyPress(msg tea.KeyPressMsg, o *app.OS) (*app.OS, tea.Cmd) {
    // 1. Check for prefix key (Ctrl+B)
    if isPrefixKey(msg) {
        o.PrefixActive = true
        return o, nil
    }

    // 2. Handle prefix commands
    if o.PrefixActive {
        return handlePrefixCommand(msg, o)
    }

    // 3. Route based on mode
    if o.Mode == app.TerminalMode {
        return forwardToTerminal(msg, o)
    } else {
        return handleWindowManagement(msg, o)
    }
}

func handleMouseClick(msg tea.MouseClickMsg, o *app.OS) (*app.OS, tea.Cmd) {
    // 1. Check if clicking window title bar
    if clickedTitleBar(msg, o) {
        o.Dragging = true
        return o, nil
    }

    // 2. Check if clicking window corner (resize)
    if clickedCorner(msg, o) {
        o.Resizing = true
        return o, nil
    }

    // 3. Focus window and enter terminal mode
    o.FocusWindow(windowIndex)
    o.Mode = app.TerminalMode
}

[general]
theme = "catppuccin-mocha"
default_shell = "/bin/zsh"

[keybindings]
leader_key = "ctrl+b"

[window]
default_width = 80
default_height = 24

[performance]
style_cache_size = 1024

type KeybindRegistry struct {
    bindings map[string]ActionFunc  // "ctrl+b, w, 1" -> SwitchWorkspace(1)
    actions  map[string]ActionInfo  // Action descriptions
}

registry.Register("new_window", ActionInfo{
    Description: "Create a new terminal window",
    Category:    "Window Management",
    DefaultKey:  "ctrl+b, c",
})

type BSPTree struct {
    Root        *TileNode      // Root of the tree
    WindowCount int            // Number of windows
}

type TileNode struct {
    Parent     *TileNode   // Parent node
    Left       *TileNode   // Left/Top child
    Right      *TileNode   // Right/Bottom child
    WindowID   int         // Window ID (leaf nodes)
    SplitType  SplitType   // Vertical or Horizontal
    SplitRatio float64     // Split position (0.0-1.0)
}