@tx5dr/contracts 1.3.0 → 1.5.0

package/src/schema/plugin.schema.ts

@@ -61,7 +61,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[]', 'info']);
+export const PluginSettingTypeSchema = z.enum(['boolean', 'number', 'string', 'string[]', 'object[]', 'info']);
 
 /**
  * Supported generated-form field types for plugin settings.
@@ -81,6 +81,16 @@ export const PluginSettingOptionSchema = z.object({
  */
 export type PluginSettingOption = z.infer<typeof PluginSettingOptionSchema>;
 
+export const PluginObjectArrayFieldSchema = z.object({
+  key: z.string(),
+  type: z.enum(['string', 'number', 'boolean']).optional().default('string'),
+  label: z.string(),
+  description: z.string().optional(),
+  placeholder: z.string().optional(),
+  required: z.boolean().optional(),
+});
+export type PluginObjectArrayField = z.infer<typeof PluginObjectArrayFieldSchema>;
+
 /**
  * Persistence and UI scope for a plugin setting.
  *
@@ -110,6 +120,10 @@ export const PluginSettingDescriptorSchema = z.object({
   min: z.number().optional(),
   max: z.number().optional(),
   options: z.array(PluginSettingOptionSchema).optional(),
+  /** Field schema used by generated editors for `object[]` settings. */
+  itemFields: z.array(PluginObjectArrayFieldSchema).optional(),
+  /** Internal settings are persisted/injected but hidden from generated UIs. */
+  hidden: z.boolean().optional(),
   /** 设置作用域：global（所有操作员共享）或 operator（每操作员独立），默认 global */
   scope: PluginSettingScopeSchema.optional().default('global'),
 });
@@ -212,7 +226,8 @@ export type PluginPanelWidth = z.infer<typeof PluginPanelWidthSchema>;
  *
  * Panels are passive containers rendered by the host. A plugin sends data into
  * them through `ctx.ui.send(panelId, data)`. When `component` is `'iframe'`,
