@tx5dr/contracts 2.0.0 → 2.5.0

package/src/schema/websocket.schema.ts

@@ -20,7 +20,11 @@ import type {
   PluginSystemSnapshot,
 } from './plugin.schema.js';
 import { ModeDescriptorSchema } from './mode.schema.js';
-import { QSORecordSchema, TargetSelectionPriorityModeSchema } from './qso.schema.js';
+import {
+  QSORecordSchema,
+  QSOPersistencePolicySchema,
+  TargetSelectionPriorityModeSchema,
+} from './qso.schema.js';
 import {
   LogBookStatisticsSchema,
   LogbookHealthSchema,
@@ -36,10 +40,27 @@ import { CWDecoderEventSchema, CWDecoderStatusSchema, type CWDecoderEvent, type
 import { CapabilityListSchema, CapabilityStateSchema, WriteCapabilityPayloadSchema } from './radio-capability.schema.js';
 import { RadioPowerStateEventSchema } from './radio-power.schema.js';
 import { AudioSidecarStatusPayloadSchema } from './audio-sidecar.schema.js';
-import { SpectrumCapabilitiesSchema, SpectrumFrameSchema, SpectrumKindSchema, SpectrumSessionControlActionSchema, SpectrumSessionControlIdSchema, SpectrumSessionStateSchema } from './spectrum.schema.js';
+import { SpectrumCapabilitiesSchema, SpectrumFrameSchema, SpectrumKindSchema, SpectrumSessionControlActionSchema, SpectrumSessionControlIdSchema, SpectrumSessionStateSchema, SpectrumViewportSchema } from './spectrum.schema.js';
 import type { RealtimeSettingsResponseData } from './realtime.schema.js';
 import type { AndroidOperatorAudioStatus } from './android-operator-audio.schema.js';
 import { ClockStatusSummarySchema } from './system.schema.js';
+import {
+  ImageRadioStatusSchema,
+  ImageRxEventSchema,
+  ImageRxSubscriptionSchema,
+  FaxCalibrationCommandResultSchema,
+  FaxCalibrationResetCommandSchema,
+  FaxCalibrationSetCommandSchema,
+  SstvTxCancelCommandSchema,
+  SstvTxCommandResultSchema,
+  SstvTxStartCommandSchema,
+  SstvTxStatusSchema,
+  type ImageRadioStatus,
+  type ImageRxEvent,
+  type FaxCalibrationCommandResult,
+  type SstvTxCommandResult,
+  type SstvTxStatus,
+} from './image-radio.schema.js';
 
 // WebSocket消息类型枚举
 export enum WSMessageType {
@@ -55,6 +76,16 @@ export enum WSMessageType {
   STOP_ENGINE = 'stopEngine',
   GET_STATUS = 'getStatus',
   SET_MODE = 'setMode',
+  SUBSCRIBE_IMAGE_RX = 'subscribeImageRx',
+  IMAGE_RADIO_STATUS = 'imageRadioStatus',
+  IMAGE_RX_EVENT = 'imageRxEvent',
+  SSTV_TX_START = 'sstvTxStart',
+  SSTV_TX_CANCEL = 'sstvTxCancel',
+  SSTV_TX_STATUS = 'sstvTxStatus',
+  SSTV_TX_COMMAND_RESULT = 'sstvTxCommandResult',
+  FAX_CALIBRATION_SET = 'faxCalibrationSet',
+  FAX_CALIBRATION_RESET = 'faxCalibrationReset',
+  FAX_CALIBRATION_COMMAND_RESULT = 'faxCalibrationCommandResult',
   
   // ===== 引擎事件 =====
   MODE_CHANGED = 'modeChanged',
@@ -67,6 +98,7 @@ export enum WSMessageType {
   SPECTRUM_FRAME = 'spectrumFrame',
   SPECTRUM_SESSION_STATE_CHANGED = 'spectrumSessionStateChanged',
   INVOKE_SPECTRUM_CONTROL = 'invokeSpectrumControl',
+  SPECTRUM_VIEWPORT_CHANGED = 'spectrumViewportChanged',
   DECODE_ERROR = 'decodeError',
   SYSTEM_STATUS = 'systemStatus',
   BOOTSTRAP_STATUS_CHANGED = 'bootstrapStatusChanged',
@@ -80,6 +112,8 @@ export enum WSMessageType {
   OPERATOR_STATUS_UPDATE = 'operatorStatusUpdate',
   SET_OPERATOR_CONTEXT = 'setOperatorContext',
   SET_OPERATOR_RUNTIME_STATE = 'setOperatorRuntimeState',
+  SET_OPERATOR_STREAM_STATE = 'setOperatorStreamState',
+  INVOKE_OPERATOR_STRATEGY_ACTION = 'invokeOperatorStrategyAction',
   SET_OPERATOR_RUNTIME_SLOT_CONTENT = 'setOperatorRuntimeSlotContent',
   SET_OPERATOR_TRANSMIT_CYCLES = 'setOperatorTransmitCycles',
   START_OPERATOR = 'startOperator',
@@ -254,7 +288,7 @@ export const SystemStatusSchema = z.object({
     connectionHealthy: z.boolean(),
   }).optional(),
   /** 引擎模式：digital（FT8/FT4）、voice（语音通联）或 cw（莫尔斯码） */
-  engineMode: z.enum(['digital', 'voice', 'cw']).default('digital'),
+  engineMode: z.enum(['digital', 'voice', 'cw', 'image']).default('digital'),
   /** 当前电台调制模式（语音模式下使用，如 USB/LSB/FM/AM） */
   currentRadioMode: z.string().optional(),
   /** 引擎状态机当前状态 */
@@ -344,10 +378,11 @@ export const DecodeErrorInfoSchema = z.object({
 /**
  * Current dial-frequency projection broadcast to plugins and clients.
  *
- * `frequency` is RF dial frequency in hertz; `mode` is the TX-5DR engine mode;
- * `band` and `description` are display labels; `radioMode` is the underlying
- * modulation when known. `source` distinguishes application changes from
- * updates reported by the radio.
+ * `frequency` is the logical RF dial target in hertz; `mode` is the TX-5DR
+ * engine mode; `band` and `description` are display labels; `radioMode` is the
+ * underlying modulation when known. `observedFrequency` is the latest physical
+ * readback. `source` distinguishes application changes from radio observations;
+ * `revision` and `connectionGeneration` reject stale events.
  */
 export const FrequencyStateSchema = z.object({
   frequency: z.number(),
@@ -357,6 +392,20 @@ export const FrequencyStateSchema = z.object({
   radioMode: z.string().optional(),
   radioConnected: z.boolean(),
   source: z.enum(['program', 'radio']).optional(),
+  /** Monotonic operating-state revision for stale-event suppression. */
+  revision: z.number().int().nonnegative().optional(),
+  /** Physical CAT session identity associated with this snapshot. */
+  connectionGeneration: z.number().int().nonnegative().optional(),
+  /** Physical confirmation status for the requested operating state. */
+  confirmation: z.enum(['confirmed', 'pending', 'mismatch', 'offline']).optional(),
+  /** Last frequency read back from the physical radio, when available. */
+  observedFrequency: z.number().optional(),
+  /** Requested logical frequency when it differs from the observed value. */
+  requestedFrequency: z.number().optional(),
+  /** Correlates a snapshot with one programmatic operating-state mutation. */
+  operationId: z.string().optional(),
+  /** Physical radio-mode confirmation status. */
+  modeConfirmation: z.enum(['confirmed', 'unconfirmed', 'unknown']).optional(),
 });
 
 export const SpectrumControlInvocationSchema = z.object({
@@ -371,7 +420,7 @@ export const PTTStatusSchema = z.object({
   operatorIds: z.array(z.string()),
   phase: z.enum(['idle', 'starting', 'on_air', 'draining', 'stopping', 'unknown']).optional(),
   frameId: z.string().optional(),
-  source: z.enum(['digital', 'voice', 'voice-keyer', 'cw', 'tune-tone', 'manual', 'test']).optional(),
+  source: z.enum(['digital', 'voice', 'voice-keyer', 'cw', 'sstv', 'tune-tone', 'manual', 'test']).optional(),
 });
 
 export const TuneToneStartPayloadSchema = z.object({
@@ -409,8 +458,103 @@ export const StrategyRuntimeContextSchema = z.object({
 });
 export type StrategyRuntimeContext = z.infer<typeof StrategyRuntimeContextSchema>;
 
+export const StrategyStateOptionSchema = z.object({
+  id: z.string().min(1),
+  label: z.string().min(1).optional(),
+  transmitText: z.string().optional(),
+});
+export type StrategyStateOption = z.infer<typeof StrategyStateOptionSchema>;
+
+export const StrategyActionInputSchema = z.discriminatedUnion('kind', [
+  z.object({
+    kind: z.literal('text'),
+    label: z.string().optional(),
+    value: z.string().optional(),
+    placeholder: z.string().optional(),
+    maxLength: z.number().int().positive().optional(),
+  }),
+  z.object({
+    kind: z.enum(['number', 'audio-frequency']),
+    label: z.string().optional(),
+    value: z.number().optional(),
+    min: z.number().optional(),
+    max: z.number().optional(),
+    step: z.number().positive().optional(),
+    unit: z.string().optional(),
+    spectrumPick: z.boolean().optional(),
+  }),
+]);
+
+export const StrategyActionDescriptorSchema = z.object({
+  id: z.string().min(1),
+  label: z.string().min(1),
+  description: z.string().optional(),
+  icon: z.string().optional(),
+  tone: z.enum(['default', 'primary', 'success', 'warning', 'danger']).optional(),
+  presentation: z.enum(['primary', 'secondary', 'menu', 'segmented']).optional(),
+  groupId: z.string().optional(),
+  selected: z.boolean().optional(),
+  disabledReason: z.string().optional(),
+  previewText: z.string().optional(),
+  confirmation: z.object({
+    title: z.string().min(1),
+    description: z.string().optional(),
+    confirmLabel: z.string().optional(),
+    cancelLabel: z.string().optional(),
+  }).optional(),
+  input: StrategyActionInputSchema.optional(),
+  navigation: z.object({
+    kind: z.literal('plugin-page'),
+    pageId: z.string().min(1),
+  }).optional(),
+});
+export type StrategyActionDescriptor = z.infer<typeof StrategyActionDescriptorSchema>;
+
+export const StrategyAttentionSchema = z.object({
+  id: z.string().min(1),
+  tone: z.enum(['info', 'warning', 'danger', 'success']),
+  title: z.string().min(1),
+  description: z.string().optional(),
+  params: z.record(z.string(), z.union([z.string(), z.number()])).optional(),
+  notify: z.boolean().optional(),
+  expiresAt: z.number().optional(),
+  actionIds: z.array(z.string()).optional(),
+});
+export type StrategyAttention = z.infer<typeof StrategyAttentionSchema>;
+
+export const StrategyCompletionProjectionSchema = z.object({
+  state: z.enum(['not-ready', 'ready', 'committing', 'committed', 'failed']),
+  label: z.string().optional(),
+  recordId: z.string().optional(),
+});
+export type StrategyCompletionProjection = z.infer<typeof StrategyCompletionProjectionSchema>;
+
+export const StrategyStreamSnapshotSchema = z.object({
+  streamId: z.string().min(1),
+  currentState: z.string(),
+  targetCallsign: z.string().optional(),
+  targetGrid: z.string().optional(),
+  audioFrequencyHz: z.number().min(0).max(5000),
+  qsoLifecycleEpoch: z.number().int().nonnegative(),
+  stateOptions: z.array(StrategyStateOptionSchema).optional(),
+  actions: z.array(StrategyActionDescriptorSchema).optional(),
+  attentions: z.array(StrategyAttentionSchema).optional(),
+  completion: StrategyCompletionProjectionSchema.optional(),
+  lastReceivedText: z.string().optional(),
+  nextTransmitText: z.string().optional(),
+});
+export type StrategyStreamSnapshot = z.infer<typeof StrategyStreamSnapshotSchema>;
+
+export const StrategyTransmissionSchema = z.object({
+  streamId: z.string().min(1),
+  text: z.string().min(1),
+  audioFrequencyHz: z.number().min(0).max(5000),
+});
+export type StrategyTransmission = z.infer<typeof StrategyTransmissionSchema>;
+
 export const AssistedQueueDisplayStateSchema = z.enum([
   'TX1', 'TX2', 'TX3', 'TX4', 'TX5', 'engaged', 'closing', 'paused', 'no-response', 'later', 'review',
+  'candidate', 'authorized', 'dupe',
 ]);
 export const AssistedQueuePauseReasonSchema = z.enum(['target-busy', 'stale']);
 export const AssistedQueueToneSchema = z.enum(['neutral', 'active', 'success', 'warning', 'danger']);
@@ -430,10 +574,18 @@ export const AssistedQueueRowSchema = z.object({
   targetGrid: z.string().optional(),
   lastSnr: z.number().optional(),
   lastHeardCyclesAgo: z.number().int().nonnegative().optional(),
+  lastHeardCycle: z.union([z.literal(0), z.literal(1)]).optional(),
+  streamId: z.string().optional(),
+  audioFrequencyHz: z.number().optional(),
+  authorizationId: z.string().optional(),
+  actions: z.array(StrategyActionDescriptorSchema).optional(),
 });
 export const AssistedQueueSnapshotSchema = z.object({
   version: z.number().int().nonnegative(),
   activeEntryId: z.string().optional(),
+  activeEntryIds: z.array(z.string()).optional(),
+  maxActiveStreams: z.number().int().min(1).max(5).optional(),
+  requestedMaxActiveStreams: z.number().int().min(1).max(5).optional(),
   rows: z.array(AssistedQueueRowSchema),
 });
 export type AssistedQueueDisplayState = z.infer<typeof AssistedQueueDisplayStateSchema>;
@@ -443,6 +595,63 @@ export type AssistedQueueIcon = z.infer<typeof AssistedQueueIconSchema>;
 export type AssistedQueueRow = z.infer<typeof AssistedQueueRowSchema>;
 export type AssistedQueueSnapshot = z.infer<typeof AssistedQueueSnapshotSchema>;
 
+/** Null clears an unsettable runtime report field over JSON/WebSocket. */
+export const OperatorContextReportFieldSchema = z.number().nullish();
+
+export const StrategyMessagePresentationToneSchema = z.enum([
+  'neutral', 'primary', 'secondary', 'success', 'warning', 'danger',
+]);
+export const StrategyMessagePresentationBadgeSchema = z.object({
+  label: z.string().min(1),
+  tone: StrategyMessagePresentationToneSchema,
+});
+export const StrategyMessagePresentationTokenMatchSchema = z.object({
+  firstTokenIn: z.array(z.string().min(1)).optional(),
+  anyTokenIn: z.array(z.string().min(1)).optional(),
+});
+export const StrategyMessagePresentationClassSchema = z.object({
+  badge: StrategyMessagePresentationBadgeSchema.optional(),
+  badges: z.array(StrategyMessagePresentationBadgeSchema).optional(),
+  row: z.object({
+    tone: StrategyMessagePresentationToneSchema,
+    background: z.enum(['none', 'soft']).optional(),
+    accent: z.boolean().optional(),
+  }).optional(),
+  emphasisWhen: z.array(StrategyMessagePresentationTokenMatchSchema).min(1).optional(),
+  textDecoration: z.literal('line-through').optional(),
+  opacity: z.enum(['normal', 'muted']).optional(),
+});
+export const StrategyMessagePresentationProjectionSchema = z.object({
+  revision: z.number().int().nonnegative(),
+  mode: z.enum(['replace-logbook', 'augment']),
+  subject: z.literal('sender-callsign'),
+  partitionBy: z.enum(['band', 'mode', 'none']),
+  eligiblePartitions: z.array(z.string()).optional(),
+  defaultClass: z.string().optional(),
+  classes: z.record(z.string(), StrategyMessagePresentationClassSchema),
+  assignments: z.array(z.object({
+    subject: z.string().min(1),
+    partition: z.string().optional(),
+    classId: z.string().min(1),
+  })),
+  noveltyRules: z.array(z.object({
+    fact: z.literal('grid-field-2'),
+    knownValuesByPartition: z.record(z.string(), z.array(z.string().min(1))),
+    classId: z.string().min(1),
+  })).optional(),
+  tagRules: z.array(z.object({
+    id: z.string().min(1),
+    match: StrategyMessagePresentationTokenMatchSchema,
+    badge: StrategyMessagePresentationBadgeSchema,
+  })).optional(),
+});
+
+export type StrategyMessagePresentationTone = z.infer<typeof StrategyMessagePresentationToneSchema>;
+export type StrategyMessagePresentationBadge = z.infer<typeof StrategyMessagePresentationBadgeSchema>;
+export type StrategyMessagePresentationTokenMatch = z.infer<typeof StrategyMessagePresentationTokenMatchSchema>;
+export type StrategyMessagePresentationClass = z.infer<typeof StrategyMessagePresentationClassSchema>;
+export type StrategyMessagePresentationProjection = z.infer<typeof StrategyMessagePresentationProjectionSchema>;
+
 export const StrategyRuntimeSnapshotSchema = z.object({
   currentState: z.string(),
   slots: z.object({
@@ -456,8 +665,32 @@ export const StrategyRuntimeSnapshotSchema = z.object({
   context: StrategyRuntimeContextSchema.optional(),
   availableSlots: z.array(z.string()).optional(),
   qsoLifecycleEpoch: z.number().int().nonnegative().optional(),
+  streams: z.array(StrategyStreamSnapshotSchema).optional(),
   queue: AssistedQueueSnapshotSchema.optional(),
+  actions: z.array(StrategyActionDescriptorSchema).optional(),
+  attentions: z.array(StrategyAttentionSchema).optional(),
+  messagePresentation: StrategyMessagePresentationProjectionSchema.optional(),
+  transmitGate: z.object({
+    allowed: z.literal(false),
+    reason: z.string().min(1),
+    actionId: z.string().optional(),
+  }).optional(),
 });
+
+export const StrategyActionTargetSchema = z.discriminatedUnion('kind', [
+  z.object({ kind: z.literal('runtime') }),
+  z.object({
+    kind: z.literal('stream'),
+    streamId: z.string().min(1),
+    lifecycleEpoch: z.number().int().nonnegative(),
+  }),
+  z.object({
+    kind: z.literal('queue-entry'),
+    entryId: z.string().min(1),
+    queueVersion: z.number().int().nonnegative(),
+  }),
+]);
+export type StrategyActionTarget = z.infer<typeof StrategyActionTargetSchema>;
 export type StrategyRuntimeSnapshot = z.infer<typeof StrategyRuntimeSnapshotSchema>;
 
 export const LevelMeterDisplayStyleSchema = z.enum([
@@ -515,11 +748,12 @@ export const MeterDataSchema = z.object({
     raw: z.number(),
     percent: z.number(),
     alert: z.boolean(),
+    unit: z.enum(['percent', 'dbfs']).optional(),
   }).nullable(),
   level: LevelMeterReadingSchema.nullable(),
   power: z.object({
     raw: z.number(),
-    percent: z.number(),
+    percent: z.number().nullable(),
     watts: z.number().nullable(),  // 绝对瓦数（仅当电台支持 RFPOWER_METER_WATTS 时非 null）
     maxWatts: z.number().nullable(), // 当前频率+模式对应的量程瓦数
   }).nullable(),
@@ -566,6 +800,56 @@ export const WSModeChangedMessageSchema = WSBaseMessageSchema.extend({
   data: ModeDescriptorSchema,
 });
 
+export const WSSubscribeImageRxMessageSchema = WSBaseMessageSchema.extend({
+  type: z.literal(WSMessageType.SUBSCRIBE_IMAGE_RX),
+  data: ImageRxSubscriptionSchema,
+});
+
+export const WSImageRadioStatusMessageSchema = WSBaseMessageSchema.extend({
+  type: z.literal(WSMessageType.IMAGE_RADIO_STATUS),
+  data: ImageRadioStatusSchema,
+});
+
+export const WSImageRxEventMessageSchema = WSBaseMessageSchema.extend({
+  type: z.literal(WSMessageType.IMAGE_RX_EVENT),
+  data: ImageRxEventSchema,
+});
+
+export const WSSstvTxStartMessageSchema = WSBaseMessageSchema.extend({
+  type: z.literal(WSMessageType.SSTV_TX_START),
+  data: SstvTxStartCommandSchema,
+});
+
+export const WSSstvTxCancelMessageSchema = WSBaseMessageSchema.extend({
+  type: z.literal(WSMessageType.SSTV_TX_CANCEL),
+  data: SstvTxCancelCommandSchema,
+});
+
+export const WSSstvTxStatusMessageSchema = WSBaseMessageSchema.extend({
+  type: z.literal(WSMessageType.SSTV_TX_STATUS),
+  data: SstvTxStatusSchema,
+});
+
+export const WSSstvTxCommandResultMessageSchema = WSBaseMessageSchema.extend({
+  type: z.literal(WSMessageType.SSTV_TX_COMMAND_RESULT),
+  data: SstvTxCommandResultSchema,
+});
+
+export const WSFaxCalibrationSetMessageSchema = WSBaseMessageSchema.extend({
+  type: z.literal(WSMessageType.FAX_CALIBRATION_SET),
+  data: FaxCalibrationSetCommandSchema,
+});
+
+export const WSFaxCalibrationResetMessageSchema = WSBaseMessageSchema.extend({
+  type: z.literal(WSMessageType.FAX_CALIBRATION_RESET),
+  data: FaxCalibrationResetCommandSchema,
+});
+
+export const WSFaxCalibrationCommandResultMessageSchema = WSBaseMessageSchema.extend({
+  type: z.literal(WSMessageType.FAX_CALIBRATION_COMMAND_RESULT),
+  data: FaxCalibrationCommandResultSchema,
+});
+
 export const WSSlotStartMessageSchema = WSBaseMessageSchema.extend({
   type: z.literal(WSMessageType.SLOT_START),
   data: SlotInfoSchema,
@@ -590,9 +874,15 @@ export const WSSubscribeSpectrumMessageSchema = WSBaseMessageSchema.extend({
   type: z.literal(WSMessageType.SUBSCRIBE_SPECTRUM),
   data: z.object({
     kind: SpectrumKindSchema.nullable(),
+    viewport: SpectrumViewportSchema.optional(),
   }),
 });
 
+export const WSSpectrumViewportChangedMessageSchema = WSBaseMessageSchema.extend({
+  type: z.literal(WSMessageType.SPECTRUM_VIEWPORT_CHANGED),
+  data: SpectrumViewportSchema.nullable(),
+});
+
 export const WSSpectrumSubscriptionChangedMessageSchema = WSBaseMessageSchema.extend({
   type: z.literal(WSMessageType.SPECTRUM_SUBSCRIPTION_CHANGED),
   data: z.object({
@@ -707,10 +997,13 @@ export const OperatorStatusSchema = z.object({
   isTransmitting: z.boolean(), // 是否已授予策略自动发射许可（发射开关状态）
   isInActivePTT: z.boolean().optional(), // 该操作员的音频是否正在被实际播放
   hasTransmitIntent: z.boolean().optional(), // 当前策略是否有可在合法周期发射的有效内容
+  currentTransmissions: z.array(StrategyTransmissionSchema).optional(),
   currentSlot: z.string().optional(),
   context: z.object({
     myCall: z.string(),
     myGrid: z.string(),
+    /** Canonical active target set; `targetCall` remains the primary compatibility field. */
+    targetCalls: z.array(z.string()).optional(),
     targetCall: z.string(),
     targetGrid: z.string().optional(),
     frequency: z.number().optional(),
@@ -776,8 +1069,8 @@ export const WSSetOperatorContextMessageSchema = WSBaseMessageSchema.extend({
       targetCallsign: z.string().optional(),
       targetGrid: z.string().optional(),
       frequency: z.number().optional(),
-      reportSent: z.number().optional(),
-      reportReceived: z.number().optional(),
+      reportSent: OperatorContextReportFieldSchema,
+      reportReceived: OperatorContextReportFieldSchema,
     }),
   }),
 });
@@ -793,6 +1086,27 @@ export const WSSetOperatorRuntimeStateMessageSchema = WSBaseMessageSchema.extend
   }),
 });
 
+/** Sets one strategy-owned stream to a protocol-approved state. */
+export const WSSetOperatorStreamStateMessageSchema = WSBaseMessageSchema.extend({
+  type: z.literal(WSMessageType.SET_OPERATOR_STREAM_STATE),
+  data: z.object({
+    operatorId: z.string(),
+    streamId: z.string().min(1),
+    stateId: z.string().min(1),
+    expectedLifecycleEpoch: z.number().int().nonnegative(),
+  }),
+});
+
+export const WSInvokeOperatorStrategyActionMessageSchema = WSBaseMessageSchema.extend({
+  type: z.literal(WSMessageType.INVOKE_OPERATOR_STRATEGY_ACTION),
+  data: z.object({
+    operatorId: z.string().min(1),
+    target: StrategyActionTargetSchema,
+    actionId: z.string().min(1),
+    payload: z.unknown().optional(),
+  }),
+});
+
 /**
  * 设置操作员运行时槽位内容消息
  */
@@ -965,6 +1279,8 @@ export type WSOperatorsListMessage = z.infer<typeof WSOperatorsListMessageSchema
 export type WSOperatorStatusUpdateMessage = z.infer<typeof WSOperatorStatusUpdateMessageSchema>;
 export type WSSetOperatorContextMessage = z.infer<typeof WSSetOperatorContextMessageSchema>;
 export type WSSetOperatorRuntimeStateMessage = z.infer<typeof WSSetOperatorRuntimeStateMessageSchema>;
+export type WSSetOperatorStreamStateMessage = z.infer<typeof WSSetOperatorStreamStateMessageSchema>;
+export type WSInvokeOperatorStrategyActionMessage = z.infer<typeof WSInvokeOperatorStrategyActionMessageSchema>;
 export type WSSetOperatorRuntimeSlotContentMessage = z.infer<typeof WSSetOperatorRuntimeSlotContentMessageSchema>;
 export type WSSetOperatorTransmitCyclesMessage = z.infer<typeof WSSetOperatorTransmitCyclesMessageSchema>;
 export type WSStartOperatorMessage = z.infer<typeof WSStartOperatorMessageSchema>;
@@ -1551,12 +1867,23 @@ export const WSMessageSchema = z.discriminatedUnion('type', [
   WSPongMessageSchema,
   // 服务端到客户端
   WSModeChangedMessageSchema,
+  WSSubscribeImageRxMessageSchema,
+  WSImageRadioStatusMessageSchema,
+  WSImageRxEventMessageSchema,
+  WSSstvTxStartMessageSchema,
+  WSSstvTxCancelMessageSchema,
+  WSSstvTxStatusMessageSchema,
+  WSSstvTxCommandResultMessageSchema,
+  WSFaxCalibrationSetMessageSchema,
+  WSFaxCalibrationResetMessageSchema,
+  WSFaxCalibrationCommandResultMessageSchema,
   WSSlotStartMessageSchema,
   WSSubWindowMessageSchema,
   WSSlotPackUpdatedMessageSchema,
   WSSpectrumCapabilitiesMessageSchema,
   WSSubscribeSpectrumMessageSchema,
   WSSpectrumSubscriptionChangedMessageSchema,
+  WSSpectrumViewportChangedMessageSchema,
   WSSpectrumFrameMessageSchema,
   WSSpectrumSessionStateChangedMessageSchema,
   WSInvokeSpectrumControlMessageSchema,
@@ -1581,6 +1908,8 @@ export const WSMessageSchema = z.discriminatedUnion('type', [
   WSOperatorStatusUpdateMessageSchema,
   WSSetOperatorContextMessageSchema,
   WSSetOperatorRuntimeStateMessageSchema,
+  WSSetOperatorStreamStateMessageSchema,
+  WSInvokeOperatorStrategyActionMessageSchema,
   WSSetOperatorRuntimeSlotContentMessageSchema,
   WSSetOperatorTransmitCyclesMessageSchema,
   WSStartOperatorMessageSchema,
@@ -1679,6 +2008,7 @@ export type WSSlotPackUpdatedMessage = z.infer<typeof WSSlotPackUpdatedMessageSc
 export type WSSpectrumCapabilitiesMessage = z.infer<typeof WSSpectrumCapabilitiesMessageSchema>;
 export type WSSubscribeSpectrumMessage = z.infer<typeof WSSubscribeSpectrumMessageSchema>;
 export type WSSpectrumSubscriptionChangedMessage = z.infer<typeof WSSpectrumSubscriptionChangedMessageSchema>;
+export type WSSpectrumViewportChangedMessage = z.infer<typeof WSSpectrumViewportChangedMessageSchema>;
 export type WSSpectrumFrameMessage = z.infer<typeof WSSpectrumFrameMessageSchema>;
 export type WSSpectrumSessionStateChangedMessage = z.infer<typeof WSSpectrumSessionStateChangedMessageSchema>;
 export type WSInvokeSpectrumControlMessage = z.infer<typeof WSInvokeSpectrumControlMessageSchema>;
@@ -1696,7 +2026,9 @@ export type WSGetStatusMessage = z.infer<typeof WSGetStatusMessageSchema>;
 
 export const TransmitRequestSchema = z.object({
   operatorId: z.string(),
+  streamId: z.string().min(1).optional(),
   transmission: z.string(),
+  audioFrequencyHz: z.number().min(0).max(5000).optional(),
   /** 是否覆盖同一操作员在同一时隙的现有 TX 帧（自动重决策时为 true） */
   replaceExisting: z.boolean().optional(),
   source: z.enum(['standard-qso', 'plugin', 'late-decode', 'operator-edit', 'manual']).optional(),
@@ -1707,6 +2039,20 @@ export const TransmitRequestSchema = z.object({
 
 export type TransmitRequest = z.infer<typeof TransmitRequestSchema>;
 
+export const TransmitBatchRequestSchema = z.object({
+  operatorId: z.string(),
+  transmissions: z.array(z.object({
+    streamId: z.string().min(1),
+    transmission: z.string(),
+    audioFrequencyHz: z.number().min(0).max(5000),
+  })).max(5),
+  replaceExisting: z.boolean().optional(),
+  source: z.enum(['standard-qso', 'plugin', 'late-decode', 'operator-edit', 'manual']).optional(),
+  reason: z.string().optional(),
+  decisionEpoch: z.number().int().nonnegative().optional(),
+});
+export type TransmitBatchRequest = z.infer<typeof TransmitBatchRequestSchema>;
+
 // ===== 前端应用事件接口 =====
 
 /**
@@ -1714,6 +2060,8 @@ export type TransmitRequest = z.infer<typeof TransmitRequestSchema>;
  */
 export const TransmissionCompleteInfoSchema = z.object({
   operatorId: z.string(),
+  streamId: z.string().optional(),
+  trackId: z.string().optional(),
   success: z.boolean(),
   frameId: z.string().optional(),
   physicalConfirmed: z.boolean().optional(),
@@ -1747,9 +2095,11 @@ export interface DigitalRadioEngineEvents {
 
   // 发射相关事件
   requestTransmit: (request: TransmitRequest) => void;
+  requestTransmitBatch: (request: TransmitBatchRequest) => void;
   transmissionComplete: (info: TransmissionCompleteInfo) => void;
   transmissionLog: (data: {
     operatorId: string;
+    streamId: string;
     frameId: string;
     revision: number;
     playbackGeneration: number;
@@ -1791,6 +2141,11 @@ export interface DigitalRadioEngineEvents {
   // PTT状态控制事件
   pttStatusChanged: (data: PTTStatus) => void;
   tuneToneStatusChanged: (data: TuneToneStatus) => void;
+  imageRadioStatus: (data: ImageRadioStatus) => void;
+  imageRxEvent: (data: ImageRxEvent) => void;
+  sstvTxStatus: (data: SstvTxStatus) => void;
+  sstvTxCommandResult: (data: SstvTxCommandResult) => void;
+  faxCalibrationCommandResult: (data: FaxCalibrationCommandResult) => void;
 
   // 电台数值表事件
   meterData: (data: MeterData) => void;
@@ -1824,7 +2179,7 @@ export interface DigitalRadioEngineEvents {
 
   // Profile 管理事件
   profileChanged: (data: z.infer<typeof ProfileChangedEventSchema>) => void;
-  profileListUpdated: (data: { profiles: z.infer<typeof RadioProfileSchema>[]; activeProfileId: string | null }) => void;
+  profileListUpdated: (data: { profiles: z.infer<typeof RadioProfileSchema>[]; activeProfileId: string | null; hasConfiguredProfiles?: boolean }) => void;
   realtimeSettingsChanged: (data: RealtimeSettingsResponseData) => void;
 
   // 认证事件
@@ -1890,10 +2245,18 @@ export interface DigitalRadioEngineEvents {
   transmitStart: (slotInfo: z.infer<typeof SlotInfoSchema>) => void;
   timingWarning: (data: { title: string; text: string }) => void;
   operatorSlotChanged: (data: { operatorId: string; slot: string }) => void;
+  operatorStreamStateChanged: (data: {
+    operatorId: string;
+    streamId: string;
+    state: string;
+    commandEpoch?: number;
+    source?: 'manual' | 'plugin' | 'late-decode' | 'slot-auto';
+  }) => void;
   operatorSlotContentChanged: (data: { operatorId: string; slot: string; content: string }) => void;
   operatorFrequencyChanged: (data: { operatorId: string; frequency: number }) => void;
   operatorTransmitCyclesChanged: (data: {
     operatorId: string;
+    previousTransmitCycles?: number[];
     transmitCycles: number[];
     commandEpoch?: number;
     source?: 'manual' | 'plugin' | 'late-decode' | 'slot-auto';
@@ -1901,15 +2264,23 @@ export interface DigitalRadioEngineEvents {
   }) => void;
   qsoLifecycleChanged: (data: {
     operatorId: string;
+    streamId?: string;
     lifecycleEpoch: number;
     runtimeGeneration?: number;
   }) => void;
   recordQSO: (data: {
     operatorId: string;
+    streamId?: string;
     qsoLifecycleId?: string;
     qsoLifecycleEpoch?: number;
     qsoRuntimeGeneration?: number;
     qsoRecord: z.infer<typeof QSORecordSchema>;
+    persistencePolicy?: z.infer<typeof QSOPersistencePolicySchema>;
+    destination?:
+      | { kind: 'plugin-session'; sessionId: string }
+      | { kind: 'plugin-session-key'; sessionKey: string };
+    sourcePluginName?: string;
+    metadata?: Record<string, unknown>;
     retryAttemptId?: string;
     resolve?: (record: z.infer<typeof QSORecordSchema>) => void;
     reject?: (error: unknown) => void;