@tx5dr/plugin-api 2.0.0 → 2.5.0

package/dist/toolkit/contest/ContestLogbook.js

@@ -0,0 +1,845 @@
+import { getBandFromFrequency } from '@tx5dr/core';
+import { defaultContestSession } from './DefaultContestSession.js';
+import { defaultContestWorkbench } from './DefaultContestWorkbench.js';
+import { formatFT8ContestSubmission, projectFT8ContestQsos, scoreFT8ContestQsos } from './FT8ContestDefinition.js';
+import { createContestQsoEnvelopeAdapter } from './ContestQsoEnvelopeAdapter.js';
+import { maidenheadDistanceKm } from './FT8ContestModules.js';
+import { CONTEST_WORKBENCH_ACTIONS } from './DefaultContestWorkbench.js';
+export const CONTEST_LOGBOOK_PERMISSIONS = [
+    'logbook:session',
+    'plugin:event-bus',
+];
+export const DEFAULT_CONTEST_LOGBOOK_PAGE_ID = 'contest-log';
+export const DEFAULT_CONTEST_LOGBOOK_PANEL_ID = 'contest-log';
+export const DEFAULT_CONTEST_LOGBOOK_ENTRY = 'contest-log.html';
+function mergeArrayById(first, second) {
+    const result = [];
+    const positions = new Map();
+    for (const item of [...first ?? [], ...second ?? []]) {
+        const existing = positions.get(item.id);
+        if (existing === undefined) {
+            positions.set(item.id, result.length);
+            result.push(item);
+        }
+        else {
+            result[existing] = item;
+        }
+    }
+    return result.length > 0 ? result : undefined;
+}
+function createImportToken() {
+    const randomUUID = globalThis.crypto?.randomUUID;
+    if (randomUUID)
+        return randomUUID.call(globalThis.crypto);
+    return `contest-import-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+}
+function defaultContestLogbookStateView(contest, health) {
+    return {
+        schemaVersion: 1,
+        contest: {
+            id: contest.id,
+            editionId: contest.edition?.id ?? '',
+            rulesetVersion: contest.rulesetVersion ?? '',
+        },
+        health,
+        settings: { value: {}, valid: true, issues: [] },
+        score: { claimedScore: 0, qsoPoints: 0, multiplierCount: 0 },
+        qsos: [],
+        review: { pendingCount: 0, issues: [] },
+        import: { state: 'idle' },
+        export: { formats: [] },
+    };
+}
+function resolveQsoBand(record) {
+    const band = getBandFromFrequency(record.frequency);
+    return band === 'Unknown' ? undefined : band.toUpperCase();
+}
+function adifField(name, value) {
+    return `<${name}:${value.length}>${value}`;
+}
+function formatADIFDate(value) {
+    const date = new Date(value);
+    return `${date.getUTCFullYear()}${String(date.getUTCMonth() + 1).padStart(2, '0')}${String(date.getUTCDate()).padStart(2, '0')}`;
+}
+function formatADIFTime(value) {
+    const date = new Date(value);
+    return `${String(date.getUTCHours()).padStart(2, '0')}${String(date.getUTCMinutes()).padStart(2, '0')}${String(date.getUTCSeconds()).padStart(2, '0')}`;
+}
+function parseADIFFields(record) {
+    const fields = {};
+    const pattern = /<([^:>]+):(\d+)(?::[^>]*)?>/gi;
+    let match;
+    while ((match = pattern.exec(record)) !== null) {
+        const length = Number.parseInt(match[2], 10);
+        const start = match.index + match[0].length;
+        fields[match[1].trim().toLowerCase()] = record.slice(start, start + length);
+    }
+    return fields;
+}
+function splitADIFRecords(content) {
+    const bodyStart = content.search(/<eoh>/i);
+    const body = bodyStart >= 0 ? content.slice(bodyStart + 5) : content;
+    return body.split(/<eor>/i).map((value) => value.trim()).filter(Boolean);
+}
+function parseADIFDateTime(dateStr, timeStr) {
+    const date = dateStr.trim();
+    const time = timeStr.trim().padEnd(6, '0');
+    const year = Number.parseInt(date.slice(0, 4), 10);
+    const month = Number.parseInt(date.slice(4, 6), 10) - 1;
+    const day = Number.parseInt(date.slice(6, 8), 10);
+    const hour = Number.parseInt(time.slice(0, 2), 10);
+    const minute = Number.parseInt(time.slice(2, 4), 10);
+    const second = Number.parseInt(time.slice(4, 6), 10);
+    return Date.UTC(year, month, day, hour, minute, second);
+}
+function generateADIFFile(records, options) {
+    const lines = [`<adif_ver:3>3.1<EOR>`];
+    if (options.programId)
+        lines.push(adifField('programid', options.programId));
+    lines.push('<eoh>');
+    for (const qso of records) {
+        const fields = [];
+        fields.push(adifField('qso_date', formatADIFDate(qso.startTime)));
+        fields.push(adifField('time_on', formatADIFTime(qso.startTime)));
+        fields.push(adifField('freq', (qso.frequency / 1_000_000).toFixed(6)));
+        const band = getBandFromFrequency(qso.frequency).toUpperCase();
+        if (band && band !== 'UNKNOWN')
+            fields.push(adifField('band', band));
+        const mode = qso.mode.trim().toUpperCase();
+        if (mode)
+            fields.push(adifField('mode', mode));
+        if (qso.submode)
+            fields.push(adifField('submode', qso.submode.trim().toUpperCase()));
+        if (qso.grid)
+            fields.push(adifField('gridsquare', qso.grid.trim().toUpperCase().slice(0, 4)));
+        if (qso.contestId)
+            fields.push(adifField('contest_id', qso.contestId));
+        if (qso.contestEntry)
+            fields.push(adifField('app_tx5dr_contest_entry', JSON.stringify(qso.contestEntry)));
+        if (options.includeStationCallsign && qso.myCallsign)
+            fields.push(adifField('station_callsign', qso.myCallsign.trim().toUpperCase()));
+        if (qso.myGrid)
+            fields.push(adifField('my_gridsquare', qso.myGrid.trim().toUpperCase().slice(0, 4)));
+        if (qso.reportSent)
+            fields.push(adifField('rst_sent', qso.reportSent));
+        if (qso.reportReceived)
+            fields.push(adifField('rst_rcvd', qso.reportReceived));
+        if (qso.comment)
+            fields.push(adifField('comment', qso.comment));
+        lines.push(`${fields.join('')}<eor>`);
+    }
+    return lines.join('\r\n') + '\r\n';
+}
+function modeOf(record) {
+    const mode = record.mode.trim().toUpperCase();
+    const submode = record.submode?.trim().toUpperCase();
+    if (mode === 'FT8' || submode === 'FT8')
+        return 'FT8';
+    if (mode === 'FT4' || submode === 'FT4')
+        return 'FT4';
+    return undefined;
+}
+/**
+ * Standard FT8/FT4 record projector that extracts the fields common contest
+ * plugins repeatedly need for logbook displays and score summaries.
+ */
+export function standardFT8ContestQsoAdapter(options = {}) {
+    return (record) => {
+        const band = resolveQsoBand(record);
+        const mode = modeOf(record);
+        if (!band || !mode)
+            return null;
+        const operatorGrid = options.operatorGrid?.(record)?.trim().toUpperCase().slice(0, 4)
+            ?? record.myGrid?.trim().toUpperCase().slice(0, 4);
+        const receivedExchange = options.receivedExchange?.(record)?.trim().toUpperCase().slice(0, 4)
+            ?? record.grid?.trim().toUpperCase().slice(0, 4);
+        const sentExchange = options.sentExchange?.(record)?.trim().toUpperCase().slice(0, 4)
+            ?? record.myGrid?.trim().toUpperCase().slice(0, 4);
+        const fields = {
+            frequencyHz: Math.round(record.frequency),
+            operatorCallsign: record.myCallsign?.trim().toUpperCase(),
+            operatorGrid,
+            sentExchange,
+            receivedExchange,
+            distanceKm: operatorGrid && receivedExchange && /^[A-R]{2}[0-9]{2}$/.test(operatorGrid) && /^[A-R]{2}[0-9]{2}$/.test(receivedExchange)
+                ? maidenheadDistanceKm(operatorGrid, receivedExchange)
+                : undefined,
+        };
+        return {
+            id: record.id,
+            callsign: record.callsign.trim().toUpperCase(),
+            band,
+            mode,
+            time: record.startTime,
+            status: record.contestEntry?.annotations?.status === 'excluded'
+                ? 'excluded'
+                : record.contestEntry?.annotations?.status === 'review'
+                    ? 'review'
+                    : 'included',
+            fields: fields,
+            ...fields,
+        };
+    };
+}
+export function officialContestExporter(contest, options) {
+    return {
+        id: contest.submission.id,
+        label: contest.submission.id,
+        extension: contest.submission.extension,
+        mediaType: contest.submission.mediaType,
+        format(records) {
+            return formatFT8ContestSubmission(contest, records, options);
+        },
+    };
+}
+export function adifContestExporter(options = {}) {
+    return {
+        id: options.id ?? 'adif',
+        label: options.label ?? 'ADIF',
+        extension: options.extension ?? '.adi',
+        mediaType: options.mediaType ?? 'text/plain',
+        format(records) {
+            return generateADIFFile(records, {
+                programId: 'TX5DR-CONTEST-LOGBOOK',
+                includeStationCallsign: options.includeStationCallsign ?? true,
+            });
+        },
+    };
+}
+export function adifContestImporter(options) {
+    return {
+        id: options.id ?? 'adif',
+        label: options.label ?? 'ADIF',
+        extension: options.extension ?? '.adi',
+        mediaType: options.mediaType ?? 'text/plain',
+        accept: options.accept ?? ['.adi', '.adif', 'text/plain'],
+        preview: options.preview,
+        commit: options.commit,
+        cancel: options.cancel,
+    };
+}
+/**
+ * Generic ADIF parse helper for contest logbooks. Contest plugins still own
+ * their validation rules through the callbacks they pass in.
+ */
+export function parseContestAdifContent(content) {
+    return splitADIFRecords(content).map((record, index) => {
+        const fields = parseADIFFields(record);
+        const date = fields.qso_date ?? fields.qso_date_off;
+        const time = fields.time_on ?? fields.time_off;
+        if (!date || !time || !fields.call)
+            return null;
+        return {
+            id: fields.qso_id ?? `contest-adif-${index}`,
+            callsign: fields.call.trim().toUpperCase(),
+            grid: fields.gridsquare?.trim().toUpperCase().slice(0, 4),
+            frequency: Number.parseFloat(fields.freq ?? '0') * 1_000_000,
+            mode: fields.mode?.trim().toUpperCase() ?? 'FT8',
+            submode: fields.submode?.trim().toUpperCase(),
+            startTime: parseADIFDateTime(date, time),
+            messageHistory: [],
+            comment: fields.comment,
+            contestId: fields.contest_id,
+            myCallsign: fields.station_callsign?.trim().toUpperCase(),
+            myGrid: fields.my_gridsquare?.trim().toUpperCase().slice(0, 4),
+        };
+    }).filter((record) => record !== null);
+}
+export function projectContestLogbookRows(contest, records) {
+    return projectFT8ContestQsos(contest, records).map((row) => ({
+        id: String(row.qso.id ?? `${row.qso.callsign}-${row.qso.startTime}`),
+        callsign: row.qso.callsign,
+        band: row.qso.band,
+        mode: row.qso.mode,
+        time: row.qso.startTime,
+        status: row.qso.status === 'review'
+            ? 'review'
+            : row.qso.status === 'excluded'
+                ? 'excluded'
+                : row.qso.status === 'x-qso'
+                    ? 'x-qso'
+                    : 'included',
+        fields: {
+            eligible: row.scoreEligible,
+            submissionEligible: row.submissionEligible,
+            dupe: row.dupe,
+            issues: row.issues,
+        },
+        sentExchange: undefined,
+        receivedExchange: undefined,
+        operatorCallsign: undefined,
+        operatorGrid: undefined,
+        distanceKm: undefined,
+    }));
+}
+export function summarizeContestLogbookScore(contest, records) {
+    return scoreFT8ContestQsos(contest, records);
+}
+export function renderOfficialContestSubmission(contest, records, options) {
+    return formatFT8ContestSubmission(contest, records, options);
+}
+export function defaultContestLogbook(options) {
+    const { contest, adapter } = options;
+    const activeContests = new Map();
+    const messagePresentations = new Map();
+    const pageId = options.pageId
+        ?? (options.ui !== false ? options.ui?.pageId : undefined)
+        ?? DEFAULT_CONTEST_LOGBOOK_PAGE_ID;
+    const uiOptions = options.ui === false ? undefined : options.ui ?? {};
+    const defaultPage = uiOptions ? {
+        id: pageId,
+        title: uiOptions.title ?? 'contestLogTitle',
+        entry: uiOptions.entry ?? DEFAULT_CONTEST_LOGBOOK_ENTRY,
+        icon: uiOptions.icon,
+        accessScope: 'operator',
+        resourceBinding: 'operator',
+    } : undefined;
+    const defaultPanel = uiOptions ? {
+        id: uiOptions.panelId ?? DEFAULT_CONTEST_LOGBOOK_PANEL_ID,
+        title: uiOptions.title ?? 'contestLogTitle',
+        component: 'iframe',
+        pageId,
+        slot: 'operator-action',
+        openMode: 'page',
+        icon: uiOptions.icon ?? 'file-lines',
+    } : undefined;
+    const customPages = options.ui === false ? [] : adapter.ui?.pages ?? [];
+    const customPanels = options.ui === false ? [] : adapter.panels ?? [];
+    const pages = mergeArrayById(defaultPage ? [defaultPage] : undefined, customPages);
+    const panels = mergeArrayById(defaultPanel ? [defaultPanel] : undefined, customPanels);
+    const sessionBase = defaultContestSession({
+        create: (_contest, context) => adapter.settings.seed(_contest, context),
+        sessionKey: options.sessionKey,
+        stateKey: options.stateKey,
+        title: adapter.settings.title,
+    });
+    const sessionReady = new Map();
+    const sessionCleanups = new Map();
+    const refreshMessagePresentation = async (operatorId, context, effectiveContest, records) => {
+        if (!adapter.messagePresentation)
+            return;
+        try {
+            const snapshotRecords = records ?? (await sessionBase.access(context).snapshot()).records;
+            const projection = adapter.messagePresentation(effectiveContest, context, snapshotRecords);
+            if (projection)
+                messagePresentations.set(operatorId, projection);
+            else
+                messagePresentations.delete(operatorId);
+        }
+        catch (error) {
+            context.log.debug('Contest message presentation refresh failed', {
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    };
+    const session = {
+        id: sessionBase.id,
+        async setup(input) {
+            const effectiveContest = options.resolveContest?.(input.context) ?? input.contest;
+            activeContests.set(input.context.operator.id, effectiveContest);
+            let resolveReady;
+            let rejectReady;
+            const ready = new Promise((resolve, reject) => {
+                resolveReady = resolve;
+                rejectReady = reject;
+            });
+            sessionReady.set(input.context.operator.id, ready);
+            const initialize = async (signal) => {
+                if (signal?.aborted) {
+                    resolveReady();
+                    return;
+                }
+                try {
+                    const cleanup = await sessionBase.setup({ ...input, contest: effectiveContest });
+                    sessionCleanups.set(input.context.operator.id, cleanup ?? undefined);
+                    await refreshMessagePresentation(input.context.operator.id, input.context, effectiveContest);
+                    resolveReady();
+                }
+                catch (error) {
+                    rejectReady(error);
+                    throw error;
+                }
+            };
+            let cancelDeferred;
+            if (options.deferStartup && input.context.lifecycle) {
+                cancelDeferred = input.context.lifecycle.scheduleAfterStartup(`contest-logbook:${input.context.operator.id}`, (signal) => initialize(signal));
+            }
+            else {
+                await initialize();
+            }
+            return async (context) => {
+                try {
+                    cancelDeferred?.();
+                    resolveReady();
+                    await ready.catch(() => undefined);
+                    await sessionCleanups.get(context.operator.id)?.(context);
+                }
+                finally {
+                    sessionCleanups.delete(context.operator.id);
+                    sessionReady.delete(context.operator.id);
+                    activeContests.delete(context.operator.id);
+                    messagePresentations.delete(context.operator.id);
+                }
+            };
+        },
+    };
+    const workbench = defaultContestWorkbench({
+        pageId,
+        getState: async ({ contest: currentContest, context }) => {
+            const effectiveContest = activeContests.get(context.operator.id) ?? currentContest;
+            await sessionReady.get(context.operator.id);
+            const sessionState = sessionBase.forOperator(context.operator.id).read();
+            const snapshot = await sessionBase.access(context).snapshot();
+            await refreshMessagePresentation(context.operator.id, context, effectiveContest, snapshot.records);
+            const state = await adapter.getState(effectiveContest, sessionState, context, snapshot.records);
+            const hostHealth = sessionBase.getHealth(context.operator.id);
+            return {
+                ...state,
+                health: hostHealth.state === 'healthy' ? state.health : hostHealth,
+                settings: {
+                    ...state.settings,
+                    fields: state.settings.fields ?? Object.entries(adapter.settings.settings).map(([key, descriptor]) => ({
+                        key,
+                        label: descriptor.label,
+                        description: descriptor.description,
+                        type: descriptor.type === 'boolean' || descriptor.type === 'number' ? descriptor.type : 'string',
+                        options: descriptor.options,
+                    })),
+                },
+                presentation: state.presentation ?? adapter.presentation,
+            };
+        },
+        decode: adapter.decode,
+        handle: async (request, handlerContext) => {
+            const effectiveContest = activeContests.get(handlerContext.context.operator.id) ?? handlerContext.contest;
+            const result = await adapter.handle(request, effectiveContest, sessionBase.forOperator(handlerContext.context.operator.id).read(), handlerContext.request, sessionBase.access(handlerContext.context), undefined, sessionBase.forOperator(handlerContext.context.operator.id), handlerContext.context);
+            await refreshMessagePresentation(handlerContext.context.operator.id, handlerContext.context, effectiveContest);
+            return result;
+        },
+    });
+    const hooks = {
+        ...adapter.hooks,
+        async onQSOComplete(record, context) {
+            await adapter.hooks?.onQSOComplete?.(record, context);
+            await refreshMessagePresentation(context.operator.id, context, activeContests.get(context.operator.id) ?? contest);
+            try {
+                await sessionBase.access(context).notify('transaction');
+            }
+            catch (error) {
+                if (!(error instanceof Error) || error.message !== 'contest_session_not_open')
+                    throw error;
+                context.log.debug('Contest logbook session is not open during QSO notification');
+            }
+            for (const page of context.ui.listActivePageSessions(pageId)) {
+                context.ui.pushToSession(page.sessionId, 'stateChanged');
+            }
+            context.ui.refreshOperatorProjection();
+        },
+        async onConfigChange(changes, context) {
+            await adapter.hooks?.onConfigChange?.(changes, context);
+            if (options.resolveContest) {
+                const effectiveContest = options.resolveContest(context);
+                activeContests.set(context.operator.id, effectiveContest);
+                await sessionBase.rebind(context.operator.id, effectiveContest, context);
+                await refreshMessagePresentation(context.operator.id, context, effectiveContest);
+            }
+            for (const page of context.ui.listActivePageSessions(pageId)) {
+                context.ui.pushToSession(page.sessionId, 'stateChanged');
+            }
+            context.ui.refreshOperatorProjection();
+        },
+    };
+    void contest;
+    return {
+        settings: adapter.settings.settings,
+        quickSettings: adapter.quickSettings ?? adapter.settings.quickSettings,
+        session,
+        workbench,
+        hooks,
+        panels,
+        ui: options.ui === false ? undefined : pages || adapter.ui || uiOptions ? {
+            dir: uiOptions?.dir ?? adapter.ui?.dir ?? 'ui',
+            pages,
+        } : undefined,
+        getMessagePresentation(operatorId) {
+            return messagePresentations.get(operatorId);
+        },
+        decorateCompletion(effect, context) {
+            const record = adapter.decorateRecord?.(effect.record, contest, context) ?? effect.record;
+            return {
+                ...effect,
+                record,
+                destination: effect.destination ?? sessionBase.getDestination(context.operator.id),
+            };
+        },
+    };
+}
+function standardContestQso(contest, record) {
+    const band = resolveQsoBand(record);
+    const mode = modeOf(record);
+    if (!band || !mode)
+        return null;
+    const entry = record.contestEntry;
+    const sentFields = entry?.sent
+        ?? { grid: record.myGrid?.trim().toUpperCase() ?? '' };
+    const receivedFields = entry?.received
+        ?? { grid: record.grid?.trim().toUpperCase() ?? '' };
+    const sent = contest.exchange.decode(sentFields);
+    const received = contest.exchange.decode(receivedFields);
+    const operatorGrid = record.myGrid?.trim().toUpperCase().slice(0, 4);
+    const receivedGrid = typeof receivedFields.grid === 'string'
+        ? receivedFields.grid.trim().toUpperCase().slice(0, 4)
+        : undefined;
+    const status = entry?.annotations?.status === 'excluded'
+        ? 'excluded'
+        : entry?.annotations?.status === 'x-qso'
+            ? 'x-qso'
+            : entry?.annotations?.status === 'review' || !sent.ok || !received.ok
+                ? 'review'
+                : 'included';
+    return {
+        qsoId: record.id,
+        callsign: record.callsign.trim().toUpperCase(),
+        band,
+        mode,
+        startTime: record.startTime,
+        status,
+        sentExchange: sent.ok ? sent.value : undefined,
+        receivedExchange: received.ok ? received.value : undefined,
+        operatorCallsign: record.myCallsign?.trim().toUpperCase() ?? '',
+        operatorGrid,
+        distanceKm: operatorGrid && receivedGrid
+            ? maidenheadDistanceKm(operatorGrid, receivedGrid)
+            : undefined,
+    };
+}
+function standardContestRecordRow(projected, record) {
+    const qso = projected.qso;
+    return {
+        id: record.id,
+        callsign: qso.callsign,
+        band: qso.band,
+        mode: qso.mode,
+        time: qso.startTime,
+        status: qso.status === 'review' || projected.issues.includes('review')
+            ? 'review'
+            : qso.status === 'excluded'
+                ? 'excluded'
+                : qso.status === 'x-qso'
+                    ? 'x-qso'
+                    : 'included',
+        sentExchange: qso.sentExchange ? JSON.stringify(qso.sentExchange) : undefined,
+        receivedExchange: qso.receivedExchange ? JSON.stringify(qso.receivedExchange) : undefined,
+        operatorCallsign: qso.operatorCallsign,
+        operatorGrid: qso.operatorGrid,
+        distanceKm: qso.distanceKm,
+        fields: {
+            eligible: projected.scoreEligible,
+            submissionEligible: projected.submissionEligible,
+            dupe: projected.dupe,
+            issues: projected.issues,
+        },
+    };
+}
+function gridField(exchange) {
+    if (!exchange || typeof exchange !== 'object')
+        return undefined;
+    const value = exchange.grid;
+    if (typeof value !== 'string')
+        return undefined;
+    const field = value.trim().toUpperCase().slice(0, 2);
+    return /^[A-R]{2}$/.test(field) ? field : undefined;
+}
+function standardContestMessagePresentation(contest, records, project, revision) {
+    const workedByBand = new Map();
+    const workedFieldsByBand = new Map();
+    for (const record of records) {
+        const qso = project(record);
+        if (!qso || qso.status === 'x-qso')
+            continue;
+        const callsign = qso.callsign.trim().toUpperCase();
+        const band = qso.band.trim().toUpperCase();
+        if (!callsign || !band)
+            continue;
+        const worked = workedByBand.get(band) ?? new Set();
+        worked.add(callsign);
+        workedByBand.set(band, worked);
+        const field = gridField(qso.receivedExchange);
+        if (field) {
+            const fields = workedFieldsByBand.get(band) ?? new Set();
+            fields.add(field);
+            workedFieldsByBand.set(band, fields);
+        }
+    }
+    const asRecord = (values) => Object.fromEntries([...values].map(([key, entries]) => [key, [...entries].sort()]));
+    const bandAssignments = [...workedByBand].flatMap(([band, callsigns]) => [...callsigns].map((subject) => ({
+        subject,
+        partition: band,
+        classId: 'contest-worked',
+    })));
+    return {
+        revision,
+        mode: 'replace-logbook',
+        subject: 'sender-callsign',
+        partitionBy: 'band',
+        eligiblePartitions: contest.bands.map((band) => band.toUpperCase()),
+        defaultClass: 'contest-new-call',
+        classes: {
+            'contest-new-field': {
+                badges: [{ label: 'contestNewMultiplier', tone: 'secondary' }],
+                row: { tone: 'secondary', background: 'soft', accent: true },
+                emphasisWhen: [{ firstTokenIn: ['CQ'] }, { anyTokenIn: ['RR73', 'RRR', '73'] }],
+            },
+            'contest-new-call': {
+                badges: [{ label: 'contestNewCallsign', tone: 'warning' }],
+                row: { tone: 'warning', background: 'soft', accent: true },
+                emphasisWhen: [{ firstTokenIn: ['CQ'] }, { anyTokenIn: ['RR73', 'RRR', '73'] }],
+            },
+            'contest-worked': { textDecoration: 'line-through', opacity: 'muted' },
+        },
+        assignments: bandAssignments,
+        noveltyRules: [{
+                fact: 'grid-field-2',
+                knownValuesByPartition: asRecord(workedFieldsByBand),
+                classId: 'contest-new-field',
+            }],
+    };
+}
+function decodeStandardContestAction(action, data) {
+    const payload = data && typeof data === 'object' ? data : {};
+    if (action === CONTEST_WORKBENCH_ACTIONS.saveSettings)
+        return { action, payload };
+    if (action === CONTEST_WORKBENCH_ACTIONS.setQsoStatus) {
+        if (typeof payload.qsoId !== 'string' || !['included', 'review', 'excluded', 'x-qso'].includes(String(payload.status))) {
+            throw new Error('contest_logbook_invalid_qso_status_request');
+        }
+        return { action, payload: { qsoId: payload.qsoId, status: payload.status } };
+    }
+    if (action === CONTEST_WORKBENCH_ACTIONS.previewImport) {
+        if (typeof payload.path !== 'string' || !payload.path.startsWith('imports/'))
+            throw new Error('contest_logbook_invalid_import_path');
+        return { action, payload: { path: payload.path, fileName: typeof payload.fileName === 'string' ? payload.fileName : 'log.adi' } };
+    }
+    if (action === CONTEST_WORKBENCH_ACTIONS.commitImport || action === 'cancel-import') {
+        if (typeof payload.token !== 'string' || !payload.token)
+            throw new Error('contest_logbook_import_token_required');
+        return { action, payload: { token: payload.token } };
+    }
+    if (action === CONTEST_WORKBENCH_ACTIONS.export) {
+        if (typeof payload.formatId !== 'string' || !payload.formatId)
+            throw new Error('contest_logbook_export_format_required');
+        return { action, payload: { formatId: payload.formatId } };
+    }
+    throw new Error(`contest_logbook_unknown_action:${action}`);
+}
+export function standardFT8ContestLogbook(options) {
+    const { contest } = options;
+    const project = (record, context) => (options.projectQso?.(record, context) ?? standardContestQso(contest, record));
+    const envelope = createContestQsoEnvelopeAdapter(contest);
+    const pending = new Map();
+    const settings = options.settings ?? {
+        settings: {},
+        seed: () => ({ schemaVersion: 1, revision: 0, settings: {} }),
+        validate: () => [],
+    };
+    const columns = options.presentation?.columns ?? [
+        { key: 'callsign', label: 'Callsign' },
+        { key: 'band', label: 'Band' },
+        { key: 'mode', label: 'Mode' },
+        { key: 'time', label: 'Time' },
+        { key: 'receivedExchange', label: 'Exchange' },
+    ];
+    const exporters = [
+        adifContestExporter(),
+        officialContestExporter(contest, options.submissionOptions),
+    ];
+    const presentationRevisions = new Map();
+    const adapter = {
+        settings,
+        createQsoEnvelope: envelope,
+        exporters,
+        messagePresentation(currentContest, context, records) {
+            const operatorId = context.operator.id;
+            const revision = (presentationRevisions.get(operatorId) ?? 0) + 1;
+            presentationRevisions.set(operatorId, revision);
+            return standardContestMessagePresentation(currentContest, records, (record) => project(record, context), revision);
+        },
+        presentation: { ...options.presentation, columns },
+        getState(currentContest, session, context, records = []) {
+            const projected = records.flatMap((record) => {
+                const qso = project(record, context);
+                return qso ? [{ record, qso }] : [];
+            });
+            const projection = projectFT8ContestQsos(currentContest, projected.map(({ qso }) => qso));
+            const recordsById = new Map(projected.map((entry) => [
+                entry.qso.qsoId,
+                entry.record,
+            ]));
+            const rows = projection.map((item) => {
+                const qso = item.qso;
+                return standardContestRecordRow(item, recordsById.get(qso.qsoId) ?? projected[0].record);
+            });
+            const score = scoreFT8ContestQsos(currentContest, projected.map(({ qso }) => qso));
+            const issues = projection.flatMap((item, index) => item.issues.map((code) => ({
+                code,
+                message: code,
+                qsoId: projected[index]?.record.id,
+                severity: code === 'review' || code === 'dupe' ? 'warning' : 'info',
+            })));
+            return {
+                schemaVersion: 1,
+                contest: {
+                    id: currentContest.id,
+                    editionId: currentContest.edition.id,
+                    rulesetVersion: currentContest.rulesetVersion,
+                    title: currentContest.presentation?.title,
+                    officialUrl: currentContest.edition.source?.url,
+                    startAt: currentContest.edition.startAt,
+                    endAt: currentContest.edition.endAt,
+                    modes: [...currentContest.modes],
+                    bands: [...currentContest.bands],
+                    exchangeId: currentContest.exchange.id,
+                    exchangeSummary: currentContest.presentation?.exchange,
+                    completionId: currentContest.completion.id,
+                    ruleSummary: currentContest.presentation?.summary ?? `${currentContest.modes.join('/')} contest using ${currentContest.exchange.id} exchange`,
+                    scoringSummary: currentContest.presentation?.scoring ?? `Scoring module: ${currentContest.scoring.id}`,
+                },
+                health: { state: 'healthy', readable: true, writable: true, updatedAt: Date.now() },
+                settings: {
+                    value: session.settings,
+                    valid: settings.validate(session, currentContest, context).length === 0,
+                    issues: settings.validate(session, currentContest, context).map((issue) => issue.message),
+                    fields: Object.entries(settings.settings).map(([key, descriptor]) => ({
+                        key,
+                        label: descriptor.label,
+                        description: descriptor.description,
+                        type: descriptor.type === 'number' || descriptor.type === 'boolean' ? descriptor.type : 'string',
+                        options: descriptor.options,
+                    })),
+                },
+                score: {
+                    claimedScore: score.total,
+                    qsoPoints: score.qsoPoints,
+                    multiplierCount: score.multiplierCount,
+                    details: {
+                        moduleId: currentContest.scoring.id,
+                        summary: currentContest.presentation?.scoring ?? `Scoring module: ${currentContest.scoring.id}`,
+                        qsoCount: score.qsoCount,
+                        multiplierCount: score.multiplierCount,
+                        total: score.total,
+                    },
+                },
+                qsos: rows,
+                review: { pendingCount: rows.filter((row) => row.status === 'review').length, issues },
+                import: { state: 'idle' },
+                export: { formats: exporters.map((item) => ({ id: item.id, label: item.label, extension: item.extension, enabled: item.enabled?.({ contest: currentContest, session }) ?? true })) },
+                columns,
+                presentation: options.presentation,
+            };
+        },
+        decode: decodeStandardContestAction,
+        async handle(request, currentContest, session, requestContext, application, records, state, pluginContext) {
+            if (request.action === CONTEST_WORKBENCH_ACTIONS.saveSettings) {
+                const nextSettings = request.payload;
+                const next = { ...session, settings: nextSettings };
+                const issues = settings.validate(next, currentContest, pluginContext);
+                if (issues.length > 0)
+                    throw new Error(`contest_logbook_invalid_settings:${issues.map((issue) => issue.code).join(',')}`);
+                state?.update(() => next);
+                await state?.flush();
+                await application?.notify('manual');
+                return { saved: true };
+            }
+            if (!application)
+                throw new Error('contest_logbook_session_unavailable');
+            if (request.action === CONTEST_WORKBENCH_ACTIONS.setQsoStatus) {
+                const payload = request.payload;
+                await application.transact((snapshot) => {
+                    const current = snapshot.records.find((record) => record.id === payload.qsoId);
+                    if (!current)
+                        throw new Error('contest_logbook_qso_not_found');
+                    const contestEntry = current.contestEntry ? {
+                        ...current.contestEntry,
+                        annotations: { ...current.contestEntry.annotations, status: payload.status },
+                    } : undefined;
+                    return [{ type: 'update', qsoId: current.id, updates: { ...(contestEntry ? { contestEntry } : {}), contestId: current.contestId ?? currentContest.id } }];
+                }, { reason: 'review' });
+                return { updated: true };
+            }
+            if (request.action === CONTEST_WORKBENCH_ACTIONS.previewImport) {
+                const payload = request.payload;
+                const source = await requestContext.files.read(payload.path);
+                await requestContext.files.delete(payload.path).catch(() => false);
+                if (!source)
+                    throw new Error('contest_logbook_import_file_missing');
+                const imported = parseContestAdifContent(source.toString('utf8'));
+                const token = createImportToken();
+                pending.set(token, { operatorId: requestContext.instanceTarget.kind === 'operator' ? requestContext.instanceTarget.operatorId : '', pageSessionId: requestContext.pageSessionId, records: imported, createdAt: Date.now() });
+                const importProjection = imported.map((record) => project(record, pluginContext));
+                const importable = importProjection.filter(Boolean).length;
+                return { token, fileName: payload.fileName, preview: { totalRead: imported.length, importable, review: importProjection.filter((qso) => qso?.status === 'review').length, duplicates: 0, rejected: imported.length - importable } };
+            }
+            if (request.action === 'cancel-import') {
+                pending.delete(request.payload.token);
+                return { cancelled: true };
+            }
+            if (request.action === CONTEST_WORKBENCH_ACTIONS.commitImport) {
+                const token = request.payload.token;
+                const entry = pending.get(token);
+                if (!entry || entry.operatorId !== (requestContext.instanceTarget.kind === 'operator' ? requestContext.instanceTarget.operatorId : '') || entry.pageSessionId !== requestContext.pageSessionId || Date.now() - entry.createdAt > 15 * 60_000)
+                    throw new Error('contest_logbook_import_preview_expired');
+                await application.transact((snapshot) => {
+                    const existing = new Set(snapshot.records.map((record) => `${record.callsign}:${record.startTime}:${record.frequency}`));
+                    return entry.records.flatMap((record) => {
+                        if (!project(record, pluginContext))
+                            return [];
+                        const decorated = options.decorateRecord?.(record, pluginContext) ?? record;
+                        const key = `${decorated.callsign}:${decorated.startTime}:${decorated.frequency}`;
+                        return existing.has(key) ? [] : [{ type: 'add', record: decorated }];
+                    });
+                }, { reason: 'import' });
+                pending.delete(token);
+                return { imported: entry.records.length };
+            }
+            if (request.action === CONTEST_WORKBENCH_ACTIONS.export) {
+                const formatId = request.payload.formatId;
+                const exporter = exporters.find((item) => item.id === formatId);
+                if (!exporter)
+                    throw new Error('contest_logbook_export_format_unknown');
+                const all = await application.query();
+                const projected = all.flatMap((record) => { const qso = project(record, pluginContext); return qso ? [{ record, qso }] : []; });
+                const exportRecords = formatId === 'adif' ? all : projected.map(({ qso }) => qso);
+                return { fileName: `contest-${currentContest.id}.${exporter.extension.replace(/^\./, '')}`, mediaType: exporter.mediaType ?? 'text/plain', text: exporter.format(exportRecords, options.submissionOptions) };
+            }
+            throw new Error(`contest_logbook_unknown_action:${request.action}`);
+        },
+        decorateRecord(record, _currentContest, context) {
+            if (options.decorateRecord)
+                return options.decorateRecord(record, context);
+            const qso = project(record, context);
+            if (!qso?.sentExchange || !qso.receivedExchange)
+                return { ...record, contestId: contest.id };
+            return {
+                ...record,
+                contestId: contest.id,
+                contestEntry: envelope.create({
+                    sent: qso.sentExchange,
+                    received: qso.receivedExchange,
+                    annotations: { status: qso.status ?? 'included', source: 'contest-logbook' },
+                }),
+            };
+        },
+    };
+    const module = defaultContestLogbook({
+        contest,
+        pageId: options.pageId,
+        ui: options.ui,
+        resolveContest: options.resolveContest,
+        sessionKey: options.sessionKey,
+        stateKey: options.stateKey,
+        deferStartup: true,
+        adapter,
+    });
+    return module;
+}
+//# sourceMappingURL=ContestLogbook.js.map