- * the panel renders a custom UI page inside a sandboxed iframe instead.
+ * the panel renders a custom UI page inside a sandboxed iframe instead. Static
+ * manifest panels and runtime UI contributions use this same descriptor.
  */
 export const PluginPanelDescriptorSchema = z.object({
   id: z.string(),
@@ -220,6 +235,8 @@ export const PluginPanelDescriptorSchema = z.object({
   component: PluginPanelComponentSchema,
   /** Required when `component` is `'iframe'`. References a page id from `ui.pages`. */
   pageId: z.string().optional(),
+  /** Optional string params forwarded to iframe panels as URL/init params. */
+  params: z.record(z.string(), z.string()).optional(),
   /** Where the panel renders. Defaults to `'operator'` (operator card live-panel area). */
   slot: PluginPanelSlotSchema.optional(),
   /** Preferred width hint. Defaults to `'half'`. */
@@ -231,6 +248,29 @@ export const PluginPanelDescriptorSchema = z.object({
  */
 export type PluginPanelDescriptor = z.infer<typeof PluginPanelDescriptorSchema>;
 
+export const PluginUIPanelContributionTargetSchema = z.discriminatedUnion('kind', [
+  z.object({ kind: z.literal('global') }),
+  z.object({ kind: z.literal('operator'), operatorId: z.string() }),
+]);
+export type PluginUIPanelContributionTarget = z.infer<typeof PluginUIPanelContributionTargetSchema>;
+
+/**
+ * A normalized group of plugin UI panels.
+ *
+ * Static `PluginDefinition.panels` are emitted by the host as the reserved
+ * `manifest` group. Runtime groups are replaced by
+ * `ctx.ui.setPanelContributions(groupId, panels)` and cleared by publishing an
+ * empty panel list for the same group.
+ */
+export const PluginUIPanelContributionGroupSchema = z.object({
+  pluginName: z.string(),
+  groupId: z.string(),
+  source: z.enum(['manifest', 'runtime']),
+  instanceTarget: PluginUIPanelContributionTargetSchema.optional(),
+  panels: z.array(PluginPanelDescriptorSchema),
+});
+export type PluginUIPanelContributionGroup = z.infer<typeof PluginUIPanelContributionGroupSchema>;
+
 // ===== 自定义 UI 页面 =====
 
 /**
@@ -422,6 +462,7 @@ export const PluginSystemSnapshotSchema = z.object({
   generation: z.number().int().nonnegative(),
   plugins: z.array(PluginStatusSchema),
   panelMeta: z.array(PluginPanelMetaPayloadSchema).optional().default([]),
+  panelContributions: z.array(PluginUIPanelContributionGroupSchema).optional().default([]),
   lastError: z.string().optional(),
 });
 export type PluginSystemSnapshot = z.infer<typeof PluginSystemSnapshotSchema>;

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

@@ -12,6 +12,14 @@ export const ProcessCpuSchema = z.object({
   user: z.number(),
   system: z.number(),
   total: z.number(),
+  capacity: z.number().positive().optional(),
+  normalizedTotal: z.number().optional(),
+});
+
+export const HostCpuSchema = z.object({
+  logicalCores: z.number().int().positive(),
+  availableParallelism: z.number().int().positive(),
+  totalUsage: z.number().optional(),
 });
 
 export const EventLoopDelaySchema = z.object({
@@ -25,6 +33,7 @@ export const ProcessSnapshotSchema = z.object({
   uptimeSeconds: z.number(),
   memory: ProcessMemorySchema,
   cpu: ProcessCpuSchema,
+  hostCpu: HostCpuSchema.optional(),
   eventLoop: EventLoopDelaySchema,
 });
 
@@ -36,6 +45,7 @@ export const ProcessSnapshotHistorySchema = z.object({
 
 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 ProcessSnapshot = z.infer<typeof ProcessSnapshotSchema>;
 export type ProcessSnapshotHistory = z.infer<typeof ProcessSnapshotHistorySchema>;

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

@@ -42,6 +42,18 @@ export type CapabilityOptionValue = z.infer<typeof CapabilityOptionValueSchema>;
 export const CapabilityValueSchema = z.union([z.boolean(), z.number(), z.string()]);
 export type CapabilityValue = z.infer<typeof CapabilityValueSchema>;
 
+export const CapabilityAvailabilitySchema = z.enum(['available', 'unavailable', 'unknown']);
+export type CapabilityAvailability = z.infer<typeof CapabilityAvailabilitySchema>;
+
+export const CapabilityAvailabilityReasonSchema = z.enum([
+  'runtime_error',
+  'busy',
+  'unsupported_by_current_mode',
+  'radio_reported_unavailable',
+  'unknown',
+]);
+export type CapabilityAvailabilityReason = z.infer<typeof CapabilityAvailabilityReasonSchema>;
+
 /**
  * 枚举项定义。
  */
@@ -161,9 +173,21 @@ export const CapabilityStateSchema = z.object({
   /** 能力 ID，与 CapabilityDescriptor.id 对应 */
   id: z.string(),
 
-  /** 当前连接的电台是否支持此能力（探测结果） */
+  /** 当前连接的电台型号/后端是否声明支持此能力 */
   supported: z.boolean(),
 
+  /**
+   * 当前运行时是否可用。
+   * 兼容旧客户端：缺省时应按 supported=true 视为 available，supported=false 视为 unknown。
+   */
+  availability: CapabilityAvailabilitySchema.optional(),
+
+  /** 当前不可用的机器可读原因 */
+  availabilityReason: CapabilityAvailabilityReasonSchema.optional(),
+
+  /** 最近一次运行时读写错误摘要 */
+  lastError: z.string().optional(),
+
   /**
    * 当前值
    * - boolean 类能力：true/false

package/src/schema/radio-power-support.ts

@@ -17,32 +17,40 @@ import type { HamlibConfig } from './radio.schema.js';
 export interface PowerCapableRigEntry {
   mfg: string | RegExp;
   model: string | RegExp;
+  /**
+   * Physical powerstat targets that are safe to expose while CAT is connected.
+   * `on` is represented by canPowerOn and is not part of this connected-state list.
+   */
+  supportedStates?: ReadonlyArray<'operate' | 'standby' | 'off'>;
 }
 
 export const POWER_CAPABLE_RIGS: ReadonlyArray<PowerCapableRigEntry> = [
   // Icom modern transceivers (CI-V 0x18 command)
-  { mfg: /^icom$/i, model: /^IC-?705$/i },
-  { mfg: /^icom$/i, model: /^IC-?7300$/i },
-  { mfg: /^icom$/i, model: /^IC-?7610$/i },
-  { mfg: /^icom$/i, model: /^IC-?7100$/i },
-  { mfg: /^icom$/i, model: /^IC-?7851$/i },
-  { mfg: /^icom$/i, model: /^IC-?9700$/i },
-  { mfg: /^icom$/i, model: /^IC-?R8600$/i },
+  { mfg: /^icom$/i, model: /^IC-?705$/i, supportedStates: ['off', 'standby', 'operate'] },
+  { mfg: /^icom$/i, model: /^IC-?7300$/i, supportedStates: ['off', 'standby', 'operate'] },
+  { mfg: /^icom$/i, model: /^IC-?7610$/i, supportedStates: ['off', 'standby', 'operate'] },
+  { mfg: /^icom$/i, model: /^IC-?7100$/i, supportedStates: ['off', 'standby', 'operate'] },
+  { mfg: /^icom$/i, model: /^IC-?7851$/i, supportedStates: ['off', 'standby', 'operate'] },
+  { mfg: /^icom$/i, model: /^IC-?9700$/i, supportedStates: ['off', 'standby', 'operate'] },
+  { mfg: /^icom$/i, model: /^IC-?R8600$/i, supportedStates: ['off', 'standby', 'operate'] },
 
   // Kenwood
-  { mfg: /^kenwood$/i, model: /^TS-590SG?$/i },
-  { mfg: /^kenwood$/i, model: /^TS-890$/i },
-  { mfg: /^kenwood$/i, model: /^TS-990$/i },
+  { mfg: /^kenwood$/i, model: /^TS-590SG?$/i, supportedStates: ['off', 'standby'] },
+  { mfg: /^kenwood$/i, model: /^TS-890$/i, supportedStates: ['off', 'standby'] },
+  { mfg: /^kenwood$/i, model: /^TS-990$/i, supportedStates: ['off', 'standby'] },
 
-  // Yaesu
-  { mfg: /^yaesu$/i, model: /^FT-991A?$/i },
-  { mfg: /^yaesu$/i, model: /^FTDX-?10$/i },
-  { mfg: /^yaesu$/i, model: /^FTDX-?101(MP|D)?$/i },
-  { mfg: /^yaesu$/i, model: /^FT-?710$/i },
+  // Yaesu: FT-710 rejects powerstat(operate), so do not expose it by default.
+  { mfg: /^yaesu$/i, model: /^FT-991A?$/i, supportedStates: ['off', 'standby'] },
+  { mfg: /^yaesu$/i, model: /^FTDX-?10$/i, supportedStates: ['off', 'standby'] },
+  { mfg: /^yaesu$/i, model: /^FTDX-?101(MP|D)?$/i, supportedStates: ['off', 'standby'] },
+  { mfg: /^yaesu$/i, model: /^FT-?710$/i, supportedStates: ['off'] },
 ];
 
-export function isRigModelPowerCapable(mfgName: string, modelName: string): boolean {
-  return POWER_CAPABLE_RIGS.some((entry) => {
+export function findPowerCapableRigEntry(
+  mfgName: string,
+  modelName: string
+): PowerCapableRigEntry | undefined {
+  return POWER_CAPABLE_RIGS.find((entry) => {
     const mfgOk =
       typeof entry.mfg === 'string'
         ? entry.mfg.toLowerCase() === mfgName.toLowerCase()
@@ -55,6 +63,10 @@ export function isRigModelPowerCapable(mfgName: string, modelName: string): bool
   });
 }
 
+export function isRigModelPowerCapable(mfgName: string, modelName: string): boolean {
+  return findPowerCapableRigEntry(mfgName, modelName) !== undefined;
+}
+
 export type PowerSupportReason =
   | 'model-unsupported'
   | 'network-mode-no-wake'
@@ -65,6 +77,8 @@ export interface PowerSupportDecision {
   canPowerOn: boolean;
   /** Whether the UI should surface a "power off" control. */
   canPowerOff: boolean;
+  /** Connected-state physical power targets the UI may offer. */
+  supportedStates: Array<'operate' | 'standby' | 'off'>;
   /** Machine-readable reason when `canPowerOn` is false. */
   reason?: PowerSupportReason;
 }
@@ -85,23 +99,32 @@ export function decidePowerSupport(
 ): PowerSupportDecision {
   switch (config.type) {
     case 'none':
-      return { canPowerOn: false, canPowerOff: false, reason: 'none-mode' };
+      return { canPowerOn: false, canPowerOff: false, supportedStates: [], reason: 'none-mode' };
     case 'network':
-      return { canPowerOn: false, canPowerOff: true, reason: 'network-mode-no-wake' };
+      return {
+        canPowerOn: false,
+        canPowerOff: true,
+        supportedStates: ['off'],
+        reason: 'network-mode-no-wake',
+      };
     case 'icom-wlan':
       // ICOM WLAN 的 CI-V-over-UDP 通道在电台关机后无法维持；即便已连接
       // 发送 powerstat(off) 也不能可靠恢复。整体不暴露电源控制。
-      return { canPowerOn: false, canPowerOff: false, reason: 'model-unsupported' };
+      return { canPowerOn: false, canPowerOff: false, supportedStates: [], reason: 'model-unsupported' };
     case 'serial': {
       if (!rigInfo) {
-        return { canPowerOn: false, canPowerOff: false, reason: 'model-unsupported' };
+        return { canPowerOn: false, canPowerOff: false, supportedStates: [], reason: 'model-unsupported' };
       }
-      const supported = isRigModelPowerCapable(rigInfo.mfgName, rigInfo.modelName);
-      return supported
-        ? { canPowerOn: true, canPowerOff: true }
-        : { canPowerOn: false, canPowerOff: false, reason: 'model-unsupported' };
+      const entry = findPowerCapableRigEntry(rigInfo.mfgName, rigInfo.modelName);
+      return entry
+        ? {
+            canPowerOn: true,
+            canPowerOff: true,
+            supportedStates: [...(entry.supportedStates ?? ['off'])],
+          }
+        : { canPowerOn: false, canPowerOff: false, supportedStates: [], reason: 'model-unsupported' };
     }
     default:
-      return { canPowerOn: false, canPowerOff: false, reason: 'model-unsupported' };
+      return { canPowerOn: false, canPowerOff: false, supportedStates: [], reason: 'model-unsupported' };
   }
 }

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

@@ -5,10 +5,10 @@ import { HamlibConfigSchema } from './radio.schema.js';
  * High-level runtime state tracked by the RadioPowerController.
  *
  * - `off`: radio is known to be off (or was never connected).
- * - `waking`: power-on command sent, waiting for the radio to respond.
- * - `awake`: radio is responding; the engine is being started (if autoEngine).
- * - `shutting_down`: engine is stopping in preparation for a power-off command.
- * - `entering_standby`: powerstat(2) sent, waiting for radio to drop CAT link.
+ * - `waking`: physical power-on command sent, waiting for the radio to respond.
+ * - `awake`: radio is physically responding; software engine startup is optional.
+ * - `shutting_down`: physical power-off command is being applied.
+ * - `entering_standby`: physical standby command is being applied.
  * - `failed`: last transition failed; UI should show an error + retry.
  */
 export const RadioPowerStateSchema = z.enum([
@@ -53,14 +53,15 @@ export type RadioPowerStateEvent = z.infer<typeof RadioPowerStateEventSchema>;
 /**
  * REST request body: POST /api/radio/power
  */
-/** Allowed target states for a power request. */
+/** Allowed physical radio target states for a power request. */
 export const RadioPowerTargetSchema = z.enum(['on', 'off', 'standby', 'operate']);
 export type RadioPowerTarget = z.infer<typeof RadioPowerTargetSchema>;
 
 export const RadioPowerRequestSchema = z.object({
   profileId: z.string().min(1),
+  /** Physical radio power target. This is not the TX-5DR software engine state. */
   state: RadioPowerTargetSchema,
-  /** Automatically start the engine after successful power-on. Defaults to true. */
+  /** Automatically start the TX-5DR engine after successful physical power-on. */
   autoEngine: z.boolean().optional().default(true),
 });
 export type RadioPowerRequest = z.infer<typeof RadioPowerRequestSchema>;
@@ -70,6 +71,7 @@ export type RadioPowerRequest = z.infer<typeof RadioPowerRequestSchema>;
  */
 export const RadioPowerResponseSchema = z.object({
   success: z.boolean(),
+  target: RadioPowerTargetSchema,
   state: RadioPowerStateSchema,
 });
 export type RadioPowerResponse = z.infer<typeof RadioPowerResponseSchema>;

package/src/schema/realtime.schema.ts

@@ -3,10 +3,7 @@ import { z } from 'zod';
 export const RealtimeScopeSchema = z.enum(['radio', 'openwebrx-preview']);
 export type RealtimeScope = z.infer<typeof RealtimeScopeSchema>;
 
-export const RealtimeParticipantKindSchema = z.enum(['listener', 'publisher', 'bridge']);
-export type RealtimeParticipantKind = z.infer<typeof RealtimeParticipantKindSchema>;
-
-export const RealtimeTransportKindSchema = z.enum(['livekit', 'ws-compat']);
+export const RealtimeTransportKindSchema = z.enum(['rtc-data-audio', 'ws-compat']);
 export type RealtimeTransportKind = z.infer<typeof RealtimeTransportKindSchema>;
 
 export const RealtimeSessionDirectionSchema = z.enum(['recv', 'send']);
@@ -27,10 +24,14 @@ export type RealtimeConnectivityErrorCode = z.infer<typeof RealtimeConnectivityE
 
 export const RealtimeConnectivityHintsSchema = z.object({
   signalingUrl: z.string(),
-  signalingPort: z.number().int().positive(),
-  rtcTcpPort: z.number().int().positive(),
-  udpPortRange: z.string(),
-  publicUrlOverrideActive: z.boolean(),
+  localUdpPort: z.number().int().min(1).max(65535),
+  publicCandidateEnabled: z.boolean(),
+  publicEndpoint: z.object({
+    host: z.string(),
+    port: z.number().int().min(1).max(65535),
+  }).nullable(),
+  iceServers: z.array(z.string()),
+  fallbackTransport: z.literal('ws-compat'),
 });
 export type RealtimeConnectivityHints = z.infer<typeof RealtimeConnectivityHintsSchema>;
 
@@ -45,14 +46,6 @@ export const RealtimeConnectivityIssueSchema = z.object({
 });
 export type RealtimeConnectivityIssue = z.infer<typeof RealtimeConnectivityIssueSchema>;
 
-export const RealtimeTokenRequestSchema = z.object({
-  scope: RealtimeScopeSchema,
-  publish: z.boolean().optional(),
-  previewSessionId: z.string().optional(),
-});
-
-export type RealtimeTokenRequest = z.infer<typeof RealtimeTokenRequestSchema>;
-
 export const RealtimeSessionRequestSchema = z.object({
   scope: RealtimeScopeSchema,
   direction: RealtimeSessionDirectionSchema,
@@ -62,30 +55,6 @@ export const RealtimeSessionRequestSchema = z.object({
 
 export type RealtimeSessionRequest = z.infer<typeof RealtimeSessionRequestSchema>;
 
-export const RealtimeParticipantMetadataSchema = z.object({
-  role: z.string(),
-  tokenId: z.string().nullable().optional(),
-  operatorIds: z.array(z.string()).optional(),
-  clientKind: z.string(),
-  participantKind: RealtimeParticipantKindSchema,
-  scope: RealtimeScopeSchema,
-  previewSessionId: z.string().optional(),
-});
-
-export type RealtimeParticipantMetadata = z.infer<typeof RealtimeParticipantMetadataSchema>;
-
-export const RealtimeTokenResponseSchema = z.object({
-  url: z.string(),
-  roomName: z.string(),
-  token: z.string(),
-  participantIdentity: z.string(),
-  participantName: z.string(),
-  participantMetadata: RealtimeParticipantMetadataSchema,
-  connectivityHints: RealtimeConnectivityHintsSchema,
-});
-
-export type RealtimeTokenResponse = z.infer<typeof RealtimeTokenResponseSchema>;
-
 export const RealtimeTransportOfferSchema = z.object({
   transport: RealtimeTransportKindSchema,
   direction: RealtimeSessionDirectionSchema,
@@ -93,7 +62,6 @@ export const RealtimeTransportOfferSchema = z.object({
   token: z.string(),
   participantIdentity: z.string().nullable().optional(),
   participantName: z.string().nullable().optional(),
-  roomName: z.string().nullable().optional(),
 });
 
 export type RealtimeTransportOffer = z.infer<typeof RealtimeTransportOfferSchema>;
@@ -101,8 +69,74 @@ export type RealtimeTransportOffer = z.infer<typeof RealtimeTransportOfferSchema
 export const RealtimeTransportPolicySchema = z.enum(['auto', 'force-compat']);
 export type RealtimeTransportPolicy = z.infer<typeof RealtimeTransportPolicySchema>;
 
-export const LiveKitNetworkModeSchema = z.enum(['lan', 'internet-auto', 'internet-manual']);
-export type LiveKitNetworkMode = z.infer<typeof LiveKitNetworkModeSchema>;
+function isValidIpv4Literal(value: string): boolean {
+  const parts = value.split('.');
+  return parts.length === 4 && parts.every((part) => {
+    if (!/^\d{1,3}$/.test(part)) {
+      return false;
+    }
+    const parsed = Number.parseInt(part, 10);
+    return parsed >= 0 && parsed <= 255;
+  });
+}
+
+function isValidIpv6Literal(value: string): boolean {
+  if (!value.includes(':') || value.includes('[') || value.includes(']')) {
+    return false;
+  }
+  try {
+    // WHATWG URL parsing gives us a portable IPv6 sanity check without Node-only APIs.
+    // The schema still forbids bracket notation because the setting is host-only.
+    const parsed = new URL(`http://[${value}]/`);
+    return parsed.hostname.length > 2;
+  } catch {
+    return false;
+  }
+}
+
+function isValidDnsHostname(value: string): boolean {
+  if (value.length > 253 || value.endsWith('.')) {
+    return false;
+  }
+  const labels = value.split('.');
+  return labels.every((label) => (
+    label.length >= 1
+    && label.length <= 63
+    && /^[a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?$/.test(label)
+  ));
+}
+
+function isValidRtcDataAudioPublicHost(value: string): boolean {
+  const host = value.trim();
+  if (!host || /\s/.test(host) || /[/?#@]/.test(host) || /^[a-zA-Z][a-zA-Z0-9+.-]*:\/\//.test(host)) {
+    return false;
+  }
+  return isValidIpv4Literal(host) || isValidIpv6Literal(host) || isValidDnsHostname(host);
+}
+
+export const RtcDataAudioPublicHostSchema = z.preprocess(
+  (value) => (typeof value === 'string' ? value.trim() : value),
+  z.union([
+    z.literal('').transform(() => null),
+    z.string().min(1).max(253).refine(isValidRtcDataAudioPublicHost, {
+      message: 'Public host must be an IP address or DNS hostname without scheme, port, or path',
+    }),
+    z.null(),
+  ]),
+);
+export type RtcDataAudioPublicHost = z.infer<typeof RtcDataAudioPublicHostSchema>;
+
+export const RtcDataAudioPublicUdpPortSchema = z.preprocess((value) => {
+  if (value === '' || value === undefined) {
+    return null;
+  }
+  if (typeof value === 'string') {
+    const parsed = Number.parseInt(value, 10);
+    return Number.isFinite(parsed) ? parsed : value;
+  }
+  return value;
+}, z.number().int().min(1).max(65535).nullable());
+export type RtcDataAudioPublicUdpPort = z.infer<typeof RtcDataAudioPublicUdpPortSchema>;
 
 export const RealtimeSessionResponseSchema = z.object({
   scope: RealtimeScopeSchema,
@@ -112,10 +146,8 @@ export const RealtimeSessionResponseSchema = z.object({
   selectionReason: z.enum([
     'client-override',
     'server-policy',
-    'bridge-unhealthy',
-    'livekit-disabled',
-    'runtime-unavailable',
-    'default-livekit',
+    'default-rtc-data-audio',
+    'rtc-data-audio-unavailable',
   ]),
   forcedCompatibilityMode: z.boolean(),
   offers: z.array(RealtimeTransportOfferSchema).min(1),
@@ -125,34 +157,27 @@ export const RealtimeSessionResponseSchema = z.object({
 export type RealtimeSessionResponse = z.infer<typeof RealtimeSessionResponseSchema>;
 
 export const RealtimeSettingsSchema = z.object({
-  publicWsUrl: z.string().url().nullable().optional(),
   transportPolicy: RealtimeTransportPolicySchema.optional(),
-  networkMode: LiveKitNetworkModeSchema.optional(),
-  nodeIp: z.string().nullable().optional(),
+  rtcDataAudioPublicHost: RtcDataAudioPublicHostSchema.optional(),
+  rtcDataAudioPublicUdpPort: RtcDataAudioPublicUdpPortSchema.optional(),
 });
 
 export type RealtimeSettings = z.infer<typeof RealtimeSettingsSchema>;
 
-export const RealtimeCredentialSourceSchema = z.enum(['managed-file', 'environment-override', 'missing']);
-export type RealtimeCredentialSource = z.infer<typeof RealtimeCredentialSourceSchema>;
-
-export const RealtimeCredentialStatusSchema = z.object({
-  initialized: z.boolean(),
-  source: RealtimeCredentialSourceSchema,
-  filePath: z.string().nullable(),
-  apiKeyPreview: z.string().nullable(),
-  createdAt: z.string().nullable(),
-  rotatedAt: z.string().nullable(),
+export const RealtimeRtcDataAudioRuntimeSchema = z.object({
+  localUdpPort: z.number().int().min(1).max(65535),
+  publicCandidateEnabled: z.boolean(),
+  publicEndpoint: z.object({
+    host: z.string(),
+    port: z.number().int().min(1).max(65535),
+  }).nullable(),
 });
-export type RealtimeCredentialStatus = z.infer<typeof RealtimeCredentialStatusSchema>;
+export type RealtimeRtcDataAudioRuntime = z.infer<typeof RealtimeRtcDataAudioRuntimeSchema>;
 
 export const RealtimeSettingsRuntimeSchema = z.object({
-  liveKitEnabled: z.boolean(),
   connectivityHints: RealtimeConnectivityHintsSchema,
   radioReceiveTransport: RealtimeTransportKindSchema,
-  radioBridgeHealthy: z.boolean(),
-  radioBridgeIssueCode: RealtimeConnectivityErrorCodeSchema.nullable(),
-  credentialStatus: RealtimeCredentialStatusSchema,
+  rtcDataAudio: RealtimeRtcDataAudioRuntimeSchema,
 });
 
 export type RealtimeSettingsRuntime = z.infer<typeof RealtimeSettingsRuntimeSchema>;
@@ -234,6 +259,10 @@ export const RealtimeVoiceTxServerIngressStatsSchema = z.object({
   queueDepthFrames: z.number().int().nonnegative(),
   queuedAudioMs: z.number().nonnegative(),
   droppedFrames: z.number().int().nonnegative(),
+  staleDroppedFrames: z.number().int().nonnegative(),
+  underrunCount: z.number().int().nonnegative(),
+  plcFrames: z.number().int().nonnegative(),
+  jitterTargetMs: z.number().nonnegative(),
 });
 
 export type RealtimeVoiceTxServerIngressStats = z.infer<typeof RealtimeVoiceTxServerIngressStatsSchema>;
@@ -242,8 +271,10 @@ export const RealtimeVoiceTxServerOutputStatsSchema = z.object({
   resampleMs: RealtimeVoiceTxMetricWindowSchema,
   queueWaitMs: RealtimeVoiceTxMetricWindowSchema,
   writeMs: RealtimeVoiceTxMetricWindowSchema,
+  serverPipelineMs: RealtimeVoiceTxMetricWindowSchema,
   endToEndMs: RealtimeVoiceTxMetricWindowSchema,
   outputBufferedMs: RealtimeVoiceTxMetricWindowSchema,
+  outputWriteIntervalMs: RealtimeVoiceTxMetricWindowSchema,
   outputSampleRate: z.number().nullable(),
   outputBufferSize: z.number().nullable(),
   writeFailures: z.number().int().nonnegative(),

package/src/schema/server-message-keys.ts

@@ -18,8 +18,8 @@ export enum ServerMessageKey {
   /** 实时语音连接异常 */
   REALTIME_CONNECTIVITY_WARNING = 'realtimeConnectivityWarning',
 
-  /** 服务端实时语音桥接异常 */
-  REALTIME_BRIDGE_DOWN = 'realtimeBridgeDown',
+  /** 服务端实时语音服务异常 */
+  REALTIME_SERVICE_DOWN = 'realtimeServiceDown',
 
   /** 实时语音链路无音频数据 */
   REALTIME_NO_AUDIO = 'realtimeNoAudio',

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

@@ -148,7 +148,9 @@ export const SlotPackSchema = z.object({
     /** 去重后的帧数 */
     totalFramesAfterDedup: z.number().default(0),
     /** 最后更新时间戳 */
-    lastUpdated: z.number().default(() => Date.now())
+    lastUpdated: z.number().default(() => Date.now()),
+    /** SlotPack 单调更新序号，用于客户端丢弃乱序旧包 */
+    updateSeq: z.number().int().nonnegative().optional()
   }).default({}),
   /** 解码历史（用于调试） */
   decodeHistory: z.array(z.object({

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

@@ -0,0 +1,55 @@
+import { z } from 'zod';
+
+export const VoiceKeyerSlotSchema = z.object({
+  id: z.string(),
+  index: z.number().int().min(1),
+  label: z.string(),
+  hasAudio: z.boolean(),
+  durationMs: z.number().int().nonnegative(),
+  updatedAt: z.number().nullable(),
+  repeatEnabled: z.boolean(),
+  repeatIntervalSec: z.number().int().min(1).max(300),
+});
+
+export const VoiceKeyerPanelSchema = z.object({
+  callsign: z.string(),
+  slotCount: z.number().int().min(3).max(12),
+  maxSlotCount: z.number().int().min(12),
+  slots: z.array(VoiceKeyerSlotSchema),
+});
+
+export const VoiceKeyerStatusSchema = z.object({
+  active: z.boolean(),
+  callsign: z.string().nullable(),
+  slotId: z.string().nullable(),
+  mode: z.enum(['idle', 'playing', 'repeat-waiting', 'stopping', 'error']),
+  repeating: z.boolean(),
+  startedBy: z.string().nullable(),
+  startedByLabel: z.string().nullable(),
+  nextRunAt: z.number().nullable(),
+  error: z.string().nullable(),
+});
+
+export const VoiceKeyerSlotUpdateSchema = z.object({
+  label: z.string().max(32).optional(),
+  repeatEnabled: z.boolean().optional(),
+  repeatIntervalSec: z.number().int().min(1).max(300).optional(),
+});
+
+export const VoiceKeyerPanelUpdateSchema = z.object({
+  slotCount: z.number().int().min(3).max(12),
+});
+
+export const VoiceKeyerPlayRequestSchema = z.object({
+  callsign: z.string(),
+  slotId: z.string(),
+  repeat: z.boolean().optional(),
+  startImmediately: z.boolean().optional(),
+});
+
+export type VoiceKeyerSlot = z.infer<typeof VoiceKeyerSlotSchema>;
+export type VoiceKeyerPanel = z.infer<typeof VoiceKeyerPanelSchema>;
+export type VoiceKeyerStatus = z.infer<typeof VoiceKeyerStatusSchema>;
+export type VoiceKeyerSlotUpdate = z.infer<typeof VoiceKeyerSlotUpdateSchema>;
+export type VoiceKeyerPanelUpdate = z.infer<typeof VoiceKeyerPanelUpdateSchema>;
+export type VoiceKeyerPlayRequest = z.infer<typeof VoiceKeyerPlayRequestSchema>;