chore: release v0.27.0

A new tab, a new file format carried over from another program, and a ClubLog
integration are a minor version, not a patch.

app.go

@@ -44,7 +44,6 @@ import (
 	"hamlog/internal/gridcache"
 	"hamlog/internal/integrations/udp"
 	"hamlog/internal/kpa"
-	"hamlog/internal/labels"
 	"hamlog/internal/lookup"
 	"hamlog/internal/lotwusers"
 	"hamlog/internal/netctl"
@@ -75,6 +74,7 @@ import (
 	"hamlog/internal/tunergenius"
 	"hamlog/internal/uls"
 	"hamlog/internal/ultrabeam"
+	"hamlog/internal/watchlist"
 	"hamlog/internal/winkeyer"
 
 	wruntime "github.com/wailsapp/wails/v2/pkg/runtime"
@@ -96,12 +96,13 @@ const (
 	keyLookupFailsafe = "lookup.failsafe"
 	keyLookupImages   = "lookup.download_images" // 1 = expose QRZ ImageURL to UI
 
-	keyStationCallsign = "station.callsign"
-	keyStationOperator = "station.operator"
-	keyStationMyGrid   = "station.my_grid"
-	keyStationCountry  = "station.my_country"
-	keyStationSOTA     = "station.my_sota_ref"
-	keyStationPOTA     = "station.my_pota_ref"
+	keyStationCallsign         = "station.callsign"
+	keyStationOperator         = "station.operator"
+	keyWatchlistContestPattern = "watchlist.contest_pattern" // auto-add contest calls containing this
+	keyStationMyGrid           = "station.my_grid"
+	keyStationCountry          = "station.my_country"
+	keyStationSOTA             = "station.my_sota_ref"
+	keyStationPOTA             = "station.my_pota_ref"
 
 	keyListsBands      = "lists.bands"
 	keyListsModes      = "lists.modes"
@@ -736,7 +737,10 @@ type App struct {
 	uls          *uls.Store // US callsign→county/grid (offline FCC ULS), lazily opened
 	awardRefs    *awardref.Repo
 	qslTemplates *qslcard.Repo
-	labelRepo    *labels.Repo // label designer (stocks + templates)
+	watchlist    *watchlist.Store     // Tools → Watchlist (global watchlist.json)
+	watchAlertMu sync.Mutex           // throttles watchlist alerts…
+	watchAlertAt map[string]time.Time // …per entry
+	watchPattern atomic.Value         // auto-contest pattern (string), loaded at startup
 	operating    *operating.Repo
 	udp          *udp.Manager
 	udpRepo      *udp.Repo
@@ -1017,6 +1021,13 @@ func (a *App) startup(ctx context.Context) {
 		return
 	}
 	a.dataDir = dataDir
+	// The watchlist needs nothing but its file, so it opens FIRST. It used to be
+	// created after the logbook connect, and a remote MySQL dial of 10-30 s left
+	// the tab saying "Watchlist: 0" until the next refresh tick — twenty seconds
+	// of an empty list for a JSON file that reads in a millisecond. (The
+	// auto-contest pattern still loads later, once the settings store is open.)
+	a.watchlist = watchlist.New(filepath.Join(dataDir, "watchlist.json"))
+	a.watchAlertAt = map[string]time.Time{}
 	// Settings/config database (settings + profiles). Fresh installs use
 	// settings.db; existing installs keep their opslog.db (which also held the
 	// QSOs before they were split into a dedicated logbook file — see below).
@@ -1187,7 +1198,6 @@ func (a *App) startup(ctx context.Context) {
 	}
 	a.awardRefs = awardref.NewRepo(conn)
 	a.qslTemplates = qslcard.NewRepo(conn)
-	a.labelRepo = labels.NewRepo(conn)
 	a.migrateAwardDefs()      // upgrade legacy award definitions (enable + new fields)
 	a.seedBuiltinReferences() // first-run: populate built-in award reference lists
 	a.mirrorAwards()          // keep <data>/awards/*.json in step with the database
@@ -1388,6 +1398,8 @@ func (a *App) startup(ctx context.Context) {
 	// POTA: background poller of api.pota.app so cluster spots can be tagged
 	// when the DX station is currently activating a park. Best-effort.
 	a.pota = pota.New(func(format string, args ...any) { applog.Printf(format, args...) })
+	a.startWatchlistClubLog()
+	a.watchPattern.Store(strings.ToUpper(strings.TrimSpace(a.settingOr(keyWatchlistContestPattern, ""))))
 	go a.pota.Run(a.ctx)
 
 	// DX Cluster (multi-server): the spot callback enriches each spot
@@ -1799,6 +1811,9 @@ func (a *App) setSettingGlobal(key, val string) {
 }
 
 func (a *App) shutdown(ctx context.Context) {
+	if a.watchlist != nil {
+		a.watchlist.Flush() // the save debounce would lose the last edits
+	}
 	// If the user managed to skip beforeClose (force kill, OS shutdown,
 	// crash recovery) we still try the backup here as a best-effort
 	// safety net. HasBackupToday makes a double-run a no-op.
@@ -6941,6 +6956,28 @@ func (a *App) BulkUpdateField(ids []int64, field, value string) (int64, error) {
 	if field == "freq" {
 		return a.bulkSetFrequency(ids, value)
 	}
+	// The station-side numbers. Bounded so a slip cannot stamp CQ zone 400 on a
+	// thousand rows: DXCC entities stop short of 1000, CQ zones at 40, ITU at 90.
+	// Empty clears (NULL).
+	if field == "my_dxcc" || field == "my_cq_zone" || field == "my_itu_zone" {
+		var vp *int
+		if t := strings.TrimSpace(value); t != "" {
+			v, err := strconv.Atoi(t)
+			max := map[string]int{"my_dxcc": 999, "my_cq_zone": 40, "my_itu_zone": 90}[field]
+			if err != nil || v < 1 || v > max {
+				return 0, fmt.Errorf("%s must be a number between 1 and %d (empty to clear)", field, max)
+			}
+			vp = &v
+		}
+		n, err := a.qso.BulkSetIntField(a.ctx, ids, field, vp)
+		if err != nil {
+			return 0, err
+		}
+		if n > 0 {
+			a.invalidateAwardStats()
+		}
+		return n, nil
+	}
 	// Some ADIF fields have no promoted column and live in extras_json
 	// (OWNER_CALLSIGN) — those take the JSON path so the rest of the extras on
 	// each QSO survive the edit.
@@ -8984,6 +9021,10 @@ func (a *App) clusterEventWorker() {
 		a.detectBandOpening(s)
 		// Fire any matching alert rules (sound / visual / e-mail).
 		a.evaluateAlerts(s)
+		// The watchlist sees the same live stream the alerts do — never the
+		// SH/DX replay above, which would mark forty stations "just seen" with
+		// spots from three hours ago.
+		a.watchSpot(s.DXCall, s.Band, alerts.InferMode(s.Comment, s.FreqHz), s.Country, s.Comment, s.FreqHz)
 		// Mirror the spot onto the FlexRadio panadapter when enabled. Infer the
 		// mode (from the comment, else the band plan) so clicking the spot on the
 		// panadapter tunes AND switches mode — a DX cluster line carries no mode,
@@ -19685,10 +19726,11 @@ type SpotStatus struct {
 // that already holds the pointer keeps reading valid (stale-by-one-log) data
 // while a newer snapshot is being built. See clusterStatusMaps.
 type clusterStatusCache struct {
-	entities        map[int]*qso.EntitySlot
-	workedCalls     map[string]struct{}
-	workedCallSlots map[string]struct{} // nil unless the "same slot" option is on
-	workedCounties  map[string]struct{}
+	entities           map[int]*qso.EntitySlot
+	workedCalls        map[string]struct{}
+	workedCallSlots    map[string]struct{}
+	workedCallSlotsDig map[string]struct{} // same set, digital modes folded to DIG // nil unless the "same slot" option is on
+	workedCounties     map[string]struct{}
 	// callCounties holds callsign → "STATE,County" for stations already logged
 	// with a county, so a spot shows the county the entry panel showed rather
 	// than the one derived from the licence ZIP. See qso.CallCounties.
@@ -19771,8 +19813,18 @@ func (a *App) clusterStatusMaps() *clusterStatusCache {
 	// "Already worked only on the same slot" option (Settings → DX Cluster): the
 	// WORKED-call flag then needs the SAME band and mode (digital-grouped through
 	// the same normMode when that option is on) rather than the call anywhere.
-	if sameSlot || slotHighlight {
-		c.workedCallSlots, _ = a.qso.WorkedCallSlotKeys(a.ctx, c.normMode)
+	// Built UNCONDITIONALLY since the watchlist arrived: its per-slot verdict
+	// needs this set whatever the cluster's own display options say, and the
+	// scan already runs at cache-rebuild cadence, not per batch.
+	c.workedCallSlots, _ = a.qso.WorkedCallSlotKeys(a.ctx, c.normMode)
+	// And once more at digital-CLASS grain, for the spots whose mode the band
+	// plan can only call "DATA": a generic mode cannot be matched exactly, so it
+	// is judged against "any digital mode of this call on this band". When the
+	// grouping option is on, workedCallSlots is already at that grain.
+	if c.normMode != nil {
+		c.workedCallSlotsDig = c.workedCallSlots
+	} else {
+		c.workedCallSlotsDig, _ = a.qso.WorkedCallSlotKeys(a.ctx, qso.GroupDigitalMode)
 	}
 	// Orthogonal dimensions: worked US counties (for the ULS callsign→county
 	// lookup) and worked POTA parks.

app_k3.go

@@ -24,6 +24,17 @@ func (a *App) GetKenwoodState() cat.KenwoodTXState {
 	return st
 }
 
+// SetKenwoodPanelMode sets the operating mode from the panel's mode row —
+// CW / USB / LSB / DATA (soundcard, DT0) / RTTY (FSK D, DT2).
+func (a *App) SetKenwoodPanelMode(mode string) error {
+	return a.kenwoodPanelDo(func(k cat.KenwoodPanelController) error { return k.SetKenwoodPanelMode(mode) })
+}
+
+// SetKenwoodRITOffset sets the RIT/XIT offset to an absolute value in Hz.
+func (a *App) SetKenwoodRITOffset(hz int) error {
+	return a.kenwoodPanelDo(func(k cat.KenwoodPanelController) error { return k.SetKenwoodRITOffset(hz) })
+}
+
 func (a *App) SetKenwoodPower(w int) error {
 	return a.kenwoodPanelDo(func(k cat.KenwoodPanelController) error { return k.SetKenwoodPower(w) })
 }

app_labels.go

@@ -1,208 +0,0 @@
-package main
-
-// Label designer — the Wails boundary for internal/labels.
-//
-// The designer edits two things: STOCKS (the physical roll in the printer,
-// geometry in mm) and TEMPLATES (one design per label kind: the QSO label glued
-// on a card, the address label for the envelope). Printing — a later module —
-// will ask for the default template of each kind and hand the rasterised pages
-// to a PDF; nothing here prints.
-
-import (
-	"fmt"
-	"strings"
-
-	"hamlog/internal/applog"
-	"hamlog/internal/labels"
-	"hamlog/internal/qso"
-)
-
-// LabelTemplateInfo is one row of the designer's template list.
-type LabelTemplateInfo struct {
-	ID        int64  `json:"id"`
-	Name      string `json:"name"`
-	Kind      string `json:"kind"`
-	StockID   int64  `json:"stock_id"`
-	ProfileID *int64 `json:"profile_id,omitempty"`
-	IsDefault bool   `json:"is_default"`
-	UpdatedAt string `json:"updated_at"`
-}
-
-// LabelListStocks returns every label stock, seeding the builtin Brother rolls
-// on first use.
-func (a *App) LabelListStocks() ([]labels.Stock, error) {
-	if a.labelRepo == nil {
-		return nil, fmt.Errorf("db not initialized")
-	}
-	if err := a.labelRepo.SeedStocks(a.ctx); err != nil {
-		applog.Printf("labels: seeding stocks failed: %v", err)
-	}
-	return a.labelRepo.Stocks(a.ctx)
-}
-
-// LabelSaveStock creates or updates one stock and returns its id.
-func (a *App) LabelSaveStock(s labels.Stock) (int64, error) {
-	if a.labelRepo == nil {
-		return 0, fmt.Errorf("db not initialized")
-	}
-	if err := a.labelRepo.SaveStock(a.ctx, &s); err != nil {
-		return 0, err
-	}
-	return s.ID, nil
-}
-
-// LabelDeleteStock removes a stock; designs pointing at it keep their content.
-func (a *App) LabelDeleteStock(id int64) error {
-	if a.labelRepo == nil {
-		return fmt.Errorf("db not initialized")
-	}
-	return a.labelRepo.DeleteStock(a.ctx, id)
-}
-
-// LabelListTemplates lists the designs visible to the active profile.
-func (a *App) LabelListTemplates() ([]LabelTemplateInfo, error) {
-	if a.labelRepo == nil {
-		return nil, fmt.Errorf("db not initialized")
-	}
-	var recs []labels.Record
-	var err error
-	if p, e := a.profiles.Active(a.ctx); e == nil {
-		recs, err = a.labelRepo.ListFor(a.ctx, p.ID)
-	} else {
-		recs, err = a.labelRepo.List(a.ctx)
-	}
-	if err != nil {
-		return nil, err
-	}
-	out := make([]LabelTemplateInfo, 0, len(recs))
-	for _, r := range recs {
-		info := LabelTemplateInfo{
-			ID: r.ID, Name: r.Name, Kind: r.Kind, ProfileID: r.ProfileID,
-			IsDefault: r.IsDefault, UpdatedAt: r.UpdatedAt.Format("2006-01-02 15:04"),
-		}
-		if r.StockID != nil {
-			info.StockID = *r.StockID
-		}
-		out = append(out, info)
-	}
-	return out, nil
-}
-
-// LabelGetTemplate returns one stored design document (JSON).
-func (a *App) LabelGetTemplate(id int64) (string, error) {
-	if a.labelRepo == nil {
-		return "", fmt.Errorf("db not initialized")
-	}
-	rec, err := a.labelRepo.Get(a.ctx, id)
-	if err != nil {
-		return "", err
-	}
-	return rec.JSON, nil
-}
-
-// LabelSaveTemplate validates and stores a design; id 0 creates. Returns the id.
-func (a *App) LabelSaveTemplate(id int64, name string, doc string, forActiveProfile bool) (int64, error) {
-	if a.labelRepo == nil {
-		return 0, fmt.Errorf("db not initialized")
-	}
-	name = strings.TrimSpace(name)
-	if name == "" {
-		return 0, fmt.Errorf("template name required")
-	}
-	t, err := labels.Parse([]byte(doc))
-	if err != nil {
-		return 0, err
-	}
-	if err := labels.Validate(t); err != nil {
-		return 0, err
-	}
-	rec := labels.Record{ID: id, Name: name, Kind: t.Kind, JSON: doc}
-	if t.StockID != 0 {
-		sid := t.StockID
-		rec.StockID = &sid
-	}
-	if forActiveProfile {
-		if p, err := a.profiles.Active(a.ctx); err == nil {
-			rec.ProfileID = &p.ID
-		}
-	}
-	if err := a.labelRepo.Save(a.ctx, &rec); err != nil {
-		return 0, err
-	}
-	applog.Printf("labels: template %q (%s) saved (id %d)", name, t.Kind, rec.ID)
-	return rec.ID, nil
-}
-
-// LabelDeleteTemplate removes a design.
-func (a *App) LabelDeleteTemplate(id int64) error {
-	if a.labelRepo == nil {
-		return fmt.Errorf("db not initialized")
-	}
-	return a.labelRepo.Delete(a.ctx, id)
-}
-
-// LabelSetDefaultTemplate marks a design as the default for its kind.
-func (a *App) LabelSetDefaultTemplate(id int64) error {
-	if a.labelRepo == nil {
-		return fmt.Errorf("db not initialized")
-	}
-	return a.labelRepo.SetDefault(a.ctx, id)
-}
-
-// LabelSampleQSO is one row of preview data for the designer's QSO table.
-type LabelSampleQSO struct {
-	Callsign string `json:"callsign"`
-	QSODate  string `json:"qso_date"` // YYYY-MM-DD
-	TimeOn   string `json:"time_on"`  // HH:MM
-	Band     string `json:"band"`
-	FreqMHz  string `json:"freq"`
-	Mode     string `json:"mode"`
-	RSTSent  string `json:"rst_sent"`
-	RSTRcvd  string `json:"rst_rcvd"`
-	Name     string `json:"name"`
-	QTH      string `json:"qth"`
-	Country  string `json:"country"`
-}
-
-// LabelSampleQSOs returns the last few real contacts for the designer's live
-// preview — real data shows a too-narrow column immediately ("14074.0" does not
-// fit where "7.1" did). Falls back to plausible fakes on an empty log; the
-// preview must never be blank.
-func (a *App) LabelSampleQSOs(limit int) []LabelSampleQSO {
-	if limit <= 0 || limit > 20 {
-		limit = 4
-	}
-	fake := []LabelSampleQSO{
-		{Callsign: "DL1ABC", QSODate: "2026-08-01", TimeOn: "14:32", Band: "20m", FreqMHz: "14.074", Mode: "FT8", RSTSent: "-08", RSTRcvd: "-12", Name: "Hans", QTH: "Berlin", Country: "Germany"},
-		{Callsign: "VK3XYZ", QSODate: "2026-08-02", TimeOn: "09:15", Band: "15m", FreqMHz: "21.245", Mode: "SSB", RSTSent: "59", RSTRcvd: "57", Name: "Bruce", QTH: "Melbourne", Country: "Australia"},
-		{Callsign: "JA1TOK", QSODate: "2026-08-03", TimeOn: "21:47", Band: "40m", FreqMHz: "7.012", Mode: "CW", RSTSent: "599", RSTRcvd: "579", Name: "Ken", QTH: "Tokyo", Country: "Japan"},
-		{Callsign: "W1AW", QSODate: "2026-08-04", TimeOn: "18:03", Band: "10m", FreqMHz: "28.480", Mode: "SSB", RSTSent: "59", RSTRcvd: "59", Name: "Hiram", QTH: "Newington", Country: "United States"},
-	}
-	if a.qso == nil {
-		return fake[:min(limit, len(fake))]
-	}
-	rows, err := a.qso.List(a.ctx, qso.ListFilter{Limit: limit})
-	if err != nil || len(rows) == 0 {
-		return fake[:min(limit, len(fake))]
-	}
-	out := make([]LabelSampleQSO, 0, len(rows))
-	for _, q := range rows {
-		s := LabelSampleQSO{
-			Callsign: q.Callsign,
-			QSODate:  q.QSODate.UTC().Format("2006-01-02"),
-			TimeOn:   q.QSODate.UTC().Format("15:04"),
-			Band:     q.Band,
-			Mode:     q.Mode,
-			RSTSent:  q.RSTSent,
-			RSTRcvd:  q.RSTRcvd,
-			Name:     q.Name,
-			QTH:      q.QTH,
-			Country:  q.Country,
-		}
-		if q.FreqHz != nil && *q.FreqHz > 0 {
-			s.FreqMHz = fmt.Sprintf("%.3f", float64(*q.FreqHz)/1e6)
-		}
-		out = append(out, s)
-	}
-	return out
-}

app_labels_print.go

@@ -1,90 +0,0 @@
-package main
-
-// The label PRINT path: pick the paper-QSL queue, review each address, choose
-// the routing, and export PDFs whose pages are the exact label size — one PDF
-// per label kind, because a roll printer holds one stock at a time and a file
-// mixing 29 mm addresses with 62 mm QSO labels could not be printed at all.
-//
-// The pages arrive from the frontend already rasterised: the designer's canvas
-// renderer draws them at the stock's dpi, so what was previewed is — pixel for
-// pixel — what lands in the PDF. Go only carries them to disk.
-
-import (
-	"encoding/base64"
-	"fmt"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"strings"
-	"time"
-
-	"hamlog/internal/applog"
-	"hamlog/internal/pdf"
-	"hamlog/internal/qso"
-)
-
-// LabelPaperQueue returns the contacts whose paper QSL is REQUESTED or QUEUED
-// (ADIF qsl_sent R/Q) — the natural worklist for a labelling session. The
-// frontend groups them by callsign.
-func (a *App) LabelPaperQueue() ([]qso.QSO, error) {
-	if a.qso == nil {
-		return nil, fmt.Errorf("db not initialized")
-	}
-	return a.qso.List(a.ctx, qso.ListFilter{
-		QSLSentIn: []string{"R", "Q"},
-		Limit:     10_000,
-	})
-}
-
-// LabelPDFPage is one page of the session's output: a rasterised label and its
-// physical size. Sizes vary WITHIN one document — the operator asked for a
-// single PDF holding QSO labels, addresses and return labels together, and PDF
-// pages each carry their own MediaBox, so a 90×29 page can follow a 100×62 one.
-type LabelPDFPage struct {
-	PNG string  `json:"png"` // base64, data-URL prefix tolerated
-	WMm float64 `json:"w_mm"`
-	HMm float64 `json:"h_mm"`
-}
-
-// LabelOpenPDF writes the session's labels to ONE temporary PDF and opens it in
-// the system viewer, from which the operator prints. No save dialog by choice:
-// the file is a print run, not a document to keep — anyone who wants to keep it
-// saves from the viewer.
-func (a *App) LabelOpenPDF(pages []LabelPDFPage) (string, error) {
-	if len(pages) == 0 {
-		return "", fmt.Errorf("nothing to print")
-	}
-	var doc pdf.Doc
-	for i, pg := range pages {
-		if pg.WMm < 5 || pg.HMm < 5 || pg.WMm > 400 || pg.HMm > 400 {
-			return "", fmt.Errorf("page %d: label size out of range", i+1)
-		}
-		p := pg.PNG
-		if idx := strings.Index(p, ","); idx >= 0 && strings.Contains(p[:idx], "base64") {
-			p = p[idx+1:]
-		}
-		raw, err := base64.StdEncoding.DecodeString(p)
-		if err != nil {
-			return "", fmt.Errorf("page %d: %w", i+1, err)
-		}
-		if err := doc.AddImagePage(raw, pg.WMm, pg.HMm); err != nil {
-			return "", fmt.Errorf("page %d: %w", i+1, err)
-		}
-	}
-	out, err := doc.Bytes()
-	if err != nil {
-		return "", err
-	}
-	// A timestamped name in the temp dir: two sessions in one evening must not
-	// fight over the file, least of all while a viewer holds the first one open.
-	path := filepath.Join(os.TempDir(), fmt.Sprintf("opslog-labels-%s.pdf", time.Now().Format("20060102-150405")))
-	if err := os.WriteFile(path, out, 0o644); err != nil {
-		return "", err
-	}
-	applog.Printf("labels: wrote %d page(s) to %s", len(pages), path)
-	if err := exec.Command("rundll32", "url.dll,FileProtocolHandler", path).Start(); err != nil {
-		applog.Printf("labels: could not open the PDF viewer: %v", err)
-		return "", fmt.Errorf("the PDF was written to %s but no viewer opened: %w", path, err)
-	}
-	return path, nil
-}

app_watchlist.go

@@ -0,0 +1,293 @@
+package main
+
+// Watchlist bindings — the DXHunter watchlist concept as an OpsLog tab.
+// The store lives in internal/watchlist (global watchlist.json, DXHunter's own
+// schema); this file is the Wails boundary plus the two places the list meets
+// the rest of the app: the spot stream (MarkSeen + alert) and the logbook (the
+// worked-today answer contest entries are judged by).
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"strings"
+	"time"
+
+	"hamlog/internal/applog"
+	"hamlog/internal/qso"
+	"hamlog/internal/watchlist"
+
+	wruntime "github.com/wailsapp/wails/v2/pkg/runtime"
+)
+
+// The auto-contest pattern, DXHunter's contest_prefix: while non-empty, any
+// spotted callsign CONTAINING it is added to the watchlist as a contest entry
+// by itself — a special-event fleet (HB9WWA, DL0WWA, F4WWA…) is collected as
+// it appears instead of typed in one by one. Held in an atomic so the spot
+// pipeline never touches the settings store per spot.
+func (a *App) GetWatchlistContestPattern() string {
+	if v := a.watchPattern.Load(); v != nil {
+		return v.(string)
+	}
+	return ""
+}
+
+// SetWatchlistContestPattern stores the pattern (global, like the list itself).
+// Emptying it stops the auto-add; entries already collected stay — deleting an
+// operator's list because a setting changed is DXHunter behaviour this port
+// deliberately drops.
+func (a *App) SetWatchlistContestPattern(p string) {
+	p = strings.ToUpper(strings.TrimSpace(p))
+	a.watchPattern.Store(p)
+	a.setSettingGlobal(keyWatchlistContestPattern, p)
+}
+
+// WatchlistEntries returns the list for the tab.
+func (a *App) WatchlistEntries() []watchlist.Entry {
+	if a.watchlist == nil {
+		return nil
+	}
+	return a.watchlist.Entries()
+}
+
+// WatchlistAdd adds a callsign or prefix; contest entries are judged per UTC day.
+func (a *App) WatchlistAdd(callsign string, contest bool) error {
+	if a.watchlist == nil {
+		return fmt.Errorf("watchlist not initialized")
+	}
+	return a.watchlist.Add(callsign, contest)
+}
+
+// WatchlistRemove deletes an entry.
+func (a *App) WatchlistRemove(callsign string) error {
+	if a.watchlist == nil {
+		return fmt.Errorf("watchlist not initialized")
+	}
+	return a.watchlist.Remove(callsign)
+}
+
+// WatchlistSetNotify arms the existing alert path (sound + toast) for an entry.
+func (a *App) WatchlistSetNotify(callsign string, on bool) error {
+	if a.watchlist == nil {
+		return fmt.Errorf("watchlist not initialized")
+	}
+	return a.watchlist.SetNotify(callsign, on)
+}
+
+// WatchlistSetContest flips the per-entry contest rule.
+func (a *App) WatchlistSetContest(callsign string, on bool) error {
+	if a.watchlist == nil {
+		return fmt.Errorf("watchlist not initialized")
+	}
+	return a.watchlist.SetContest(callsign, on)
+}
+
+// WatchlistSlotQuery asks whether one spot's slot is worked — against the whole
+// log for a normal entry, against TODAY (UTC) for a contest one.
+type WatchlistSlotQuery struct {
+	Call    string `json:"call"`
+	Band    string `json:"band"`
+	Mode    string `json:"mode"`
+	Contest bool   `json:"contest"`
+}
+
+// WatchlistWorkedSlots answers a batch of slot questions for the tab.
+//
+// Normal entries read the CLUSTER's own slot set — the same cached
+// WorkedCallSlotKeys index that colours the grid — so the watchlist can never
+// contradict the cluster about the same spot. That index normalises the mode
+// exactly as the operator configured (digital grouping on → FT4 counts as FT8's
+// class; off → exact mode), and the first version of this ignored that: it
+// asked the alerts' raw-mode index with a CLASS name, matched nothing, and
+// showed a fully-worked DXpedition as all Needed.
+//
+// Contest entries read TODAY's contacts instead — the midnight-UTC reset is
+// the query's date bound, nothing stored, nothing to reset — normalised through
+// the same function so the two answers use one grammar.
+func (a *App) WatchlistWorkedSlots(queries []WatchlistSlotQuery) []bool {
+	out := make([]bool, len(queries))
+	if a.qso == nil || len(queries) == 0 {
+		return out
+	}
+	idx := a.clusterStatusMaps()
+	norm := func(m string) string {
+		m = strings.ToUpper(strings.TrimSpace(m))
+		if idx.normMode != nil {
+			m = idx.normMode(m)
+		}
+		return m
+	}
+	slotKey := func(call, band, mode string) string {
+		up := strings.ToUpper(strings.TrimSpace(call))
+		b := strings.ToLower(strings.TrimSpace(band))
+		if m := norm(mode); m != "" {
+			return up + "|" + b + "|" + m
+		}
+		return up + "|" + b
+	}
+	// A spot whose mode the band plan could only call "DATA" (an F/H DXpedition
+	// off the standard dials, a comment with no mode) cannot be matched exactly:
+	// "DATA" is in nobody's log. Such a spot is judged at digital-CLASS grain —
+	// worked if ANY digital mode of that call is logged on that band. Claiming
+	// NEW MODE because the label differs from FT8 was the reported bug.
+	generic := func(m string) bool {
+		switch strings.ToUpper(strings.TrimSpace(m)) {
+		case "", "DATA", "DIG", "DIGI", "DIGITAL":
+			return true
+		}
+		return false
+	}
+	digKey := func(call, band string) string {
+		return strings.ToUpper(strings.TrimSpace(call)) + "|" + strings.ToLower(strings.TrimSpace(band)) + "|DIG"
+	}
+	needToday := false
+	for _, q := range queries {
+		if q.Contest {
+			needToday = true
+			break
+		}
+	}
+	today := map[string]bool{}
+	if needToday {
+		midnight := time.Now().UTC().Truncate(24 * time.Hour)
+		rows, err := a.qso.SlotsSince(a.ctx, midnight)
+		if err == nil {
+			for _, r := range rows {
+				today[slotKey(r.Callsign, r.Band, r.Mode)] = true
+				today[digKey(r.Callsign, r.Band)] = qso.ModeClass(r.Mode) == "DIG" || today[digKey(r.Callsign, r.Band)]
+			}
+		}
+	}
+	for i, q := range queries {
+		if q.Contest {
+			if generic(q.Mode) {
+				out[i] = today[digKey(q.Call, q.Band)]
+			} else {
+				out[i] = today[slotKey(q.Call, q.Band, q.Mode)]
+			}
+		} else if generic(q.Mode) {
+			if idx.workedCallSlotsDig != nil {
+				_, out[i] = idx.workedCallSlotsDig[digKey(q.Call, q.Band)]
+			}
+		} else if idx.workedCallSlots != nil {
+			_, out[i] = idx.workedCallSlots[slotKey(q.Call, q.Band, q.Mode)]
+		}
+	}
+	return out
+}
+
+// watchSpot runs one live spot through the watchlist: last-seen bookkeeping and
+// the alert, through the SAME event the alert rules fire — the frontend already
+// knows how to toast and sound it, and a second notification path would be a
+// second thing to misconfigure.
+func (a *App) watchSpot(dxCall, band, mode, country, comment string, freqHz int64) {
+	if a.watchlist == nil {
+		return
+	}
+	entry, notify, ok := a.watchlist.MarkSeen(dxCall)
+	if !ok {
+		// Not watched yet — the auto-contest pattern may claim it. Contains, not
+		// prefix: the event string sits anywhere in these calls (HB9WWA, F4WWA/P).
+		if p := a.GetWatchlistContestPattern(); p != "" &&
+			strings.Contains(strings.ToUpper(dxCall), p) {
+			if err := a.watchlist.Add(dxCall, true); err == nil {
+				applog.Printf("watchlist: auto-added %s (contest pattern %q)", dxCall, p)
+				entry, notify, ok = a.watchlist.MarkSeen(dxCall)
+				if a.ctx != nil {
+					wruntime.EventsEmit(a.ctx, "watchlist:changed")
+				}
+			}
+		}
+	}
+	if !ok || !notify || a.ctx == nil {
+		return
+	}
+	// Already worked? Then nothing to announce. Judged HERE, before the sound —
+	// the report was an alert ringing for a slot the tab showed as Worked a
+	// moment later, because the frontend's verdict arrives on a debounce while
+	// the alert used to fire on the raw spot. Same verdict as the tab: exact
+	// slot for named modes, digital class for a generic DATA spot, today-only
+	// for a contest entry.
+	if e, found := a.watchlist.Get(entry); found {
+		if a.WatchlistWorkedSlots([]WatchlistSlotQuery{{Call: dxCall, Band: band, Mode: mode, Contest: e.IsContest}})[0] {
+			return
+		}
+	}
+	// Throttled per entry: a DXpedition lights up every skimmer on the planet,
+	// and forty alerts a minute for one station is a alarm nobody keeps on.
+	a.watchAlertMu.Lock()
+	last := a.watchAlertAt[entry]
+	now := time.Now()
+	if now.Sub(last) < 2*time.Minute {
+		a.watchAlertMu.Unlock()
+		return
+	}
+	a.watchAlertAt[entry] = now
+	a.watchAlertMu.Unlock()
+	wruntime.EventsEmit(a.ctx, "alert:fired", map[string]any{
+		"rule":    "Watchlist " + entry,
+		"call":    strings.ToUpper(strings.TrimSpace(dxCall)),
+		"band":    band,
+		"mode":    mode,
+		"freq_hz": freqHz,
+		"country": country,
+		"comment": comment,
+		"sound":   true,
+		"visual":  true,
+	})
+}
+
+// startWatchlistClubLog begins the expedition enrichment: every entry's
+// ClubLog block (expedition flag, OQRS, LiveStream, QSO totals and 24 h rate)
+// is refreshed on a rolling schedule — hourly for expeditions, six-hourly for
+// the rest, DXHunter's own cadence. OpsLog's application API key is used, so
+// there is nothing to configure.
+//
+// Two at a time with a breath between requests: the key is shared by every
+// OpsLog install, and a hundred-entry watchlist must read as a trickle at
+// ClubLog's end, not a burst.
+func (a *App) startWatchlistClubLog() {
+	if a.watchlist == nil {
+		return
+	}
+	go func() {
+		client := &http.Client{Timeout: 30 * time.Second}
+		// Let the app finish starting before the first network pass.
+		time.Sleep(15 * time.Second)
+		for {
+			stale := a.watchlist.StaleEntries(1*time.Hour, 6*time.Hour)
+			changed := false
+			for _, call := range stale {
+				// The pattern's BASE is what ClubLog knows: VK9* has no log.
+				base := strings.TrimSuffix(call, "*")
+				if base == "" {
+					continue
+				}
+				ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+				d, err := watchlist.FetchWatch(ctx, client, clublogAppAPIKey, base)
+				cancel()
+				if err != nil {
+					applog.Printf("watchlist clublog: %s: %v", base, err)
+					continue
+				}
+				if a.watchlist.ApplyClubLog(call, d) {
+					changed = true
+					if d.IsExpedition {
+						applog.Printf("watchlist clublog: %s is a DXpedition (%d QSOs, %d/24h, OQRS=%v)",
+							base, func() int {
+								if d.ClubLogInfo != nil {
+									return d.ClubLogInfo.TotalQSOs
+								}
+								return 0
+							}(), d.QSOs24h(), d.HasOQRS)
+					}
+				}
+				time.Sleep(400 * time.Millisecond)
+			}
+			if changed && a.ctx != nil {
+				wruntime.EventsEmit(a.ctx, "watchlist:changed")
+			}
+			time.Sleep(10 * time.Minute)
+		}
+	}()
+}

changelog.json

@@ -1,16 +1,42 @@
 [
+  {
+    "version": "0.27.0",
+    "date": "",
+    "en": [
+      "⭐ NEW — Watchlist (Tools): the DXHunter watchlist as an OpsLog tab — callsigns you are hunting (exact, or a family with a trailing * — VK9* catches every VK9), the live cluster spots under each with the NEW badges and a Needed/Worked verdict per slot, an ON AIR badge, per-entry alerts through the normal alert path, and CONTEST entries judged per UTC day (at midnight everything is workable again).Each entry is enriched from ClubLog automatically: DXpedition badge, OQRS, LiveStream link, QSO total and 24-hour rate — nothing to configure. Reads and writes DXHunter’s own watchlist.json format — drop your existing file into the data folder to carry it over.",
+      "TCI (SunSDR): the meter subscription is renewed when the radio announces it is ready — sent only at connect, it could fall inside the initial state dump and be ignored, which left the transmit power and SWR empty. The log now also records the subscription and the first sensor frames, so a report can tell “the radio never sends them” from “they arrived and were dropped”.",
+      "Sending a spot while in split now pre-fills the RX frequency — where the station actually is — instead of the TX frequency, which spotted the pile-up five up from the DX.",
+      "Cluster: NEW SLOT gets its own colour — the sky cyan the panadapter palette already uses for it, clearly apart from POTA green and the yellows. The NEW SLOT and NEW COUNTY filter chips now wear the same colours as the badges they select, and the NEW CALL filter works even when the slot-highlight display option is off.",
+      "Elecraft console: a mode row — CW, USB, LSB, DATA and DATA RTTY. The two DATA buttons set the K3’s submode as well (DATA A for FT8/FT4, FSK D for RTTY): switching to DATA by mode alone kept whatever submode the last session left, which is how a K3 “in DATA” keys FT8 with no audio.",
+      "DX Cluster settings: “I chase POTA” and “I chase SOTA”, on by default. Unticked, the NEW POTA badge, colour and filter disappear — a new-band + new-POTA spot reads NEW BAND alone — and the reference columns stay empty.",
+      "Elecraft console: RIT and XIT use the same control as the Icom and TCI consoles — ± buttons, mouse wheel, typed value, Ctrl+←/→ — and the power slider moves in 1 W steps instead of 5.",
+      "Bulk edit: My DXCC, My CQ zone and My ITU zone join the My-station fields — numbers checked against their real ranges, empty clears.",
+      "Clicking a spot in the Chase new panel now applies the FlexRadio panadapter width/zoom, like every other spot click.",
+      "FlexRadio: the panadapter width/zoom now applies reliably when double-clicking a cluster spot — the zoom is sent after the tune settles, so SmartSDR’s own pan-follow on a band change no longer overrides it."
+    ],
+    "fr": [
+      "⭐ NOUVEAU — Watchlist (Outils) : la watchlist de DXHunter en onglet OpsLog — indicatifs chassés (exacts, ou une famille avec une * finale — VK9* attrape tous les VK9), les spots cluster en direct sous chaque entrée avec les badges NOUVEAU et un verdict Manquant/Contacté par créneau, un badge ON AIR, des alertes par entrée via le circuit d'alerte normal, et des entrées CONTEST jugées par jour UTC (à minuit tout redevient à faire).Chaque entrée est enrichie automatiquement depuis ClubLog : badge DXpedition, OQRS, lien LiveStream, total de QSO et rythme sur 24 h — rien à configurer. Lit et écrit le format watchlist.json de DXHunter — déposez votre fichier existant dans le dossier data pour le récupérer.",
+      "TCI (SunSDR) : l'abonnement aux mesures est renouvelé quand la radio annonce qu'elle est prête — envoyé seulement à la connexion, il pouvait tomber pendant l'envoi initial de l'état et être ignoré, laissant la puissance et le ROS vides en émission. Le journal enregistre aussi l'abonnement et les premières trames de mesure, pour distinguer « la radio ne les envoie jamais » de « elles arrivaient et étaient perdues ».",
+      "Envoyer un spot en split préremplit désormais la fréquence RX — là où la station se trouve réellement — au lieu de la fréquence TX, qui spottait le pile-up cinq au-dessus du DX.",
+      "Cluster : NOUVEAU SLOT reçoit sa propre couleur — le cyan ciel que la palette du panadapter lui donne déjà, bien distinct du vert POTA et des jaunes. Les puces de filtre NOUVEAU SLOT et NOUVEAU COMTÉ portent désormais les couleurs des badges qu'elles sélectionnent, et le filtre NOUVEAU CALL fonctionne même quand l'option de surlignage par slot est désactivée.",
+      "Console Elecraft : une rangée de modes — CW, USB, LSB, DATA et DATA RTTY. Les deux boutons DATA règlent aussi le sous-mode du K3 (DATA A pour FT8/FT4, FSK D pour le RTTY) : passer en DATA par le seul mode gardait le sous-mode de la session précédente, et un K3 « en DATA » manipulait le FT8 sans audio.",
+      "Réglages DX Cluster : « Je chasse le POTA » et « Je chasse le SOTA », cochés par défaut. Décochés, le badge, la couleur et le filtre NOUVEAU POTA disparaissent — un spot nouvelle bande + nouveau POTA affiche seulement NOUVELLE BANDE — et les colonnes de références restent vides.",
+      "Console Elecraft : le RIT et le XIT utilisent la même commande que les consoles Icom et TCI — boutons ±, molette, valeur tapée, Ctrl+←/→ — et le curseur de puissance avance par pas de 1 W au lieu de 5.",
+      "Édition groupée : My DXCC, My CQ zone et My ITU zone rejoignent les champs Ma station — valeurs vérifiées contre leurs bornes réelles, vide efface.",
+      "Cliquer un spot dans le panneau Chase new applique désormais la largeur/zoom du panadapter FlexRadio, comme tout autre clic de spot.",
+      "FlexRadio : la largeur/zoom du panadapter s’applique désormais de façon fiable au double-clic sur un spot du cluster — le zoom est envoyé après le tune, pour que le suivi du panadapter de SmartSDR lors d’un changement de bande ne l’écrase plus."
+    ]
+  },
   {
     "version": "0.26.23",
     "date": "",
     "en": [
       "LoTW: the downloaded confirmations list gains a Station column, so a list spanning several callsigns says which one each confirmation belongs to. Shown only when the report actually carries more than the one station.",
-      "Label Designer (Tools): design the labels for paper QSL work — a QSO label for the card (repeating QSO table, several contacts of the same station per label) and address labels for the envelope. Label sizes are profiles in millimetres with margins, seeded with the common Brother DK rolls; elements are dragged in place on a millimetre-true preview fed with your latest contacts. Printing to PDF comes next.",
-      "Label printing (Tools → Print QSL labels): a three-step session — pick from the paper-QSL queue (sent status R/Q), check each address with a routing choice (direct / bureau / via manager) and a QRZ fetch (the MANAGER’s address when routing says via), then ONE PDF holding every label at its exact size, opened straight in the viewer to print from. Finishing marks the contacts sent with the date and the via."
+      "The band maps follow your IARU region (Settings → General): Region 2’s 40 m runs to 7300 kHz with phone from 7125 and its 80 m to 4000, Region 3’s 80 m to 3900 — the band edges and the CW/digital/phone shading all adjust."
     ],
     "fr": [
       "LoTW : la liste des confirmations téléchargées gagne une colonne Station, pour savoir à quel indicatif appartient chaque confirmation quand le téléchargement en couvre plusieurs. Affichée seulement si le rapport en contient effectivement.",
-      "Créateur d'étiquettes (Outils) : dessinez les étiquettes de vos QSL papier — étiquette QSO pour la carte (tableau de QSO répétable, plusieurs contacts de la même station par étiquette) et étiquettes adresse pour l'enveloppe. Les formats sont des profils en millimètres avec marges, préremplis avec les rouleaux Brother DK courants ; les éléments se placent à la souris sur un aperçu fidèle au millimètre nourri de vos derniers contacts. L'impression en PDF viendra ensuite.",
-      "Impression des étiquettes (Outils → Imprimer les étiquettes QSL) : une session en trois étapes — choisir dans la file QSL papier (statut envoyé R/Q), vérifier chaque adresse avec le routage (direct / bureau / via manager) et une récupération QRZ (l'adresse du MANAGER quand le routage le dit), puis UN PDF contenant toutes les étiquettes à leur taille exacte, ouvert directement dans le lecteur pour impression. La fin de session marque les contacts envoyés avec la date et le moyen."
+      "Les cartes de bande suivent votre région IARU (Réglages → Général) : le 40 m de la Région 2 va jusqu'à 7300 kHz avec la phonie dès 7125 et son 80 m jusqu'à 4000, le 80 m de la Région 3 jusqu'à 3900 — les limites de bande et les zones CW/numérique/phonie s'ajustent."
     ]
   },
   {

frontend/src/App.tsx

@@ -69,9 +69,8 @@ import {
 } from '@/components/ui/dropdown-menu';
 import { APP_VERSION, APP_AUTHOR } from '@/version';
 import { QSLManagerPanel } from '@/components/QSLManagerModal';
+import { WatchlistTab } from '@/components/WatchlistTab';
 import { QslDesignerModal } from '@/components/qsl/QslDesignerModal';
-import { LabelDesignerModal } from '@/components/labels/LabelDesignerModal';
-import { LabelPrintModal } from '@/components/labels/LabelPrintModal';
 import { SendEQSLModal } from '@/components/qsl/SendEQSLModal';
 import { AutoEQSL } from '@/components/qsl/AutoEQSL';
 import { ConfirmDialog } from '@/components/ConfirmDialog';
@@ -100,7 +99,7 @@ import { ExportFieldsDialog } from '@/components/ExportFieldsDialog';
 import { ShutdownProgress } from '@/components/ShutdownProgress';
 import { ClusterGrid } from '@/components/ClusterGrid';
 import { cleanSpotter, inferSpotMode, spotModeCategory, spotStatusKey } from '@/lib/spot';
-import { applySpotDisplay, readSpotDisplayOptions, spotIsWorked, SPOT_DISPLAY_OPTIONS_EXPOSED } from '@/lib/spotDisplay';
+import { applySpotDisplay, chasePota, readSpotDisplayOptions, spotIsWorked, SPOT_DISPLAY_OPTIONS_EXPOSED } from '@/lib/spotDisplay';
 import { AnswerDecode, HaltDecodeTx, LogUIError, FlexTXOnBand, GetMatrixColors, GetRotorPresets, GetRowColors, GetSpotTTLMinutes, GetSpotMax, IsNewUSCounty } from '../wailsjs/go/main/App';
 import { applyMatrixColors } from '@/lib/matrixColors';
 import { WorkedBeforeGrid } from '@/components/WorkedBeforeGrid';
@@ -1269,8 +1268,6 @@ export default function App() {
     setQslPaperReq((r) => ({ call: c, n: (r?.n ?? 0) + 1 }));
   }
   const [qslDesignerOpen, setQslDesignerOpen] = useState(false);
-  const [labelDesignerOpen, setLabelDesignerOpen] = useState(false);
-  const [labelPrintOpen, setLabelPrintOpen] = useState(false);
   const [eqslQsoId, setEqslQsoId] = useState<number | null>(null); // QSO being sent as eQSL
   function closeQslTab() {
     setQslTabOpen(false);
@@ -1688,6 +1685,9 @@ export default function App() {
   // NET Control tab — enabled from Tools (persisted; once on it's a tab like Cluster).
   const [netEnabled, setNetEnabled] = useState(() => localStorage.getItem('opslog.netEnabled') === '1');
   useEffect(() => { localStorage.setItem('opslog.netEnabled', netEnabled ? '1' : '0'); }, [netEnabled]);
+  // Watchlist tab — opt-in from Tools, persisted, closable like NET Control.
+  const [watchlistEnabled, setWatchlistEnabled] = useState(() => localStorage.getItem('opslog.watchlistEnabled') === '1');
+  useEffect(() => { localStorage.setItem('opslog.watchlistEnabled', watchlistEnabled ? '1' : '0'); }, [watchlistEnabled]);
   // Contest tab is hidden until enabled from Tools → Contest mode.
   const [contestTabEnabled, setContestTabEnabled] = useState(() => localStorage.getItem('opslog.contestTab') === '1');
   useEffect(() => { localStorage.setItem('opslog.contestTab', contestTabEnabled ? '1' : '0'); }, [contestTabEnabled]);
@@ -2018,7 +2018,7 @@ export default function App() {
   // so it's loaded async on mount and re-read on profile:changed below.
   // 'none' is only ever stored for the third and fourth panes: the first two are
   // the Main view, and a layout with no panes at all is not a layout.
-  type MainPaneKind = 'map1' | 'map2' | 'cluster' | 'worked' | 'flex' | 'recent' | 'icom' | 'yaesu' | 'elecraft' | 'tci' | 'netcontrol' | 'decodes' | 'none';
+  type MainPaneKind = 'map1' | 'map2' | 'cluster' | 'worked' | 'flex' | 'recent' | 'icom' | 'yaesu' | 'elecraft' | 'tci' | 'netcontrol' | 'decodes' | 'watchlist' | 'none';
   const [mapZoomSignal, setMapZoomSignal] = useState(0); // bump → world map auto-zooms now
   const [mainPaneLeft, setMainPaneLeft] = useState<MainPaneKind>('map1');
   const [mainPaneRight, setMainPaneRight] = useState<MainPaneKind>('map2');
@@ -2029,7 +2029,7 @@ export default function App() {
   // quarter-width map is unreadable.
   const [mainLayout4, setMainLayout4] = useState<'cols' | 'quad'>('quad');
   const loadMainPanes = useCallback(async () => {
-    const valid = (v: string): v is MainPaneKind => v === 'map1' || v === 'map2' || v === 'cluster' || v === 'worked' || v === 'flex' || v === 'recent' || v === 'icom' || v === 'yaesu' || v === 'elecraft' || v === 'tci' || v === 'netcontrol' || v === 'decodes';
+    const valid = (v: string): v is MainPaneKind => v === 'map1' || v === 'map2' || v === 'cluster' || v === 'worked' || v === 'flex' || v === 'recent' || v === 'icom' || v === 'yaesu' || v === 'elecraft' || v === 'tci' || v === 'netcontrol' || v === 'decodes' || v === 'watchlist';
     const [l, r, p3, p4, lay] = await Promise.all([
       GetUIPref('mainPaneLeft').catch(() => ''),
       GetUIPref('mainPaneRight').catch(() => ''),
@@ -3304,11 +3304,16 @@ export default function App() {
       noteManualEdit();
     }
     if (s.band) setBand(s.band);
-    if (catState.connected) tuneRigCAT(s.freq_hz, m);
     // The panadapter width follows the MODE of the spot, when the option is on.
-    // AFTER the tune, deliberately: a view change must never delay the frequency
-    // change the operator is waiting for. A no-op on any backend but a Flex.
-    FlexZoomForSpot(m ?? '', s.freq_hz ?? 0).catch(() => {});
+    // A no-op on any backend but a Flex. Sequenced AFTER the tune settles, not
+    // fired alongside it: on a cross-band jump SmartSDR moves the panadapter
+    // itself to follow the slice, and that follow lands after — and overrides —
+    // a zoom sent in the same instant. (A spot clicked ON the panadapter never
+    // hit this: the radio had already tuned before our zoom arrived.)
+    const zoom = () => FlexZoomForSpot(m ?? '', s.freq_hz ?? 0).catch(() => {});
+    if (catState.connected) {
+      void tuneRigCAT(s.freq_hz, m).then(() => window.setTimeout(zoom, 300));
+    } else zoom();
     if (m) applyModeFromSpot(m);
     onCallsignInput(s.dx_call, { force: true });
     applySpotRefs((s as any).pota_ref, (s as any).sota_ref);
@@ -5002,14 +5007,13 @@ export default function App() {
       { type: 'item', label: t('dec.tab'), action: 'tools.decodes' },
       { type: 'item', label: t('gsm.title'), action: 'tools.grids' },
       { type: 'item', label: t('tools.qslDesigner'), action: 'tools.qsldesigner' },
-      { type: 'item', label: t('tools.labelDesigner'), action: 'tools.labeldesigner' },
-      { type: 'item', label: t('tools.labelPrint'), action: 'tools.labelprint' },
       { type: 'separator' },
       { type: 'item', label: (wkEnabled ? '✓ ' : '') + t('tools.winkeyer'), action: 'tools.winkeyer' },
       { type: 'item', label: (dvkEnabled ? '✓ ' : '') + t('tools.dvk'), action: 'tools.dvk' },
       { type: 'item', label: (cwEnabled ? '✓ ' : '') + t('tools.cwDecoder'), action: 'tools.cwdecoder' },
       { type: 'separator' },
       { type: 'item', label: (netEnabled ? '✓ ' : '') + t('tools.net'), action: 'tools.net' },
+      { type: 'item', label: (watchlistEnabled ? '✓ ' : '') + t('tools.watchlist'), action: 'tools.watchlist' },
       { type: 'item', label: (contestTabEnabled ? '✓ ' : '') + t('tools.contest'), action: 'tools.contest' },
       { type: 'item', label: t('tools.alerts'), action: 'tools.alerts' },
       { type: 'separator' },
@@ -5033,7 +5037,7 @@ export default function App() {
       { type: 'separator' },
       { type: 'item', label: t('help.about'), action: 'help.about' },
     ]},
-  ], [total, selectedId, selectedIds, exporting, wkEnabled, dvkEnabled, cwEnabled, netEnabled, contestTabEnabled, smtpConfigured, sendingLog, t]);
+  ], [total, selectedId, selectedIds, exporting, wkEnabled, dvkEnabled, cwEnabled, netEnabled, watchlistEnabled, contestTabEnabled, smtpConfigured, sendingLog, t]);
 
   function handleMenu(action: string) {
     switch (action) {
@@ -5057,12 +5061,11 @@ export default function App() {
       case 'tools.decodes':     openDecodesTab(); break;
       case 'tools.grids':       openGridsTab(); break;
       case 'tools.qsldesigner': setQslDesignerOpen(true); break;
-      case 'tools.labeldesigner': setLabelDesignerOpen(true); break;
-      case 'tools.labelprint': setLabelPrintOpen(true); break;
       case 'tools.winkeyer':    wkSetEnabled(!wkEnabled); break;
       case 'tools.dvk':         setDvkEnabled((v) => !v); break;
       case 'tools.cwdecoder':   toggleCwDecoder(); break;
       case 'tools.net':         setNetEnabled((v) => { const nv = !v; if (nv) setActiveTab('net'); return nv; }); break;
+      case 'tools.watchlist':   setWatchlistEnabled((v) => { const nv = !v; if (nv) setActiveTab('watchlist'); return nv; }); break;
       case 'tools.contest':     setContestTabEnabled((v) => { const nv = !v; if (nv) setActiveTab('contest'); else setActiveTab((tb) => (tb === 'contest' ? 'recent' : tb)); return nv; }); break;
       case 'tools.alerts':      setAlertsOpen(true); break;
       case 'tools.duplicates':  setShowDuplicates(true); break;
@@ -5878,6 +5881,13 @@ export default function App() {
         // worked call still matches its own entity status too (new-band/new-slot),
         // so it stays visible under those chips.
         const matches = (st !== 'worked' && clusterStatusFilter.has(st))
+          // NEW CALL is a FACT about the callsign (never worked on this band and
+          // mode), surfaced as a status only by the slot-highlight option. The
+          // chip filters on the fact itself, so it works whether or not that
+          // display option is on — worked_slot is computed whenever either
+          // slot option is enabled.
+          || (clusterStatusFilter.has('new-call') && e?.worked_slot === false
+            && (!e?.status || e?.status === 'worked' || e?.status === 'new-call'))
           || (!!e?.worked_call && clusterStatusFilter.has('worked'))
           || (!!e?.new_pota && clusterStatusFilter.has('new-pota'))
           || (!!e?.new_county && clusterStatusFilter.has('new-county'))
@@ -5984,12 +5994,20 @@ export default function App() {
   );
 
   const F_CHIP = 'px-1.5 py-[3px] rounded-md border text-[10px] font-bold tracking-wider transition-opacity';
-  const fChip = (key: string, label: string, cls: string, on: boolean, toggle: () => void) => (
-    <button key={key} type="button" onClick={toggle}
-      className={cn(F_CHIP, on ? cls : `${cls} opacity-40 hover:opacity-80`)}>
+  const fChip = (key: string, label: string, cls: string, on: boolean, toggle: () => void, style?: React.CSSProperties, title?: string) => (
+    <button key={key} type="button" onClick={toggle} title={title}
+      className={cn(F_CHIP, on ? cls : `${cls} opacity-40 hover:opacity-80`)} style={style}>
       {label}
     </button>
   );
+  // chipStyle builds a filter chip in an arbitrary colour — for the statuses
+  // whose grid badge is not one of the semantic tokens the chip classes cover.
+  // A filter that does not look like what it selects has to be learned twice.
+  const chipStyle = (c: string): React.CSSProperties => ({
+    color: c,
+    borderColor: `color-mix(in srgb, ${c} 45%, transparent)`,
+    background: `color-mix(in srgb, ${c} 14%, transparent)`,
+  });
 
   const renderClusterFilters = () => (
     <div className="w-56 shrink-0 border-l border-border/60 flex flex-col min-h-0 bg-muted/10">
@@ -6105,14 +6123,14 @@ export default function App() {
               { k: 'new-band-mode' as SpotFilterKey, label: 'NEW B+M', cls: 'bg-danger-muted text-danger-muted-foreground border-danger-border' },
               { k: 'new-band' as SpotFilterKey, label: 'NEW BAND',  cls: 'bg-warning-muted text-warning-muted-foreground border-warning-border' },
               { k: 'new-mode' as SpotFilterKey, label: 'NEW MODE',  cls: 'bg-caution-muted text-caution-muted-foreground border-caution-border' },
-              { k: 'new-slot' as SpotFilterKey, label: 'NEW SLOT',  cls: 'bg-caution-muted text-caution-muted-foreground border-caution-border' },
+              { k: 'new-slot' as SpotFilterKey, label: 'NEW SLOT',  cls: 'border', style: chipStyle('#5AC8FA') },
               // NEW CALL is about the CALLSIGN, not the entity: never worked on this
               // band and mode. Only appears when the slot-highlight option is on.
               { k: 'new-call' as SpotFilterKey, label: 'NEW CALL',  cls: 'bg-caution-muted text-caution-muted-foreground border-caution-border' },
               // Same colours as the badges in the grid — a filter that does not
               // look like what it selects has to be learned twice.
               { k: 'new-pota'   as SpotFilterKey, label: 'NEW POTA',   cls: 'bg-success-muted text-success-muted-foreground border-success-border' },
-              { k: 'new-county' as SpotFilterKey, label: 'NEW COUNTY', cls: 'bg-success-muted text-success-muted-foreground border-success-border' },
+              { k: 'new-county' as SpotFilterKey, label: 'NEW COUNTY', cls: 'border', style: chipStyle('var(--chart-5)') },
               { k: 'new-pfx'    as SpotFilterKey, label: 'NEW PFX',    cls: 'bg-caution-muted text-caution-muted-foreground border-caution-border' },
               // Only ever set for a station this receiver decoded over the UDP link.
               { k: 'new-grid'   as SpotFilterKey, label: 'NEW GRID',   cls: 'bg-muted text-foreground border-border' },
@@ -6120,8 +6138,9 @@ export default function App() {
               // worked spots; the separate "Hide worked" checkbox drops them — they
               // are opposite controls, so don't use both at once.
               { k: 'worked'   as SpotFilterKey, label: 'WORKED',   cls: 'bg-info-muted text-info-muted-foreground border-info-border' },
-            ]).map((s) => fChip(s.k, s.label, s.cls, clusterStatusFilter.has(s.k),
-              () => setClusterStatusFilter((cur) => { const n = new Set(cur); if (n.has(s.k)) n.delete(s.k); else n.add(s.k); return n; })))}
+            ]).filter((s: any) => s.k !== 'new-pota' || chasePota())
+              .map((s: any) => fChip(s.k, s.label, s.cls, clusterStatusFilter.has(s.k),
+              () => setClusterStatusFilter((cur) => { const n = new Set(cur); if (n.has(s.k)) n.delete(s.k); else n.add(s.k); return n; }), s.style))}
           </div>,
           clusterStatusFilter.size > 0 ? (
             <button type="button" onClick={() => setClusterStatusFilter(new Set())}
@@ -6325,6 +6344,13 @@ export default function App() {
             <IcomPanel isNetwork={catBackend === 'icom-net'} onReportRST={(r) => { setRstSent(r); rstUserEditedRef.current = true; }} />
           </div>
         );
+      case 'watchlist':
+        return (
+          <div className="h-full w-full min-h-0 flex flex-col bg-card border border-border rounded-lg overflow-hidden">
+            <WatchlistTab spots={spots} spotStatus={spotStatus}
+              onSpotSelect={handleSpotSelect} onSpotClick={handleSpotClick} />
+          </div>
+        );
       case 'netcontrol':
         return (
           <div className="h-full w-full min-h-0 flex flex-col rounded-lg overflow-hidden border border-border">
@@ -7218,7 +7244,7 @@ export default function App() {
         // relative + absolute inner: the panel's content can't grow the row, so
         // the row height is set by the ENTRY STRIP. A taller tab (Awards/F3) then
         // scrolls inside this fixed height instead of pushing everything down.
-        <div className="w-[560px] shrink-0 min-h-0 relative">
+        <div className="w-[600px] shrink-0 min-h-0 relative">
           <div className="absolute inset-0 flex flex-col min-h-0">
           <DetailsPanel
             callsign={callsign}
@@ -7400,7 +7426,10 @@ export default function App() {
                   entry, and the rig onto the frequency it was decoded on. */}
               <ChaseNewPanel onPick={(sp) => {
                 onCallsignInput(sp.call, { force: true });
-                if (sp.freq_hz) void tuneRigCAT(sp.freq_hz, sp.mode);
+                // And the panadapter width too — after the tune settles, for the
+                // same SmartSDR pan-follow reason as handleSpotClick.
+                if (sp.freq_hz) void tuneRigCAT(sp.freq_hz, sp.mode).then(() =>
+                  window.setTimeout(() => FlexZoomForSpot(sp.mode ?? '', sp.freq_hz ?? 0).catch(() => {}), 300));
               }} onClose={() => { setShowChaseNew(false); writeUiPref('opslog.showChaseNew', '0'); }} />
             </div>
           )}
@@ -7593,6 +7622,21 @@ export default function App() {
                   </span>
                 </TabsTrigger>
               )}
+              {watchlistEnabled && (
+                <TabsTrigger value="watchlist" className="gap-1.5">
+                  {t('tab.watchlist')}
+                  <span
+                    role="button"
+                    aria-label="Close Watchlist"
+                    title="Close"
+                    className="inline-flex items-center justify-center size-4 rounded hover:bg-foreground/10 text-muted-foreground hover:text-foreground"
+                    onPointerDown={(e) => { e.stopPropagation(); }}
+                    onClick={(e) => { e.stopPropagation(); setWatchlistEnabled(false); setActiveTab((t) => (t === 'watchlist' ? 'recent' : t)); }}
+                  >
+                    <X className="size-3" />
+                  </span>
+                </TabsTrigger>
+              )}
               {catState.backend === 'flex' && <TabsTrigger value="flex">Flex Console</TabsTrigger>}
               {catState.backend === 'icom' && <TabsTrigger value="icom">Icom Console</TabsTrigger>}
               {catState.backend === 'yaesu' && <TabsTrigger value="yaesu">Yaesu Console</TabsTrigger>}
@@ -8304,6 +8348,12 @@ export default function App() {
             {/* Band Map: several bands shown side-by-side (panadapter-style
                 strips). Pick bands with the chips; each strip is clickable to
                 tune the rig. */}
+            {watchlistEnabled && (
+              <TabsContent value="watchlist" className="mt-0 flex flex-col min-h-0 flex-1">
+                <WatchlistTab spots={spots} spotStatus={spotStatus}
+                  onSpotSelect={handleSpotSelect} onSpotClick={handleSpotClick} />
+              </TabsContent>
+            )}
             {netEnabled && (
               <TabsContent value="net" className="mt-0 flex flex-col min-h-0 flex-1">
                 <NetControlPanel onLogged={refresh} countries={countries} bands={bands} modes={modes}
@@ -8660,9 +8710,14 @@ export default function App() {
         // freqMhz display string, which the manual-edit freeze / field locks can
         // leave stale (that dropped the sub-kHz: on 14134.5 the frozen "14.134"
         // string spotted 14134). Fall back to the entry field, then the last QSO.
+        //
+        // The RX frequency when split, deliberately: a spot names where the
+        // STATION is, and in split that is where we listen — freq_hz is where
+        // we transmit, and spotting a 5-up pile-up's TX frequency sent the
+        // whole cluster five kHz above the DX.
         defaultFreqKHz={
-          catState.connected && (catState.freq_hz ?? 0) > 0
-            ? Math.round(((catState.freq_hz ?? 0) / 1000) * 10) / 10
+          catState.connected && ((catState.split && (catState.freq_rx_hz ?? 0) > 0 ? catState.freq_rx_hz : catState.freq_hz) ?? 0) > 0
+            ? Math.round((((catState.split && (catState.freq_rx_hz ?? 0) > 0 ? catState.freq_rx_hz : catState.freq_hz) ?? 0) / 1000) * 10) / 10
             : parseFloat(freqMhz) > 0
               ? Math.round(parseFloat(freqMhz) * 1000 * 10) / 10
               : (qsos[0]?.freq_hz ? Math.round((qsos[0].freq_hz / 1000) * 10) / 10 : 0)
@@ -8720,8 +8775,6 @@ export default function App() {
         onError={(msg) => showToast(msg)}
       />
       <QslDesignerModal open={qslDesignerOpen} onClose={() => setQslDesignerOpen(false)} />
-      <LabelDesignerModal open={labelDesignerOpen} onClose={() => setLabelDesignerOpen(false)} />
-      <LabelPrintModal open={labelPrintOpen} onClose={() => setLabelPrintOpen(false)} />
       <SendEQSLModal
         open={eqslQsoId !== null}
         qsoId={eqslQsoId}

frontend/src/components/BandMap.tsx

@@ -2,6 +2,7 @@ import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import { Minus, Plus, Crosshair, X, PanelLeft, PanelRight } from 'lucide-react';
 import { cn } from '@/lib/utils';
 import { useI18n } from '@/lib/i18n';
+import { bandRange, bandSegments, subscribeIaruRegion, type SegMode } from '@/lib/bandplan';
 import { spotStatusKey, inferSpotMode, spotModeCategory } from '@/lib/spot';
 import { SPOT_MARKERS, activeMarkers } from '@/lib/spotMarkers';
 import { applySpotDisplay, readSpotDisplayOptions } from '@/lib/spotDisplay';
@@ -114,59 +115,26 @@ interface Props {
   keyNav?: boolean;
 }
 
-const BAND_RANGES: Record<string, [number, number]> = {
-  '160m': [1800, 2000],
-  '80m':  [3500, 3800],
-  '60m':  [5350, 5450],
-  '40m':  [7000, 7200],
-  '30m':  [10100, 10150],
-  '20m':  [14000, 14350],
-  '17m':  [18068, 18168],
-  '15m':  [21000, 21450],
-  '12m':  [24890, 24990],
-  '10m':  [28000, 29700],
-  '6m':   [50000, 50500],
-  '4m':   [70000, 70500],
-  '2m':   [144000, 146000],
-  '70cm': [430000, 440000],
+// Band edges and mode segments come from lib/bandplan, which knows the
+// operator's IARU region (Settings → General): a Region 2 operator's 40 m runs
+// to 7300 with phone from 7125, and drawing Region 1's plan under their spots
+// cut the top 100 kHz of the band off the map.
+//
+// Sub-band shading colours: these are IDENTITIES (which mode the segment is
+// for), not states, so they take categorical hues — never the status tokens.
+// All three are drawn from the cool end of the categorical order and laid down
+// at low opacity, so the band plan stays background context while the warm
+// spot pills keep the foreground. Checked with the palette validator in both
+// themes (violet failed the dark protan step; magenta clears every check).
+const SEG_COLOR: Record<SegMode, string> = {
+  cw: 'var(--chart-7)',    // magenta
+  digi: 'var(--chart-1)',  // blue
+  phone: 'var(--chart-2)', // aqua
 };
-
-// Sub-band shading: CW / digital / phone.
-//
-// These are IDENTITIES (which mode the segment is for), not states, so they take
-// categorical hues — never the status tokens. They used to use success / info /
-// warning, which collided head-on with the spot pills drawn ON TOP of them: amber
-// is "new band" in this very component's legend, so the whole SSB portion read as
-// a giant "new band" wash. Status colours are reserved for status.
-//
-// All three are drawn from the COOL end of the categorical order and laid down at
-// low opacity, so the band plan stays background context while the warm spot pills
-// keep the foreground to themselves.
-// Checked with the palette validator in BOTH themes. Violet was the first pick
-// for CW and failed on the dark steps — violet and blue land 1.9 ΔE apart for a
-// protan reader there, i.e. the same colour. Magenta clears every check on both
-// surfaces (worst adjacent pair 13.0 light / 15.9 dark).
-const SEG_CW = 'var(--chart-7)';    // magenta
-const SEG_DIGI = 'var(--chart-1)';  // blue
-const SEG_PHONE = 'var(--chart-2)'; // aqua
 // A band-plan wash is CONTEXT, not data: it must stay under the spot pills that
 // are read on top of it.
 const SEG_OPACITY = 0.13;
 
-const SEGMENT_COLORS: Record<string, [number, number, string][]> = {
-  '160m': [[1800, 1838, SEG_CW], [1838, 1840, SEG_DIGI], [1840, 2000, SEG_PHONE]],
-  '80m':  [[3500, 3580, SEG_CW], [3580, 3600, SEG_DIGI], [3600, 3800, SEG_PHONE]],
-  '60m':  [[5350, 5450, SEG_PHONE]],
-  '40m':  [[7000, 7040, SEG_CW], [7040, 7100, SEG_DIGI], [7100, 7200, SEG_PHONE]],
-  '30m':  [[10100, 10130, SEG_CW], [10130, 10150, SEG_DIGI]],
-  '20m':  [[14000, 14070, SEG_CW], [14070, 14100, SEG_DIGI], [14100, 14350, SEG_PHONE]],
-  '17m':  [[18068, 18095, SEG_CW], [18095, 18110, SEG_DIGI], [18110, 18168, SEG_PHONE]],
-  '15m':  [[21000, 21070, SEG_CW], [21070, 21150, SEG_DIGI], [21150, 21450, SEG_PHONE]],
-  '12m':  [[24890, 24915, SEG_CW], [24915, 24940, SEG_DIGI], [24940, 24990, SEG_PHONE]],
-  '10m':  [[28000, 28070, SEG_CW], [28070, 28300, SEG_DIGI], [28300, 29700, SEG_PHONE]],
-  '6m':   [[50000, 50100, SEG_CW], [50100, 50500, SEG_PHONE]],
-};
-
 // Small coloured dot + label used in the band-map legend strip.
 function LegendDot({ cls, colour, label }: { cls?: string; colour?: string; label: string }) {
   return (
@@ -304,13 +272,16 @@ export function BandMap({ band, spots, spotStatus: spotStatusRaw, currentFreqHz,
   // nothing until the next poll happened to hand over a fresh object.
   const dispOpts = readSpotDisplayOptions();
   const spotStatus = useMemo(() => {
-    if (!dispOpts.muteWorked && !dispOpts.slotHighlight) return spotStatusRaw;
+    if (!dispOpts.muteWorked && !dispOpts.slotHighlight && dispOpts.chasePota) return spotStatusRaw;
     const out: Record<string, SpotStatusEntry> = {};
     for (const k of Object.keys(spotStatusRaw)) out[k] = applySpotDisplay(spotStatusRaw[k], dispOpts) as SpotStatusEntry;
     return out;
-  }, [spotStatusRaw, dispOpts.muteWorked, dispOpts.slotHighlight]);
-  const range = BAND_RANGES[band];
-  const segments = SEGMENT_COLORS[band] ?? [];
+  }, [spotStatusRaw, dispOpts.muteWorked, dispOpts.slotHighlight, dispOpts.chasePota]);
+  // Re-render when the operator changes their IARU region in Settings.
+  const [, setRegionTick] = useState(0);
+  useEffect(() => subscribeIaruRegion(() => setRegionTick((n) => n + 1)), []);
+  const range = bandRange(band);
+  const segments = bandSegments(band).map(([a, b, m]) => [a, b, SEG_COLOR[m]] as [number, number, string]);
   const [zoomIdx, setZoomIdx] = useState(() => readZoom(band));
   // The docked map follows the rig, so a band change must bring up THAT band's
   // remembered zoom.
@@ -794,9 +765,9 @@ export function BandMap({ band, spots, spotStatus: spotStatusRaw, currentFreqHz,
         ))}
         {/* Sub-band shading, so the wash behind the pills is never colour-alone. */}
         <span className="mx-0.5 opacity-40">|</span>
-        <LegendDot colour={SEG_CW} label={t("bmp.legendCW")} />
-        <LegendDot colour={SEG_DIGI} label={t("bmp.legendData")} />
-        <LegendDot colour={SEG_PHONE} label={t("bmp.legendPhone")} />
+        <LegendDot colour={SEG_COLOR.cw} label={t("bmp.legendCW")} />
+        <LegendDot colour={SEG_COLOR.digi} label={t("bmp.legendData")} />
+        <LegendDot colour={SEG_COLOR.phone} label={t("bmp.legendPhone")} />
       </div>
       <div className="px-3 py-1 text-[9px] text-muted-foreground bg-muted/30 border-t border-border font-mono text-center shrink-0">
         {t('bmp.footerHint')}

frontend/src/components/BandSlotGrid.tsx

@@ -242,11 +242,11 @@ export function BandSlotGrid({ wb, busy, currentBand, currentMode, bands, hasCal
   return (
     <section
       className={cn(
-        'flex items-center gap-4 px-3 py-2 flex-wrap shrink-0',
+        'flex items-center gap-2 px-2 py-2 flex-wrap shrink-0',
         newOne && 'bg-gradient-to-br from-warning-muted to-warning-muted rounded-lg',
       )}
     >
-      <div className="flex items-center gap-2 min-w-[220px] flex-1">
+      <div className="flex items-center gap-2 min-w-0 flex-1">
         {newOne ? (
           <>
             <Badge className="bg-warning text-warning-foreground gap-1 px-3 py-1 text-[11px]">
@@ -269,7 +269,7 @@ export function BandSlotGrid({ wb, busy, currentBand, currentMode, bands, hasCal
                 {forCall}
               </Badge>
             )}
-            <Badge className="bg-primary text-primary-foreground px-3 py-1 text-xs normal-case font-semibold tracking-normal">
+            <Badge className="bg-primary text-primary-foreground px-2 py-0.5 text-xs normal-case font-semibold tracking-normal leading-tight">
               {dxccName || `DXCC #${dxcc}`}
             </Badge>
             {mwBadge}

frontend/src/components/BulkEditModal.tsx

@@ -60,6 +60,9 @@ const FIELDS: FieldDef[] = [
   // No promoted column: written into extras_json (see qso.bulkEditableExtras).
   { id: 'owner_callsign',   label: 'bulk.fOwnerCallsign', group: 'My station', kind: 'text', upper: true },
   { id: 'my_grid',          label: 'bulk.fMyGrid',       group: 'My station', kind: 'text', upper: true },
+  { id: 'my_dxcc',          label: 'bulk.fMyDxcc',       group: 'My station', kind: 'text' },
+  { id: 'my_cq_zone',       label: 'bulk.fMyCqZone',     group: 'My station', kind: 'text' },
+  { id: 'my_itu_zone',      label: 'bulk.fMyItuZone',    group: 'My station', kind: 'text' },
   { id: 'my_antenna',       label: 'bulk.fMyAntenna',    group: 'My station', kind: 'text' },
   { id: 'my_rig',           label: 'bulk.fMyRig',        group: 'My station', kind: 'text' },
   { id: 'my_street',        label: 'bulk.fMyStreet',     group: 'My station', kind: 'text' },

frontend/src/components/ClusterGrid.tsx

@@ -13,7 +13,7 @@ import { Button } from '@/components/ui/button';
 import { Checkbox } from '@/components/ui/checkbox';
 import { cleanSpotter, inferSpotMode, spotStatusKey } from '@/lib/spot';
 import { markerColour } from '@/lib/spotMarkers';
-import { applySpotDisplay, readSpotDisplayOptions } from '@/lib/spotDisplay';
+import { applySpotDisplay, chasePota, chaseSota, readSpotDisplayOptions } from '@/lib/spotDisplay';
 import { loadLocal, loadRemote, saveState, seedLocal, whenGridPrefsReady } from '@/lib/gridPrefs';
 import { distanceUnit, distanceValue, subscribeDistanceUnit } from '@/lib/units';
 import { useI18n } from '@/lib/i18n';
@@ -148,6 +148,12 @@ function statusFor(p: any): SpotStatusEntry | undefined {
 //   filled pfx  → new prefix  filled POTA → new park    filled county → new county
 //   blue call   → already worked (not a novelty, so text only)
 const NEW = 'var(--warning)'; // yellow: something here is new
+// NEW SLOT gets its own hue. It shared the amber NEW family while the NEW PFX
+// marker sits in caution yellow — two different facts, two near-identical
+// colours in the same cell. Sky cyan, the exact colour the panadapter palette
+// ships for new-slot (#5AC8FA), so the two views tell one story — and clearly
+// apart from the POTA green the first attempt (aqua) sat next to.
+const NEWSLOT = '#5AC8FA';
 const WKD = 'var(--info)';    // blue: this callsign is already in the log
 
 // FILLING the cell that carries the fact, rather than only tinting its text.
@@ -190,9 +196,10 @@ function statusColor(s: SpotStatusEntry | undefined): string | null {
     case 'new-band-mode':
     case 'new-band':
     case 'new-mode':
-    case 'new-slot':
     case 'new-call':
       return NEW;
+    case 'new-slot':
+      return NEWSLOT;
     default:
       return s?.worked_call ? WKD : null;
   }
@@ -336,7 +343,9 @@ const makeColCatalog = (t: TFn): ColEntry[] => [
   },
   {
     group: 'Spot', label: t('clg2.c.pota'), colId: 'pota',
-    headerName: t('clg2.c.pota'), field: 'pota_ref' as any, width: 92, cellClass: 'font-mono',
+    headerName: t('clg2.c.pota'), width: 92, cellClass: 'font-mono',
+    // Through a valueGetter so the chase switch empties the column live.
+    valueGetter: (p: any) => (chasePota() ? p.data?.pota_ref ?? '' : ''),
     defaultVisible: true,
     cellStyle: (p: any) => (statusFor(p)?.new_pota
       ? fillStyle(markerColour('new_pota'))
@@ -349,7 +358,8 @@ const makeColCatalog = (t: TFn): ColEntry[] => [
     // which is why the column is off by default rather than an empty column for
     // everyone who does not watch summits.
     group: 'Spot', label: t('clg2.c.sota'), colId: 'sota',
-    headerName: t('clg2.c.sota'), field: 'sota_ref' as any, width: 100, cellClass: 'font-mono',
+    headerName: t('clg2.c.sota'), width: 100, cellClass: 'font-mono',
+    valueGetter: (p: any) => (chaseSota() ? p.data?.sota_ref ?? '' : ''),
     defaultVisible: false,
     cellStyle: () => ({ color: 'var(--success)' }) as any,
   },

frontend/src/components/ElecraftPanel.tsx

@@ -4,17 +4,18 @@ import {
   GetKenwoodState, RefreshKenwood, SetKenwoodPower, SetKenwoodAFGain, SetKenwoodTX, TuneKenwoodATU,
   SetKenwoodRFGain, SetKenwoodMicGain, SetKenwoodSquelch, SetKenwoodPreamp, SetKenwoodAtt,
   SetKenwoodNB, SetKenwoodNR, SetKenwoodAGC, SetKenwoodFilter, SetKenwoodAntenna,
-  SetKenwoodRIT, SetKenwoodXIT, ClearKenwoodRIT, SetKenwoodKeySpeed, ToggleKenwoodATU, NudgeKenwoodRIT,
+  SetKenwoodRIT, SetKenwoodXIT, ClearKenwoodRIT, SetKenwoodKeySpeed, ToggleKenwoodATU, SetKenwoodRITOffset, SetKenwoodPanelMode,
   GetCATState,
 } from '../../wailsjs/go/main/App';
 import { cn } from '@/lib/utils';
 import { useI18n } from '@/lib/i18n';
 import { sMeterRST } from '@/lib/rst';
+import { ShiftRow } from '@/components/ShiftRow';
 import { MeterBar } from '@/components/MeterBar';
 import { WheelRange } from '@/components/WheelRange';
 
 type KenwoodState = {
-  available: boolean; model?: string; elecraft: boolean; mode?: string;
+  available: boolean; model?: string; elecraft: boolean; mode?: string; data_sub?: string;
   transmitting: boolean; split: boolean; split_tx_hz?: number;
   s_meter: number; s_meter_raw: number;
   power_meter: number; swr: number; swr_raw: number;
@@ -89,9 +90,34 @@ function Toggle({ label, on, off, onClick }: { label: string; on: boolean; off:
   );
 }
 
+// isDataMode: what the rig reports for MD6 varies — "DATA", or the configured
+// digital default (FT8…) — so the DATA family is "not one of the native modes".
+function isDataMode(m?: string): boolean {
+  switch ((m ?? '').toUpperCase()) {
+    case '': case 'CW': case 'USB': case 'LSB': case 'SSB': case 'FM': case 'AM': case 'RTTY':
+      return false;
+  }
+  return true;
+}
+
 export function ElecraftPanel({ onReportRST }: { onReportRST?: (rst: string) => void }) {
   const { t } = useI18n();
   const [st, setSt] = useState<KenwoodState>(ZERO);
+  // Ctrl+Left/Right shifts the RIT by ±10 Hz while RIT is on — the same
+  // keyboard clarifier the Icom and TCI consoles have, for zero-beating a
+  // caller without touching the mouse.
+  const stRef = useRef(st); stRef.current = st;
+  useEffect(() => {
+    const onKey = (e: KeyboardEvent) => {
+      if (!e.ctrlKey || (e.key !== 'ArrowLeft' && e.key !== 'ArrowRight')) return;
+      const v = stRef.current;
+      if (!v.available || !v.rit) return;
+      e.preventDefault();
+      SetKenwoodRITOffset((v.rit_offset || 0) + (e.key === 'ArrowRight' ? 10 : -10)).catch(() => {});
+    };
+    window.addEventListener('keydown', onKey);
+    return () => window.removeEventListener('keydown', onKey);
+  }, []);
   const [freqHz, setFreqHz] = useState(0);
   const [err, setErr] = useState('');
   // Optimistic overlay: a slider must follow the finger, not the poll. Dropped
@@ -149,6 +175,28 @@ export function ElecraftPanel({ onReportRST }: { onReportRST?: (rst: string) =>
             {freqHz > 0 ? (freqHz / 1e6).toFixed(6) : '—'}
           </div>
         </div>
+        {/* Mode row. The two DATA buttons are why it exists: MD6 alone keeps
+            whatever submode the last session left, and a K3 "in DATA" with FSK D
+            still armed keys FT8 with no audio. DATA sends MD6+DT0 (DATA A, the
+            soundcard path), RTTY sends MD6+DT2 (FSK D). The active DATA button
+            follows the rig's own DT answer. */}
+        <div className="inline-flex rounded-md border border-border overflow-hidden">
+          {([
+            ['CW', 'CW', view.mode === 'CW'],
+            ['USB', 'USB', view.mode === 'USB'],
+            ['LSB', 'LSB', view.mode === 'LSB'],
+            ['DATA', t('k3.modeData'), isDataMode(view.mode) && view.data_sub !== 'FSK D' && view.data_sub !== 'PSK D'],
+            ['RTTY', t('k3.modeRtty'), (isDataMode(view.mode) && (view.data_sub === 'FSK D' || view.data_sub === 'PSK D')) || view.mode === 'RTTY'],
+          ] as [string, string, boolean][]).map(([cmd, label, on]) => (
+            <button key={cmd} type="button" disabled={off}
+              title={cmd === 'DATA' ? t('k3.modeDataHint') : cmd === 'RTTY' ? t('k3.modeRttyHint') : label}
+              onClick={() => SetKenwoodPanelMode(cmd).catch((e: any) => setErr(String(e?.message ?? e)))}
+              className={cn('px-2.5 py-1.5 text-xs font-bold border-l border-border first:border-l-0',
+                on ? 'bg-primary text-primary-foreground' : 'bg-card text-muted-foreground hover:bg-muted')}>
+              {label}
+            </button>
+          ))}
+        </div>
         <button type="button" className="text-[11px] text-muted-foreground hover:text-foreground flex items-center gap-1"
           onClick={() => RefreshKenwood().catch(() => {})} title={t('k3.refreshHint')}>
           <SlidersHorizontal className="size-3.5" />
@@ -216,7 +264,7 @@ export function ElecraftPanel({ onReportRST }: { onReportRST?: (rst: string) =>
       <div className="grid grid-cols-1 lg:grid-cols-2 gap-x-6 gap-y-2">
         <label className="flex items-center gap-2 text-xs">
           <span className="w-16 shrink-0 text-muted-foreground">{t('k3.power')}</span>
-          <WheelRange min={0} max={110} step={5} disabled={off}
+          <WheelRange min={0} max={110} step={1} disabled={off}
             value={view.rf_power ?? 0}
             onChange={(n) => put({ rf_power: n }, () => SetKenwoodPower(n))} />
           <span className="w-12 text-right font-mono tabular-nums">{view.rf_power ?? 0} W</span>
@@ -279,21 +327,18 @@ export function ElecraftPanel({ onReportRST }: { onReportRST?: (rst: string) =>
           ))}
         </div>
 
-        {/* RIT / XIT. Clear zeroes both offsets at once — the radio's own RC,
-            and what an operator means by "clear it". */}
+        {/* RIT / XIT — the shared ShiftRow, exactly as the Icom and TCI consoles
+            drive theirs: ± / wheel / type, Ctrl+←/→ while RIT is on. The K3 has
+            ONE offset for both, so both rows show it, like the Icom's. */}
+        <div className="space-y-1.5">
+          <ShiftRow label="RIT" accent="#8b5cf6" on={view.rit} hz={view.rit_offset || 0} disabled={off}
+            onToggle={() => SetKenwoodRIT(!view.rit).catch(setErrMsg)}
+            onSet={(hz) => SetKenwoodRITOffset(hz).catch(setErrMsg)} />
+          <ShiftRow label="XIT" accent="#f59e0b" on={view.xit} hz={view.rit_offset || 0} disabled={off}
+            onToggle={() => SetKenwoodXIT(!view.xit).catch(setErrMsg)}
+            onSet={(hz) => SetKenwoodRITOffset(hz).catch(setErrMsg)} />
+        </div>
         <div className="flex flex-wrap items-center gap-1.5">
-          <Toggle label="RIT" on={view.rit} off={off} onClick={() => SetKenwoodRIT(!view.rit).catch(setErrMsg)} />
-          <Toggle label="XIT" on={view.xit} off={off} onClick={() => SetKenwoodXIT(!view.xit).catch(setErrMsg)} />
-          {/* The offset itself. A lit RIT button says the feature is on and
-              nothing about where it has put the receiver. */}
-          {[-100, -10, 10, 100].map((d) => (
-            <Toggle key={d} label={(d > 0 ? '+' : '') + d} on={false} off={off}
-              onClick={() => NudgeKenwoodRIT(d).catch(setErrMsg)} />
-          ))}
-          <span className="text-[11px] font-mono tabular-nums text-muted-foreground w-16">
-            {view.rit_offset > 0 ? '+' : ''}{view.rit_offset || 0} Hz
-          </span>
-          <Toggle label={t('k3.clear')} on={false} off={off} onClick={() => ClearKenwoodRIT().catch(setErrMsg)} />
           {/* Antenna only when the radio answered AN — a K3 without the internal
               ATU has one socket and no switch to offer. */}
           {view.antenna > 0 && (<>

frontend/src/components/SettingsModal.tsx

@@ -81,6 +81,7 @@ import {
 import { cn } from '@/lib/utils';
 import { writeUiPref } from '@/lib/uiPref';
 import { setUseMiles } from '@/lib/units';
+import { iaruRegion, setIaruRegion, type IaruRegion } from '@/lib/bandplan';
 import { getDateFormat, setDateFormat, type DateFormat } from '@/lib/dateFormat';
 import { useI18n, FlagGB, FlagFR, type Lang } from '@/lib/i18n';
 import { useTheme, CONCRETE_THEMES, type ThemeChoice } from '@/lib/theme';
@@ -689,8 +690,7 @@ function TelemetryToggle() {
     <label className="flex items-center gap-2 text-sm cursor-pointer">
       <Checkbox checked={on} disabled={!loaded}
         onCheckedChange={(c) => { const v = !!c; setOn(v); SetTelemetryEnabled(v).catch(() => {}); }} />
-      {t('settings.telemetry')}
-      <span className="text-xs text-muted-foreground">({t('settings.telemetryHint')})</span>
+      <span title={t('settings.telemetryHint')}>{t('settings.telemetry')}</span>
     </label>
   );
 }
@@ -1086,7 +1086,7 @@ function RelayAutoPanel() {
 // panes. The first two are the view; the third and fourth can be left empty, and
 // an empty one is not drawn at all. Per-profile (stored via SetUIPref, which is
 // profile-prefixed). Self-contained so it owns its async-loaded state.
-const MAIN_PANE_VALUES = ['map1', 'map2', 'cluster', 'worked', 'recent', 'netcontrol', 'decodes'];
+const MAIN_PANE_VALUES = ['map1', 'map2', 'cluster', 'worked', 'recent', 'netcontrol', 'decodes', 'watchlist'];
 const PANE_NONE = 'none';
 function MainViewPanes({ onChanged, flexAvailable, icomAvailable, yaesuAvailable, elecraftAvailable, tciAvailable }: { onChanged?: (side: 'left' | 'right' | 'p3' | 'p4' | 'layout', value: string) => void; flexAvailable?: boolean; icomAvailable?: boolean; yaesuAvailable?: boolean; elecraftAvailable?: boolean; tciAvailable?: boolean }) {
   const { t } = useI18n();
@@ -1749,6 +1749,7 @@ function SettingsModalImpl({ onClose, onSaved, initialSection, onMainPaneChanged
   const [lookupOnBlur, setLookupOnBlur] = useState(() => localStorage.getItem('opslog.lookupOnBlur') === '1');
   const [groupDigital, setGroupDigital] = useState(() => localStorage.getItem('opslog.groupDigitalSlots') === '1');
   const [milesUnit, setMilesUnit] = useState(() => localStorage.getItem('opslog.distanceMiles') === '1');
+  const [region, setRegion] = useState<IaruRegion>(() => iaruRegion());
   const [clusterWorkedSameSlot, setClusterWorkedSameSlot] = useState(() => localStorage.getItem('opslog.clusterWorkedSameSlot') === '1');
   // Declared HERE and not in ClusterPanel: that renderer is called as a plain
   // function by the PANELS map, so it must stay hooks-free.
@@ -2067,6 +2068,8 @@ function SettingsModalImpl({ onClose, onSaved, initialSection, onMainPaneChanged
     try { await SaveGridScopeSettings(next); } catch { /* the panel keeps the choice either way */ }
   };
   const [chaseGrids, setChaseGrids] = useState(false);
+  const [chasePotaOn, setChasePotaOn] = useState(() => localStorage.getItem('opslog.chasePota') !== '0');
+  const [chaseSotaOn, setChaseSotaOn] = useState(() => localStorage.getItem('opslog.chaseSota') !== '0');
   const [chaseNew, setChaseNew] = useState(false);
   const [spotTTL, setSpotTTL] = useState(0);
   const [spotTTLText, setSpotTTLText] = useState('0');
@@ -5313,11 +5316,6 @@ function SettingsModalImpl({ onClose, onSaved, initialSection, onMainPaneChanged
               ))}
             </div>
           </div>
-          <p className="text-xs text-muted-foreground">
-            {t('clu.freeNodes')} <span className="font-mono">dxc.k0xm.net:7300</span>,{' '}
-            <span className="font-mono">dx.maritimecontestclub.net:7300</span>,{' '}
-            <span className="font-mono">w8avi.net:7300</span>.
-          </p>
           <label className="flex items-start gap-2 text-sm cursor-pointer border-t border-border/60 pt-3">
             <Checkbox checked={clusterWorkedSameSlot} className="mt-0.5"
               onCheckedChange={(c) => { const v = !!c; setClusterWorkedSameSlot(v); writeUiPref('opslog.clusterWorkedSameSlot', v ? '1' : '0'); }} />
@@ -5379,11 +5377,24 @@ function SettingsModalImpl({ onClose, onSaved, initialSection, onMainPaneChanged
                   const n = parseInt(raw, 10);
                   if (Number.isFinite(n) && n > 0) SetSpotMax(Math.min(10000, n)).catch(() => {});
                 }} />
-              <span className="text-xs text-muted-foreground">{t('clu.spotMaxHint')}</span>
+
             </div>
           </div>
 
           <div className="border-t border-border/60 pt-3 space-y-2">
+            {/* Chase switches: off, the marker stops being TOLD, everywhere at
+                once — badge, colour, filter chip, reference column. A "new band
+                + new POTA" spot then reads NEW BAND alone. */}
+            <label className="flex items-center gap-2 text-sm cursor-pointer" title={t('clu.chasePotaHint')}>
+              <Checkbox checked={chasePotaOn}
+                onCheckedChange={(c) => { const v = !!c; setChasePotaOn(v); writeUiPref('opslog.chasePota', v ? '1' : '0'); }} />
+              {t('clu.chasePota')}
+            </label>
+            <label className="flex items-center gap-2 text-sm cursor-pointer" title={t('clu.chaseSotaHint')}>
+              <Checkbox checked={chaseSotaOn}
+                onCheckedChange={(c) => { const v = !!c; setChaseSotaOn(v); writeUiPref('opslog.chaseSota', v ? '1' : '0'); }} />
+              {t('clu.chaseSota')}
+            </label>
             <label className="flex items-start gap-2 text-sm cursor-pointer">
               <Checkbox checked={chaseGrids} className="mt-0.5"
                 onCheckedChange={(c) => { setChaseGrids(!!c); SetChaseNewGrids(!!c).catch(() => {}); }} />
@@ -6777,7 +6788,7 @@ function SettingsModalImpl({ onClose, onSaved, initialSection, onMainPaneChanged
               useLocalLogbook(); // SQLite → default logbook file (clears any per-profile path)
             }}
           >
-            <SelectTrigger className="h-8 w-72"><SelectValue /></SelectTrigger>
+            <SelectTrigger className="h-8 w-72" title={t('gen.iaruHint')}><SelectValue /></SelectTrigger>
             <SelectContent>
               <SelectItem value="sqlite">{t('db.optSqlite')}</SelectItem>
               <SelectItem value="mysql">{t('db.optMysql')}</SelectItem>
@@ -7147,7 +7158,7 @@ function SettingsModalImpl({ onClose, onSaved, initialSection, onMainPaneChanged
     const { lang, setLang, t } = useI18n();
     return (
       <>
-        <SectionHeader title={t('sec.general')} hint={t('gen.hint')} />
+        <SectionHeader title={t('sec.general')} />
         <div className="space-y-3 max-w-3xl">
           <div className="flex items-center gap-3">
             <Label className="text-sm w-40">{t('settings.language')}</Label>
@@ -7175,15 +7186,32 @@ function SettingsModalImpl({ onClose, onSaved, initialSection, onMainPaneChanged
                  ['us', t('gen.dateUS'), '07-30-2026 14:25']] as [DateFormat, string, string][]).map(([code, label, sample]) => (
                 <button key={code} type="button" title={sample}
                   onClick={() => { setDateFormat(code); setDateFmtSel(code); }}
-                  className={cn('flex flex-col items-start px-3 py-1 text-sm font-medium border-l border-border first:border-l-0',
+                  className={cn('px-3 py-1.5 text-sm font-medium border-l border-border first:border-l-0',
                     dateFmtSel === code ? 'bg-primary text-primary-foreground' : 'bg-card text-muted-foreground hover:bg-muted')}>
                   {label}
-                  <span className="text-[10px] font-mono opacity-70">{sample}</span>
                 </button>
               ))}
             </div>
           </div>
 
+          <div className="flex items-center gap-2 text-sm">
+            {/* The IARU region drives the band edges and mode segments the band
+                maps draw — Region 2's 40 m runs to 7300, Region 1's stops at
+                7200 — and nothing else: spots and logging are region-blind. */}
+            <Label className="text-sm w-40 shrink-0">{t('gen.iaruRegion')}</Label>
+            <Select value={String(region)} onValueChange={(v) => {
+              const r = (v === '2' ? 2 : v === '3' ? 3 : 1) as IaruRegion;
+              setRegion(r); setIaruRegion(r);
+            }}>
+              <SelectTrigger className="h-8 w-72"><SelectValue /></SelectTrigger>
+              <SelectContent>
+                <SelectItem value="1">{t('gen.iaruR1')}</SelectItem>
+                <SelectItem value="2">{t('gen.iaruR2')}</SelectItem>
+                <SelectItem value="3">{t('gen.iaruR3')}</SelectItem>
+              </SelectContent>
+            </Select>
+          </div>
+
           <ThemeSelector />
 
           <label className="flex items-center gap-2 text-sm cursor-pointer">
@@ -7205,11 +7233,10 @@ function SettingsModalImpl({ onClose, onSaved, initialSection, onMainPaneChanged
           {/* Super Check Partial / N+1 — downloads the community MASTER.SCP list and
               shows a two-column callsign helper (partial matches + one-edit calls). */}
           <div className="border-t border-border/60 pt-3 space-y-2">
-            <label className="flex items-center gap-2 text-sm cursor-pointer">
+            <label className="flex items-center gap-2 text-sm cursor-pointer" title={t('scp.settingsHint')}>
               <Checkbox checked={scp.enabled} disabled={scpBusy} onCheckedChange={(c) => toggleScp(!!c)} />
               {t('scp.enable')}
             </label>
-            <p className="text-[11px] text-muted-foreground">{t('scp.settingsHint')}</p>
             {scp.enabled && (
               <div className="flex items-center gap-3">
                 <Button variant="outline" size="sm" onClick={downloadScp} disabled={scpBusy}>
@@ -7237,18 +7264,18 @@ function SettingsModalImpl({ onClose, onSaved, initialSection, onMainPaneChanged
           </label>
           <label className="flex items-center gap-2 text-sm cursor-pointer">
             <Checkbox checked={groupDigital} onCheckedChange={(c) => { const v = !!c; setGroupDigital(v); writeUiPref('opslog.groupDigitalSlots', v ? '1' : '0'); }} />
-            {t('gen.groupDigital')} <span className="text-xs text-muted-foreground">{t('gen.groupDigitalHint')}</span>
+            <span title={t('gen.groupDigitalHint')}>{t('gen.groupDigital')}</span>
           </label>
           <label className="flex items-center gap-2 text-sm cursor-pointer">
             {/* Distances are computed in km everywhere and converted at display
                 time — see lib/units. Changing this repaints the columns that
                 already carry a distance; nothing stored moves. */}
             <Checkbox checked={milesUnit} onCheckedChange={(c) => { const v = !!c; setMilesUnit(v); setUseMiles(v); }} />
-            {t('gen.miles')} <span className="text-xs text-muted-foreground">{t('gen.milesHint')}</span>
+            {t('gen.miles')}
           </label>
           <label className="flex items-center gap-2 text-sm cursor-pointer">
             <Checkbox checked={checkUpdates} onCheckedChange={(c) => { const v = !!c; setCheckUpdates(v); writeUiPref('opslog.checkUpdates', v ? '1' : '0'); }} />
-            {t('gen.checkUpdates')} <span className="text-xs text-muted-foreground">{t('gen.checkUpdatesHint')}</span>
+            {t('gen.checkUpdates')}
           </label>
           <TelemetryToggle />
 
@@ -7311,12 +7338,7 @@ function SettingsModalImpl({ onClose, onSaved, initialSection, onMainPaneChanged
                 }}
                 className="mt-0.5"
               />
-              <span>
-                {t('gen.clubUse')}
-                <span className="block text-xs text-muted-foreground mt-0.5">
-                  {t('gen.clubDesc')}
-                </span>
-              </span>
+              <span title={t('gen.clubDesc')}>{t('gen.clubUse')}</span>
             </label>
             <div className="flex items-center gap-3 pl-6">
               <Button variant="outline" size="sm" className="h-8" disabled={clubBusy}

frontend/src/components/WatchlistTab.tsx

@@ -0,0 +1,417 @@
+// Watchlist — the DXHunter concept as an OpsLog tab.
+//
+// One card per watched callsign (or prefix), the live spots that match it
+// underneath, and the two questions an operator actually asks answered on every
+// line: is this slot still NEEDED, and what would it be worth (the same NEW
+// DXCC / band / mode / slot badges the cluster shows, resolved from the same
+// index). A CONTEST entry is judged against the current UTC day — at midnight
+// everything reads "work today" again; the boundary lives in the backend query,
+// so there is nothing to reset.
+//
+// The design is DXHunter's — the layout, the badges, the wording — repainted in
+// the app's theme tokens rather than its hard-coded slate/pink.
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { Eye, Plus, Trash2, Bell, BellOff, Trophy, Search } from 'lucide-react';
+import { Button } from '@/components/ui/button';
+import { Input } from '@/components/ui/input';
+import { Checkbox } from '@/components/ui/checkbox';
+import { cn } from '@/lib/utils';
+import { useI18n } from '@/lib/i18n';
+import {
+  WatchlistEntries, WatchlistAdd, WatchlistRemove, WatchlistSetNotify,
+  WatchlistSetContest, WatchlistWorkedSlots,
+  GetWatchlistContestPattern, SetWatchlistContestPattern, OpenExternalURL,
+} from '../../wailsjs/go/main/App';
+import { EventsOn } from '../../wailsjs/runtime/runtime';
+import type { ClusterSpot, SpotStatusEntry } from '@/components/ClusterGrid';
+import { inferSpotMode, spotStatusKey } from '@/lib/spot';
+
+interface WLEntry {
+  callsign: string; lastSeenStr: string; addedAt: string; spotCount: number;
+  isContest: boolean; notify: boolean;
+  isExpedition: boolean; clubLogQSOs24h: number; clubLogTotalQSOs: number;
+  clubLogHasOQRS: boolean; clubLogLiveStream: boolean;
+}
+
+interface Props {
+  spots: ClusterSpot[];
+  spotStatus: Record<string, SpotStatusEntry>;
+  onSpotSelect?: (s: ClusterSpot) => void;
+  onSpotClick?: (s: ClusterSpot) => void;
+}
+
+// A spot is ON AIR for the badge while its last sighting is this fresh.
+const ON_AIR_MS = 10 * 60 * 1000;
+
+// Exact unless the entry carries a trailing * — the same rule the backend's
+// Match applies to the live stream, mirrored so the tab and the alerts can
+// never disagree about what an entry covers.
+function matchesEntry(call: string, pattern: string): boolean {
+  const c = call.toUpperCase();
+  if (pattern.endsWith('*')) {
+    const p = pattern.slice(0, -1);
+    return p !== '' && c.startsWith(p);
+  }
+  return c === pattern;
+}
+
+export function WatchlistTab({ spots, spotStatus, onSpotSelect, onSpotClick }: Props) {
+  const { t } = useI18n();
+  const [entries, setEntries] = useState<WLEntry[]>([]);
+  const [addCall, setAddCall] = useState('');
+  const [addContest, setAddContest] = useState(false);
+  const [search, setSearch] = useState('');
+  // The filters survive leaving the tab: the component unmounts on every tab
+  // switch, and filters that reset each time are filters nobody trusts.
+  const [neededOnly, setNeededOnlyRaw] = useState(() => localStorage.getItem('opslog.wlNeededOnly') === '1');
+  const [activeOnly, setActiveOnlyRaw] = useState(() => localStorage.getItem('opslog.wlActiveOnly') === '1');
+  const [family, setFamilyRaw] = useState<'all' | 'normal' | 'contest'>(() => {
+    const v = localStorage.getItem('opslog.wlFamily');
+    return v === 'normal' || v === 'contest' ? v : 'all';
+  });
+  const setNeededOnly = (f: (v: boolean) => boolean) => setNeededOnlyRaw((v) => { const nv = f(v); try { localStorage.setItem('opslog.wlNeededOnly', nv ? '1' : '0'); } catch {} return nv; });
+  const setActiveOnly = (f: (v: boolean) => boolean) => setActiveOnlyRaw((v) => { const nv = f(v); try { localStorage.setItem('opslog.wlActiveOnly', nv ? '1' : '0'); } catch {} return nv; });
+  const setFamily = (v: 'all' | 'normal' | 'contest') => { setFamilyRaw(v); try { localStorage.setItem('opslog.wlFamily', v); } catch {} };
+  // Mode filter — DXHunter's "All Modes" select. DIGI matches the digital class
+  // (FT8, FT4, a generic DATA spot…), the named modes match exactly.
+  const [modeFilter, setModeFilterRaw] = useState(() => localStorage.getItem('opslog.wlMode') || 'ALL');
+  const setModeFilter = (v: string) => { setModeFilterRaw(v); try { localStorage.setItem('opslog.wlMode', v); } catch {} };
+  const modeMatches = (s2: ClusterSpot): boolean => {
+    if (modeFilter === 'ALL') return true;
+    const m = (inferSpotMode(s2.comment ?? '', s2.freq_hz) || '').toUpperCase();
+    if (modeFilter === 'DIGI') return !['', 'CW', 'SSB', 'USB', 'LSB', 'FM', 'AM'].includes(m);
+    if (modeFilter === 'SSB') return m === 'SSB' || m === 'USB' || m === 'LSB';
+    return m === modeFilter;
+  };
+  const [error, setError] = useState('');
+  // A quiet confirmation under the toolbar; both messages clear themselves —
+  // a stale "added" from ten minutes ago reads as a fresh one.
+  const [notice, setNotice] = useState('');
+  const noticeTimer = useRef<number | undefined>(undefined);
+  const flash = (msg: string, isError: boolean) => {
+    if (noticeTimer.current) window.clearTimeout(noticeTimer.current);
+    setError(isError ? msg : '');
+    setNotice(isError ? '' : msg);
+    noticeTimer.current = window.setTimeout(() => { setError(''); setNotice(''); }, 4000) as unknown as number;
+  };
+
+  // worked answer per "call|band|modeclass|contest" key.
+  const [worked, setWorked] = useState<Record<string, boolean>>({});
+
+  const refresh = useCallback(async () => {
+    try { setEntries(((await WatchlistEntries()) ?? []) as any as WLEntry[]); }
+    catch (e: any) { setError(String(e?.message ?? e)); }
+  }, []);
+  // Refreshed on mount, when the backend auto-adds (event), and on a slow tick
+  // so last-seen and the spot counters stay honest while the tab sits open.
+  useEffect(() => {
+    void refresh();
+    const off = EventsOn('watchlist:changed', () => { void refresh(); });
+    const id = window.setInterval(() => { void refresh(); }, 30_000);
+    return () => { off(); window.clearInterval(id); };
+  }, [refresh]);
+  // The auto-contest pattern (DXHunter's contest_prefix): spots whose call
+  // contains it are added as contest entries by the backend.
+  const [pattern, setPattern] = useState('');
+  useEffect(() => { GetWatchlistContestPattern().then((p: string) => setPattern(p ?? '')).catch(() => {}); }, []);
+
+  // Live spots per entry — prefix-matched, newest first, deduped per band+mode
+  // (one line per slot; the freshest spot represents it).
+  const spotsFor = useMemo(() => {
+    const map = new Map<string, ClusterSpot[]>();
+    for (const e of entries) map.set(e.callsign, []);
+    for (const s of spots) {
+      for (const e of entries) {
+        if (matchesEntry(s.dx_call ?? '', e.callsign)) { map.get(e.callsign)!.push(s); break; }
+      }
+    }
+    for (const [k, list] of map) {
+      const seen = new Set<string>();
+      map.set(k, list.filter((s) => {
+        const key = `${(s.band ?? '')}|${inferSpotMode(s.comment ?? '', s.freq_hz)}|${s.dx_call}`;
+        if (seen.has(key)) return false;
+        seen.add(key);
+        return true;
+      }));
+    }
+    return map;
+  }, [spots, entries]);
+
+  // The worked answers, refreshed when the visible slots change. Debounced: a
+  // spot burst must cost one round trip, not one per spot.
+  const queryTimer = useRef<number | undefined>(undefined);
+  useEffect(() => {
+    if (queryTimer.current) window.clearTimeout(queryTimer.current);
+    queryTimer.current = window.setTimeout(async () => {
+      const queries: { call: string; band: string; mode: string; contest: boolean }[] = [];
+      const keys: string[] = [];
+      for (const e of entries) {
+        for (const s of spotsFor.get(e.callsign) ?? []) {
+          const mode = inferSpotMode(s.comment ?? '', s.freq_hz) || '';
+          queries.push({ call: s.dx_call, band: s.band ?? '', mode, contest: e.isContest });
+          keys.push(`${s.dx_call}|${s.band ?? ''}|${mode}|${e.isContest ? 1 : 0}`);
+        }
+      }
+      if (queries.length === 0) { setWorked({}); return; }
+      try {
+        const res: boolean[] = (await WatchlistWorkedSlots(queries as any)) ?? [];
+        // MERGED, not replaced: replacing made every already-answered key
+        // momentarily unknown on each refresh, which re-hid settled lines.
+        setWorked((prev) => {
+          const next = { ...prev };
+          keys.forEach((k, i) => { next[k] = !!res[i]; });
+          return next;
+        });
+      } catch { /* the badges just stay conservative */ }
+    }, 150) as unknown as number;
+    return () => { if (queryTimer.current) window.clearTimeout(queryTimer.current); };
+  }, [spotsFor, entries]);
+
+  const wkey = (e: WLEntry, s: ClusterSpot) =>
+    `${s.dx_call}|${s.band ?? ''}|${inferSpotMode(s.comment ?? '', s.freq_hz) || ''}|${e.isContest ? 1 : 0}`;
+  const workedFor = (e: WLEntry, s: ClusterSpot): boolean => worked[wkey(e, s)] ?? false;
+  // A spot whose verdict has not come back yet is NOT drawn. Showing it as
+  // Needed and withdrawing it half a second later made the list twitch on
+  // every burst — and nobody needs a spot 400 ms early, they need it settled.
+  const settled = (e: WLEntry, s: ClusterSpot): boolean => wkey(e, s) in worked;
+
+  const add = async () => {
+    const c = addCall.trim().toUpperCase();
+    if (!c) return;
+    try {
+      await WatchlistAdd(c, addContest);
+      setAddCall('');
+      flash(t(addContest ? 'wl.addedContest' : 'wl.added', { call: c }), false);
+      await refresh();
+    } catch (e: any) { flash(String(e?.message ?? e), true); }
+  };
+
+  // One click, like the bell and the trophy beside it: removing a watchlist
+  // entry is cheap to undo (type it again), so it does not earn a confirmation
+  // the other two buttons do not have.
+  const remove = async (call: string) => {
+    try { await WatchlistRemove(call); flash(t('wl.removed', { call }), false); await refresh(); }
+    catch (e: any) { flash(String(e?.message ?? e), true); }
+  };
+
+  const isOnAir = (e: WLEntry): boolean =>
+    (spotsFor.get(e.callsign) ?? []).some((s) => {
+      const ts = Date.parse(String((s as any).received_at ?? ''));
+      return ts > 0 && Date.now() - ts < ON_AIR_MS;
+    });
+
+  const shown = entries.filter((e) => {
+    if (family === 'normal' && e.isContest) return false;
+    if (family === 'contest' && !e.isContest) return false;
+    if (search && !e.callsign.includes(search.trim().toUpperCase())) return false;
+    const list = (spotsFor.get(e.callsign) ?? []).filter(modeMatches).filter((s2) => settled(e, s2));
+    if (activeOnly && list.length === 0) return false;
+    if (neededOnly && !list.some((s2) => !workedFor(e, s2))) return false;
+    return true;
+  });
+
+  const counters = useMemo(() => {
+    let active = 0, needed = 0;
+    for (const e of entries) {
+      const list = (spotsFor.get(e.callsign) ?? []).filter(modeMatches).filter((s2) => settled(e, s2));
+      if (list.length > 0) active++;
+      if (list.some((s2) => !workedFor(e, s2))) needed++;
+    }
+    return { total: entries.length, active, needed };
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [entries, spotsFor, worked, modeFilter]);
+
+  // The cluster's own badge for a spot, read from the shared status index.
+  const dxccBadge = (s: ClusterSpot): { label: string; color: string } | null => {
+    const st = spotStatus[spotStatusKey(s.dx_call, s.band ?? '', s.comment ?? '', s.freq_hz)];
+    switch (st?.status) {
+      case 'new': return { label: t('wl.newDxcc'), color: 'var(--danger)' };
+      case 'new-band-mode': return { label: t('clg2.newBandMode'), color: 'var(--danger)' };
+      case 'new-band': return { label: t('clg2.newBand'), color: 'var(--warning)' };
+      case 'new-mode': return { label: t('clg2.newMode'), color: 'var(--caution)' };
+      case 'new-slot': return { label: t('clg2.newSlot'), color: '#5AC8FA' };
+      default: return null;
+    }
+  };
+
+  const chip = (color: string, text: string, extra?: string) => (
+    <span className={cn('px-1.5 py-0.5 rounded text-[10px] font-bold border', extra)}
+      style={{ color, borderColor: `color-mix(in srgb, ${color} 40%, transparent)`, background: `color-mix(in srgb, ${color} 12%, transparent)` }}>
+      {text}
+    </span>
+  );
+
+  return (
+    // Capped and centred: a card is a reading surface, and callsign-to-badge
+    // lines stretched across a 34-inch window are not readable, they are long.
+    <div className="flex flex-col min-h-0 flex-1 gap-2 p-2 w-full max-w-5xl mx-auto">
+      {/* Header: the counters alone, centred — they are the tab's headline.
+          Everything one INTERACTS with lives on the second row. */}
+      <div className="flex items-center justify-center gap-2 text-sm text-muted-foreground">
+        <Eye className="size-4 text-primary shrink-0" />
+        <span>
+          {t('wl.cTotal')} <b className="text-foreground">{counters.total}</b>
+          <span className="mx-1.5 opacity-50">|</span>
+          {t('wl.cActive')} <b className="text-info">{counters.active}</b>
+          <span className="mx-1.5 opacity-50">|</span>
+          {t('wl.cNeeded')} <b className="text-warning">{counters.needed}</b>
+        </span>
+      </div>
+      {/* toolbar */}
+      <div className="flex items-start justify-between gap-x-3 gap-y-1.5 flex-wrap">
+        <div className="flex items-center gap-2 shrink-0">
+        <Input className="h-8 w-40 font-mono placeholder:font-sans placeholder:normal-case" placeholder={t('wl.addPh')} value={addCall}
+          onChange={(e) => setAddCall(e.target.value.toUpperCase())}
+          onKeyDown={(e) => { if (e.key === 'Enter') void add(); }} />
+        <label className="flex items-center gap-1.5 text-xs cursor-pointer" title={t('wl.contestHint')}>
+          <Checkbox checked={addContest} onCheckedChange={(c) => setAddContest(!!c)} />
+          <Trophy className="size-3.5 text-warning" /> {t('wl.addAsContest')}
+        </label>
+        <Button size="sm" className="h-8" onClick={() => void add()} disabled={!addCall.trim()}>
+          <Plus className="size-3.5" /> {t('wl.add')}
+        </Button>
+        <Input className="h-8 w-28 font-mono placeholder:font-sans placeholder:normal-case" placeholder={t('wl.patternPh')}
+          title={t('wl.patternHint')}
+          value={pattern}
+          onChange={(e) => setPattern(e.target.value.toUpperCase())}
+          onBlur={() => { void SetWatchlistContestPattern(pattern.trim()); }} />
+        </div>
+        <div className="flex items-center gap-2 shrink-0">
+        <div className="relative">
+          <Search className="size-3.5 absolute left-2 top-1/2 -translate-y-1/2 text-muted-foreground" />
+          <Input className="h-8 w-28 pl-7 text-sm" placeholder={t('wl.searchPh')} value={search}
+            onChange={(e) => setSearch(e.target.value)} />
+        </div>
+        {/* families kept together, told apart — per review of the DXHunter port,
+            no global contest mode: each entry carries its own rule. */}
+        <div className="inline-flex rounded-md border border-border overflow-hidden text-xs">
+          {([['all', t('wl.famAll')], ['normal', t('wl.famNormal')], ['contest', t('wl.famContest')]] as const).map(([k, label]) => (
+            <button key={k} type="button" onClick={() => setFamily(k)}
+              className={cn('px-2 py-1 border-l border-border first:border-l-0',
+                family === k ? 'bg-accent font-medium' : 'text-muted-foreground hover:bg-accent/50')}>
+              {label}
+            </button>
+          ))}
+        </div>
+        <select value={modeFilter} onChange={(e) => setModeFilter(e.target.value)}
+          title={t('wl.modeFilter')}
+          className="h-7 px-1.5 rounded-md border border-border bg-background text-xs text-foreground">
+          {['ALL', 'CW', 'SSB', 'FT8', 'FT4', 'RTTY', 'DIGI'].map((m) => (
+            <option key={m} value={m}>{m === 'ALL' ? t('wl.allModes') : m}</option>
+          ))}
+        </select>
+        <button type="button" onClick={() => setActiveOnly((v) => !v)}
+          className={cn('px-2 py-1 rounded-md border text-xs', activeOnly ? 'bg-accent border-border font-medium' : 'border-border text-muted-foreground hover:bg-accent/50')}>
+          {t('wl.activeOnly')}
+        </button>
+        <button type="button" onClick={() => setNeededOnly((v) => !v)}
+          className={cn('px-2 py-1 rounded-md border text-xs', neededOnly ? 'bg-accent border-border font-medium' : 'border-border text-muted-foreground hover:bg-accent/50')}>
+          {t('wl.neededOnly')}
+        </button>
+        </div>
+      </div>
+      {error && <div className="text-xs text-danger px-1">{error}</div>}
+      {notice && <div className="text-xs text-success px-1">{notice}</div>}
+
+      {/* cards */}
+      <div className="flex-1 min-h-0 overflow-y-auto space-y-2 pr-1">
+        {shown.length === 0 ? (
+          <div className="text-sm text-muted-foreground text-center pt-16 max-w-md mx-auto leading-relaxed">
+            {entries.length === 0 ? t('wl.empty') : t('wl.noneMatch')}
+          </div>
+        ) : shown.map((e) => {
+          const all = (spotsFor.get(e.callsign) ?? []).filter(modeMatches).filter((s2) => settled(e, s2));
+          const needed = all.filter((s) => !workedFor(e, s)).length;
+          // Needed-only hides the worked LINES as well as the all-worked cards:
+          // a filter that says needed and still lists five green Worked rows is
+          // answering a different question than the one asked.
+          const list = neededOnly ? all.filter((s) => !workedFor(e, s)) : all;
+          return (
+            <div key={e.callsign}
+              className={cn('rounded-lg border bg-card p-3',
+                needed > 0 ? 'border-warning/50' : 'border-border',
+                e.isContest && 'border-l-4 border-l-warning')}>
+              <div className="flex items-center gap-2 flex-wrap">
+                <span className="text-lg font-bold font-mono text-primary">{e.callsign}</span>
+                {isOnAir(e) && chip('var(--danger)', t('wl.onAir'), 'animate-pulse')}
+                {e.isContest && (
+                  <span className="inline-flex items-center gap-1 px-1.5 py-0.5 rounded text-[10px] font-bold bg-warning-muted text-warning-muted-foreground border border-warning-border"
+                    title={t('wl.contestHint')}>
+                    <Trophy className="size-3" /> {t('wl.contest')}
+                  </span>
+                )}
+                {e.isExpedition && chip('var(--chart-5)', t('wl.expedition'))}
+                {e.clubLogTotalQSOs > 0 && <span className="text-[11px] text-muted-foreground">{e.clubLogTotalQSOs.toLocaleString()} QSOs{e.clubLogQSOs24h > 0 ? ` · ${e.clubLogQSOs24h}/24h` : ''}</span>}
+                {e.clubLogHasOQRS && chip('var(--success)', 'OQRS')}
+                {e.clubLogLiveStream && (
+                  <a href="#" onClick={(ev) => { ev.preventDefault(); void OpenExternalURL(`https://clublog.org/livestream/${e.callsign.replace('*', '')}`); }}
+                    className="px-1.5 py-0.5 rounded text-[10px] font-bold border text-info border-info/40 bg-info/10 hover:bg-info/20">Live</a>
+                )}
+                {list.length > 0 && (needed > 0
+                  ? chip('var(--warning)', e.isContest ? t('wl.nToday', { n: needed }) : t('wl.nNeeded', { n: needed }))
+                  : chip('var(--success)', e.isContest ? t('wl.workedToday') : t('wl.allWorked')))}
+                {e.lastSeenStr && e.lastSeenStr !== 'Never' && (
+                  <span className="text-[11px] text-muted-foreground">· {e.lastSeenStr}</span>
+                )}
+                {e.spotCount > 0 && (
+                  <span className="text-[11px] text-muted-foreground/70">· {t('wl.totalSpots', { n: e.spotCount })}</span>
+                )}
+                <div className="flex-1" />
+                <button type="button" title={t('wl.toggleContest')}
+                  onClick={() => void WatchlistSetContest(e.callsign, !e.isContest).then(refresh)}
+                  className={cn('p-1 rounded hover:bg-muted', e.isContest ? 'text-warning' : 'text-muted-foreground/40')}>
+                  <Trophy className="size-3.5" />
+                </button>
+                <button type="button" title={e.notify ? t('wl.notifyOff') : t('wl.notifyOn')}
+                  onClick={() => void WatchlistSetNotify(e.callsign, !e.notify).then(refresh)}
+                  className={cn('p-1 rounded hover:bg-muted', e.notify ? 'text-warning' : 'text-muted-foreground/40')}>
+                  {e.notify ? <Bell className="size-3.5" /> : <BellOff className="size-3.5" />}
+                </button>
+                <button type="button" title={t('wl.remove')}
+                  onClick={() => void remove(e.callsign)}
+                  className="p-1 rounded hover:bg-muted text-muted-foreground/40 hover:text-danger">
+                  <Trash2 className="size-3.5" />
+                </button>
+              </div>
+
+              {list.length > 0 ? (
+                <div className="mt-2 space-y-1 max-h-52 overflow-y-auto">
+                  {list.slice(0, 12).map((s, i) => {
+                    const done = workedFor(e, s);
+                    const badge = dxccBadge(s);
+                    const mode = inferSpotMode(s.comment ?? '', s.freq_hz);
+                    return (
+                      <button key={i} type="button"
+                        onClick={() => onSpotSelect?.(s)}
+                        onDoubleClick={() => onSpotClick?.(s)}
+                        title={t('wl.spotTip')}
+                        className={cn('w-full flex items-center gap-2 px-2 py-1.5 rounded text-[11px] bg-muted/40 hover:bg-muted text-left',
+                          !done && 'border-l-2 border-warning')}>
+                        {done && <span className='font-bold shrink-0 text-success'>✓</span>}
+                        <span className="font-mono font-bold text-info shrink-0">{s.dx_call}</span>
+                        <span className="text-muted-foreground truncate flex-1 min-w-0 max-w-56">{(s as any).country ?? ''}</span>
+                        <span className="px-1.5 rounded bg-muted shrink-0">{s.band}</span>
+                        {mode && <span className="px-1.5 rounded shrink-0" style={{ color: 'var(--chart-5)', background: 'color-mix(in srgb, var(--chart-5) 12%, transparent)' }}>{mode}</span>}
+                        <span className="font-mono text-muted-foreground shrink-0">{(s.freq_hz / 1e6).toFixed(4)}</span>
+                        {badge && chip(badge.color, badge.label)}
+                        <div className="flex-1" />
+                        {done
+                          ? chip('var(--success)', e.isContest ? t('wl.todayOk') : t('wl.worked'))
+                          : chip('var(--warning)', e.isContest ? t('wl.workToday') : t('wl.needed'))}
+                        <span className="text-muted-foreground/70 shrink-0">{s.time_utc ?? ''}</span>
+                      </button>
+                    );
+                  })}
+                </div>
+              ) : (
+                <div className="mt-2 text-[11px] text-muted-foreground text-center py-1.5 bg-muted/30 rounded">
+                  {t('wl.noSpots')}
+                </div>
+              )}
+            </div>
+          );
+        })}
+      </div>
+    </div>
+  );
+}

frontend/src/components/labels/LabelDesignerModal.tsx

@@ -1,555 +0,0 @@
-// Label Designer — QSO labels for QSL cards and address labels for envelopes.
-//
-// Same architecture as the QSL card designer, stripped to what a monochrome
-// sticker needs: saved templates on the left, a mm-true canvas on the right,
-// click to select, drag to move. The canvas renderer (labelRender) is shared
-// with the future print path, so what the preview shows is what the PDF gets.
-import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
-import { X, Plus, Trash2, Star, Tag, MapPin } from 'lucide-react';
-import { Button } from '@/components/ui/button';
-import { Input } from '@/components/ui/input';
-import { Label } from '@/components/ui/label';
-import { Checkbox } from '@/components/ui/checkbox';
-import {
-  Select, SelectContent, SelectItem, SelectTrigger, SelectValue,
-} from '@/components/ui/select';
-import { cn } from '@/lib/utils';
-import { useI18n } from '@/lib/i18n';
-import {
-  LabelListStocks, LabelSaveStock, LabelDeleteStock,
-  LabelListTemplates, LabelGetTemplate, LabelSaveTemplate, LabelDeleteTemplate,
-  LabelSetDefaultTemplate, LabelSampleQSOs, GetActiveProfile,
-} from '../../../wailsjs/go/main/App';
-import type { LabelElement, LabelSample, LabelStock, LabelTemplate } from './labelTypes';
-import { LABEL_VARS, TABLE_FIELDS, starterTemplate } from './labelTypes';
-import { drawMargins, render, type ElementBox } from './labelRender';
-
-interface Props { open: boolean; onClose: () => void }
-
-interface TplInfo {
-  id: number; name: string; kind: string; stock_id: number;
-  is_default: boolean; updated_at: string;
-}
-
-// The preview fills whatever room the centre pane offers — a label cut off at
-// the edge cannot be judged, and 90 mm across a fixed 720 px wasted half the
-// window. Measured live so a resize re-fits.
-const PREVIEW_MIN_SCALE = 2;
-
-export function LabelDesignerModal({ open, onClose }: Props) {
-  const { t } = useI18n();
-  const [stocks, setStocks] = useState<LabelStock[]>([]);
-  const [saved, setSaved] = useState<TplInfo[]>([]);
-  const [samples, setSamples] = useState<LabelSample[]>([]);
-  const [myVars, setMyVars] = useState<Record<string, string>>({});
-  const [error, setError] = useState('');
-
-  // The design being edited (null = nothing open yet).
-  const [tplId, setTplId] = useState(0);
-  const [tpl, setTpl] = useState<LabelTemplate | null>(null);
-  const [tplName, setTplName] = useState('');
-  const [forProfile, setForProfile] = useState(true);
-  const [sel, setSel] = useState<number | null>(null);
-  const [dirty, setDirty] = useState(false);
-  const [deleteArm, setDeleteArm] = useState(0);
-
-  // Stock editor (collapsed by default — geometry is set once per roll).
-  const [stockOpen, setStockOpen] = useState(false);
-  const [stockDraft, setStockDraft] = useState<LabelStock | null>(null);
-
-  const canvasRef = useRef<HTMLCanvasElement>(null);
-  const paneRef = useRef<HTMLDivElement>(null);
-  const [paneSize, setPaneSize] = useState({ w: 720, h: 420 });
-  useEffect(() => {
-    const el = paneRef.current;
-    if (!el) return;
-    const ro = new ResizeObserver(() => {
-      setPaneSize({ w: el.clientWidth, h: el.clientHeight });
-    });
-    ro.observe(el);
-    return () => ro.disconnect();
-  }, [open, tpl != null]);
-  const boxesRef = useRef<ElementBox[]>([]);
-  const dragRef = useRef<{ idx: number; dxMm: number; dyMm: number } | null>(null);
-
-  const stock = useMemo(
-    () => stocks.find((s) => s.id === tpl?.stock_id) ?? stocks[0],
-    [stocks, tpl?.stock_id]);
-
-  const refresh = useCallback(async () => {
-    try {
-      setStocks((await LabelListStocks()) as any as LabelStock[]);
-      setSaved(((await LabelListTemplates()) ?? []) as any as TplInfo[]);
-    } catch (e: any) { setError(String(e?.message ?? e)); }
-  }, []);
-
-  useEffect(() => {
-    if (!open) return;
-    setError(''); setTpl(null); setTplId(0); setSel(null); setDirty(false);
-    void refresh();
-    LabelSampleQSOs(5).then((r: any) => setSamples(r ?? [])).catch(() => {});
-    // The preview resolves <MY*> from the active profile so the address label
-    // reads like the finished sticker, not like a form.
-    GetActiveProfile().then((p: any) => setMyVars({
-      MYCALL: p?.callsign ?? 'MYCALL', MYNAME: p?.op_name ?? p?.operator ?? '',
-      MYSTREET: p?.my_street ?? '', MYZIP: p?.my_postal_code ?? '', MYCITY: p?.my_city ?? '',
-      MYCOUNTRY: p?.my_country ?? '',
-    })).catch(() => setMyVars({ MYCALL: 'MYCALL' }));
-  }, [open, refresh]);
-
-  // Preview variable values: the first sample QSO plays the DX station.
-  const vars = useMemo(() => {
-    const q = samples[0];
-    return {
-      CALL: q?.callsign ?? 'DL1ABC', NAME: q?.name ?? 'Hans', QTH: q?.qth ?? 'Berlin',
-      COUNTRY: q?.country ?? 'Germany', VIA: 'DJ5XX',
-      STREET: 'Funkerstrasse 12', ZIP: '10115', CITY: q?.qth || 'Berlin', STATE: '',
-      ...myVars,
-    } as Record<string, string>;
-  }, [samples, myVars]);
-
-  // ── canvas ────────────────────────────────────────────────────────────
-  const scale = useMemo(() => {
-    if (!stock) return 4;
-    // Leave room for the pane's padding and the two control strips above and
-    // below the canvas; never shrink below a scale where 8 pt is readable.
-    const availW = Math.max(200, paneSize.w - 56);
-    const availH = Math.max(120, paneSize.h - 130);
-    return Math.max(PREVIEW_MIN_SCALE, Math.min(availW / stock.w_mm, availH / stock.h_mm));
-  }, [stock, paneSize]);
-
-  const paint = useCallback(() => {
-    const cv = canvasRef.current;
-    if (!cv || !tpl || !stock) return;
-    const dpr = window.devicePixelRatio || 1;
-    cv.width = Math.round(stock.w_mm * scale * dpr);
-    cv.height = Math.round(stock.h_mm * scale * dpr);
-    cv.style.width = `${stock.w_mm * scale}px`;
-    cv.style.height = `${stock.h_mm * scale}px`;
-    const ctx = cv.getContext('2d');
-    if (!ctx) return;
-    ctx.setTransform(dpr, 0, 0, dpr, 0, 0);
-    boxesRef.current = render(ctx, tpl, stock, { vars, qsos: samples }, scale);
-    drawMargins(ctx, stock, scale);
-    // Selection outline, drawn after everything: the editor's own chrome.
-    if (sel != null && boxesRef.current[sel]) {
-      const b = boxesRef.current[sel];
-      ctx.save();
-      ctx.scale(scale, scale);
-      ctx.strokeStyle = 'rgba(255,140,0,0.9)';
-      ctx.lineWidth = 0.3;
-      ctx.setLineDash([1, 0.8]);
-      ctx.strokeRect(b.x - 0.6, b.y - 0.6, b.w + 1.2, b.h + 1.2);
-      ctx.restore();
-    }
-  }, [tpl, stock, vars, samples, scale, sel]);
-
-  useEffect(() => { paint(); }, [paint]);
-
-  const mmFromEvent = (ev: React.MouseEvent): { x: number; y: number } => {
-    const r = canvasRef.current!.getBoundingClientRect();
-    return { x: (ev.clientX - r.left) / scale, y: (ev.clientY - r.top) / scale };
-  };
-
-  const onCanvasDown = (ev: React.MouseEvent) => {
-    if (!tpl) return;
-    const p = mmFromEvent(ev);
-    // Topmost element under the pointer wins — iterate backwards.
-    for (let i = boxesRef.current.length - 1; i >= 0; i--) {
-      const b = boxesRef.current[i];
-      if (p.x >= b.x && p.x <= b.x + b.w && p.y >= b.y && p.y <= b.y + b.h) {
-        setSel(i);
-        dragRef.current = { idx: i, dxMm: p.x - tpl.elements[i].x_mm, dyMm: p.y - tpl.elements[i].y_mm };
-        return;
-      }
-    }
-    setSel(null);
-  };
-  const onCanvasMove = (ev: React.MouseEvent) => {
-    const d = dragRef.current;
-    if (!d || !tpl) return;
-    const p = mmFromEvent(ev);
-    // Snapped to 0.5 mm: free pixels look precise on screen and print ragged.
-    const x = Math.round((p.x - d.dxMm) * 2) / 2;
-    const y = Math.round((p.y - d.dyMm) * 2) / 2;
-    patchEl(d.idx, { x_mm: x, y_mm: y });
-  };
-  const onCanvasUp = () => { dragRef.current = null; };
-
-  // ── template edits ────────────────────────────────────────────────────
-  function patchEl(idx: number, patch: Partial<LabelElement>) {
-    setTpl((cur) => {
-      if (!cur) return cur;
-      const elements = cur.elements.map((e, i) => (i === idx ? { ...e, ...patch } : e));
-      return { ...cur, elements };
-    });
-    setDirty(true);
-  }
-  function addElement(e: LabelElement) {
-    setTpl((cur) => (cur ? { ...cur, elements: [...cur.elements, e] } : cur));
-    setSel(tpl ? tpl.elements.length : 0);
-    setDirty(true);
-  }
-  function removeSelected() {
-    if (sel == null) return;
-    setTpl((cur) => (cur ? { ...cur, elements: cur.elements.filter((_, i) => i !== sel) } : cur));
-    setSel(null);
-    setDirty(true);
-  }
-
-  function newTemplate(kind: 'qso' | 'address') {
-    const s = stocks[0];
-    if (!s) { setError(t('lbl.noStock')); return; }
-    setTpl(starterTemplate(kind, s));
-    setTplId(0);
-    setTplName(kind === 'qso' ? t('lbl.newQsoName') : t('lbl.newAddrName'));
-    setSel(null);
-    setDirty(true);
-  }
-
-  async function openTemplate(info: TplInfo) {
-    try {
-      const doc = await LabelGetTemplate(info.id);
-      setTpl(JSON.parse(doc) as LabelTemplate);
-      setTplId(info.id);
-      setTplName(info.name);
-      setSel(null);
-      setDirty(false);
-    } catch (e: any) { setError(String(e?.message ?? e)); }
-  }
-
-  async function save() {
-    if (!tpl) return;
-    try {
-      const id = await LabelSaveTemplate(tplId, tplName.trim() || 'Label', JSON.stringify(tpl), forProfile);
-      setTplId(id as number);
-      setDirty(false);
-      await refresh();
-    } catch (e: any) { setError(String(e?.message ?? e)); }
-  }
-
-  async function removeTemplate(id: number) {
-    if (deleteArm !== id) { setDeleteArm(id); window.setTimeout(() => setDeleteArm(0), 2500); return; }
-    try {
-      await LabelDeleteTemplate(id);
-      if (id === tplId) { setTpl(null); setTplId(0); }
-      await refresh();
-    } catch (e: any) { setError(String(e?.message ?? e)); }
-  }
-
-  // ── stock editor ──────────────────────────────────────────────────────
-  async function saveStock() {
-    if (!stockDraft) return;
-    try {
-      await LabelSaveStock(stockDraft as any);
-      setStockDraft(null);
-      await refresh();
-    } catch (e: any) { setError(String(e?.message ?? e)); }
-  }
-
-  if (!open) return null;
-  const e = sel != null && tpl ? tpl.elements[sel] : undefined;
-
-  const numField = (label: string, value: number, set: (v: number) => void, step = 0.5, w = 'w-20') => (
-    <div className="space-y-0.5">
-      <Label className="text-[10px] text-muted-foreground">{label}</Label>
-      <Input type="number" step={step} value={value} className={cn('h-7 text-xs font-mono', w)}
-        onChange={(ev) => set(parseFloat(ev.target.value) || 0)} />
-    </div>
-  );
-
-  return (
-    <div className="fixed inset-0 z-50 bg-black/60 flex items-center justify-center p-4">
-      <div className="bg-card border border-border rounded-xl shadow-2xl w-full max-w-6xl h-[92vh] flex flex-col overflow-hidden">
-        {/* header */}
-        <div className="flex items-center gap-3 px-4 py-2.5 border-b border-border shrink-0">
-          <Tag className="size-4 text-primary" />
-          <span className="font-semibold text-sm">{t('lbl.title')}</span>
-          <div className="flex-1" />
-          {tpl && (
-            <>
-              <Input className="h-8 w-56 text-sm" value={tplName} onChange={(ev) => { setTplName(ev.target.value); setDirty(true); }}
-                placeholder={t('lbl.namePh')} />
-              <label className="flex items-center gap-1.5 text-xs text-muted-foreground cursor-pointer">
-                <Checkbox checked={forProfile} onCheckedChange={(c) => setForProfile(!!c)} />
-                {t('lbl.forProfile')}
-              </label>
-              <Button size="sm" className="h-8" onClick={save} disabled={!dirty && tplId !== 0}>
-                {t('lbl.save')}
-              </Button>
-            </>
-          )}
-          <Button variant="ghost" size="sm" className="h-8" onClick={onClose}><X className="size-4" /></Button>
-        </div>
-        {error && <div className="px-4 py-1.5 text-xs text-danger border-b border-border/60">{error}</div>}
-
-        <div className="flex-1 min-h-0 flex">
-          {/* left: saved templates + stocks */}
-          <div className="w-64 border-r border-border flex flex-col min-h-0 shrink-0">
-            <div className="p-2 flex gap-1.5">
-              <Button size="sm" variant="outline" className="h-8 flex-1" onClick={() => newTemplate('qso')}>
-                <Plus className="size-3.5" /> {t('lbl.newQso')}
-              </Button>
-              <Button size="sm" variant="outline" className="h-8 flex-1" onClick={() => newTemplate('address')}>
-                <Plus className="size-3.5" /> {t('lbl.newAddr')}
-              </Button>
-            </div>
-            <div className="flex-1 overflow-y-auto px-2 pb-2 space-y-1">
-              {saved.map((s) => (
-                <div key={s.id}
-                  className={cn('rounded-md border px-2 py-1.5 cursor-pointer text-xs',
-                    s.id === tplId ? 'border-primary bg-primary/5' : 'border-border hover:bg-muted/50')}
-                  onClick={() => void openTemplate(s)}>
-                  <div className="flex items-center gap-1.5">
-                    {s.kind === 'qso' ? <Tag className="size-3 shrink-0 text-muted-foreground" /> : <MapPin className="size-3 shrink-0 text-muted-foreground" />}
-                    <span className="font-medium truncate flex-1">{s.name}</span>
-                    <button type="button" title={t('lbl.setDefault')}
-                      onClick={(ev) => { ev.stopPropagation(); void LabelSetDefaultTemplate(s.id).then(refresh); }}>
-                      <Star className={cn('size-3.5', s.is_default ? 'text-warning fill-warning' : 'text-muted-foreground/40')} />
-                    </button>
-                    <button type="button" title={t('lbl.delete')}
-                      onClick={(ev) => { ev.stopPropagation(); void removeTemplate(s.id); }}>
-                      <Trash2 className={cn('size-3.5', deleteArm === s.id ? 'text-danger' : 'text-muted-foreground/40')} />
-                    </button>
-                  </div>
-                  <div className="text-[10px] text-muted-foreground pl-4">
-                    {s.kind === 'qso' ? t('lbl.kindQso') : t('lbl.kindAddr')} · {s.updated_at}
-                  </div>
-                </div>
-              ))}
-              {saved.length === 0 && (
-                <div className="text-xs text-muted-foreground px-1 py-3">{t('lbl.empty')}</div>
-              )}
-            </div>
-            {/* stocks */}
-            <div className="border-t border-border p-2 space-y-1.5">
-              <button type="button" className="text-[11px] font-semibold uppercase tracking-wider text-muted-foreground"
-                onClick={() => setStockOpen((v) => !v)}>
-                {t('lbl.stocks')} {stockOpen ? '▾' : '▸'}
-              </button>
-              {stockOpen && (
-                <div className="space-y-1.5">
-                  <Select value={String(stockDraft?.id ?? '')} onValueChange={(v) => {
-                    const s = stocks.find((x) => String(x.id) === v);
-                    if (s) setStockDraft({ ...s });
-                  }}>
-                    <SelectTrigger className="h-7 text-xs"><SelectValue placeholder={t('lbl.pickStock')} /></SelectTrigger>
-                    <SelectContent>
-                      {stocks.map((s) => <SelectItem key={s.id} value={String(s.id)}>{s.name}</SelectItem>)}
-                    </SelectContent>
-                  </Select>
-                  <div className="flex gap-1.5">
-                    <Button size="sm" variant="outline" className="h-7 text-xs flex-1"
-                      onClick={() => setStockDraft({ name: t('lbl.customStock'), w_mm: 90, h_mm: 29, margin_top_mm: 1.5, margin_right_mm: 3, margin_bottom_mm: 1.5, margin_left_mm: 3, dpi: 300 })}>
-                      <Plus className="size-3" /> {t('lbl.newStock')}
-                    </Button>
-                    {stockDraft?.id ? (
-                      <Button size="sm" variant="ghost" className="h-7 text-xs text-danger"
-                        onClick={() => { void LabelDeleteStock(stockDraft.id!).then(() => { setStockDraft(null); return refresh(); }); }}>
-                        <Trash2 className="size-3" />
-                      </Button>
-                    ) : null}
-                  </div>
-                  {stockDraft && (
-                    <div className="space-y-1.5">
-                      <Input className="h-7 text-xs" value={stockDraft.name}
-                        onChange={(ev) => setStockDraft({ ...stockDraft, name: ev.target.value })} />
-                      <div className="grid grid-cols-2 gap-1.5">
-                        {numField(t('lbl.widthMm'), stockDraft.w_mm, (v) => setStockDraft({ ...stockDraft, w_mm: v }), 0.5, 'w-full')}
-                        {numField(t('lbl.heightMm'), stockDraft.h_mm, (v) => setStockDraft({ ...stockDraft, h_mm: v }), 0.5, 'w-full')}
-                      </div>
-                      <div className="grid grid-cols-4 gap-1.5">
-                        {numField('↑', stockDraft.margin_top_mm, (v) => setStockDraft({ ...stockDraft, margin_top_mm: v }), 0.5, 'w-full')}
-                        {numField('→', stockDraft.margin_right_mm, (v) => setStockDraft({ ...stockDraft, margin_right_mm: v }), 0.5, 'w-full')}
-                        {numField('↓', stockDraft.margin_bottom_mm, (v) => setStockDraft({ ...stockDraft, margin_bottom_mm: v }), 0.5, 'w-full')}
-                        {numField('←', stockDraft.margin_left_mm, (v) => setStockDraft({ ...stockDraft, margin_left_mm: v }), 0.5, 'w-full')}
-                      </div>
-                      <Button size="sm" className="h-7 text-xs w-full" onClick={() => void saveStock()}>{t('lbl.saveStock')}</Button>
-                    </div>
-                  )}
-                </div>
-              )}
-            </div>
-          </div>
-
-          {/* centre: preview */}
-          <div ref={paneRef} className="flex-1 min-w-0 flex flex-col items-center justify-center bg-muted/30 overflow-auto p-6 gap-3">
-            {tpl && stock ? (
-              <>
-                <div className="flex items-center gap-2 text-xs text-muted-foreground">
-                  <span>{t('lbl.stock')}:</span>
-                  <Select value={String(tpl.stock_id || stock.id)} onValueChange={(v) => {
-                    setTpl({ ...tpl, stock_id: parseInt(v, 10) }); setDirty(true);
-                  }}>
-                    <SelectTrigger className="h-7 text-xs w-72"><SelectValue /></SelectTrigger>
-                    <SelectContent>
-                      {stocks.map((s) => <SelectItem key={s.id} value={String(s.id)}>{s.name}</SelectItem>)}
-                    </SelectContent>
-                  </Select>
-                  <span className="font-mono">{stock.w_mm}×{stock.h_mm} mm</span>
-                </div>
-                <canvas ref={canvasRef} className="shadow-lg rounded-sm cursor-move"
-                  onMouseDown={onCanvasDown} onMouseMove={onCanvasMove}
-                  onMouseUp={onCanvasUp} onMouseLeave={onCanvasUp} />
-                <div className="flex items-center gap-1.5">
-                  <Button size="sm" variant="outline" className="h-7 text-xs"
-                    onClick={() => addElement({ type: 'text', x_mm: stock.margin_left_mm, y_mm: stock.h_mm / 2, text: t('lbl.newText'), size_pt: 9 })}>
-                    <Plus className="size-3" /> {t('lbl.addText')}
-                  </Button>
-                  <Button size="sm" variant="outline" className="h-7 text-xs"
-                    onClick={() => addElement({ type: 'line', x_mm: stock.margin_left_mm, y_mm: stock.h_mm / 2, w_mm: stock.w_mm - stock.margin_left_mm - stock.margin_right_mm, thickness_mm: 0.3 })}>
-                    <Plus className="size-3" /> {t('lbl.addLine')}
-                  </Button>
-                  {tpl.kind === 'address' && (
-                    <Button size="sm" variant="outline" className="h-7 text-xs"
-                      onClick={() => addElement({ type: 'addr_block', x_mm: stock.margin_left_mm + 2, y_mm: stock.margin_top_mm + 2, lines: ['<NAME>', '<STREET>', '<ZIP> <CITY>', '<COUNTRY>'], size_pt: 11, line_gap_mm: 1.6 })}>
-                      <Plus className="size-3" /> {t('lbl.addAddr')}
-                    </Button>
-                  )}
-                  {tpl.kind === 'qso' && !tpl.elements.some((x) => x.type === 'qso_table') && (
-                    <Button size="sm" variant="outline" className="h-7 text-xs"
-                      onClick={() => addElement({ type: 'qso_table', x_mm: stock.margin_left_mm, y_mm: stock.margin_top_mm + 7, w_mm: stock.w_mm - stock.margin_left_mm - stock.margin_right_mm, rows_max: 4, row_h_mm: 4, header: true, size_pt: 7.5, columns: TABLE_FIELDS.slice(0, 6).map((c) => ({ ...c })) })}>
-                      <Plus className="size-3" /> {t('lbl.addTable')}
-                    </Button>
-                  )}
-                  {sel != null && (
-                    <Button size="sm" variant="ghost" className="h-7 text-xs text-danger" onClick={removeSelected}>
-                      <Trash2 className="size-3" /> {t('lbl.removeEl')}
-                    </Button>
-                  )}
-                </div>
-              </>
-            ) : (
-              <div className="text-sm text-muted-foreground text-center max-w-sm leading-relaxed">
-                {t('lbl.intro')}
-              </div>
-            )}
-          </div>
-
-          {/* right: properties of the selection */}
-          {tpl && (
-            <div className="w-72 border-l border-border overflow-y-auto p-3 space-y-3 shrink-0">
-              {!e ? (
-                <div className="text-xs text-muted-foreground leading-relaxed">{t('lbl.selectHint')}</div>
-              ) : (
-                <>
-                  <div className="text-[11px] font-semibold uppercase tracking-wider text-muted-foreground">
-                    {t(`lbl.el_${e.type}` as any)}
-                  </div>
-                  <div className="flex gap-2">
-                    {numField('X mm', e.x_mm, (v) => patchEl(sel!, { x_mm: v }))}
-                    {numField('Y mm', e.y_mm, (v) => patchEl(sel!, { y_mm: v }))}
-                    {(e.type === 'text' || e.type === 'line' || e.type === 'qso_table') &&
-                      numField('W mm', e.w_mm ?? 0, (v) => patchEl(sel!, { w_mm: v }))}
-                  </div>
-
-                  {e.type === 'text' && (
-                    <>
-                      <div className="space-y-0.5">
-                        <Label className="text-[10px] text-muted-foreground">{t('lbl.text')}</Label>
-                        <Input className="h-7 text-xs" value={e.text ?? ''} onChange={(ev) => patchEl(sel!, { text: ev.target.value })} />
-                      </div>
-                      <VarPicker onPick={(v) => patchEl(sel!, { text: `${e.text ?? ''}<${v}>` })} t={t} />
-                      <div className="flex gap-2 items-end">
-                        {numField('pt', e.size_pt ?? 9, (v) => patchEl(sel!, { size_pt: v }), 0.5, 'w-16')}
-                        <label className="flex items-center gap-1 text-xs cursor-pointer pb-1.5">
-                          <Checkbox checked={!!e.bold} onCheckedChange={(c) => patchEl(sel!, { bold: !!c })} /> B
-                        </label>
-                        <label className="flex items-center gap-1 text-xs italic cursor-pointer pb-1.5">
-                          <Checkbox checked={!!e.italic} onCheckedChange={(c) => patchEl(sel!, { italic: !!c })} /> I
-                        </label>
-                        <Select value={e.align ?? 'left'} onValueChange={(v) => patchEl(sel!, { align: v as any })}>
-                          <SelectTrigger className="h-7 text-xs w-24"><SelectValue /></SelectTrigger>
-                          <SelectContent>
-                            <SelectItem value="left">{t('lbl.alignLeft')}</SelectItem>
-                            <SelectItem value="center">{t('lbl.alignCenter')}</SelectItem>
-                            <SelectItem value="right">{t('lbl.alignRight')}</SelectItem>
-                          </SelectContent>
-                        </Select>
-                      </div>
-                    </>
-                  )}
-
-                  {e.type === 'line' && numField(t('lbl.thickness'), e.thickness_mm ?? 0.3, (v) => patchEl(sel!, { thickness_mm: v }), 0.1)}
-
-                  {e.type === 'addr_block' && (
-                    <>
-                      <div className="space-y-0.5">
-                        <Label className="text-[10px] text-muted-foreground">{t('lbl.addrLines')}</Label>
-                        <textarea
-                          className="w-full h-28 rounded-md border border-input bg-background px-2 py-1 text-xs font-mono"
-                          value={(e.lines ?? []).join('\n')}
-                          onChange={(ev) => patchEl(sel!, { lines: ev.target.value.split('\n') })} />
-                        <div className="text-[10px] text-muted-foreground">{t('lbl.addrHint')}</div>
-                      </div>
-                      <VarPicker onPick={(v) => patchEl(sel!, { lines: [...(e.lines ?? []), `<${v}>`] })} t={t} />
-                      <div className="flex gap-2">
-                        {numField('pt', e.size_pt ?? 11, (v) => patchEl(sel!, { size_pt: v }), 0.5, 'w-16')}
-                        {numField(t('lbl.lineGap'), e.line_gap_mm ?? 1.5, (v) => patchEl(sel!, { line_gap_mm: v }), 0.1, 'w-20')}
-                      </div>
-                    </>
-                  )}
-
-                  {e.type === 'qso_table' && (
-                    <>
-                      <div className="flex gap-2">
-                        {numField(t('lbl.rows'), e.rows_max ?? 4, (v) => patchEl(sel!, { rows_max: Math.max(1, Math.round(v)) }), 1, 'w-16')}
-                        {numField(t('lbl.rowH'), e.row_h_mm ?? 4, (v) => patchEl(sel!, { row_h_mm: v }), 0.1, 'w-20')}
-                        {numField('pt', e.size_pt ?? 7.5, (v) => patchEl(sel!, { size_pt: v }), 0.5, 'w-16')}
-                      </div>
-                      <label className="flex items-center gap-1.5 text-xs cursor-pointer">
-                        <Checkbox checked={!!e.header} onCheckedChange={(c) => patchEl(sel!, { header: !!c })} />
-                        {t('lbl.header')}
-                      </label>
-                      <div className="space-y-1">
-                        <Label className="text-[10px] text-muted-foreground">{t('lbl.columns')}</Label>
-                        {(e.columns ?? []).map((c, ci) => (
-                          <div key={ci} className="flex items-center gap-1">
-                            <Select value={c.field} onValueChange={(v) => {
-                              const f = TABLE_FIELDS.find((x) => x.field === v);
-                              const columns = e.columns!.map((x, i) => (i === ci ? { ...x, field: v, label: f?.label ?? v } : x));
-                              patchEl(sel!, { columns });
-                            }}>
-                              <SelectTrigger className="h-6 text-[11px] flex-1"><SelectValue /></SelectTrigger>
-                              <SelectContent>
-                                {TABLE_FIELDS.map((f) => <SelectItem key={f.field} value={f.field}>{f.label}</SelectItem>)}
-                              </SelectContent>
-                            </Select>
-                            <Input type="number" step={0.5} className="h-6 w-14 text-[11px] font-mono" value={c.w_mm}
-                              onChange={(ev) => {
-                                const columns = e.columns!.map((x, i) => (i === ci ? { ...x, w_mm: parseFloat(ev.target.value) || 1 } : x));
-                                patchEl(sel!, { columns });
-                              }} />
-                            <button type="button" onClick={() => patchEl(sel!, { columns: e.columns!.filter((_, i) => i !== ci) })}>
-                              <Trash2 className="size-3 text-muted-foreground/60" />
-                            </button>
-                          </div>
-                        ))}
-                        <Button size="sm" variant="outline" className="h-6 text-[11px] w-full"
-                          onClick={() => patchEl(sel!, { columns: [...(e.columns ?? []), { ...TABLE_FIELDS[0] }] })}>
-                          <Plus className="size-3" /> {t('lbl.addColumn')}
-                        </Button>
-                      </div>
-                    </>
-                  )}
-                </>
-              )}
-            </div>
-          )}
-        </div>
-      </div>
-    </div>
-  );
-}
-
-// VarPicker inserts a <VARIABLE> — a menu beats remembering the exact spelling.
-function VarPicker({ onPick, t }: { onPick: (v: string) => void; t: (k: string) => string }) {
-  return (
-    <Select value="" onValueChange={(v) => { if (v) onPick(v); }}>
-      <SelectTrigger className="h-7 text-xs"><SelectValue placeholder={t('lbl.insertVar')} /></SelectTrigger>
-      <SelectContent>
-        {LABEL_VARS.map((v) => <SelectItem key={v} value={v}>{`<${v}>`}</SelectItem>)}
-      </SelectContent>
-    </Select>
-  );
-}

frontend/src/components/labels/LabelPrintModal.tsx

@@ -1,502 +0,0 @@
-// Label printing — the paper-QSL labelling session, in three steps:
-//
-//   1. PICK    the contacts (preloaded with the R/Q paper queue), grouped by
-//              callsign — several QSOs of the same station share one card.
-//   2. REVIEW  each recipient: routing (direct / bureau / via manager), the
-//              address checked and edited by hand, a QRZ fetch to fill it.
-//   3. PRINT   ONE PDF holding every label of the session (each page at its
-//              own physical size), opened straight in the system viewer — the
-//              operator prints from there — then mark the contacts sent
-//              (date + via) in the log.
-//
-// The pages are rasterised by the designer's own renderer at the stock's dpi:
-// what the designer previewed is what the PDF carries.
-import { useCallback, useEffect, useMemo, useState } from 'react';
-import { X, Printer, RefreshCw, ChevronRight, ChevronLeft, Check, Loader2 } from 'lucide-react';
-import { Button } from '@/components/ui/button';
-import { Input } from '@/components/ui/input';
-import { Checkbox } from '@/components/ui/checkbox';
-import {
-  Select, SelectContent, SelectItem, SelectTrigger, SelectValue,
-} from '@/components/ui/select';
-import { cn } from '@/lib/utils';
-import { useI18n } from '@/lib/i18n';
-import {
-  LabelPaperQueue, LabelListStocks, LabelListTemplates, LabelGetTemplate,
-  LabelOpenPDF, LookupCallsignFresh, BulkUpdateQSL, GetActiveProfile,
-} from '../../../wailsjs/go/main/App';
-import type { LabelSample, LabelStock, LabelTemplate } from './labelTypes';
-import { rasterize } from './labelRender';
-
-interface Props { open: boolean; onClose: () => void }
-
-type Routing = 'direct' | 'bureau' | 'via';
-
-interface Station {
-  call: string;
-  qsos: any[];          // raw QSO rows, newest first
-  checked: boolean;
-  routing: Routing;
-  via: string;          // manager callsign when routing = via
-  address: string;      // multiline, the text that will be printed — verbatim
-  // Whose address the box holds: the DX's prefill, the manager's fetch, or the
-  // operator's own edit. Routing changes recompute the first two and must never
-  // touch the third — an address typed by hand is not the app's to replace.
-  addrFor: 'dx' | 'mgr' | 'user' | 'none';
-  fetching?: boolean;
-}
-
-interface TplInfo { id: number; name: string; kind: string; stock_id: number; is_default: boolean }
-
-// One label's worth of QSO rows, in the designer's sample shape.
-function toSample(q: any): LabelSample {
-  const d = new Date(q.qso_date);
-  const pad = (n: number) => String(n).padStart(2, '0');
-  return {
-    callsign: q.callsign ?? '',
-    qso_date: `${d.getUTCFullYear()}-${pad(d.getUTCMonth() + 1)}-${pad(d.getUTCDate())}`,
-    time_on: `${pad(d.getUTCHours())}:${pad(d.getUTCMinutes())}`,
-    band: q.band ?? '', mode: q.mode ?? '',
-    freq: q.freq_hz ? (q.freq_hz / 1e6).toFixed(3) : '',
-    rst_sent: q.rst_sent ?? '', rst_rcvd: q.rst_rcvd ?? '',
-    name: q.name ?? '', qth: q.qth ?? '', country: q.country ?? '',
-  };
-}
-
-// dedupeLines drops empties and any line already CONTAINED in an earlier one:
-// the log often holds "20370 Casablanca Morocco" as the address AND "20370
-// CASABLANCA" as the QTH AND "Morocco" as the country, and printing all three
-// stacks the same city three times on the envelope.
-function dedupeLines(lines: Array<any>): string[] {
-  const out: string[] = [];
-  for (const raw of lines) {
-    const l = String(raw ?? '').trim();
-    if (!l) continue;
-    const low = l.toLowerCase();
-    if (out.some((prev) => prev.toLowerCase().includes(low))) continue;
-    out.push(l);
-  }
-  return out;
-}
-
-function initialAddress(q: any): string {
-  return dedupeLines([q.name, q.address, q.qth, q.country]).join('\n');
-}
-
-export function LabelPrintModal({ open, onClose }: Props) {
-  const { t } = useI18n();
-  const [step, setStep] = useState<'pick' | 'review' | 'print'>('pick');
-  const [stations, setStations] = useState<Station[]>([]);
-  const [loading, setLoading] = useState(false);
-  const [error, setError] = useState('');
-
-  const [stocks, setStocks] = useState<LabelStock[]>([]);
-  const [tpls, setTpls] = useState<TplInfo[]>([]);
-  const [doQso, setDoQso] = useState(true);
-  const [doAddr, setDoAddr] = useState(true);
-  const [doReturn, setDoReturn] = useState(false);
-  const [qsoTplId, setQsoTplId] = useState(0);
-  const [addrTplId, setAddrTplId] = useState(0);
-  const [retTplId, setRetTplId] = useState(0);
-  const [myAddress, setMyAddress] = useState('');
-  const [myVars, setMyVars] = useState<Record<string, string>>({});
-
-  // Rasterised pages per kind — kept separate for the previews, concatenated
-  // (with each page's own mm size) into the single PDF.
-  type Page = { png: string; w_mm: number; h_mm: number };
-  const [pages, setPages] = useState<{ qso: Page[]; addr: Page[]; ret: Page[] }>({ qso: [], addr: [], ret: [] });
-  const [building, setBuilding] = useState(false);
-  const [pdfPath, setPdfPath] = useState('');
-  const [markDate, setMarkDate] = useState(() => new Date().toISOString().slice(0, 10));
-  const [marked, setMarked] = useState(0);
-
-  const load = useCallback(async () => {
-    setLoading(true); setError('');
-    try {
-      const rows: any[] = (await LabelPaperQueue()) ?? [];
-      // Group by callsign, newest first inside each group.
-      const by = new Map<string, any[]>();
-      for (const q of rows) {
-        const c = String(q.callsign ?? '').toUpperCase();
-        if (!by.has(c)) by.set(c, []);
-        by.get(c)!.push(q);
-      }
-      setStations([...by.entries()].map(([call, qsos]) => {
-        const via = String(qsos[0]?.qsl_via ?? '').trim();
-        // Via a manager, the DX's own address is exactly the wrong thing to
-        // print on the envelope — start empty and let the QRZ fetch fill in the
-        // MANAGER's.
-        const address = via ? '' : initialAddress(qsos[0]);
-        return {
-          call, qsos, checked: true,
-          routing: via ? 'via' as Routing : (address.split('\n').length >= 3 ? 'direct' as Routing : 'bureau' as Routing),
-          via, address, addrFor: (via ? 'none' : 'dx') as Station['addrFor'],
-        };
-      }));
-      const st = (await LabelListStocks()) as any as LabelStock[];
-      setStocks(st);
-      const tl = ((await LabelListTemplates()) ?? []) as any as TplInfo[];
-      setTpls(tl);
-      const def = (kind: string) => tl.find((x) => x.kind === kind && x.is_default) ?? tl.find((x) => x.kind === kind);
-      setQsoTplId(def('qso')?.id ?? 0);
-      setAddrTplId(def('address')?.id ?? 0);
-      setRetTplId(def('address')?.id ?? 0);
-      const p: any = await GetActiveProfile().catch(() => null);
-      const mv = {
-        MYCALL: p?.callsign ?? '', MYNAME: p?.op_name ?? p?.operator ?? '',
-        MYSTREET: p?.my_street ?? '', MYZIP: p?.my_postal_code ?? '',
-        MYCITY: p?.my_city ?? '', MYCOUNTRY: p?.my_country ?? '',
-      };
-      setMyVars(mv);
-      setMyAddress([mv.MYNAME && `${mv.MYNAME} · ${mv.MYCALL}` || mv.MYCALL, mv.MYSTREET,
-        [mv.MYZIP, mv.MYCITY].filter(Boolean).join(' '), mv.MYCOUNTRY]
-        .map((x) => String(x ?? '').trim()).filter(Boolean).join('\n'));
-    } catch (e: any) { setError(String(e?.message ?? e)); }
-    setLoading(false);
-  }, []);
-
-  useEffect(() => {
-    if (!open) return;
-    setStep('pick'); setPages({ qso: [], addr: [], ret: [] }); setPdfPath(''); setMarked(0);
-    void load();
-  }, [open, load]);
-
-  const patchStation = (i: number, p: Partial<Station>) =>
-    setStations((l) => l.map((s, j) => (j === i ? { ...s, ...p } : s)));
-
-  async function fetchAddress(i: number) {
-    const s = stations[i];
-    const target = s.routing === 'via' && s.via.trim() ? s.via.trim().toUpperCase() : s.call;
-    patchStation(i, { fetching: true });
-    try {
-      const r: any = await LookupCallsignFresh(target, '');
-      // A postal address needs a STREET (or at least a name and a town). A
-      // lookup that fell back to cty.dat answers with a country alone —
-      // overwriting a reviewed address with a bare country is strictly worse
-      // than saying nothing was found, and losing the address is what was
-      // reported.
-      const street = String(r?.address ?? '').trim();
-      if (!street && !(String(r?.name ?? '').trim() && String(r?.qth ?? '').trim())) {
-        patchStation(i, { fetching: false });
-        setError(t('lpr.noAddress', { call: target }));
-        return;
-      }
-      const lines = dedupeLines([
-        r?.name, street,
-        [r?.zip, r?.qth].filter(Boolean).join(' '),
-        r?.country,
-      ]);
-      patchStation(i, {
-        address: lines.join('\n'), fetching: false,
-        addrFor: target === s.call ? 'dx' : 'mgr',
-      });
-    } catch (e: any) {
-      patchStation(i, { fetching: false });
-      setError(String(e?.message ?? e));
-    }
-  }
-
-  const picked = stations.filter((s) => s.checked);
-  const needAddress = picked.filter((s) => s.routing !== 'bureau');
-
-  // ── step 3: build the pages ───────────────────────────────────────────
-  async function buildPages() {
-    setBuilding(true); setError('');
-    try {
-      const getTpl = async (id: number): Promise<{ tpl: LabelTemplate; stock: LabelStock } | null> => {
-        if (!id) return null;
-        const tpl = JSON.parse(await LabelGetTemplate(id)) as LabelTemplate;
-        const stock = stocks.find((x) => x.id === tpl.stock_id) ?? stocks[0];
-        return stock ? { tpl, stock } : null;
-      };
-      const out = { qso: [] as Page[], addr: [] as Page[], ret: [] as Page[] };
-      const page = (png: string, stock: LabelStock): Page => ({ png, w_mm: stock.w_mm, h_mm: stock.h_mm });
-      if (doQso) {
-        const got = await getTpl(qsoTplId);
-        if (!got) throw new Error(t('lpr.noQsoTpl'));
-        const table = got.tpl.elements.find((e) => e.type === 'qso_table');
-        const per = Math.max(1, table?.rows_max ?? 4);
-        for (const s of picked) {
-          const vars = { CALL: s.call, NAME: s.qsos[0]?.name ?? '', QTH: s.qsos[0]?.qth ?? '', COUNTRY: s.qsos[0]?.country ?? '', VIA: s.via, ...myVars };
-          for (let i = 0; i < s.qsos.length; i += per) {
-            out.qso.push(page(rasterize(got.tpl, got.stock, { vars, qsos: s.qsos.slice(i, i + per).map(toSample) }), got.stock));
-          }
-        }
-      }
-      if (doAddr) {
-        const got = await getTpl(addrTplId);
-        if (!got) throw new Error(t('lpr.noAddrTpl'));
-        for (const s of needAddress) {
-          // The REVIEWED text wins: the template's address block prints these
-          // lines verbatim — that is what "check the address first" means.
-          const tpl: LabelTemplate = {
-            ...got.tpl,
-            elements: got.tpl.elements.map((e) =>
-              e.type === 'addr_block' ? { ...e, lines: s.address.split('\n') } : e),
-          };
-          const vars = { CALL: s.call, VIA: s.via, ...myVars };
-          out.addr.push(page(rasterize(tpl, got.stock, { vars, qsos: [] }), got.stock));
-        }
-      }
-      if (doReturn) {
-        const got = await getTpl(retTplId);
-        if (!got) throw new Error(t('lpr.noAddrTpl'));
-        const tpl: LabelTemplate = {
-          ...got.tpl,
-          elements: got.tpl.elements.map((e) =>
-            e.type === 'addr_block' ? { ...e, lines: myAddress.split('\n') } : e),
-        };
-        // One per envelope that needs a return slip — the direct/via ones.
-        const n = Math.max(1, needAddress.length);
-        const one = page(rasterize(tpl, got.stock, { vars: { ...myVars, CALL: myVars.MYCALL }, qsos: [] }), got.stock);
-        for (let i = 0; i < n; i++) out.ret.push(one);
-      }
-      setPages(out);
-    } catch (e: any) { setError(String(e?.message ?? e)); }
-    setBuilding(false);
-  }
-
-  const allPages = [...pages.qso, ...pages.addr, ...pages.ret];
-
-  async function openPdf() {
-    try {
-      const path = await LabelOpenPDF(allPages as any);
-      if (path) setPdfPath(path as string);
-    } catch (e: any) { setError(String(e?.message ?? e)); }
-  }
-
-  async function markSent() {
-    try {
-      const date = markDate.replace(/-/g, '');
-      let n = 0;
-      const groups: Array<[Station[], string]> = [
-        [picked.filter((s) => s.routing === 'bureau'), 'B'],
-        [picked.filter((s) => s.routing !== 'bureau'), 'D'],
-      ];
-      for (const [list, via] of groups) {
-        const ids = list.flatMap((s) => s.qsos.map((q) => q.id));
-        if (ids.length === 0) continue;
-        n += (await BulkUpdateQSL(ids, { sent_status: 'Y', sent_date: date, via, rcvd_status: '', rcvd_date: '', rcvd_via: '', notes: '', comment: '' } as any)) as number;
-      }
-      setMarked(n);
-    } catch (e: any) { setError(String(e?.message ?? e)); }
-  }
-
-  const kindBlock = (kind: 'qso' | 'addr' | 'ret', title: string) => {
-    const pg = pages[kind];
-    if (pg.length === 0) return null;
-    return (
-      <div className="rounded-lg border border-border p-3 space-y-2">
-        <div className="flex items-center gap-2">
-          <span className="text-sm font-semibold">{title}</span>
-          <span className="text-xs text-muted-foreground">{t('lpr.pageCount', { n: pg.length })}</span>
-        </div>
-        <div className="flex gap-2 overflow-x-auto pb-1">
-          {pg.slice(0, 8).map((p, i) => (
-            <img key={i} src={p.png} className="h-20 border border-border rounded-sm bg-white shrink-0" />
-          ))}
-          {pg.length > 8 && <span className="text-xs text-muted-foreground self-center">+{pg.length - 8}</span>}
-        </div>
-      </div>
-    );
-  };
-
-  if (!open) return null;
-  const sumQsos = picked.reduce((a, s) => a + s.qsos.length, 0);
-
-  return (
-    <div className="fixed inset-0 z-50 bg-black/60 flex items-center justify-center p-4">
-      <div className="bg-card border border-border rounded-xl shadow-2xl w-full max-w-5xl h-[90vh] flex flex-col overflow-hidden">
-        <div className="flex items-center gap-3 px-4 py-2.5 border-b border-border shrink-0">
-          <Printer className="size-4 text-primary" />
-          <span className="font-semibold text-sm">{t('lpr.title')}</span>
-          <span className="text-xs text-muted-foreground">
-            {step === 'pick' ? t('lpr.step1') : step === 'review' ? t('lpr.step2') : t('lpr.step3')}
-          </span>
-          <div className="flex-1" />
-          <Button variant="ghost" size="sm" className="h-8" onClick={onClose}><X className="size-4" /></Button>
-        </div>
-        {error && <div className="px-4 py-1.5 text-xs text-danger border-b border-border/60">{error}</div>}
-
-        <div className="flex-1 min-h-0 overflow-y-auto p-4">
-          {loading ? (
-            <div className="flex items-center justify-center h-full text-muted-foreground gap-2">
-              <Loader2 className="size-4 animate-spin" /> …
-            </div>
-          ) : step === 'pick' ? (
-            stations.length === 0 ? (
-              <div className="text-sm text-muted-foreground text-center pt-16 max-w-md mx-auto leading-relaxed">
-                {t('lpr.emptyQueue')}
-              </div>
-            ) : (
-              <div className="space-y-1">
-                <div className="flex items-center gap-2 pb-1 text-xs text-muted-foreground">
-                  <button type="button" className="underline underline-offset-2" onClick={() => setStations((l) => l.map((s) => ({ ...s, checked: true })))}>{t('lpr.all')}</button>
-                  <button type="button" className="underline underline-offset-2" onClick={() => setStations((l) => l.map((s) => ({ ...s, checked: false })))}>{t('lpr.none')}</button>
-                  <div className="flex-1" />
-                  <span>{t('lpr.pickSummary', { s: picked.length, q: sumQsos })}</span>
-                </div>
-                {stations.map((s, i) => (
-                  <label key={s.call} className="flex items-center gap-2.5 rounded-md border border-border/60 px-2.5 py-1.5 text-sm cursor-pointer hover:bg-muted/40">
-                    <Checkbox checked={s.checked} onCheckedChange={(c) => patchStation(i, { checked: !!c })} />
-                    <span className="font-mono font-bold w-28">{s.call}</span>
-                    <span className="text-xs text-muted-foreground w-16">{s.qsos.length} QSO{s.qsos.length > 1 ? 's' : ''}</span>
-                    <span className="text-xs text-muted-foreground flex-1 truncate">
-                      {s.qsos.map((q) => `${q.band ?? ''} ${q.mode ?? ''}`).slice(0, 5).join(' · ')}
-                    </span>
-                    <span className="text-xs text-muted-foreground truncate max-w-40">{s.qsos[0]?.country ?? ''}</span>
-                    {s.via && <span className="text-[10px] px-1.5 rounded bg-info-muted text-info-muted-foreground">via {s.via}</span>}
-                  </label>
-                ))}
-              </div>
-            )
-          ) : step === 'review' ? (
-            <div className="space-y-2">
-              {picked.map((s) => {
-                const i = stations.indexOf(s);
-                return (
-                  <div key={s.call} className="rounded-lg border border-border p-2.5 flex gap-3">
-                    <div className="w-64 shrink-0 space-y-1.5">
-                      <div className="font-mono font-bold">{s.call}
-                        <span className="ml-2 text-xs font-normal text-muted-foreground">{s.qsos.length} QSO{s.qsos.length > 1 ? 's' : ''}</span>
-                      </div>
-                      <Select value={s.routing} onValueChange={(v) => {
-                        const routing = v as Routing;
-                        const patch: Partial<Station> = { routing };
-                        if (s.addrFor !== 'user') {
-                          // The box follows the routing while the operator has
-                          // not typed in it: via → empty (fetch the manager),
-                          // direct → the DX's own prefill.
-                          patch.address = routing === 'via' ? '' : initialAddress(s.qsos[0]);
-                          patch.addrFor = routing === 'via' ? 'none' : 'dx';
-                        }
-                        patchStation(i, patch);
-                      }}>
-                        <SelectTrigger className="h-7 text-xs"><SelectValue /></SelectTrigger>
-                        <SelectContent>
-                          <SelectItem value="direct">{t('lpr.direct')}</SelectItem>
-                          <SelectItem value="bureau">{t('lpr.bureau')}</SelectItem>
-                          <SelectItem value="via">{t('lpr.viaMgr')}</SelectItem>
-                        </SelectContent>
-                      </Select>
-                      {s.routing === 'via' && (
-                        <Input className="h-7 text-xs font-mono uppercase" placeholder={t('lpr.mgrPh')}
-                          value={s.via} onChange={(ev) => patchStation(i, { via: ev.target.value })} />
-                      )}
-                      {s.routing !== 'bureau' && (
-                        <Button size="sm" variant="outline" className="h-7 text-xs w-full"
-                          disabled={s.fetching}
-                          onClick={() => void fetchAddress(i)}>
-                          {s.fetching ? <Loader2 className="size-3 animate-spin" /> : <RefreshCw className="size-3" />}
-                          {t('lpr.fetchQrz')}
-                        </Button>
-                      )}
-                    </div>
-                    {s.routing === 'bureau' ? (
-                      <div className="flex-1 text-xs text-muted-foreground self-center">{t('lpr.bureauHint')}</div>
-                    ) : (
-                      <textarea
-                        className={cn('flex-1 rounded-md border bg-background px-2 py-1 text-sm font-mono',
-                          s.address.trim() ? 'border-input' : 'border-danger')}
-                        rows={4}
-                        placeholder={s.routing === 'via' ? t('lpr.mgrAddressPh') : t('lpr.addressPh')}
-                        value={s.address}
-                        onChange={(ev) => patchStation(i, { address: ev.target.value, addrFor: 'user' })} />
-                    )}
-                  </div>
-                );
-              })}
-            </div>
-          ) : (
-            <div className="space-y-3">
-              {/* what to print */}
-              <div className="rounded-lg border border-border p-3 space-y-2">
-                <div className="text-sm font-semibold">{t('lpr.whatToPrint')}</div>
-                {([
-                  ['qso', doQso, setDoQso, qsoTplId, setQsoTplId, 'qso', t('lpr.kQso')],
-                  ['addr', doAddr, setDoAddr, addrTplId, setAddrTplId, 'address', t('lpr.kAddr')],
-                  ['ret', doReturn, setDoReturn, retTplId, setRetTplId, 'address', t('lpr.kRet')],
-                ] as const).map(([key, on, setOn, tplId, setTplId, kind, label]) => (
-                  <div key={key} className="flex items-center gap-2">
-                    <label className="flex items-center gap-1.5 text-sm cursor-pointer w-64">
-                      <Checkbox checked={on} onCheckedChange={(c) => (setOn as any)(!!c)} /> {label}
-                    </label>
-                    <Select value={String(tplId || '')} onValueChange={(v) => (setTplId as any)(parseInt(v, 10))}>
-                      <SelectTrigger className="h-7 text-xs w-72"><SelectValue placeholder={t('lpr.pickTpl')} /></SelectTrigger>
-                      <SelectContent>
-                        {tpls.filter((x) => x.kind === kind).map((x) => (
-                          <SelectItem key={x.id} value={String(x.id)}>{x.name}</SelectItem>
-                        ))}
-                      </SelectContent>
-                    </Select>
-                  </div>
-                ))}
-                {doReturn && (
-                  <div className="flex items-start gap-2 pl-6">
-                    <span className="text-xs text-muted-foreground pt-1 w-24">{t('lpr.myAddress')}</span>
-                    <textarea className="flex-1 max-w-96 rounded-md border border-input bg-background px-2 py-1 text-xs font-mono" rows={4}
-                      value={myAddress} onChange={(ev) => setMyAddress(ev.target.value)} />
-                  </div>
-                )}
-                <Button size="sm" className="h-8" onClick={() => void buildPages()} disabled={building || (!doQso && !doAddr && !doReturn)}>
-                  {building ? <Loader2 className="size-3.5 animate-spin" /> : <RefreshCw className="size-3.5" />}
-                  {t('lpr.build')}
-                </Button>
-              </div>
-              {kindBlock('qso', t('lpr.kQso'))}
-              {kindBlock('addr', t('lpr.kAddr'))}
-              {kindBlock('ret', t('lpr.kRet'))}
-              {allPages.length > 0 && (
-                <div className="flex items-center gap-3">
-                  <Button size="sm" className="h-8" onClick={() => void openPdf()}>
-                    <Printer className="size-3.5" /> {t('lpr.openPdf', { n: allPages.length })}
-                  </Button>
-                  {pdfPath && <span className="text-xs text-success flex items-center gap-1"><Check className="size-3.5" />{pdfPath}</span>}
-                </div>
-              )}
-              {/* mark as sent */}
-              {(pages.qso.length > 0 || pages.addr.length > 0) && (
-                <div className="rounded-lg border border-border p-3 space-y-2">
-                  <div className="text-sm font-semibold">{t('lpr.markTitle')}</div>
-                  <div className="text-xs text-muted-foreground">{t('lpr.markHint')}</div>
-                  <div className="flex items-center gap-2">
-                    <input type="date" className="h-8 rounded-md border border-input bg-background px-2 text-xs"
-                      value={markDate} onChange={(ev) => setMarkDate(ev.target.value)} />
-                    <Button size="sm" className="h-8" onClick={() => void markSent()} disabled={marked > 0}>
-                      <Check className="size-3.5" /> {t('lpr.markBtn', { n: sumQsos })}
-                    </Button>
-                    {marked > 0 && <span className="text-xs text-success">{t('lpr.markDone', { n: marked })}</span>}
-                  </div>
-                </div>
-              )}
-            </div>
-          )}
-        </div>
-
-        {/* footer nav */}
-        <div className="flex items-center gap-2 px-4 py-2.5 border-t border-border shrink-0">
-          {step !== 'pick' && (
-            <Button variant="outline" size="sm" className="h-8"
-              onClick={() => setStep(step === 'print' ? 'review' : 'pick')}>
-              <ChevronLeft className="size-3.5" /> {t('lpr.back')}
-            </Button>
-          )}
-          <div className="flex-1" />
-          {step === 'pick' && (
-            <Button size="sm" className="h-8" disabled={picked.length === 0} onClick={() => setStep('review')}>
-              {t('lpr.next')} <ChevronRight className="size-3.5" />
-            </Button>
-          )}
-          {step === 'review' && (
-            <Button size="sm" className="h-8"
-              disabled={needAddress.some((s) => !s.address.trim())}
-              title={needAddress.some((s) => !s.address.trim()) ? t('lpr.missingAddr') : undefined}
-              onClick={() => setStep('print')}>
-              {t('lpr.next')} <ChevronRight className="size-3.5" />
-            </Button>
-          )}
-        </div>
-      </div>
-    </div>
-  );
-}

frontend/src/components/labels/labelRender.ts

@@ -1,190 +0,0 @@
-// labelRender draws a label template onto a canvas. It is THE renderer: the
-// designer's preview and (later) the pages rasterised into the print PDF both
-// come through here, which is what makes the preview trustworthy — there is no
-// second implementation to disagree with it.
-//
-// The canvas is scaled so that 1 mm = `scale` px; print passes dpi/25.4, the
-// preview passes whatever fits its box. All layout maths stays in mm.
-
-import type { LabelElement, LabelSample, LabelStock, LabelTemplate } from './labelTypes';
-
-export interface RenderData {
-  // Variable values for text/address elements (<CALL> → value). Missing keys
-  // render as the bare <NAME> so the designer can SEE an unresolved variable.
-  vars: Record<string, string>;
-  // Rows for the qso_table element.
-  qsos: LabelSample[];
-}
-
-export interface ElementBox { x: number; y: number; w: number; h: number } // mm
-
-const PT_TO_MM = 25.4 / 72;
-
-// resolveVars substitutes <VAR> markers, collapsing to '' only when the value
-// is known-empty; unknown markers stay visible on purpose.
-export function resolveVars(text: string, vars: Record<string, string>): string {
-  return text.replace(/<([A-Z_]+)>/g, (m, k) => (k in vars ? vars[k] : m));
-}
-
-// render draws the whole label and returns each element's bounding box in mm —
-// the editor's hit-testing works off these, so a drag grabs exactly what was
-// painted, table rows included.
-export function render(
-  ctx: CanvasRenderingContext2D,
-  t: LabelTemplate,
-  stock: LabelStock,
-  data: RenderData,
-  scale: number,
-): ElementBox[] {
-  const W = stock.w_mm, H = stock.h_mm;
-  ctx.save();
-  ctx.scale(scale, scale);
-  // The physical label: white, whatever the app theme — this is paper.
-  ctx.fillStyle = '#fff';
-  ctx.fillRect(0, 0, W, H);
-  ctx.fillStyle = '#000';
-
-  // The canvas thinks in mm from here on; fonts are set per element in pt and
-  // drawn with an unscaled-pt trick: setTransform back to px for text quality.
-  const boxes: ElementBox[] = [];
-  for (const e of t.elements) {
-    boxes.push(drawElement(ctx, e, t, data, scale));
-  }
-  ctx.restore();
-  return boxes;
-}
-
-// drawMargins paints the unprintable border as a dashed guide — editor only,
-// never part of a print rasterisation.
-export function drawMargins(ctx: CanvasRenderingContext2D, stock: LabelStock, scale: number): void {
-  ctx.save();
-  ctx.scale(scale, scale);
-  ctx.strokeStyle = 'rgba(80,140,255,0.55)';
-  ctx.lineWidth = 0.15;
-  ctx.setLineDash([1.2, 1.2]);
-  ctx.strokeRect(
-    stock.margin_left_mm, stock.margin_top_mm,
-    stock.w_mm - stock.margin_left_mm - stock.margin_right_mm,
-    stock.h_mm - stock.margin_top_mm - stock.margin_bottom_mm,
-  );
-  ctx.restore();
-}
-
-function drawText(
-  ctx: CanvasRenderingContext2D, text: string, xMm: number, yTopMm: number,
-  wMm: number | undefined, sizePt: number, scale: number,
-  opts: { bold?: boolean; italic?: boolean; align?: string; face?: string },
-): number {
-  // Text is drawn in PX space (resetting the mm scale) so the browser rasterises
-  // the font at device resolution instead of scaling a 1-mm-tall glyph up.
-  const hMm = sizePt * PT_TO_MM;
-  ctx.save();
-  ctx.setTransform(1, 0, 0, 1, 0, 0);
-  // The font is specified in px = (pt → mm) × scale, so a 10 pt line measures
-  // exactly 10 pt on the printed label whatever the preview zoom is.
-  ctx.font = `${opts.italic ? 'italic ' : ''}${opts.bold ? 'bold ' : ''}${hMm * scale}px ${opts.face && opts.face.trim() ? opts.face : 'Arial, Helvetica, sans-serif'}`;
-  ctx.fillStyle = '#000';
-  ctx.textBaseline = 'top';
-  let x = xMm * scale;
-  if (wMm && opts.align === 'center') {
-    ctx.textAlign = 'center';
-    x = (xMm + wMm / 2) * scale;
-  } else if (wMm && opts.align === 'right') {
-    ctx.textAlign = 'right';
-    x = (xMm + wMm) * scale;
-  } else {
-    ctx.textAlign = 'left';
-  }
-  ctx.fillText(text, x, yTopMm * scale);
-  ctx.restore();
-  return hMm;
-}
-
-function drawElement(
-  ctx: CanvasRenderingContext2D, e: LabelElement, t: LabelTemplate,
-  data: RenderData, scale: number,
-): ElementBox {
-  switch (e.type) {
-    case 'text': {
-      const size = e.size_pt || 9;
-      const text = resolveVars(e.text ?? '', data.vars);
-      drawText(ctx, text, e.x_mm, e.y_mm, e.w_mm, size, scale,
-        { bold: e.bold, italic: e.italic, align: e.align, face: t.font });
-      const h = size * PT_TO_MM * 1.25;
-      return { x: e.x_mm, y: e.y_mm, w: e.w_mm || Math.max(20, text.length * size * PT_TO_MM * 0.55), h };
-    }
-    case 'line': {
-      const th = e.thickness_mm || 0.3;
-      ctx.fillStyle = '#000';
-      ctx.fillRect(e.x_mm, e.y_mm, e.w_mm || 10, th);
-      // A hairline is a 0.3 mm target nobody can grab; the box pads it.
-      return { x: e.x_mm, y: e.y_mm - 0.8, w: e.w_mm || 10, h: th + 1.6 };
-    }
-    case 'addr_block': {
-      const size = e.size_pt || 11;
-      const gap = e.line_gap_mm ?? 1.5;
-      // Collapse-empty is the point of the block: a missing street must pull
-      // the city UP, not leave a hole in the middle of an address.
-      const lines = (e.lines ?? [])
-        .map((l) => resolveVars(l, data.vars).trim())
-        .filter((l) => l !== '');
-      let y = e.y_mm;
-      let maxW = 0;
-      for (const l of lines) {
-        const h = drawText(ctx, l, e.x_mm, y, undefined, size, scale,
-          { bold: e.bold, italic: e.italic, face: t.font });
-        y += h + gap;
-        maxW = Math.max(maxW, l.length * size * PT_TO_MM * 0.55);
-      }
-      return { x: e.x_mm, y: e.y_mm, w: Math.max(20, maxW), h: Math.max(4, y - e.y_mm) };
-    }
-    case 'qso_table': {
-      const cols = e.columns ?? [];
-      const size = e.size_pt || 7.5;
-      const rowH = e.row_h_mm || 4;
-      const wTot = cols.reduce((a, c) => a + c.w_mm, 0);
-      let y = e.y_mm;
-      if (e.header) {
-        let x = e.x_mm;
-        for (const c of cols) {
-          drawText(ctx, c.label, x + 0.6, y + (rowH - size * PT_TO_MM) / 2, c.w_mm - 1.2, size, scale,
-            { bold: true, align: c.align, face: t.font });
-          x += c.w_mm;
-        }
-        // Rule under the header, not a full grid: on a 29 mm label the grid IS
-        // the noise.
-        ctx.fillStyle = '#000';
-        ctx.fillRect(e.x_mm, y + rowH - 0.25, wTot, 0.25);
-        y += rowH;
-      }
-      const rows = data.qsos.slice(0, e.rows_max || 4);
-      for (const q of rows) {
-        let x = e.x_mm;
-        for (const c of cols) {
-          const v = String((q as any)[c.field] ?? '');
-          drawText(ctx, v, x + 0.6, y + (rowH - size * PT_TO_MM) / 2, c.w_mm - 1.2, size, scale,
-            { align: c.align, face: t.font });
-          x += c.w_mm;
-        }
-        y += rowH;
-      }
-      return { x: e.x_mm, y: e.y_mm, w: wTot, h: y - e.y_mm };
-    }
-  }
-  return { x: e.x_mm, y: e.y_mm, w: 10, h: 4 };
-}
-
-// rasterize renders one label at the stock's dpi and returns a PNG data URL —
-// the pages handed to the PDF exporter. Same renderer as the preview, only the
-// scale changes, which is the whole guarantee of the feature.
-export function rasterize(
-  t: LabelTemplate, stock: LabelStock, data: RenderData,
-): string {
-  const scale = (stock.dpi || 300) / 25.4; // px per mm
-  const cv = document.createElement('canvas');
-  cv.width = Math.round(stock.w_mm * scale);
-  cv.height = Math.round(stock.h_mm * scale);
-  const ctx = cv.getContext('2d')!;
-  render(ctx, t, stock, data, scale);
-  return cv.toDataURL('image/png');
-}

frontend/src/components/labels/labelTypes.ts

@@ -1,118 +0,0 @@
-// TypeScript mirror of the label template schema (v1) defined in
-// internal/labels/labels.go. Documents cross the Wails boundary as JSON
-// strings; these types are the frontend's contract with that schema.
-//
-// Everything is in MILLIMETRES — pixels only exist inside labelRender, at the
-// stock's dpi. See the Go package comment for why.
-
-export interface LabelStock {
-  id?: number;
-  name: string;
-  w_mm: number;
-  h_mm: number;
-  margin_top_mm: number;
-  margin_right_mm: number;
-  margin_bottom_mm: number;
-  margin_left_mm: number;
-  dpi: number;
-}
-
-export interface LabelColumn {
-  field: string;
-  label: string;
-  w_mm: number;
-  align?: 'left' | 'center' | 'right';
-}
-
-export interface LabelElement {
-  type: 'text' | 'line' | 'qso_table' | 'addr_block';
-  x_mm: number;
-  y_mm: number;
-  w_mm?: number;
-  // text
-  text?: string;
-  size_pt?: number;
-  bold?: boolean;
-  italic?: boolean;
-  align?: 'left' | 'center' | 'right';
-  // line
-  thickness_mm?: number;
-  // qso_table
-  columns?: LabelColumn[];
-  rows_max?: number;
-  row_h_mm?: number;
-  header?: boolean;
-  // addr_block
-  lines?: string[];
-  line_gap_mm?: number;
-}
-
-export interface LabelTemplate {
-  version: 1;
-  kind: 'qso' | 'address';
-  name?: string;
-  stock_id: number;
-  font?: string;
-  elements: LabelElement[];
-}
-
-export interface LabelSample {
-  callsign: string; qso_date: string; time_on: string; band: string;
-  freq: string; mode: string; rst_sent: string; rst_rcvd: string;
-  name: string; qth: string; country: string;
-}
-
-// The QSO-table columns the designer offers, with default widths that fit their
-// content at 8 pt — the operator adjusts from there against real data.
-export const TABLE_FIELDS: { field: string; label: string; w_mm: number }[] = [
-  { field: 'qso_date', label: 'Date', w_mm: 17 },
-  { field: 'time_on', label: 'UTC', w_mm: 10 },
-  { field: 'band', label: 'Band', w_mm: 10 },
-  { field: 'freq', label: 'MHz', w_mm: 13 },
-  { field: 'mode', label: 'Mode', w_mm: 11 },
-  { field: 'rst_sent', label: 'RST', w_mm: 9 },
-  { field: 'rst_rcvd', label: 'RST rx', w_mm: 9 },
-];
-
-// The variables a text or address element may carry. Resolution at PRINT time
-// uses the real QSO/profile; the designer resolves them against the sample so
-// the preview reads like a finished label.
-export const LABEL_VARS = [
-  'CALL', 'NAME', 'QTH', 'COUNTRY', 'VIA',
-  'STREET', 'ZIP', 'CITY', 'STATE',
-  'MYCALL', 'MYNAME', 'MYSTREET', 'MYZIP', 'MYCITY', 'MYCOUNTRY',
-] as const;
-
-// Starter documents for a fresh template — a usable label, not a blank page:
-// an empty canvas asks the operator to invent the feature, a finished-looking
-// starter only asks them to adjust it.
-export function starterTemplate(kind: 'qso' | 'address', stock: LabelStock): LabelTemplate {
-  const w = stock.w_mm - stock.margin_left_mm - stock.margin_right_mm;
-  const x = stock.margin_left_mm;
-  if (kind === 'qso') {
-    return {
-      version: 1, kind, stock_id: stock.id ?? 0,
-      elements: [
-        { type: 'text', x_mm: x, y_mm: stock.margin_top_mm + 1, w_mm: w, text: 'To Radio <CALL>', size_pt: 10, bold: true },
-        { type: 'line', x_mm: x, y_mm: stock.margin_top_mm + 6.2, w_mm: w, thickness_mm: 0.3 },
-        {
-          type: 'qso_table', x_mm: x, y_mm: stock.margin_top_mm + 7.5, w_mm: w,
-          rows_max: Math.max(1, Math.min(5, Math.floor((stock.h_mm - stock.margin_top_mm - stock.margin_bottom_mm - 12) / 4))),
-          row_h_mm: 4, header: true, size_pt: 7.5,
-          columns: TABLE_FIELDS.slice(0, 6).map((c) => ({ ...c })),
-        } as LabelElement,
-        { type: 'text', x_mm: x, y_mm: stock.h_mm - stock.margin_bottom_mm - 4, w_mm: w, text: 'PSE QSL · 73 de <MYCALL>', size_pt: 8 },
-      ],
-    };
-  }
-  return {
-    version: 1, kind, stock_id: stock.id ?? 0,
-    elements: [
-      {
-        type: 'addr_block', x_mm: x + 2, y_mm: stock.margin_top_mm + 3,
-        lines: ['<NAME> · <CALL>', '<STREET>', '<ZIP> <CITY>', '<COUNTRY>'],
-        size_pt: 11, line_gap_mm: 1.6,
-      },
-    ],
-  };
-}

frontend/src/lib/bandplan.ts

@@ -0,0 +1,113 @@
+// IARU band plans, by region.
+//
+// The band maps used to carry one hard-coded table — Region 1's — so a US or
+// Australian operator saw 40 m stop at 7200 while stations sat spotted at 7250,
+// and the SSB wash started 25 kHz early. The region is a station-level fact the
+// operator states once (Settings → General); everything drawing a band edge or
+// a mode segment reads it from here.
+//
+// The tables are deliberately coarse: a band map's wash is CONTEXT, not a
+// regulatory chart. Only the segments that differ between regions in ways an
+// operator notices are split out; national fine print (US licence classes,
+// beacon slots) does not belong in a background tint.
+import { writeUiPref } from '@/lib/uiPref';
+
+export type IaruRegion = 1 | 2 | 3;
+export const KEY_IARU_REGION = 'opslog.iaruRegion';
+
+export function iaruRegion(): IaruRegion {
+  try {
+    const v = localStorage.getItem(KEY_IARU_REGION);
+    return v === '2' ? 2 : v === '3' ? 3 : 1;
+  } catch { return 1; }
+}
+
+export function setIaruRegion(r: IaruRegion): void {
+  writeUiPref(KEY_IARU_REGION, String(r));
+  listeners.forEach((l) => l());
+}
+
+// The band maps capture the plan inside their render, so a change must reach
+// them the way the distance unit reaches the grids.
+const listeners = new Set<() => void>();
+export function subscribeIaruRegion(fn: () => void): () => void {
+  listeners.add(fn);
+  return () => { listeners.delete(fn); };
+}
+
+export type SegMode = 'cw' | 'digi' | 'phone';
+type Seg = [number, number, SegMode];
+
+interface Plan {
+  ranges: Record<string, [number, number]>;
+  segments: Record<string, Seg[]>;
+}
+
+// Region 1 — Europe / Africa / Middle East / northern Asia. The baseline the
+// other two override.
+const R1: Plan = {
+  ranges: {
+    '160m': [1800, 2000], '80m': [3500, 3800], '60m': [5350, 5450],
+    '40m': [7000, 7200], '30m': [10100, 10150], '20m': [14000, 14350],
+    '17m': [18068, 18168], '15m': [21000, 21450], '12m': [24890, 24990],
+    '10m': [28000, 29700], '6m': [50000, 50500], '4m': [70000, 70500],
+    '2m': [144000, 146000], '70cm': [430000, 440000],
+  },
+  segments: {
+    '160m': [[1800, 1838, 'cw'], [1838, 1840, 'digi'], [1840, 2000, 'phone']],
+    '80m': [[3500, 3580, 'cw'], [3580, 3600, 'digi'], [3600, 3800, 'phone']],
+    '60m': [[5350, 5450, 'phone']],
+    '40m': [[7000, 7040, 'cw'], [7040, 7100, 'digi'], [7100, 7200, 'phone']],
+    '30m': [[10100, 10130, 'cw'], [10130, 10150, 'digi']],
+    '20m': [[14000, 14070, 'cw'], [14070, 14100, 'digi'], [14100, 14350, 'phone']],
+    '17m': [[18068, 18095, 'cw'], [18095, 18110, 'digi'], [18110, 18168, 'phone']],
+    '15m': [[21000, 21070, 'cw'], [21070, 21150, 'digi'], [21150, 21450, 'phone']],
+    '12m': [[24890, 24915, 'cw'], [24915, 24940, 'digi'], [24940, 24990, 'phone']],
+    '10m': [[28000, 28070, 'cw'], [28070, 28300, 'digi'], [28300, 29700, 'phone']],
+    '6m': [[50000, 50100, 'cw'], [50100, 50500, 'phone']],
+  },
+};
+
+// Region 2 — the Americas. 80 m runs to 4000 and 40 m to 7300, with phone from
+// 7125 (the whole point of asking the region: a KP4 ragchew on 7250 must not
+// hang past the top of the map).
+const R2: Plan = {
+  ranges: {
+    ...R1.ranges,
+    '80m': [3500, 4000], '40m': [7000, 7300],
+    '6m': [50000, 54000], '2m': [144000, 148000], '70cm': [420000, 450000],
+  },
+  segments: {
+    ...R1.segments,
+    '80m': [[3500, 3570, 'cw'], [3570, 3600, 'digi'], [3600, 4000, 'phone']],
+    '40m': [[7000, 7040, 'cw'], [7040, 7125, 'digi'], [7125, 7300, 'phone']],
+    '6m': [[50000, 50100, 'cw'], [50100, 54000, 'phone']],
+  },
+};
+
+// Region 3 — Asia-Pacific. 80 m to 3900; 40 m as Region 1's shape.
+const R3: Plan = {
+  ranges: {
+    ...R1.ranges,
+    '80m': [3500, 3900],
+    '6m': [50000, 54000], '2m': [144000, 148000], '70cm': [430000, 450000],
+  },
+  segments: {
+    ...R1.segments,
+    '80m': [[3500, 3535, 'cw'], [3535, 3600, 'digi'], [3600, 3900, 'phone']],
+    '6m': [[50000, 50100, 'cw'], [50100, 54000, 'phone']],
+  },
+};
+
+function plan(): Plan {
+  const r = iaruRegion();
+  return r === 2 ? R2 : r === 3 ? R3 : R1;
+}
+
+export function bandRange(band: string): [number, number] | undefined {
+  return plan().ranges[band];
+}
+
+export function bandSegments(band: string): Seg[] {
+  return plan().segments[band] ?? [];
+}

frontend/src/lib/spotDisplay.ts

@@ -11,7 +11,25 @@
 //
 // They compose deliberately: mute what is done, light up what is not.
 
-export type SpotDisplayOptions = { muteWorked: boolean; slotHighlight: boolean };
+export type SpotDisplayOptions = {
+  muteWorked: boolean; slotHighlight: boolean;
+  // Chase switches (Settings → DX Cluster), ON by default. An operator who does
+  // not chase parks does not want NEW POTA shouting from every activator spot:
+  // off, the marker is withdrawn at the display layer — a "new band + new POTA"
+  // spot simply reads NEW BAND — and the reference column goes quiet. The facts
+  // keep being computed; only the telling stops, so ticking the box back on
+  // needs no rescan.
+  chasePota: boolean; chaseSota: boolean;
+};
+
+// chasePota/chaseSota read the switches directly — for the places that show a
+// REFERENCE rather than a status (the POTA and SOTA columns).
+export function chasePota(): boolean {
+  try { return localStorage.getItem('opslog.chasePota') !== '0'; } catch { return true; }
+}
+export function chaseSota(): boolean {
+  try { return localStorage.getItem('opslog.chaseSota') !== '0'; } catch { return true; }
+}
 
 // Both options are withdrawn from the filter panel for now. The machinery below
 // is deliberately kept whole — it is correct and hard-won — so putting the two
@@ -23,14 +41,19 @@ export type SpotDisplayOptions = { muteWorked: boolean; slotHighlight: boolean }
 export const SPOT_DISPLAY_OPTIONS_EXPOSED = false;
 
 export function readSpotDisplayOptions(): SpotDisplayOptions {
-  if (!SPOT_DISPLAY_OPTIONS_EXPOSED) return { muteWorked: false, slotHighlight: false };
+  // The EXPOSED flag only withdraws the two original switches; the chase
+  // switches are live regardless.
+  if (!SPOT_DISPLAY_OPTIONS_EXPOSED) {
+    return { muteWorked: false, slotHighlight: false, chasePota: chasePota(), chaseSota: chaseSota() };
+  }
   try {
     return {
       muteWorked: localStorage.getItem('opslog.clusterMuteWorked') === '1',
       slotHighlight: localStorage.getItem('opslog.clusterSlotHighlight') === '1',
+      chasePota: chasePota(), chaseSota: chaseSota(),
     };
   } catch {
-    return { muteWorked: false, slotHighlight: false };
+    return { muteWorked: false, slotHighlight: false, chasePota: true, chaseSota: true };
   }
 }
 
@@ -72,6 +95,9 @@ export function applySpotDisplay<T extends Entry>(s: T, o: SpotDisplayOptions):
   if (o.muteWorked) {
     e = { ...e, worked_call: false } as NonNullable<T>;
   }
+  if (!o.chasePota && e.new_pota) {
+    e = { ...e, new_pota: false } as NonNullable<T>;
+  }
   return e;
 }
 

frontend/src/lib/uiPref.ts

@@ -41,6 +41,9 @@ const PORTABLE_KEYS = [
   'opslog.clusterLockBand', 'opslog.clusterLockMode', 'opslog.clusterStatusFilter',
   'opslog.clusterModeFilter', 'opslog.clusterSearch', 'opslog.clusterHideWorked',
   'opslog.distanceMiles', // distances shown in statute miles rather than km
+  'opslog.iaruRegion',    // IARU region (1/2/3) — band edges and segments on the band maps
+  'opslog.chasePota',     // show POTA references and the NEW POTA marker on spots
+  'opslog.chaseSota',     // show SOTA references on spots
   'opslog.activeTab',     // last selected tab
   'opslog.mainSplit',    // Main tab: width share of the left pane (percent) — legacy, read once to seed mainShares
   'opslog.mainShares',   // Main tab: column shares per column count, as {2:[..],3:[..],4:[..]}

frontend/src/version.ts

@@ -1,6 +1,6 @@
 // Single source of truth for the app version shown in the UI (header + About).
 // Bump this on a release (the release script updates it alongside telemetry.go).
-export const APP_VERSION = '0.26.22';
+export const APP_VERSION = '0.27.0';
 
 // Author / credits, shown in Help -> About.
 export const APP_AUTHOR = 'F4BPO';

frontend/wailsjs/go/main/App.d.ts

@@ -21,7 +21,6 @@ import {solar} from '../models';
 import {tunergenius} from '../models';
 import {webpub} from '../models';
 import {winkeyer} from '../models';
-import {labels} from '../models';
 import {alerts} from '../models';
 import {audio} from '../models';
 import {contest} from '../models';
@@ -31,6 +30,7 @@ import {lotwusers} from '../models';
 import {lookup} from '../models';
 import {netctl} from '../models';
 import {scp} from '../models';
+import {watchlist} from '../models';
 
 export function ACOMSetOperate(arg1:boolean):Promise<void>;
 
@@ -602,6 +602,8 @@ export function GetUltrabeamSettings():Promise<main.UltrabeamSettings>;
 
 export function GetUltrabeamStatus():Promise<main.UltrabeamStatusInfo>;
 
+export function GetWatchlistContestPattern():Promise<string>;
+
 export function GetWebPublishConfig():Promise<webpub.Config>;
 
 export function GetWebPublishStatus():Promise<main.WebPublishStatus>;
@@ -726,28 +728,6 @@ export function KenwoodSendCW(arg1:string):Promise<void>;
 
 export function KenwoodStopCW():Promise<void>;
 
-export function LabelDeleteStock(arg1:number):Promise<void>;
-
-export function LabelDeleteTemplate(arg1:number):Promise<void>;
-
-export function LabelGetTemplate(arg1:number):Promise<string>;
-
-export function LabelListStocks():Promise<Array<labels.Stock>>;
-
-export function LabelListTemplates():Promise<Array<main.LabelTemplateInfo>>;
-
-export function LabelOpenPDF(arg1:Array<main.LabelPDFPage>):Promise<string>;
-
-export function LabelPaperQueue():Promise<Array<qso.QSO>>;
-
-export function LabelSampleQSOs(arg1:number):Promise<Array<main.LabelSampleQSO>>;
-
-export function LabelSaveStock(arg1:labels.Stock):Promise<number>;
-
-export function LabelSaveTemplate(arg1:number,arg2:string,arg3:string,arg4:boolean):Promise<number>;
-
-export function LabelSetDefaultTemplate(arg1:number):Promise<void>;
-
 export function LaunchAutostartProgram(arg1:string):Promise<main.AutostartLaunchResult>;
 
 export function LaunchAutostartPrograms():Promise<Array<main.AutostartLaunchResult>>;
@@ -1168,6 +1148,8 @@ export function SetKenwoodNB(arg1:boolean):Promise<void>;
 
 export function SetKenwoodNR(arg1:boolean):Promise<void>;
 
+export function SetKenwoodPanelMode(arg1:string):Promise<void>;
+
 export function SetKenwoodPower(arg1:number):Promise<void>;
 
 export function SetKenwoodPreamp(arg1:boolean):Promise<void>;
@@ -1176,6 +1158,8 @@ export function SetKenwoodRFGain(arg1:number):Promise<void>;
 
 export function SetKenwoodRIT(arg1:boolean):Promise<void>;
 
+export function SetKenwoodRITOffset(arg1:number):Promise<void>;
+
 export function SetKenwoodSquelch(arg1:number):Promise<void>;
 
 export function SetKenwoodTX(arg1:boolean):Promise<void>;
@@ -1246,6 +1230,8 @@ export function SetUIPref(arg1:string,arg2:string):Promise<void>;
 
 export function SetUltrabeamDirection(arg1:number):Promise<void>;
 
+export function SetWatchlistContestPattern(arg1:string):Promise<void>;
+
 export function SetWinkeyerTrace(arg1:boolean):Promise<void>;
 
 export function SetWorkedCallVariants(arg1:boolean):Promise<void>;
@@ -1376,6 +1362,18 @@ export function UploadCallsign(arg1:string):Promise<string>;
 
 export function UploadQSOsManual(arg1:string,arg2:Array<number>):Promise<void>;
 
+export function WatchlistAdd(arg1:string,arg2:boolean):Promise<void>;
+
+export function WatchlistEntries():Promise<Array<watchlist.Entry>>;
+
+export function WatchlistRemove(arg1:string):Promise<void>;
+
+export function WatchlistSetContest(arg1:string,arg2:boolean):Promise<void>;
+
+export function WatchlistSetNotify(arg1:string,arg2:boolean):Promise<void>;
+
+export function WatchlistWorkedSlots(arg1:Array<main.WatchlistSlotQuery>):Promise<Array<boolean>>;
+
 export function WebPublishColumns():Promise<Array<Record<string, string>>>;
 
 export function WinkeyerBackspace():Promise<void>;

frontend/wailsjs/go/main/App.js

@@ -1142,6 +1142,10 @@ export function GetUltrabeamStatus() {
   return window['go']['main']['App']['GetUltrabeamStatus']();
 }
 
+export function GetWatchlistContestPattern() {
+  return window['go']['main']['App']['GetWatchlistContestPattern']();
+}
+
 export function GetWebPublishConfig() {
   return window['go']['main']['App']['GetWebPublishConfig']();
 }
@@ -1390,50 +1394,6 @@ export function KenwoodStopCW() {
   return window['go']['main']['App']['KenwoodStopCW']();
 }
 
-export function LabelDeleteStock(arg1) {
-  return window['go']['main']['App']['LabelDeleteStock'](arg1);
-}
-
-export function LabelDeleteTemplate(arg1) {
-  return window['go']['main']['App']['LabelDeleteTemplate'](arg1);
-}
-
-export function LabelGetTemplate(arg1) {
-  return window['go']['main']['App']['LabelGetTemplate'](arg1);
-}
-
-export function LabelListStocks() {
-  return window['go']['main']['App']['LabelListStocks']();
-}
-
-export function LabelListTemplates() {
-  return window['go']['main']['App']['LabelListTemplates']();
-}
-
-export function LabelOpenPDF(arg1) {
-  return window['go']['main']['App']['LabelOpenPDF'](arg1);
-}
-
-export function LabelPaperQueue() {
-  return window['go']['main']['App']['LabelPaperQueue']();
-}
-
-export function LabelSampleQSOs(arg1) {
-  return window['go']['main']['App']['LabelSampleQSOs'](arg1);
-}
-
-export function LabelSaveStock(arg1) {
-  return window['go']['main']['App']['LabelSaveStock'](arg1);
-}
-
-export function LabelSaveTemplate(arg1, arg2, arg3, arg4) {
-  return window['go']['main']['App']['LabelSaveTemplate'](arg1, arg2, arg3, arg4);
-}
-
-export function LabelSetDefaultTemplate(arg1) {
-  return window['go']['main']['App']['LabelSetDefaultTemplate'](arg1);
-}
-
 export function LaunchAutostartProgram(arg1) {
   return window['go']['main']['App']['LaunchAutostartProgram'](arg1);
 }
@@ -2274,6 +2234,10 @@ export function SetKenwoodNR(arg1) {
   return window['go']['main']['App']['SetKenwoodNR'](arg1);
 }
 
+export function SetKenwoodPanelMode(arg1) {
+  return window['go']['main']['App']['SetKenwoodPanelMode'](arg1);
+}
+
 export function SetKenwoodPower(arg1) {
   return window['go']['main']['App']['SetKenwoodPower'](arg1);
 }
@@ -2290,6 +2254,10 @@ export function SetKenwoodRIT(arg1) {
   return window['go']['main']['App']['SetKenwoodRIT'](arg1);
 }
 
+export function SetKenwoodRITOffset(arg1) {
+  return window['go']['main']['App']['SetKenwoodRITOffset'](arg1);
+}
+
 export function SetKenwoodSquelch(arg1) {
   return window['go']['main']['App']['SetKenwoodSquelch'](arg1);
 }
@@ -2430,6 +2398,10 @@ export function SetUltrabeamDirection(arg1) {
   return window['go']['main']['App']['SetUltrabeamDirection'](arg1);
 }
 
+export function SetWatchlistContestPattern(arg1) {
+  return window['go']['main']['App']['SetWatchlistContestPattern'](arg1);
+}
+
 export function SetWinkeyerTrace(arg1) {
   return window['go']['main']['App']['SetWinkeyerTrace'](arg1);
 }
@@ -2690,6 +2662,30 @@ export function UploadQSOsManual(arg1, arg2) {
   return window['go']['main']['App']['UploadQSOsManual'](arg1, arg2);
 }
 
+export function WatchlistAdd(arg1, arg2) {
+  return window['go']['main']['App']['WatchlistAdd'](arg1, arg2);
+}
+
+export function WatchlistEntries() {
+  return window['go']['main']['App']['WatchlistEntries']();
+}
+
+export function WatchlistRemove(arg1) {
+  return window['go']['main']['App']['WatchlistRemove'](arg1);
+}
+
+export function WatchlistSetContest(arg1, arg2) {
+  return window['go']['main']['App']['WatchlistSetContest'](arg1, arg2);
+}
+
+export function WatchlistSetNotify(arg1, arg2) {
+  return window['go']['main']['App']['WatchlistSetNotify'](arg1, arg2);
+}
+
+export function WatchlistWorkedSlots(arg1) {
+  return window['go']['main']['App']['WatchlistWorkedSlots'](arg1);
+}
+
 export function WebPublishColumns() {
   return window['go']['main']['App']['WebPublishColumns']();
 }

frontend/wailsjs/go/models.ts

@@ -1072,6 +1072,7 @@ export namespace cat {
 	    model?: string;
 	    elecraft: boolean;
 	    mode?: string;
+	    data_sub?: string;
 	    transmitting: boolean;
 	    split: boolean;
 	    split_tx_hz: number;
@@ -1108,6 +1109,7 @@ export namespace cat {
 	        this.model = source["model"];
 	        this.elecraft = source["elecraft"];
 	        this.mode = source["mode"];
+	        this.data_sub = source["data_sub"];
 	        this.transmitting = source["transmitting"];
 	        this.split = source["split"];
 	        this.split_tx_hz = source["split_tx_hz"];
@@ -1617,39 +1619,6 @@ export namespace kpa {
 
 }
 
-export namespace labels {
-	
-	export class Stock {
-	    id?: number;
-	    name: string;
-	    w_mm: number;
-	    h_mm: number;
-	    margin_top_mm: number;
-	    margin_right_mm: number;
-	    margin_bottom_mm: number;
-	    margin_left_mm: number;
-	    dpi: number;
-	
-	    static createFrom(source: any = {}) {
-	        return new Stock(source);
-	    }
-	
-	    constructor(source: any = {}) {
-	        if ('string' === typeof source) source = JSON.parse(source);
-	        this.id = source["id"];
-	        this.name = source["name"];
-	        this.w_mm = source["w_mm"];
-	        this.h_mm = source["h_mm"];
-	        this.margin_top_mm = source["margin_top_mm"];
-	        this.margin_right_mm = source["margin_right_mm"];
-	        this.margin_bottom_mm = source["margin_bottom_mm"];
-	        this.margin_left_mm = source["margin_left_mm"];
-	        this.dpi = source["dpi"];
-	    }
-	}
-
-}
-
 export namespace lookup {
 	
 	export class Result {
@@ -2969,78 +2938,6 @@ export namespace main {
 	        this.samples = source["samples"];
 	    }
 	}
-	export class LabelPDFPage {
-	    png: string;
-	    w_mm: number;
-	    h_mm: number;
-	
-	    static createFrom(source: any = {}) {
-	        return new LabelPDFPage(source);
-	    }
-	
-	    constructor(source: any = {}) {
-	        if ('string' === typeof source) source = JSON.parse(source);
-	        this.png = source["png"];
-	        this.w_mm = source["w_mm"];
-	        this.h_mm = source["h_mm"];
-	    }
-	}
-	export class LabelSampleQSO {
-	    callsign: string;
-	    qso_date: string;
-	    time_on: string;
-	    band: string;
-	    freq: string;
-	    mode: string;
-	    rst_sent: string;
-	    rst_rcvd: string;
-	    name: string;
-	    qth: string;
-	    country: string;
-	
-	    static createFrom(source: any = {}) {
-	        return new LabelSampleQSO(source);
-	    }
-	
-	    constructor(source: any = {}) {
-	        if ('string' === typeof source) source = JSON.parse(source);
-	        this.callsign = source["callsign"];
-	        this.qso_date = source["qso_date"];
-	        this.time_on = source["time_on"];
-	        this.band = source["band"];
-	        this.freq = source["freq"];
-	        this.mode = source["mode"];
-	        this.rst_sent = source["rst_sent"];
-	        this.rst_rcvd = source["rst_rcvd"];
-	        this.name = source["name"];
-	        this.qth = source["qth"];
-	        this.country = source["country"];
-	    }
-	}
-	export class LabelTemplateInfo {
-	    id: number;
-	    name: string;
-	    kind: string;
-	    stock_id: number;
-	    profile_id?: number;
-	    is_default: boolean;
-	    updated_at: string;
-	
-	    static createFrom(source: any = {}) {
-	        return new LabelTemplateInfo(source);
-	    }
-	
-	    constructor(source: any = {}) {
-	        if ('string' === typeof source) source = JSON.parse(source);
-	        this.id = source["id"];
-	        this.name = source["name"];
-	        this.kind = source["kind"];
-	        this.stock_id = source["stock_id"];
-	        this.profile_id = source["profile_id"];
-	        this.is_default = source["is_default"];
-	        this.updated_at = source["updated_at"];
-	    }
-	}
 	export class ModePreset {
 	    name: string;
 	    default_rst_sent?: string;
@@ -4404,6 +4301,24 @@ export namespace main {
 	        this.text = source["text"];
 	    }
 	}
+	export class WatchlistSlotQuery {
+	    call: string;
+	    band: string;
+	    mode: string;
+	    contest: boolean;
+	
+	    static createFrom(source: any = {}) {
+	        return new WatchlistSlotQuery(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.call = source["call"];
+	        this.band = source["band"];
+	        this.mode = source["mode"];
+	        this.contest = source["contest"];
+	    }
+	}
 	export class WebPublishStatus {
 	    last_run: string;
 	    last_err: string;
@@ -5243,7 +5158,6 @@ export namespace qso {
 	    band?: string;
 	    mode?: string;
 	    station_callsign?: string;
-	    qsl_sent_in?: string[];
 	    limit?: number;
 	    offset?: number;
 	
@@ -5257,7 +5171,6 @@ export namespace qso {
 	        this.band = source["band"];
 	        this.mode = source["mode"];
 	        this.station_callsign = source["station_callsign"];
-	        this.qsl_sent_in = source["qsl_sent_in"];
 	        this.limit = source["limit"];
 	        this.offset = source["offset"];
 	    }
@@ -6095,6 +6008,68 @@ export namespace udp {
 
 }
 
+export namespace watchlist {
+	
+	export class Entry {
+	    callsign: string;
+	    // Go type: time
+	    lastSeen: any;
+	    lastSeenStr: string;
+	    // Go type: time
+	    addedAt: any;
+	    spotCount: number;
+	    isContest: boolean;
+	    notify: boolean;
+	    isExpedition: boolean;
+	    clubLogQSOs24h: number;
+	    clubLogTotalQSOs: number;
+	    clubLogHasOQRS: boolean;
+	    clubLogLiveStream: boolean;
+	    // Go type: time
+	    clubLogUpdatedAt?: any;
+	
+	    static createFrom(source: any = {}) {
+	        return new Entry(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.callsign = source["callsign"];
+	        this.lastSeen = this.convertValues(source["lastSeen"], null);
+	        this.lastSeenStr = source["lastSeenStr"];
+	        this.addedAt = this.convertValues(source["addedAt"], null);
+	        this.spotCount = source["spotCount"];
+	        this.isContest = source["isContest"];
+	        this.notify = source["notify"];
+	        this.isExpedition = source["isExpedition"];
+	        this.clubLogQSOs24h = source["clubLogQSOs24h"];
+	        this.clubLogTotalQSOs = source["clubLogTotalQSOs"];
+	        this.clubLogHasOQRS = source["clubLogHasOQRS"];
+	        this.clubLogLiveStream = source["clubLogLiveStream"];
+	        this.clubLogUpdatedAt = this.convertValues(source["clubLogUpdatedAt"], null);
+	    }
+	
+		convertValues(a: any, classs: any, asMap: boolean = false): any {
+		    if (!a) {
+		        return a;
+		    }
+		    if (a.slice && a.map) {
+		        return (a as any[]).map(elem => this.convertValues(elem, classs));
+		    } else if ("object" === typeof a) {
+		        if (asMap) {
+		            for (const key of Object.keys(a)) {
+		                a[key] = new classs(a[key]);
+		            }
+		            return a;
+		        }
+		        return new classs(a);
+		    }
+		    return a;
+		}
+	}
+
+}
+
 export namespace webpub {
 	
 	export class Config {

internal/cat/kenwood_panel.go

@@ -35,6 +35,11 @@ type KenwoodTXState struct {
 	Model     string `json:"model,omitempty"`
 	Elecraft  bool   `json:"elecraft"` // a K3/K4 rather than a Kenwood
 	Mode      string `json:"mode,omitempty"`
+	// DataSub is the K3/K4 DATA submode while in DATA mode (DT): "DATA A",
+	// "AFSK A", "FSK D" or "PSK D". Empty on a Kenwood, and outside DATA. The
+	// panel's two DATA buttons need it to show WHICH data mode the rig is in —
+	// FT8 wants DATA A, RTTY wants FSK D, and MD6 alone cannot say which.
+	DataSub string `json:"data_sub,omitempty"`
 
 	Transmitting bool  `json:"transmitting"`
 	Split        bool  `json:"split"`
@@ -107,10 +112,12 @@ type KenwoodPanelController interface {
 	SetKenwoodRIT(bool) error
 	SetKenwoodXIT(bool) error
 	NudgeKenwoodRIT(int) error
+	SetKenwoodRITOffset(int) error
 	ClearKenwoodRIT() error
 	SetKenwoodTX(bool) error
 	TuneKenwoodATU() error
 	ToggleKenwoodATU() error
+	SetKenwoodPanelMode(string) error
 }
 
 // kenwoodPanelSlowBeat is how many polls pass between full re-reads of the
@@ -212,6 +219,14 @@ func (k *Kenwood) readPanelSettings() {
 	if v, ok := k.askNum("NR;", "NR", 1); ok {
 		k.panel.NR = v != 0
 	}
+	// The DATA submode, Elecraft only (a plain Kenwood has no DT and would "?;"
+	// it). Read every settings beat: the operator changes it from the rig's own
+	// front panel mid-session, and the two DATA buttons must follow.
+	if k.elecraft {
+		if v, ok := k.askNum("DT;", "DT", 1); ok {
+			k.panel.DataSub = kenwoodDataSubName(v)
+		}
+	}
 	if v, ok := k.askNum("GT;", "GT", 3); ok {
 		k.panel.AGC = kenwoodAGCName(v)
 	}
@@ -564,6 +579,16 @@ func (k *Kenwood) SetKenwoodXIT(on bool) error {
 
 // ClearKenwoodRIT zeroes the RIT/XIT offset, both at once — which is what RC
 // does and what the operator means by "clear it".
+// SetKenwoodRITOffset writes the offset as an ABSOLUTE value — what the shared
+// ShiftRow control speaks. Nudge stays for the keyboard clarifier; both funnel
+// into the same RO write.
+func (k *Kenwood) SetKenwoodRITOffset(hz int) error {
+	k.mu.Lock()
+	cur := k.panel.RITOffset
+	k.mu.Unlock()
+	return k.NudgeKenwoodRIT(hz - cur)
+}
+
 func (k *Kenwood) ClearKenwoodRIT() error {
 	return k.setPanel("RC;")
 }
@@ -650,3 +675,58 @@ func (k *Kenwood) askNum(cmd, prefix string, digits int) (int, bool) {
 	}
 	return n, true
 }
+
+// kenwoodDataSubName decodes DT (K3/K4 programmer's reference).
+func kenwoodDataSubName(v int) string {
+	switch v {
+	case 0:
+		return "DATA A"
+	case 1:
+		return "AFSK A"
+	case 2:
+		return "FSK D"
+	case 3:
+		return "PSK D"
+	}
+	return ""
+}
+
+// SetKenwoodPanelMode is the panel's mode row: CW / USB / LSB / DATA / RTTY.
+//
+// It exists because SetMode is the LOGGER's path — it maps an ADIF mode and
+// honours the data-mode preference — while a panel button is the operator
+// saying exactly what the rig should do. The two DATA cases are the point:
+// "DATA" is MD6 + DT0 (DATA A, the soundcard submode FT8/FT4 modulate through)
+// and "RTTY" is MD6 + DT2 (FSK D, the K3's direct-keyed RTTY). MD6 alone keeps
+// whatever submode a prior session left, which is how a K3 "in DATA" transmits
+// FT8 with no audio — the report behind this row.
+func (k *Kenwood) SetKenwoodPanelMode(mode string) error {
+	k.mu.Lock()
+	defer k.mu.Unlock()
+	if k.port == nil {
+		return fmt.Errorf("kenwood: not connected")
+	}
+	var cmds []string
+	switch strings.ToUpper(strings.TrimSpace(mode)) {
+	case "CW":
+		cmds = []string{"MD3;"}
+	case "USB":
+		cmds = []string{"MD2;"}
+	case "LSB":
+		cmds = []string{"MD1;"}
+	case "DATA":
+		cmds = []string{"MD6;", "DT0;"}
+	case "RTTY":
+		cmds = []string{"MD6;", "DT2;"}
+	default:
+		return fmt.Errorf("kenwood panel: unknown mode %q", mode)
+	}
+	for _, c := range cmds {
+		if err := k.write(c); err != nil {
+			return err
+		}
+	}
+	// Re-read the settings on the next poll so Mode and DataSub confirm at once.
+	k.panelCycle = kenwoodPanelSlowBeat
+	return nil
+}

internal/cat/tci.go

@@ -165,8 +165,7 @@ func (t *TCI) Connect() error {
 	if t.spotsEnabled {
 		debugLog.Printf("TCI: panorama spots are ON — spots will be sent to the radio")
 	}
-	_ = t.send("rx_sensors_enable:true,200;")
-	_ = t.send("tx_sensors_enable:true,200;")
+	t.subscribeSensors("connect")
 	if t.spotsEnabled {
 		// Forget what we thought was on the panorama at the same moment the radio
 		// is told to drop it. Kept, the memory would suppress the next spot for
@@ -461,6 +460,24 @@ func (t *TCI) SetTXAudioSource(src string) {
 }
 
 // send writes a command to the WebSocket (one writer at a time).
+// subscribeSensors asks the radio to push its meters. Nothing measures anything
+// until this goes out — the S-meter, the transmit power and the SWR are all
+// subscription-only (TCI §4.4) — and it is sent at connect AND again at every
+// "ready", because a subscription sent during the server's initial dump can be
+// dropped. 200 ms is the rate the protocol's own examples use.
+func (t *TCI) subscribeSensors(when string) {
+	// Both cases, deliberately. Every other command this backend sends works in
+	// lower case, but the meters stayed silent on a real SunSDR through two
+	// rounds of fixes — and the protocol document's own examples are upper case
+	// (TX_SENSORS_ENABLE:true,200;). A server that is case-insensitive ignores
+	// the duplicate; one that is not finally hears the subscription.
+	e1 := t.send("rx_sensors_enable:true,200;")
+	e2 := t.send("tx_sensors_enable:true,200;")
+	_ = t.send("RX_SENSORS_ENABLE:true,200;")
+	_ = t.send("TX_SENSORS_ENABLE:true,200;")
+	debugLog.Printf("TCI: sensor subscription sent (%s, both cases): rx=%v tx=%v", when, e1, e2)
+}
+
 func (t *TCI) send(cmd string) error {
 	t.mu.Lock()
 	c := t.conn
@@ -567,6 +584,13 @@ func (t *TCI) handle(msg string) {
 		}
 	case "ready", "start":
 		t.ready = true
+		// (Re)subscribe to the meters HERE, not only at connect. ExpertSDR3
+		// dumps its whole state and then says "ready"; a unidirectional control
+		// command sent while that dump is still in flight can be ignored, and
+		// the report from a real SunSDR — transmit meters still empty after the
+		// connect-time subscription — has exactly that shape. From a goroutine:
+		// send takes t.mu, which this handler holds.
+		go t.subscribeSensors("ready")
 	case "stop":
 		t.ready = false
 	case "vfo":

internal/cat/tci_panel.go

@@ -113,7 +113,8 @@ func (t *TCI) handlePanel(name string, get func(int) string, args string) bool {
 	// it. What the radio actually announces after the command settles whether
 	// this is our reading or its doing, and no amount of reasoning will.
 	switch name {
-	case "mute", "sql_enable", "sql_level", "tx_power", "tx_swr", "tune":
+	case "mute", "sql_enable", "sql_level", "tx_power", "tx_swr", "tune",
+		"tx_sensors", "rx_sensors", "rx_channel_sensors":
 		// Logged on arrival so an ANSWER can be told from a SILENCE: the log
 		// showed the transmit meters being asked for and nothing coming back,
 		// which on its own proves nothing — a reply that arrived and failed to

internal/db/migrations/0031_label_templates.sql

@@ -1,30 +0,0 @@
--- Label designer: printable labels for paper QSL work.
---
--- Two tables because the two things have different lifetimes. A STOCK is the
--- physical roll in the printer (width, height, margins) — one per label size,
--- shared by every design printed on it. A TEMPLATE is one design (what goes on
--- the label) and points at the stock it was drawn for. Deleting a design must
--- never take the roll definition of the other designs with it.
---
--- kind separates the two families the operator designs: 'qso' (the label glued
--- on the QSL card, with its repeating QSO table) and 'address' (destination or
--- return address). is_default is per (kind, profile scope) — printing wants
--- "the QSO label" and "the address label" without asking every time.
-CREATE TABLE label_stocks (
-    id          INTEGER PRIMARY KEY,
-    name        TEXT NOT NULL,
-    json        TEXT NOT NULL,
-    created_at  TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ','now')),
-    updated_at  TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ','now'))
-);
-CREATE TABLE label_templates (
-    id          INTEGER PRIMARY KEY,
-    name        TEXT NOT NULL,
-    kind        TEXT NOT NULL,
-    profile_id  INTEGER REFERENCES station_profiles(id) ON DELETE SET NULL,
-    stock_id    INTEGER REFERENCES label_stocks(id) ON DELETE SET NULL,
-    json        TEXT NOT NULL,
-    is_default  INTEGER NOT NULL DEFAULT 0,
-    created_at  TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ','now')),
-    updated_at  TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ','now'))
-);

internal/db/roles.go

@@ -51,8 +51,6 @@ var settingsTables = []string{
 	"operating_stations_new",
 	"award_references",
 	"qsl_templates",
-	"label_stocks",
-	"label_templates",
 	"cluster_servers",
 	"integrations_udp",
 	"callsign_cache",

internal/labels/labels.go

@@ -1,194 +0,0 @@
-// Package labels holds the label designer's data model: the printable labels
-// an operator sticks on a QSL card (the QSO table) or an envelope (addresses).
-//
-// Everything is measured in MILLIMETRES. Label stock is sold in mm (a Brother
-// DK-11201 is 29×90), printer margins are quoted in mm, and an operator lining
-// a design up against a physical label thinks in mm — pixels only exist at
-// render time, where the frontend rasterises at the stock's dpi. Storing mm
-// keeps a template meaningful if it is ever printed at another resolution.
-//
-// The document is deliberately much simpler than the QSL card designer's: a
-// label is monochrome text on a small sticker, so there are no photos, no
-// effects, no presets — four element types and a geometry.
-package labels
-
-import (
-	"encoding/json"
-	"fmt"
-	"strings"
-)
-
-// Stock is one physical label size — the roll in the printer. Designs point at
-// a stock rather than embedding the geometry so that changing "my printer's
-// margins are actually 2 mm" fixes every design at once.
-type Stock struct {
-	ID   int64   `json:"id,omitempty"`
-	Name string  `json:"name"`
-	WMm  float64 `json:"w_mm"`
-	HMm  float64 `json:"h_mm"`
-	// Margins are the unprintable border, in mm from each edge.
-	MarginTop    float64 `json:"margin_top_mm"`
-	MarginRight  float64 `json:"margin_right_mm"`
-	MarginBottom float64 `json:"margin_bottom_mm"`
-	MarginLeft   float64 `json:"margin_left_mm"`
-	DPI          int     `json:"dpi"`
-}
-
-// BuiltinStocks are the label sizes seeded on first run — the common Brother DK
-// rolls (the QL family is what prompted the feature) plus a 62 mm continuous
-// strip. Ordinary rows once seeded: an operator with different margins edits
-// them like any stock.
-func BuiltinStocks() []Stock {
-	m := func(name string, w, h float64) Stock {
-		return Stock{Name: name, WMm: w, HMm: h,
-			MarginTop: 1.5, MarginRight: 3, MarginBottom: 1.5, MarginLeft: 3, DPI: 300}
-	}
-	return []Stock{
-		m("Brother DK-11201 · 29×90 mm (address)", 90, 29),
-		m("Brother DK-11202 · 62×100 mm (shipping)", 100, 62),
-		m("Brother DK-11208 · 38×90 mm (large address)", 90, 38),
-		m("Brother DK-22205 · 62 mm continuous (cut 100 mm)", 100, 62),
-	}
-}
-
-// Element is one thing drawn on the label. Type selects which fields matter:
-//
-//	text       X/Y/W, Text (with <VARIABLES>), Size, Bold, Align
-//	line       X/Y/W, Thickness — a horizontal rule
-//	qso_table  X/Y/W, Columns, RowsMax, RowH, Header — the repeating QSO block
-//	addr_block X/Y, Lines, Size, Bold, LineGap — address lines, blanks collapsed
-//
-// One struct with optional fields rather than a type per element: the document
-// crosses the Wails boundary as JSON and the frontend edits it in place, and a
-// closed union would buy safety here at the price of a parallel hierarchy on
-// both sides of that boundary.
-type Element struct {
-	Type string  `json:"type"`
-	XMm  float64 `json:"x_mm"`
-	YMm  float64 `json:"y_mm"`
-	WMm  float64 `json:"w_mm,omitempty"`
-
-	// text
-	Text   string  `json:"text,omitempty"`
-	SizePt float64 `json:"size_pt,omitempty"`
-	Bold   bool    `json:"bold,omitempty"`
-	Italic bool    `json:"italic,omitempty"`
-	Align  string  `json:"align,omitempty"` // left | center | right
-
-	// line
-	ThicknessMm float64 `json:"thickness_mm,omitempty"`
-
-	// qso_table
-	Columns []Column `json:"columns,omitempty"`
-	RowsMax int      `json:"rows_max,omitempty"`
-	RowHMm  float64  `json:"row_h_mm,omitempty"`
-	Header  bool     `json:"header,omitempty"`
-
-	// addr_block
-	Lines   []string `json:"lines,omitempty"`
-	LineGap float64  `json:"line_gap_mm,omitempty"`
-}
-
-// Column is one column of the QSO table. Field names the QSO field (the same
-// lower-case keys the grids use: qso_date, time_on, band, freq, mode, rst_sent,
-// rst_rcvd, …); Label is the printed header.
-type Column struct {
-	Field string  `json:"field"`
-	Label string  `json:"label"`
-	WMm   float64 `json:"w_mm"`
-	Align string  `json:"align,omitempty"`
-}
-
-// Template is one label design.
-type Template struct {
-	Version  int       `json:"version"`
-	Kind     string    `json:"kind"` // qso | address
-	Name     string    `json:"name,omitempty"`
-	StockID  int64     `json:"stock_id"`
-	FontName string    `json:"font,omitempty"` // one face for the whole label; "" = the renderer's default
-	Elements []Element `json:"elements"`
-}
-
-// Parse decodes a template document.
-func Parse(doc []byte) (Template, error) {
-	var t Template
-	if err := json.Unmarshal(doc, &t); err != nil {
-		return t, fmt.Errorf("label template: %w", err)
-	}
-	return t, nil
-}
-
-// Encode is the inverse of Parse.
-func Encode(t Template) ([]byte, error) { return json.MarshalIndent(t, "", "  ") }
-
-// Validate rejects a document that could not be rendered or printed sensibly.
-// Geometry beyond the stock is NOT an error — the editor lets an element be
-// dragged around freely and clips at render time — but nonsense that would make
-// rendering undefined (unknown types, absurd sizes) is refused at save.
-func Validate(t Template) error {
-	if t.Version != 1 {
-		return fmt.Errorf("unsupported label template version %d", t.Version)
-	}
-	if t.Kind != "qso" && t.Kind != "address" {
-		return fmt.Errorf("unknown label kind %q", t.Kind)
-	}
-	if len(t.Elements) == 0 {
-		return fmt.Errorf("the label has no elements")
-	}
-	if len(t.Elements) > 64 {
-		return fmt.Errorf("too many elements (%d)", len(t.Elements))
-	}
-	for i, e := range t.Elements {
-		switch e.Type {
-		case "text":
-			if strings.TrimSpace(e.Text) == "" {
-				return fmt.Errorf("element %d: empty text", i+1)
-			}
-		case "line":
-			if e.WMm <= 0 {
-				return fmt.Errorf("element %d: a line needs a width", i+1)
-			}
-		case "qso_table":
-			if len(e.Columns) == 0 {
-				return fmt.Errorf("element %d: the QSO table has no columns", i+1)
-			}
-			if e.RowsMax < 1 || e.RowsMax > 20 {
-				return fmt.Errorf("element %d: rows must be 1-20", i+1)
-			}
-			for _, c := range e.Columns {
-				if strings.TrimSpace(c.Field) == "" || c.WMm <= 0 {
-					return fmt.Errorf("element %d: every column needs a field and a width", i+1)
-				}
-			}
-		case "addr_block":
-			if len(e.Lines) == 0 {
-				return fmt.Errorf("element %d: the address block has no lines", i+1)
-			}
-		default:
-			return fmt.Errorf("element %d: unknown type %q", i+1, e.Type)
-		}
-		if e.SizePt < 0 || e.SizePt > 72 {
-			return fmt.Errorf("element %d: font size out of range", i+1)
-		}
-	}
-	return nil
-}
-
-// ValidStock rejects geometry no label printer produces.
-func ValidStock(s Stock) error {
-	if strings.TrimSpace(s.Name) == "" {
-		return fmt.Errorf("the stock needs a name")
-	}
-	if s.WMm < 10 || s.WMm > 300 || s.HMm < 6 || s.HMm > 300 {
-		return fmt.Errorf("label size out of range (10-300 mm wide, 6-300 mm high)")
-	}
-	for _, m := range []float64{s.MarginTop, s.MarginRight, s.MarginBottom, s.MarginLeft} {
-		if m < 0 || m*2 >= s.HMm || m*2 >= s.WMm {
-			return fmt.Errorf("margins leave no printable area")
-		}
-	}
-	if s.DPI != 0 && (s.DPI < 72 || s.DPI > 1200) {
-		return fmt.Errorf("dpi out of range")
-	}
-	return nil
-}

internal/labels/repo.go

@@ -1,252 +0,0 @@
-package labels
-
-import (
-	"context"
-	"database/sql"
-	"fmt"
-	"time"
-)
-
-// Record is one stored template row; JSON holds the Template document.
-type Record struct {
-	ID        int64     `json:"id"`
-	Name      string    `json:"name"`
-	Kind      string    `json:"kind"`
-	ProfileID *int64    `json:"profile_id,omitempty"`
-	StockID   *int64    `json:"stock_id,omitempty"`
-	JSON      string    `json:"json"`
-	IsDefault bool      `json:"is_default"`
-	UpdatedAt time.Time `json:"updated_at"`
-}
-
-// Repo accesses the label_stocks and label_templates tables. Same shape as the
-// QSL template repo it is modelled on — the label designer is that feature's
-// smaller sibling and the storage questions were settled there.
-type Repo struct{ db *sql.DB }
-
-func NewRepo(db *sql.DB) *Repo { return &Repo{db: db} }
-
-// ── stocks ──────────────────────────────────────────────────────────────
-
-// Stocks lists every stored label stock, oldest first (the seeded Brother rolls
-// keep their familiar order at the top).
-func (r *Repo) Stocks(ctx context.Context) ([]Stock, error) {
-	rows, err := r.db.QueryContext(ctx, `SELECT id, json FROM label_stocks ORDER BY id`)
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-	var out []Stock
-	for rows.Next() {
-		var id int64
-		var doc string
-		if err := rows.Scan(&id, &doc); err != nil {
-			return nil, err
-		}
-		var s Stock
-		if err := parseStock(doc, &s); err != nil {
-			continue // one corrupt row must not hide the rest
-		}
-		s.ID = id
-		out = append(out, s)
-	}
-	return out, rows.Err()
-}
-
-// SaveStock upserts one stock (ID 0 creates) and writes the id back.
-func (r *Repo) SaveStock(ctx context.Context, s *Stock) error {
-	if err := ValidStock(*s); err != nil {
-		return err
-	}
-	doc, err := encodeStock(*s)
-	if err != nil {
-		return err
-	}
-	now := time.Now().UTC().Format("2006-01-02T15:04:05.000Z")
-	if s.ID == 0 {
-		res, err := r.db.ExecContext(ctx,
-			`INSERT INTO label_stocks (name, json, created_at, updated_at) VALUES (?,?,?,?)`,
-			s.Name, doc, now, now)
-		if err != nil {
-			return fmt.Errorf("insert stock: %w", err)
-		}
-		s.ID, _ = res.LastInsertId()
-		return nil
-	}
-	_, err = r.db.ExecContext(ctx,
-		`UPDATE label_stocks SET name = ?, json = ?, updated_at = ? WHERE id = ?`,
-		s.Name, doc, now, s.ID)
-	return err
-}
-
-// DeleteStock removes a stock. Templates pointing at it keep their design and
-// fall back to "pick a stock" in the editor (the FK nulls the reference).
-func (r *Repo) DeleteStock(ctx context.Context, id int64) error {
-	_, err := r.db.ExecContext(ctx, `DELETE FROM label_stocks WHERE id = ?`, id)
-	return err
-}
-
-// SeedStocks inserts the builtin rolls when the table is empty — first run, or
-// an operator who deleted everything and wants the presets back gets them by
-// emptying the table.
-func (r *Repo) SeedStocks(ctx context.Context) error {
-	var n int
-	if err := r.db.QueryRowContext(ctx, `SELECT COUNT(*) FROM label_stocks`).Scan(&n); err != nil {
-		return err
-	}
-	if n > 0 {
-		return nil
-	}
-	for _, s := range BuiltinStocks() {
-		st := s
-		if err := r.SaveStock(ctx, &st); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-// ── templates ───────────────────────────────────────────────────────────
-
-const tplCols = `id, name, kind, profile_id, stock_id, json, is_default, updated_at`
-
-// ListFor returns the templates visible to a profile (its own plus shared),
-// defaults first.
-func (r *Repo) ListFor(ctx context.Context, profileID int64) ([]Record, error) {
-	rows, err := r.db.QueryContext(ctx, `SELECT `+tplCols+` FROM label_templates
-		WHERE profile_id = ? OR profile_id IS NULL
-		ORDER BY is_default DESC, id DESC`, profileID)
-	if err != nil {
-		return nil, err
-	}
-	return scanRecords(rows)
-}
-
-// List returns every template (no active profile yet).
-func (r *Repo) List(ctx context.Context) ([]Record, error) {
-	rows, err := r.db.QueryContext(ctx,
-		`SELECT `+tplCols+` FROM label_templates ORDER BY is_default DESC, id DESC`)
-	if err != nil {
-		return nil, err
-	}
-	return scanRecords(rows)
-}
-
-// Get returns one template.
-func (r *Repo) Get(ctx context.Context, id int64) (Record, error) {
-	row := r.db.QueryRowContext(ctx, `SELECT `+tplCols+` FROM label_templates WHERE id = ?`, id)
-	return scanRecord(row)
-}
-
-// Save upserts a template (ID 0 creates); the id is written back.
-func (r *Repo) Save(ctx context.Context, rec *Record) error {
-	if rec.Name == "" {
-		return fmt.Errorf("template name required")
-	}
-	now := time.Now().UTC().Format("2006-01-02T15:04:05.000Z")
-	if rec.ID == 0 {
-		res, err := r.db.ExecContext(ctx, `INSERT INTO label_templates
-			(name, kind, profile_id, stock_id, json, is_default, created_at, updated_at)
-			VALUES (?,?,?,?,?,?,?,?)`,
-			rec.Name, rec.Kind, nullID(rec.ProfileID), nullID(rec.StockID), rec.JSON,
-			boolInt(rec.IsDefault), now, now)
-		if err != nil {
-			return fmt.Errorf("insert label template: %w", err)
-		}
-		rec.ID, _ = res.LastInsertId()
-		return nil
-	}
-	_, err := r.db.ExecContext(ctx, `UPDATE label_templates
-		SET name = ?, kind = ?, profile_id = ?, stock_id = ?, json = ?, updated_at = ?
-		WHERE id = ?`,
-		rec.Name, rec.Kind, nullID(rec.ProfileID), nullID(rec.StockID), rec.JSON, now, rec.ID)
-	return err
-}
-
-// Delete removes a template.
-func (r *Repo) Delete(ctx context.Context, id int64) error {
-	_, err := r.db.ExecContext(ctx, `DELETE FROM label_templates WHERE id = ?`, id)
-	return err
-}
-
-// SetDefault marks one template as the default FOR ITS KIND within its profile
-// scope: printing asks for "the QSO label" and "the address label" separately,
-// so the two defaults must not compete.
-func (r *Repo) SetDefault(ctx context.Context, id int64) error {
-	tx, err := r.db.BeginTx(ctx, nil)
-	if err != nil {
-		return err
-	}
-	defer tx.Rollback() //nolint:errcheck
-	var kind string
-	var profileID sql.NullInt64
-	if err := tx.QueryRowContext(ctx,
-		`SELECT kind, profile_id FROM label_templates WHERE id = ?`, id).Scan(&kind, &profileID); err != nil {
-		return err
-	}
-	if profileID.Valid {
-		_, err = tx.ExecContext(ctx, `UPDATE label_templates SET is_default = 0
-			WHERE kind = ? AND (profile_id = ? OR profile_id IS NULL)`, kind, profileID.Int64)
-	} else {
-		_, err = tx.ExecContext(ctx, `UPDATE label_templates SET is_default = 0 WHERE kind = ?`, kind)
-	}
-	if err != nil {
-		return err
-	}
-	if _, err = tx.ExecContext(ctx, `UPDATE label_templates SET is_default = 1 WHERE id = ?`, id); err != nil {
-		return err
-	}
-	return tx.Commit()
-}
-
-// ── scanning helpers ────────────────────────────────────────────────────
-
-type rowScanner interface{ Scan(dest ...any) error }
-
-func scanRecord(row rowScanner) (Record, error) {
-	var rec Record
-	var pid, sid sql.NullInt64
-	var def int
-	var updated string
-	if err := row.Scan(&rec.ID, &rec.Name, &rec.Kind, &pid, &sid, &rec.JSON, &def, &updated); err != nil {
-		return rec, err
-	}
-	if pid.Valid {
-		v := pid.Int64
-		rec.ProfileID = &v
-	}
-	if sid.Valid {
-		v := sid.Int64
-		rec.StockID = &v
-	}
-	rec.IsDefault = def != 0
-	rec.UpdatedAt, _ = time.Parse(time.RFC3339, updated)
-	return rec, nil
-}
-
-func scanRecords(rows *sql.Rows) ([]Record, error) {
-	defer rows.Close()
-	var out []Record
-	for rows.Next() {
-		rec, err := scanRecord(rows)
-		if err != nil {
-			return nil, err
-		}
-		out = append(out, rec)
-	}
-	return out, rows.Err()
-}
-
-func nullID(p *int64) any {
-	if p == nil || *p == 0 {
-		return nil
-	}
-	return *p
-}
-
-func boolInt(b bool) int {
-	if b {
-		return 1
-	}
-	return 0
-}

internal/labels/stockjson.go

@@ -1,13 +0,0 @@
-package labels
-
-import "encoding/json"
-
-// The stock row stores its geometry as JSON so adding a field never needs a
-// migration; the name is duplicated into its own column for listing.
-func parseStock(doc string, s *Stock) error { return json.Unmarshal([]byte(doc), s) }
-
-func encodeStock(s Stock) (string, error) {
-	s.ID = 0 // the row id is authoritative; never persist a stale copy inside the blob
-	b, err := json.Marshal(s)
-	return string(b), err
-}

internal/pdf/pdf.go

@@ -1,131 +0,0 @@
-// Package pdf writes the one kind of PDF the label printer needs: a document
-// whose every page is a single full-bleed image at an exact physical size.
-//
-// Written by hand rather than through a library for two reasons. The build is
-// pure Go with no room for cgo, and the need is tiny: the pages arrive as
-// PNGs rasterised by the SAME canvas renderer the designer's preview uses, so
-// this file only has to carry pixels to paper without touching them. Fonts,
-// vectors, compression profiles — all already decided upstream.
-//
-// The images are stored as 8-bit DeviceGray with FlateDecode: labels are
-// monochrome, grey keeps antialiased text edges smooth on a 300 dpi thermal
-// head, and flate is lossless — JPEG artefacts around small print are exactly
-// what a QSL label cannot afford.
-package pdf
-
-import (
-	"bytes"
-	"compress/zlib"
-	"fmt"
-	"image/png"
-)
-
-const mmToPt = 72.0 / 25.4
-
-// Doc accumulates pages; Bytes() renders the file.
-type Doc struct {
-	pages []pageData
-}
-
-type pageData struct {
-	wPt, hPt float64
-	imgW     int
-	imgH     int
-	gray     []byte // zlib-compressed 8-bit samples
-}
-
-// AddImagePage appends one page of wMm×hMm entirely covered by the PNG.
-// The PNG's aspect ratio is not checked against the page's: the caller
-// rasterised it AT this size, and a mismatch would be its bug to see.
-func (d *Doc) AddImagePage(pngBytes []byte, wMm, hMm float64) error {
-	img, err := png.Decode(bytes.NewReader(pngBytes))
-	if err != nil {
-		return fmt.Errorf("page image: %w", err)
-	}
-	b := img.Bounds()
-	w, h := b.Dx(), b.Dy()
-	if w <= 0 || h <= 0 {
-		return fmt.Errorf("page image is empty")
-	}
-	// To 8-bit grey. Luminance weights, not an average: blue text on a designer
-	// screen should darken the way a photocopier would darken it.
-	gray := make([]byte, w*h)
-	i := 0
-	for y := b.Min.Y; y < b.Max.Y; y++ {
-		for x := b.Min.X; x < b.Max.X; x++ {
-			r, g, bb, _ := img.At(x, y).RGBA()
-			gray[i] = byte((299*r + 587*g + 114*bb) / 1000 >> 8)
-			i++
-		}
-	}
-	var buf bytes.Buffer
-	zw := zlib.NewWriter(&buf)
-	if _, err := zw.Write(gray); err != nil {
-		return err
-	}
-	if err := zw.Close(); err != nil {
-		return err
-	}
-	d.pages = append(d.pages, pageData{
-		wPt: wMm * mmToPt, hPt: hMm * mmToPt,
-		imgW: w, imgH: h, gray: buf.Bytes(),
-	})
-	return nil
-}
-
-// Bytes renders the whole document.
-func (d *Doc) Bytes() ([]byte, error) {
-	if len(d.pages) == 0 {
-		return nil, fmt.Errorf("no pages")
-	}
-	var out bytes.Buffer
-	offsets := []int{0} // object 0 is the free-list head
-	obj := func(body func()) int {
-		offsets = append(offsets, out.Len())
-		n := len(offsets) - 1
-		fmt.Fprintf(&out, "%d 0 obj\n", n)
-		body()
-		out.WriteString("endobj\n")
-		return n
-	}
-
-	out.WriteString("%PDF-1.4\n%\xe2\xe3\xcf\xd3\n")
-
-	// Objects 1 (catalog) and 2 (pages) reference their children by number, so
-	// the numbering is laid out first: 3 objects per page after the two roots.
-	nPages := len(d.pages)
-	pageObj := func(i int) int { return 3 + i*3 }
-
-	obj(func() { out.WriteString("<< /Type /Catalog /Pages 2 0 R >>\n") }) // 1
-	obj(func() {                                                           // 2
-		out.WriteString("<< /Type /Pages /Kids [")
-		for i := 0; i < nPages; i++ {
-			fmt.Fprintf(&out, "%d 0 R ", pageObj(i))
-		}
-		fmt.Fprintf(&out, "] /Count %d >>\n", nPages)
-	})
-	for i, p := range d.pages {
-		content := fmt.Sprintf("q %.4f 0 0 %.4f 0 0 cm /Im0 Do Q", p.wPt, p.hPt)
-		obj(func() { // page
-			fmt.Fprintf(&out, "<< /Type /Page /Parent 2 0 R /MediaBox [0 0 %.4f %.4f] /Contents %d 0 R /Resources << /XObject << /Im0 %d 0 R >> >> >>\n",
-				p.wPt, p.hPt, pageObj(i)+1, pageObj(i)+2)
-		})
-		obj(func() { // contents
-			fmt.Fprintf(&out, "<< /Length %d >>\nstream\n%s\nendstream\n", len(content), content)
-		})
-		obj(func() { // image
-			fmt.Fprintf(&out, "<< /Type /XObject /Subtype /Image /Width %d /Height %d /ColorSpace /DeviceGray /BitsPerComponent 8 /Filter /FlateDecode /Length %d >>\nstream\n",
-				p.imgW, p.imgH, len(p.gray))
-			out.Write(p.gray)
-			out.WriteString("\nendstream\n")
-		})
-	}
-
-	xref := out.Len()
-	fmt.Fprintf(&out, "xref\n0 %d\n0000000000 65535 f \n", len(offsets))
-	for _, off := range offsets[1:] {
-		fmt.Fprintf(&out, "%010d 00000 n \n", off)
-	}
-	fmt.Fprintf(&out, "trailer\n<< /Size %d /Root 1 0 R >>\nstartxref\n%d\n%%%%EOF\n", len(offsets), xref)
-	return out.Bytes(), nil
-}

internal/pdf/pdf_test.go

@@ -1,54 +0,0 @@
-package pdf
-
-import (
-	"bytes"
-	"image"
-	"image/color"
-	"image/png"
-	"testing"
-)
-
-func testPNG(t *testing.T, w, h int) []byte {
-	t.Helper()
-	img := image.NewRGBA(image.Rect(0, 0, w, h))
-	for x := 0; x < w; x++ {
-		img.Set(x, h/2, color.Black)
-	}
-	var buf bytes.Buffer
-	if err := png.Encode(&buf, img); err != nil {
-		t.Fatal(err)
-	}
-	return buf.Bytes()
-}
-
-func TestDocShape(t *testing.T) {
-	var d Doc
-	// A 90×29 mm label at 300 dpi is 1063×343 px.
-	if err := d.AddImagePage(testPNG(t, 1063, 343), 90, 29); err != nil {
-		t.Fatal(err)
-	}
-	if err := d.AddImagePage(testPNG(t, 1063, 343), 90, 29); err != nil {
-		t.Fatal(err)
-	}
-	b, err := d.Bytes()
-	if err != nil {
-		t.Fatal(err)
-	}
-	// Not a PDF parser — the shape a viewer needs to find its way in.
-	for _, want := range []string{"%PDF-1.4", "/Count 2", "/DeviceGray", "startxref", "%%EOF"} {
-		if !bytes.Contains(b, []byte(want)) {
-			t.Errorf("missing %q in output", want)
-		}
-	}
-	// 90 mm = 255.118 pt — the page size a driver prints 1:1 on the roll.
-	if !bytes.Contains(b, []byte("/MediaBox [0 0 255.1181 82.2047]")) {
-		t.Errorf("media box is not the label size")
-	}
-}
-
-func TestEmptyDocRefused(t *testing.T) {
-	var d Doc
-	if _, err := d.Bytes(); err == nil {
-		t.Fatal("an empty document should refuse to render")
-	}
-}

internal/qso/qso.go

@@ -232,11 +232,8 @@ type ListFilter struct {
 	Band            string `json:"band,omitempty"`
 	Mode            string `json:"mode,omitempty"`
 	StationCallsign string `json:"station_callsign,omitempty"`
-	// QSLSentIn keeps only rows whose paper-QSL sent status is one of these
-	// values — 'R' (requested) and 'Q' (queued) are the label printer's queue.
-	QSLSentIn []string `json:"qsl_sent_in,omitempty"`
-	Limit     int      `json:"limit,omitempty"`
-	Offset    int      `json:"offset,omitempty"`
+	Limit           int    `json:"limit,omitempty"`
+	Offset          int    `json:"offset,omitempty"`
 }
 
 // Repo accesses the qso table.
@@ -871,6 +868,44 @@ var bulkEditableCols = map[string]bool{
 
 // BulkSetField sets one whitelisted column to value on every listed QSO in a
 // single statement. value "" clears the field. Returns rows affected.
+// bulkEditableIntCols are the NUMERIC columns the bulk editor may touch. Their
+// own path, not the text one: the columns are nullable integers, and while
+// SQLite would coerce "14" quietly, a shared MySQL logbook would not — and an
+// empty string is NULL here, never "".
+var bulkEditableIntCols = map[string]bool{
+	"my_dxcc":     true,
+	"my_cq_zone":  true,
+	"my_itu_zone": true,
+}
+
+// BulkSetIntField sets one integer column across the ids; v nil clears it.
+func (r *Repo) BulkSetIntField(ctx context.Context, ids []int64, column string, v *int) (int64, error) {
+	if !bulkEditableIntCols[column] {
+		return 0, fmt.Errorf("field %q is not bulk-editable", column)
+	}
+	if len(ids) == 0 {
+		return 0, nil
+	}
+	ph := make([]string, len(ids))
+	args := make([]any, 0, len(ids)+2)
+	var val any
+	if v != nil {
+		val = *v
+	}
+	args = append(args, val, db.NowISO())
+	for i, id := range ids {
+		ph[i] = "?"
+		args = append(args, id)
+	}
+	res, err := r.db.ExecContext(ctx,
+		"UPDATE qso SET "+column+" = ?, updated_at = ? WHERE id IN ("+strings.Join(ph, ",")+")", args...)
+	if err != nil {
+		return 0, fmt.Errorf("bulk set %s: %w", column, err)
+	}
+	n, _ := res.RowsAffected()
+	return n, nil
+}
+
 func (r *Repo) BulkSetField(ctx context.Context, ids []int64, column, value string) (int64, error) {
 	if !bulkEditableCols[column] {
 		return 0, fmt.Errorf("field %q is not bulk-editable", column)
@@ -1214,12 +1249,6 @@ func (r *Repo) List(ctx context.Context, f ListFilter) ([]QSO, error) {
 		q += " AND station_callsign = ?"
 		args = append(args, f.StationCallsign)
 	}
-	if len(f.QSLSentIn) > 0 {
-		q += " AND qsl_sent IN (?" + strings.Repeat(",?", len(f.QSLSentIn)-1) + ")"
-		for _, v := range f.QSLSentIn {
-			args = append(args, v)
-		}
-	}
 	q += " ORDER BY qso_date DESC, id DESC"
 	if f.Limit <= 0 {
 		f.Limit = 500
@@ -1974,6 +2003,39 @@ func bandStatusCode(callWorked, callConfirmed, entityConfirmed bool) int {
 
 // modeClass collapses ADIF modes into the three buckets DXers care about.
 // Anything not voice and not CW is treated as digital.
+// ModeClass is modeClass for callers outside the package — the watchlist
+// judges slots at the same grain the cluster does.
+func ModeClass(mode string) string { return modeClass(mode) }
+
+// SlotRow is one (callsign, band, mode) triple from SlotsSince.
+type SlotRow struct {
+	Callsign string
+	Band     string
+	Mode     string
+}
+
+// SlotsSince lists the slots of every contact made since the given instant —
+// the contest watchlist's "worked today", where the day boundary lives in this
+// query's bound and nowhere else.
+func (r *Repo) SlotsSince(ctx context.Context, since time.Time) ([]SlotRow, error) {
+	rows, err := r.db.QueryContext(ctx,
+		"SELECT callsign, band, mode FROM qso WHERE qso_date >= ?",
+		since.UTC().Format(isoMillis))
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	var out []SlotRow
+	for rows.Next() {
+		var sr SlotRow
+		if err := rows.Scan(&sr.Callsign, &sr.Band, &sr.Mode); err != nil {
+			return nil, err
+		}
+		out = append(out, sr)
+	}
+	return out, rows.Err()
+}
+
 func modeClass(mode string) string {
 	switch strings.ToUpper(mode) {
 	case "SSB", "USB", "LSB", "AM", "FM", "DIGITALVOICE", "PHONE":

internal/watchlist/clublog.go

@@ -0,0 +1,131 @@
+package watchlist
+
+// ClubLog enrichment — phase 2 of the DXHunter port. clublog.org/watch.php
+// answers, per callsign: is this an expedition, does it run OQRS, is there a
+// LiveStream, the log's QSO total and the last 24 hours' rate. That block has
+// been in the Entry schema since phase 1 (the file round-trips DXHunter's);
+// this file finally fills it.
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"strings"
+	"time"
+)
+
+// WatchData is clublog.org/watch.php's answer, reduced to what the tab shows.
+type WatchData struct {
+	IsExpedition bool `json:"is_expedition"`
+	HasOQRS      bool `json:"has_oqrs"`
+	LiveStream   bool `json:"livestream"`
+	ClubLogInfo  *struct {
+		TotalQSOs int `json:"total_qsos"`
+	} `json:"clublog_info"`
+	// {} when populated, [] when empty — RawMessage swallows both shapes.
+	QSOsPerBand json.RawMessage `json:"24h_qsos_per_band_mode"`
+}
+
+// QSOs24h sums the per-band/per-mode counts.
+func (d *WatchData) QSOs24h() int {
+	if len(d.QSOsPerBand) == 0 {
+		return 0
+	}
+	var parsed map[string]map[string]int
+	if err := json.Unmarshal(d.QSOsPerBand, &parsed); err != nil {
+		return 0 // "[]" for an empty answer lands here, which is the right zero
+	}
+	n := 0
+	for _, modes := range parsed {
+		for _, c := range modes {
+			n += c
+		}
+	}
+	return n
+}
+
+// FetchWatch asks ClubLog about one callsign. A 404 is "ClubLog has no log for
+// this call" — an ordinary answer, not an error.
+func FetchWatch(ctx context.Context, client *http.Client, apiKey, callsign string) (*WatchData, error) {
+	url := fmt.Sprintf("https://clublog.org/watch.php?call=%s&api=%s",
+		strings.ToUpper(strings.TrimSpace(callsign)), apiKey)
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
+	if err != nil {
+		return nil, err
+	}
+	req.Header.Set("User-Agent", "OpsLog")
+	resp, err := client.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode == http.StatusNotFound {
+		return &WatchData{}, nil
+	}
+	if resp.StatusCode != http.StatusOK {
+		return nil, fmt.Errorf("clublog watch %s: HTTP %d", callsign, resp.StatusCode)
+	}
+	body, err := io.ReadAll(io.LimitReader(resp.Body, 1<<20))
+	if err != nil {
+		return nil, err
+	}
+	if len(strings.TrimSpace(string(body))) == 0 {
+		return &WatchData{}, nil
+	}
+	var data WatchData
+	if err := json.Unmarshal(body, &data); err != nil {
+		return nil, fmt.Errorf("clublog watch %s: %w", callsign, err)
+	}
+	return &data, nil
+}
+
+// ApplyClubLog writes one answer into the entry and reports whether anything
+// the tab shows actually changed — the caller only broadcasts on true.
+func (s *Store) ApplyClubLog(callsign string, d *WatchData) bool {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	e, ok := s.entries[strings.ToUpper(strings.TrimSpace(callsign))]
+	if !ok {
+		return false
+	}
+	total := e.ClubLogTotalQSOs
+	if d.ClubLogInfo != nil {
+		total = d.ClubLogInfo.TotalQSOs
+	}
+	q24 := d.QSOs24h()
+	changed := e.IsExpedition != d.IsExpedition || e.ClubLogHasOQRS != d.HasOQRS ||
+		e.ClubLogLiveStream != d.LiveStream || e.ClubLogTotalQSOs != total ||
+		e.ClubLogQSOs24h != q24
+	e.IsExpedition = d.IsExpedition
+	e.ClubLogHasOQRS = d.HasOQRS
+	e.ClubLogLiveStream = d.LiveStream
+	e.ClubLogTotalQSOs = total
+	e.ClubLogQSOs24h = q24
+	e.ClubLogUpdatedAt = time.Now()
+	s.scheduleSave()
+	return changed
+}
+
+// StaleEntries lists the callsigns whose ClubLog block is due a refresh.
+// Expeditions age faster — their totals are the interesting number and move by
+// the hour; a quiet call is asked about four times a day at most.
+func (s *Store) StaleEntries(expTTL, otherTTL time.Duration) []string {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+	now := time.Now()
+	var out []string
+	for call, e := range s.entries {
+		// A starred pattern is a family, not a station — ClubLog has no log
+		// for "VK9*". The base (star stripped) is what gets asked about.
+		ttl := otherTTL
+		if e.IsExpedition {
+			ttl = expTTL
+		}
+		if now.Sub(e.ClubLogUpdatedAt) >= ttl {
+			out = append(out, call)
+		}
+	}
+	return out
+}

internal/watchlist/watchlist.go

@@ -0,0 +1,268 @@
+// Package watchlist is the DXHunter watchlist, transplanted: a list of
+// callsigns (or prefixes) the operator is hunting, matched against the live
+// spot stream, with per-entry state that survives restarts.
+//
+// The JSON file is DXHunter's OWN schema, field for field — including the
+// ClubLog expedition block this phase does not fill yet. Deliberate: the
+// operator asked to carry their watchlist.json across, and a file that
+// round-trips unchanged is the whole of "same format". The file is GLOBAL
+// (dataDir, beside nets.json), not per profile: a DXpedition worth hunting is
+// worth hunting whichever station is on.
+//
+// The CONTEST idea is per entry, not a global mode as in DXHunter: an entry
+// marked contest is judged against the CURRENT UTC DAY — at midnight UTC
+// yesterday's contacts stop counting and every slot reads "work today" again.
+// Nothing resets and nothing is stored for it: the day boundary lives in the
+// query, which is why it cannot drift or need a timer.
+package watchlist
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"sort"
+	"strings"
+	"sync"
+	"time"
+)
+
+// Entry is one watched callsign. JSON tags match DXHunter's watchlist.json
+// exactly — see the package comment before renaming anything.
+type Entry struct {
+	Callsign    string    `json:"callsign"`
+	LastSeen    time.Time `json:"lastSeen"`
+	LastSeenStr string    `json:"lastSeenStr"`
+	AddedAt     time.Time `json:"addedAt"`
+	SpotCount   int       `json:"spotCount"`
+	IsContest   bool      `json:"isContest"`
+	Notify      bool      `json:"notify"`
+	// ClubLog expedition enrichment — phase 2. Carried so a DXHunter file
+	// round-trips; not filled by OpsLog yet.
+	IsExpedition      bool      `json:"isExpedition"`
+	ClubLogQSOs24h    int       `json:"clubLogQSOs24h"`
+	ClubLogTotalQSOs  int       `json:"clubLogTotalQSOs"`
+	ClubLogHasOQRS    bool      `json:"clubLogHasOQRS"`
+	ClubLogLiveStream bool      `json:"clubLogLiveStream"`
+	ClubLogUpdatedAt  time.Time `json:"clubLogUpdatedAt,omitempty"`
+}
+
+// Store owns the file. All methods are safe for concurrent use; writes are
+// debounced so a burst of MarkSeen calls costs one disk write.
+type Store struct {
+	mu      sync.RWMutex
+	entries map[string]*Entry
+	path    string
+
+	saveMu    sync.Mutex
+	saveTimer *time.Timer
+	ioMu      sync.Mutex
+}
+
+func New(path string) *Store {
+	s := &Store{entries: map[string]*Entry{}, path: path}
+	s.load()
+	return s
+}
+
+func (s *Store) load() {
+	data, err := os.ReadFile(s.path)
+	if err != nil {
+		return // absent on first run — created on first save
+	}
+	var list []Entry
+	if err := json.Unmarshal(data, &list); err != nil {
+		return // a corrupt file must not take the app down; it is left for repair
+	}
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	for i := range list {
+		e := list[i]
+		e.Callsign = strings.ToUpper(strings.TrimSpace(e.Callsign))
+		if e.Callsign == "" {
+			continue
+		}
+		s.entries[e.Callsign] = &e
+	}
+}
+
+// Entries returns a snapshot, watched-first ordering left to the UI.
+func (s *Store) Entries() []Entry {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+	out := make([]Entry, 0, len(s.entries))
+	for _, e := range s.entries {
+		c := *e
+		c.LastSeenStr = lastSeenLabel(c.LastSeen)
+		out = append(out, c)
+	}
+	sort.Slice(out, func(i, j int) bool { return out[i].Callsign < out[j].Callsign })
+	return out
+}
+
+// Add creates an entry; contest marks it as re-workable every UTC day. A
+// trailing * makes the entry a prefix (VK9* catches every VK9…); anywhere else
+// the star is refused rather than silently matching nothing.
+func (s *Store) Add(callsign string, contest bool) error {
+	call := strings.ToUpper(strings.TrimSpace(callsign))
+	if call == "" {
+		return fmt.Errorf("callsign required")
+	}
+	if i := strings.Index(call, "*"); i >= 0 && i != len(call)-1 {
+		return fmt.Errorf("* is only allowed at the end (VK9*)")
+	}
+	if call == "*" {
+		return fmt.Errorf("a bare * would match every spot")
+	}
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	if _, ok := s.entries[call]; ok {
+		return fmt.Errorf("%s is already on the watchlist", call)
+	}
+	s.entries[call] = &Entry{Callsign: call, AddedAt: time.Now(), IsContest: contest}
+	s.scheduleSave()
+	return nil
+}
+
+// Remove deletes an entry.
+func (s *Store) Remove(callsign string) error {
+	call := strings.ToUpper(strings.TrimSpace(callsign))
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	if _, ok := s.entries[call]; !ok {
+		return fmt.Errorf("%s is not on the watchlist", call)
+	}
+	delete(s.entries, call)
+	s.scheduleSave()
+	return nil
+}
+
+// SetNotify arms or disarms the alert for one entry.
+func (s *Store) SetNotify(callsign string, on bool) error {
+	return s.patch(callsign, func(e *Entry) { e.Notify = on })
+}
+
+// SetContest flips the per-entry contest rule.
+func (s *Store) SetContest(callsign string, on bool) error {
+	return s.patch(callsign, func(e *Entry) { e.IsContest = on })
+}
+
+func (s *Store) patch(callsign string, fn func(*Entry)) error {
+	call := strings.ToUpper(strings.TrimSpace(callsign))
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	e, ok := s.entries[call]
+	if !ok {
+		return fmt.Errorf("%s is not on the watchlist", call)
+	}
+	fn(e)
+	s.scheduleSave()
+	return nil
+}
+
+// Match returns the entry a spotted callsign belongs to, or "".
+//
+// EXACT unless the entry says otherwise: N8W matches only N8W, and it takes
+// N8W* to catch N8WCR. The first version prefix-matched everything, DXHunter
+// style, and a three-letter special-event call swallowed every longer call
+// sharing its start — N8W lit up for N8WCR, which is a different station
+// entirely. The operator writes the star when they MEAN a family (VK9*, an
+// expedition's portable forms via RI0SP*); a bare entry means that call.
+func (s *Store) Match(callsign string) (string, bool) {
+	call := strings.ToUpper(strings.TrimSpace(callsign))
+	if call == "" {
+		return "", false
+	}
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+	for pattern := range s.entries {
+		if PatternMatches(pattern, call) {
+			return pattern, true
+		}
+	}
+	return "", false
+}
+
+// PatternMatches reports whether one watchlist pattern covers a callsign:
+// exact equality, or — with a trailing * — a prefix.
+func PatternMatches(pattern, call string) bool {
+	if p, ok := strings.CutSuffix(pattern, "*"); ok {
+		return p != "" && strings.HasPrefix(call, p)
+	}
+	return call == pattern
+}
+
+// MarkSeen records a spot against the matching entry and reports whether the
+// entry wants an alert.
+func (s *Store) MarkSeen(callsign string) (entry string, notify bool, ok bool) {
+	pattern, found := s.Match(callsign)
+	if !found {
+		return "", false, false
+	}
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	e := s.entries[pattern]
+	if e == nil {
+		return "", false, false
+	}
+	e.LastSeen = time.Now()
+	e.SpotCount++
+	s.scheduleSave()
+	return e.Callsign, e.Notify, true
+}
+
+// scheduleSave debounces the write: a burst of spots costs one file write two
+// seconds after the last of them. Callers hold s.mu.
+func (s *Store) scheduleSave() {
+	s.saveMu.Lock()
+	defer s.saveMu.Unlock()
+	if s.saveTimer != nil {
+		s.saveTimer.Stop()
+	}
+	s.saveTimer = time.AfterFunc(2*time.Second, func() { s.persist() })
+}
+
+func (s *Store) persist() {
+	list := s.Entries()
+	data, err := json.MarshalIndent(list, "", "  ")
+	if err != nil {
+		return
+	}
+	s.ioMu.Lock()
+	defer s.ioMu.Unlock()
+	_ = os.WriteFile(s.path, data, 0o644)
+}
+
+// Flush writes now — for shutdown, where the two-second debounce would lose
+// the last edits.
+func (s *Store) Flush() { s.persist() }
+
+// lastSeenLabel is DXHunter's "Just now / 5m ago / 3h ago / 2d ago" string,
+// computed at read time so it never goes stale in the file.
+func lastSeenLabel(t time.Time) string {
+	if t.IsZero() {
+		return "Never"
+	}
+	d := time.Since(t)
+	switch {
+	case d < time.Minute:
+		return "Just now"
+	case d < time.Hour:
+		return fmt.Sprintf("%dm ago", int(d.Minutes()))
+	case d < 24*time.Hour:
+		return fmt.Sprintf("%dh ago", int(d.Hours()))
+	default:
+		return fmt.Sprintf("%dd ago", int(d.Hours()/24))
+	}
+}
+
+// Get returns one entry by its exact name — the alert path needs its contest
+// flag after MarkSeen named it.
+func (s *Store) Get(callsign string) (Entry, bool) {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+	e, ok := s.entries[strings.ToUpper(strings.TrimSpace(callsign))]
+	if !ok {
+		return Entry{}, false
+	}
+	return *e, true
+}

internal/watchlist/watchlist_test.go

@@ -0,0 +1,92 @@
+package watchlist
+
+import (
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestGlobMatch(t *testing.T) {
+	s := New(filepath.Join(t.TempDir(), "watchlist.json"))
+	if err := s.Add("RI0SP*", false); err != nil {
+		t.Fatal(err)
+	}
+	if err := s.Add("N8W", false); err != nil {
+		t.Fatal(err)
+	}
+	// A starred entry is a family: the expedition's portable forms.
+	for _, call := range []string{"RI0SP", "RI0SP/MM", "RI0SP/P"} {
+		if _, ok := s.Match(call); !ok {
+			t.Errorf("Match(%q) = false, want true", call)
+		}
+	}
+	// A bare entry is THAT call — the reported bug was N8W lighting up for
+	// N8WCR, a different station entirely.
+	if _, ok := s.Match("N8W"); !ok {
+		t.Error("exact entry must match its own call")
+	}
+	if _, ok := s.Match("N8WCR"); ok {
+		t.Error("exact entry must NOT match a longer call")
+	}
+	if _, ok := s.Match("RI0S"); ok {
+		t.Error("a SHORTER call must not match a starred entry")
+	}
+	if err := s.Add("VK*9", false); err == nil {
+		t.Error("a mid-string star must be refused")
+	}
+	if err := s.Add("*", false); err == nil {
+		t.Error("a bare star must be refused")
+	}
+}
+
+func TestDXHunterFileRoundTrips(t *testing.T) {
+	// A real DXHunter entry, ClubLog block included. It must survive
+	// load → save byte-meaningfully: same keys, values preserved.
+	src := `[{"callsign":"C5SP","lastSeen":"0001-01-01T00:00:00Z","lastSeenStr":"Never",
+	  "addedAt":"2026-01-17T00:18:43.89Z","spotCount":7,"isContest":true,"notify":true,
+	  "isExpedition":true,"clubLogQSOs24h":120,"clubLogTotalQSOs":30500,
+	  "clubLogHasOQRS":true,"clubLogLiveStream":true,"clubLogUpdatedAt":"2026-08-28T22:32:18Z"}]`
+	dir := t.TempDir()
+	path := filepath.Join(dir, "watchlist.json")
+	if err := os.WriteFile(path, []byte(src), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	s := New(path)
+	s.Flush()
+	out, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var list []map[string]any
+	if err := json.Unmarshal(out, &list); err != nil {
+		t.Fatal(err)
+	}
+	if len(list) != 1 {
+		t.Fatalf("got %d entries", len(list))
+	}
+	e := list[0]
+	for k, want := range map[string]any{
+		"callsign": "C5SP", "isContest": true, "notify": true,
+		"isExpedition": true, "clubLogQSOs24h": float64(120),
+		"clubLogTotalQSOs": float64(30500), "clubLogHasOQRS": true,
+	} {
+		if e[k] != want {
+			t.Errorf("%s = %v, want %v", k, e[k], want)
+		}
+	}
+}
+
+func TestMarkSeenAndNotify(t *testing.T) {
+	s := New(filepath.Join(t.TempDir(), "watchlist.json"))
+	_ = s.Add("HB040A", false)
+	_ = s.SetNotify("HB040A", true)
+	entry, notify, ok := s.MarkSeen("HB040A")
+	if !ok || !notify || entry != "HB040A" {
+		t.Fatalf("MarkSeen = %q %v %v", entry, notify, ok)
+	}
+	list := s.Entries()
+	if list[0].SpotCount != 1 || list[0].LastSeenStr != "Just now" {
+		t.Errorf("entry after MarkSeen: %+v", list[0])
+	}
+}

telemetry.go

@@ -21,7 +21,7 @@ import (
 
 const (
 	// appVersion is stamped on every heartbeat (and could feed the About box).
-	appVersion = "0.26.22"
+	appVersion = "0.27.0"
 
 	// posthogHost is the PostHog ingestion endpoint. EU cloud by default; change
 	// to https://us.i.posthog.com for a US project.