@tx5dr/contracts 1.7.1 → 1.7.3

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

@@ -643,11 +643,17 @@ export const PluginRuntimeLogEntrySchema = z.object({
 });
 export type PluginRuntimeLogEntry = z.infer<typeof PluginRuntimeLogEntrySchema>;
 
+export const PluginLogHistoryEntrySchema = z.union([
+  PluginRuntimeLogEntrySchema,
+  PluginLogEntrySchema,
+]);
+export type PluginLogHistoryEntry = z.infer<typeof PluginLogHistoryEntrySchema>;
+
 /**
  * 宿主级插件运行日志历史响应载荷
  */
 export const PluginRuntimeLogHistoryPayloadSchema = z.object({
-  entries: z.array(PluginRuntimeLogEntrySchema),
+  entries: z.array(PluginLogHistoryEntrySchema),
 });
 export type PluginRuntimeLogHistoryPayload = z.infer<typeof PluginRuntimeLogHistoryPayloadSchema>;
 

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

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

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

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

package/src/schema/websocket.schema.ts

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import { FT8DecodeSchema } from './ft8.schema.js';
-import { SlotPackSchema, SlotInfoSchema } from './slot-info.schema.js';
+import { SlotPackSchema, SlotInfoSchema, SlotPackFrequencyContextSchema } from './slot-info.schema.js';
 import {
   PluginDataPayloadSchema,
   PluginLogEntrySchema,
@@ -779,7 +779,9 @@ export const WSTransmissionLogMessageSchema = WSBaseMessageSchema.extend({
     time: z.string(),
     message: z.string(),
     frequency: z.number(),
-    slotStartMs: z.number()
+    slotStartMs: z.number(),
+    replaceExisting: z.boolean().optional(),
+    frequencyContext: SlotPackFrequencyContextSchema.optional(),
   }),
 });
 
@@ -1443,6 +1445,7 @@ export interface DigitalRadioEngineEvents {
     frequency: number;
     slotStartMs: number;
     replaceExisting?: boolean;
+    frequencyContext?: z.infer<typeof SlotPackFrequencyContextSchema>;
   }) => void;
   
   // 操作员事件
@@ -1544,6 +1547,17 @@ export interface DigitalRadioEngineEvents {
   }) => void;
   pluginPanelMeta: (data: import('./plugin.schema.js').PluginPanelMetaPayload) => void;
   pluginPanelContributionsChanged: (data: import('./plugin.schema.js').PluginUIPanelContributionGroup) => void;
+  pluginRemoteReplyToDecode: (data: { operatorId: string; callsign: string; modifiers?: number }) => void;
+  pluginRemoteClearDecodes: (data: { operatorId: string; window?: number }) => void;
+  pluginRemoteFreeText: (data: { operatorId: string; text?: string; send: boolean }) => void;
+  pluginRemoteLocation: (data: { operatorId: string; location: string }) => void;
+  pluginRemoteHighlightCallsign: (data: {
+    operatorId: string;
+    callsign: string;
+    background?: string | null;
+    foreground?: string | null;
+    lastOnly?: boolean;
+  }) => void;
 
   // 内部子系统间通信事件（不通过 WebSocket 广播，用于 engine emitter 内部编排）
   encodeStart: (slotInfo: z.infer<typeof SlotInfoSchema>) => void;

package/src/utils/callsign.ts

@@ -0,0 +1,9 @@
+const CALLSIGN_WHITESPACE_REGEX = /\s+/g;
+
+export function sanitizeCallsignInput(callsign?: string | null): string {
+  if (!callsign) {
+    return '';
+  }
+
+  return callsign.toUpperCase().replace(CALLSIGN_WHITESPACE_REGEX, '');
+}

package/test/decode-request-schema.test.ts

@@ -0,0 +1,48 @@
+import { describe, expect, it } from 'vitest';
+import { DecodeRequestSchema } from '../src/schema/slot-info.schema.js';
+
+function makePcm(): ArrayBuffer {
+  return new Float32Array(16).buffer;
+}
+
+describe('DecodeRequestSchema', () => {
+  it('accepts legacy decode requests without AP context', () => {
+    const parsed = DecodeRequestSchema.parse({
+      slotId: 'FT8-1-15000',
+      mode: 'FT8',
+      windowIdx: 0,
+      pcm: makePcm(),
+      sampleRate: 12000,
+      windowOffsetMs: 0,
+    });
+
+    expect(parsed.apContext).toBeUndefined();
+  });
+
+  it('accepts a single AP decode context', () => {
+    const parsed = DecodeRequestSchema.parse({
+      slotId: 'FT8-1-15000',
+      mode: 'FT8',
+      windowIdx: 1,
+      pcm: makePcm(),
+      sampleRate: 12000,
+      windowOffsetMs: 0,
+      apContext: {
+        operatorId: 'op1',
+        myCall: 'BG4IAJ',
+        myGrid: 'OM96',
+        dxCall: 'JA1AAA',
+        dxGrid: 'PM95',
+        frequencyHz: 1500,
+        qsoProgress: 4,
+        currentSlot: 'TX4',
+      },
+    });
+
+    expect(parsed.apContext).toEqual(expect.objectContaining({
+      operatorId: 'op1',
+      qsoProgress: 4,
+      currentSlot: 'TX4',
+    }));
+  });
+});