@tx5dr/contracts 1.7.3 → 1.7.4

package/src/schema/__tests__/radio.schema.test.ts

@@ -0,0 +1,160 @@
+import { describe, expect, it } from 'vitest';
+import { PresetFrequencySchema } from '../radio.schema.js';
+
+describe('PresetFrequencySchema repeater DUP fields', () => {
+  it('accepts existing presets without repeater DUP fields', () => {
+    const parsed = PresetFrequencySchema.parse({
+      band: '2m',
+      mode: 'VOICE',
+      radioMode: 'FM',
+      frequency: 145000000,
+      description: '145.000 MHz 2m FM',
+    });
+
+    expect(parsed.repeaterShift).toBeUndefined();
+    expect(parsed.repeaterOffsetHz).toBeUndefined();
+  });
+
+  it('accepts plus or minus DUP presets with positive Hz offsets', () => {
+    const parsed = PresetFrequencySchema.parse({
+      band: '2m',
+      mode: 'VOICE',
+      radioMode: 'FM',
+      frequency: 145000000,
+      repeaterShift: 'plus',
+      repeaterOffsetHz: 600000,
+    });
+
+    expect(parsed.repeaterShift).toBe('plus');
+    expect(parsed.repeaterOffsetHz).toBe(600000);
+  });
+
+  it('rejects DUP direction without a positive offset', () => {
+    expect(() => PresetFrequencySchema.parse({
+      band: '2m',
+      mode: 'VOICE',
+      radioMode: 'FM',
+      frequency: 145000000,
+      repeaterShift: 'minus',
+    })).toThrow();
+
+    expect(() => PresetFrequencySchema.parse({
+      band: '2m',
+      mode: 'VOICE',
+      radioMode: 'FM',
+      frequency: 145000000,
+      repeaterShift: 'minus',
+      repeaterOffsetHz: 0,
+    })).toThrow();
+  });
+
+  it('rejects invalid DUP directions', () => {
+    expect(() => PresetFrequencySchema.parse({
+      band: '2m',
+      mode: 'VOICE',
+      radioMode: 'FM',
+      frequency: 145000000,
+      repeaterShift: 'up',
+      repeaterOffsetHz: 600000,
+    })).toThrow();
+  });
+
+  it('rejects DUP presets outside VOICE FM', () => {
+    expect(() => PresetFrequencySchema.parse({
+      band: '20m',
+      mode: 'VOICE',
+      radioMode: 'USB',
+      frequency: 14270000,
+      repeaterShift: 'plus',
+      repeaterOffsetHz: 600000,
+    })).toThrow();
+  });
+});
+
+describe('PresetFrequencySchema tone squelch fields', () => {
+  it('accepts CTCSS tone presets with positive 0.1 Hz values', () => {
+    const parsed = PresetFrequencySchema.parse({
+      band: '2m',
+      mode: 'VOICE',
+      radioMode: 'FM',
+      frequency: 145000000,
+      toneMode: 'ctcss',
+      ctcssToneTenthsHz: 885,
+    });
+
+    expect(parsed.toneMode).toBe('ctcss');
+    expect(parsed.ctcssToneTenthsHz).toBe(885);
+  });
+
+  it('accepts DCS presets with positive codes', () => {
+    const parsed = PresetFrequencySchema.parse({
+      band: '2m',
+      mode: 'VOICE',
+      radioMode: 'FM',
+      frequency: 145000000,
+      toneMode: 'dcs',
+      dcsCode: 23,
+    });
+
+    expect(parsed.toneMode).toBe('dcs');
+    expect(parsed.dcsCode).toBe(23);
+  });
+
+  it('rejects tone squelch modes without required values', () => {
+    expect(() => PresetFrequencySchema.parse({
+      band: '2m',
+      mode: 'VOICE',
+      radioMode: 'FM',
+      frequency: 145000000,
+      toneMode: 'ctcss',
+    })).toThrow();
+
+    expect(() => PresetFrequencySchema.parse({
+      band: '2m',
+      mode: 'VOICE',
+      radioMode: 'FM',
+      frequency: 145000000,
+      toneMode: 'dcs',
+    })).toThrow();
+  });
+
+  it('rejects invalid tone squelch values and modes', () => {
+    expect(() => PresetFrequencySchema.parse({
+      band: '2m',
+      mode: 'VOICE',
+      radioMode: 'FM',
+      frequency: 145000000,
+      toneMode: 'ctcss',
+      ctcssToneTenthsHz: 0,
+    })).toThrow();
+
+    expect(() => PresetFrequencySchema.parse({
+      band: '2m',
+      mode: 'VOICE',
+      radioMode: 'FM',
+      frequency: 145000000,
+      toneMode: 'dcs',
+      dcsCode: -1,
+    })).toThrow();
+
+    expect(() => PresetFrequencySchema.parse({
+      band: '2m',
+      mode: 'VOICE',
+      radioMode: 'FM',
+      frequency: 145000000,
+      toneMode: 'tone',
+      ctcssToneTenthsHz: 885,
+    })).toThrow();
+  });
+
+  it('rejects tone squelch presets outside VOICE FM', () => {
+    expect(() => PresetFrequencySchema.parse({
+      band: '20m',
+      mode: 'VOICE',
+      radioMode: 'USB',
+      frequency: 14270000,
+      toneMode: 'ctcss',
+      ctcssToneTenthsHz: 885,
+    })).toThrow();
+  });
+});

