Function bodies 285 total

func sortBySize(rows []table.Row, colIdx int, asc bool) {
	slices.SortFunc(rows, func(a, b table.Row) int {
		av, _ := parseSize(a[colIdx])
		bv, _ := parseSize(b[colIdx])
		if asc {
			return int(av - bv)
		}
		return int(bv - av)
	})
}

func parseSize(s string) (int64, error) {
	s = strings.TrimSpace(s)
	if s == "" {
		return 0, nil
	}
	n := len(s)
	if n == 0 {
		return 0, nil
	}
	last := s[n-1]
	var mult float64 = 1
	switch last {
	case 'B', 'b':
		mult = 1e9
		s = s[:n-1]
	case 'M', 'm':
		mult = 1e6
		s = s[:n-1]
	case 'T', 't':
		mult = 1e12
		s = s[:n-1]
	}
	num, err := strconv.ParseFloat(strings.TrimSpace(s), 64)
	if err != nil {
		return 0, err
	}
	return int64(num*mult + 0.5), nil // round to nearest int
}

func sortByString(rows []table.Row, colIdx int, asc bool) {
	slices.SortFunc(rows, func(a, b table.Row) int {
		if asc {
			return strings.Compare(a[colIdx], b[colIdx])
		}
		return strings.Compare(b[colIdx], a[colIdx])
	})
}

func hasIntHeader(m map[string]struct{}, header string) bool {
	for k := range m {
		if strings.EqualFold(k, header) {
			return true
		}
	}
	return false
}

func parsePercent(s string) (int64, error) {
	s = strings.TrimSpace(strings.TrimSuffix(s, "%"))
	f, err := strconv.ParseFloat(s, 64)
	if err != nil {
		return 0, err
	}
	return int64(f + 0.5), nil // round to nearest int
}

func getHeaders(category domain.Category) []header {
	if headers, exists := headerDefinitions[category]; exists {
		return headers
	}
	return nil
}

func getTableRows(dataset *models.Dataset, category domain.Category, context *domain.ToolkitContext, filter string, sortColumn string, sortAsc bool, faultyOnly bool) ([]table.Row, tableStats) {
	if context != nil && !context.Category.IsScopeOf(category) {
		context = nil
	}

	if handler, exists := categoryHandlers[category]; exists {
		rows := handler(dataset, context, filter, faultyOnly)
		if sortColumn != "" && len(rows) > 0 {
			headers := getHeaders(category)
			sortRows(rows, headers, sortColumn, sortAsc)
		}
		return rows, computeStats(category, rows)
	}

	return nil, nil
}

func computeStats(category domain.Category, rows []table.Row) tableStats {
	cols, ok := statsColumns[category]
	if !ok || len(rows) == 0 {
		return nil
	}
	headers := getHeaders(category)
	idx := make(map[string]int)
	for i, h := range headers {
		idx[h.text] = i
	}
	totals := make(tableStats)
	for _, col := range cols {
		columnIdx, ok := idx[col]
		if !ok {
			return nil // header missing, bail out
		}
		sum := 0
		for _, r := range rows {
			v, err := strconv.Atoi(r[columnIdx])
			if err == nil {
				sum += v
			}
		}
		totals[col] = sum
	}
	return totals
}

func getItemKey(category domain.Category, row table.Row) models.ItemKey {
	if len(row) == 0 {
		return nil
	}
	switch category {
	case domain.Tenant, domain.LimitDefinition, domain.Environment, domain.ServiceTenancy,
		domain.ConsolePropertyDefinition, domain.PropertyDefinition, domain.GpuPool,
		domain.LimitRegionalOverride, domain.ConsolePropertyRegionalOverride,
		domain.PropertyRegionalOverride, domain.ModelArtifact, domain.Alias, domain.BaseModel:
		return row[0]
	case domain.LimitTenancyOverride, domain.ConsolePropertyTenancyOverride,
		domain.PropertyTenancyOverride, domain.GpuNode, domain.DedicatedAICluster:
		return models.ScopedItemKey{Scope: row[1], Name: row[0]}
	case domain.CategoryUnknown:
		// exhaustive
	}
	return nil
}

