@tx5dr/contracts 1.7.12 → 2.0.0

package/src/schema/auth.schema.ts

@@ -82,6 +82,19 @@ export const LoginResponseSchema = z.object({
 
 export type LoginResponse = z.infer<typeof LoginResponseSchema>;
 
+export const BrowserLoginCodeResponseSchema = z.object({
+  code: z.string().min(1),
+  expiresAt: z.number(),
+});
+
+export type BrowserLoginCodeResponse = z.infer<typeof BrowserLoginCodeResponseSchema>;
+
+export const ExchangeBrowserLoginCodeRequestSchema = z.object({
+  code: z.string().min(1),
+});
+
+export type ExchangeBrowserLoginCodeRequest = z.infer<typeof ExchangeBrowserLoginCodeRequestSchema>;
+
 // ===== Token 管理（Admin API） =====
 
 export const LoginCredentialSummarySchema = z.object({
@@ -211,11 +224,76 @@ export const UpdateAuthConfigRequestSchema = z.object({
 
 export type UpdateAuthConfigRequest = z.infer<typeof UpdateAuthConfigRequestSchema>;
 
+export const RemoteAccessPresetSchema = z.enum(['local', 'lan', 'public']);
+export type RemoteAccessPreset = z.infer<typeof RemoteAccessPresetSchema>;
+
+export function isPrivateRemoteAccessHostname(hostname: string): boolean {
+  if (['localhost', '127.0.0.1', '::1'].includes(hostname)) return true;
+  if (hostname.includes(':')) {
+    const normalized = hostname.toLowerCase();
+    return normalized.startsWith('fc') || normalized.startsWith('fd') || normalized.startsWith('fe8')
+      || normalized.startsWith('fe9') || normalized.startsWith('fea') || normalized.startsWith('feb');
+  }
+  const parts = hostname.split('.').map(Number);
+  if (parts.length !== 4 || parts.some(part => !Number.isInteger(part) || part < 0 || part > 255)) return false;
+  return parts[0] === 10
+    || (parts[0] === 172 && parts[1] >= 16 && parts[1] <= 31)
+    || (parts[0] === 192 && parts[1] === 168)
+    || (parts[0] === 100 && parts[1] >= 64 && parts[1] <= 127)
+    || (parts[0] === 169 && parts[1] === 254);
+}
+
+export function normalizeRemoteAccessOrigin(value: string): string | null {
+  try {
+    const parsed = new URL(value.trim());
+    if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') return null;
+    if (parsed.username || parsed.password || parsed.pathname !== '/' || parsed.search || parsed.hash) return null;
+    return parsed.origin;
+  } catch {
+    return null;
+  }
+}
+
+export function isSecureRemoteAccessOrigin(value: string): boolean {
+  const normalized = normalizeRemoteAccessOrigin(value);
+  if (!normalized) return false;
+  const parsed = new URL(normalized);
+  return parsed.protocol === 'https:' || isPrivateRemoteAccessHostname(parsed.hostname);
+}
+
+export const RemoteAccessSecurityConfigSchema = z.object({
+  preset: RemoteAccessPresetSchema.default('lan'),
+  allowedOrigins: z.array(z.string().url().refine(
+    value => normalizeRemoteAccessOrigin(value) !== null,
+    'Expected a complete HTTP(S) origin without a path',
+  )).max(32).default([]),
+  maxConnections: z.number().int().min(1).max(512).default(32),
+  maxConnectionsPerIp: z.number().int().min(1).max(128).default(16),
+  maxPendingAuth: z.number().int().min(1).max(128).default(32),
+  authTimeoutMs: z.number().int().min(3_000).max(60_000).default(10_000),
+  handshakeTimeoutMs: z.number().int().min(3_000).max(60_000).default(10_000),
+});
+export type RemoteAccessSecurityConfig = z.infer<typeof RemoteAccessSecurityConfigSchema>;
+
+export const UpdateRemoteAccessSecurityRequestSchema = RemoteAccessSecurityConfigSchema.partial().extend({
+  allowPublicViewing: z.boolean().optional(),
+});
+export type UpdateRemoteAccessSecurityRequest = z.infer<typeof UpdateRemoteAccessSecurityRequestSchema>;
+
+export const RemoteAccessSecurityStatusSchema = RemoteAccessSecurityConfigSchema.extend({
+  allowPublicViewing: z.boolean(),
+  activeConnections: z.number().int().nonnegative(),
+  pendingConnections: z.number().int().nonnegative(),
+});
+export type RemoteAccessSecurityStatus = z.infer<typeof RemoteAccessSecurityStatusSchema>;
+
 // ===== 认证配置（持久化到 auth.json） =====
 
 export const AuthConfigSchema = z.object({
   enabled: z.boolean().default(true),
-  allowPublicViewing: z.boolean().default(true),
+  // Existing installations persist their explicit value; new installations opt in.
+  allowPublicViewing: z.boolean().default(false),
+  remoteAccess: RemoteAccessSecurityConfigSchema.default({}),
   jwtSecret: z.string().optional(),
   jwtExpiresInSeconds: z.number().default(7 * 24 * 3600), // 7 days
   tokens: z.array(AuthTokenSchema).default([]),

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

@@ -6,6 +6,9 @@ import { z } from 'zod';
 export const CWKeyerBackendSchema = z.enum(['cat', 'serial']);
 export type CWKeyerBackend = z.infer<typeof CWKeyerBackendSchema>;
 
+export const CWKeyActiveLevelSchema = z.enum(['high', 'low']);
+export type CWKeyActiveLevel = z.infer<typeof CWKeyActiveLevelSchema>;
+
 export const CWKeyerConfigSchema = z.object({
   /** CW 发报后端：cat=Hamlib 整报文，serial=DTR/RTS 时序键控 */
   backend: CWKeyerBackendSchema.default('cat'),
@@ -13,6 +16,8 @@ export const CWKeyerConfigSchema = z.object({
   keyPort: z.string(),
   /** CW 键控引脚类型 */
   keyMethod: z.enum(['dtr', 'rts']),
+  /** CW 键控有效电平：high=高电平按下，low=低电平按下 */
+  keyActiveLevel: CWKeyActiveLevelSchema.default('high'),
   /** 莫尔斯码速度 (WPM, 5-60) */
   wpm: z.number().int().min(5).max(60).default(20),
 });

package/src/schema/diagnostics.schema.ts

@@ -0,0 +1,55 @@
+import { z } from 'zod';
+
+export const DiagnosticLogSourceIdSchema = z.enum(['server', 'electron-main', 'client-tools']);
+export type DiagnosticLogSourceId = z.infer<typeof DiagnosticLogSourceIdSchema>;
+
+export const DiagnosticLogSourceSchema = z.object({
+  id: DiagnosticLogSourceIdSchema,
+  fileName: z.string().min(1),
+  fileCount: z.number().int().positive(),
+  totalBytes: z.number().int().nonnegative(),
+  availableFromMs: z.number().int().positive().nullable(),
+  availableToMs: z.number().int().positive().nullable(),
+});
+export type DiagnosticLogSource = z.infer<typeof DiagnosticLogSourceSchema>;
+
+export const DiagnosticLogSourcesResponseSchema = z.object({
+  sources: z.array(DiagnosticLogSourceSchema),
+  limits: z.object({
+    maxRangeMs: z.number().int().positive(),
+    maxUncompressedBytes: z.number().int().positive(),
+    maxCompressedBytes: z.number().int().positive(),
+    feedbackMaxCharacters: z.number().int().positive(),
+  }),
+});
+export type DiagnosticLogSourcesResponse = z.infer<typeof DiagnosticLogSourcesResponseSchema>;
+
+export const CreateDiagnosticUploadRequestSchema = z.object({
+  sourceId: DiagnosticLogSourceIdSchema,
+  fromMs: z.number().int().positive(),
+  toMs: z.number().int().positive(),
+  feedback: z.string().trim().max(2000).optional(),
+}).strict().superRefine((value, context) => {
+  if (value.toMs <= value.fromMs) {
+    context.addIssue({ code: z.ZodIssueCode.custom, path: ['toMs'], message: 'toMs must be later than fromMs' });
+  }
+  if (value.toMs - value.fromMs > 7 * 24 * 60 * 60 * 1000) {
+    context.addIssue({ code: z.ZodIssueCode.custom, path: ['toMs'], message: 'time range exceeds seven days' });
+  }
+});
+export type CreateDiagnosticUploadRequest = z.infer<typeof CreateDiagnosticUploadRequestSchema>;
+
+export const DiagnosticUploadReceiptSchema = z.object({
+  uploadId: z.string().uuid(),
+  sourceId: DiagnosticLogSourceIdSchema,
+  requestedFromMs: z.number().int().positive(),
+  requestedToMs: z.number().int().positive(),
+  includedFromMs: z.number().int().positive(),
+  includedToMs: z.number().int().positive(),
+  lineCount: z.number().int().positive(),
+  uncompressedBytes: z.number().int().positive(),
+  compressedBytes: z.number().int().positive(),
+  acceptedAt: z.string().datetime(),
+  retainedUntil: z.string().datetime(),
+});
+export type DiagnosticUploadReceipt = z.infer<typeof DiagnosticUploadReceiptSchema>;

package/src/schema/ft8.schema.ts

@@ -276,6 +276,9 @@ export const FT8MessageSchema = z.discriminatedUnion('type', [
  * This is the main plugin-facing FT8 payload. It combines RF metrics from the
  * decoder (`snr`, `dt`, `df`), the original unparsed text (`rawMessage`), the
  * normalized semantic form (`message`) and optional logbook enrichment.
+ * `snr` is dB, `dt` is seconds from the expected decode timing, `df` is audio
+ * offset in hertz, and `timestamp` is Unix epoch milliseconds. `slotId` ties
+ * the decode back to its `SlotInfo`/`SlotPack`.
  */
 export const ParsedFT8MessageSchema = z.object({
   snr: z.number(),
@@ -285,6 +288,11 @@ export const ParsedFT8MessageSchema = z.object({
   message: FT8MessageSchema,
   slotId: z.string(),
   timestamp: z.number(),
+  /**
+   * 标记该消息为 WSJT-X 部分解码（含 `<...>` 未解码呼号占位符）。
+   * 部分解码消息不得作为自动呼叫/回复目标，仅供监控与防御使用。
+   */
+  isPartialDecode: z.boolean().optional(),
   logbookAnalysis: LogbookAnalysisSchema.optional(),
 });
 

package/src/schema/logbook.schema.ts

@@ -1,4 +1,49 @@
 import { z } from 'zod';
+import { QSORecordSchema } from './qso.schema.js';
+
+export const LOGBOOK_OPERATION_ERROR_CODES = [
+  'LOGBOOK_LOADING',
+  'LOGBOOK_READ_ONLY',
+  'LOGBOOK_UNAVAILABLE',
+  'LOGBOOK_WRITE_FAILED',
+  'LOGBOOK_WRITE_STATE_UNCERTAIN',
+  'LOGBOOK_UNSAVED_QSO_NOT_FOUND',
+  'LOGBOOK_BACKUP_FAILED',
+  'LOGBOOK_BACKUP_UNAVAILABLE',
+  'LOGBOOK_BACKUP_CHANGED',
+  'LOGBOOK_MAINTENANCE',
+  'LOGBOOK_REVISION_MISMATCH',
+  'LOGBOOK_RESTORE_PRECONDITION_FAILED',
+  'LOGBOOK_PRECONDITION_REQUIRED',
+  'LOGBOOK_IDEMPOTENCY_CONFLICT',
+] as const;
+
+export const LogbookOperationErrorCodeSchema = z.enum(LOGBOOK_OPERATION_ERROR_CODES);
+
+export const LogbookHealthStateSchema = z.enum([
+  'loading',
+  'healthy',
+  'degraded',
+  'read_only',
+  'unavailable',
+]);
+
+export const LogbookHealthIssueSchema = z.object({
+  code: z.string(),
+  message: z.string(),
+  affectedRecords: z.number().int().nonnegative().optional(),
+  affectedBytes: z.number().int().nonnegative().optional(),
+  recoveryFileName: z.string().optional(),
+  occurredAt: z.number(),
+});
+
+export const LogbookHealthSchema = z.object({
+  state: LogbookHealthStateSchema,
+  readable: z.boolean(),
+  writable: z.boolean(),
+  issues: z.array(LogbookHealthIssueSchema),
+  updatedAt: z.number(),
+});
 
 export const DxccCountSummarySchema = z.object({
   current: z.number().default(0),
@@ -27,10 +72,12 @@ export const LogBookInfoSchema = z.object({
   id: z.string(),
   name: z.string(),
   description: z.string().optional(),
-  filePath: z.string(),
+  fileName: z.string().min(1).max(255),
+  storageKind: z.enum(['managed', 'custom']),
   createdAt: z.number(),
   lastUsed: z.number(),
   isActive: z.boolean(),
+  health: LogbookHealthSchema,
 });
 
 /**
@@ -102,6 +149,141 @@ export const LogBookActionResponseSchema = z.object({
   data: LogBookInfoSchema.optional(),
 });
 
+export const LogbookRecoveryRetryResponseSchema = z.object({
+  success: z.boolean(),
+  data: z.object({
+    logBookId: z.string(),
+    health: LogbookHealthSchema,
+  }),
+});
+
+const LogbookRevisionSchema = z.string()
+  .min(1)
+  .max(256)
+  .regex(/^[A-Za-z0-9._:"-]+$/);
+const LogbookIdempotencyKeySchema = z.string()
+  .min(8)
+  .max(128)
+  .regex(/^[A-Za-z0-9._:-]+$/);
+const LogbookRecoveryTokenSchema = z.string()
+  .min(8)
+  .max(128)
+  .regex(/^[A-Za-z0-9._:-]+$/);
+const UnsavedQsoAttemptIdSchema = z.string()
+  .min(8)
+  .max(128)
+  .regex(/^[A-Za-z0-9._:-]+$/);
+
+export const LogbookUnsavedQsoSummarySchema = z.object({
+  attemptId: UnsavedQsoAttemptIdSchema,
+  operatorId: z.string().min(1).max(128),
+  createdAt: z.number(),
+  callsign: z.string().max(64),
+  mode: z.string().max(32),
+});
+
+export const LogbookBackupArtifactSchema = z.object({
+  createdAt: z.number(),
+  size: z.number().int().nonnegative(),
+  recordCount: z.number().int().nonnegative().optional(),
+  opaqueRecordCount: z.number().int().nonnegative().optional(),
+});
+
+export const LogbookBackupOperationSchema = z.object({
+  id: z.string().min(1).max(128),
+  kind: z.enum(['backup', 'restore-prepare', 'restore']),
+  state: z.enum(['queued', 'running', 'succeeded', 'failed']),
+  phase: z.string().min(1).max(128),
+  processedBytes: z.number().int().nonnegative().optional(),
+  totalBytes: z.number().int().nonnegative().optional(),
+  errorCode: z.string().min(1).max(128).optional(),
+});
+
+export const LogbookBackupStatusSchema = z.object({
+  logBookId: z.string(),
+  revision: LogbookRevisionSchema,
+  mainHealth: LogbookHealthSchema,
+  dirty: z.boolean(),
+  pendingMutations: z.number().int().nonnegative(),
+  latest: LogbookBackupArtifactSchema.optional(),
+  preRestore: LogbookBackupArtifactSchema.optional(),
+  operation: LogbookBackupOperationSchema.optional(),
+  unsaved: z.array(LogbookUnsavedQsoSummarySchema).optional(),
+  capabilities: z.object({
+    canCreate: z.boolean(),
+    canDownload: z.boolean(),
+    canRestore: z.boolean(),
+    canDownloadPreRestore: z.boolean(),
+  }),
+  error: z.object({
+    code: z.string().min(1).max(128),
+    message: z.string(),
+  }).optional(),
+});
+
+export const LogbookBackupStatusResponseSchema = z.object({
+  success: z.literal(true),
+  data: LogbookBackupStatusSchema,
+});
+
+export const CreateLogbookBackupRequestSchema = z.object({
+}).strict();
+
+export const PrepareLogbookRestoreRequestSchema = z.object({
+}).strict();
+
+export const RestoreLogbookRequestSchema = z.object({
+  preflightToken: LogbookRecoveryTokenSchema,
+  confirmation: z.string().min(1).max(128),
+}).strict();
+
+export const LogbookConditionalMutationHeadersSchema = z.object({
+  revision: LogbookRevisionSchema,
+  idempotencyKey: LogbookIdempotencyKeySchema,
+}).strict();
+
+export const LogbookIdempotentMutationHeadersSchema = z.object({
+  idempotencyKey: LogbookIdempotencyKeySchema,
+}).strict();
+
+export const LogbookRestoreFileSummarySchema = z.object({
+  size: z.number().int().nonnegative(),
+  recordCount: z.number().int().nonnegative(),
+  opaqueRecordCount: z.number().int().nonnegative(),
+  incompleteTail: z.boolean(),
+  issueCount: z.number().int().nonnegative(),
+});
+
+export const LogbookRestorePreflightSchema = z.object({
+  preflightToken: LogbookRecoveryTokenSchema,
+  expiresAt: z.number(),
+  revision: LogbookRevisionSchema,
+  main: LogbookRestoreFileSummarySchema,
+  backup: LogbookRestoreFileSummarySchema,
+  recordDelta: z.number().int(),
+  estimatedLoss: z.number().int().nonnegative(),
+  highRisk: z.boolean(),
+});
+
+export const LogbookRestorePreflightResponseSchema = z.object({
+  success: z.literal(true),
+  data: LogbookRestorePreflightSchema,
+});
+
+export const LogbookUnsavedQsoRetryResponseSchema = z.object({
+  success: z.literal(true),
+  data: QSORecordSchema,
+});
+
+export const LogbookUnsavedQsoDiscardResponseSchema = z.object({
+  success: z.literal(true),
+  data: z.object({ attemptId: UnsavedQsoAttemptIdSchema }),
+});
+
+export const LogbookUnsavedQsoAttemptParamsSchema = z.object({
+  attemptId: UnsavedQsoAttemptIdSchema,
+}).strict();
+
 /**
  * 日志本QSO查询选项Schema
  */
@@ -293,6 +475,10 @@ export const QSOActionResponseSchema = z.object({
 // ========== 类型导出 ==========
 
 export type LogBookInfo = z.infer<typeof LogBookInfoSchema>;
+export type LogbookOperationErrorCode = z.infer<typeof LogbookOperationErrorCodeSchema>;
+export type LogbookHealthState = z.infer<typeof LogbookHealthStateSchema>;
+export type LogbookHealthIssue = z.infer<typeof LogbookHealthIssueSchema>;
+export type LogbookHealth = z.infer<typeof LogbookHealthSchema>;
 export type CreateLogBookRequest = z.infer<typeof CreateLogBookRequestSchema>;
 export type UpdateLogBookRequest = z.infer<typeof UpdateLogBookRequestSchema>;
 export type ConnectOperatorToLogBookRequest = z.infer<typeof ConnectOperatorToLogBookRequestSchema>;
@@ -301,6 +487,23 @@ export type LogBookDxccSummary = z.infer<typeof LogBookDxccSummarySchema>;
 export type LogBookListResponse = z.infer<typeof LogBookListResponseSchema>;
 export type LogBookDetailResponse = z.infer<typeof LogBookDetailResponseSchema>;
 export type LogBookActionResponse = z.infer<typeof LogBookActionResponseSchema>;
+export type LogbookRecoveryRetryResponse = z.infer<typeof LogbookRecoveryRetryResponseSchema>;
+export type LogbookUnsavedQsoSummary = z.infer<typeof LogbookUnsavedQsoSummarySchema>;
+export type LogbookBackupArtifact = z.infer<typeof LogbookBackupArtifactSchema>;
+export type LogbookBackupOperation = z.infer<typeof LogbookBackupOperationSchema>;
+export type LogbookBackupStatus = z.infer<typeof LogbookBackupStatusSchema>;
+export type LogbookBackupStatusResponse = z.infer<typeof LogbookBackupStatusResponseSchema>;
+export type CreateLogbookBackupRequest = z.infer<typeof CreateLogbookBackupRequestSchema>;
+export type PrepareLogbookRestoreRequest = z.infer<typeof PrepareLogbookRestoreRequestSchema>;
+export type RestoreLogbookRequest = z.infer<typeof RestoreLogbookRequestSchema>;
+export type LogbookConditionalMutationHeaders = z.infer<typeof LogbookConditionalMutationHeadersSchema>;
+export type LogbookIdempotentMutationHeaders = z.infer<typeof LogbookIdempotentMutationHeadersSchema>;
+export type LogbookRestoreFileSummary = z.infer<typeof LogbookRestoreFileSummarySchema>;
+export type LogbookRestorePreflight = z.infer<typeof LogbookRestorePreflightSchema>;
+export type LogbookRestorePreflightResponse = z.infer<typeof LogbookRestorePreflightResponseSchema>;
+export type LogbookUnsavedQsoRetryResponse = z.infer<typeof LogbookUnsavedQsoRetryResponseSchema>;
+export type LogbookUnsavedQsoDiscardResponse = z.infer<typeof LogbookUnsavedQsoDiscardResponseSchema>;
+export type LogbookUnsavedQsoAttemptParams = z.infer<typeof LogbookUnsavedQsoAttemptParamsSchema>;
 export type LogBookQSOQueryOptions = z.infer<typeof LogBookQSOQueryOptionsSchema>;
 export type LogBookRecentGlobeQuery = z.infer<typeof LogBookRecentGlobeQuerySchema>;
 export type LogBookRecentGlobeHomeSource = z.infer<typeof LogBookRecentGlobeHomeSourceSchema>;

package/src/schema/mode.schema.ts

@@ -1,8 +1,6 @@
 import { z } from 'zod';
 
-/**
- * 模式描述符 - 定义 FT8/FT4 等模式的时序参数
- */
+/** Timing, decoder and display parameters for a digital mode such as FT8 or FT4. */
 export const ModeDescriptorSchema = z.object({
   /** 模式名称，如 "FT8", "FT4" */
   name: z.string(),
@@ -109,9 +107,7 @@ export const FT4_WINDOW_PRESETS: Record<string, number[]> = {
   lightweight: [0],              // 1 轮：仅末端
 };
 
-/**
- * 解码窗口设置 Schema
- */
+/** Per-mode decode-window presets and optional custom timing windows. */
 export const DecodeWindowSettingsSchema = z.object({
   ft8: z.object({
     preset: z.enum(['maximum', 'balanced', 'lightweight', 'minimum', 'custom']).default('balanced'),

package/src/schema/observability.schema.ts

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+
+export const OBSERVABILITY_NOTICE_VERSION = 1;
+
+export const ObservabilitySettingsSchema = z.object({
+  enabled: z.boolean(),
+  noticeVersion: z.number().int().nonnegative(),
+});
+export type ObservabilitySettings = z.infer<typeof ObservabilitySettingsSchema>;
+
+export const UpdateObservabilitySettingsSchema = z.object({
+  enabled: z.boolean(),
+  noticeVersion: z.literal(OBSERVABILITY_NOTICE_VERSION),
+});
+export type UpdateObservabilitySettingsRequest = z.infer<typeof UpdateObservabilitySettingsSchema>;
+
+export const ObservabilityStatusSchema = z.object({
+  settings: ObservabilitySettingsSchema,
+  effectiveEnabled: z.boolean(),
+  noticeRequired: z.boolean(),
+  endpointConfigured: z.boolean(),
+  queueDepth: z.number().int().nonnegative(),
+  lastSentAt: z.number().int().nonnegative().nullable(),
+  lastError: z.string().nullable(),
+});
+export type ObservabilityStatus = z.infer<typeof ObservabilityStatusSchema>;

package/src/schema/operator.schema.ts

@@ -1,18 +1,24 @@
 import { z } from 'zod';
 import { ModeDescriptorSchema } from './mode.schema.js';
 import { sanitizeCallsignInput } from '../utils/callsign.js';
+import { sanitizeGridInput } from '../utils/grid.js';
 
 const OperatorCallsignSchema = z
   .string()
   .transform(sanitizeCallsignInput)
   .pipe(z.string().min(1, '呼号不能为空').max(10, '呼号不能超过10个字符'));
 
+const OperatorGridSchema = z
+  .string()
+  .transform(sanitizeGridInput)
+  .pipe(z.string().min(4, '网格坐标至少4位').max(8, '网格坐标不能超过8位'));
+
 // 操作员配置 Schema (重命名以避免冲突)
 export const RadioOperatorConfigSchema = z.object({
   id: z.string().min(1, '操作员ID不能为空'),
   createdByTokenId: z.string().optional(), // 创建者 Token ID（仅用于审计，不参与权限判断）
   myCallsign: OperatorCallsignSchema,
-  myGrid: z.string().min(4, '网格坐标至少4位').max(8, '网格坐标不能超过8位').optional(),
+  myGrid: OperatorGridSchema.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=奇数周期
   mode: ModeDescriptorSchema.optional(),