Im going back to writing code by hand

case resourcesLoadedMsg:
    m.logLines = nil       // Clear log lines when loading resources
    m.horizontalOffset = 0 // Reset horizontal scroll on resource change

    if m.currentGVR != msg.gvr && m.resourceWatcher != nil {
        m.resourceWatcher.Stop()
        m.resourceWatcher = nil
    }
    m.currentGVR = msg.gvr
    m.currentNamespace = msg.namespace
    m.listOptions = msg.listOptions
    m.rawObjects = msg.rawObjects

    // For nodes: store the full unfiltered set, classify, then filter
    if msg.gvr.Resource == k8s.ResourceNodes && m.fleetView != nil {
        m.allResources = msg.resources
        m.allCreationTimes = msg.creationTimes
        if len(msg.rawObjects) > 0 {
            m.fleetView.ClassifyAndCount(m.rawObjectPtrs())
        }
        m.applyFleetFilter()
    } else {
        m.resources = msg.resources
        m.creationTimes = msg.creationTimes
        m.allResources = nil
        m.allCreationTimes = nil
    }

m.logLines = nil       // Clear log lines when loading resources
m.allResources = nil   // Clear fleet data when not on nodes
m.resources = nil      // Clear resources when loading logs
m.resources = nil      // Clear resources when loading describe view
m.logLines = nil       // Clear log lines when loading describe view
m.resources = nil      // Clear resources when loading yaml view
m.logLines = nil       // Clear log lines when loading yaml view
m.logLines = nil       // ... two more in other handlers
m.logLines = nil

# Architecture Invariants (CLAUDE.md)

- Each view implements the View trait. Views do NOT access other views' state.
- All async data arrives via AppMsg variants. No direct field mutation from background tasks.
- Adding a new view MUST NOT require modifying existing views.
- The App struct is a thin router. It owns navigation and message dispatch. Nothing else.

case m.config.KeyBind.For(config.ActionToggleAutoScroll, key):
    if m.currentGVR.Resource == k8s.ResourceLogs {
        m.logView.Autoscroll = !m.logView.Autoscroll
        if m.logView.Autoscroll {
            m.table.GotoBottom()
        }
        return m, nil
    }
    // Shell exec for pods and containers views
    if m.currentGVR.Resource == k8s.ResourcePods {
        // ... 20 lines to look up selected pod, get name, namespace ...
        return m, m.commandWithPreflights(
            m.execIntoPod(selectedName, selectedNamespace),
            m.requireConnection,
        )
    }
    if m.currentGVR.Resource == k8s.ResourceContainers {
        // ... container exec logic ...
        return m, m.commandWithPreflights(m.execIntoContainer(), m.requireConnection)
    }
    return m, nil

case m.config.KeyBind.For(config.ActionSubmit, key):
    // Special handling for contexts view
    if m.currentGVR.Resource == "contexts" {
        // ... 12 lines ...
        return m, m.executeCtxCommand([]string{contextName})
    }
    // Special handling for namespaces view
    if m.currentGVR.Resource == "namespaces" {
        // ... 12 lines ...
        return m, m.executeNsCommand([]string{namespaceName})
    }
    if m.currentGVR.Resource == k8s.ResourceLogs {
        return m, nil
    }
    // ... 25 more lines of generic drill-down ...

# State Ownership Rules

- NEVER add fields to the App/Model struct for view-specific state.
- Each view is a separate struct implementing the View trait/interface.
- Each view declares its own key bindings. The app dispatches keys to the active view.
- If you need to add a keybinding, add it to the relevant view's keymap, not a global one.
- Adding a view means adding a file. If your change requires modifying existing views, stop and ask.

type keyMap struct {
    Up, Down, Left, Right    key.Binding
    GotoTop, GotoBottom      key.Binding
    AllNS, DefaultNS         key.Binding
    Enter, Back              key.Binding
    Command, Quit            key.Binding
    Fullscreen               key.Binding  // log view
    Autoscroll               key.Binding  // log view (also shell in pods!)
    ToggleTime               key.Binding  // log view
    WrapText                 key.Binding  // log + describe view
    CopyLogs                 key.Binding  // log view
    ToggleLineNums           key.Binding  // describe view
    Describe                 key.Binding  // resource views
    YamlView                 key.Binding  // resource views
    Edit                     key.Binding  // resource views
    Shell                    key.Binding  // pods (CONFLICTS with Autoscroll!)
    FilterLogs               key.Binding  // log view
    FleetTabNext             key.Binding  // fleet view only
    FleetTabPrev             key.Binding  // fleet view only
}

