@ham2k/extension-sdk 0.2.0 → 0.3.0

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Sebastian Delmont <sd@ham2k.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -67,7 +67,3 @@ in, so your editor works with only this package installed.
 
 Install one only to `inline` it — to ship your own copy because you need a
 version the host does not carry.
-
-## License
-
-MPL-2.0

package/dist/activityExports.js

@@ -1,4 +1,5 @@
 import { exportFilename, startMillisOf } from "./exportNames.js";
+import { segmentsWith } from "./segments.js";
 import { createCachedTranslator } from "./i18n.js";
 import en from "./i18n/activityExports.en.json";
 import es from "./i18n/activityExports.es.json";
@@ -50,13 +51,16 @@ function activityExportHook(rules) {
       if (!refsOfType(args.operation, rules.activationType).some((r) => r.ref === wanted)) {
         throw new Error(`${rules.key}: operation has no ${rules.activationType} reference '${wanted}'`);
       }
-      const refs = (args.operation.refs ?? []).filter(
-        (r) => r?.type !== rules.activationType || r?.ref === wanted
-      );
-      const operation = { ...args.operation, refs };
+      const claimOnly = (operation) => ({
+        ...operation,
+        refs: (operation.refs ?? []).filter(
+          (r) => r?.type !== rules.activationType || r?.ref === wanted
+        )
+      });
       const content = await adifForExport({
-        operation,
+        operation: claimOnly(args.operation),
         qsos: args.qsos,
+        segments: segmentsWith(args.segments, claimOnly),
         includePrivateData: args.includePrivateData,
         mainHandler: rules.key,
         includeFieldsFrom: rules.includeFieldsFrom
@@ -113,6 +117,7 @@ function huntingExportHook(rules) {
       const content = await adifForExport({
         operation: args.operation,
         qsos: huntedQsos(args.qsos ?? []),
+        segments: args.segments,
         includePrivateData: args.includePrivateData,
         // The hunter file is submitted to ONE program too — see
         // `activityExportHook.generateExport`. `rules.key` is the ACTIVITY's
@@ -131,11 +136,12 @@ function huntingExportHook(rules) {
     }
   };
 }
-async function adifForExport({ operation, qsos, includePrivateData, mainHandler, includeFieldsFrom }) {
+async function adifForExport({ operation, qsos, segments, includePrivateData, mainHandler, includeFieldsFrom }) {
   const { hooks } = await import("@ham2k/extension-sdk");
   const entries = await hooks.invokeOne("export", "adif", "generateExport", {
     operation,
     qsos,
+    segments,
     exportType: "adif",
     // Forwarded, or the delegate defaults to withholding and the user's
     // "include private info" setting silently does nothing here.

package/dist/activityScoring.js

@@ -127,6 +127,8 @@ function activityScorer(rules) {
         score.alerts = ["duplicate"];
       } else if (verdict) {
         score.notices = [NOTICE_KEYS[verdict]];
+      } else if (priors.length > 0 && score.value > 0 && freshRefRescuesActivation) {
+        score.dupe = false;
       }
       const packed = packContact(day, band, mode, huntedRefs);
       if (priors.length > 0) priors.push(packed);

package/dist/dxcc.js

@@ -2,8 +2,8 @@ import { parseCallsign } from "@ham2k/lib-callsigns";
 import { annotateFromCountryFile, useBuiltinCountryFile } from "@ham2k/lib-country-files";
 import { DXCC_BY_CODE } from "@ham2k/lib-dxcc-data";
 useBuiltinCountryFile();
-function annotateCallAgainstCountryFile(call) {
-  return annotateFromCountryFile(parseCallsign(call));
+function annotateCallAgainstCountryFile(call, options) {
+  return annotateFromCountryFile(parseCallsign(call), options);
 }
 function entityPrefixForCall(call) {
   if (!call) return void 0;
@@ -17,8 +17,21 @@ function regionAndCountryForDxccCode(dxccCode) {
   const entity = DXCC_BY_CODE[dxccCode];
   return { ituRegion: entity?.ituRegion, countryCode: entity?.countryCode };
 }
+function countryPrefixForCall(call) {
+  if (!call) return void 0;
+  const annotated = annotateCallAgainstCountryFile(call);
+  const { countryCode } = regionAndCountryForDxccCode(annotated.dxccCode);
+  return countryCode ? countryCode.toUpperCase() : annotated.entityPrefix;
+}
+function entityForCall(call) {
+  if (!call) return {};
+  const { dxccCode, continent, entityName } = annotateCallAgainstCountryFile(call);
+  return { dxccCode, continent, entityName };
+}
 export {
   annotateCallAgainstCountryFile,
+  countryPrefixForCall,
+  entityForCall,
   entityPrefixForCall,
   flagForDxccCode,
   regionAndCountryForDxccCode

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-// @ham2k/extension-sdk 0.2.0
+// @ham2k/extension-sdk 0.3.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;
@@ -380,6 +391,7 @@ export interface AdifImportHook {
 export interface ExportRequest {
 	operation: Record<string, JSONValue>;
 	qsos: Record<string, JSONValue>[];
+	segments?: OperationSegmentPayload[];
 	exportType?: string;
 	compactFilenames?: boolean;
 	includePrivateData?: boolean;
@@ -464,6 +476,7 @@ export interface ScoreQsoRequest {
 export interface QsoScoreNotices {
 	notices: string[];
 	alerts: string[];
+	dupe?: boolean;
 }
 export interface ScoreCandidatesRequest {
 	operation: Record<string, JSONValue>;
@@ -517,6 +530,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 +557,10 @@ export interface CommandAction {
 		operatorCall?: string;
 		multiIdentifier?: string;
 	};
+	markSegment?: {
+		kind: "start" | "break" | "stop";
+		setLocation?: boolean;
+	};
 	setCallField?: {
 		text: string;
 	};
@@ -575,6 +596,9 @@ export interface CommandAction {
 		deltaMillis?: number;
 		speed?: number;
 	};
+	devBench?: {
+		qsoCount?: number;
+	};
 	toggleExperiment?: {
 		token: string;
 	};
@@ -723,6 +747,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 +771,7 @@ export interface ExtensionManifest {
 	allowUserAgentOverride?: boolean;
 	requiresLocation?: boolean;
 	experiments?: string[];
+	relevance?: ExtensionRelevance;
 	translations?: Record<string, {
 		name?: string;
 		description?: string;
@@ -883,7 +916,7 @@ export interface FormHeader {
 	title: string;
 	subtitle?: string;
 	devMode?: boolean;
-	style?: "default" | "section";
+	style?: "default" | "section" | "category";
 	environment?: string | string[];
 }
 export interface FormSectionDivider {
@@ -1129,13 +1162,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 +1186,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 +1201,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;
@@ -1210,9 +1257,10 @@ export declare function huntingExportHook(rules: HuntingExportRules): {
 	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, mainHandler, includeFieldsFrom }: {
 	operation: Record<string, JSONValue>;
 	qsos: Record<string, JSONValue>[];
+	segments?: OperationSegmentPayload[];
 	includePrivateData?: boolean;
 	mainHandler: string;
 	includeFieldsFrom?: string[];
@@ -1236,6 +1284,12 @@ 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 type RefTransform = {
+	pattern: string;
+	replacement: string;
+	flags?: string;
+};
+export declare function transformsForPrefix(prefix: string): RefTransform[];
 export interface ReferenceActivityConfig {
 	key: string;
 	label: string;
@@ -1254,7 +1308,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,19 @@
-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 "./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
+};