chore(changelog): move the post-release entries into a 0.26.23 block

The Station column, the Label Designer and the label printing all landed after
v0.26.22 was tagged; the .22 block is byte-identical to the tag again.

app.go

@@ -44,6 +44,7 @@ import (
 	"hamlog/internal/gridcache"
 	"hamlog/internal/integrations/udp"
 	"hamlog/internal/kpa"
+	"hamlog/internal/labels"
 	"hamlog/internal/lookup"
 	"hamlog/internal/lotwusers"
 	"hamlog/internal/netctl"
@@ -402,6 +403,8 @@ const (
 
 	keyExtLoTWTQSLPath     = "extsvc.lotw.tqsl_path"
 	keyExtLoTWStationLoc   = "extsvc.lotw.station_location"
+	keyExtLoTWQSLDetail    = "extsvc.lotw.qsl_detail"             // ask LoTW for the QSL dates and station details (an order of magnitude slower)
+	keyExtLoTWAllCalls     = "extsvc.lotw.download_all_calls"     // download confirmations for EVERY call on the account, not just this profile's
 	keyExtLoTWForceCall    = "extsvc.lotw.force_station_callsign" // override STATION_CALLSIGN at sign time (e.g. F4BPO/P on the F4BPO cert)
 	keyExtLoTWKeyPassword  = "extsvc.lotw.key_password"
 	keyExtLoTWUploadFlag   = "extsvc.lotw.upload_flag"  // legacy single flag (migrated to upload_flags)
@@ -733,6 +736,7 @@ 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)
 	operating    *operating.Repo
 	udp          *udp.Manager
 	udpRepo      *udp.Repo
@@ -1183,6 +1187,7 @@ 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
@@ -2122,6 +2127,21 @@ func (a *App) saveWindowState() {
 // position — which options can't express — remains, and it is set here while the
 // window is still hidden, so there is no visible jump. Nothing to do for a
 // maximised or first-run window.
+// moveWindowTo places the window at an ABSOLUTE desktop coordinate — the same
+// coordinate system WindowGetPosition reports and window.json stores.
+//
+// Wails' WindowSetPosition is relative to the current monitor's work area (see
+// windowpos_windows.go), so on a monitor left of the primary one it added that
+// monitor's negative origin to an already-absolute value and the window walked
+// one screen further off the desktop at every launch. Fall back to it only when
+// we cannot place the window ourselves — on the primary monitor the two agree.
+func (a *App) moveWindowTo(x, y int) {
+	if setWindowPosAbsolute(x, y) {
+		return
+	}
+	wruntime.WindowSetPosition(a.ctx, x, y)
+}
+
 func (a *App) restoreWindowPosition() {
 	if a.ctx == nil {
 		return
@@ -2149,7 +2169,7 @@ func (a *App) restoreWindowPosition() {
 			return
 		}
 		wruntime.WindowUnmaximise(a.ctx)
-		wruntime.WindowSetPosition(a.ctx, ws.X, ws.Y)
+		a.moveWindowTo(ws.X, ws.Y)
 		wruntime.WindowMaximise(a.ctx)
 		gx, gy := wruntime.WindowGetPosition(a.ctx)
 		applog.Printf("window: re-maximised at the saved corner — now at %d,%d", gx, gy)
@@ -2177,10 +2197,13 @@ func (a *App) restoreWindowPosition() {
 		}
 		applog.Printf("window: saved position %d,%d is off every monitor (%s) — moved to %d,%d",
 			ws.X, ws.Y, describeMonitors(monitorRects()), nx, ny)
-		wruntime.WindowSetPosition(a.ctx, nx, ny)
+		a.moveWindowTo(nx, ny)
 		return
 	}
-	wruntime.WindowSetPosition(a.ctx, ws.X, ws.Y)
+	a.moveWindowTo(ws.X, ws.Y)
+	if gx, gy := wruntime.WindowGetPosition(a.ctx); gx != ws.X || gy != ws.Y {
+		applog.Printf("window: asked for %d,%d and the window reports %d,%d", ws.X, ws.Y, gx, gy)
+	}
 }
 
 // onSomeMonitor reports whether a window at these coordinates would land on the
@@ -3338,6 +3361,10 @@ func (a *App) applyStationDefaults(q *qso.QSO, includeIdentity bool) {
 	// Per-band rig/antenna from Operating conditions (the antenna ticked as
 	// DEFAULT for this band) — the same auto-fill the entry strip does, applied
 	// here so imported QSOs get MY_RIG / MY_ANTENNA from the band defaults.
+	// The radio that is CONNECTED names itself first — see activeRadioMyRig.
+	if q.MyRig == "" {
+		q.MyRig = a.activeRadioMyRig()
+	}
 	if a.operating != nil && q.Band != "" && (q.MyRig == "" || q.MyAntenna == "") {
 		if d, ok, _ := a.operating.BandDefault(a.ctx, p.ID, q.Band); ok {
 			if q.MyRig == "" {
@@ -7228,7 +7255,9 @@ func (a *App) SetCompactMode(on bool) {
 		wruntime.WindowSetMinSize(a.ctx, normalMinW, normalMinH)
 		if a.preCompactValid {
 			wruntime.WindowSetSize(a.ctx, a.preCompactW, a.preCompactH)
-			wruntime.WindowSetPosition(a.ctx, a.preCompactX, a.preCompactY)
+			// Absolute, like the capture — see moveWindowTo. Leaving compact mode on a
+			// monitor left of the primary one moved the window a screen further out.
+			a.moveWindowTo(a.preCompactX, a.preCompactY)
 			if a.preCompactMax {
 				wruntime.WindowMaximise(a.ctx)
 			}
@@ -8927,6 +8956,11 @@ func (a *App) clusterEventWorker() {
 				}
 			}
 		}
+		// SOTA: the summit is in the spot's own text — the SOTA feeds put it
+		// there — so it costs a regex rather than an API lookup.
+		if s.SOTARef == "" {
+			s.SOTARef = cluster.SOTARefFrom(s.Comment)
+		}
 		// POTA: tag the spot when the DX station is currently activating a park.
 		if a.pota != nil {
 			if info, ok := a.pota.Lookup(s.DXCall); ok {
@@ -11295,11 +11329,19 @@ func (a *App) runManualUpload(svc extsvc.Service, ids []int64, cfg extsvc.Extern
 		}
 		res, err := extsvc.UploadLoTW(ctx, cfg.LoTW, "", strings.Join(recs, "\n"))
 		if err != nil || !res.OK {
-			msg := res.Message
-			if err != nil {
+			// The DETAIL wins over the error string. UploadLoTW returns both: a
+			// terse error ("no QSOs processed") and a Message carrying TQSL's own
+			// account of what happened to the contacts ("…already uploaded", "…out
+			// of date range"). Taking the error whenever there was one threw the
+			// answer away and showed the operator the half that explains nothing.
+			msg := strings.TrimSpace(res.Message)
+			if msg == "" && err != nil {
 				msg = err.Error()
+			} else if err != nil && !strings.Contains(msg, err.Error()) {
+				msg = msg + " (" + err.Error() + ")"
 			}
 			emit("LoTW upload failed: " + msg)
+			emit("  The station location OpsLog signs with must match the callsign on these contacts, and their dates must fall inside the certificate's validity — TQSL refuses the whole batch otherwise.")
 			// The qslmgr:log console is only visible in the QSL Manager — a failure
 			// triggered from the Recent QSOs right-click was completely silent, which
 			// read as "send to LoTW does nothing". Surface it as a toast too.
@@ -11537,14 +11579,18 @@ func (a *App) runManualUpload(svc extsvc.Service, ids []int64, cfg extsvc.Extern
 // with award-style NEW flags computed against the log's prior confirmations.
 type ConfirmationItem struct {
 	Callsign string `json:"callsign"`
-	QSODate  string `json:"qso_date"` // ISO UTC
-	Band     string `json:"band"`
-	Mode     string `json:"mode"`
-	Country  string `json:"country"`
-	NewDXCC  bool   `json:"new_dxcc"`
-	NewBand  bool   `json:"new_band"`
-	NewMode  bool   `json:"new_mode"` // new mode CLASS (Phone/CW/Digital) for the entity
-	NewSlot  bool   `json:"new_slot"`
+	// Station is the callsign the QSO was made UNDER, which the download can now
+	// span ("All my callsigns"): a list mixing F4BPO, F4BPO/P and TM2Q says
+	// nothing useful unless each line says which of them it belongs to.
+	Station string `json:"station"`
+	QSODate string `json:"qso_date"` // ISO UTC
+	Band    string `json:"band"`
+	Mode    string `json:"mode"`
+	Country string `json:"country"`
+	NewDXCC bool   `json:"new_dxcc"`
+	NewBand bool   `json:"new_band"`
+	NewMode bool   `json:"new_mode"` // new mode CLASS (Phone/CW/Digital) for the entity
+	NewSlot bool   `json:"new_slot"`
 }
 
 // GetSlotStats returns the worked/confirmed slot + DXCC tallies for the QSL
@@ -12087,6 +12133,27 @@ func manualRefFor(existing, code string) string {
 	return ""
 }
 
+// GetLoTWQSLDetail reports whether the download asks LoTW for the QSL detail.
+func (a *App) GetLoTWQSLDetail() bool {
+	return a.settingOr(keyExtLoTWQSLDetail, "") == "1"
+}
+
+// SetLoTWQSLDetail stores that choice.
+func (a *App) SetLoTWQSLDetail(on bool) {
+	a.setSetting(keyExtLoTWQSLDetail, map[bool]string{true: "1", false: "0"}[on])
+}
+
+// GetLoTWDownloadAllCalls reports whether the LoTW download ignores the
+// profile's own call and pulls every callsign on the account.
+func (a *App) GetLoTWDownloadAllCalls() bool {
+	return a.settingOr(keyExtLoTWAllCalls, "") == "1"
+}
+
+// SetLoTWDownloadAllCalls stores that choice.
+func (a *App) SetLoTWDownloadAllCalls(on bool) {
+	a.setSetting(keyExtLoTWAllCalls, map[bool]string{true: "1", false: "0"}[on])
+}
+
 // DownloadConfirmations pulls confirmed QSOs from a service and updates the
 // matching local QSOs' received status. LoTW only for now (the canonical
 // confirmation system); runs in the background emitting the same
@@ -12158,7 +12225,30 @@ func (a *App) runDownloadConfirmations(ctx context.Context, svc extsvc.Service,
 	case extsvc.ServiceLoTW:
 		sinceDate := resolveSince(keyExtLoTWLastDownload)
 		ownCall := a.uploadOwnerCall(extsvc.ServiceLoTW)
+		// A LoTW account holds every call its owner operates — F4BPO, F4BPO/P,
+		// TM2Q — and the download is normally scoped to the profile's own call so
+		// one profile does not pull another's confirmations. That scope also
+		// silently hides them: a QSO made as F4BPO/P is confirmed at LoTW and can
+		// never be downloaded from the F4BPO profile, so it stays unconfirmed here
+		// for good while the ARRL counts it. Off by default, because the scope is
+		// right for anyone whose profiles are separate stations.
+		if a.settingOr(keyExtLoTWAllCalls, "") == "1" {
+			ownCall = ""
+		}
 		callLabel := ownCall
+		// Unscoped, the report carries every station on the account — including
+		// the ones belonging to ANOTHER profile's logbook (a Vietnam expedition,
+		// say). Those confirmations have nothing to match here, and with "add the
+		// ones not found" ticked they would pour a second log into this one. So
+		// the station callsigns this logbook actually holds become the filter:
+		// F4BPO/P is kept because it was worked here, XV9Q is skipped because it
+		// never was.
+		var ownStations map[string]bool
+		if ownCall == "" {
+			if st, e := a.qso.StationCallsigns(ctx); e == nil && len(st) > 0 {
+				ownStations = st
+			}
+		}
 		if callLabel == "" {
 			callLabel = "all callsigns"
 		}
@@ -12168,13 +12258,36 @@ func (a *App) runDownloadConfirmations(ctx context.Context, svc extsvc.Service,
 			emit(fmt.Sprintf("Downloading all LoTW confirmations for %s…", callLabel))
 		}
 		emit(fmt.Sprintf("Window: since=%q → resolved=%q (scope owncall=%q)", since, sinceDate, ownCall))
-		adifText, err := extsvc.DownloadLoTWConfirmations(ctx, nil, cfg.LoTW, sinceDate, ownCall)
+		// The report arrives over minutes, and a window that says nothing while it
+		// does is indistinguishable from one that has hung — which is what it was
+		// being reported as. Every half-megabyte, say how much has landed.
+		// Adding the QSOs LoTW knows and we do not is the one job that needs the
+		// slow report: without the detail those records would come in with no
+		// grid, state or county, and nothing else would ever fill them.
+		detail := addNotFound || a.settingOr(keyExtLoTWQSLDetail, "") == "1"
+		if detail {
+			emit("Asking for the QSL details too — LoTW takes considerably longer to build that report.")
+		}
+		adifText, err := extsvc.DownloadLoTWConfirmations(ctx, nil, cfg.LoTW, sinceDate, ownCall, detail, emit)
 		if err != nil {
 			emit("Download failed: " + err.Error())
 			done(matched, total)
 			return
 		}
 		emit(fmt.Sprintf("LoTW returned %d KB of ADIF", len(adifText)/1024))
+		// A report far smaller than the account justifies is the one failure that
+		// looks like success: LoTW answers 200 with a near-empty ADIF when it
+		// disagrees with the query (an unknown callsign in qso_owncall, a login
+		// that half-worked). Show its own header rather than leaving "matched 1 of
+		// 1" to be read as "you have one confirmation".
+		if len(adifText) < 4096 {
+			head := strings.TrimSpace(adifText)
+			if len(head) > 400 {
+				head = head[:400]
+			}
+			emit("The report is unexpectedly small — what LoTW actually sent:")
+			emit("  " + strings.Join(strings.Fields(head), " "))
+		}
 		keyIDs, kerr := a.qso.DedupeKeyIDs(ctx)
 		if kerr != nil {
 			emit("Error reading local log: " + kerr.Error())
@@ -12192,6 +12305,7 @@ func (a *App) runDownloadConfirmations(ctx context.Context, svc extsvc.Service,
 		sets, _ := a.qso.ConfirmedSlots(ctx, []string{"lotw_rcvd", "qsl_rcvd"})
 		var items []ConfirmationItem
 		var unmatched []string
+		skippedOtherStation := 0
 		perr := adif.Parse(strings.NewReader(adifText), func(rec adif.Record) error {
 			if ctx.Err() != nil {
 				return ctx.Err() // window closed / superseded
@@ -12200,6 +12314,16 @@ func (a *App) runDownloadConfirmations(ctx context.Context, svc extsvc.Service,
 			if !ok {
 				return nil
 			}
+			// Another station's confirmation — see ownStations above. Counted so
+			// the report says how many were left alone rather than silently
+			// dropping a third of the file.
+			if ownStations != nil {
+				st := strings.ToUpper(strings.TrimSpace(rec["station_callsign"]))
+				if st != "" && !ownStations[st] {
+					skippedOtherStation++
+					return nil
+				}
+			}
 			total++
 			date := rec["qslrdate"]
 			if date == "" {
@@ -12248,6 +12372,7 @@ func (a *App) runDownloadConfirmations(ctx context.Context, svc extsvc.Service,
 			}
 			it := ConfirmationItem{
 				Callsign: q.Callsign,
+				Station:  strings.ToUpper(strings.TrimSpace(rec["station_callsign"])),
 				QSODate:  q.QSODate.UTC().Format(time.RFC3339),
 				Band:     q.Band,
 				Mode:     q.Mode,
@@ -12280,6 +12405,9 @@ func (a *App) runDownloadConfirmations(ctx context.Context, svc extsvc.Service,
 		} else {
 			emit(fmt.Sprintf("Matched %d of %d confirmed QSO(s)", matched, total))
 		}
+		if skippedOtherStation > 0 {
+			emit(fmt.Sprintf("  (%d confirmation(s) skipped — made under a callsign this logbook has never used)", skippedOtherStation))
+		}
 		if byClass > 0 {
 			// Said out loud rather than folded silently into the total: these
 			// matched on the mode CLASS, not the mode. LoTW hands back "DATA" for
@@ -13401,7 +13529,12 @@ func (a *App) LogUDPLoggedADIF(adifText string) (int64, error) {
 
 	// ── Operating-conditions stamp ──
 	// Pre-fill MY_RIG / MY_ANTENNA / TX_PWR from the default antenna for
-	// this band (if the user has configured Operating conditions).
+	// this band (if the user has configured Operating conditions) — after the
+	// connected radio has had its say, since it knows which rig is keying and
+	// the band default only knows which one was planned.
+	if q.MyRig == "" {
+		q.MyRig = a.activeRadioMyRig()
+	}
 	if a.operating != nil && a.profiles != nil {
 		if p, err := a.profiles.Active(a.ctx); err == nil {
 			if d, ok2, _ := a.operating.BandDefault(a.ctx, p.ID, q.Band); ok2 {
@@ -14502,6 +14635,36 @@ func (a *App) FlexBackspaceCW(n int) error {
 	return a.cat.FlexDo(func(fc cat.FlexController) error { return fc.BackspaceCW(n) })
 }
 
+// TCISendCW keys a CW message through the SunSDR's own macro keyer, so a TCI
+// station needs no WinKeyer and no second serial port. Text is already
+// variable-resolved by the UI.
+func (a *App) TCISendCW(text string) error {
+	if a.cat == nil {
+		return fmt.Errorf("cat not initialized")
+	}
+	err := a.cat.TCICWDo(func(tc cat.TCICWController) error { return tc.SendCW(text) })
+	if err != nil {
+		applog.Printf("tci cw: TCISendCW(%q) failed: %v", text, err)
+	}
+	return err
+}
+
+// TCIStopCW aborts whatever the keyer is sending.
+func (a *App) TCIStopCW() error {
+	if a.cat == nil {
+		return fmt.Errorf("cat not initialized")
+	}
+	return a.cat.TCICWDo(func(tc cat.TCICWController) error { return tc.StopCW() })
+}
+
+// TCISetKeySpeed sets the macro keyer speed in WPM.
+func (a *App) TCISetKeySpeed(wpm int) error {
+	if a.cat == nil {
+		return fmt.Errorf("cat not initialized")
+	}
+	return a.cat.TCICWDo(func(tc cat.TCICWController) error { return tc.SetCWSpeed(wpm) })
+}
+
 // IcomStopCW aborts the CW message currently being sent.
 func (a *App) IcomStopCW() error {
 	if a.cat == nil {

app_labels.go

@@ -0,0 +1,208 @@
+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

@@ -0,0 +1,90 @@
+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_radios.go

@@ -43,6 +43,14 @@ type RadioConfig struct {
 	// the CAT panel has always edited, so a saved radio is exactly "what the
 	// settings said the day it was saved".
 	Settings CATSettings `json:"settings"`
+	// MyRig is what goes into MY_RIG on a QSO made with this radio.
+	//
+	// It belongs here rather than in Operating conditions once there is more
+	// than one rig: the operating conditions describe a PLAN — "on 20 m I use
+	// the beam and the 7300" — while this is the fact of which radio is keying.
+	// Left empty, nothing changes: the old chain (band default, then the
+	// profile's rig) answers exactly as it did.
+	MyRig string `json:"my_rig"`
 }
 
 // radioLabel is what the status bar shows when the operator never named one.
@@ -204,3 +212,26 @@ func (a *App) syncActiveRadio(s CATSettings) {
 		}
 	}
 }
+
+// activeRadioMyRig is the MY_RIG of the radio currently connected, or "".
+//
+// Consulted BEFORE the per-band default, and deliberately: the band default is
+// what the operator planned to use on that band, this is which radio is
+// actually on the air. When they disagree — a second rig borrowed for one
+// evening on 20 m — the one that is transmitting is the true answer.
+func (a *App) activeRadioMyRig() string {
+	if a.settings == nil || strings.TrimSpace(a.settingOr(keyRadiosList, "")) == "" {
+		return "" // no list was ever made: nothing to say, nothing changes
+	}
+	list, err := a.GetRadios()
+	if err != nil {
+		return ""
+	}
+	id := a.ActiveRadioID()
+	for _, r := range list {
+		if r.ID == id {
+			return strings.TrimSpace(r.MyRig)
+		}
+	}
+	return ""
+}

appearance.go

@@ -174,6 +174,11 @@ type MatrixColors struct {
 	EntityWorked    string `json:"entity_worked"`
 	NotWorked       string `json:"not_worked"`
 	CurrentEntry    string `json:"current_entry"`
+	// The dot marking a slot already worked with the callsign in hand. It is a
+	// mark rather than a background, so it needs its own two colours: it is
+	// drawn on top of all five of the above and must stay legible over each.
+	MarkWorked    string `json:"mark_worked"`
+	MarkConfirmed string `json:"mark_confirmed"`
 }
 
 // normMatrixColors keeps only plain hex values. Anything else becomes "" — i.e.
@@ -196,6 +201,8 @@ func normMatrixColors(c MatrixColors) MatrixColors {
 		EntityWorked:    clean(c.EntityWorked),
 		NotWorked:       clean(c.NotWorked),
 		CurrentEntry:    clean(c.CurrentEntry),
+		MarkWorked:      clean(c.MarkWorked),
+		MarkConfirmed:   clean(c.MarkConfirmed),
 	}
 }
 

changelog.json

@@ -1,4 +1,90 @@
 [
+  {
+    "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."
+    ],
+    "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."
+    ]
+  },
+  {
+    "version": "0.26.22",
+    "date": "",
+    "en": [
+      "LoTW download: the QSL details (QSL date, grid, state, county) are now optional and off by default — LoTW takes about ten times longer to build that report, twenty minutes against two on the same account, and marking a confirmation needs none of it. Still asked for automatically when adding the QSOs not found in the log.",
+      "Band map: the tooltip now also names a new prefix or a new grid square. They stay off the 22-pixel colour strip, but leaving them out of the text made the two panels look as though they disagreed — the cluster said NEW PFX about a spot the map called Worked, and both were right. The map’s “Worked” also says whose: it is the ENTITY that was worked on that band and mode, not the callsign, which is what made the two readings look contradictory.",
+      "TCI (SunSDR): clicking a cluster spot no longer needs a second click to get the mode right — the sideband was chosen from the frequency the radio had last reported instead of the one just asked for. The log also names the ExpertSDR version now, and says so when it is older than the 1.5 that panorama spots need.",
+      "Two screens: OpsLog no longer walks off the desktop. On a monitor placed left of the primary one, the saved position was being added to that monitor’s own origin at every launch, so the window moved one screen further out each time until it was invisible.",
+      "CW over TCI: a SunSDR can now be keyed through its own macro keyer — pick TCI as the keyer engine (Settings → CW Keyer) and macros, auto-call and the speed control all work over the link already open, with no WinKeyer and no second serial port. NOT TESTED on the air yet.",
+      "LoTW upload: a refusal now shows TQSL’s own explanation — which contacts were already uploaded, which fell outside the certificate’s dates — instead of the bare “no QSOs processed”, and names the two settings that cause it.",
+      "Main tab: the docked cluster now has ONE header row — its title, live count and Filters button sit with Clear filters and Columns, as Recent QSOs beside it already did. The pane is titled DX Cluster.",
+      "A busy cluster no longer makes the rest of the interface sluggish: incoming spots are grouped into fewer, larger updates as the feed gets faster (up to half a second), instead of redrawing the window twenty times a second. A quiet cluster still shows each spot as it lands.",
+      "SunSDR console: the meters work. The S-meter, transmit power and SWR are pushed by the radio only to a client that subscribes, and OpsLog never did — it was reading commands ExpertSDR3 does not send.",
+      "Cluster: the “N new spots” counter no longer jumps to the whole buffer. It was looking for the row it had frozen on, and a station spotted again replaces its row — so the count fell through to “everything is new”.",
+      "E-mail: a refused SMTP login now says what to do about it — Microsoft 365 and outlook.com have switched off password-based SMTP, and an app password does not bring it back.",
+      "TCI panorama spots: the colour was sent as a negative number and ExpertSDR dropped every spot in silence. It now goes out as the unsigned ARGB integer the protocol document uses, and the first few spots are written to the log verbatim.",
+      "Cluster: “Group duplicates” was hiding the same station on OTHER bands and modes — a DXpedition spotted on five bands showed as one line and four slots disappeared. A duplicate is now what it should always have been: the same station on the same band and mode."
+    ],
+    "fr": [
+      "Téléchargement LoTW : les détails QSL (date du QSL, locator, état, comté) deviennent optionnels et désactivés par défaut — LoTW met environ dix fois plus longtemps à construire ce rapport, vingt minutes contre deux sur le même compte, et marquer une confirmation n'en a pas besoin. Toujours demandés automatiquement quand on ajoute les QSO absents du log.",
+      "Carte des bandes : l'infobulle indique aussi un nouveau préfixe ou un nouveau locator. Ils restent hors de la bande de couleur de 22 pixels, mais les omettre du texte donnait l'impression que les deux panneaux se contredisaient — le cluster annonçait NOUVEAU PFX pour un spot que la carte disait contacté, et les deux avaient raison. Le « Contacté » de la carte dit aussi de qui il parle : c'est l'ENTITÉ qui a été contactée sur cette bande et ce mode, pas l'indicatif — d'où l'impression de contradiction.",
+      "TCI (SunSDR) : cliquer un spot du cluster ne demande plus un second clic pour obtenir le bon mode — la bande latérale était choisie d'après la fréquence encore annoncée par la radio au lieu de celle qu'on venait de demander. Le journal indique aussi la version d'ExpertSDR, et signale si elle est antérieure à la 1.5 qu'exigent les spots sur le panorama.",
+      "Deux écrans : OpsLog ne s'échappe plus du bureau. Sur un écran placé à gauche de l'écran principal, la position enregistrée était ajoutée à l'origine de cet écran à chaque lancement, si bien que la fenêtre s'éloignait d'un écran à chaque fois jusqu'à devenir invisible.",
+      "CW en TCI : un SunSDR peut désormais être manipulé par son propre keyer à macros — choisissez TCI comme moteur (Réglages → Manipulateur CW) et les macros, l'appel automatique et le réglage de vitesse passent par la liaison déjà ouverte, sans WinKeyer ni second port série. PAS ENCORE TESTÉ sur l'air.",
+      "Envoi LoTW : un refus affiche désormais l'explication de TQSL — quels contacts étaient déjà envoyés, lesquels tombaient hors des dates du certificat — au lieu du seul « no QSOs processed », et nomme les deux réglages qui en sont la cause.",
+      "Onglet Main : le cluster ancré n'a plus qu'UNE ligne d'en-tête — son titre, le compteur live et le bouton Filtres rejoignent Effacer les filtres et Colonnes, comme le faisait déjà la liste des QSO récents à côté. Le panneau s'intitule DX Cluster.",
+      "Un cluster chargé ne ralentit plus le reste de l'interface : les spots entrants sont regroupés en mises à jour moins nombreuses à mesure que le flux s'accélère (jusqu'à une demi-seconde), au lieu de redessiner la fenêtre vingt fois par seconde. Sur un cluster calme, chaque spot s'affiche toujours dès son arrivée.",
+      "Console SunSDR : les mesures fonctionnent. Le S-mètre, la puissance et le ROS ne sont envoyés qu'à un client qui s'abonne, ce qu'OpsLog ne faisait pas — il lisait des commandes qu'ExpertSDR3 n'envoie pas.",
+      "Cluster : le compteur « N nouveaux spots » ne saute plus à la taille du tampon. Il cherchait la ligne sur laquelle il s'était figé, or une station re-spottée remplace sa ligne — le compte basculait donc sur « tout est nouveau ».",
+      "E-mail : un refus d'authentification SMTP explique désormais quoi faire — Microsoft 365 et outlook.com ont désactivé le SMTP par mot de passe, et un mot de passe d'application ne le rétablit pas.",
+      "Spots sur le panorama TCI : la couleur partait en nombre négatif et ExpertSDR écartait chaque spot en silence. Elle est désormais envoyée en entier ARGB non signé, comme dans la documentation du protocole, et les premiers spots sont écrits tels quels dans le journal.",
+      "Cluster : « Grouper les doublons » masquait la même station sur les AUTRES bandes et modes — une expédition spottée sur cinq bandes n'affichait qu'une ligne et quatre créneaux disparaissaient. Un doublon est désormais ce qu'il aurait toujours dû être : la même station sur la même bande et le même mode."
+    ]
+  },
+  {
+    "version": "0.26.21",
+    "date": "",
+    "en": [
+      "Distances can be shown in miles (Settings → General): the cluster and Recent QSOs columns, the map path box, the rotator buttons and the band-opening list all follow, and the column headers name the unit.",
+      "LoTW download: the report is now counted in megabytes as it arrives, LoTW’s \"busy\" answer (HTTP 503) is retried twice instead of failing, and a transfer that stops moving for two minutes says so rather than showing \"working\" indefinitely."
+    ],
+    "fr": [
+      "Les distances peuvent s'afficher en miles (Réglages → Général) : les colonnes du cluster et des QSO récents, l'encart du tracé sur la carte, les boutons du rotor et la liste des ouvertures suivent, et l'unité est indiquée dans les en-têtes de colonne.",
+      "Téléchargement LoTW : le rapport est compté en mégaoctets au fur et à mesure, la réponse « occupé » de LoTW (HTTP 503) est retentée deux fois au lieu d'échouer, et un transfert qui n'avance plus pendant deux minutes le dit au lieu d'afficher « en cours » indéfiniment."
+    ]
+  },
+  {
+    "version": "0.26.20",
+    "date": "",
+    "en": [
+      "Each radio carries its own MY_RIG (Settings → CAT), written on every QSO made with it — ahead of the per-band station in Operating conditions, which says what you planned to use rather than which radio is keying. Left empty, nothing changes.",
+      "Worked-before matrix: a dot in the corner of a cell now means the callsign you are working has already been worked on that slot, whatever colour the entity status gave the cell. Its two colours (worked / confirmed with this callsign) are in Appearance with the other matrix colours.",
+      "Icom spectrum scope: the command shape (with or without the main/sub selector) is now worked out from the radio’s own answers instead of a list of models. A radio that has scope control but no waveform stream over CI-V — the IC-7851 — says so in the panel rather than showing a black rectangle.",
+      "Elecraft KPA: the status-bar chip now shows the amplifier as connected and switches it between OPERATE and STANDBY like the other brands, and an offline KPA no longer calls itself an Acom.",
+      "Cluster: a SOTA column, read from the summit reference the SOTA feeds put in the spot comment. Clicking the spot fills the QSO’s SOTA award reference, as a POTA spot already did. Turn the column on in Columns. Add cluster.sota.org.uk:7300 as a server to receive the summit spots.",
+      "Awards: a \"Slots to confirm\" filter and a running count beside the reference total, so the gap between worked and confirmed band-slots — the Challenge difference — can be seen reference by reference instead of only as two numbers.",
+      "QSL Manager: a QRZ button next to the Paper QSL search, opening the callsign on QRZ.com.",
+      "LoTW: an \"All my callsigns\" option beside the download. The download is scoped to the profile’s own callsign, so a QSO made as a portable or contest call was confirmed at LoTW and never marked here. Confirmations made under a callsign this logbook has never used are skipped, and a suspiciously small report now shows what LoTW actually answered.",
+      "LoTW download: \"All\" really means all — without a date LoTW answered with a handful of recent confirmations, which looked like a successful download of an empty account. A full account also has time to arrive: the two-minute limit that ended in \"context deadline exceeded\" is now twenty."
+    ],
+    "fr": [
+      "Chaque radio porte son propre MY_RIG (Réglages → CAT), inscrit sur chaque QSO fait avec elle — avant la station par bande des Conditions de trafic, qui dit ce qui était prévu et non quelle radio émet. Laissé vide, rien ne change.",
+      "Matrice des contacts : un point dans le coin d'une case indique que l'indicatif en cours a déjà été contacté sur ce créneau, quelle que soit la couleur donnée par le statut de l'entité. Ses deux couleurs (contacté / confirmé avec cet indicatif) se règlent dans Apparence avec les autres couleurs de la matrice.",
+      "Scope Icom : la forme des commandes (avec ou sans le sélecteur main/sub) est déduite des réponses de la radio au lieu d'une liste de modèles. Une radio qui pilote son scope mais ne l'envoie pas en CI-V — l'IC-7851 — l'indique dans le panneau au lieu d'afficher un rectangle noir.",
+      "Elecraft KPA : la pastille de la barre d'état montre enfin l'amplificateur comme connecté et bascule OPERATE / STANDBY comme les autres marques, et un KPA hors ligne ne s'annonce plus comme un Acom.",
+      "Cluster : une colonne SOTA, lue dans la référence de sommet que les flux SOTA mettent dans le commentaire du spot. Cliquer le spot remplit la référence SOTA du QSO, comme le faisait déjà un spot POTA. Colonne à activer dans Colonnes. Ajoutez le serveur cluster.sota.org.uk:7300 pour recevoir les spots de sommets.",
+      "Awards : un filtre « Slots à confirmer » et un compteur à côté du total de références, pour voir l'écart entre créneaux contactés et confirmés — la différence du Challenge — référence par référence et non plus seulement en deux chiffres.",
+      "Gestionnaire QSL : un bouton QRZ à côté de la recherche QSL papier, qui ouvre l'indicatif sur QRZ.com.",
+      "LoTW : une option « Tous mes indicatifs » à côté du téléchargement. Celui-ci est limité à l'indicatif du profil, si bien qu'un QSO fait sous un indicatif portable ou de contest était confirmé chez LoTW sans jamais être marqué ici. Les confirmations faites sous un indicatif que ce carnet n'a jamais utilisé sont ignorées, et un rapport anormalement petit affiche désormais ce que LoTW a réellement répondu.",
+      "Téléchargement LoTW : « Tout » veut enfin dire tout — sans date, LoTW ne renvoyait qu'une poignée de confirmations récentes, ce qui ressemblait à un téléchargement réussi d'un compte vide. Un compte complet a aussi le temps d'arriver : la limite de deux minutes, qui finissait en « context deadline exceeded », passe à vingt."
+    ]
+  },
   {
     "version": "0.26.19",
     "date": "",
@@ -1919,4 +2005,4 @@
       "Ce résumé « Nouveautés » s'affiche désormais au premier lancement après chaque mise à jour."
     ]
   }
-]
+]

frontend/src/App.tsx

@@ -41,6 +41,7 @@ import {
   IcomSendCW, YaesuSendCW, YaesuStopCW, SetYaesuKeySpeed, IcomStopCW, IcomSetKeySpeed, IcomSetBreakIn, GetIcomState,
   KenwoodSendCW, KenwoodStopCW, SetKenwoodKeySpeed,
   FlexSendCW, FlexStopCW, FlexSetKeySpeed, FlexBackspaceCW,
+  TCISendCW, TCIStopCW, TCISetKeySpeed,
   GetDVKMessages, GetDVKStatus, DVKPlay, DVKStop,
   StartCWDecoder, StopCWDecoder, SetCWDecoderPitch,
   ChatAvailable, GetChatHistory, SendChatMessage, GetOnlineOperators,
@@ -57,6 +58,7 @@ import {
 import { Combobox } from '@/components/ui/combobox';
 import { applyAwardRefs, parseAwardRefs as parseManualRefs, spotRefList , withIOTARef, withRDARef } from '@/lib/awardRefs';
 import { ListRadios, SetActiveRadio } from '../wailsjs/go/main/App';
+import { formatDistance } from '@/lib/units';
 import { EventsOn, BrowserOpenURL, WindowMinimise, WindowToggleMaximise, WindowIsMaximised, Quit } from '../wailsjs/runtime/runtime';
 import type { adif as adifModels, lookup as lookupModels, cat as catModels } from '../wailsjs/go/models';
 import type { QSOForm, WorkedBeforeView, StationSettingsForm, ListsSettingsForm, ModePresetForm } from '@/types';
@@ -68,6 +70,8 @@ import {
 import { APP_VERSION, APP_AUTHOR } from '@/version';
 import { QSLManagerPanel } from '@/components/QSLManagerModal';
 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';
@@ -1265,6 +1269,8 @@ 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);
@@ -1489,7 +1495,7 @@ export default function App() {
   // CI-V 0x17 (no extra hardware — sends over the CAT connection). Macros,
   // auto-call and <LOGQSO> are shared; only the transport differs.
   const [wkEngine, setWkEngine] = useState<string>('winkeyer');
-  const cwSource: 'winkeyer' | 'icom' | 'flex' | 'yaesu' | 'kenwood' = wkEngine === 'icom' ? 'icom' : wkEngine === 'flex' ? 'flex' : wkEngine === 'yaesu' ? 'yaesu' : wkEngine === 'kenwood' ? 'kenwood' : 'winkeyer';
+  const cwSource: 'winkeyer' | 'icom' | 'flex' | 'yaesu' | 'kenwood' | 'tci' = wkEngine === 'icom' ? 'icom' : wkEngine === 'flex' ? 'flex' : wkEngine === 'yaesu' ? 'yaesu' : wkEngine === 'kenwood' ? 'kenwood' : wkEngine === 'tci' ? 'tci' : 'winkeyer';
   // Setting the CW speed has to reach the keyer that is ACTUALLY sending, and
   // both the CW panel and the Yaesu console can ask for it. With DTR/RTS line
   // keying the PC does the timing, so the rig's internal keyer speed changes
@@ -1503,6 +1509,7 @@ export default function App() {
     else if (src === 'flex') FlexSetKeySpeed(w).catch(() => {});
     else if (src === 'yaesu') SetYaesuKeySpeed(w).catch(() => {});
     else if (src === 'kenwood') SetKenwoodKeySpeed(w).catch(() => {});
+    else if (src === 'tci') TCISetKeySpeed(w).catch(() => {});
     else WinkeyerSetSpeed(w).catch(() => {});
     // The rig's own keyer follows too whenever a Yaesu is on CAT, even when it is
     // not the sending engine: its front panel and OpsLog then agree.
@@ -1547,6 +1554,7 @@ export default function App() {
       : cwSource === 'flex' ? (catState.backend === 'flex' && catState.connected)
       : cwSource === 'yaesu' ? (catState.backend === 'yaesu' && catState.connected)
       : cwSource === 'kenwood' ? (catState.backend === 'kenwood' && catState.connected)
+      : cwSource === 'tci' ? (catState.backend === 'tci' && catState.connected)
       : wkStatus.connected;
     wkActiveRef.current = wkEnabled && connected;
   }, [wkEnabled, wkStatus.connected, cwSource, catState.backend, catState.connected]);
@@ -2064,6 +2072,9 @@ export default function App() {
   useEffect(() => { spotStatusRef.current = spotStatus; }, [spotStatus]);
   // Mirror of spots so the log-triggered refresh reads the current list without
   // a stale closure.
+  // Arrival times of the last second's spots, for the adaptive batching window
+  // in the cluster:spot listener.
+  const spotRateRef = useRef<number[]>([]);
   const spotsRef = useRef(spots);
   useEffect(() => { spotsRef.current = spots; }, [spots]);
   // The decoded stations, for the same reason: the status refresh and the cache
@@ -3275,7 +3286,7 @@ export default function App() {
   function handleSpotSelect(s: any) {
     if (!s?.dx_call?.trim()) return;
     onCallsignInput(s.dx_call, { force: true });
-    applySpotPOTA((s as any).pota_ref);
+    applySpotRefs((s as any).pota_ref, (s as any).sota_ref);
   }
 
   function handleSpotClick(s: any) {
@@ -3300,7 +3311,7 @@ export default function App() {
     FlexZoomForSpot(m ?? '', s.freq_hz ?? 0).catch(() => {});
     if (m) applyModeFromSpot(m);
     onCallsignInput(s.dx_call, { force: true });
-    applySpotPOTA((s as any).pota_ref);
+    applySpotRefs((s as any).pota_ref, (s as any).sota_ref);
     if (s.dx_call?.trim()) restartRecordingForNewTarget(s.dx_call);
   }
 
@@ -3591,11 +3602,24 @@ export default function App() {
     const unsubSpot = EventsOn('cluster:spot', (sp: ClusterSpot) => {
       // Stage the spot; a short timer resolves its status then commits it.
       pendingSpotsRef.current.push(sp);
-      // 50 ms is enough to coalesce an RBN burst into one status lookup (the
-      // worked-index is in memory, so resolving is near-instant) while staying
-      // imperceptible.
+      // The window WIDENS with the rate of the feed.
+      //
+      // Every flush commits state that the whole window re-renders on, so a
+      // fixed 50 ms means twenty full renders a second under an RBN firehose —
+      // and that is felt everywhere else: a dropdown highlighting its entries a
+      // beat late as the mouse moves down them, which is what was reported.
+      //
+      // A quiet cluster keeps the 50 ms: a handful of spots an hour should
+      // appear the moment they arrive. A busy one is coalesced instead, and half
+      // a second's delay on a line in a list that is already scrolling past is
+      // not something anyone can see.
+      const now = Date.now();
+      spotRateRef.current = spotRateRef.current.filter((t) => now - t < 1000);
+      spotRateRef.current.push(now);
+      const perSec = spotRateRef.current.length;
+      const window_ms = perSec > 20 ? 500 : perSec > 5 ? 200 : 50;
       if (pendingSpotTimer.current === undefined) {
-        pendingSpotTimer.current = window.setTimeout(flushPendingSpots, 50);
+        pendingSpotTimer.current = window.setTimeout(flushPendingSpots, window_ms);
       }
       // Self-spot: someone spotted OUR callsign — show it in the shared header
       // toast (same place as the other notifications), not a separate banner.
@@ -3761,14 +3785,14 @@ export default function App() {
       restartRecordingForNewTarget(call);
       // The park, like a click in the band map: the radio reports only a
       // callsign, so the backend looks it up again before sending the event.
-      applySpotPOTA(String(p?.pota_ref ?? ''));
+      applySpotRefs(String(p?.pota_ref ?? ''), String(p?.sota_ref ?? ''));
     });
     // Clicking a spot on the ExpertSDR (TCI) panorama fills the call, like Flex.
     const unsubTciSpot = EventsOn('tci:spot_clicked', (p: any) => {
       const call = String(p?.call ?? '');
       if (!applyUdpCall(call, true)) return;
       restartRecordingForNewTarget(call);
-      applySpotPOTA(String(p?.pota_ref ?? ''));
+      applySpotRefs(String(p?.pota_ref ?? ''), String(p?.sota_ref ?? ''));
     });
     const unsubBulk = EventsOn('bulkupdate:progress', (p: any) => {
       const total = Number(p?.total ?? 0);
@@ -3967,7 +3991,7 @@ export default function App() {
     // segment AFTER the <LOGQSO> (which logs and clears the form) still expands its
     // variables correctly.
     const parts = rawText.split(/<LOGQSO>/i).map((pt) => resolveCW(pt));
-    const isRig = cwSourceRef.current === 'icom' || cwSourceRef.current === 'flex' || cwSourceRef.current === 'yaesu' || cwSourceRef.current === 'kenwood';
+    const isRig = cwSourceRef.current === 'icom' || cwSourceRef.current === 'flex' || cwSourceRef.current === 'yaesu' || cwSourceRef.current === 'kenwood' || cwSourceRef.current === 'tci';
     for (let p = 0; p < parts.length; p++) {
       if (aborted()) return; // ESC / Stop before this segment → stop sending, don't log
       const resolved = parts[p];
@@ -3979,7 +4003,7 @@ export default function App() {
         // current WPM, so it scales automatically.
         const keyed = resolved + ' ';
         setWkSent(resolved);
-        const sendFn = cwSourceRef.current === 'flex' ? FlexSendCW : cwSourceRef.current === 'icom' ? IcomSendCW : cwSourceRef.current === 'yaesu' ? YaesuSendCW : cwSourceRef.current === 'kenwood' ? KenwoodSendCW : null;
+        const sendFn = cwSourceRef.current === 'flex' ? FlexSendCW : cwSourceRef.current === 'icom' ? IcomSendCW : cwSourceRef.current === 'yaesu' ? YaesuSendCW : cwSourceRef.current === 'kenwood' ? KenwoodSendCW : cwSourceRef.current === 'tci' ? TCISendCW : null;
         if (sendFn) await sendFn(keyed).catch((e) => setError(String(e?.message ?? e)));
         else await WinkeyerSend(keyed).catch((e) => setError(String(e?.message ?? e)));
         // WAIT for THIS segment's CW to finish before moving on — so a <LOGQSO>
@@ -4022,6 +4046,7 @@ export default function App() {
     else if (cwSourceRef.current === 'flex') FlexStopCW().catch(() => {});
     else if (cwSourceRef.current === 'yaesu') YaesuStopCW().catch(() => {});
     else if (cwSourceRef.current === 'kenwood') KenwoodStopCW().catch(() => {});
+    else if (cwSourceRef.current === 'tci') TCIStopCW().catch(() => {});
     else WinkeyerStop().catch(() => {});
   }
   // runAutoCall sends macro i, waits for the keyer to finish, waits the chosen
@@ -4070,6 +4095,10 @@ export default function App() {
   // send-on-type: key the typed chars verbatim (no variable substitution).
   function wkSendRaw(chars: string) {
     if (cwSourceRef.current === 'flex') { FlexSendCW(chars).catch(() => {}); return; }
+    // TCI keys the character as a macro of its own. There is no un-typing it
+    // afterwards — the radio can stop the message but not shorten it — so the
+    // backspace below leaves the TCI engine alone rather than pretending.
+    if (cwSourceRef.current === 'tci') { TCISendCW(chars).catch(() => {}); return; }
     WinkeyerSend(chars).catch(() => {});
   }
   function wkBackspace() {
@@ -4796,13 +4825,17 @@ export default function App() {
     }
     wbTimerRef.current = window.setTimeout(() => runWorkedBefore(call), 150);
   }
-  // applySpotPOTA sets the QSO's POTA award reference(s) from a clicked spot's
-  // park ref ("US-4164" or n-fer "US-1,US-2"). Empty ref clears it (fresh
-  // target). Routed to the pota_ref column at save via applyAwardRefs.
-  function applySpotPOTA(potaRef?: string) {
-    const refs = String(potaRef || '')
-      .split(/[,;]/).map((x) => x.trim().toUpperCase()).filter(Boolean);
-    setDetails((d) => ({ ...d, award_refs: refs.map((r) => `POTA@${r}`).join(';') }));
+  // Award references carried by the spot itself: the park a station is
+  // activating, the summit it is on, or both. Written into award_refs the same
+  // way for each, so logging the contact credits it without retyping a
+  // reference that was on screen.
+  function applySpotRefs(potaRef?: string, sotaRef?: string) {
+    const split = (v?: string) => String(v || '').split(/[,;]/).map((x) => x.trim().toUpperCase()).filter(Boolean);
+    const refs = [
+      ...split(potaRef).map((r) => `POTA@${r}`),
+      ...split(sotaRef).map((r) => `SOTA@${r}`),
+    ];
+    setDetails((d) => ({ ...d, award_refs: refs.join(';') }));
   }
   function onCallsignInput(v: string, opts?: { force?: boolean }) {
     // Programmatic call-sets (force: spot click, UDP, external app) count as
@@ -4969,6 +5002,8 @@ 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' },
@@ -5022,6 +5057,8 @@ 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;
@@ -5897,11 +5934,17 @@ export default function App() {
     });
     let rendered = list as (ClusterSpot & { repeats?: number })[];
     if (clusterGroup) {
+      // A DUPLICATE is the same station on the same band AND mode — the dozen
+      // skimmers that all heard one CQ. The same station on another band is the
+      // opposite of a duplicate: it is the line a DX chaser is scanning for, and
+      // grouping on the callsign alone deleted it. RI1FJL spotted on five bands
+      // showed as one row, so four slots simply vanished from the list.
       const seen = new Map<string, ClusterSpot & { repeats: number }>();
       for (const s of list) {
-        const e = seen.get(s.dx_call);
+        const key = `${(s.dx_call ?? '').toUpperCase()}|${(s.band ?? '').toLowerCase()}|${inferSpotMode(s.comment ?? '', s.freq_hz)}`;
+        const e = seen.get(key);
         if (e) { e.repeats++; }
-        else seen.set(s.dx_call, { ...s, repeats: 1 });
+        else seen.set(key, { ...s, repeats: 1 });
       }
       rendered = Array.from(seen.values());
     }
@@ -6223,13 +6266,19 @@ export default function App() {
       case 'cluster':
         return (
           <div className="h-full w-full min-h-0 flex flex-col bg-card border border-border rounded-lg overflow-hidden">
-            <div className="flex items-center justify-between px-2 py-1 border-b border-border/60 shrink-0">
-              <span className="text-[11px] font-semibold uppercase tracking-wider text-muted-foreground">Cluster</span>
-              {clusterFiltersToggleBtn}
-            </div>
             <div className="flex-1 min-h-0 flex">
               <div className="flex-1 min-w-0 flex flex-col min-h-0">
-                <ClusterGrid key={`clg-${activeProfileId ?? 'x'}`} rows={clusterRenderedRows as any} spotStatus={spotStatus} onSpotClick={handleSpotClick} onSpotSelect={handleSpotSelect} />
+                {/* Title, count and Filters ride INSIDE the grid's toolbar: two
+                    header rows cost a pane that is often only a few spots tall
+                    one of the few lines it has. */}
+                <ClusterGrid key={`clg-${activeProfileId ?? 'x'}`} rows={clusterRenderedRows as any} spotStatus={spotStatus} onSpotClick={handleSpotClick} onSpotSelect={handleSpotSelect}
+                  headerLeft={(
+                    <>
+                      <span className="text-[11px] font-semibold uppercase tracking-wider text-muted-foreground shrink-0">DX Cluster</span>
+                      <Badge variant="secondary" className="text-[10px] shrink-0">{spots.length} live</Badge>
+                      {clusterFiltersToggleBtn}
+                    </>
+                  )} />
               </div>
               {clusterShowFilters && renderClusterFilters()}
             </div>
@@ -6415,7 +6464,7 @@ export default function App() {
                     disabled={disabled}
                     onClick={() => p && goto(p.bearingShort, 'SP')}
                     title={p
-                      ? `Rotate short-path · ${Math.round(p.distanceShort).toLocaleString()} km`
+                      ? `Rotate short-path · ${formatDistance(p.distanceShort)}`
                       : (station.my_grid ? 'No remote grid' : 'Set your station grid in Preferences')}
                     className={cn(
                       'inline-flex items-center gap-1 px-2 py-0.5 transition-colors',
@@ -6431,7 +6480,7 @@ export default function App() {
                     type="button"
                     disabled={disabled}
                     onClick={() => p && goto(p.bearingLong, 'LP')}
-                    title={p ? `Rotate long-path · ${Math.round(p.distanceLong).toLocaleString()} km` : ''}
+                    title={p ? `Rotate long-path · ${formatDistance(p.distanceLong)}` : ''}
                     className={cn(
                       'px-1.5 py-0.5 border-l border-info-border text-[10px] transition-colors',
                       disabled
@@ -8423,9 +8472,13 @@ export default function App() {
                 STANDBY, red = offline. CLICK toggles OPERATE ↔ STANDBY (optimistic
                 flip, the 2s poll reconciles); offline → click opens the settings. */}
             {ampSts.map((a: any) => {
-              const isPGXL = !a.spe && !a.acom;
+              // Every brand must be listed here. A KPA was not, so its chip
+              // read the fallback — permanently red on a connected amplifier,
+              // and clicking it opened the settings instead of switching to
+              // STANDBY.
+              const isPGXL = !a.spe && !a.acom && !a.kpa;
               const viaFlex = isPGXL && !!flexAmp?.amp_available;
-              const raw = a.spe ?? a.acom ?? a.pgxl ?? { connected: false };
+              const raw = a.spe ?? a.acom ?? a.kpa ?? a.pgxl ?? { connected: false };
               const connected = !!raw.connected || viaFlex;
               const operate = viaFlex ? !!flexAmp.amp_operate : !!raw.operate;
               const dot = !connected ? 'bg-danger' : operate ? 'bg-success' : 'bg-warning';
@@ -8435,7 +8488,7 @@ export default function App() {
                 const want = !operate;
                 if (viaFlex) setFlexAmp((f: any) => ({ ...f, amp_operate: want }));
                 else setAmpSts((l) => l.map((x: any) => x.id === a.id
-                  ? { ...x, spe: x.spe && { ...x.spe, operate: want }, acom: x.acom && { ...x.acom, operate: want }, pgxl: x.pgxl && { ...x.pgxl, operate: want } }
+                  ? { ...x, spe: x.spe && { ...x.spe, operate: want }, acom: x.acom && { ...x.acom, operate: want }, kpa: x.kpa && { ...x.kpa, operate: want }, pgxl: x.pgxl && { ...x.pgxl, operate: want } }
                   : x));
                 (viaFlex ? FlexAmpOperate(want) : AmpOperate(a.id, want)).catch(() => {});
               };
@@ -8562,7 +8615,7 @@ export default function App() {
                     "1.5k" and then appended the unit, giving "1.5kkm" — and even
                     written correctly, "1.5k km" makes a reader do arithmetic to
                     recover a number that was four characters long to begin with. */}
-                <span className="font-mono opacity-80">{o.median_km} km</span>
+                <span className="font-mono opacity-80">{formatDistance(o.median_km)}</span>
                 {/* Out of season is the one an operator must not learn last, so it
                     earns a mark on the badge rather than a line in the tooltip. */}
                 {!o.in_season && <span className="opacity-90">!</span>}
@@ -8667,6 +8720,8 @@ 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/AmpCard.tsx

@@ -194,7 +194,7 @@ export function AmpCard({ amp, flex, t }: { amp: Amp; flex: any; t: (k: string,
           </div>
           <span className={cn('inline-flex items-center gap-1.5 text-sm', kpa.connected ? 'text-muted-foreground' : 'text-danger')}>
             <span className={cn('size-2 rounded-full', kpa.connected ? 'bg-success' : 'bg-danger')} />
-            {kpa.connected ? (kpa.tuning ? t('flxp.kpaTuning') : (kpa.power_on ? 'ON' : 'OFF')) : t('flxp.acomOffline')}
+            {kpa.connected ? (kpa.tuning ? t('flxp.kpaTuning') : (kpa.power_on ? 'ON' : 'OFF')) : t('flxp.kpaOffline')}
           </span>
           {kpa.connected && (
             <span className="text-sm font-mono text-muted-foreground tabular-nums">

frontend/src/components/AppearancePanel.tsx

@@ -127,6 +127,12 @@ function MatrixColorsSection() {
             <span className="inline-block w-7 h-5 rounded bg-mx-dx-work" />
             <span className="inline-block w-7 h-5 rounded bg-mx-none" />
             <span className="inline-block w-7 h-5 rounded bg-mx-none ring-2 ring-mx-cur ring-inset" />
+            <span className="relative inline-block w-7 h-5 rounded bg-mx-dx-conf">
+              <span className="absolute top-[4px] right-[4px] size-[5px] rounded-full bg-mx-mark-work ring-1 ring-background" />
+            </span>
+            <span className="relative inline-block w-7 h-5 rounded bg-mx-dx-conf">
+              <span className="absolute top-[4px] right-[4px] size-[5px] rounded-full bg-mx-mark-conf ring-1 ring-background" />
+            </span>
           </div>
 
           <button type="button" onClick={reset}

frontend/src/components/AwardsPanel.tsx

@@ -65,6 +65,19 @@ function cellStatus(r: AwardRef, band: string): CellStatus {
   if (r.bands?.includes(band)) return 'worked';
   return 'none';
 }
+// slotsToConfirm counts the band-slots worked with this reference and not yet
+// confirmed on any of them — the QSLs still outstanding, one per cell showing W.
+//
+// It is the difference the Challenge line makes visible in the aggregate (1832
+// worked against 1554 confirmed) without saying WHERE it is. Counted over the
+// bands actually on screen, so it always adds up to the columns in front of the
+// operator rather than to a band set they filtered out.
+function slotsToConfirm(r: AwardRef, bands: string[]): number {
+  let n = 0;
+  for (const b of bands) if (cellStatus(r, b) === 'worked') n++;
+  return n;
+}
+
 const CELL_STYLE: Record<CellStatus, string> = {
   validated: 'bg-success text-success-foreground',
   confirmed: 'bg-warning text-warning-foreground',
@@ -112,7 +125,7 @@ export function AwardsPanel({ onEditQSO, onAwardsChanged, onPaperQSL }: {
   const [refSearch, setRefSearch] = useState('');
   const [editing, setEditing] = useState(false);
   const [view, setView] = useState<'grid' | 'list' | 'stats'>('grid');
-  const [refFilter, setRefFilter] = useState<'all' | 'worked' | 'notworked' | 'worked_notconf'>('all');
+  const [refFilter, setRefFilter] = useState<'all' | 'worked' | 'notworked' | 'worked_notconf' | 'slots_notconf'>('all');
   // Mode filter, stacked ON TOP of the status one. "Worked on CW but not
   // confirmed" is two questions at once, and answering only one of them is what
   // sends an operator to a spreadsheet.
@@ -304,6 +317,10 @@ export function AwardsPanel({ onEditQSO, onAwardsChanged, onPaperQSL }: {
       if (refFilter === 'worked' && !r.worked) return false;
       if (refFilter === 'notworked' && r.worked) return false;
       if (refFilter === 'worked_notconf' && !(r.worked && !r.confirmed)) return false;
+      // Worked-not-confirmed by SLOT, not by reference: an entity confirmed on
+      // 20 m still has a 15 m contact waiting for its card, and every filter
+      // above answers "no" for it because the entity itself is confirmed.
+      if (refFilter === 'slots_notconf' && slotsToConfirm(r, gridBands) === 0) return false;
       if (modeFilter !== 'all' && refFilter !== 'notworked') {
         // A reference never worked has no mode, so "not worked" plus a mode is
         // a contradiction: the mode filter stands aside rather than emptying
@@ -339,7 +356,14 @@ export function AwardsPanel({ onEditQSO, onAwardsChanged, onPaperQSL }: {
       }
       return a.ref.localeCompare(b.ref, undefined, { numeric: true }) * dir;
     });
-  }, [current, refSearch, refFilter, modeFilter, refSort, refSortDir]);
+  }, [current, refSearch, refFilter, modeFilter, refSort, refSortDir, gridBands]);
+
+  // The gap itself, over whatever the other filters left on screen: the number
+  // of cells an operator would have to turn green to close it.
+  const slotGap = useMemo(
+    () => filteredRefs.reduce((n, r) => n + slotsToConfirm(r, gridBands), 0),
+    [filteredRefs, gridBands],
+  );
 
   // The group column earns its width only when the list actually carries one
   // (DXCC prefixes, POTA locations); most custom lists have none. For DXCC the
@@ -468,7 +492,7 @@ export function AwardsPanel({ onEditQSO, onAwardsChanged, onPaperQSL }: {
                 <Input className="h-8 w-56 pl-7 text-sm" placeholder={t('awp.filterReferences')} value={refSearch} onChange={(e) => setRefSearch(e.target.value)} />
               </div>
               <div className="flex items-center rounded-md border border-border overflow-hidden text-sm">
-                {([['all', t('awp.filterAll')], ['worked', t('awp.filterWkd')], ['notworked', t('awp.filterNotWkd')], ['worked_notconf', t('awp.filterWkdNotCfmd')]] as const).map(([k, label]) => (
+                {([['all', t('awp.filterAll')], ['worked', t('awp.filterWkd')], ['notworked', t('awp.filterNotWkd')], ['worked_notconf', t('awp.filterWkdNotCfmd')], ['slots_notconf', t('awp.filterSlotsNotCfmd')]] as const).map(([k, label]) => (
                   <button key={k} onClick={() => setRefFilter(k)}
                     className={cn('px-2 py-1', refFilter === k ? 'bg-accent font-medium' : 'hover:bg-accent/50 text-muted-foreground')}>
                     {label}
@@ -484,6 +508,11 @@ export function AwardsPanel({ onEditQSO, onAwardsChanged, onPaperQSL }: {
                 ))}
               </div>
               <span className="text-xs text-muted-foreground">{filteredRefs.length} {t('awp.refs')}</span>
+              {slotGap > 0 && (
+                <span className="text-xs text-muted-foreground" title={t('awp.slotGapTip')}>
+                  · <span className="font-semibold text-foreground">{slotGap}</span> {t('awp.slotGap')}
+                </span>
+              )}
               {/* Only for an award scoped to a DXCC entity. "In this award's
                   scope but with no reference" needs a scope to be in: on a
                   worldwide reference award — POTA, SOTA, IOTA, WWFF — every
@@ -604,7 +633,14 @@ export function AwardsPanel({ onEditQSO, onAwardsChanged, onPaperQSL }: {
                             <td key={b} className="border-b border-l border-border/30 p-0 text-center">
                               {s === 'none' ? <span className="block w-11 h-7" /> : (
                                 <button
-                                  className={cn('block w-11 h-7 text-[11px] font-bold', CELL_STYLE[s], 'hover:brightness-110')}
+                                  className={cn('block w-11 h-7 text-[11px] font-bold', CELL_STYLE[s], 'hover:brightness-110',
+                                    // Chasing the slots still to confirm, the
+                                    // confirmed ones are context, not the answer:
+                                    // a row is kept for its W cells and its V
+                                    // cells would otherwise be the loudest thing
+                                    // on it. Faded rather than hidden — which
+                                    // band is already done is worth seeing.
+                                    refFilter === 'slots_notconf' && s !== 'worked' && 'opacity-25')}
                                   title={t('awp.cellTitle', { ref: r.ref, band: b })}
                                   onClick={() => setCell({ ref: r.ref, band: b, name: r.name })}
                                 >{CELL_LABEL[s]}</button>

frontend/src/components/BandMap.tsx

@@ -76,6 +76,13 @@ const BMP_MARKER_LABEL: Record<string, string> = {
   new_pota: 'bmp.legendNewPota',
   new_county: 'bmp.legendNewCounty',
   worked_call: 'bmp.legendWorkedCall',
+  // Not on the strip — the pill is 22 px and a fourth segment turns it into a
+  // colour code nobody reads — but the TOOLTIP has room, and leaving them out of
+  // it made the two panels contradict each other: the cluster said NEW PFX about
+  // a spot the map called "Worked". Both were true (the entity is worked on this
+  // slot, the WPX prefix never has been) and neither view said so.
+  new_pfx: 'clg2.newPfx',
+  new_grid: 'clg2.newGrid',
 };
 
 interface Props {
@@ -737,7 +744,7 @@ export function BandMap({ band, spots, spotStatus: spotStatusRaw, currentFreqHz,
                   'hover:translate-x-0.5 hover:shadow',
                   style.pill,
                 )}
-                title={`${p.spot.dx_call}${entry?.country ? ' · ' + entry.country : ''} · ${p.spot.freq_khz.toFixed(1)} kHz · ${statusLabel(st, t)}${markersFor(entry).map((m) => ' · ' + t(BMP_MARKER_LABEL[m.key])).join('')}${p.spot.comment ? ' · ' + p.spot.comment : ''}${p.spot.spotter ? ' · de ' + p.spot.spotter : ''}`}
+                title={`${p.spot.dx_call}${entry?.country ? ' · ' + entry.country : ''} · ${p.spot.freq_khz.toFixed(1)} kHz · ${statusLabel(st, t)}${activeMarkers(entry).map((m) => ' · ' + t(BMP_MARKER_LABEL[m.key])).join('')}${p.spot.comment ? ' · ' + p.spot.comment : ''}${p.spot.spotter ? ' · de ' + p.spot.spotter : ''}`}
               >
                 {/* Left accent strip. With no extra marker it repeats the status
                     colour, exactly as before; otherwise it splits into one

frontend/src/components/BandSlotGrid.tsx

@@ -81,23 +81,44 @@ const STATUS_CLASSES: Record<string, string> = {
 // i18n keys the Appearance panel's colour pickers use, so the two can never
 // disagree about which green is which. swatch = the background class (or a
 // special ring marker for the current-entry cell).
-const LEGEND: { swatch: string; ring?: boolean; label: string }[] = [
+const LEGEND: { swatch: string; ring?: boolean; mark?: string; label: string }[] = [
   { swatch: 'bg-mx-call-conf', label: 'mx.callConf' },
   { swatch: 'bg-mx-call-work', label: 'mx.callWork' },
   { swatch: 'bg-mx-dx-conf', label: 'mx.dxConf' },
   { swatch: 'bg-mx-dx-work', label: 'mx.dxWork' },
   { swatch: 'bg-mx-none', label: 'mx.none' },
   { swatch: 'bg-mx-none', ring: true, label: 'mx.current' },
+  { swatch: 'bg-mx-none', mark: 'w', label: 'mx.markWork' },
+  { swatch: 'bg-mx-none', mark: 'c', label: 'mx.markConf' },
 ];
 
-function cellTitle(t: (k: string) => string, band: string, cls: string, status: string, current: boolean): string {
+// CallMark — "this callsign has already been worked on this slot".
+//
+// Drawn the same way on every cell, whatever colour the entity status gave it:
+// the operator learns one shape and reads it without first working out what the
+// background means. Only the fill changes, and only with the callsign's own
+// state (worked / confirmed) — never with the entity's. The ring is the theme
+// background, which is what keeps the dot legible over all five cell colours.
+function CallMark({ state = 'w' }: { state?: string }) {
+  return (
+    <span
+      className={cn(
+        'pointer-events-none absolute top-[4px] right-[4px] size-[5px] rounded-full ring-1 ring-background',
+        state === 'c' ? 'bg-mx-mark-conf' : 'bg-mx-mark-work',
+      )}
+    />
+  );
+}
+
+function cellTitle(t: (k: string) => string, band: string, cls: string, status: string, current: boolean, call = ''): string {
   const desc =
     status === 'call_c' ? t('mx.tipCallConf') :
     status === 'call_w' ? t('mx.tipCallWork') :
     status === 'dxcc_c' ? t('mx.tipDxConf') :
     status === 'dxcc_w' ? t('mx.tipDxWork') :
                           t('mx.tipNone');
-  return `${band} ${cls}: ${desc}${current ? ' — ' + t('mx.current') : ''}`;
+  const mine = call === 'c' ? t('mx.tipThisCallConf') : call === 'w' ? t('mx.tipThisCall') : '';
+  return `${band} ${cls}: ${desc}${mine ? ' — ' + mine : ''}${current ? ' — ' + t('mx.current') : ''}`;
 }
 
 export function BandSlotGrid({ wb, busy, currentBand, currentMode, bands, hasCall = true, lat, lon, forCall, onEditQso }: Props) {
@@ -126,6 +147,16 @@ export function BandSlotGrid({ wb, busy, currentBand, currentMode, bands, hasCal
     return m;
   }, [wb]);
 
+  // Worked-with-this-callsign, per cell — carried separately by the backend
+  // because collapsing it into the status is what hid it.
+  const callMap = useMemo(() => {
+    const m = new Map<string, string>();
+    for (const s of wb?.band_status ?? []) {
+      if ((s as any).call) m.set(`${s.band}|${s.class}`, (s as any).call);
+    }
+    return m;
+  }, [wb]);
+
   // "Newness" of the current band+mode entry, for the award/DX-chase badges.
   // Derived straight from the entity's real band_status (all bands it was
   // worked on — not just the operator's configured column list).
@@ -308,21 +339,29 @@ export function BandSlotGrid({ wb, busy, currentBand, currentMode, bands, hasCal
                 </th>
                 {cols.map((b) => {
                   const st = statusMap.get(`${b.tag}|${cls}`) ?? '';
+                  // The same cell's other answer: worked with THIS callsign
+                  // here. The status above is the entity's, and a confirmed
+                  // entity outranks a worked call — so chasing a DXpedition,
+                  // the cell could say "confirmed" about a contact made years
+                  // ago and nothing about the one made this morning.
+                  const mine = callMap.get(`${b.tag}|${cls}`) ?? '';
                   const isCurrent = hasCall && b.tag === currentBand && classCurrent;
                   return (
                     <td
                       key={b.tag}
-                      title={cellTitle(t, b.tag, cls, st, isCurrent) + (st ? ' — ' + t('mx.tipClick') : '')}
+                      title={cellTitle(t, b.tag, cls, st, isCurrent, mine) + (st ? ' — ' + t('mx.tipClick') : '')}
                       onClick={st ? () => setSlot({ band: b.tag, cls }) : undefined}
                       className={cn(
-                        'w-[28px] h-[24px] rounded transition-colors p-0',
+                        'relative w-[28px] h-[24px] rounded transition-colors p-0',
                         st ? STATUS_CLASSES[st] : 'bg-mx-none',
                         // Only a filled cell has anything to show — an empty one
                         // stays inert rather than opening a "no QSOs" dialog.
                         st && 'cursor-pointer hover:brightness-110',
                         isCurrent && 'ring-2 ring-mx-cur ring-inset',
                       )}
-                    />
+                    >
+                      {mine ? <CallMark state={mine} /> : null}
+                    </td>
                   );
                 })}
               </tr>
@@ -337,11 +376,13 @@ export function BandSlotGrid({ wb, busy, currentBand, currentMode, bands, hasCal
           <span key={l.label} className="flex items-center gap-1.5 text-[10px] text-muted-foreground">
             <span
               className={cn(
-                'inline-block size-3 rounded shrink-0',
+                'relative inline-block size-3 rounded shrink-0',
                 l.swatch,
                 l.ring && 'ring-2 ring-mx-cur ring-inset',
               )}
-            />
+            >
+              {l.mark ? <CallMark state={l.mark} /> : null}
+            </span>
             {t(l.label)}
           </span>
         ))}

frontend/src/components/ChaseNewPanel.tsx

@@ -10,6 +10,7 @@
 // new is being decoded on FT8/FT4/JS8 near here — not that the band is dead.
 import { useEffect, useMemo, useState } from 'react';
 import { Radar, Loader2, X } from 'lucide-react';
+import { formatDistance } from '@/lib/units';
 import { useI18n } from '@/lib/i18n';
 import { markerColour } from '@/lib/spotMarkers';
 import { cn } from '@/lib/utils';
@@ -186,7 +187,7 @@ export function ChaseNewPanel({ onPick, onClose }: Props) {
                   title={[
                     s.country,
                     s.grid,
-                    s.dist_km ? `${s.dist_km} km` : '',
+                    s.dist_km ? formatDistance(s.dist_km) : '',
                     s.freq_hz ? `${(s.freq_hz / 1000).toFixed(1)} kHz` : '',
                   ].filter(Boolean).join(' · ')}
                 >

frontend/src/components/ClusterGrid.tsx

@@ -15,6 +15,7 @@ import { cleanSpotter, inferSpotMode, spotStatusKey } from '@/lib/spot';
 import { markerColour } from '@/lib/spotMarkers';
 import { applySpotDisplay, 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';
 
 type TFn = (key: string, vars?: Record<string, string | number>) => string;
@@ -45,6 +46,7 @@ export type ClusterSpot = {
   raw: string;
   repeats?: number;
   pota_ref?: string;
+  sota_ref?: string;
   pota_name?: string;
 };
 
@@ -82,6 +84,11 @@ type Props = {
   // stray click while looking took the operator off the station they were
   // working. Looking and going are now two different gestures.
   onSpotSelect?: (s: ClusterSpot) => void;
+  // Anything the caller wants on the LEFT of the toolbar — the pane's title, its
+  // live count, its Filters button. Docked in a pane, the title used to sit on a
+  // row of its own above this one, so the cluster ate two lines of a short pane
+  // where Recent QSOs beside it ate one. Reported by VK4DX.
+  headerLeft?: React.ReactNode;
 };
 
 const COL_STATE_KEY = 'hamlog.clusterColState.v1';
@@ -336,6 +343,16 @@ const makeColCatalog = (t: TFn): ColEntry[] => [
       : { color: 'var(--success)' }) as any,
     tooltipValueGetter: (p: any) => (p.data?.pota_name ? t('clg2.tipPota', { name: p.data.pota_name }) : undefined),
   },
+  {
+    // SOTA sits next to POTA and reads the same way. The reference comes from the
+    // spot's comment, so it is present on the SOTA feeds and empty elsewhere —
+    // 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',
+    defaultVisible: false,
+    cellStyle: () => ({ color: 'var(--success)' }) as any,
+  },
   {
     group: 'Spot', label: t('clg2.c.freq'), colId: 'freq',
     headerName: t('clg2.c.freq'), field: 'freq_khz' as any, width: 95, type: 'rightAligned', cellClass: 'font-mono',
@@ -432,8 +449,13 @@ const makeColCatalog = (t: TFn): ColEntry[] => [
   },
   {
     group: 'Geo', label: t('clg2.c.distance_km'), colId: 'distance_km',
-    headerName: t('clg2.h.distance_km'), field: 'distance_km' as any, width: 80, type: 'rightAligned', cellClass: 'font-mono',
-    valueFormatter: (p) => p.value ? String(p.value) : '',
+    // The header carries the unit, so the cells stay bare numbers and the
+    // column still sorts on the km the backend sent — converting the VALUE
+    // would sort miles as if they were kilometres either way, but it would
+    // also round twice.
+    headerName: t('clg2.h.distance_km') + ' (' + distanceUnit() + ')',
+    field: 'distance_km' as any, width: 90, type: 'rightAligned', cellClass: 'font-mono',
+    valueFormatter: (p) => p.value ? String(distanceValue(p.value)) : '',
     comparator: (a, b) => (a ?? 0) - (b ?? 0),
   },
   {
@@ -506,13 +528,15 @@ const GROUP_ORDER = ['Spot', 'Geo'];
 const CLG_GRP_KEYS: Record<string, string> = { Spot: 'clg2.grpSpot', Geo: 'clg2.grpGeo' };
 const groupLabel = (t: TFn, g: string): string => t(CLG_GRP_KEYS[g] ?? g);
 
-export function ClusterGrid({ rows, spotStatus, onSpotClick, onSpotSelect }: Props) {
+export function ClusterGrid({ rows, spotStatus, onSpotClick, onSpotSelect, headerLeft }: Props) {
   const { t } = useI18n();
   const gridRef = useRef<any>(null);
   const [pickerOpen, setPickerOpen] = useState(false);
 
   // Localized column catalog — rebuilt when the language changes.
-  const COL_CATALOG = useMemo(() => makeColCatalog(t), [t]);
+  const [distUnit, setDistUnit] = useState(distanceUnit);
+  useEffect(() => subscribeDistanceUnit(() => setDistUnit(distanceUnit())), []);
+  const COL_CATALOG = useMemo(() => makeColCatalog(t), [t, distUnit]);
 
   // A rebuild makes AG Grid re-apply every colDef hide/width DEFAULT and fire the
   // matching column events. Without this guard those events were persisted, so a
@@ -603,16 +627,27 @@ export function ClusterGrid({ rows, spotStatus, onSpotClick, onSpotSelect }: Pro
   const [held, setHeld] = useState<ClusterSpot[] | null>(null);
   const shown = held ?? rows;
 
-  // How many arrived since the freeze. Counted by finding the frozen top row in
-  // the live list rather than by comparing lengths: the list is a ring buffer,
-  // so once it is full the length stops growing and a length comparison would
-  // report nothing new for the rest of the evening.
-  const spotID = (r: ClusterSpot) => `${(r as any).received_at}-${r.dx_call}-${(r as any).source_id}`;
+  // How many arrived since the freeze — counted by TIME, not by finding the
+  // frozen top row again.
+  //
+  // Looking for that row was wrong in the ordinary case: a station spotted again
+  // REPLACES its row (that is the de-dupe), so the row we froze on disappears
+  // from the live list the moment somebody re-spots it — and the count fell
+  // through to "everything is new", jumping from 4 to the buffer cap. Reported
+  // as "it shows 4, 5 new spots and then 500 all at once".
+  //
+  // A timestamp survives both the replacement and the ring buffer, which was the
+  // reason the length was not used either.
+  const spotTime = (r: ClusterSpot) => Date.parse(String((r as any).received_at ?? '')) || 0;
   const waiting = useMemo(() => {
     if (!held || held.length === 0) return 0;
-    const top = spotID(held[0]);
-    const i = rows.findIndex((r) => spotID(r) === top);
-    return i < 0 ? rows.length : i; // fell out of the buffer: everything is new
+    const since = spotTime(held[0]);
+    if (!since) return 0; // no usable timestamp — say nothing rather than a number
+    let n = 0;
+    for (const r of rows) {
+      if (spotTime(r) > since) n++;
+    }
+    return n;
   }, [held, rows]);
 
   const onBodyScroll = (e: { top: number }) => {
@@ -670,7 +705,9 @@ export function ClusterGrid({ rows, spotStatus, onSpotClick, onSpotSelect }: Pro
 
   return (
     <>
-      <div className="flex items-center justify-end gap-2 px-2.5 py-1 border-b border-border/60 bg-muted/20">
+      <div className="flex items-center gap-2 px-2.5 py-1 border-b border-border/60 bg-muted/20">
+        {headerLeft}
+        <div className="flex-1" />
         <Button variant="ghost" size="sm" className="h-7 text-[11px]" onClick={() => gridRef.current?.api?.setFilterModel(null)}
           title={t('clg2.clearFiltersTitle')}>
           <FilterX className="size-3.5" /> {t('clg2.clearFilters')}

frontend/src/components/IcomPanel.tsx

@@ -292,6 +292,9 @@ function ScopePanadapter() {
   const wfRef = useRef<HTMLCanvasElement>(null); // waterfall
   const peakRef = useRef(160); // running amplitude ceiling for auto-scale
   const holdRef = useRef<number[]>([]); // per-bin peak-hold line
+  // Some radios control their scope over CI-V but never stream it (IC-7851).
+  // Saying so beats a black rectangle, which reads as a bug in OpsLog.
+  const [unsupported, setUnsupported] = useState(false);
   const spanRef = useRef({ low: 0, high: 0 }); // latest sweep edges, for click-to-tune
   const vfoRef = useRef(0);    // latest VFO frequency, for wheel-tune
   const centerRef = useRef(0); // scope centre we last set (for pan ◀/▶)
@@ -333,6 +336,7 @@ function ScopePanadapter() {
       if (!alive) return;
       try {
         const sw = await IcomScopeData();
+        if (sw?.unsupported) setUnsupported(true);
         if (sw && sw.seq !== lastSeq && sw.amp && sw.amp.length) {
           lastSeq = sw.seq;
           setFixed(sw.fixed);
@@ -543,7 +547,10 @@ function ScopePanadapter() {
           <Chip label={on ? 'ON' : 'OFF'} on={on} onClick={toggle} />
         </div>
       </div>
-      {on && (
+      {on && unsupported && (
+        <div className="px-3 py-2 text-xs text-muted-foreground">{t('icmp.scopeNoStream')}</div>
+      )}
+      {on && !unsupported && (
         <div className="p-3">
           <div className="rounded-xl overflow-hidden ring-1 ring-info/20 shadow-lg shadow-sky-500/5 bg-[#05070e]">
             <canvas ref={canvasRef} onDoubleClick={onDblClick}

frontend/src/components/MainMap.tsx

@@ -4,6 +4,7 @@ import 'leaflet/dist/leaflet.css';
 import { nightPolygon } from '../lib/greyline';
 import { gridToLatLon, gridSquareBounds, greatCirclePoints, pathBetween, destinationPoint } from '@/lib/maidenhead';
 import { writeUiPref } from '@/lib/uiPref';
+import { formatDistance } from '@/lib/units';
 
 // Persisted free-pan view of the world map (when auto-zoom is off).
 function loadMapView(): { lat: number; lon: number; zoom: number } | null {
@@ -446,8 +447,8 @@ export function WorldMap({ fromGrid, toGrid, fromLabel, toLabel, beamAzimuths, b
       </button>
       {path && (
         <div className="absolute bottom-1 left-1 z-[500] rounded-md bg-card/90 backdrop-blur px-2 py-1 text-[11px] font-mono shadow border border-border pointer-events-none">
-          <div><span className="text-muted-foreground">Dist</span> {Math.round(path.distanceShort).toLocaleString()} km
-            <span className="text-muted-foreground"> · LP</span> {Math.round(path.distanceLong).toLocaleString()} km</div>
+          <div><span className="text-muted-foreground">Dist</span> {formatDistance(path.distanceShort)}
+            <span className="text-muted-foreground"> · LP</span> {formatDistance(path.distanceLong)}</div>
           <div><span className="text-muted-foreground">Az SP</span> {Math.round(path.bearingShort)}°
             <span className="text-muted-foreground"> · LP</span> {Math.round(path.bearingLong)}°</div>
         </div>

frontend/src/components/QSLManagerModal.tsx

@@ -8,7 +8,7 @@ import {
   Select, SelectTrigger, SelectValue, SelectContent, SelectItem,
 } from '@/components/ui/select';
 import { cn } from '@/lib/utils';
-import { FindQSOsForUpload, UploadQSOsManual, DownloadConfirmations, CancelConfirmations, ImportHamlogConfirmations, ExportHamlogUnmatched, OpenADIFFile, SaveADIFFile, SyncPOTAHunterLog, ListQSO, BulkUpdateQSL, UploadCallsign, GetSlotStats } from '../../wailsjs/go/main/App';
+import { GetLoTWQSLDetail, SetLoTWQSLDetail, GetLoTWDownloadAllCalls, SetLoTWDownloadAllCalls, OpenExternalURL, FindQSOsForUpload, UploadQSOsManual, DownloadConfirmations, CancelConfirmations, ImportHamlogConfirmations, ExportHamlogUnmatched, OpenADIFFile, SaveADIFFile, SyncPOTAHunterLog, ListQSO, BulkUpdateQSL, UploadCallsign, GetSlotStats } from '../../wailsjs/go/main/App';
 import { Input } from '@/components/ui/input';
 import { RecentQSOsGrid } from '@/components/RecentQSOsGrid';
 import { EventsOn } from '../../wailsjs/runtime/runtime';
@@ -31,7 +31,7 @@ const UPLOAD_COLS: ColDef<UploadRow>[] = [
 ];
 
 type Confirmation = {
-  callsign: string; qso_date: string; band: string; mode: string; country: string;
+  callsign: string; station?: string; qso_date: string; band: string; mode: string; country: string;
   new_dxcc: boolean; new_band: boolean; new_mode: boolean; new_slot: boolean;
 };
 
@@ -255,6 +255,15 @@ export function QSLManagerPanel({ onEditQSO, actions, paperRequest }: {
   const [searching, setSearching] = useState(false);
   const [error, setError] = useState('');
   const [addNotFound, setAddNotFound] = useState(false);
+  // LoTW only: pull the whole account rather than this profile's callsign.
+  const [lotwAllCalls, setLotwAllCalls] = useState(false);
+  // LoTW only: ask for the QSL dates and station details. Ten times slower to
+  // build, so it is a choice rather than the default it used to be.
+  const [lotwDetail, setLotwDetail] = useState(false);
+  useEffect(() => {
+    GetLoTWDownloadAllCalls().then((v: boolean) => setLotwAllCalls(!!v)).catch(() => {});
+    GetLoTWQSLDetail().then((v: boolean) => setLotwDetail(!!v)).catch(() => {});
+  }, []);
   // Download date window: 'last' = incremental since last pull, 'date' = from a
   // chosen date, 'all' = everything.
   const [sinceMode, setSinceMode] = useState<'last' | 'date' | 'all'>('last');
@@ -434,6 +443,18 @@ export function QSLManagerPanel({ onEditQSO, actions, paperRequest }: {
               {paperBusy ? <Loader2 className="size-3.5 animate-spin" /> : <Search className="size-3.5" />}
               {t('qslm.search')}
             </Button>
+            {/* The station's QRZ page, one click away: writing a card means
+                reading the address, the manager and whether they even want
+                paper, and all three are on that page. */}
+            <Button size="sm" variant="outline" className="h-8" disabled={!paperCall.trim()}
+              title={t('qslm.qrzTitle')}
+              onClick={() => {
+                const c = paperCall.trim().toUpperCase();
+                if (c) OpenExternalURL(`https://www.qrz.com/db/${c}`).catch(() => {});
+              }}>
+              <ExternalLink className="size-3.5" />
+              QRZ
+            </Button>
             <span className="text-[11px] text-muted-foreground self-center">{t('qslm.paperHint')}</span>
           </>
         ) : (
@@ -598,6 +619,10 @@ export function QSLManagerPanel({ onEditQSO, actions, paperRequest }: {
               <thead className="sticky top-0 bg-card">
                 <tr className="text-left text-muted-foreground border-b border-border">
                   <th className="py-1.5 px-2">{t('qslm.thDateUtc')}</th><th className="py-1.5 px-2">{t('qslm.thCallsign')}</th>
+                  {/* Which of the operator's callsigns the contact was made
+                      under. Only worth a column when the list can hold more than
+                      one — see "All my callsigns" on the download. */}
+                  {shownConfs.some((c) => c.station) && <th className="py-1.5 px-2">{t('qslm.thStation')}</th>}
                   <th className="py-1.5 px-2">{t('qslm.thBand')}</th><th className="py-1.5 px-2">{t('qslm.thMode')}</th>
                   <th className="py-1.5 px-2">{t('qslm.thCountry')}</th><th className="py-1.5 px-2">{t('qslm.thNew')}</th>
                 </tr>
@@ -607,6 +632,9 @@ export function QSLManagerPanel({ onEditQSO, actions, paperRequest }: {
                   <tr key={i} className="border-b border-border/40">
                     <td className="py-1 px-2 font-mono">{fmtDate(c.qso_date)}</td>
                     <td className="py-1 px-2 font-mono font-bold">{c.callsign}</td>
+                    {shownConfs.some((x) => x.station) && (
+                      <td className="py-1 px-2 font-mono text-muted-foreground">{c.station ?? ''}</td>
+                    )}
                     <td className="py-1 px-2">{c.band}</td>
                     <td className="py-1 px-2">{c.mode}</td>
                     <td className="py-1 px-2 text-muted-foreground">{c.country}</td>
@@ -736,6 +764,19 @@ export function QSLManagerPanel({ onEditQSO, actions, paperRequest }: {
             <Checkbox checked={addNotFound} onCheckedChange={(c) => setAddNotFound(!!c)} />
             {t('qslm.addNotFound')}
           </label>
+          {service === 'lotw' && (
+            <label className="flex items-center gap-1.5 text-[11px] text-muted-foreground cursor-pointer" title={t('qslm.lotwDetailTitle')}>
+              <Checkbox checked={lotwDetail || addNotFound} disabled={addNotFound}
+                onCheckedChange={(c) => { setLotwDetail(!!c); SetLoTWQSLDetail(!!c); }} />
+              {t('qslm.lotwDetail')}
+            </label>
+          )}
+          {service === 'lotw' && (
+            <label className="flex items-center gap-1.5 text-[11px] text-muted-foreground cursor-pointer" title={t('qslm.lotwAllCallsTitle')}>
+              <Checkbox checked={lotwAllCalls} onCheckedChange={(c) => { setLotwAllCalls(!!c); SetLoTWDownloadAllCalls(!!c); }} />
+              {t('qslm.lotwAllCalls')}
+            </label>
+          )}
           </>)}
         </div>
         <Button size="sm" onClick={upload} disabled={selectedCount === 0 || busy}>

frontend/src/components/RecentQSOsGrid.tsx

@@ -9,6 +9,7 @@ import { formatDateTimeUTC, formatDateOnly, getDateFormat, subscribeDateFormat }
 import { AgGridReact } from 'ag-grid-react';
 import { Columns3, FilterX, ListChecks } from 'lucide-react';
 import type { QSOForm } from '@/types';
+import { distanceUnit, distanceValue, subscribeDistanceUnit } from '@/lib/units';
 import { QSOContextMenu, type QSOMenuState } from './QSOContextMenu';
 import {
   Dialog, DialogContent, DialogHeader, DialogTitle, DialogFooter, DialogDescription,
@@ -177,8 +178,9 @@ export const makeColCatalog = (t: TFn, myGrid?: string): ColEntry[] => [
   { group: 'Contacted', label: t('rqg.c.lon'),      colId: 'lon',      headerName: t('rqg.c.lon'),      field: 'lon' as any,      width: 90, type: 'rightAligned', cellClass: 'font-mono' },
   // Derived, not stored: computed from the two locations at display time, like
   // the cluster grid's own distance column.
-  { group: 'Contacted', label: t('rqg.c.distance_km'), colId: 'distance_km', headerName: t('rqg.h.distance_km'), width: 90, type: 'rightAligned', cellClass: 'font-mono',
-    valueGetter: (p) => qsoDistanceKm(p.data, myGrid),
+  { group: 'Contacted', label: t('rqg.c.distance_km'), colId: 'distance_km',
+    headerName: t('rqg.h.distance_km') + ' (' + distanceUnit() + ')', width: 95, type: 'rightAligned', cellClass: 'font-mono',
+    valueGetter: (p) => { const km = qsoDistanceKm(p.data, myGrid); return km ? distanceValue(km) : km; },
     comparator: (a, b) => (a ?? 0) - (b ?? 0), defaultVisible: true },
   { group: 'Contacted', label: t('rqg.c.email'),    colId: 'email',    headerName: t('rqg.c.email'),    field: 'email' as any,    width: 180 },
   { group: 'Contacted', label: t('rqg.c.web'),      colId: 'web',      headerName: t('rqg.c.web'),      field: 'web' as any,      width: 180 },
@@ -335,7 +337,9 @@ export function RecentQSOsGrid({ rows, myGrid, selectAllSignal, selectRowSignal,
   // inside the column definitions, so nothing else would notice.
   const [dateFmt, setDateFmt] = useState(getDateFormat);
   useEffect(() => subscribeDateFormat(() => setDateFmt(getDateFormat())), []);
-  const COL_CATALOG = useMemo(() => makeColCatalog(t, myGrid), [t, myGrid, dateFmt]);
+  const [distUnit, setDistUnit] = useState(distanceUnit);
+  useEffect(() => subscribeDistanceUnit(() => setDistUnit(distanceUnit())), []);
+  const COL_CATALOG = useMemo(() => makeColCatalog(t, myGrid), [t, myGrid, dateFmt, distUnit]);
 
   // Right-click: if the clicked row isn't already part of the selection,
   // select just it; then open the bulk-action menu on the whole selection.

frontend/src/components/SettingsModal.tsx

@@ -80,6 +80,7 @@ import {
 } from '@/components/ui/select';
 import { cn } from '@/lib/utils';
 import { writeUiPref } from '@/lib/uiPref';
+import { setUseMiles } from '@/lib/units';
 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';
@@ -1747,6 +1748,7 @@ function SettingsModalImpl({ onClose, onSaved, initialSection, onMainPaneChanged
   const [startEqEnd, setStartEqEnd] = useState(() => localStorage.getItem('opslog.startEqualsEnd') === '1');
   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 [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.
@@ -3266,7 +3268,19 @@ function SettingsModalImpl({ onClose, onSaved, initialSection, onMainPaneChanged
                 <Trash2 className="size-3.5" />
               </Button>
             </div>
+            {/* MY_RIG follows the radio, not the profile.
+                Operating conditions describe a PLAN — "on 20 m I use the beam
+                and the 7300" — while this is the fact of which rig is keying.
+                Empty leaves the old chain alone. */}
+            <div className="flex items-center gap-2">
+              <Label className="shrink-0 w-24">{t('cat.radioMyRig')}</Label>
+              <Input className="h-9 flex-1" placeholder={t('cat.radioMyRigPh')}
+                value={(radios.find((r: any) => r.id === activeRadio)?.my_rig) ?? ''}
+                onChange={(e) => setRadios((l) => l.map((r: any) => r.id === activeRadio ? { ...r, my_rig: e.target.value } : r))}
+                onBlur={() => { SaveRadios(radios as any).catch(() => {}); }} />
+            </div>
             <p className="text-[11px] text-muted-foreground">{t('cat.radioHint')}</p>
+            <p className="text-[11px] text-muted-foreground">{t('cat.radioMyRigHint')}</p>
           </div>
 
           <label className="flex items-center gap-2 text-sm cursor-pointer">
@@ -4853,7 +4867,7 @@ function SettingsModalImpl({ onClose, onSaved, initialSection, onMainPaneChanged
                   <SelectItem value="yaesu">{t('wk.engYaesu')}</SelectItem>
                   <SelectItem value="kenwood">{t('wk.engKenwood')}</SelectItem>
                   <SelectItem value="flex">{t('wk.engFlex')}</SelectItem>
-                  <SelectItem value="tci" disabled>{t('wk.engTci')}</SelectItem>
+                  <SelectItem value="tci">{t('wk.engTci')}</SelectItem>
                 </SelectContent>
               </Select>
             </div>
@@ -4914,6 +4928,22 @@ function SettingsModalImpl({ onClose, onSaved, initialSection, onMainPaneChanged
                 </div>
               </div>
             </>
+          ) : wk.engine === 'tci' ? (
+            <>
+              {(!catCfg.enabled || catCfg.backend !== 'tci') && (
+                <p className="text-xs font-medium text-warning -mt-1 flex items-start gap-1.5">
+                  <span aria-hidden>⚠</span>
+                  <span>{t('wk.catWarnTci', { backend: catCfg.enabled ? (catCfg.backend || 'none') : 'disabled' })}</span>
+                </p>
+              )}
+              <p className="text-xs text-muted-foreground -mt-1">{t('wk.tciHint')}</p>
+              <div className="grid grid-cols-4 gap-3">
+                <div className="space-y-1">
+                  <Label>{t('wk.speed')}</Label>
+                  <Input type="number" min={5} max={60} value={wk.wpm} onChange={(e) => setWkField({ wpm: num(e.target.value, 25) })} className="font-mono" />
+                </div>
+              </div>
+            </>
           ) : wk.engine === 'flex' ? (
             <>
               {(!catCfg.enabled || catCfg.backend !== 'flex') && (
@@ -7209,6 +7239,13 @@ function SettingsModalImpl({ onClose, onSaved, initialSection, onMainPaneChanged
             <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>
           </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>
+          </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>

frontend/src/components/WinkeyerPanel.tsx

@@ -26,7 +26,7 @@ interface Props {
   wpm: number;
   macros: WKMacro[];
   sent: string; // text echoed back by the keyer as it transmits
-  source: 'winkeyer' | 'icom' | 'flex' | 'yaesu' | 'kenwood'; // CW output engine (chosen in Settings → CW Keyer)
+  source: 'winkeyer' | 'icom' | 'flex' | 'yaesu' | 'kenwood' | 'tci'; // CW output engine (chosen in Settings → CW Keyer)
   breakIn?: number;                          // Icom CW break-in: 0=OFF, 1=SEMI, 2=FULL
   onSetBreakIn?: (mode: number) => void;
   onSelectPort: (p: string) => void;
@@ -109,16 +109,16 @@ export function WinkeyerPanel({
         <Radio className="size-4 text-primary shrink-0" />
         {/* CW output engine (chosen in Settings → CW Keyer). */}
         <span className="text-xs font-semibold uppercase tracking-wider text-muted-foreground shrink-0">
-          {source === 'icom' ? 'Icom CW' : source === 'flex' ? 'Flex CWX' : source === 'yaesu' ? 'Yaesu CW' : source === 'kenwood' ? 'Kenwood CW' : 'WinKeyer'}
+          {source === 'icom' ? 'Icom CW' : source === 'flex' ? 'Flex CWX' : source === 'yaesu' ? 'Yaesu CW' : source === 'kenwood' ? 'Kenwood CW' : source === 'tci' ? 'TCI CW' : 'WinKeyer'}
         </span>
         <span className={cn('size-2 rounded-full', connected ? (status.busy ? 'bg-warning animate-pulse' : 'bg-success') : 'bg-muted-foreground/40')}
           title={connected ? (status.busy ? t('wkp.sending') : t('wkp.connectedV', { version: status.version })) : t('wkp.disconnected')} />
         <div className="flex-1" />
-        {source === 'icom' || source === 'flex' || source === 'yaesu' || source === 'kenwood' ? (
+        {source === 'icom' || source === 'flex' || source === 'yaesu' || source === 'kenwood' || source === 'tci' ? (
           <span className="text-[11px] font-medium text-muted-foreground">
             {source === 'flex'
               ? (connected ? t('wkp.cwxReady') : t('wkp.cwxOffline'))
-              : source === 'yaesu' || source === 'kenwood'
+              : source === 'yaesu' || source === 'kenwood' || source === 'tci'
                 ? (connected ? t('wkp.rigReady') : t('wkp.rigOffline'))
                 : (connected ? t('wkp.civReady') : t('wkp.civOffline'))}
           </span>

frontend/src/components/labels/LabelDesignerModal.tsx

@@ -0,0 +1,555 @@
+// 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

@@ -0,0 +1,502 @@
+// 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

@@ -0,0 +1,190 @@
+// 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

@@ -0,0 +1,118 @@
+// 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/matrixColors.ts

@@ -14,9 +14,11 @@ export type MatrixColors = {
   entity_worked: string;
   not_worked: string;
   current_entry: string;
+  mark_worked: string;
+  mark_confirmed: string;
 };
 
-// The six settings fields and the CSS custom property each one drives. Also the
+// The settings fields and the CSS custom property each one drives. Also the
 // display order — the same order the legend under the matrix reads in, so the
 // settings panel and the grid can never disagree about which green is which.
 export const MATRIX_VARS: { key: keyof Omit<MatrixColors, 'enabled'>; cssVar: string; label: string }[] = [
@@ -26,12 +28,15 @@ export const MATRIX_VARS: { key: keyof Omit<MatrixColors, 'enabled'>; cssVar: st
   { key: 'entity_worked',    cssVar: '--mx-dx-work',   label: 'mx.dxWork' },
   { key: 'not_worked',       cssVar: '--mx-none',      label: 'mx.none' },
   { key: 'current_entry',    cssVar: '--mx-cur',       label: 'mx.current' },
+  { key: 'mark_worked',      cssVar: '--mx-mark-work', label: 'mx.markWork' },
+  { key: 'mark_confirmed',   cssVar: '--mx-mark-conf', label: 'mx.markConf' },
 ];
 
 export const emptyMatrixColors = (): MatrixColors => ({
   enabled: false,
   call_confirmed: '', call_worked: '', entity_confirmed: '',
   entity_worked: '', not_worked: '', current_entry: '',
+  mark_worked: '', mark_confirmed: '',
 });
 
 // applyMatrixColors stamps (or clears) the overrides on <html>. Safe to call as

frontend/src/lib/uiPref.ts

@@ -40,6 +40,7 @@ const PORTABLE_KEYS = [
   'opslog.clusterFilterSource', 'opslog.clusterGroup', 'opslog.clusterBands',
   'opslog.clusterLockBand', 'opslog.clusterLockMode', 'opslog.clusterStatusFilter',
   'opslog.clusterModeFilter', 'opslog.clusterSearch', 'opslog.clusterHideWorked',
+  'opslog.distanceMiles', // distances shown in statute miles rather than km
   '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/lib/units.ts

@@ -0,0 +1,49 @@
+// Distance units.
+//
+// Everything is COMPUTED in kilometres — the great-circle maths, the backend's
+// distance_km on a spot, the map's path lengths — and converted once, here, at
+// display time. Storing miles anywhere would mean two sources of truth for the
+// same number and a rounding error that grows with every hop.
+//
+// The preference is portable (see lib/uiPref): an operator who works in miles
+// works in miles on every machine they copy their folder to.
+import { writeUiPref } from '@/lib/uiPref';
+
+export const KEY_MILES = 'opslog.distanceMiles';
+const KM_PER_MILE = 1.609344; // statute miles, the ones a US licence is used in
+
+export function useMiles(): boolean {
+  try { return localStorage.getItem(KEY_MILES) === '1'; } catch { return false; }
+}
+
+export function setUseMiles(on: boolean): void {
+  writeUiPref(KEY_MILES, on ? '1' : '0');
+  listeners.forEach((l) => l());
+}
+
+// subscribeDistanceUnit notifies on a change. The grids capture the unit inside
+// their column definitions (header text and formatter both), so without this a
+// toggle would only show up on the next language change or restart.
+const listeners = new Set<() => void>();
+export function subscribeDistanceUnit(fn: () => void): () => void {
+  listeners.add(fn);
+  return () => { listeners.delete(fn); };
+}
+
+// distanceValue converts a distance in km to the operator's unit, rounded to a
+// whole unit — the precision the inputs actually justify (a 4-character grid is
+// a square tens of kilometres wide).
+export function distanceValue(km: number): number {
+  if (!isFinite(km)) return 0;
+  return Math.round(useMiles() ? km / KM_PER_MILE : km);
+}
+
+// distanceUnit is the short label: "km" or "mi".
+export function distanceUnit(): string {
+  return useMiles() ? 'mi' : 'km';
+}
+
+// formatDistance is value + unit, thousands-separated: "12 345 km".
+export function formatDistance(km: number): string {
+  return `${distanceValue(km).toLocaleString()} ${distanceUnit()}`;
+}

frontend/src/style.css

@@ -91,6 +91,11 @@
      be recoloured on its own without dragging every other warning in the app
      with it (Appearance → matrix colours). */
   --mx-cur: var(--warning);
+  /* The "worked with this callsign" dot. Declared ONCE, like --mx-cur: it is
+     drawn over every one of the five cell colours, so it follows the theme's own
+     foreground/background pair rather than a per-theme colour of its own. */
+  --mx-mark-work: var(--foreground);
+  --mx-mark-conf: var(--foreground);
 
   --scrollbar-thumb: #b8a880;
   --scrollbar-thumb-hover: #968455;
@@ -981,6 +986,8 @@
   --color-mx-dx-work: var(--mx-dx-work);
   --color-mx-none: var(--mx-none);
   --color-mx-cur: var(--mx-cur);
+  --color-mx-mark-work: var(--mx-mark-work);
+  --color-mx-mark-conf: var(--mx-mark-conf);
 
   --radius: 0.5rem;
 

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.19';
+export const APP_VERSION = '0.26.22';
 
 // Author / credits, shown in Help -> About.
 export const APP_AUTHOR = 'F4BPO';

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

@@ -21,6 +21,7 @@ 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';
@@ -503,6 +504,10 @@ export function GetLiveOpenings():Promise<Array<bandopen.Opening>>;
 
 export function GetLiveStations():Promise<Array<main.LiveStation>>;
 
+export function GetLoTWDownloadAllCalls():Promise<boolean>;
+
+export function GetLoTWQSLDetail():Promise<boolean>;
+
 export function GetLoTWUsersStatus():Promise<main.LoTWUsersStatus>;
 
 export function GetLogFilePath():Promise<string>;
@@ -721,6 +726,28 @@ 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>>;
@@ -1157,6 +1184,10 @@ export function SetKenwoodXIT(arg1:boolean):Promise<void>;
 
 export function SetLinkedAmps(arg1:Array<string>):Promise<void>;
 
+export function SetLoTWDownloadAllCalls(arg1:boolean):Promise<void>;
+
+export function SetLoTWQSLDetail(arg1:boolean):Promise<void>;
+
 export function SetMotorFollow(arg1:boolean,arg2:number,arg3:string):Promise<void>;
 
 export function SetOpsLogQSLReceived(arg1:number,arg2:boolean):Promise<void>;
@@ -1271,6 +1302,12 @@ export function SyncFolderNow():Promise<number>;
 
 export function SyncPOTAHunterLog(arg1:boolean,arg2:boolean):Promise<main.POTASyncResult>;
 
+export function TCISendCW(arg1:string):Promise<void>;
+
+export function TCISetKeySpeed(arg1:number):Promise<void>;
+
+export function TCIStopCW():Promise<void>;
+
 export function TailLogFile(arg1:number):Promise<string>;
 
 export function TestCloudlogUpload():Promise<string>;

frontend/wailsjs/go/main/App.js

@@ -946,6 +946,14 @@ export function GetLiveStations() {
   return window['go']['main']['App']['GetLiveStations']();
 }
 
+export function GetLoTWDownloadAllCalls() {
+  return window['go']['main']['App']['GetLoTWDownloadAllCalls']();
+}
+
+export function GetLoTWQSLDetail() {
+  return window['go']['main']['App']['GetLoTWQSLDetail']();
+}
+
 export function GetLoTWUsersStatus() {
   return window['go']['main']['App']['GetLoTWUsersStatus']();
 }
@@ -1382,6 +1390,50 @@ 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);
 }
@@ -2254,6 +2306,14 @@ export function SetLinkedAmps(arg1) {
   return window['go']['main']['App']['SetLinkedAmps'](arg1);
 }
 
+export function SetLoTWDownloadAllCalls(arg1) {
+  return window['go']['main']['App']['SetLoTWDownloadAllCalls'](arg1);
+}
+
+export function SetLoTWQSLDetail(arg1) {
+  return window['go']['main']['App']['SetLoTWQSLDetail'](arg1);
+}
+
 export function SetMotorFollow(arg1, arg2, arg3) {
   return window['go']['main']['App']['SetMotorFollow'](arg1, arg2, arg3);
 }
@@ -2482,6 +2542,18 @@ export function SyncPOTAHunterLog(arg1, arg2) {
   return window['go']['main']['App']['SyncPOTAHunterLog'](arg1, arg2);
 }
 
+export function TCISendCW(arg1) {
+  return window['go']['main']['App']['TCISendCW'](arg1);
+}
+
+export function TCISetKeySpeed(arg1) {
+  return window['go']['main']['App']['TCISetKeySpeed'](arg1);
+}
+
+export function TCIStopCW() {
+  return window['go']['main']['App']['TCIStopCW']();
+}
+
 export function TailLogFile(arg1) {
   return window['go']['main']['App']['TailLogFile'](arg1);
 }

frontend/wailsjs/go/models.ts

@@ -1196,6 +1196,7 @@ export namespace cat {
 	    low_hz: number;
 	    high_hz: number;
 	    fixed: boolean;
+	    unsupported: boolean;
 	
 	    static createFrom(source: any = {}) {
 	        return new ScopeSweep(source);
@@ -1208,6 +1209,7 @@ export namespace cat {
 	        this.low_hz = source["low_hz"];
 	        this.high_hz = source["high_hz"];
 	        this.fixed = source["fixed"];
+	        this.unsupported = source["unsupported"];
 	    }
 	}
 	export class TCIPanelState {
@@ -1615,6 +1617,39 @@ 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 {
@@ -2934,6 +2969,78 @@ 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;
@@ -3066,6 +3173,8 @@ export namespace main {
 	    entity_worked: string;
 	    not_worked: string;
 	    current_entry: string;
+	    mark_worked: string;
+	    mark_confirmed: string;
 	
 	    static createFrom(source: any = {}) {
 	        return new MatrixColors(source);
@@ -3080,6 +3189,8 @@ export namespace main {
 	        this.entity_worked = source["entity_worked"];
 	        this.not_worked = source["not_worked"];
 	        this.current_entry = source["current_entry"];
+	        this.mark_worked = source["mark_worked"];
+	        this.mark_confirmed = source["mark_confirmed"];
 	    }
 	}
 	
@@ -3573,6 +3684,7 @@ export namespace main {
 	    id: string;
 	    name: string;
 	    settings: CATSettings;
+	    my_rig: string;
 	
 	    static createFrom(source: any = {}) {
 	        return new RadioConfig(source);
@@ -3583,6 +3695,7 @@ export namespace main {
 	        this.id = source["id"];
 	        this.name = source["name"];
 	        this.settings = this.convertValues(source["settings"], CATSettings);
+	        this.my_rig = source["my_rig"];
 	    }
 	
 		convertValues(a: any, classs: any, asMap: boolean = false): any {
@@ -5025,6 +5138,7 @@ export namespace qso {
 	    band: string;
 	    class: string;
 	    status: string;
+	    call?: string;
 	
 	    static createFrom(source: any = {}) {
 	        return new BandStatus(source);
@@ -5035,6 +5149,7 @@ export namespace qso {
 	        this.band = source["band"];
 	        this.class = source["class"];
 	        this.status = source["status"];
+	        this.call = source["call"];
 	    }
 	}
 	export class Bucket {
@@ -5128,6 +5243,7 @@ export namespace qso {
 	    band?: string;
 	    mode?: string;
 	    station_callsign?: string;
+	    qsl_sent_in?: string[];
 	    limit?: number;
 	    offset?: number;
 	
@@ -5141,6 +5257,7 @@ 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"];
 	    }

internal/cat/cat.go

@@ -674,6 +674,12 @@ type ScopeSweep struct {
 	LowHz  int64 `json:"low_hz"`  // left edge frequency (0 when unknown)
 	HighHz int64 `json:"high_hz"` // right edge frequency (0 when unknown)
 	Fixed  bool  `json:"fixed"`   // true = fixed-span mode, false = center-on-VFO
+	// Unsupported: this radio refuses the waveform-output command, so there will
+	// never be a sweep. The IC-7851 does — its last firmware is from 2016, older
+	// than the CI-V waveform stream — while still answering the scope's other
+	// commands. Reported so the panadapter can say so instead of showing a black
+	// rectangle that looks like a bug in OpsLog.
+	Unsupported bool `json:"unsupported"`
 }
 
 // IcomState returns the current Icom DSP state, or (zero, false) when the active

internal/cat/icomserial.go

@@ -93,15 +93,18 @@ type IcomSerial struct {
 	// leading main/sub selector byte (IC-7610/9700). scopeAmp is the latest
 	// reassembled sweep; scopeMu guards it (written by the scope goroutine, read
 	// via ScopeData from the binding goroutine).
-	dualScope  bool
-	scopeMu    sync.Mutex
-	scopeAmp   []byte
-	scopeLow   int64 // spectrum left-edge frequency (from the sweep's header frame)
-	scopeHigh  int64 // spectrum right-edge frequency
-	scopeSeq   int
-	scopeOn    bool
-	scopeFixed bool // true = fixed-span mode (tracked optimistically)
-	scopeSeen  bool // logged the first sweep's structure once (on-rig verification)
+	dualScope bool
+	// Set when the rig rejects the waveform-output command in both shapes: it has
+	// no stream to give, and asking again on every enable is noise.
+	scopeUnsupported bool
+	scopeMu          sync.Mutex
+	scopeAmp         []byte
+	scopeLow         int64 // spectrum left-edge frequency (from the sweep's header frame)
+	scopeHigh        int64 // spectrum right-edge frequency
+	scopeSeq         int
+	scopeOn          bool
+	scopeFixed       bool // true = fixed-span mode (tracked optimistically)
+	scopeSeen        bool // logged the first sweep's structure once (on-rig verification)
 
 	curFreq     int64     // last frequency read (for sideband choice)
 	curModeByte byte      // last raw Icom mode byte (for filter re-send)
@@ -848,6 +851,19 @@ func (b *IcomSerial) scopeLoop(spec chan civ.Decoded, done chan struct{}) {
 					loggedCfg[f.Data[0]] = true
 					applog.Printf("icom scope cfg 0x%02X: data=[% X]", f.Data[0], f.Data)
 				}
+				// The rig just told us its own layout: a mode/span/edge answer of
+				// three bytes or more carries the main/sub selector, one of two
+				// bytes does not. Worth reading, because the SET commands take the
+				// same shape and several firmwares answer a wrong-shaped set with
+				// silence rather than a rejection — which is not something the
+				// retry in execScope can act on.
+				if f.Data[0] == civ.SubScopeMode && len(f.Data) >= 2 {
+					if sel := len(f.Data) >= 3; sel != b.dualScope {
+						applog.Printf("icom scope: the rig answers 0x%02X with %d bytes — using the %s form",
+							f.Data[0], len(f.Data)-1, map[bool]string{true: "27 xx 00 …", false: "27 xx …"}[sel])
+						b.dualScope = sel
+					}
+				}
 				continue
 			}
 			if rawN < 24 {
@@ -982,6 +998,43 @@ func (b *IcomSerial) assembleSweep(regions map[byte][]byte, total byte) {
 	}
 }
 
+// execScope sends a 0x27 SET and, if the rig rejects it, sends it once more in
+// the other shape — with or without the leading main/sub selector byte — and
+// remembers which one this rig speaks.
+//
+// The shape used to be decided from the CI-V address, which meant every new
+// model was a blank scope until someone reported it: the IC-7851 (0x8E) rejects
+// "27 11 01" outright and wants "27 11 00 01", exactly as the IC-7610 does not.
+// A rejection is a cheap and unambiguous answer, so ask the rig instead of
+// keeping a list. Only the SET commands need this — the waveform parser already
+// detects the selector per frame.
+func (b *IcomSerial) execScope(what string, sub byte, args ...byte) error {
+	try := func(sel bool) error {
+		p := []byte{civ.CmdScope, sub}
+		if sel {
+			p = append(p, 0x00) // main scope
+		}
+		return b.exec(append(p, args...)...)
+	}
+	err := try(b.dualScope)
+	// Only a REJECTION means "wrong shape". A timeout says nothing (several
+	// firmwares simply don't ack a 0x27 set), and retrying it in the other shape
+	// would flip a working rig onto the wrong one.
+	if err == nil || !strings.Contains(err.Error(), "rejected") {
+		return err
+	}
+	err2 := try(!b.dualScope)
+	applog.Printf("icom scope: %s rejected in the %s form — the other form gave: %v",
+		what, map[bool]string{true: "27 xx 00 …", false: "27 xx …"}[b.dualScope], err2)
+	if err2 == nil {
+		b.dualScope = !b.dualScope
+		applog.Printf("icom scope: %s rejected — this rig wants the %s form (selector=%v)",
+			what, map[bool]string{true: "27 xx 00 …", false: "27 xx …"}[b.dualScope], b.dualScope)
+		return nil
+	}
+	return err
+}
+
 // SetScope enables or disables the spectrum scope. Two commands are needed and
 // RS-BA1 sends both: 0x27 0x10 turns the scope DISPLAY on (without it the rig
 // streams nothing — the case when we're remote and can't touch the front panel),
@@ -1000,15 +1053,25 @@ func (b *IcomSerial) SetScope(on bool) error {
 		// radio, and closing OpsLog (SetScope(false)) blanking a local IC-7300's
 		// screen is exactly the regression this avoids. Some firmwares don't ack a
 		// 0x27 set; a timeout isn't fatal, so log and continue.
-		if err := b.exec(civ.CmdScope, civ.SubScopeOnOff, 0x01); err != nil {
+		if err := b.execScope("display on", civ.SubScopeOnOff, 0x01); err != nil {
 			applog.Printf("icom scope: display on ack: %v", err)
 		}
 	}
 	// Waveform data OUTPUT over CI-V: enabled with the scope, and — crucially —
 	// the ONLY thing we switch off on disable, so the radio's own scope display is
 	// left exactly as the operator had it.
-	if err := b.exec(civ.CmdScope, civ.SubScopeOn, boolByte(on)); err != nil {
+	if err := b.execScope("data output", civ.SubScopeOn, boolByte(on)); err != nil {
 		applog.Printf("icom scope: output on=%v ack: %v", on, err)
+		// Rejected in both shapes = the command does not exist on this rig, which
+		// is a permanent answer and not a bad guess on our part. Remember it: the
+		// panel can then say so, and we stop asking a radio that has already
+		// said no.
+		if strings.Contains(err.Error(), "rejected") {
+			applog.Printf("icom scope: %s does not stream its scope over CI-V — control commands only", b.model)
+			b.scopeMu.Lock()
+			b.scopeUnsupported = true
+			b.scopeMu.Unlock()
+		}
 	}
 	b.scopeMu.Lock()
 	b.scopeOn = on
@@ -1041,13 +1104,7 @@ func (b *IcomSerial) scopeReadCfg() {
 // makes the scope follow the VFO, so tuning pans the view left/right.
 func (b *IcomSerial) SetScopeMode(fixed bool) error {
 	mode := boolByte(fixed) // 0 = center, 1 = fixed (verify on rig via the cfg log)
-	var payload []byte
-	if b.dualScope {
-		payload = []byte{civ.CmdScope, civ.SubScopeMode, 0x00, mode}
-	} else {
-		payload = []byte{civ.CmdScope, civ.SubScopeMode, mode}
-	}
-	if err := b.exec(payload...); err != nil {
+	if err := b.execScope("set mode", civ.SubScopeMode, mode); err != nil {
 		applog.Printf("icom scope: set mode fixed=%v ack: %v", fixed, err)
 	}
 	b.scopeMu.Lock()
@@ -1093,13 +1150,8 @@ func (b *IcomSerial) SetScopeEdges(low, high int64) error {
 	if rangeID == 0 {
 		return fmt.Errorf("icom scope: freq out of range")
 	}
-	if b.dualScope {
-		_ = b.exec(civ.CmdScope, civ.SubScopeMode, 0x00, 0x01) // fixed mode (main)
-		_ = b.exec(civ.CmdScope, civ.SubScopeEdge, 0x00, 0x01) // activate edge set 1
-	} else {
-		_ = b.exec(civ.CmdScope, civ.SubScopeMode, 0x01)
-		_ = b.exec(civ.CmdScope, civ.SubScopeEdge, 0x01)
-	}
+	_ = b.execScope("fixed mode", civ.SubScopeMode, 0x01)
+	_ = b.execScope("edge set 1", civ.SubScopeEdge, 0x01)
 	payload := append([]byte{civ.CmdScope, civ.SubScopeFixEdge, rangeID, 0x01}, civ.FreqToBCD(low)...)
 	payload = append(payload, civ.FreqToBCD(high)...)
 	b.scopeMu.Lock()
@@ -1263,7 +1315,8 @@ func (b *IcomSerial) ScopeData() ScopeSweep {
 	for i, v := range b.scopeAmp {
 		amp[i] = int(v)
 	}
-	return ScopeSweep{Amp: amp, Seq: b.scopeSeq, LowHz: b.scopeLow, HighHz: b.scopeHigh, Fixed: b.scopeFixed}
+	return ScopeSweep{Amp: amp, Seq: b.scopeSeq, LowHz: b.scopeLow, HighHz: b.scopeHigh, Fixed: b.scopeFixed,
+		Unsupported: b.scopeUnsupported}
 }
 
 // exec sends a set command and waits for the rig's OK (FB) / NG (FA) ack.

internal/cat/tci.go

@@ -27,6 +27,14 @@ type TCI struct {
 
 	digitalDefault string // surfaced when the rig reports a digital mode (FT8/…)
 	spotsEnabled   bool   // mirror cluster spots onto the TCI panorama
+	// wantFreq is the frequency last COMMANDED and not yet echoed back, used to
+	// pick the sideband before the radio has confirmed the move.
+	wantFreq int64
+	// What the server said it is, from its "protocol:" announcement.
+	serverName    string
+	serverVersion string
+	// How many spots have been logged verbatim (the first few only).
+	spotsSent int
 
 	// OnSpotClick is called when the user clicks one of our spots on the TCI
 	// panorama (callsign + freq), so the host can fill the entry form. Set before
@@ -149,6 +157,16 @@ func (t *TCI) Connect() error {
 	t.mu.Unlock()
 	debugLog.Printf("TCI: connected to %s", url)
 	go t.reader(conn)
+	// Ask for the meters. Nothing measures anything until this goes out: the
+	// S-meter, the transmit power and the SWR are all pushed by the radio, and
+	// only to a client that has subscribed. 200 ms is the rate the protocol's own
+	// examples use — fast enough for a needle, slow enough not to flood a socket
+	// that also carries audio.
+	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;")
 	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
@@ -228,11 +246,19 @@ func (t *TCI) SendSpot(s SpotInfo) error {
 		// other two matching what already works here.
 		_ = t.send(fmt.Sprintf("spot_delete:%s;", call))
 	}
-	// TCI's SPOT command wants the colour as a signed 32-bit DECIMAL integer in
-	// 0xAARRGGBB order — NOT a "0x…" hex string (e.g. "spot:UN7GK,cw,14025000,
-	// -16776961,test;"). ExpertSDR silently drops a spot whose colour field it
-	// can't parse as a number, which is why spots never showed on the panorama
-	// while tuning (a separate command) still worked.
+	// The colour is a DECIMAL ARGB integer, and an UNSIGNED one.
+	//
+	// Expert Electronics' own protocol document gives the whole command:
+	//
+	//	SPOT:RN6LHF,CW,7100000,16711680,ANY_TEXT;
+	//
+	// 16711680 is 0x00FF0000 — positive, alpha zero. This backend was sending
+	// the same number as a SIGNED 32-bit value, taken from a third-party
+	// example: with the alpha byte set to FF for opacity, 0xFFFFA500 becomes
+	// -22336, and a spot whose colour field ExpertSDR cannot read is dropped in
+	// silence. Reported on ExpertSDR3 1.3 (which speaks TCI 2.x, so the version
+	// was never the problem): everything else worked and the panorama stayed
+	// empty.
 	hex := strings.TrimPrefix(strings.TrimPrefix(strings.TrimSpace(s.Color), "#"), "0x")
 	if hex == "" {
 		hex = "FFFFA500" // opaque orange default
@@ -253,7 +279,15 @@ func (t *TCI) SendSpot(s SpotInfo) error {
 	}
 	// Commas/semicolons would break TCI's comma-separated argument parsing.
 	text := strings.NewReplacer(",", " ", ";", " ").Replace(s.Comment)
-	return t.send(fmt.Sprintf("spot:%s,%s,%d,%d,%s;", call, mode, s.FreqHz, int32(argb), text))
+	cmd := fmt.Sprintf("spot:%s,%s,%d,%d,%s;", call, mode, s.FreqHz, argb, text)
+	// The first few, verbatim. A spot that the radio ignores leaves no trace at
+	// all — no reply, no error — so the only evidence that OpsLog sent one, and
+	// in what shape, is this line.
+	if n := t.spotsSent; n < 3 {
+		t.spotsSent = n + 1
+		debugLog.Printf("TCI: sending spot #%d: %s", n+1, strings.TrimSuffix(cmd, ";"))
+	}
+	return t.send(cmd)
 }
 
 // Disconnect closes the WebSocket; the reader goroutine then exits.
@@ -334,6 +368,11 @@ func (t *TCI) ReadState() (RigState, error) {
 
 // SetFrequency tunes VFO A (the main/RX VFO).
 func (t *TCI) SetFrequency(hz int64) error {
+	// Remember what we ASKED for. SetMode reads it to choose the sideband, and
+	// the radio's own echo can be a moment behind — see SetMode.
+	t.mu.Lock()
+	t.wantFreq = hz
+	t.mu.Unlock()
 	return t.send(fmt.Sprintf("vfo:0,0,%d;", hz))
 }
 
@@ -342,6 +381,17 @@ func (t *TCI) SetFrequency(hz int64) error {
 func (t *TCI) SetMode(mode string) error {
 	t.mu.Lock()
 	freq := t.freqA
+	// Prefer the frequency we just COMMANDED over the one the radio has echoed.
+	//
+	// Clicking a spot sets the frequency and then the mode, and the sideband is
+	// chosen from the frequency (below 10 MHz → LSB). Read from the echo, that
+	// is the frequency we were on BEFORE the click whenever the echo has not
+	// landed yet: a 14 MHz spot clicked from 7 MHz got LSB, and clicking the same
+	// spot again — now that the echo has arrived — got USB. Reported from a
+	// SunSDR as "the frequency is right, the mode is wrong until I click twice".
+	if t.wantFreq > 0 {
+		freq = t.wantFreq
+	}
 	t.mu.Unlock()
 	m := adifToTCIMode(mode, freq)
 	if m == "" {
@@ -493,6 +543,18 @@ func (t *TCI) handle(msg string) {
 	switch lower {
 	case "device":
 		t.device = strings.TrimSpace(args)
+	// The server's own announcement: "protocol:ExpertSDR3,1.9;" — its name and
+	// the TCI version it speaks. Worth keeping rather than filing under
+	// "unhandled": panorama spots need a version that HAS the spot command, and
+	// without this an operator on an older ExpertSDR sees nothing on the
+	// waterfall and nothing anywhere saying why.
+	case "protocol":
+		t.serverName, t.serverVersion = get(0), get(1)
+		debugLog.Printf("TCI: server is %s, TCI %s", t.serverName, t.serverVersion)
+		if t.spotsEnabled && tciSpotsUnsupported(t.serverVersion) {
+			debugLog.Printf("TCI: this server speaks TCI %s — panorama spots need 1.5 or later, so they will not appear",
+				t.serverVersion)
+		}
 	// The radio ANNOUNCES its audio format at connect —
 	// "audio_stream_sample_type:float32" and "audio_stream_channels:2" — which
 	// is better evidence than anything derived from a frame, and it arrives
@@ -516,6 +578,10 @@ func (t *TCI) handle(msg string) {
 				switch get(1) {
 				case "0":
 					t.freqA = hz
+					// The radio has caught up: from here the echo IS the truth.
+					if t.wantFreq != 0 && absInt64(hz-t.wantFreq) < 100 {
+						t.wantFreq = 0
+					}
 				case "1":
 					t.freqB = hz
 				}
@@ -651,3 +717,18 @@ func adifToTCIMode(mode string, freqHz int64) string {
 		return "digu"
 	}
 }
+
+// tciSpotsUnsupported reports whether a TCI version predates the spot commands.
+//
+// SPOT / SPOT_DELETE / SPOT_CLEAR arrived in TCI 1.5. An older ExpertSDR accepts
+// the connection, answers frequency and mode perfectly, and silently ignores
+// every spot — which is indistinguishable from a bug in the logger unless
+// somebody says so. Anything unparseable is treated as supported: refusing to
+// draw on a doubt would be the worse mistake.
+func tciSpotsUnsupported(version string) bool {
+	var maj, min int
+	if n, err := fmt.Sscanf(strings.TrimSpace(version), "%d.%d", &maj, &min); n < 2 || err != nil {
+		return false
+	}
+	return maj < 1 || (maj == 1 && min < 5)
+}

internal/cat/tci_cw.go

@@ -0,0 +1,72 @@
+package cat
+
+import (
+	"fmt"
+	"strings"
+)
+
+// CW keying over TCI — a sixth CW engine, so a SunSDR needs no WinKeyer and no
+// second serial port: the radio's own macro keyer is driven over the WebSocket
+// that already carries the CAT.
+//
+// The commands, from the TCI command table (confirmed against ars-ka0s/eesdr-tci,
+// the same source that settled SPOT):
+//
+//	CW_MACROS:<trx>,<text>;   send text through the radio's keyer
+//	CW_MACROS_SPEED:<wpm>;    the speed those macros are keyed at
+//	CW_MACROS_STOP;           abort what is being keyed
+//	CW_MACROS_EMPTY;          the radio saying the buffer has run dry
+//
+// CW_MSG (TCI 2.0) does the same with separate before/after callsign fields.
+// CW_MACROS is used instead because it exists from 1.6 and OpsLog resolves the
+// variables itself — the text handed here is already what should go on the air.
+//
+// Notably absent: there is no backspace. The FlexRadio CWX keyer can un-type
+// what has not been sent yet; TCI can only stop. So the type-ahead correction
+// the Flex engine offers is not offered here rather than faked.
+
+// tciCWTextLimit caps one macro. A runaway paste down a WebSocket that also
+// carries audio is worth refusing, and no real CW message is this long.
+const tciCWTextLimit = 512
+
+// SendCW keys a message through the radio's macro keyer.
+func (t *TCI) SendCW(text string) error {
+	msg := sanitiseTCICW(text)
+	if msg == "" {
+		return nil
+	}
+	return t.send(fmt.Sprintf("cw_macros:0,%s;", msg))
+}
+
+// StopCW aborts the message being keyed.
+func (t *TCI) StopCW() error { return t.send("cw_macros_stop;") }
+
+// SetCWSpeed sets the macro keyer speed in words per minute.
+//
+// Only the MACRO speed: the paddle keyer has its own (CW_KEYER_SPEED) and an
+// operator who has set their paddle to 28 wpm did not ask the logger to change
+// it because a macro went out at 25.
+func (t *TCI) SetCWSpeed(wpm int) error {
+	if wpm < 5 {
+		wpm = 5
+	}
+	if wpm > 60 {
+		wpm = 60
+	}
+	return t.send(fmt.Sprintf("cw_macros_speed:%d;", wpm))
+}
+
+// sanitiseTCICW makes a message safe to put in a TCI command.
+//
+// Commas and semicolons are the protocol's own separators — a comma inside the
+// text would be read as another argument and a semicolon would end the command
+// early, keying half a message and leaving the rest to be parsed as a command of
+// its own. Neither belongs in Morse anyway.
+func sanitiseTCICW(text string) string {
+	s := strings.ToUpper(strings.TrimSpace(text))
+	s = strings.NewReplacer(",", " ", ";", " ", "\r", " ", "\n", " ").Replace(s)
+	if len(s) > tciCWTextLimit {
+		s = s[:tciCWTextLimit]
+	}
+	return strings.TrimSpace(s)
+}

internal/cat/tci_manager.go

@@ -96,3 +96,26 @@ func (m *Manager) TCIPanelDo(fn func(TCIPanelController) error) error {
 		return fn(tc)
 	})
 }
+
+// TCICWController is the radio's CW keyer, as the CW engine uses it.
+//
+// Three methods, and no backspace: TCI can stop a message but cannot un-type one
+// (see tci_cw.go). Kept as its own interface rather than folded into the console
+// one so a CW engine does not have to depend on forty panel setters to key a
+// message.
+type TCICWController interface {
+	SendCW(text string) error
+	StopCW() error
+	SetCWSpeed(wpm int) error
+}
+
+// TCICWDo dispatches one keyer command onto the CAT goroutine.
+func (m *Manager) TCICWDo(fn func(TCICWController) error) error {
+	return m.exec(func(b Backend) error {
+		tc, ok := b.(TCICWController)
+		if !ok {
+			return fmt.Errorf("the active CAT backend is not a TCI radio")
+		}
+		return fn(tc)
+	})
+}

internal/cat/tci_panel.go

@@ -233,6 +233,42 @@ func (t *TCI) handlePanel(name string, get func(int) string, args string) bool {
 		if n, ok := num(get(1)); ok && forRX0() {
 			p.SMeter = n
 		}
+	// The meters of ExpertSDR3. The S-meter used to be read only from RX_SMETER
+	// and the transmit ones from TX_POWER / TX_SWR — commands this radio simply
+	// never sends, which is why the console's meters sat empty on a SunSDR in
+	// both RX and TX while everything else worked.
+	//
+	// The protocol's own answer (TCI Protocol.pdf, §4.4) is a SUBSCRIPTION:
+	//
+	//	RX_SENSORS:<rx>,<dBm>;                       (deprecated in 2.0)
+	//	RX_CHANNEL_SENSORS:<rx>,<channel>,<dBm>;     (its replacement)
+	//	TX_SENSORS:<trx>,<mic dBm>,<power W>,<peak W>,<SWR>;
+	//
+	// none of which arrives until the client asks with RX_SENSORS_ENABLE and
+	// TX_SENSORS_ENABLE — see Connect.
+	case "rx_sensors":
+		if v, err := strconv.ParseFloat(strings.TrimSpace(get(1)), 64); err == nil && forRX0() {
+			p.SMeter = int(v)
+		}
+	case "rx_channel_sensors":
+		// Main channel (A) of receiver 0: the one the console is showing.
+		if v, err := strconv.ParseFloat(strings.TrimSpace(get(2)), 64); err == nil &&
+			get(0) == "0" && get(1) == "0" {
+			p.SMeter = int(v)
+		}
+	case "tx_sensors":
+		if get(0) != "0" {
+			break
+		}
+		// arg3 is RMS power, arg4 the peak. The peak is what a power meter's
+		// needle does on speech; the RMS is what the operator is asked to keep
+		// under the amplifier's limit — so RMS is the number, as elsewhere.
+		if v, err := strconv.ParseFloat(strings.TrimSpace(get(2)), 64); err == nil {
+			p.TXPowerW = v
+		}
+		if v, err := strconv.ParseFloat(strings.TrimSpace(get(4)), 64); err == nil {
+			p.TXSWR = v
+		}
 	case "tune":
 		if forRX0() {
 			p.Tuning = yes(get(1))

internal/cat/tci_test.go

@@ -0,0 +1,41 @@
+package cat
+
+import "testing"
+
+func TestTCISpotsUnsupported(t *testing.T) {
+	// SPOT arrived in TCI 1.5. The SunSDR2 PRO report that prompted this was an
+	// ExpertSDR announcing 1.3 — spots accepted and silently dropped.
+	for _, c := range []struct {
+		version string
+		old     bool
+	}{
+		{"1.3", true},
+		{"1.4", true},
+		{"1.5", false},
+		{"1.9", false},
+		{"2.0", false},
+		{"", false},      // unparseable → assume it works
+		{"weird", false}, // refusing to draw on a doubt is the worse mistake
+	} {
+		if got := tciSpotsUnsupported(c.version); got != c.old {
+			t.Errorf("tciSpotsUnsupported(%q) = %v, want %v", c.version, got, c.old)
+		}
+	}
+}
+
+func TestSanitiseTCICW(t *testing.T) {
+	// The separators must never survive: a comma would become another argument
+	// and a semicolon would end the command with the message half sent.
+	for _, c := range []struct{ in, want string }{
+		{"cq cq de f4bpo", "CQ CQ DE F4BPO"},
+		{" tu 599 ", "TU 599"},
+		{"73, gl", "73  GL"},
+		{"test;cw_macros_stop", "TEST CW_MACROS_STOP"},
+		{"line\r\nbreak", "LINE  BREAK"},
+		{"   ", ""},
+	} {
+		if got := sanitiseTCICW(c.in); got != c.want {
+			t.Errorf("sanitiseTCICW(%q) = %q, want %q", c.in, got, c.want)
+		}
+	}
+}

internal/cluster/cluster.go

@@ -44,30 +44,30 @@ type ServerConfig struct {
 // is emitted to the UI, so the table never has empty country cells
 // flickering in for a few hundred ms.
 type Spot struct {
-	SourceID   int64     `json:"source_id"`   // ID of the cluster server this came from
-	SourceName string    `json:"source_name"` // display name (handy in the UI when multiple servers)
-	Spotter    string    `json:"spotter"`     // DE field
+	SourceID   int64  `json:"source_id"`   // ID of the cluster server this came from
+	SourceName string `json:"source_name"` // display name (handy in the UI when multiple servers)
+	Spotter    string `json:"spotter"`     // DE field
 	// SpotterContinent belongs to the SPOT, not to the DX station: one call is
 	// spotted by dozens of skimmers on every continent within a minute. It is
 	// resolved per spot at ingest for exactly that reason — see the note on the
 	// spotter-continent filter in App.tsx.
-	SpotterContinent string `json:"spotter_continent,omitempty"`
-	DXCall           string `json:"dx_call"` // the DX station heard
-	FreqKHz    float64   `json:"freq_khz"`
-	FreqHz     int64     `json:"freq_hz"`
-	Band       string    `json:"band,omitempty"`
-	Comment    string    `json:"comment,omitempty"`
-	Locator    string    `json:"locator,omitempty"` // spotter grid (optional)
-	TimeUTC    string    `json:"time_utc,omitempty"`
-	Country    string    `json:"country,omitempty"`     // DXCC entity name (cty.dat)
-	Continent  string    `json:"continent,omitempty"`   // 2-letter continent
-	CQZone     int       `json:"cqz,omitempty"`         // DXCC entity CQ zone
-	ITUZone    int       `json:"ituz,omitempty"`        // DXCC entity ITU zone
-	DistanceKm int       `json:"distance_km,omitempty"` // great-circle km from operator's grid
-	ShortPath  int       `json:"sp_deg,omitempty"`      // azimuth (deg) short path from operator
-	LongPath   int       `json:"lp_deg,omitempty"`      // azimuth (deg) long path = SP + 180 mod 360
-	ReceivedAt time.Time `json:"received_at"`
-	Raw        string    `json:"raw"`
+	SpotterContinent string    `json:"spotter_continent,omitempty"`
+	DXCall           string    `json:"dx_call"` // the DX station heard
+	FreqKHz          float64   `json:"freq_khz"`
+	FreqHz           int64     `json:"freq_hz"`
+	Band             string    `json:"band,omitempty"`
+	Comment          string    `json:"comment,omitempty"`
+	Locator          string    `json:"locator,omitempty"` // spotter grid (optional)
+	TimeUTC          string    `json:"time_utc,omitempty"`
+	Country          string    `json:"country,omitempty"`     // DXCC entity name (cty.dat)
+	Continent        string    `json:"continent,omitempty"`   // 2-letter continent
+	CQZone           int       `json:"cqz,omitempty"`         // DXCC entity CQ zone
+	ITUZone          int       `json:"ituz,omitempty"`        // DXCC entity ITU zone
+	DistanceKm       int       `json:"distance_km,omitempty"` // great-circle km from operator's grid
+	ShortPath        int       `json:"sp_deg,omitempty"`      // azimuth (deg) short path from operator
+	LongPath         int       `json:"lp_deg,omitempty"`      // azimuth (deg) long path = SP + 180 mod 360
+	ReceivedAt       time.Time `json:"received_at"`
+	Raw              string    `json:"raw"`
 	// Historical marks a spot recovered from a SH/DX table rather than heard live.
 	// It belongs in the grid, but must NOT fire alerts or reach the panadapter:
 	// replaying 100 past spots would spam both, and a station spotted three hours
@@ -75,6 +75,10 @@ type Spot struct {
 	Historical bool   `json:"historical,omitempty"`
 	POTARef    string `json:"pota_ref,omitempty"`  // park id if this station is activating (api.pota.app)
 	POTAName   string `json:"pota_name,omitempty"` // park name
+	// SOTARef comes from the COMMENT, not from an API: the SOTA clusters put the
+	// summit in the text of the spot they send ("W9/WI-001"), and there is no
+	// per-callsign endpoint to ask the way POTA has one.
+	SOTARef string `json:"sota_ref,omitempty"`
 }
 
 // State enumerates the per-server lifecycle.

internal/cluster/cluster_test.go

@@ -110,7 +110,7 @@ func TestParseShowDX(t *testing.T) {
 // chatter turned into fake spots would be worse than no parser at all.
 func TestParseShowDXRejectsNoise(t *testing.T) {
 	noise := []string{
-		"DX de F5ABC:     14195.0  EA8DHH       CQ DX                 1234Z",  // the broadcast form: spotRE owns it
+		"DX de F5ABC:     14195.0  EA8DHH       CQ DX                 1234Z", // the broadcast form: spotRE owns it
 		"Hello and welcome to the DXSpider cluster",
 		"WWV de VE7CC <18Z> : SFI=110, A=16, K=2",
 		"F4BPO de GB7DXC 12-Jul-2026 2130Z dxspider >",

internal/cluster/sotaref.go

@@ -0,0 +1,21 @@
+package cluster
+
+import "regexp"
+
+// sotaRefRe matches a SOTA summit reference inside a spot comment.
+//
+// The shape is association/region-NNN — "W9/WI-001", "DM/BM-063", "VK3/VC-014",
+// "F/AM-123" — and the association may carry digits. Anchored on both sides so
+// a callsign like DL/SP9DPM/P can never be read as one, and deliberately
+// narrower than "anything with a slash and a dash": POTA (US-4475) and WWFF
+// (DLFF-0001) refs share the comment field and must not be caught here.
+var sotaRefRe = regexp.MustCompile(`\b([A-Z0-9]{1,4}(?:/[A-Z0-9]{1,4})?/[A-Z]{2}-[0-9]{3})\b`)
+
+// SOTARefFrom returns the first SOTA reference in a spot comment, or "".
+func SOTARefFrom(comment string) string {
+	m := sotaRefRe.FindStringSubmatch(comment)
+	if m == nil {
+		return ""
+	}
+	return m[1]
+}

internal/cluster/sotaref_test.go

@@ -0,0 +1,25 @@
+package cluster
+
+import "testing"
+
+func TestSOTARefFrom(t *testing.T) {
+	// Left column: real comments seen on the SOTA cluster feed.
+	cases := []struct{ in, want string }{
+		{"W9/WI-001", "W9/WI-001"},
+		{"DM/BM-063", "DM/BM-063"},
+		{"W7Y/TT-122", "W7Y/TT-122"},
+		{"VK3/VC-014 s2s", "VK3/VC-014"},
+		{"[SOTA] F/AM-123 cq", "F/AM-123"},
+		{"", ""},
+		// The other reference schemes that share this field.
+		{"POTA US-4475", ""},
+		{"WWFF DLFF-0001", ""},
+		// A portable callsign is not a summit.
+		{"DL/SP9DPM/P calling", ""},
+	}
+	for _, c := range cases {
+		if got := SOTARefFrom(c.in); got != c.want {
+			t.Errorf("SOTARefFrom(%q) = %q, want %q", c.in, got, c.want)
+		}
+	}
+}

internal/db/migrations/0031_label_templates.sql

@@ -0,0 +1,30 @@
+-- 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,6 +51,8 @@ var settingsTables = []string{
 	"operating_stations_new",
 	"award_references",
 	"qsl_templates",
+	"label_stocks",
+	"label_templates",
 	"cluster_servers",
 	"integrations_udp",
 	"callsign_cache",

internal/email/email.go

@@ -5,6 +5,7 @@ package email
 import (
 	"fmt"
 	"os"
+	"strings"
 	"time"
 
 	"github.com/wneessen/go-mail"
@@ -86,12 +87,42 @@ func SendFiles(cfg Config, to, subject, body string, attachPaths []string) error
 		return fmt.Errorf("smtp client: %w", err)
 	}
 	if err := client.DialAndSend(m); err != nil {
-		return fmt.Errorf("send via %s:%d (%s, %s): %w",
-			cfg.Host, cfg.Port, cfg.Encryption, describeSize(attachPaths), err)
+		return fmt.Errorf("send via %s:%d (%s, %s): %w%s",
+			cfg.Host, cfg.Port, cfg.Encryption, describeSize(attachPaths), err, explainSMTP(err))
 	}
 	return nil
 }
 
+// explainSMTP turns a server's refusal into the thing to go and do.
+//
+// A rejection is quoted verbatim above it — the server's own words are the
+// evidence — but several of them name a policy rather than a mistake, and no
+// amount of re-checking the password will fix those. Microsoft's is the one
+// operators keep hitting: basic authentication for SMTP is switched off across
+// Microsoft 365 and outlook.com, and an app password does not bring it back.
+func explainSMTP(err error) string {
+	msg := strings.ToLower(err.Error())
+	switch {
+	case strings.Contains(msg, "basic authentication is disabled"),
+		strings.Contains(msg, "5.7.139"):
+		return "\n\nMicrosoft has switched off password-based SMTP for this account. " +
+			"An app password does not restore it — the server refuses the password itself, not the one you typed. " +
+			"On a Microsoft 365 tenant an administrator can re-enable it for this mailbox " +
+			"(Set-CASMailbox -SmtpClientAuthenticationDisabled $false, plus the tenant-wide setting); " +
+			"otherwise use another provider for alerts (a Gmail account with an app password works, so does any ordinary IMAP/SMTP host)."
+	case strings.Contains(msg, "application-specific password"),
+		strings.Contains(msg, "5.7.9"):
+		return "\n\nThis account needs an APP PASSWORD rather than the one you sign in with " +
+			"(Google, Yahoo and others require it once two-factor authentication is on)."
+	case strings.Contains(msg, "5.7.8"), strings.Contains(msg, "authentication failed"),
+		strings.Contains(msg, "535"):
+		return "\n\nThe server rejected the username or the password."
+	case strings.Contains(msg, "must issue a starttls"):
+		return "\n\nThe server requires encryption: set STARTTLS (usually port 587) or SSL (465)."
+	}
+	return ""
+}
+
 // describeSize reports what was attached, in bytes.
 //
 // "An existing connection was forcibly closed" during DATA is the same message

internal/email/email_explain_test.go

@@ -0,0 +1,29 @@
+package email
+
+import (
+	"errors"
+	"strings"
+	"testing"
+)
+
+func TestExplainSMTP(t *testing.T) {
+	// The real refusal, from an operator's Outlook account.
+	outlook := errors.New("SMTP AUTH failed: 535 5.7.139 Authentication unsuccessful, basic authentication is disabled.")
+	if got := explainSMTP(outlook); !strings.Contains(got, "Microsoft has switched off") {
+		t.Errorf("the Microsoft policy refusal is not explained: %q", got)
+	}
+	// A plain wrong password must NOT claim a policy: the advice would send the
+	// operator to an administrator over a typo.
+	wrong := errors.New("535 5.7.8 authentication failed")
+	got := explainSMTP(wrong)
+	if strings.Contains(got, "Microsoft") {
+		t.Errorf("a wrong password was explained as a Microsoft policy: %q", got)
+	}
+	if !strings.Contains(got, "rejected the username") {
+		t.Errorf("a wrong password is not explained: %q", got)
+	}
+	// Anything else is left to speak for itself.
+	if got := explainSMTP(errors.New("dial tcp: i/o timeout")); got != "" {
+		t.Errorf("an unrelated error got an explanation: %q", got)
+	}
+}

internal/extsvc/lotw.go

@@ -12,6 +12,7 @@ import (
 	"os/exec"
 	"path/filepath"
 	"strings"
+	"sync"
 	"syscall"
 	"time"
 )
@@ -20,6 +21,67 @@ import (
 // document of the user's QSOs (optionally only confirmed ones).
 const lotwReportURL = "https://lotw.arrl.org/lotwuser/lotwreport.adi"
 
+const (
+	// How long LoTW may take to START answering. It builds the whole report
+	// before sending anything, so this is the slow part of a big account.
+	lotwHeaderTimeout = 10 * time.Minute
+	// How long the transfer may stall once it HAS started. A download that has
+	// not moved in this long is not slow, it is dead — and saying so beats a
+	// progress window that sits at "working" until someone gives up.
+	lotwIdleTimeout = 2 * time.Minute
+	lotwMaxBytes    = 256 * 1024 * 1024
+)
+
+// readWithProgress reads the body in chunks, reporting the running total and
+// failing fast on a stall.
+//
+// Reported as it arrives rather than at the end: an 18 MB report over a slow
+// link is minutes of silence otherwise, which is indistinguishable from a hang —
+// and that is exactly what operators were reporting.
+func say(note func(string), msg string) {
+	if note != nil {
+		note(msg)
+	}
+	LogSink("%s", msg)
+}
+
+func readWithProgress(ctx context.Context, r io.Reader, note func(string)) ([]byte, error) {
+	var (
+		out   []byte
+		total int64
+		last  = time.Now()
+		buf   = make([]byte, 64*1024)
+		next  = int64(256 * 1024) // first report early — proof it is moving
+	)
+	for {
+		if err := ctx.Err(); err != nil {
+			return nil, err
+		}
+		n, err := r.Read(buf)
+		if n > 0 {
+			out = append(out, buf[:n]...)
+			total += int64(n)
+			last = time.Now()
+			if total >= next {
+				say(note, fmt.Sprintf("  … %.1f MB received", float64(total)/(1024*1024)))
+				next = total + 512*1024
+			}
+			if total >= lotwMaxBytes {
+				return out, nil
+			}
+		}
+		if err == io.EOF {
+			return out, nil
+		}
+		if err != nil {
+			return nil, err
+		}
+		if time.Since(last) > lotwIdleTimeout {
+			return nil, fmt.Errorf("the transfer stalled after %d KB — LoTW stopped sending", total/1024)
+		}
+	}
+}
+
 // DownloadLoTWConfirmations fetches confirmed QSOs from LoTW as ADIF text.
 // Uses the LoTW *website* login (Username/Password), not the TQSL cert. When
 // since is non-empty (YYYY-MM-DD) only confirmations received since then are
@@ -27,7 +89,7 @@ const lotwReportURL = "https://lotw.arrl.org/lotwuser/lotwreport.adi"
 // non-empty, only confirmations for that station callsign are returned (an
 // LoTW account holds every call you operate — F4BPO, F4BPO/P, TM2Q — so this
 // scopes the pull to the active profile's call).
-func DownloadLoTWConfirmations(ctx context.Context, client *http.Client, cfg ServiceConfig, since, ownCall string) (string, error) {
+func DownloadLoTWConfirmations(ctx context.Context, client *http.Client, cfg ServiceConfig, since, ownCall string, detail bool, note func(string)) (string, error) {
 	user := strings.TrimSpace(cfg.Username)
 	if user == "" || cfg.Password == "" {
 		return "", fmt.Errorf("lotw: website login (username/password) not set")
@@ -36,28 +98,119 @@ func DownloadLoTWConfirmations(ctx context.Context, client *http.Client, cfg Ser
 	q.Set("login", user)
 	q.Set("password", cfg.Password)
 	q.Set("qso_query", "1")
-	q.Set("qso_qsl", "yes")       // only QSLed (confirmed) records
-	q.Set("qso_qsldetail", "yes") // include QSL_RCVD / QSLRDATE detail
+	q.Set("qso_qsl", "yes") // only QSLed (confirmed) records
+	// qso_qsldetail is what LoTW charges for: it adds the QSL date and the
+	// station's own DXCC / grid / state / county to every record, and takes an
+	// order of magnitude longer to build — a report that arrives in two minutes
+	// without it takes twenty with it, measured on the same account.
+	//
+	// What we actually need to mark a confirmation is call, date, band and mode.
+	// The rest is worth its price only when the download is also ADDING the QSOs
+	// it cannot find, which is the one case where the extra fields are the only
+	// source for them.
+	if detail {
+		q.Set("qso_qsldetail", "yes")
+	}
 	if c := strings.TrimSpace(ownCall); c != "" {
 		q.Set("qso_owncall", c) // restrict to this station callsign
 	}
-	if s := strings.TrimSpace(since); s != "" {
-		q.Set("qso_qslsince", s)
+	// qso_qslsince is ALWAYS sent, even for "everything".
+	//
+	// Left out, LoTW does not answer "all confirmations" — it answers with a
+	// handful of recent ones, which arrives as a 200 and a valid ADIF and reads
+	// as a successful download of a nearly empty account. Asking from a date
+	// older than the service itself is the only way to mean "all".
+	sinceDate := strings.TrimSpace(since)
+	if sinceDate == "" {
+		sinceDate = "1945-11-15" // older than any QSO LoTW will accept
 	}
+	q.Set("qso_qslsince", sinceDate)
 
 	req, err := http.NewRequestWithContext(ctx, http.MethodGet, lotwReportURL+"?"+q.Encode(), nil)
 	if err != nil {
 		return "", fmt.Errorf("lotw: build request: %w", err)
 	}
+	// Named, because LoTW's front end throttles unidentified clients harder than
+	// it throttles known ones, and an operator reporting a 503 deserves a request
+	// that says who is asking.
+	req.Header.Set("User-Agent", "OpsLog")
 	if client == nil {
-		client = &http.Client{Timeout: 120 * time.Second}
+		// NO overall deadline. A full account is tens of megabytes and LoTW spends
+		// minutes building it before the first byte; a total timeout turns a slow
+		// but healthy download into "context deadline exceeded", and a longer one
+		// turns a dead connection into a window that says "working" for twenty
+		// minutes. What matters is not how long it takes but whether it is still
+		// moving — see the idle watchdog below.
+		client = &http.Client{
+			Transport: &http.Transport{
+				Proxy:                 http.ProxyFromEnvironment,
+				ResponseHeaderTimeout: lotwHeaderTimeout,
+				TLSHandshakeTimeout:   30 * time.Second,
+			},
+		}
+	}
+	// LoTW answers 503 when it is busy, which for a report covering more than a
+	// few days is often — other loggers get the same answer and simply ask
+	// again. Three tries, spaced, and each one said out loud: an operator whose
+	// download takes four minutes because the ARRL is loaded should be able to
+	// see that rather than guess it.
+	// LoTW sends nothing at all until the whole report is built — minutes for a
+	// large account. That silence was the entire complaint: a window saying
+	// "working" with no way to tell a busy server from a dead one. Count it out
+	// loud until the first byte.
+	beat := make(chan struct{})
+	go func() {
+		start := time.Now()
+		tick := time.NewTicker(15 * time.Second)
+		defer tick.Stop()
+		for {
+			select {
+			case <-beat:
+				return
+			case <-ctx.Done():
+				return
+			case <-tick.C:
+				say(note, fmt.Sprintf("  … still waiting for LoTW to build the report (%.0f s)", time.Since(start).Seconds()))
+			}
+		}
+	}()
+	// Stopped where the WAIT ends, not where the function does: deferred, the
+	// heartbeat went on counting between the megabyte lines and read as if the
+	// report were still being built while it was already arriving.
+	stopBeat := sync.OnceFunc(func() { close(beat) })
+	defer stopBeat()
+
+	var resp *http.Response
+	for attempt := 1; ; attempt++ {
+		resp, err = client.Do(req) //nolint:bodyclose // closed below or in the retry
+		if err == nil && resp.StatusCode != http.StatusServiceUnavailable &&
+			resp.StatusCode != http.StatusBadGateway && resp.StatusCode != http.StatusGatewayTimeout {
+			break
+		}
+		if attempt >= 3 {
+			break
+		}
+		wait := time.Duration(attempt*20) * time.Second
+		if resp != nil {
+			say(note, fmt.Sprintf("LoTW is busy (HTTP %d) — asking again in %s…", resp.StatusCode, wait))
+			resp.Body.Close()
+		} else {
+			say(note, fmt.Sprintf("LoTW did not answer (%v) — asking again in %s…", err, wait))
+		}
+		select {
+		case <-ctx.Done():
+			return "", ctx.Err()
+		case <-time.After(wait):
+		}
+		req = req.Clone(ctx)
 	}
-	resp, err := client.Do(req)
 	if err != nil {
 		return "", fmt.Errorf("lotw: request failed: %w", err)
 	}
 	defer resp.Body.Close()
-	body, err := io.ReadAll(io.LimitReader(resp.Body, 32*1024*1024))
+	stopBeat()
+	say(note, fmt.Sprintf("LoTW answered (HTTP %d) — receiving…", resp.StatusCode))
+	body, err := readWithProgress(ctx, resp.Body, note)
 	if err != nil {
 		return "", fmt.Errorf("lotw: read response: %w", err)
 	}
@@ -365,7 +518,7 @@ func TestLoTW(cfg ServiceConfig, stationDataPath string) (string, error) {
 	}
 	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
 	defer cancel()
-	if _, err := DownloadLoTWConfirmations(ctx, nil, cfg, "2099-01-01", ""); err != nil {
+	if _, err := DownloadLoTWConfirmations(ctx, nil, cfg, "2099-01-01", "", false, nil); err != nil {
 		return "", fmt.Errorf("%s — but the DOWNLOAD login failed: %w", up, err)
 	}
 	return up + ". Download login accepted.", nil

internal/labels/labels.go

@@ -0,0 +1,194 @@
+// 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

@@ -0,0 +1,252 @@
+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

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,131 @@
+// 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

@@ -0,0 +1,54 @@
+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,8 +232,11 @@ type ListFilter struct {
 	Band            string `json:"band,omitempty"`
 	Mode            string `json:"mode,omitempty"`
 	StationCallsign string `json:"station_callsign,omitempty"`
-	Limit           int    `json:"limit,omitempty"`
-	Offset          int    `json:"offset,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"`
 }
 
 // Repo accesses the qso table.
@@ -1211,6 +1214,12 @@ 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
@@ -1901,10 +1910,24 @@ type WorkedBefore struct {
 }
 
 // BandStatus is one cell in the worked-before grid.
+//
+// Status is the single highest thing true of the cell, which is what colours
+// it. Call is the SAME cell's answer to a different question — "have I worked
+// THIS callsign here" — kept separately because the two are asked at the same
+// moment and one was hiding the other.
+//
+// Chasing an expedition, an operator needs both: whether the slot is still
+// missing for the entity (does this fill a DXCC hole) and whether this
+// expedition has already been worked on it (would this be a dupe). A confirmed
+// entity outranks a worked callsign in Status — correctly, for awards — so a
+// slot worked with the DX yesterday can read "entity confirmed" and say nothing
+// at all about yesterday.
 type BandStatus struct {
 	Band   string `json:"band"`   // ADIF lowercase band, e.g. "20m"
 	Class  string `json:"class"`  // "PH" | "CW" | "DIG"
 	Status string `json:"status"` // "call_c" | "call_w" | "dxcc_c" | "dxcc_w"
+	// Call is "", "w" (worked with this callsign) or "c" (confirmed with it).
+	Call string `json:"call,omitempty"`
 }
 
 // Band-status codes, lowest first. The ORDER is the rule: a cell shows the
@@ -2222,13 +2245,17 @@ func (r *Repo) WorkedBefore(ctx context.Context, callsign string, dxccHint int,
 	// The grid answers "what do I still need on this band and mode", and for
 	// that question confirmation is the axis that matters: a confirmed entity
 	// needs nothing, whoever else was worked afterwards.
+	// The two per-callsign columns use the SAME predicate as the callsign count
+	// above, portable variants included: a cell that counts RI1FJL/1 in "worked
+	// with this call" and a header that does not would be two answers to one
+	// question.
 	// Filter NULL/empty band+mode rows — they'd create a NULL group key
 	// that Scan into *string can't handle and would error out the whole
 	// WorkedBefore call, blanking the matrix in the UI.
 	statusRows, err := r.db.QueryContext(ctx, `
         SELECT band, mode,
-               MAX(CASE WHEN callsign = ? THEN 1 ELSE 0 END),
-               MAX(CASE WHEN callsign = ?
+               MAX(CASE WHEN `+pred+` THEN 1 ELSE 0 END),
+               MAX(CASE WHEN `+pred+`
                          AND (lotw_rcvd IN `+ConfirmedValues+` OR qsl_rcvd IN `+ConfirmedValues+` OR eqsl_rcvd IN `+ConfirmedValues+`)
                         THEN 1 ELSE 0 END),
                MAX(CASE WHEN lotw_rcvd IN `+ConfirmedValues+` OR qsl_rcvd IN `+ConfirmedValues+` OR eqsl_rcvd IN `+ConfirmedValues+`
@@ -2237,12 +2264,14 @@ func (r *Repo) WorkedBefore(ctx context.Context, callsign string, dxccHint int,
         WHERE dxcc = ?
           AND band IS NOT NULL AND band != ''
           AND mode IS NOT NULL AND mode != ''
-        GROUP BY band, mode`, wb.Callsign, wb.Callsign, dxcc)
+        GROUP BY band, mode`, append(append(append([]any{}, predArgs...), predArgs...), dxcc)...)
 	if err != nil {
 		return wb, fmt.Errorf("band status: %w", err)
 	}
 	type cellKey struct{ band, class string }
 	best := map[cellKey]int{}
+	// The call's own answer per cell, independent of the ladder above.
+	callByCell := map[cellKey]string{}
 	for statusRows.Next() {
 		var band, mode string
 		var callW, callC, dxccConfirmed int
@@ -2255,12 +2284,21 @@ func (r *Repo) WorkedBefore(ctx context.Context, callsign string, dxccHint int,
 		if cur, ok := best[k]; !ok || code > cur {
 			best[k] = code
 		}
+		// Confirmed beats worked here too, and neither is ever erased by the
+		// entity: this is only ever about the callsign.
+		switch {
+		case callC == 1:
+			callByCell[k] = "c"
+		case callW == 1 && callByCell[k] == "":
+			callByCell[k] = "w"
+		}
 	}
 	statusRows.Close()
 	codeStr := bandStatusNames
 	for k, code := range best {
 		wb.BandStatus = append(wb.BandStatus, BandStatus{
 			Band: k.band, Class: k.class, Status: codeStr[code],
+			Call: callByCell[k],
 		})
 	}
 	return wb, nil
@@ -2955,6 +2993,33 @@ func DedupeKey(callsign, qsoDateMinute, band, mode string) string {
 	return strings.ToUpper(callsign) + "|" + qsoDateMinute + "|" + strings.ToLower(band) + "|" + strings.ToUpper(mode)
 }
 
+// StationCallsigns lists the distinct station callsigns the logbook was worked
+// under, upper-cased and without the blanks.
+//
+// Used to decide whether a downloaded confirmation belongs to THIS log at all:
+// one LoTW account can hold several stations (a home call, a portable, an
+// expedition), and a confirmation for a station this logbook has never used is
+// somebody else's log — here, another profile's.
+func (r *Repo) StationCallsigns(ctx context.Context) (map[string]bool, error) {
+	rows, err := r.db.QueryContext(ctx,
+		`SELECT DISTINCT COALESCE(station_callsign,'') FROM qso`)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	out := map[string]bool{}
+	for rows.Next() {
+		var c string
+		if err := rows.Scan(&c); err != nil {
+			return nil, err
+		}
+		if c = strings.ToUpper(strings.TrimSpace(c)); c != "" {
+			out[c] = true
+		}
+	}
+	return out, rows.Err()
+}
+
 // DedupeKeyIDs returns a map of dedupe key → QSO id, for matching downloaded
 // confirmations back to local QSOs.
 func (r *Repo) DedupeKeyIDs(ctx context.Context) (map[string]int64, error) {

telemetry.go

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

windowpos_other.go

@@ -0,0 +1,7 @@
+//go:build !windows
+
+package main
+
+// Placing a window at an absolute desktop coordinate is Windows-specific; every
+// caller falls back to the toolkit's own call when this says no.
+func setWindowPosAbsolute(x, y int) bool { return false }

windowpos_windows.go

@@ -0,0 +1,93 @@
+//go:build windows
+
+package main
+
+import (
+	"syscall"
+	"unsafe"
+
+	"hamlog/internal/applog"
+)
+
+// Moving the window to an ABSOLUTE virtual-desktop position.
+//
+// Wails' own WindowSetPosition cannot do it. Its Windows implementation reads:
+//
+//	func (cba *ControlBase) SetPos(x, y int) {
+//	    info := getMonitorInfo(cba.hwnd)
+//	    w32.SetWindowPos(cba.hwnd, HWND_TOP, int(info.RcWork.Left)+x, int(info.RcWork.Top)+y, ...)
+//	}
+//
+// — the coordinates are relative to the CURRENT monitor's work area, while
+// WindowGetPosition returns GetWindowRect, which is absolute. Saving one and
+// restoring the other is only harmless on the primary monitor, where the work
+// area starts at 0.
+//
+// On a second monitor to the LEFT it compounds at every launch. Reported from a
+// two-screen station with the left monitor at x = -3840: OpsLog saved -3844,
+// reopened on that monitor, added the monitor's own origin, and stored -7684 —
+// then -11524, each launch one screen further into nowhere.
+//
+// So we place the window ourselves. Same call the toolkit makes, without the
+// offset.
+const (
+	swpNoSize     = 0x0001
+	swpNoZOrder   = 0x0004
+	swpNoActivate = 0x0010
+)
+
+var (
+	procSetWindowPos              = user32Dll.NewProc("SetWindowPos")
+	procEnumWindows               = user32Dll.NewProc("EnumWindows")
+	procGetWindowThreadProcessID  = user32Dll.NewProc("GetWindowThreadProcessId")
+	procGetWindowTextLengthW      = user32Dll.NewProc("GetWindowTextLengthW")
+	procGetWindow                 = user32Dll.NewProc("GetWindow")
+	kernel32Dll                   = syscall.NewLazyDLL("kernel32.dll")
+	procGetCurrentProcessIDWinPos = kernel32Dll.NewProc("GetCurrentProcessId")
+)
+
+// mainWindowHandle finds this process's own top-level window.
+//
+// Wails does not expose the handle, so it is looked up: the first top-level
+// window belonging to this process id that has no owner and a title. The window
+// is created hidden (StartHidden), and EnumWindows lists hidden windows too,
+// which is what makes this usable before the window is shown.
+func mainWindowHandle() uintptr {
+	self, _, _ := procGetCurrentProcessIDWinPos.Call()
+	var found uintptr
+	cb := syscall.NewCallback(func(hwnd uintptr, _ uintptr) uintptr {
+		var pid uint32
+		procGetWindowThreadProcessID.Call(hwnd, uintptr(unsafe.Pointer(&pid)))
+		if uintptr(pid) != self {
+			return 1 // keep going
+		}
+		// GW_OWNER = 4: skip tool windows and dialogs owned by the main one.
+		if owner, _, _ := procGetWindow.Call(hwnd, 4); owner != 0 {
+			return 1
+		}
+		if n, _, _ := procGetWindowTextLengthW.Call(hwnd); n == 0 {
+			return 1
+		}
+		found = hwnd
+		return 0 // stop
+	})
+	procEnumWindows.Call(cb, 0)
+	return found
+}
+
+// setWindowPosAbsolute moves the window to a virtual-desktop coordinate.
+// Reports whether it could; the caller falls back to the toolkit's own call.
+func setWindowPosAbsolute(x, y int) bool {
+	hwnd := mainWindowHandle()
+	if hwnd == 0 {
+		applog.Printf("window: could not find our own window handle — falling back to the toolkit's placement")
+		return false
+	}
+	r, _, err := procSetWindowPos.Call(hwnd, 0, uintptr(int32(x)), uintptr(int32(y)), 0, 0,
+		swpNoSize|swpNoZOrder|swpNoActivate)
+	if r == 0 {
+		applog.Printf("window: SetWindowPos(%d,%d) failed: %v", x, y, err)
+		return false
+	}
+	return true
+}