# Scope (do NOT expand beyond this)

k10s is for GPU cluster operators. Not all Kubernetes users.
Supported views: fleet, node-detail, gpu-detail, workload. That's it.
Do NOT add generic resource views (pods, deployments, services).
Do NOT add features that duplicate k9s functionality.
If a feature request doesn't serve someone running GPU training jobs, reject it.

type OrderedResourceFields []string

func sortFilteredResources(rows []k8s.OrderedResourceFields, times []time.Time, tab FleetTab) {
    sort.SliceStable(indices, func(a, b int) bool {
        ra := rows[indices[a]]
        rb := rows[indices[b]]

        switch tab {
        case FleetTabGPU:
            // Sort by Alloc column (index 3) ascending
            allocA, allocB := "", ""
            if len(ra) > 3 {
                allocA = ra[3]
            }
            if len(rb) > 3 {
                allocB = rb[3]
            }
            return allocA < allocB

        case FleetTabCPU:
            // Sort by Name column (index 0) ascending
            nameA, nameB := "", ""
            if len(ra) > 0 {
                nameA = ra[0]
            }
            if len(rb) > 0 {
                nameB = rb[0]
            }
            return nameA < nameB

        case FleetTabAll:
            // GPU nodes first, then CPU nodes.
            // Within GPU: sort by Alloc (index 3).
            // Within CPU: sort by Name (index 0).
            computeA, computeB := "", ""
            if len(ra) > 2 {
                computeA = ra[2]
            }
            if len(rb) > 2 {
                computeB = rb[2]
            }
            aIsGPU := strings.HasPrefix(computeA, "gpu")
            bIsGPU := strings.HasPrefix(computeB, "gpu")
            // ...
        }
    })
}

{
  "nodes": {
    "fields": [
      { "name": "Name",     "weight": 0.28 },
      { "name": "Instance", "weight": 0.15 },
      { "name": "Compute",  "weight": 0.12 },
      { "name": "Alloc",    "weight": 0.12 },
      ...
    ]
  }
}

# Data Representation

- NEVER flatten structured data into []string, Vec, or positional arrays.
- All data flows as typed structs (FleetNode, PodInfo, etc.) until the render() call.
- Column identity comes from struct field names, not array indices.
- Sort functions operate on typed fields, never on positional access like row[3].
- The ONLY place strings are created for display is inside render()/view() functions.

struct FleetNode {
    name: String,
    instance_type: String,
    compute_class: ComputeClass,
    alloc: GpuAlloc,
}

case updateTableMsg:
    return m, func() tea.Msg {
        // block on someone sending the update message.
        <-m.updateTableChan
        // Preserve cursor position across column/row updates so that
        // background refreshes don't reset the user's selection.
        savedCursor := max(m.table.Cursor(), 0)
        // run the necessary table view update calls.
        m.updateColumns(m.viewWidth)
        m.updateTableData()
        // Restore cursor, clamped to valid range.
        rowCount := len(m.table.Rows())
        if rowCount > 0 {
            if savedCursor >= rowCount {
                savedCursor = rowCount - 1
            }
            m.table.SetCursor(savedCursor)
        }
        return updateTableMsg{}
    }

// Background task:
tx.send(AppMsg::FleetData(nodes)).await;

// Main loop:
match msg {
    AppMsg::FleetData(nodes) => {
        self.fleet_view.update_nodes(nodes);
    }
}

# Concurrency Rules

- Background tasks (watchers, scrapers, API calls) NEVER mutate UI state directly.
- Background tasks send results through a channel as typed messages.
- Only the main event loop applies state mutations from received messages.
- render()/view() is a PURE function. No side effects. No I/O. No channel operations.
- If you need to update state from async work, define a new AppMsg variant.