@tx5dr/contracts 1.7.2 → 1.7.4

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),

package/src/schema/device-ui.schema.ts

@@ -0,0 +1,182 @@
+import { z } from 'zod';
+
+export const DEVICE_UI_JWT_TYPE = 'device-ui' as const;
+export const DEVICE_UI_JWT_AUDIENCE = 'tx5dr-device-ui' as const;
+
+export const DeviceUiJwtPayloadSchema = z.object({
+  typ: z.literal(DEVICE_UI_JWT_TYPE),
+  aud: z.literal(DEVICE_UI_JWT_AUDIENCE),
+  deviceId: z.string().min(1),
+  sessionId: z.string().min(1),
+  iat: z.number().int().nonnegative(),
+  exp: z.number().int().positive(),
+});
+
+export type DeviceUiJwtPayload = z.infer<typeof DeviceUiJwtPayloadSchema>;
+
+export const DeviceUiSessionRequestSchema = z.object({
+  deviceId: z.string().trim().min(1).max(128),
+  sessionToken: z.string().min(1),
+});
+
+export type DeviceUiSessionRequest = z.infer<typeof DeviceUiSessionRequestSchema>;
+
+export const DeviceUiSessionResponseSchema = z.object({
+  jwt: z.string().min(1),
+  deviceId: z.string().min(1),
+  sessionId: z.string().min(1),
+  expiresAt: z.number().int().positive(),
+});
+
+export type DeviceUiSessionResponse = z.infer<typeof DeviceUiSessionResponseSchema>;
+
+export const DeviceUiAuthSessionStateSchema = z.object({
+  sessionId: z.string().min(1),
+  deviceId: z.string().min(1),
+  createdAt: z.number().int().nonnegative(),
+  expiresAt: z.number().int().positive(),
+  lastVerifiedAt: z.number().int().nonnegative().optional(),
+  revoked: z.boolean().optional(),
+});
+
+export type DeviceUiAuthSessionState = z.infer<typeof DeviceUiAuthSessionStateSchema>;
+
+export const DeviceUiAuthStateSchema = z.object({
+  jwtSecret: z.string().min(32),
+  sessions: z.array(DeviceUiAuthSessionStateSchema).default([]),
+  updatedAt: z.number().int().nonnegative().optional(),
+});
+
+export type DeviceUiAuthState = z.infer<typeof DeviceUiAuthStateSchema>;
+
+const NullableStringSchema = z.string().nullable();
+const NullableNumberSchema = z.number().nullable();
+
+export const DeviceUiFrameSnapshotSchema = z.object({
+  slotId: NullableStringSchema.optional(),
+  slotStartMs: NullableNumberSchema.optional(),
+  snr: NullableNumberSchema,
+  freq: NullableNumberSchema,
+  dt: NullableNumberSchema,
+  message: z.string(),
+  operatorId: NullableStringSchema,
+  country: NullableStringSchema.optional(),
+  countryZh: NullableStringSchema.optional(),
+  countryEn: NullableStringSchema.optional(),
+  countryCode: NullableStringSchema.optional(),
+});
+
+export const DeviceUiCurrentTxSnapshotSchema = z.object({
+  active: z.boolean(),
+  operatorIds: z.array(z.string()),
+  messages: z.array(z.string()),
+  lastMessage: NullableStringSchema,
+  slotStartMs: NullableNumberSchema,
+});
+
+export const DeviceUiOperatorSnapshotSchema = z.object({
+  id: z.string(),
+  callsign: z.string(),
+  active: z.boolean(),
+  transmitting: z.boolean(),
+  ptt: z.boolean(),
+});
+
+export const DeviceUiCwSnapshotSchema = z.object({
+  decoder: z.object({
+    enabled: z.boolean(),
+    active: z.boolean(),
+    state: z.string(),
+    muted: z.boolean(),
+    pendingText: z.string(),
+    committedText: z.string(),
+    lastDecodeAt: NullableNumberSchema,
+    updatedAt: z.number().int().nonnegative(),
+  }),
+  keyer: z.object({
+    active: z.boolean(),
+    mode: NullableStringSchema,
+    messageId: NullableStringSchema,
+    currentText: NullableStringSchema,
+    lastText: NullableStringSchema,
+  }),
+  currentTx: z.object({
+    active: z.boolean(),
+    messages: z.array(z.string()),
+    lastMessage: NullableStringSchema,
+  }),
+});
+
+export const DeviceUiBootstrapSnapshotSchema = z.object({
+  server: z.object({
+    status: z.literal('ok'),
+    version: z.string(),
+    webPort: NullableNumberSchema,
+  }),
+  station: z.object({
+    callsign: NullableStringSchema,
+    callsigns: z.array(z.string()).default([]),
+  }),
+  operators: z.array(DeviceUiOperatorSnapshotSchema).default([]),
+  engine: z.object({
+    running: z.boolean(),
+    mode: NullableStringSchema,
+    currentMode: z.object({
+      name: z.string(),
+      slotMs: z.number().nonnegative().optional(),
+    }).nullable(),
+    state: NullableStringSchema,
+  }),
+  radio: z.object({
+    connected: z.boolean(),
+    frequency: NullableNumberSchema,
+    radioMode: NullableStringSchema,
+    ptt: z.boolean(),
+    tx: z.boolean(),
+  }),
+  ft8: z.object({
+    slot: z.object({
+      id: z.string(),
+      startMs: z.number(),
+      phaseMs: z.number(),
+      driftMs: z.number().optional(),
+      cycleNumber: z.number(),
+      utcSeconds: z.number(),
+      mode: z.string(),
+    }).nullable(),
+    utc: NullableNumberSchema,
+    cycle: NullableNumberSchema,
+    periodMs: NullableNumberSchema,
+    recentDecodeRawMessages: z.array(z.string()),
+    lastDecodeRawMessage: NullableStringSchema,
+    recentFramesSlotId: NullableStringSchema,
+    recentFramesSlotStartMs: NullableNumberSchema,
+    recentFrames: z.array(DeviceUiFrameSnapshotSchema),
+    currentTx: DeviceUiCurrentTxSnapshotSchema,
+  }),
+  voice: z.object({
+    active: z.boolean(),
+    radioMode: NullableStringSchema,
+    pttLocked: z.boolean(),
+    pttLockedByLabel: NullableStringSchema,
+    keyerActive: z.boolean(),
+    keyerMode: NullableStringSchema,
+    keyerSlotId: NullableStringSchema,
+  }),
+  cw: DeviceUiCwSnapshotSchema,
+  access: z.object({
+    localUrl: NullableStringSchema,
+    localUrls: z.array(z.string()),
+  }),
+  updatedAt: z.number().int().nonnegative(),
+});
+
+export type DeviceUiBootstrapSnapshot = z.infer<typeof DeviceUiBootstrapSnapshotSchema>;
+
+export const DeviceUiWsEventSchema = z.object({
+  type: z.literal('snapshot'),
+  payload: DeviceUiBootstrapSnapshotSchema,
+  timestamp: z.string(),
+});
+
+export type DeviceUiWsEvent = z.infer<typeof DeviceUiWsEventSchema>;

