@tx5dr/contracts 1.7.2 → 1.7.4

package/src/schema/process-monitor.schema.ts

@@ -28,6 +28,65 @@ export const EventLoopDelaySchema = z.object({
   p99: z.number(),
 });
 
+export const DecodeWorkerCurrentJobSchema = z.object({
+  jobId: z.number(),
+  slotId: z.string(),
+  windowIdx: z.number(),
+  mode: z.string(),
+  startedAt: z.number(),
+  elapsedMs: z.number(),
+  requestAudioDurationMs: z.number().optional(),
+});
+
+export const DecodeWorkerTelemetryWorkerSchema = z.object({
+  workerId: z.number(),
+  pid: z.number().optional(),
+  ready: z.boolean(),
+  busy: z.boolean(),
+  nativeThreads: z.number().int().positive(),
+  uptimeSeconds: z.number(),
+  memory: ProcessMemorySchema,
+  cpu: ProcessCpuSchema,
+  currentJob: DecodeWorkerCurrentJobSchema.optional(),
+  lastSeenAt: z.number(),
+});
+
+export const DecodeWorkerTelemetrySummarySchema = z.object({
+  status: z.enum(['stopped', 'starting', 'ready', 'degraded', 'unavailable']).optional(),
+  workerCount: z.number().int().nonnegative(),
+  desiredWorkers: z.number().int().nonnegative().optional(),
+  readyCount: z.number().int().nonnegative(),
+  busyCount: z.number().int().nonnegative(),
+  totalRss: z.number().nonnegative(),
+  totalCpu: z.number().nonnegative(),
+  nativeThreadsPerWorker: z.number().int().positive(),
+  pendingJobs: z.number().int().nonnegative(),
+  activeJobs: z.number().int().nonnegative(),
+  lastError: z.string().optional(),
+  lastFailureAt: z.number().optional(),
+  restartAttempts: z.number().int().nonnegative().optional(),
+  workerEntry: z.string().optional(),
+  workerMode: z.enum(['development', 'production']).optional(),
+});
+
+export const DecodeWorkerTelemetrySnapshotSchema = z.object({
+  summary: DecodeWorkerTelemetrySummarySchema,
+  workers: z.array(DecodeWorkerTelemetryWorkerSchema),
+});
+
+export const WorkerPoolTelemetryWorkerSchema = DecodeWorkerTelemetryWorkerSchema;
+export const WorkerPoolTelemetrySummarySchema = DecodeWorkerTelemetrySummarySchema;
+
+export const WorkerPoolTelemetrySnapshotSchema = z.object({
+  id: z.string().min(1),
+  name: z.string().min(1),
+  kind: z.string().min(1),
+  summary: WorkerPoolTelemetrySummarySchema,
+  workers: z.array(WorkerPoolTelemetryWorkerSchema),
+});
+
+export const WorkerPoolTelemetryListSchema = z.array(WorkerPoolTelemetrySnapshotSchema);
+
 export const ProcessSnapshotSchema = z.object({
   timestamp: z.number(),
   uptimeSeconds: z.number(),
@@ -35,6 +94,8 @@ export const ProcessSnapshotSchema = z.object({
   cpu: ProcessCpuSchema,
   hostCpu: HostCpuSchema.optional(),
   eventLoop: EventLoopDelaySchema,
+  decodeWorkers: DecodeWorkerTelemetrySnapshotSchema.optional(),
+  workerPools: WorkerPoolTelemetryListSchema.optional(),
 });
 
 export const ProcessSnapshotHistorySchema = z.object({
@@ -47,5 +108,13 @@ export type ProcessMemory = z.infer<typeof ProcessMemorySchema>;
 export type ProcessCpu = z.infer<typeof ProcessCpuSchema>;
 export type HostCpu = z.infer<typeof HostCpuSchema>;
 export type EventLoopDelay = z.infer<typeof EventLoopDelaySchema>;
+export type DecodeWorkerCurrentJob = z.infer<typeof DecodeWorkerCurrentJobSchema>;
+export type DecodeWorkerTelemetryWorker = z.infer<typeof DecodeWorkerTelemetryWorkerSchema>;
+export type DecodeWorkerTelemetrySummary = z.infer<typeof DecodeWorkerTelemetrySummarySchema>;
+export type DecodeWorkerTelemetrySnapshot = z.infer<typeof DecodeWorkerTelemetrySnapshotSchema>;
+export type WorkerPoolTelemetryWorker = z.infer<typeof WorkerPoolTelemetryWorkerSchema>;
+export type WorkerPoolTelemetrySummary = z.infer<typeof WorkerPoolTelemetrySummarySchema>;
+export type WorkerPoolTelemetrySnapshot = z.infer<typeof WorkerPoolTelemetrySnapshotSchema>;
+export type WorkerPoolTelemetryList = z.infer<typeof WorkerPoolTelemetryListSchema>;
 export type ProcessSnapshot = z.infer<typeof ProcessSnapshotSchema>;
 export type ProcessSnapshotHistory = z.infer<typeof ProcessSnapshotHistorySchema>;

package/src/schema/radio-capability.schema.ts

@@ -247,21 +247,62 @@ export const CAPABILITY_IDS = [
   'compressor',
   'compressor_level',
   'monitor_gain',
+  'monitor_enabled',
+  'apf_enabled',
+  'apf_level',
   'nb',
+  'nb_level',
   'nr',
+  'nr_level',
+  'rf_gain',
+  'if_shift',
+  'pbt_in',
+  'pbt_out',
+  'cw_pitch',
+  'key_speed',
+  'notch_raw',
+  'agc_time',
+  'balance',
+  'drive_gain',
+  'digi_sel_enabled',
+  'digi_sel_level',
   'lock_mode',
   'mute',
   'vox',
+  'vox_gain',
+  'anti_vox',
+  'vox_delay',
+  'break_in_delay',
+  'auto_notch',
+  'manual_notch',
+  'rit_enabled',
+  'xit_enabled',
+  'tone_enabled',
+  'tone_squelch_enabled',
+  'beep_enabled',
+  'break_in_mode',
   'agc_mode',
   'preamp',
   'attenuator',
   'mode_bandwidth',
+  'split_enabled',
+  'vfo_select',
+  'audio_if_mode',
   'rit_offset',
   'xit_offset',
   'tuning_step',
   'repeater_shift',
   'repeater_offset',
   'ctcss_tone',
+  'spectrum_data_output',
+  'spectrum_hold',
+  'spectrum_speed',
+  'spectrum_ref',
+  'spectrum_average',
+  'spectrum_vbw',
+  'spectrum_rbw',
+  'spectrum_during_tx',
+  'spectrum_center_type',
   'dcs_code',
 ] as const;
 

package/src/schema/radio.schema.ts

@@ -1,5 +1,15 @@
 import { z } from 'zod';
 
+/**
+ * 中继差频方向
+ */
+export const RepeaterShiftSchema = z.enum(['none', 'minus', 'plus']);
+
+/**
+ * 哑音类型
+ */
+export const ToneSquelchModeSchema = z.enum(['none', 'ctcss', 'dcs']);
+
 /**
  * 预设频率Schema
  */
@@ -9,6 +19,85 @@ export const PresetFrequencySchema = z.object({
   radioMode: z.string().optional(), // 电台调制模式，如 USB, LSB, AM, FM
   frequency: z.number(),
   description: z.string().optional(),
+  repeaterShift: RepeaterShiftSchema.optional(), // 中继差频方向，默认 none
+  repeaterOffsetHz: z.number().int().positive().optional(), // 中继偏移，单位 Hz
+  toneMode: ToneSquelchModeSchema.optional(), // 哑音类型，默认 none
+  ctcssToneTenthsHz: z.number().int().positive().optional(), // CTCSS，单位 0.1Hz
+  dcsCode: z.number().int().positive().optional(), // DCS 码
+}).superRefine((preset, ctx) => {
+  const isVoiceFmPreset = preset.mode === 'VOICE' && preset.radioMode?.toUpperCase() === 'FM';
+  const hasRepeaterDuplex = preset.repeaterShift === 'minus' || preset.repeaterShift === 'plus';
+
+  if (hasRepeaterDuplex && !isVoiceFmPreset) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      path: ['repeaterShift'],
+      message: 'repeater duplex is only supported for VOICE FM presets',
+    });
+  }
+
+  if (
+    hasRepeaterDuplex
+    && preset.repeaterOffsetHz === undefined
+  ) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      path: ['repeaterOffsetHz'],
+      message: 'repeaterOffsetHz is required when repeaterShift is plus or minus',
+    });
+  }
+
+  if (!isVoiceFmPreset && preset.toneMode && preset.toneMode !== 'none') {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      path: ['toneMode'],
+      message: 'tone squelch is only supported for VOICE FM presets',
+    });
+  }
+
+  if (preset.toneMode === 'ctcss') {
+    if (preset.ctcssToneTenthsHz === undefined) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ['ctcssToneTenthsHz'],
+        message: 'ctcssToneTenthsHz is required when toneMode is ctcss',
+      });
+    }
+    if (preset.dcsCode !== undefined) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ['dcsCode'],
+        message: 'dcsCode cannot be set when toneMode is ctcss',
+      });
+    }
+  }
+
+  if (preset.toneMode === 'dcs') {
+    if (preset.dcsCode === undefined) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ['dcsCode'],
+        message: 'dcsCode is required when toneMode is dcs',
+      });
+    }
+    if (preset.ctcssToneTenthsHz !== undefined) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ['ctcssToneTenthsHz'],
+        message: 'ctcssToneTenthsHz cannot be set when toneMode is dcs',
+      });
+    }
+  }
+
+  if ((preset.toneMode === undefined || preset.toneMode === 'none')
+    && (preset.ctcssToneTenthsHz !== undefined || preset.dcsCode !== undefined)
+  ) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      path: ['toneMode'],
+      message: 'toneMode must be ctcss or dcs when tone values are set',
+    });
+  }
 });
 
 /**
@@ -163,6 +252,12 @@ export const HamlibConfigSchema = z.object({
   // PTT 独立串口路径（仅当 pttMethod 为 dtr/rts 时有效）
   // 留空则复用 CAT 同一串口
   pttPort: z.string().optional(),
+
+  // CW 键控串口路径（用于 DTR/RTS 引脚驱动电台 CW KEY 输入）
+  cwKeyPort: z.string().optional(),
+
+  // CW 键控引脚类型（dtr 或 rts）
+  cwKeyMethod: z.enum(['dtr', 'rts']).optional(),
 });
 
 /**
@@ -357,6 +452,8 @@ export const CustomFrequencyPresetsSchema = z.object({
 // 导出类型
 export type CustomFrequencyPresets = z.infer<typeof CustomFrequencyPresetsSchema>;
 export type PresetFrequency = z.infer<typeof PresetFrequencySchema>;
+export type RepeaterShift = z.infer<typeof RepeaterShiftSchema>;
+export type ToneSquelchMode = z.infer<typeof ToneSquelchModeSchema>;
 export type FrequencyListResponse = z.infer<typeof FrequencyListResponseSchema>;
 export type SerialConfig = z.infer<typeof SerialConfigSchema>;
 export type HamlibBackendConfig = z.infer<typeof HamlibBackendConfigSchema>;

package/src/schema/slot-info.schema.ts

@@ -1,6 +1,20 @@
 import { z } from 'zod';
 import { DxccStatusSchema, SubdivisionConfidenceSchema } from './qso.schema.js';
 
+/**
+ * Frequency context captured when a slot pack is created.
+ * Fields are optional so older persisted slot packs remain valid.
+ */
+export const SlotPackFrequencyContextSchema = z.object({
+  frequency: z.number().optional(),
+  mode: z.string().optional(),
+  band: z.string().optional(),
+  radioMode: z.string().optional(),
+  description: z.string().optional(),
+});
+
+export type SlotPackFrequencyContext = z.infer<typeof SlotPackFrequencyContextSchema>;
+
 /**
  * 时隙周期（偶数奇数）
  */