func findItem(dataset *models.Dataset, category domain.Category, key models.ItemKey) any {
	if key == nil {
		return nil
	}
	switch category {
	case domain.Tenant:
		return findTenant(dataset, key)
	case domain.LimitDefinition:
		return findLimitDefinition(dataset, key)
	case domain.ConsolePropertyDefinition:
		return findConsolePropertyDefinition(dataset, key)
	case domain.PropertyDefinition:
		return findPropertyDefinition(dataset, key)
	case domain.LimitTenancyOverride:
		return findLimitTenancyOverride(dataset, key)
	case domain.ConsolePropertyTenancyOverride:
		return findConsolePropertyTenancyOverride(dataset, key)
	case domain.PropertyTenancyOverride:
		return findPropertyTenancyOverride(dataset, key)
	case domain.LimitRegionalOverride:
		return findLimitRegionalOverride(dataset, key)
	case domain.ConsolePropertyRegionalOverride:
		return findConsolePropertyRegionalOverride(dataset, key)
	case domain.PropertyRegionalOverride:
		return findPropertyRegionalOverride(dataset, key)
	

func findLimitTenancyOverride(dataset *models.Dataset, key models.ItemKey) any {
	k := key.(models.ScopedItemKey)
	if items, ok := dataset.LimitTenancyOverrideMap[k.Scope]; ok {
		return collections.FindByName(items, k.Name)
	}
	return nil
}

func findConsolePropertyTenancyOverride(dataset *models.Dataset, key models.ItemKey) any {
	k := key.(models.ScopedItemKey)
	if items, ok := dataset.ConsolePropertyTenancyOverrideMap[k.Scope]; ok {
		return collections.FindByName(items, k.Name)
	}
	return nil
}

func findPropertyTenancyOverride(dataset *models.Dataset, key models.ItemKey) any {
	k := key.(models.ScopedItemKey)
	if items, ok := dataset.PropertyTenancyOverrideMap[k.Scope]; ok {
		return collections.FindByName(items, k.Name)
	}
	return nil
}

func findModelArtifact(dataset *models.Dataset, key models.ItemKey) any {
	k := key.(string)
	for _, value := range dataset.ModelArtifactMap {
		if item := collections.FindByName(value, k); item != nil {
			return item
		}
	}
	return nil
}

func findGpuNode(dataset *models.Dataset, key models.ItemKey) any {
	k := key.(models.ScopedItemKey)
	if items, ok := dataset.GpuNodeMap[k.Scope]; ok {
		return collections.FindByName(items, k.Name)
	}
	return nil
}

func findDedicatedAICluster(dataset *models.Dataset, key models.ItemKey) any {
	k := key.(models.ScopedItemKey)
	if items, ok := dataset.DedicatedAIClusterMap[k.Scope]; ok {
		return collections.FindByName(items, k.Name)
	}
	return nil
}

func deleteItem(dataset *models.Dataset, category domain.Category, key models.ItemKey) {
	if key == nil {
		return
	}

	switch category {
	case domain.DedicatedAICluster:
		deleteItemInMap(dataset.DedicatedAIClusterMap, key)
	case domain.GpuNode:
		deleteItemInMap(dataset.GpuNodeMap, key)
	default:
		// exhausive
	}
}

func getItemKeyString(key models.ItemKey) string {
	if k, ok := key.(string); ok {
		return k
	} else if k, ok := key.(models.ScopedItemKey); ok {
		return fmt.Sprintf("%s/%s", k.Scope, k.Name)
	}

	return "UNKNOWN"
}

func (m *Model) updateDetailView(msg tea.Msg) (tea.Model, tea.Cmd) {
	var cmds []tea.Cmd

	if keyMsg, ok := msg.(tea.KeyMsg); ok {
		switch {
		case key.Matches(keyMsg, keys.Quit):
			m.cancelInFlight()
			return m, tea.Quit
		case key.Matches(keyMsg, keys.Back, keys.ViewDetails):
			m.exitDetailView()
		case key.Matches(keyMsg, keys.CopyName):
			item := findItem(m.dataset, m.category, m.choice)
			cmds = append(cmds, m.copyItemNameCmd(item))
		case key.Matches(keyMsg, keys.Help):
			m.enterHelpView()
		case key.Matches(keyMsg, keys.CopyObject):
			cmds = append(cmds, m.copyItemJSONByChoice())
		}
	}

	updatedViewport, cmd := m.viewport.Update(msg)
	m.viewport = &updatedViewport
	cmds = append(cmds, cmd)
	return m, tea.Batch(cmds...)
}

func (m *Model) copyItemJSON(item any) tea.Cmd {
	return func() tea.Msg {
		content, err := jsonutil.PrettyJSON(item)
		if err != nil {
			m.logger.Errorw("failed to convert item to JSON", "error", err)
			return nil
		}
		if err := clipboard.WriteAll(content); err != nil {
			m.logger.Errorw("failed to copy JSON to clipboard", "error", err)
		}
		return nil
	}
}

func (m *Model) updateErrorView(msg tea.Msg) (tea.Model, tea.Cmd) {
	if msg, ok := msg.(tea.KeyMsg); ok {
		if key.Matches(msg, keys.Quit) {
			m.cancelInFlight()
			return m, tea.Quit
		}
	}

	return m, nil
}

func (m *Model) updateExportView(msg tea.Msg) (tea.Model, tea.Cmd) {
	switch msg := msg.(type) {
	case exportDoneMsg:
		m.viewMode = common.ListView
		return m, nil
	case exportErrMsg:
		m.err = fmt.Errorf("export failed: %w", msg.err)
		m.viewMode = common.ErrorView
		return m, nil
	}

	keyMsg, isKeyMsg := msg.(tea.KeyMsg)
	if isKeyMsg {
		switch {
		case key.Matches(keyMsg, keys.ExportCSV):
			m.viewMode = m.lastViewMode
			return m, nil
		case key.Matches(keyMsg, keys.Quit):
			return m, tea.Quit
		}
	}

	updated, cmd := m.dirPicker.Update(msg)
	m.dirPicker = &updated

	selected, selectedPath := m.dirPicker.DidSelectFile(msg)
	if selected && isKeyMsg && key.Matches(keyMsg, keys.Confirm) {
		exportPath := filepath.Join(selectedPath, m.exportFilename())
		return m, m.exportTableCSVCmd(exportPath)
	}

	return m, cmd
}

func (m *Model) exportTableCSVCmd(outPath string) tea.Cmd {
	return func() tea.Msg {
		if err := m.exportTableCSV(outPath); err != nil {
			return exportErrMsg{err: err}
		}
		return exportDoneMsg{}
	}
}

func (m *Model) exportView() string {
	var s strings.Builder
	s.WriteString("Export file name: ")
	s.WriteString(m.dirPicker.Styles.Selected.Render(m.exportFilename()))
	s.WriteString("\n\nPick an export path:\n\n")
	s.WriteString(m.dirPicker.View() + "\n")
	s.WriteString(m.exportHelpView())
	return m.helpBorder.Width(m.viewWidth * 4 / 5).Render(s.String())
}

func (m *Model) exportHelpView() string {
	km := m.dirPicker.KeyMap
	bindings := []key.Binding{
		km.Up, km.Down, km.GoToTop, km.GoToLast,
		km.PageUp, km.PageDown, km.Select, km.Open, km.Back,
	}
	return m.help.ShortHelpView(bindings)
}

func (m *Model) updateHelpView(msg tea.Msg) (tea.Model, tea.Cmd) {
	if keyMsg, ok := msg.(tea.KeyMsg); ok {
		if key.Matches(keyMsg, keys.Back, keys.Help) {
			m.viewMode = m.lastViewMode
		} else if key.Matches(keyMsg, keys.Quit) {
			m.cancelInFlight()
			return m, tea.Quit
		}
	}

	return m, nil
}

func (m *Model) updateListView(msg tea.Msg) (tea.Model, tea.Cmd) {
	cmds := m.routeListMsg(msg)

	updatedTable, cmd := m.table.Update(msg)
	m.table = &updatedTable
	cmds = append(cmds, cmd)
	return m, tea.Batch(cmds...)
}

func (m *Model) routeListMsg(msg tea.Msg) []tea.Cmd {
	switch msg := msg.(type) {
	case tea.KeyMsg:
		return m.handleKeyMsg(msg)
	case DataMsg:
		return []tea.Cmd{m.handleDataMsg(msg)}
	case FilterMsg:
		return []tea.Cmd{m.handleFilterMsg(msg)}
	case SetFilterMsg:
		return []tea.Cmd{m.handleSetFilterMsg(msg)}
	case FilterApplyMsg:
		return []tea.Cmd{m.handleFilterApplyMsg(msg)}
	case deleteErrMsg:
		m.handleDeleteErrMsg(msg)
		return nil
	case deleteDoneMsg:
		m.handleDeleteDoneMsg(msg)
		return nil
	case updateDoneMsg:
		m.handleUpdateDoneMsg(msg)
		return nil
	default:
		return m.routeListAsyncMsg(msg)
	}
}

func (m *Model) routeListAsyncMsg(msg tea.Msg) []tea.Cmd {
	switch msg := msg.(type) {
	case gpuPoolScaleStartedMsg:
		m.handleGpuPoolScaleStartedMsg(msg)
	case gpuPoolScaleResultMsg:
		m.handleGpuPoolScaleResultMsg(msg)
	case cordonNodeResultMsg:
		m.handleCordonNodeResultMsg(msg)
	case drainNodeResultMsg:
		m.handleDrainNodeResultMsg(msg)
	case rebootNodeResultMsg:
		m.handleRebootNodeResultMsg(msg)
	default:
		return m.routeListDataMsg(msg)
	}
	return nil
}

func (m *Model) routeListDataMsg(msg tea.Msg) []tea.Cmd {
	switch msg := msg.(type) {
	case datasetLoadedMsg:
		return []tea.Cmd{m.handleDataMsg(DataMsg{Data: msg.Dataset, Gen: msg.Gen})}
	case baseModelsLoadedMsg:
		m.handleBaseModelsLoaded(msg.Items, msg.Gen)
	case gpuPoolsLoadedMsg:
		return []tea.Cmd{m.handleGpuPoolsLoaded(msg.Items, msg.Gen)}
	default:
		return m.routeListMoreDataMsg(msg)
	}
	return nil
}

func (m *Model) routeListMoreDataMsg(msg tea.Msg) []tea.Cmd {
	switch msg := msg.(type) {
	case gpuNodesLoadedMsg:
		m.handleGpuNodesLoaded(msg.Items, msg.Gen)
	case dedicatedAIClustersLoadedMsg:
		m.handleDedicatedAIClustersLoaded(msg.Items, msg.Gen)
	case tenancyOverridesLoadedMsg:
		m.handleTenancyOverridesLoaded(msg.Group, msg.Gen)
	case limitRegionalOverridesLoadedMsg:
		m.handleLimitRegionalOverridesLoaded(msg.Items, msg.Gen)
	case consolePropertyRegionalOverridesLoadedMsg:
		m.handleConsolePropertyRegionalOverridesLoaded(msg.Items, msg.Gen)
	case propertyRegionalOverridesLoadedMsg:
		m.handlePropertyRegionalOverridesLoaded(msg.Items, msg.Gen)
	default:
		// Future-proof: ignore unknown message types
	}
	return nil
}

func (m *Model) handleKeyMsg(msg tea.KeyMsg) []tea.Cmd {
	var cmds []tea.Cmd
	if key.Matches(msg, keys.Back) {
		cmd := m.backToLastState()
		if cmd != nil {
			cmds = append(cmds, cmd)
		}
	}
	if m.inputMode == common.NormalInput {
		cmds = append(cmds, m.handleNormalKeys(msg)...)
	} else {
		cmds = append(cmds, m.handleEditKeys(msg)...)
	}
	return cmds
}

func (m *Model) handleSetFilterMsg(msg SetFilterMsg) tea.Cmd {
	val := string(msg)
	m.textInput.SetValue(val)
	normalized := strings.ToLower(val)
	// Invalidate any pending debounce tick that may be in-flight.
	m.filterNonce++
	return func() tea.Msg {
		return FilterMsg(normalized)
	}
}

func (m *Model) handleFilterApplyMsg(msg FilterApplyMsg) tea.Cmd {
	// Only apply if this tick corresponds to the most recent debounce
	if msg.Nonce == m.filterNonce {
		return filterTableAsync(m, msg.Value)
	}
	return nil
}

func (m *Model) handleNormalKeys(msg tea.KeyMsg) []tea.Cmd {
	var cmds []tea.Cmd

	// Dispatch table for key handlers
	keyHandlers := []struct {
		match  key.Binding
		action func() []tea.Cmd
	}{
		{keys.Quit, func() []tea.Cmd { return []tea.Cmd{func() tea.Msg { m.cancelInFlight(); return tea.QuitMsg{} }} }},
		{keys.BackHist, func() []tea.Cmd { return []tea.Cmd{m.moveHistory(-1)} }},
		{keys.FwdHist, func() []tea.Cmd { return []tea.Cmd{m.moveHistory(1)} }},
		{keys.NextCategory, func() []tea.Cmd { return []tea.Cmd{m.handleNextCategory()} }},
		{keys.PrevCategory, func() []tea.Cmd { return []tea.Cmd{m.handlePrevCategory()} }},
		{keys.FilterMode, func() []tea.Cmd { return []tea.Cmd{m.enterEditMode(common.FilterTarget)} }},
		{keys.PasteFilter, func() []tea.Cmd { return []tea.Cmd{m.pasteFilter()} }},
		{keys.CommandMode, func() []tea.Cmd { return []tea.Cmd{m.enterEditMode(common.AliasTarget)} }},
		{keys.ViewDetails, func() []tea.Cmd { return []tea.Cmd{m.enterDetailView()} }},
		{keys.C

func (m *Model) deleteItem(itemKey models.ItemKey) tea.Cmd {
	switch m.category {
	case domain.DedicatedAICluster:
		return m.deleteDedicatedAICluster(itemKey)
	case domain.GpuNode:
		return m.deleteGpuNode(itemKey)
	default:
		// exhausive
	}
	return nil
}

func (m *Model) deleteDedicatedAICluster(itemKey models.ItemKey) tea.Cmd {
	item := findItem(m.dataset, m.category, itemKey)
	dac, ok := item.(*models.DedicatedAICluster)
	if !ok || dac == nil {
		m.logger.Errorw("item not found for delete operation", "category", m.category, "key", itemKey)
		return nil
	}
	if dac.Status == "Deleting" {
		return nil
	}
	prevState := dac.Status
	dac.Status = "Deleting"
	m.updateRows(false)
	return func() tea.Msg {
		ctx, cancel := m.opContext()
		defer cancel()
		if err := actions.DeleteDedicatedAICluster(ctx, dac, m.environment, m.logger); err != nil {
			return deleteErrMsg{
				err:       err,
				category:  domain.DedicatedAICluster,
				key:       itemKey,
				prevState: prevState,
			}
		}
		return deleteDoneMsg{
			category: domain.DedicatedAICluster,
			key:      itemKey,
		}
	}
}

func (m *Model) deleteGpuNode(itemKey models.ItemKey) tea.Cmd {
	item := findItem(m.dataset, m.category, itemKey)
	node, ok := item.(*models.GpuNode)
	if !ok || node == nil {
		m.logger.Errorw("item not found for delete operation", "category", m.category, "key", itemKey)
		return nil
	}
	if node.GetStatus() == "Deleting" {
		return nil
	}
	node.SetStatus("Deleting")
	m.updateRows(false)
	return func() tea.Msg {
		ctx, cancel := m.opContext()
		defer cancel()
		if err := actions.TerminateInstance(ctx, node, m.environment, m.logger); err != nil {
			return deleteErrMsg{
				err:      err,
				category: domain.GpuNode,
				key:      itemKey,
			}
		}
		return deleteDoneMsg{
			category: domain.GpuNode,
			key:      itemKey,
		}
	}
}

func (m *Model) rebootNode(item any) tea.Cmd {
	if item == nil {
		m.logger.Errorw("no item selected for reboot operation", "category", m.category)
		return nil
	}

	node, ok := item.(*models.GpuNode)
	if !ok {
		m.logger.Errorw("unsupported item type for reboot operation", "item", item)
		return nil
	}

	if node.GetStatus() == "Rebooting" {
		return nil
	}
	itemKey := getItemKey(m.category, m.table.SelectedRow())
	// optimistic UI
	node.SetStatus("Rebooting")
	m.updateRows(false)

	return func() tea.Msg {
		ctx, cancel := m.opContext()
		defer cancel()
		err := actions.SoftResetInstance(ctx, node, m.environment, m.logger)
		return rebootNodeResultMsg{key: itemKey, err: err}
	}
}

func (m *Model) handleDeleteErrMsg(msg deleteErrMsg) {
	m.logger.Errorw("failed to delete item", "key", msg.key, "error", msg.err)
	item := findItem(m.dataset, msg.category, msg.key)

	if dac, ok := item.(*models.DedicatedAICluster); ok {
		dac.Status = msg.prevState
	} else if node, ok := item.(*models.GpuNode); ok {
		node.SetStatus(msg.prevState)
	}

	// update view if current
	if msg.category == m.category {
		m.updateRows(false)
	}
}

func (m *Model) handleDeleteDoneMsg(msg deleteDoneMsg) {
	deleteItem(m.dataset, msg.category, msg.key)

	// update view if current
	if msg.category == m.category {
		idx := m.table.Cursor()
		if idx+1 >= len(m.table.Rows()) {
			m.table.MoveUp(1)
		}
		m.updateRows(false)
	}
}

func (m *Model) handleUpdateDoneMsg(msg updateDoneMsg) {
	if msg.err != nil {
		m.logger.Errorw("failed to update data", "category", msg.category, "error", msg.err)
		for i := range m.dataset.GpuPools {
			m.dataset.GpuPools[i].Status = "UNKNOWN"
		}
	}

	// update view if current
	if msg.category == m.category {
		m.updateRows(false)
	}
}

func (m *Model) handleGpuPoolScaleStartedMsg(msg gpuPoolScaleStartedMsg) {
	item := findItem(m.dataset, domain.GpuPool, msg.key)
	if pool, ok := item.(*models.GpuPool); ok && pool != nil {
		pool.Status = "SCALING"
		if m.category == domain.GpuPool {
			m.updateRows(false)
		}
	}
}

func (m *Model) handleGpuPoolScaleResultMsg(msg gpuPoolScaleResultMsg) {
	item := findItem(m.dataset, domain.GpuPool, msg.key)
	if pool, ok := item.(*models.GpuPool); ok && pool != nil {
		if msg.err != nil {
			m.logger.Errorw("failed to scale GPU pool", "key", msg.key, "error", msg.err)
			pool.Status = "FAILED"
		} else {
			// Optimistic success state until enrichment updates the pool
			pool.Status = "RUNNING"
		}
		if m.category == domain.GpuPool {
			m.updateRows(false)
		}
	}
}

func (m *Model) handleCordonNodeResultMsg(msg cordonNodeResultMsg) {
	item := findItem(m.dataset, domain.GpuNode, msg.key)
	if node, ok := item.(*models.GpuNode); ok && node != nil {
		if msg.err != nil {
			m.logger.Errorw("failed to toggle cordon state", "key", msg.key, "error", msg.err)
		} else {
			node.IsSchedulingDisabled = msg.state
			// Clear transient status so GetStatus reflects current state
			node.SetStatus("")
		}
		if m.category == domain.GpuNode {
			m.updateRows(false)
		}
	}
}

func (m *Model) handleDrainNodeResultMsg(msg drainNodeResultMsg) {
	if msg.err != nil {
		m.logger.Errorw("failed to drain node", "key", msg.key, "error", msg.err)
	}
	if m.category == domain.GpuNode {
		m.updateRows(false)
	}
}

func (m *Model) handleRebootNodeResultMsg(msg rebootNodeResultMsg) {
	item := findItem(m.dataset, domain.GpuNode, msg.key)
	if node, ok := item.(*models.GpuNode); ok && node != nil {
		if msg.err != nil {
			m.logger.Errorw("failed to reboot node", "key", msg.key, "error", msg.err)
			node.SetStatus("FAILED")
		} else {
			// Clear transient "Rebooting" status to recompute via GetStatus()
			node.SetStatus("")
		}
	}
	if m.category == domain.GpuNode {
		m.updateRows(false)
	}
}

func (m *Model) toggleAliases() []tea.Cmd {
	if m.category == domain.Alias {
		return []tea.Cmd{m.moveHistory(-1)}
	}
	return m.updateCategory(domain.Alias)
}

func (m *Model) enterExportView() []tea.Cmd {
	m.lastViewMode = m.viewMode
	m.viewMode = common.ExportView

	var cmd tea.Cmd
	if m.dirPicker.Path != "" {
		cmd = func() tea.Msg {
			return tea.KeyMsg{Type: tea.KeyType(tea.KeyBackspace)}
		}
	} else {
		cmd = m.dirPicker.Init()
	}
	return []tea.Cmd{cmd}
}

func (*Model) pasteFilter() tea.Cmd {
	return func() tea.Msg {
		clip, err := clipboard.ReadAll()
		if err != nil {
			return nil
		}
		clip = strings.TrimSpace(clip)
		if clip == "" {
			return nil
		}
		return SetFilterMsg(clip)
	}
}