package/src/schema/mode.schema.ts

@@ -63,6 +63,14 @@ export const MODES = {
     transmitTiming: 0,
     encodeAdvance: 0,
   } as ModeDescriptor,
+  CW: {
+    name: 'CW',
+    slotMs: 0,            // CW 模式无时隙概念
+    toleranceMs: 0,
+    windowTiming: [],     // 无解码窗口
+    transmitTiming: 0,
+    encodeAdvance: 0,
+  } as ModeDescriptor,
 } as const;
 
 /**

package/src/schema/operator.schema.ts

@@ -1,11 +1,17 @@
 import { z } from 'zod';
 import { ModeDescriptorSchema } from './mode.schema.js';
+import { sanitizeCallsignInput } from '../utils/callsign.js';
+
+const OperatorCallsignSchema = z
+  .string()
+  .transform(sanitizeCallsignInput)
+  .pipe(z.string().min(1, '呼号不能为空').max(10, '呼号不能超过10个字符'));
 
 // 操作员配置 Schema (重命名以避免冲突)
 export const RadioOperatorConfigSchema = z.object({
   id: z.string().min(1, '操作员ID不能为空'),
   createdByTokenId: z.string().optional(), // 创建者 Token ID（仅用于审计，不参与权限判断）
-  myCallsign: z.string().min(1, '呼号不能为空').max(10, '呼号不能超过10个字符'),
+  myCallsign: OperatorCallsignSchema,
   myGrid: z.string().min(4, '网格坐标至少4位').max(8, '网格坐标不能超过8位').optional(),
   frequency: z.number().min(0).max(1000000000, '频率必须在0-1GHz之间').default(1000), // 音频偏移频率（Hz），默认1000Hz，创建时自动分配不重复值
   transmitCycles: z.array(z.number().min(0).max(1)).default([0]), // 0=偶数周期，1=奇数周期

package/src/schema/plugin.schema.ts

@@ -73,7 +73,7 @@ export type PluginPanelComponent = z.infer<typeof PluginPanelComponentSchema>;
  * These values control both validation expectations and default frontend
  * rendering in plugin settings UIs.
  */