@@ -83,6 +97,19 @@ export const FrameMessageSchema = z.object({
 
 export type FrameMessage = z.infer<typeof FrameMessageSchema>;
 
+export const DecodeApContextSchema = z.object({
+  operatorId: z.string(),
+  myCall: z.string(),
+  myGrid: z.string().optional(),
+  dxCall: z.string(),
+  dxGrid: z.string().optional(),
+  frequencyHz: z.number(),
+  qsoProgress: z.number(),
+  currentSlot: z.string(),
+});
+
+export type DecodeApContext = z.infer<typeof DecodeApContextSchema>;
+
 /**
  * 解码请求，用于SlotScheduler内部
  */
@@ -100,7 +127,9 @@ export const DecodeRequestSchema = z.object({
   /** 请求时间戳 */
   timestamp: z.number().default(() => Date.now()),
   /** 窗口时间偏移（毫秒） */
-  windowOffsetMs: z.number().default(0)
+  windowOffsetMs: z.number().default(0),
+  /** 可选的单操作员 AP decode 上下文 */
+  apContext: DecodeApContextSchema.optional()
 });
 
 export type DecodeRequest = z.infer<typeof DecodeRequestSchema>;
@@ -160,7 +189,9 @@ export const SlotPackSchema = z.object({
     timestamp: z.number(),
     frameCount: z.number(),
     processingTimeMs: z.number()
-  })).default([])
+  })).default([]),
+  /** Dial/band context active when this slot was created. */
+  frequencyContext: SlotPackFrequencyContextSchema.optional()
 });
 
 export type SlotPack = z.infer<typeof SlotPackSchema>;