package/src/schema/ability.ts

@@ -34,6 +34,8 @@ export type CapabilitySubject =
   | 'RigctldBridge'
   | 'Engine'
   | 'ModeSwitch'
+  | 'CWDecoder'
+  | 'CWDecoderConfig'
   | 'SettingsDecodeWindows'
   | 'SettingsFrequencyPresets'
   | 'StationInfo';
@@ -59,6 +61,8 @@ export enum Permission {
   RIGCTLD_BRIDGE = 'rigctld:bridge',
   ENGINE_START_STOP = 'engine:start_stop',
   MODE_SWITCH = 'mode:switch',
+  CW_DECODER_CONTROL = 'cw:decoder_control',
+  CW_DECODER_CONFIG = 'cw:decoder_config',
   SETTINGS_DECODE_WINDOWS = 'settings:decode_windows',
   SETTINGS_FREQUENCY_PRESETS = 'settings:frequency_presets',
   STATION_UPDATE = 'station:update',
@@ -79,6 +83,8 @@ export const PERMISSION_RULE_MAP: Record<Permission, { action: AppAction; subjec
   [Permission.RIGCTLD_BRIDGE]: { action: 'execute', subject: 'RigctldBridge' },
   [Permission.ENGINE_START_STOP]: { action: 'execute', subject: 'Engine' },
   [Permission.MODE_SWITCH]: { action: 'execute', subject: 'ModeSwitch' },
+  [Permission.CW_DECODER_CONTROL]: { action: 'execute', subject: 'CWDecoder' },
+  [Permission.CW_DECODER_CONFIG]: { action: 'update', subject: 'CWDecoderConfig' },
   [Permission.SETTINGS_DECODE_WINDOWS]: { action: 'update', subject: 'SettingsDecodeWindows' },
   [Permission.SETTINGS_FREQUENCY_PRESETS]: { action: 'update', subject: 'SettingsFrequencyPresets' },
   [Permission.STATION_UPDATE]: { action: 'update', subject: 'StationInfo' },
@@ -181,6 +187,13 @@ export const PERMISSION_GROUPS: PermissionGroupDef[] = [
   },
   { key: 'engine', permissions: [Permission.ENGINE_START_STOP] },
   { key: 'mode', permissions: [Permission.MODE_SWITCH] },
+  {
+    key: 'cw',
+    permissions: [
+      Permission.CW_DECODER_CONTROL,
+      Permission.CW_DECODER_CONFIG,
+    ],
+  },
   {
     key: 'settings',
     permissions: [

package/src/schema/api-response.schema.ts

@@ -115,6 +115,23 @@ export const DisconnectRadioResponseSchema = z.object({
 export const LastFrequencyResponseSchema = z.object({
   success: z.boolean(),
   lastFrequency: PresetFrequencySchema.nullable(),
+  lastVoiceFrequency: z.object({
+    frequency: z.number(),
+    radioMode: z.string().optional(),
+    band: z.string(),
+    description: z.string().optional(),
+    repeaterShift: z.enum(['none', 'minus', 'plus']).optional(),
+    repeaterOffsetHz: z.number().optional(),
+    toneMode: z.enum(['none', 'ctcss', 'dcs']).optional(),
+    ctcssToneTenthsHz: z.number().optional(),
+    dcsCode: z.number().optional(),
+  }).nullable().optional(),
+  lastCWFrequency: z.object({
+    frequency: z.number(),
+    radioMode: z.string().optional(),
+    band: z.string(),
+    description: z.string().optional(),
+  }).nullable().optional(),
 });
 
 /**
@@ -127,6 +144,11 @@ export const SetFrequencyResponseSchema = z.object({
   mode: z.string().optional(),
   band: z.string().optional(),
   radioMode: z.string().optional(),
+  repeaterShift: z.enum(['none', 'minus', 'plus']).optional(),
+  repeaterOffsetHz: z.number().optional(),
+  toneMode: z.enum(['none', 'ctcss', 'dcs']).optional(),
+  ctcssToneTenthsHz: z.number().optional(),
+  dcsCode: z.number().optional(),
   radioConnected: z.boolean().optional(),
 });
 

package/src/schema/cw-decoder.schema.ts

@@ -0,0 +1,234 @@
+import { z } from 'zod';
+
+export const CWDecoderBackendSchema = z.enum(['deepcw-onnx']);
+export type CWDecoderBackend = z.infer<typeof CWDecoderBackendSchema>;
+
+export const CWDecoderRuntimeBackendSchema = z.enum([
+  'cpu',
+  'cuda',
+  'coreml',
+  'directml',
+  'wasm',
+  'webgpu',
+]);
+export type CWDecoderRuntimeBackend = z.infer<typeof CWDecoderRuntimeBackendSchema>;
+
+export const CWDecoderModelSizeSchema = z.enum(['tiny', 'small']);
+export type CWDecoderModelSize = z.infer<typeof CWDecoderModelSizeSchema>;
+
+export const CWDecoderModeSchema = z.enum(['streaming']);
+export type CWDecoderMode = z.infer<typeof CWDecoderModeSchema>;
+
+export const CWDecoderConfigSchema = z.object({
+  enabled: z.boolean().default(false),
+  backend: CWDecoderBackendSchema.default('deepcw-onnx'),
+  runtimeBackend: CWDecoderRuntimeBackendSchema.default('cpu'),
+  modelSize: CWDecoderModelSizeSchema.default('tiny'),
+  language: z.string().min(1).default('en'),
+  mode: CWDecoderModeSchema.default('streaming'),
+  targetFreqHz: z.number().int().positive().default(800),
+  filterWidthHz: z.number().int().positive().default(800),
+  windowSeconds: z.number().positive().default(12),
+  decodeIntervalMs: z.number().int().positive().default(1000),
+  muteWhileTransmitting: z.boolean().default(true),
+  workerCount: z.number().int().positive().max(4).default(1),
+  minCommitChars: z.number().int().positive().default(1),
+  commitStability: z.number().int().positive().default(2),
+  maxPendingAgeMs: z.number().int().positive().default(4000),
+});
+export type CWDecoderConfig = z.infer<typeof CWDecoderConfigSchema>;
+
+export const CWDecoderTuningUpdateSchema = z.object({
+  targetFreqHz: z.number().int().min(100).max(1500).optional(),
+  filterWidthHz: z.number().int().min(100).max(800).optional(),
+}).refine(value => value.targetFreqHz !== undefined || value.filterWidthHz !== undefined, {
+  message: 'At least one CW decoder tuning field is required',
+});
+export type CWDecoderTuningUpdate = z.infer<typeof CWDecoderTuningUpdateSchema>;
+
+export const CWDecoderBackendDescriptorSchema = z.object({
+  id: CWDecoderBackendSchema,
+  name: z.string(),
+  available: z.boolean(),
+  runtimeBackends: z.array(CWDecoderRuntimeBackendSchema).default(['cpu']),
+  modelSizes: z.array(CWDecoderModelSizeSchema).default(['tiny']),
+  languages: z.array(z.string()).default(['en']),
+  modes: z.array(CWDecoderModeSchema).default(['streaming']),
+  version: z.string().optional(),
+  label: z.string().optional(),
+  model: z.string().optional(),
+  runtime: z.string().optional(),
+  attributionName: z.string().optional(),
+  sourceUrl: z.string().url().optional(),
+  license: z.string().optional(),
+  error: z.string().nullable().optional(),
+  reason: z.string().optional(),
+});
+export type CWDecoderBackendDescriptor = z.infer<typeof CWDecoderBackendDescriptorSchema>;
+
+export const CWDecoderStatusStateSchema = z.enum([
+  'disabled',
+  'starting',
+  'listening',
+  'decoding',
+  'muted',
+  'error',
+]);
+export type CWDecoderStatusState = z.infer<typeof CWDecoderStatusStateSchema>;
+
+export const CWDecoderStatusSchema = z.object({
+  enabled: z.boolean(),
+  state: CWDecoderStatusStateSchema,
+  config: CWDecoderConfigSchema,
+  backend: CWDecoderBackendDescriptorSchema.optional(),
+  muted: z.boolean().default(false),
+  active: z.boolean().default(false),
+  lastDecodeAt: z.number().optional(),
+  lastError: z.string().nullable().optional(),
+  running: z.boolean().optional(),
+  backendId: CWDecoderBackendSchema.optional(),
+  pendingText: z.string().optional(),
+  committedText: z.string().optional(),
+  queuedSamples: z.number().int().nonnegative().optional(),
+  updatedAt: z.number(),
+});
+export type CWDecoderStatus = z.infer<typeof CWDecoderStatusSchema>;
+
+export const CWDecoderWordSpaceSpanSchema = z.object({
+  startFrame: z.number().int().nonnegative(),
+  endFrame: z.number().int().nonnegative(),
+});
+export type CWDecoderWordSpaceSpan = z.infer<typeof CWDecoderWordSpaceSpanSchema>;
+
+export const CWDecoderCharacterSpanSchema = z.object({
+  char: z.string(),
+  startFrame: z.number().int().nonnegative(),
+  endFrame: z.number().int().nonnegative(),
+});
+export type CWDecoderCharacterSpan = z.infer<typeof CWDecoderCharacterSpanSchema>;
+
+export const CWDecoderTranscriptSegmentSchema = z.object({
+  id: z.string(),
+  sessionId: z.string(),
+  sequence: z.number().int().nonnegative(),
+  text: z.string(),
+  plainText: z.string().optional(),
+  finalized: z.literal(true).default(true),
+  prependSpace: z.boolean().default(true),
+  confidence: z.number().min(0).max(1).optional(),
+  targetFreqHz: z.number().positive().optional(),
+  filterWidthHz: z.number().positive().optional(),
+  characterSpans: z.array(CWDecoderCharacterSpanSchema).optional(),
+  wordSpaceSpans: z.array(CWDecoderWordSpaceSpanSchema).optional(),
+  startedAt: z.number().optional(),
+  endedAt: z.number().nullable().optional(),
+  updatedAt: z.number(),
+  wpm: z.number().positive().optional(),
+});
+export type CWDecoderTranscriptSegment = z.infer<typeof CWDecoderTranscriptSegmentSchema>;
+
+export const CWDecoderPendingSegmentSchema = z.object({
+  sessionId: z.string(),
+  version: z.number().int().nonnegative(),
+  text: z.string(),
+  plainText: z.string().optional(),
+  finalized: z.literal(false).default(false),
+  confidence: z.number().min(0).max(1).optional(),
+  targetFreqHz: z.number().positive().optional(),
+  filterWidthHz: z.number().positive().optional(),
+  characterSpans: z.array(CWDecoderCharacterSpanSchema).optional(),
+  wordSpaceSpans: z.array(CWDecoderWordSpaceSpanSchema).optional(),
+  updatedAt: z.number(),
+});
+export type CWDecoderPendingSegment = z.infer<typeof CWDecoderPendingSegmentSchema>;
+
+export const CWDecoderStatusEventSchema = z.object({
+  kind: z.literal('status'),
+  status: CWDecoderStatusSchema,
+});
+
+export const CWDecoderTranscriptEventSchema = z.object({
+  kind: z.literal('transcript'),
+  segment: CWDecoderTranscriptSegmentSchema,
+});
+
+export const CWDecoderTranscriptResetEventSchema = z.object({
+  kind: z.literal('transcript_reset'),
+  sessionId: z.string(),
+  timestamp: z.number(),
+});
+
+export const CWDecoderTranscriptPendingEventSchema = z.object({
+  kind: z.literal('transcript_pending'),
+  pending: CWDecoderPendingSegmentSchema.nullable(),
+  timestamp: z.number(),
+});
+
+export const CWDecoderTranscriptCommitEventSchema = z.object({
+  kind: z.literal('transcript_commit'),
+  segment: CWDecoderTranscriptSegmentSchema,
+  timestamp: z.number(),
+});
+
+export const CWDecoderPendingEventSchema = z.object({
+  kind: z.literal('pending'),
+  text: z.string(),
+  confidence: z.number().min(0).max(1).optional(),
+  timestamp: z.number(),
+});
+
+export const CWDecoderCommitEventSchema = z.object({
+  kind: z.literal('commit'),
+  segment: CWDecoderTranscriptSegmentSchema,
+  text: z.string().optional(),
+  confidence: z.number().min(0).max(1).optional(),
+  timestamp: z.number().optional(),
+});
+
+export const CWDecoderPartialEventSchema = z.object({
+  kind: z.literal('partial'),
+  text: z.string(),
+  confidence: z.number().min(0).max(1).optional(),
+  timestamp: z.number(),
+});
+
+export const CWDecoderErrorEventSchema = z.object({
+  kind: z.literal('error'),
+  message: z.string(),
+  code: z.string().optional(),
+  recoverable: z.boolean().optional(),
+  timestamp: z.number(),
+});
+
+export const CWDecoderModelLoadEventSchema = z.object({
+  kind: z.literal('model_load'),
+  backend: CWDecoderBackendSchema,
+  modelSize: CWDecoderModelSizeSchema.optional(),
+  language: z.string().optional(),
+  progress: z.number().min(0).max(1).optional(),
+  message: z.string().optional(),
+  timestamp: z.number(),
+});
+
+export const CWDecoderAudioBufferEventSchema = z.object({
+  kind: z.literal('audio_buffer'),
+  queuedSamples: z.number().int().nonnegative(),
+  sampleRate: z.number().int().positive().optional(),
+  durationMs: z.number().nonnegative().optional(),
+  timestamp: z.number(),
+});
+
+export const CWDecoderEventSchema = z.discriminatedUnion('kind', [
+  CWDecoderStatusEventSchema,
+  CWDecoderTranscriptEventSchema,
+  CWDecoderTranscriptResetEventSchema,
+  CWDecoderTranscriptPendingEventSchema,
+  CWDecoderTranscriptCommitEventSchema,
+  CWDecoderPendingEventSchema,
+  CWDecoderCommitEventSchema,
+  CWDecoderPartialEventSchema,
+  CWDecoderErrorEventSchema,
+  CWDecoderModelLoadEventSchema,
+  CWDecoderAudioBufferEventSchema,
+]);
+export type CWDecoderEvent = z.infer<typeof CWDecoderEventSchema>;

package/src/schema/cw-keyer.schema.ts

@@ -0,0 +1,177 @@
+import { z } from 'zod';
+
+/**
+ * CW 键控器配置
+ */
+export const CWKeyerBackendSchema = z.enum(['cat', 'serial']);
+export type CWKeyerBackend = z.infer<typeof CWKeyerBackendSchema>;
+
+export const CWKeyerConfigSchema = z.object({
+  /** CW 发报后端：cat=Hamlib 整报文，serial=DTR/RTS 时序键控 */
+  backend: CWKeyerBackendSchema.default('cat'),
+  /** CW 键控串口路径（用于 DTR/RTS 引脚控制） */
+  keyPort: z.string(),
+  /** CW 键控引脚类型 */
+  keyMethod: z.enum(['dtr', 'rts']),
+  /** 莫尔斯码速度 (WPM, 5-60) */
+  wpm: z.number().int().min(5).max(60).default(20),
+});
+
+export type CWKeyerConfig = z.infer<typeof CWKeyerConfigSchema>;
+
+/**
+ * CW 键控器状态
+ */
+export const CWKeyerStatusSchema = z.object({
+  /** 是否有活动键控 */
+  active: z.boolean(),
+  /** 当前状态模式 */
+  mode: z.enum(['idle', 'keying', 'playing', 'repeat-waiting', 'error']),
+  /** 发起键控的客户端 ID */
+  startedBy: z.string().nullable(),
+  /** 发起键控的客户端显示名 */
+  startedByLabel: z.string().nullable(),
+  /** 当前播放的报文 ID */
+  messageId: z.string().nullable(),
+  /** 下次执行时间戳 (repeat-waiting 时有效) */
+  nextRunAt: z.number().nullable(),
+  /** 错误信息 */
+  error: z.string().nullable(),
+  /** 当前 CW 发报后端 */
+  backend: CWKeyerBackendSchema.optional(),
+  /** 当前后端是否具备发报条件 */
+  backendAvailable: z.boolean().optional(),
+  /** 当前后端不可用原因 */
+  backendError: z.string().nullable().optional(),
+  /** 当前正在发送的文本（只读状态字段） */
+  currentText: z.string().nullable().optional(),
+  /** 最近一次发送的文本（只读状态字段） */
+  lastText: z.string().nullable().optional(),
+});
+
+export type CWKeyerStatus = z.infer<typeof CWKeyerStatusSchema>;
+
+/**
+ * CW 报文槽位
+ */
+export const CWMessageSlotSchema = z.object({
+  /** 槽位唯一 ID */
+  id: z.string(),
+  /** 显示序号 (1-based) */
+  index: z.number().int().min(1),
+  /** 报文标签 */
+  label: z.string(),
+  /** 报文文本内容 */
+  text: z.string(),
+  /** 是否启用循环播放 */
+  repeatEnabled: z.boolean(),
+  /** 循环播放间隔（秒） */
+  repeatIntervalSec: z.number().int().min(1).max(300),
+});
+
+export type CWMessageSlot = z.infer<typeof CWMessageSlotSchema>;
+
+/**
+ * CW 报文面板
+ */
+export const CWMessagePanelSchema = z.object({
+  /** 呼号 */
+  callsign: z.string(),
+  /** 当前槽位数 */
+  slotCount: z.number().int().min(3).max(12),
+  /** 最大槽位数 */
+  maxSlotCount: z.number().int().min(12),
+  /** 槽位列表 */
+  slots: z.array(CWMessageSlotSchema),
+});
+
+export type CWMessagePanel = z.infer<typeof CWMessagePanelSchema>;
+
+/**
+ * CW 手键动作
+ */
+export const CWKeyActionSchema = z.object({
+  /** 键控动作 */
+  action: z.enum(['key-down', 'key-up']),
+});
+
+export type CWKeyAction = z.infer<typeof CWKeyActionSchema>;
+
+/**
+ * CW 报文占位符值（由前端根据当前 UI 上下文提供）
+ */
+export const CWPlaceholderValuesSchema = z.object({
+  /** 当前操作员呼号，用于 {MYCALL} */
+  myCall: z.string().optional(),
+  /** 当前通联对象呼号，用于 {HISCALL} */
+  hisCall: z.string().optional(),
+  /** 发送的 RST 信号报告，用于 {TRST} */
+  trst: z.string().optional(),
+  /** 接收的 RST 信号报告，用于 {RRST} */
+  rrst: z.string().optional(),
+});
+
+export type CWPlaceholderValues = z.infer<typeof CWPlaceholderValuesSchema>;
+
+/**
+ * CW 文字输入
+ */
+export const CWTextInputSchema = z.object({
+  /** 要发送的文字 */
+  text: z.string().min(1).max(500),
+  /** 操作员呼号，用于占位符替换（如 {MYCALL}） */
+  callsign: z.string().optional(),
+  /** 前端解析出的占位符值 */
+  placeholderValues: CWPlaceholderValuesSchema.optional(),
+});
+
+export type CWTextInput = z.infer<typeof CWTextInputSchema>;
+
+/**
+ * CW 播放预设报文请求
+ */
+export const CWPlayMessageSchema = z.object({
+  /** 呼号 */
+  callsign: z.string(),
+  /** 报文槽位 ID */
+  slotId: z.string(),
+  /** 是否循环播放 */
+  repeat: z.boolean().optional().default(false),
+  /** 是否立即发送；false 时仅进入循环等待 */
+  startImmediately: z.boolean().optional(),
+  /** 前端解析出的占位符值 */
+  placeholderValues: CWPlaceholderValuesSchema.optional(),
+});
+
+export type CWPlayMessage = z.infer<typeof CWPlayMessageSchema>;
+
+/**
+ * CW 报文槽位更新
+ */
+export const CWMessageSlotUpdateSchema = z.object({
+  label: z.string().max(32).optional(),
+  text: z.string().max(500).optional(),
+  repeatEnabled: z.boolean().optional(),
+  repeatIntervalSec: z.number().int().min(1).max(300).optional(),
+});
+
+export type CWMessageSlotUpdate = z.infer<typeof CWMessageSlotUpdateSchema>;
+
+/**
+ * CW 报文面板更新
+ */
+export const CWMessagePanelUpdateSchema = z.object({
+  slotCount: z.number().int().min(3).max(12),
+});
+
+export type CWMessagePanelUpdate = z.infer<typeof CWMessagePanelUpdateSchema>;
+
+/**
+ * CW 报文槽位交换请求
+ */
+export const CWMessageSlotSwapSchema = z.object({
+  slotIdA: z.string(),
+  slotIdB: z.string(),
+});
+
+export type CWMessageSlotSwap = z.infer<typeof CWMessageSlotSwapSchema>;

package/src/schema/desktop-https.schema.ts

@@ -23,7 +23,7 @@ export const DesktopHttpsCertificateMetaSchema = z.object({
 export type DesktopHttpsCertificateMeta = z.infer<typeof DesktopHttpsCertificateMetaSchema>;
 
 export const DesktopHttpsSettingsSchema = z.object({
-  enabled: z.boolean().default(false),
+  enabled: z.boolean().default(true),
   mode: DesktopHttpsModeSchema.default('self-signed'),
   httpsPort: z.number().int().min(1).max(65535).default(8443),
   redirectExternalHttp: z.boolean().default(true),