@tx5dr/contracts 1.7.3 → 1.7.5

package/src/schema/websocket.schema.ts

@@ -27,6 +27,8 @@ import { RadioProfileSchema, ProfileChangedEventSchema } from './radio-profile.s
 import { UserRole } from './auth.schema.js';
 import type { VoicePTTLock } from './voice.schema.js';
 import type { VoiceKeyerStatus } from './voice-keyer.schema.js';
+import type { CWKeyerStatus, CWKeyerConfig } from './cw-keyer.schema.js';
+import { CWDecoderEventSchema, CWDecoderStatusSchema, type CWDecoderEvent, type CWDecoderStatus } from './cw-decoder.schema.js';
 import { CapabilityListSchema, CapabilityStateSchema, WriteCapabilityPayloadSchema } from './radio-capability.schema.js';
 import { RadioPowerStateEventSchema } from './radio-power.schema.js';
 import { AudioSidecarStatusPayloadSchema } from './audio-sidecar.schema.js';
@@ -56,11 +58,13 @@ export enum WSMessageType {
   SLOT_PACK_UPDATED = 'slotPackUpdated',
   SPECTRUM_CAPABILITIES = 'spectrumCapabilities',
   SUBSCRIBE_SPECTRUM = 'subscribeSpectrum',
+  SPECTRUM_SUBSCRIPTION_CHANGED = 'spectrumSubscriptionChanged',
   SPECTRUM_FRAME = 'spectrumFrame',
   SPECTRUM_SESSION_STATE_CHANGED = 'spectrumSessionStateChanged',
   INVOKE_SPECTRUM_CONTROL = 'invokeSpectrumControl',
   DECODE_ERROR = 'decodeError',
   SYSTEM_STATUS = 'systemStatus',
+  BOOTSTRAP_STATUS_CHANGED = 'bootstrapStatusChanged',
   CLIENT_COUNT_CHANGED = 'clientCountChanged',
   CLOCK_STATUS_CHANGED = 'clockStatusChanged',
   RIGCTLD_STATUS = 'rigctldStatus',
@@ -175,6 +179,24 @@ export enum WSMessageType {
   VOICE_KEYER_STOP = 'voiceKeyerStop',
   VOICE_KEYER_STATUS_CHANGED = 'voiceKeyerStatusChanged',
 
+  // ===== CW 模式 =====
+  /** CW 键控器状态变化（server → client） */
+  CW_KEYER_STATUS = 'cwKeyerStatus',
+  /** CW 手键动作（client → server） */
+  CW_KEY_ACTION = 'cwKeyAction',
+  /** CW 文字输入（client → server） */
+  CW_TEXT_INPUT = 'cwTextInput',
+  /** CW 播放预设报文（client → server） */
+  CW_PLAY_MESSAGE = 'cwPlayMessage',
+  /** CW 停止播放（client → server） */
+  CW_STOP_MESSAGE = 'cwStopMessage',
+  /** CW 配置变更通知（server → client） */
+  CW_CONFIG_CHANGED = 'cwConfigChanged',
+  /** CW 解码器状态快照（server → client） */
+  CW_DECODER_STATUS = 'cwDecoderStatus',
+  /** CW 解码器增量事件（server → client） */
+  CW_DECODER_EVENT = 'cwDecoderEvent',
+
   // ===== 进程监控 =====
   PROCESS_SNAPSHOT = 'processSnapshot',
   PROCESS_SNAPSHOT_HISTORY = 'processSnapshotHistory',
@@ -215,8 +237,8 @@ export const SystemStatusSchema = z.object({
   radioConnectionHealth: z.object({
     connectionHealthy: z.boolean(),
   }).optional(),
-  /** 引擎模式：digital（FT8/FT4）或 voice（语音通联） */
-  engineMode: z.enum(['digital', 'voice']).default('digital'),
+  /** 引擎模式：digital（FT8/FT4）、voice（语音通联）或 cw（莫尔斯码） */
+  engineMode: z.enum(['digital', 'voice', 'cw']).default('digital'),
   /** 当前电台调制模式（语音模式下使用，如 USB/LSB/FM/AM） */
   currentRadioMode: z.string().optional(),
   /** 引擎状态机当前状态 */
@@ -229,6 +251,62 @@ export const SystemStatusSchema = z.object({
   }).nullable().optional(),
 });
 
+export const BootstrapLifecycleSchema = z.enum(['booting', 'completed', 'degraded', 'failed', 'dismissed']);
+export const BootstrapPhaseStateSchema = z.enum([
+  'pending',
+  'running',
+  'ready',
+  'skipped',
+  'warning',
+  'failed',
+  'timed_out',
+]);
+export const BootstrapPhaseIdSchema = z.enum([
+  'config-auth',
+  'core-http',
+  'engine-bootstrap',
+  'audio-device-discovery',
+  'logbook-prewarm',
+  'plugin-bootstrap',
+  'ntp-initial-check',
+  'active-profile-autostart',
+]);
+
+export const BootstrapPhaseStatusSchema = z.object({
+  id: BootstrapPhaseIdSchema,
+  label: z.string(),
+  description: z.string().optional(),
+  state: BootstrapPhaseStateSchema,
+  startedAt: z.number().optional(),
+  completedAt: z.number().optional(),
+  updatedAt: z.number(),
+  durationMs: z.number().optional(),
+  message: z.string().optional(),
+  retryable: z.boolean().optional(),
+  userVisible: z.boolean().optional(),
+});
+
+export const BootstrapStatusSchema = z.object({
+  bootSessionId: z.string(),
+  lifecycle: BootstrapLifecycleSchema,
+  startedAt: z.number(),
+  updatedAt: z.number(),
+  completedAt: z.number().optional(),
+  durationMs: z.number().optional(),
+  blockingReady: z.boolean().default(false),
+  phases: z.array(BootstrapPhaseStatusSchema),
+  summary: z.object({
+    total: z.number(),
+    pending: z.number(),
+    running: z.number(),
+    ready: z.number(),
+    skipped: z.number(),
+    warning: z.number(),
+    failed: z.number(),
+    timedOut: z.number(),
+  }),
+});
+
 // 子窗口信息数据结构
 export const SubWindowInfoSchema = z.object({
   slotInfo: SlotInfoSchema,
@@ -387,6 +465,11 @@ export const MeterDataSchema = z.object({
 
 // ===== 导出共享类型 =====
 export type SystemStatus = z.infer<typeof SystemStatusSchema>;
+export type BootstrapLifecycle = z.infer<typeof BootstrapLifecycleSchema>;
+export type BootstrapPhaseState = z.infer<typeof BootstrapPhaseStateSchema>;
+export type BootstrapPhaseId = z.infer<typeof BootstrapPhaseIdSchema>;
+export type BootstrapPhaseStatus = z.infer<typeof BootstrapPhaseStatusSchema>;
+export type BootstrapStatus = z.infer<typeof BootstrapStatusSchema>;
 export type SubWindowInfo = z.infer<typeof SubWindowInfoSchema>;
 export type DecodeErrorInfo = z.infer<typeof DecodeErrorInfoSchema>;
 export type FrequencyState = z.infer<typeof FrequencyStateSchema>;
@@ -448,6 +531,17 @@ export const WSSubscribeSpectrumMessageSchema = WSBaseMessageSchema.extend({
   }),
 });
 
+export const WSSpectrumSubscriptionChangedMessageSchema = WSBaseMessageSchema.extend({
+  type: z.literal(WSMessageType.SPECTRUM_SUBSCRIPTION_CHANGED),
+  data: z.object({
+    requestedKind: SpectrumKindSchema.nullable(),
+    effectiveKind: SpectrumKindSchema.nullable(),
+    ok: z.boolean(),
+    reason: z.string().optional(),
+    capabilities: SpectrumCapabilitiesSchema.optional(),
+  }),
+});
+
 export const WSSpectrumFrameMessageSchema = WSBaseMessageSchema.extend({
   type: z.literal(WSMessageType.SPECTRUM_FRAME),
   data: SpectrumFrameSchema,
@@ -473,6 +567,11 @@ export const WSSystemStatusMessageSchema = WSBaseMessageSchema.extend({
   data: SystemStatusSchema,
 });
 
+export const WSBootstrapStatusChangedMessageSchema = WSBaseMessageSchema.extend({
+  type: z.literal(WSMessageType.BOOTSTRAP_STATUS_CHANGED),
+  data: BootstrapStatusSchema,
+});
+
 export const WSClientCountChangedMessageSchema = WSBaseMessageSchema.extend({
   type: z.literal(WSMessageType.CLIENT_COUNT_CHANGED),
   data: z.object({
@@ -1109,6 +1208,20 @@ export const WSTextMessageSchema = WSBaseMessageSchema.extend({
 
 export type WSTextMessage = z.infer<typeof WSTextMessageSchema>;
 
+export const WSCWDecoderStatusMessageSchema = WSBaseMessageSchema.extend({
+  type: z.literal(WSMessageType.CW_DECODER_STATUS),
+  data: CWDecoderStatusSchema,
+});
+
+export type WSCWDecoderStatusMessage = z.infer<typeof WSCWDecoderStatusMessageSchema>;
+
+export const WSCWDecoderEventMessageSchema = WSBaseMessageSchema.extend({
+  type: z.literal(WSMessageType.CW_DECODER_EVENT),
+  data: CWDecoderEventSchema,
+});
+
+export type WSCWDecoderEventMessage = z.infer<typeof WSCWDecoderEventMessageSchema>;
+
 // ===== 统一电台控制能力消息 =====
 
 /**
@@ -1270,11 +1383,13 @@ export const WSMessageSchema = z.discriminatedUnion('type', [
   WSSlotPackUpdatedMessageSchema,
   WSSpectrumCapabilitiesMessageSchema,
   WSSubscribeSpectrumMessageSchema,
+  WSSpectrumSubscriptionChangedMessageSchema,
   WSSpectrumFrameMessageSchema,
   WSSpectrumSessionStateChangedMessageSchema,
   WSInvokeSpectrumControlMessageSchema,
   WSDecodeErrorMessageSchema,
   WSSystemStatusMessageSchema,
+  WSBootstrapStatusChangedMessageSchema,
   WSClientCountChangedMessageSchema,
   WSClockStatusChangedMessageSchema,
   WSErrorMessageSchema,
@@ -1347,6 +1462,10 @@ export const WSMessageSchema = z.discriminatedUnion('type', [
   // 文本消息（Toast通知）
   WSTextMessageSchema,
 
+  // CW 解码器消息
+  WSCWDecoderStatusMessageSchema,
+  WSCWDecoderEventMessageSchema,
+
   // 认证消息
   WSAuthRequiredMessageSchema,
   WSAuthTokenMessageSchema,
@@ -1378,11 +1497,13 @@ export type WSSubWindowMessage = z.infer<typeof WSSubWindowMessageSchema>;
 export type WSSlotPackUpdatedMessage = z.infer<typeof WSSlotPackUpdatedMessageSchema>;
 export type WSSpectrumCapabilitiesMessage = z.infer<typeof WSSpectrumCapabilitiesMessageSchema>;
 export type WSSubscribeSpectrumMessage = z.infer<typeof WSSubscribeSpectrumMessageSchema>;
+export type WSSpectrumSubscriptionChangedMessage = z.infer<typeof WSSpectrumSubscriptionChangedMessageSchema>;
 export type WSSpectrumFrameMessage = z.infer<typeof WSSpectrumFrameMessageSchema>;
 export type WSSpectrumSessionStateChangedMessage = z.infer<typeof WSSpectrumSessionStateChangedMessageSchema>;
 export type WSInvokeSpectrumControlMessage = z.infer<typeof WSInvokeSpectrumControlMessageSchema>;
 export type WSDecodeErrorMessage = z.infer<typeof WSDecodeErrorMessageSchema>;
 export type WSSystemStatusMessage = z.infer<typeof WSSystemStatusMessageSchema>;
+export type WSBootstrapStatusChangedMessage = z.infer<typeof WSBootstrapStatusChangedMessageSchema>;
 export type WSClientCountChangedMessage = z.infer<typeof WSClientCountChangedMessageSchema>;
 export type WSClockStatusChangedMessage = z.infer<typeof WSClockStatusChangedMessageSchema>;
 export type WSErrorMessage = z.infer<typeof WSErrorMessageSchema>;
@@ -1432,6 +1553,7 @@ export interface DigitalRadioEngineEvents {
   slotPackUpdated: (slotPack: z.infer<typeof SlotPackSchema>) => void;
   slotPacksReset: (data: z.infer<typeof WSSlotPacksResetMessageSchema>['data']) => void;
   spectrumCapabilities: (data: z.infer<typeof SpectrumCapabilitiesSchema>) => void;
+  spectrumSubscriptionChanged: (data: z.infer<typeof WSSpectrumSubscriptionChangedMessageSchema>['data']) => void;
   spectrumFrame: (data: z.infer<typeof SpectrumFrameSchema>) => void;
   spectrumSessionStateChanged: (data: z.infer<typeof SpectrumSessionStateSchema>) => void;
 
@@ -1455,6 +1577,7 @@ export interface DigitalRadioEngineEvents {
   // 错误和状态事件
   decodeError: (errorInfo: DecodeErrorInfo) => void;
   systemStatus: (status: SystemStatus) => void;
+  bootstrapStatusChanged: (status: BootstrapStatus) => void;
   clientCountChanged: (data: { count: number; timestamp: number }) => void;
   clockStatusChanged: (data: import('./system.schema.js').ClockStatusSummary) => void;
 
@@ -1519,6 +1642,12 @@ export interface DigitalRadioEngineEvents {
   voiceRadioModeChanged: (data: { radioMode: string }) => void;
   voiceKeyerStatusChanged: (data: VoiceKeyerStatus) => void;
 
+  // CW 模式事件
+  cwKeyerStatusChanged: (data: CWKeyerStatus) => void;
+  cwConfigChanged: (data: CWKeyerConfig) => void;
+  cwDecoderStatusChanged: (data: CWDecoderStatus) => void;
+  cwDecoderEvent: (data: CWDecoderEvent) => void;
+
   // 进程监控事件
   processSnapshot: (data: import('./process-monitor.schema.js').ProcessSnapshot) => void;
   processSnapshotHistory: (data: import('./process-monitor.schema.js').ProcessSnapshotHistory) => void;

package/src/utils/__tests__/cwTiming.test.ts

@@ -0,0 +1,91 @@
+import { describe, expect, it } from 'vitest';
+import {
+  encodeTextToCWEvents,
+  encodeTextToCWKeyStateSegments,
+  estimateCWMessageDurationMs,
+} from '../cwTiming.js';
+
+function totalSegmentDuration(text: string, wpm: number): number {
+  return encodeTextToCWKeyStateSegments(text, wpm).reduce((sum, segment) => sum + segment.durationMs, 0);
+}
+
+describe('CW timing utilities', () => {
+  it('returns no events and zero duration for blank text', () => {
+    expect(encodeTextToCWEvents('   ', 20)).toEqual([]);
+    expect(encodeTextToCWKeyStateSegments('   ', 20)).toEqual([]);
+    expect(estimateCWMessageDurationMs('', 20)).toBe(0);
+  });
+
+  it('encodes exact key events for simple characters and spacing', () => {
+    expect(encodeTextToCWEvents('E', 20)).toEqual([
+      { type: 'key-down', afterMs: 0 },
+      { type: 'key-up', afterMs: 60 },
+    ]);
+
+    expect(encodeTextToCWEvents('EE', 20)).toEqual([
+      { type: 'key-down', afterMs: 0 },
+      { type: 'key-up', afterMs: 60 },
+      { type: 'key-down', afterMs: 180 },
+      { type: 'key-up', afterMs: 60 },
+    ]);
+
+    expect(encodeTextToCWEvents('E E', 20)).toEqual([
+      { type: 'key-down', afterMs: 0 },
+      { type: 'key-up', afterMs: 60 },
+      { type: 'key-down', afterMs: 420 },
+      { type: 'key-up', afterMs: 60 },
+    ]);
+
+    expect(encodeTextToCWEvents('A', 20)).toEqual([
+      { type: 'key-down', afterMs: 0 },
+      { type: 'key-up', afterMs: 60 },
+      { type: 'key-down', afterMs: 60 },
+      { type: 'key-up', afterMs: 180 },
+    ]);
+  });
+
+  it('encodes exact key state segments for browser sidetone adapters', () => {
+    expect(encodeTextToCWKeyStateSegments('E', 20)).toEqual([
+      { keyDown: true, durationMs: 60 },
+    ]);
+
+    expect(encodeTextToCWKeyStateSegments('EE', 20)).toEqual([
+      { keyDown: true, durationMs: 60 },
+      { keyDown: false, durationMs: 180 },
+      { keyDown: true, durationMs: 60 },
+    ]);
+
+    expect(encodeTextToCWKeyStateSegments('E E', 20)).toEqual([
+      { keyDown: true, durationMs: 60 },
+      { keyDown: false, durationMs: 420 },
+      { keyDown: true, durationMs: 60 },
+    ]);
+
+    expect(encodeTextToCWKeyStateSegments('A', 20)).toEqual([
+      { keyDown: true, durationMs: 60 },
+      { keyDown: false, durationMs: 60 },
+      { keyDown: true, durationMs: 180 },
+    ]);
+  });
+
+  it('scales duration by WPM', () => {
+    expect(estimateCWMessageDurationMs('EE', 20)).toBe(300);
+    expect(estimateCWMessageDurationMs('EE', 40)).toBe(150);
+  });
+
+  it('uses the Hamlib/PARIS exact dot duration for non-divisible WPM values', () => {
+    expect(estimateCWMessageDurationMs('EE', 17)).toBe(353);
+  });
+
+  it('treats prosigns as single Morse tokens rather than re-encoding dots and dashes', () => {
+    expect(estimateCWMessageDurationMs('<SK>', 20)).toBe(900);
+    expect(totalSegmentDuration('<SK>', 20)).toBe(900);
+    expect(totalSegmentDuration('<CL>', 20)).toBeGreaterThan(0);
+  });
+
+  it('keeps unsupported-character and WPM clamp behavior', () => {
+    expect(estimateCWMessageDurationMs('E☃E', 20)).toBe(300);
+    expect(estimateCWMessageDurationMs('E', 1)).toBe(240);
+    expect(estimateCWMessageDurationMs('E', 1000)).toBe(20);
+  });
+});

package/src/utils/cwTiming.ts

@@ -0,0 +1,203 @@
+/**
+ * CW text to Morse timing encoder.
+ *
+ * Timing follows the ITU/PARIS convention:
+ * - dit = 1200 / WPM ms
+ * - dah = 3 dits
+ * - intra-character gap = 1 dit
+ * - character gap = 3 dits
+ * - word gap = 7 dits
+ */
+export interface CWTimingEvent {
+  type: 'key-down' | 'key-up';
+  /** Delay from the previous event, in milliseconds. */
+  afterMs: number;
+}
+
+export interface CWKeyStateSegment {
+  /** true when the key/tone is closed, false for silence/open key. */
+  keyDown: boolean;
+  /** Segment duration in milliseconds. */
+  durationMs: number;
+}
+
+const DOT_UNITS = {
+  dit: 1,
+  dah: 3,
+  intraChar: 1,
+  interChar: 3,
+  interWord: 7,
+} as const;
+
+const MORSE_TABLE: Record<string, string> = {
+  A: '.-',    B: '-...',  C: '-.-.',  D: '-..',
+  E: '.',     F: '..-.',  G: '--.',   H: '....',
+  I: '..',    J: '.---',  K: '-.-',   L: '.-..',
+  M: '--',    N: '-.',    O: '---',   P: '.--.',
+  Q: '--.-',  R: '.-.',   S: '...',   T: '-',
+  U: '..-',   V: '...-',  W: '.--',   X: '-..-',
+  Y: '-.--',  Z: '--..',
+  '0': '-----', '1': '.----', '2': '..---', '3': '...--',
+  '4': '....-', '5': '.....', '6': '-....', '7': '--...',
+  '8': '---..', '9': '----.',
+  '.': '.-.-.-', ',': '--..--', '?': '..--..', '/': '-..-.',
+  '@': '.--.-.', '=': '-...-', '-': '-....-', '+': '.-.-.',
+  ':': '---...', ';': '-.-.-.', '\'': '.----.', '"': '.-..-.',
+  '!': '-.-.--', '&': '.-...', '(': '-.--.', ')': '-.--.-',
+  '_': '..--.-', '$': '...-..-',
+};
+
+const PROSIGN_MAP: Record<string, string> = {
+  '<AR>': '.-.-.',
+  '<SK>': '...-.-',
+  '<BT>': '-...-',
+  '<KN>': '-.--.',
+  '<BK>': '-...-.-',
+  '<CL>': '-.-..-..',
+};
+
+const PROSIGN_TOKENS = Object.keys(PROSIGN_MAP).sort((a, b) => b.length - a.length);
+
+/**
+ * Encodes supported CW text into a sequence of timing events.
+ */
+export function encodeTextToCWEvents(text: string, wpm: number): CWTimingEvent[] {
+  const events: CWTimingEvent[] = [];
+  let nextEventDelayMs = 0;
+
+  for (const segment of encodeTextToCWKeyStateSegments(text, wpm)) {
+    if (!segment.keyDown) {
+      nextEventDelayMs += segment.durationMs;
+      continue;
+    }
+
+    events.push({ type: 'key-down', afterMs: nextEventDelayMs });
+    events.push({ type: 'key-up', afterMs: segment.durationMs });
+    nextEventDelayMs = 0;
+  }
+
+  return events;
+}
+
+/**
+ * Encodes supported CW text into key-down/silence duration segments.
+ * This is the shared adapter input for browser sidetone and other local keying outputs.
+ */
+export function encodeTextToCWKeyStateSegments(text: string, wpm: number): CWKeyStateSegment[] {
+  const dotMs = getRoundedDotMs(wpm);
+  const tokenizedWords = tokenizeText(text);
+  const segments: CWKeyStateSegment[] = [];
+  let firstToken = true;
+
+  for (const word of tokenizedWords) {
+    for (let ti = 0; ti < word.length; ti += 1) {
+      if (!firstToken) {
+        appendSegment(segments, false, (ti === 0 ? DOT_UNITS.interWord : DOT_UNITS.interChar) * dotMs);
+      }
+
+      appendCodeSegments(segments, word[ti], dotMs);
+      firstToken = false;
+    }
+  }
+
+  return segments;
+}
+
+/**
+ * Estimates total CW message duration from the first key-down to the final key-up.
+ * Uses the PARIS timing base from Hamlib: dot milliseconds = 1200 / WPM.
+ */
+export function estimateCWMessageDurationMs(text: string, wpm: number): number {
+  const safeWpm = getSafeWpm(wpm);
+  const dotUnits = countCWMessageDotUnits(text);
+  if (dotUnits <= 0) {
+    return 0;
+  }
+  return Math.ceil(dotUnits * (1200 / safeWpm));
+}
+
+function appendCodeSegments(segments: CWKeyStateSegment[], code: string, dotMs: number): void {
+  for (let si = 0; si < code.length; si += 1) {
+    if (si > 0) {
+      appendSegment(segments, false, DOT_UNITS.intraChar * dotMs);
+    }
+    appendSegment(segments, true, (code[si] === '-' ? DOT_UNITS.dah : DOT_UNITS.dit) * dotMs);
+  }
+}
+
+function appendSegment(segments: CWKeyStateSegment[], keyDown: boolean, durationMs: number): void {
+  if (durationMs <= 0) {
+    return;
+  }
+  const previous = segments[segments.length - 1];
+  if (previous?.keyDown === keyDown) {
+    previous.durationMs += durationMs;
+    return;
+  }
+  segments.push({ keyDown, durationMs });
+}
+
+function countCWMessageDotUnits(text: string): number {
+  const tokenizedWords = tokenizeText(text);
+  let firstToken = true;
+  let totalUnits = 0;
+
+  for (const word of tokenizedWords) {
+    for (let ti = 0; ti < word.length; ti += 1) {
+      if (!firstToken) {
+        totalUnits += ti === 0 ? DOT_UNITS.interWord : DOT_UNITS.interChar;
+      }
+
+      const code = word[ti];
+      for (let si = 0; si < code.length; si += 1) {
+        totalUnits += si === 0 ? 0 : DOT_UNITS.intraChar;
+        totalUnits += code[si] === '-' ? DOT_UNITS.dah : DOT_UNITS.dit;
+      }
+      firstToken = false;
+    }
+  }
+
+  return totalUnits;
+}
+
+function tokenizeText(text: string): string[][] {
+  const normalized = text.toUpperCase().trim();
+  if (!normalized) {
+    return [];
+  }
+
+  return normalized
+    .split(/\s+/)
+    .map(tokenizeWord)
+    .filter((word) => word.length > 0);
+}
+
+function tokenizeWord(word: string): string[] {
+  const codes: string[] = [];
+  let index = 0;
+
+  while (index < word.length) {
+    const prosign = PROSIGN_TOKENS.find((token) => word.startsWith(token, index));
+    if (prosign) {
+      codes.push(PROSIGN_MAP[prosign]);
+      index += prosign.length;
+      continue;
+    }
+
+    const code = MORSE_TABLE[word[index]];
+    if (code) {
+      codes.push(code);
+    }
+    index += 1;
+  }
+
+  return codes;
+}
+
+function getRoundedDotMs(wpm: number): number {
+  return Math.round(1200 / getSafeWpm(wpm));
+}
+
+function getSafeWpm(wpm: number): number {
+  return Math.max(5, Math.min(60, Math.round(Number(wpm) || 20)));
+}

package/test/plugin-slot-schema.test.ts

@@ -8,6 +8,8 @@ describe('PluginPanelSlotSchema', () => {
     expect(PluginPanelSlotSchema.parse('main-right')).toBe('main-right');
     expect(PluginPanelSlotSchema.parse('voice-left-top')).toBe('voice-left-top');
     expect(PluginPanelSlotSchema.parse('voice-right-top')).toBe('voice-right-top');
+    expect(PluginPanelSlotSchema.parse('cw-right-top')).toBe('cw-right-top');
+    expect(PluginPanelSlotSchema.parse('radio-control-toolbar')).toBe('radio-control-toolbar');
   });
 
   it('validates iframe panels declared in the new host slots', () => {
@@ -27,4 +29,54 @@ describe('PluginPanelSlotSchema', () => {
       slot: 'voice-right-top',
     })).not.toThrow();
   });
+
+  it('validates radio control toolbar iframe panel metadata', () => {
+    expect(PluginPanelDescriptorSchema.parse({
+      id: 'rotator-button',
+      title: 'rotatorTitle',
+      component: 'iframe',
+      pageId: 'rotator',
+      slot: 'radio-control-toolbar',
+      icon: 'brands:github',
+      openMode: 'modal',
+      uiSize: 'lg',
+    })).toMatchObject({
+      slot: 'radio-control-toolbar',
+      icon: 'brands:github',
+      openMode: 'modal',
+      uiSize: 'lg',
+    });
+
+    expect(() => PluginPanelDescriptorSchema.parse({
+      id: 'bad-toolbar',
+      title: 'Bad',
+      component: 'key-value',
+      slot: 'radio-control-toolbar',
+    })).toThrow('radio-control-toolbar panels must use iframe component');
+
+    expect(() => PluginPanelDescriptorSchema.parse({
+      id: 'missing-page',
+      title: 'Missing',
+      component: 'iframe',
+      slot: 'radio-control-toolbar',
+    })).toThrow('radio-control-toolbar panels must declare pageId');
+
+    expect(() => PluginPanelDescriptorSchema.parse({
+      id: 'bad-open-mode',
+      title: 'Bad',
+      component: 'iframe',
+      pageId: 'rotator',
+      slot: 'radio-control-toolbar',
+      openMode: 'drawer',
+    })).toThrow();
+
+    expect(() => PluginPanelDescriptorSchema.parse({
+      id: 'bad-size',
+      title: 'Bad',
+      component: 'iframe',
+      pageId: 'rotator',
+      slot: 'radio-control-toolbar',
+      uiSize: 'xl',
+    })).toThrow();
+  });
 });