@ham2k/extension-sdk 0.2.0 → 0.4.0

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-// @ham2k/extension-sdk 0.2.0
+// @ham2k/extension-sdk 0.4.0
 export type CallInfo = {
 	call: string;
 	baseCall?: string;
@@ -103,8 +103,14 @@ export interface HookContext {
 	distanceUnits?: string;
 	decimalSeparator?: string;
 	groupingSeparator?: string;
+	gridPrecision?: number;
 	edition?: string;
 	enabledExperiments?: string[];
+	experiments?: {
+		key: string;
+		name: string;
+		aliases: string[];
+	}[];
 	getOperation?(uuid: string): Promise<Record<string, JSONValue> | null>;
 	getQsos?(operationUuid: string): Promise<Record<string, JSONValue>[] | null>;
 	getSpotsForCall?(call: string, maxAgeMinutes?: number): Promise<Spot[]>;
@@ -275,6 +281,7 @@ export interface SerialInputDescriptor {
 export interface FormInputDescriptor {
 	kind: "form";
 	refType: string;
+	alsoHandles?: string[];
 	form: FormDefinition;
 }
 export interface TextInputDescriptor {
@@ -304,6 +311,10 @@ export interface OptionsInputDescriptor {
 	matchOn?: ("code" | "name")[];
 	allowFreeform?: boolean;
 	preferredCodes?: string[];
+	multiValue?: {
+		separator: string;
+		inheritPrefix?: number;
+	};
 	minCharsForSuggestions?: number;
 	placeholder?: string;
 	uppercase?: boolean;
@@ -377,10 +388,44 @@ export interface AdifImportHook {
 		}[];
 	}, ctx: HookContext): Promise<(AdifImportResult | null)[]>;
 }
+export interface ExportSettings {
+	includePrivateData?: boolean;
+	includeLookupData?: boolean;
+	customTemplates?: boolean;
+	filenameTemplate?: string;
+	compactFilenameTemplate?: string;
+	titleTemplate?: string;
+	adifNotesTemplate?: string;
+	adifCommentTemplate?: string;
+	adifQslMessageTemplate?: string;
+}
+export interface GlobalExportSettings extends ExportSettings {
+	referenceFilenameTemplate?: string;
+	referenceCompactFilenameTemplate?: string;
+	referenceTitleTemplate?: string;
+	otherFilenameTemplate?: string;
+	otherCompactFilenameTemplate?: string;
+	otherTitleTemplate?: string;
+}
+export interface ExportTypeDefinition {
+	exportType: string;
+	label: string;
+	format: string;
+	activationType?: string;
+	templateCategory?: "reference" | "other";
+	defaults?: ExportSettings;
+	templateSample?: Record<string, JSONValue>;
+}
 export interface ExportRequest {
+	exportSettings?: ExportSettings;
+	exportData?: Record<string, JSONValue>;
+	exportTitle?: string;
+	includeLookupData?: boolean;
 	operation: Record<string, JSONValue>;
 	qsos: Record<string, JSONValue>[];
+	segments?: OperationSegmentPayload[];
 	exportType?: string;
+	exportKey?: string;
 	compactFilenames?: boolean;
 	includePrivateData?: boolean;
 	mainHandler?: string;
@@ -397,7 +442,10 @@ export interface ExportOptionsRequest {
 	compactFilenames?: boolean;
 }
 export interface ExportOption {
+	qsoCount?: number;
+	templateData?: Record<string, JSONValue>;
 	exportType: string;
+	exportKey?: string;
 	format: string;
 	label: string;
 	filename?: string;
@@ -409,6 +457,7 @@ export interface ExportOption {
 	refType?: string;
 }
 export interface ExportHook {
+	getExportTypes?(args: Record<string, never>, ctx: HookContext): Promise<ExportTypeDefinition[]>;
 	suggestExportOptions?(args: ExportOptionsRequest, ctx: HookContext): Promise<ExportOption[]>;
 	generateExport(args: ExportRequest, ctx: HookContext): Promise<ExportResult>;
 }
@@ -464,6 +513,7 @@ export interface ScoreQsoRequest {
 export interface QsoScoreNotices {
 	notices: string[];
 	alerts: string[];
+	dupe?: boolean;
 }
 export interface ScoreCandidatesRequest {
 	operation: Record<string, JSONValue>;
@@ -517,6 +567,10 @@ export interface CommandAction {
 	setPower?: {
 		watts: number;
 	};
+	setKeyerSpeed?: {
+		wpm: number;
+	};
+	showKeyer?: Record<string, never>;
 	updateQso?: Record<string, JSONValue>;
 	addQso?: Record<string, JSONValue>;
 	sendSpots?: {
@@ -540,6 +594,10 @@ export interface CommandAction {
 		operatorCall?: string;
 		multiIdentifier?: string;
 	};
+	markSegment?: {
+		kind: "start" | "break" | "stop";
+		setLocation?: boolean;
+	};
 	setCallField?: {
 		text: string;
 	};
@@ -575,6 +633,9 @@ export interface CommandAction {
 		deltaMillis?: number;
 		speed?: number;
 	};
+	devBench?: {
+		qsoCount?: number;
+	};
 	toggleExperiment?: {
 		token: string;
 	};
@@ -723,6 +784,14 @@ export interface ActivationApi {
 	registerHook(category: string, params: RegisterHookParams): void;
 	hostCall(method: string, params: Record<string, unknown>): Promise<unknown>;
 }
+export interface ExtensionRelevance {
+	entities?: string[];
+	countries?: string[];
+	continents?: string[];
+	ituRegions?: number[];
+	dates?: string[];
+	interests?: string[];
+}
 export interface ExtensionManifest {
 	key: string;
 	name: string;
@@ -739,6 +808,7 @@ export interface ExtensionManifest {
 	allowUserAgentOverride?: boolean;
 	requiresLocation?: boolean;
 	experiments?: string[];
+	relevance?: ExtensionRelevance;
 	translations?: Record<string, {
 		name?: string;
 		description?: string;
@@ -838,7 +908,7 @@ export interface DataFileDefinition {
 	onLoadRawData?: (data: any) => void;
 	onRemoveRawData?: () => Promise<void>;
 }
-export type FormFieldType = "text" | "multiline" | "email" | "callsign" | "number" | "select" | "radio" | "checkbox" | "secret" | "list" | "multiselect" | "account";
+export type FormFieldType = "text" | "multiline" | "textTemplate" | "email" | "callsign" | "number" | "select" | "radio" | "checkbox" | "secret" | "list" | "multiselect" | "account";
 export interface FormFieldOption {
 	label: string;
 	value: any;
@@ -852,6 +922,8 @@ export interface FormField {
 	label: string;
 	value?: any;
 	placeholder?: string;
+	templateContext?: "export" | "adif" | "text";
+	templateSample?: Record<string, JSONValue>;
 	uppercase?: boolean;
 	options?: FormFieldOption[] | string;
 	validate?: (value: any, state: Record<string, any>) => string | null | undefined | Promise<string | null | undefined>;
@@ -883,7 +955,7 @@ export interface FormHeader {
 	title: string;
 	subtitle?: string;
 	devMode?: boolean;
-	style?: "default" | "section";
+	style?: "default" | "section" | "category";
 	environment?: string | string[];
 }
 export interface FormSectionDivider {
@@ -901,6 +973,8 @@ export interface FormMarkdownBlock {
 	title?: string;
 }
 export interface FormActionElement {
+	style?: "row";
+	icon?: string;
 	type: "action";
 	key: string;
 	label: string;
@@ -1129,13 +1203,17 @@ type AnnotatedCallInfo$1 = CombinedCallInfo & {
 	originalValues?: AnnotatedCallInfo$1;
 	cfValues?: AnnotatedCallInfo$1;
 };
-export declare function annotateCallAgainstCountryFile(call: string): AnnotatedCallInfo$1;
+export declare function annotateCallAgainstCountryFile(call: string, options?: {
+	wae?: boolean;
+}): AnnotatedCallInfo$1;
 export declare function entityPrefixForCall(call: string | undefined): string | undefined;
 export declare function flagForDxccCode(dxccCode: number | undefined): string | undefined;
 export declare function regionAndCountryForDxccCode(dxccCode: number | undefined): {
 	ituRegion?: number;
 	countryCode?: string;
 };
+export declare function countryPrefixForCall(call: string | undefined): string | undefined;
+export declare function entityForCall(call: string | undefined): Pick<AnnotatedCallInfo$1, "dxccCode" | "continent" | "entityName">;
 export declare const LOCATION_ACCURACY: {
 	readonly EXACT: 0;
 	readonly ACCURATE: 2;
@@ -1149,6 +1227,14 @@ export declare function applyLatLonFromApiFields(target: {
 }, raw: Record<string, unknown>): void;
 export declare function canonicalMode(mode: string): string;
 export declare function modesMatchForDupe(worked: string, candidate: string): boolean;
+export declare function expectedSideband({ freqKHz, band }: {
+	freqKHz?: number;
+	band?: string;
+}): string | undefined;
+export declare function isUnexpectedSideband(mode: string | undefined | null, { freqKHz, band }: {
+	freqKHz?: number;
+	band?: string;
+}): boolean;
 export interface ContestScorerOptions {
 	scope?: ScoringScope;
 }
@@ -1156,6 +1242,8 @@ export declare function contestScorer<S extends Scoresheet = Scoresheet>(scorer:
 	scope: ScoringScope;
 };
 export declare function tally(key: string, forScope: "day" | "operation", total: number, extra?: Partial<ScoreTally>): ScoreTally;
+export declare function operationForQso(base: Record<string, JSONValue>, qso: Record<string, JSONValue>, segments?: OperationSegmentPayload[]): Record<string, JSONValue>;
+export declare function segmentsWith(segments: OperationSegmentPayload[] | undefined, transform: (operation: Record<string, JSONValue>) => Record<string, JSONValue>): OperationSegmentPayload[] | undefined;
 export type UniqueAxis = "day" | "band" | "mode" | "ref";
 export interface ActivityScoringRules {
 	label: string;
@@ -1188,12 +1276,14 @@ export type ActivityScoresheet = {
 export declare function activityScorer(rules: ActivityScoringRules): ContestScorer<ActivityScoresheet>;
 export interface ActivityExportRules {
 	key: string;
+	templateSample?: Record<string, JSONValue>;
 	label: string;
 	activationType: string;
 	icon?: string;
 	includeFieldsFrom?: string[];
 }
 export declare function activityExportHook(rules: ActivityExportRules): {
+	getExportTypes(): Promise<ExportTypeDefinition[]>;
 	suggestExportOptions({ operation, qsos, compactFilenames }: ExportOptionsRequest, ctx: HookContext): Promise<ExportOption[]>;
 	generateExport(args: ExportRequest, ctx: HookContext): Promise<ExportResult>;
 };
@@ -1207,13 +1297,19 @@ export interface HuntingExportRules {
 	includeFieldsFrom?: string[];
 }
 export declare function huntingExportHook(rules: HuntingExportRules): {
+	getExportTypes(): Promise<ExportTypeDefinition[]>;
 	suggestExportOptions({ operation, qsos, compactFilenames }: ExportOptionsRequest, ctx: HookContext): Promise<ExportOption[]>;
 	generateExport(args: ExportRequest, ctx: HookContext): Promise<ExportResult>;
 };
-export declare function adifForExport({ operation, qsos, includePrivateData, mainHandler, includeFieldsFrom }: {
+export declare function adifForExport({ operation, qsos, segments, includePrivateData, includeLookupData, exportSettings, exportData, exportTitle, mainHandler, includeFieldsFrom }: {
 	operation: Record<string, JSONValue>;
 	qsos: Record<string, JSONValue>[];
+	segments?: OperationSegmentPayload[];
 	includePrivateData?: boolean;
+	includeLookupData?: boolean;
+	exportSettings?: ExportSettings;
+	exportData?: Record<string, JSONValue>;
+	exportTitle?: string;
 	mainHandler: string;
 	includeFieldsFrom?: string[];
 }): Promise<string>;
@@ -1236,6 +1332,25 @@ export interface ExportNameParts {
 }
 export declare function exportFilename(parts: ExportNameParts): string;
 export declare function startMillisOf(operation: Record<string, JSONValue>, qsos?: Record<string, JSONValue>[]): number | undefined;
+export declare const EXPORT_DEFAULTS: ExportSettings;
+export declare const GLOBAL_EXPORT_DEFAULTS: GlobalExportSettings;
+export declare function resolveGlobalExportSettings(global?: GlobalExportSettings): GlobalExportSettings;
+export declare function exportTypeDefinition(activationType: string, format: string, label: string, defaults?: ExportSettings): ExportTypeDefinition;
+export declare function resolveExportSettings(definition: ExportTypeDefinition, global?: GlobalExportSettings, overrides?: ExportSettings): ExportSettings;
+export declare function exportQso(qso: Record<string, JSONValue>, settings: ExportSettings): Record<string, JSONValue>;
+export declare function prepareExportOption(option: ExportOption & {
+	exportSettings: ExportSettings;
+}, operation: Record<string, JSONValue>, qsos: Record<string, JSONValue>[], compact: boolean): ExportOption & {
+	exportSettings: ExportSettings;
+	exportTitle: string;
+	exportData: Record<string, JSONValue>;
+};
+export type RefTransform = {
+	pattern: string;
+	replacement: string;
+	flags?: string;
+};
+export declare function transformsForPrefix(prefix: string): RefTransform[];
 export interface ReferenceActivityConfig {
 	key: string;
 	label: string;
@@ -1254,7 +1369,20 @@ export interface ReferenceActivityConfig {
 	adifRefField?: string;
 	allowsMultiple?: boolean;
 	linkUrl?: (reference: string) => string;
+	transforms?: RefTransform[];
+	refInput?: (args: RefInputArgs, ctx: HookContext) => Promise<RefInputExtras> | RefInputExtras;
+}
+export interface RefInputArgs {
+	operation: Record<string, JSONValue>;
+	qso?: Record<string, JSONValue>;
+	side: "activation" | "hunting";
+}
+export interface RefInputExtras {
+	placeholder?: string;
+	transforms?: RefTransform[];
 }
+export declare function learnedReferencePrefix(category: string, entityPrefix: string, fallback: string): Promise<string>;
+export declare function looksLikeReference(text: string, referenceRegex: RegExp): boolean;
 export interface ReferenceActivityHooks {
 	refHandler: Record<string, unknown>;
 	activityHook: Record<string, unknown>;

package/dist/index.js

@@ -1,17 +1,20 @@
-export * from "./types";
-export * from "./i18n";
-export * from "./dxcc";
-export * from "./location";
-export * from "./modes";
-export * from "./scoring";
-export * from "./activityScoring";
-export * from "./activityExports";
-export * from "./activityAdifImport";
-export * from "./exportNames";
-export * from "./referenceActivity";
-export * from "./templates";
-export * from "./templateContext";
-export * from "./testOperation";
+export * from "./types.js";
+export * from "./i18n.js";
+export * from "./dxcc.js";
+export * from "./location.js";
+export * from "./modes.js";
+export * from "./scoring.js";
+export * from "./segments.js";
+export * from "./activityScoring.js";
+export * from "./activityExports.js";
+export * from "./activityAdifImport.js";
+export * from "./exportNames.js";
+export * from "./exportSettings.js";
+export * from "./referenceActivity.js";
+export * from "./refTransforms.js";
+export * from "./templates.js";
+export * from "./templateContext.js";
+export * from "./testOperation.js";
 let currentExtensionKey = "unknown";
 const privilegedHostCalls = {};
 function kernel() {

package/dist/modes.js

@@ -22,7 +22,27 @@ function modesMatchForDupe(worked, candidate) {
   const superMode = COARSE_SUPER_MODES[c];
   return Boolean(superMode) && KNOWN_MODES.has(w) && superModeForMode(w) === superMode;
 }
+const LSB_BANDS = /* @__PURE__ */ new Set(["2190m", "2200m", "630m", "560m", "160m", "80m", "75m", "40m"]);
+const UPPER_SIDEBAND_FLOOR_KHZ = 9e3;
+const SIXTY_METRE_LO_KHZ = 5e3;
+const SIXTY_METRE_HI_KHZ = 6e3;
+function expectedSideband({ freqKHz, band }) {
+  if (freqKHz != null) {
+    if (freqKHz >= UPPER_SIDEBAND_FLOOR_KHZ) return "USB";
+    return freqKHz >= SIXTY_METRE_LO_KHZ && freqKHz < SIXTY_METRE_HI_KHZ ? "USB" : "LSB";
+  }
+  if (!band) return void 0;
+  return LSB_BANDS.has(band) ? "LSB" : "USB";
+}
+function isUnexpectedSideband(mode, { freqKHz, band }) {
+  const upper = (mode ?? "").toUpperCase();
+  if (upper !== "USB" && upper !== "LSB") return false;
+  const expected = expectedSideband({ freqKHz, band });
+  return expected !== void 0 && upper !== expected;
+}
 export {
   canonicalMode,
+  expectedSideband,
+  isUnexpectedSideband,
   modesMatchForDupe
 };

package/dist/refTransforms.js

@@ -0,0 +1,34 @@
+function transformsForPrefix(prefix) {
+  return [
+    // a run of spaces between two refs -> ", " (normalize to one separator style)
+    { pattern: "([A-Z0-9]-\\d+|TEST) +(?=[A-Z0-9])", replacement: "${1}, ", flags: "gi" },
+    // bare number (or "TEST"), at the start or right after a separator -> prefix-number
+    // (the separator itself is captured and replayed, not consumed, so a
+    // pasted "US-1234,5678" keeps its comma instead of merging into one ref).
+    // Braced `${1}`/`${2}`, not bare `$1`/`$2` — `prefix` can itself start
+    // with a digit (e.g. DXCC "3D2" for Fiji), and a bare "$1" immediately
+    // followed by that would misparse as capture group 13.
+    { pattern: "(^|,\\s*)(\\d\\d+|TEST)", replacement: `\${1}${prefix}-\${2}`, flags: "gi" },
+    // "US1234" -> "US-1234". Anchored with a negative lookbehind so it only
+    // fires at the START of a not-yet-dashed reference — without it, a
+    // multi-character DXCC prefix that mixes letters and digits (e.g.
+    // Fiji's "3D2") gets its OWN internal "D2" mismatched as an undashed
+    // reference once transform 2 above has already inserted "3D2-1234",
+    // corrupting it into "3D-2-1234".
+    { pattern: "(?<![A-Z0-9])([A-Z]+)(\\d+|TEST)", replacement: "${1}-${2}", flags: "gi" },
+    // NOTE: deliberately no "eagerly insert the next prefix right after a
+    // trailing comma" rule here (app-polo's inputs have one) — transform 2
+    // above already prefixes a second reference once 2+ digits appear after
+    // the comma, the same way it does at the start of the field. An eager
+    // version that inserted "US-" the instant a trailing comma appeared
+    // makes deleting back through a second reference impossible: backspacing
+    // "US-1234,US-5678" down to "US-1234,US-" and then to "US-1234," would
+    // immediately re-grow the trailing "US-1234,US-" the transform had just
+    // reinserted, so the comma itself could never be reached.
+    // strip anything that can't appear in a reference list
+    { pattern: "[^A-Z0-9\\-, ]", replacement: "", flags: "gi" }
+  ];
+}
+export {
+  transformsForPrefix
+};

package/dist/referenceActivity.js

@@ -6,9 +6,39 @@ async function hostApi() {
 }
 const NEARBY_DELTA = 1.5;
 const MAX_SUGGESTIONS = 30;
+const learnedPrefixes = /* @__PURE__ */ new Map();
+async function learnedReferencePrefix(category, entityPrefix, fallback) {
+  const cacheKey = `${category}:${entityPrefix}`;
+  const cached = learnedPrefixes.get(cacheKey);
+  if (cached) return cached;
+  const host = await hostApi();
+  let rows = [];
+  try {
+    rows = await host.dbLookupSelectAll(category, "", entityPrefix);
+  } catch (e) {
+    host.log(`${category}: prefix lookup failed for ${entityPrefix}: ${e}`);
+  }
+  const counts = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const prefix = row.key.split("-")[0];
+    if (prefix) counts.set(prefix, (counts.get(prefix) ?? 0) + 1);
+  }
+  let best;
+  for (const [prefix, count] of counts) {
+    if (best === void 0 || count > (counts.get(best) ?? 0)) best = prefix;
+  }
+  if (best === void 0) return fallback;
+  learnedPrefixes.set(cacheKey, best);
+  return best;
+}
 function normalize(ref) {
   return (ref ?? "").toUpperCase().trim();
 }
+function looksLikeReference(text, referenceRegex) {
+  if (referenceRegex.test(text)) return true;
+  if (/\s/.test(text)) return false;
+  return /[0-9]/.test(text) || /[-/]/.test(text);
+}
 function refsOfType(container, type) {
   return (container.refs ?? []).filter((r) => r.type === type && r.ref);
 }
@@ -36,8 +66,22 @@ function referenceActivity(config) {
       return null;
     }
   }
+  function undecorated(ref, reference, name) {
+    return {
+      ...ref,
+      ref: reference,
+      name,
+      program,
+      label: void 0,
+      shortLabel: void 0,
+      grid: void 0,
+      lat: void 0,
+      lon: void 0,
+      location: void 0
+    };
+  }
   function decorate(ref, reference, row, unknown) {
-    if (!row?.name) return { ...ref, ref: reference, name: unknown, program };
+    if (!row?.name) return undecorated(ref, reference, unknown);
     const data = row.data ?? {};
     return {
       ...ref,
@@ -52,6 +96,16 @@ function referenceActivity(config) {
       shortLabel: `${config.label} ${reference}`
     };
   }
+  async function refListInput(refType, args, ctx) {
+    const extras = config.refInput ? await config.refInput(args, ctx) : {};
+    return {
+      kind: "refList",
+      refType,
+      placeholder: extras.placeholder ?? config.placeholder,
+      pattern: config.referenceRegex.source,
+      transforms: extras.transforms ?? config.transforms
+    };
+  }
   const refHandler = {
     async validateRef({ ref }, _ctx) {
       const normalized = normalize(ref.ref);
@@ -61,7 +115,7 @@ function referenceActivity(config) {
       const t = config.tFor(ctx);
       const reference = normalize(ref.ref);
       if (!config.referenceRegex.test(reference)) {
-        return { ...ref, ref: reference, name: t("invalidReference") };
+        return undecorated(ref, reference, t("invalidReference"));
       }
       return decorate(ref, reference, await lookupReference(reference), t("unknownReference"));
     },
@@ -97,7 +151,7 @@ function referenceActivity(config) {
     }
   };
   const activityHook = {
-    async operationControls(_args, ctx) {
+    async operationControls({ operation }, ctx) {
       return [
         {
           key: `${config.key}/activation`,
@@ -107,12 +161,7 @@ function referenceActivity(config) {
           order: 10,
           optionType: "optional",
           allowsMultiple,
-          input: {
-            kind: "refList",
-            refType: config.activationType,
-            placeholder: config.placeholder,
-            pattern: config.referenceRegex.source
-          }
+          input: await refListInput(config.activationType, { operation, side: "activation" }, ctx)
         }
       ];
     },
@@ -122,7 +171,7 @@ function referenceActivity(config) {
     // on whether the operation is activating — both write the same hunting
     // refs, and POTA's HaLo port already settled on the single control.
     ...config.huntingType ? {
-      async loggingControls(_args, ctx) {
+      async loggingControls({ operation, qso }, ctx) {
         return [
           {
             key: `${config.key}/hunter`,
@@ -132,17 +181,12 @@ function referenceActivity(config) {
             order: 10,
             optionType: "optional",
             allowsMultiple: true,
-            input: {
-              kind: "refList",
-              refType: config.huntingType,
-              placeholder: config.placeholder,
-              pattern: config.referenceRegex.source
-            }
+            input: await refListInput(config.huntingType, { operation, qso, side: "hunting" }, ctx)
           }
         ];
       }
     } : {},
-    async suggest({ location, searchTerm }, _ctx) {
+    async suggest({ location, searchTerm, scoped }, ctx) {
       const host = await hostApi();
       const rows = searchTerm ? await host.dbLookupSelectAll(category, searchTerm) : location ? await host.dbLookupSelectByLocation(category, location.lat, location.lon, NEARBY_DELTA) : [];
       const withDistance = rows.map((row) => ({
@@ -152,7 +196,7 @@ function referenceActivity(config) {
       if (!searchTerm) {
         withDistance.sort((a, b) => (a.distance ?? Infinity) - (b.distance ?? Infinity));
       }
-      return withDistance.slice(0, MAX_SUGGESTIONS).map(({ row, distance }) => {
+      const suggestions = withDistance.slice(0, MAX_SUGGESTIONS).map(({ row, distance }) => {
         const data = row.data ?? {};
         return {
           type: config.activationType,
@@ -170,6 +214,31 @@ function referenceActivity(config) {
           allowsMultiple
         };
       });
+      const typed = scoped ? normalize(searchTerm) : "";
+      if (typed && looksLikeReference(typed, config.referenceRegex) && !suggestions.some((s) => s.ref === typed)) {
+        const t = config.tFor(ctx);
+        const valid = config.referenceRegex.test(typed);
+        const row = valid ? await lookupReference(typed) : null;
+        const data = row?.data ?? {};
+        const name = row?.name || (valid ? t("unknownReference") : t("invalidReference"));
+        if (suggestions.length >= MAX_SUGGESTIONS) suggestions.pop();
+        suggestions.unshift({
+          type: config.activationType,
+          ref: typed,
+          name,
+          grid: data.grid,
+          lat: row?.lat,
+          lon: row?.lon,
+          location: data.location,
+          program,
+          label: `${config.label} ${typed}: ${name}`,
+          shortLabel: `${config.label} ${typed}`,
+          distance: void 0,
+          relevance: 1,
+          allowsMultiple
+        });
+      }
+      return suggestions;
     }
   };
   function activationFields(operation) {
@@ -222,5 +291,7 @@ function referenceActivity(config) {
   return { refHandler, activityHook, adifFieldsHook, adifImportHook };
 }
 export {
+  learnedReferencePrefix,
+  looksLikeReference,
   referenceActivity
 };

package/dist/scoring.js

@@ -16,6 +16,9 @@ function startAtMillisOf(qso) {
   const at = qso.startAtMillis;
   return typeof at === "number" ? at : 0;
 }
+function candidateAsOfNow(qso) {
+  return typeof qso.startAtMillis === "number" ? qso : { ...qso, startAtMillis: Date.now() };
+}
 function contestScorer(scorer, options = {}) {
   const scope = options.scope ?? "always";
   const scopedRefTypes = typeof scope === "object" && Array.isArray(scope.refTypes) ? scope.refTypes : void 0;
@@ -118,10 +121,10 @@ function contestScorer(scorer, options = {}) {
     async scoreQso(args, ctx) {
       const sheet = await liveScoresheet(args, ctx, args.excludeUuid);
       const { score } = scorer.scoreQso(
-        { scoresheet: sheet, qso: args.qso, operation: args.operation, ref: args.ref, isNewDay: false },
+        { scoresheet: sheet, qso: candidateAsOfNow(args.qso), operation: args.operation, ref: args.ref, isNewDay: false },
         ctx
       );
-      return { notices: score.notices ?? [], alerts: score.alerts ?? [] };
+      return { notices: score.notices ?? [], alerts: score.alerts ?? [], ...score.dupe !== void 0 && { dupe: score.dupe } };
     },
     /// The same live judgement as `scoreQso`, for many candidates at once —
     /// the Spots Panel annotating every spot on screen. The log is folded ONCE
@@ -141,14 +144,18 @@ function contestScorer(scorer, options = {}) {
         const { score } = scorer.scoreQso(
           {
             scoresheet: copyCheckpoint(base),
-            qso: candidate.qso,
+            qso: candidateAsOfNow(candidate.qso),
             operation: args.operation,
             ref: args.ref,
             isNewDay: false
           },
           ctx
         );
-        result[candidate.key] = { notices: score.notices ?? [], alerts: score.alerts ?? [] };
+        result[candidate.key] = {
+          notices: score.notices ?? [],
+          alerts: score.alerts ?? [],
+          ...score.dupe !== void 0 && { dupe: score.dupe }
+        };
       }
       return result;
     }

package/dist/segments.js

@@ -0,0 +1,17 @@
+function operationForQso(base, qso, segments) {
+  if (!segments || segments.length === 0) return base;
+  const at = typeof qso.startAtMillis === "number" ? qso.startAtMillis : 0;
+  let effective = base;
+  for (const segment of segments) {
+    if (segment.fromMillis > at) break;
+    effective = segment.operation;
+  }
+  return effective;
+}
+function segmentsWith(segments, transform) {
+  return segments?.map((segment) => ({ ...segment, operation: transform(segment.operation) }));
+}
+export {
+  operationForQso,
+  segmentsWith
+};

package/dist/templateContext.js

@@ -26,6 +26,10 @@ function opValues(operation, extra = {}) {
   return {
     ...atMillis > 0 ? dateValues(atMillis) : { date: "", dateCompact: "", time: "", at: "" },
     station,
+    // `call` says the same thing, for symmetry with `qso.call` — the name an
+    // operator writing a CW message reaches for first; without it,
+    // `{{ op.call }}` renders empty with nothing to say why.
+    call: station,
     // Deduped, like halo_core's `Operation.stationCalls`: "N0DEV, N0DEV" is a
     // typo, and a template fanning out over this would otherwise repeat
     // itself once per typo.