-export const PluginSettingTypeSchema = z.enum(['boolean', 'number', 'string', 'string[]', 'object[]', 'info']);
+export const PluginSettingTypeSchema = z.enum(['boolean', 'number', 'string', 'string[]', 'object[]', 'keyedStringArrays', 'info']);
 
 /**
  * Supported generated-form field types for plugin settings.
@@ -103,6 +103,26 @@ export const PluginObjectArrayFieldSchema = z.object({
 });
 export type PluginObjectArrayField = z.infer<typeof PluginObjectArrayFieldSchema>;
 
+export const PluginKeyedStringArrayKeySchema = z.object({
+  key: z.string(),
+  label: z.string(),
+  description: z.string().optional(),
+});
+export type PluginKeyedStringArrayKey = z.infer<typeof PluginKeyedStringArrayKeySchema>;
+
+export const PluginSettingConditionSchema = z.object({
+  setting: z.string(),
+  equals: z.unknown().optional(),
+  notEquals: z.unknown().optional(),
+});
+export type PluginSettingCondition = z.infer<typeof PluginSettingConditionSchema>;
+
+export const PluginSettingConditionalDescriptionSchema = z.object({
+  when: PluginSettingConditionSchema,
+  description: z.string(),
+});
+export type PluginSettingConditionalDescription = z.infer<typeof PluginSettingConditionalDescriptionSchema>;
+
 /**
  * Persistence and UI scope for a plugin setting.
  *
@@ -134,6 +154,12 @@ export const PluginSettingDescriptorSchema = z.object({
   options: z.array(PluginSettingOptionSchema).optional(),
   /** Field schema used by generated editors for `object[]` settings. */
   itemFields: z.array(PluginObjectArrayFieldSchema).optional(),
+  /** Fixed key list used by generated editors for `keyedStringArrays` settings. */
+  keys: z.array(PluginKeyedStringArrayKeySchema).optional(),
+  /** Conditionally show the field based on another setting in the same form. */
+  visibleWhen: PluginSettingConditionSchema.optional(),
+  /** Conditionally override the field description based on another setting. */
+  descriptionWhen: z.array(PluginSettingConditionalDescriptionSchema).optional(),
   /** Internal settings are persisted/injected but hidden from generated UIs. */
   hidden: z.boolean().optional(),
   /** 设置作用域：global（所有操作员共享）或 operator（每操作员独立），默认 global */
@@ -212,7 +238,7 @@ export type PluginCapability = z.infer<typeof PluginCapabilitySchema>;
  * - `voice-left-top`: shown above the voice frequency control card.
  * - `voice-right-top`: shown in the tabbed top area of the voice right panel.
  */
-export const PluginPanelSlotSchema = z.enum(['operator', 'automation', 'main-right', 'voice-left-top', 'voice-right-top']);
+export const PluginPanelSlotSchema = z.enum(['operator', 'automation', 'main-right', 'voice-left-top', 'voice-right-top', 'cw-right-top']);
 
 /**
  * Rendering slot that determines where a panel appears in the UI.