package/src/schema/voice.schema.ts

@@ -24,5 +24,5 @@ export type VoicePTTLock = z.infer<typeof VoicePTTLockSchema>;
  * digital: FT8/FT4 等数字模式
  * voice: 语音通联模式（SSB/FM/AM）
  */
-export const EngineModeSchema = z.enum(['digital', 'voice']);
+export const EngineModeSchema = z.enum(['digital', 'voice', 'cw']);
 export type EngineMode = z.infer<typeof EngineModeSchema>;

package/src/schema/websocket.schema.ts

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import { FT8DecodeSchema } from './ft8.schema.js';
-import { SlotPackSchema, SlotInfoSchema } from './slot-info.schema.js';
+import { SlotPackSchema, SlotInfoSchema, SlotPackFrequencyContextSchema } from './slot-info.schema.js';
 import {
   PluginDataPayloadSchema,
   PluginLogEntrySchema,
@@ -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({
@@ -779,7 +878,9 @@ export const WSTransmissionLogMessageSchema = WSBaseMessageSchema.extend({
     time: z.string(),
     message: z.string(),
     frequency: z.number(),
-    slotStartMs: z.number()
+    slotStartMs: z.number(),
+    replaceExisting: z.boolean().optional(),
+    frequencyContext: SlotPackFrequencyContextSchema.optional(),
   }),
 });
 
@@ -1107,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>;
+
 // ===== 统一电台控制能力消息 =====
 
 /**
@@ -1268,11 +1383,13 @@ export const WSMessageSchema = z.discriminatedUnion('type', [
   WSSlotPackUpdatedMessageSchema,
   WSSpectrumCapabilitiesMessageSchema,
   WSSubscribeSpectrumMessageSchema,
+  WSSpectrumSubscriptionChangedMessageSchema,
   WSSpectrumFrameMessageSchema,
   WSSpectrumSessionStateChangedMessageSchema,
   WSInvokeSpectrumControlMessageSchema,
   WSDecodeErrorMessageSchema,
   WSSystemStatusMessageSchema,
+  WSBootstrapStatusChangedMessageSchema,
   WSClientCountChangedMessageSchema,
   WSClockStatusChangedMessageSchema,
   WSErrorMessageSchema,
@@ -1345,6 +1462,10 @@ export const WSMessageSchema = z.discriminatedUnion('type', [
   // 文本消息（Toast通知）
   WSTextMessageSchema,
 
+  // CW 解码器消息
+  WSCWDecoderStatusMessageSchema,
+  WSCWDecoderEventMessageSchema,
+
   // 认证消息
   WSAuthRequiredMessageSchema,
   WSAuthTokenMessageSchema,
@@ -1376,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>;
@@ -1430,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;
 
@@ -1443,6 +1567,7 @@ export interface DigitalRadioEngineEvents {
     frequency: number;
     slotStartMs: number;
     replaceExisting?: boolean;
+    frequencyContext?: z.infer<typeof SlotPackFrequencyContextSchema>;
   }) => void;
   
   // 操作员事件
@@ -1452,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;
 
@@ -1516,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;
@@ -1544,6 +1676,17 @@ export interface DigitalRadioEngineEvents {
   }) => void;
   pluginPanelMeta: (data: import('./plugin.schema.js').PluginPanelMetaPayload) => void;
   pluginPanelContributionsChanged: (data: import('./plugin.schema.js').PluginUIPanelContributionGroup) => void;
+  pluginRemoteReplyToDecode: (data: { operatorId: string; callsign: string; modifiers?: number }) => void;
+  pluginRemoteClearDecodes: (data: { operatorId: string; window?: number }) => void;
+  pluginRemoteFreeText: (data: { operatorId: string; text?: string; send: boolean }) => void;
+  pluginRemoteLocation: (data: { operatorId: string; location: string }) => void;
+  pluginRemoteHighlightCallsign: (data: {
+    operatorId: string;
+    callsign: string;
+    background?: string | null;
+    foreground?: string | null;
+    lastOnly?: boolean;
+  }) => void;
 
   // 内部子系统间通信事件（不通过 WebSocket 广播，用于 engine emitter 内部编排）
   encodeStart: (slotInfo: z.infer<typeof SlotInfoSchema>) => void;