@tx5dr/contracts 1.7.12 → 2.5.0

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

@@ -0,0 +1,342 @@
+import { z } from 'zod';
+
+export const ImageFamilySchema = z.enum(['sstv', 'fax']);
+export type ImageFamily = z.infer<typeof ImageFamilySchema>;
+
+export const ImagePixelFormatSchema = z.enum(['rgb8', 'gray8']);
+export type ImagePixelFormat = z.infer<typeof ImagePixelFormatSchema>;
+
+export const ImageSstvReceiveProfileSchema = z.discriminatedUnion('strategy', [
+  z.object({ family: z.literal('sstv'), strategy: z.literal('auto') }),
+  z.object({ family: z.literal('sstv'), strategy: z.literal('manual'), mode: z.string().min(1) }),
+]);
+export type ImageSstvReceiveProfile = z.infer<typeof ImageSstvReceiveProfileSchema>;
+
+export const ImageFaxReceiveProfileSchema = z.discriminatedUnion('strategy', [
+  z.object({ family: z.literal('fax'), strategy: z.literal('auto') }),
+  z.object({
+    family: z.literal('fax'), strategy: z.literal('manual'),
+    ioc: z.enum(['ioc288', 'ioc576']), lpm: z.number().int().positive(),
+    modulation: z.enum(['fm', 'am']), centerHz: z.number().positive(),
+    deviationHz: z.number().positive(),
+  }),
+]);
+export type ImageFaxReceiveProfile = z.infer<typeof ImageFaxReceiveProfileSchema>;
+
+export const ImageReceiveProfileSchema = z.union([
+  ImageSstvReceiveProfileSchema,
+  ImageFaxReceiveProfileSchema,
+]);
+export type ImageReceiveProfile = z.infer<typeof ImageReceiveProfileSchema>;
+
+export const ImageSstvModeInfoSchema = z.object({
+  mode: z.string(), name: z.string(), visCode: z.number().int().nonnegative(),
+  width: z.number().int().positive(), height: z.number().int().positive(),
+  colorLayout: z.enum(['monochrome', 'rgb', 'yuv']),
+  scanLayout: z.enum(['monochrome', 'martin', 'scottie', 'robot', 'pd', 'wraase', 'pasokon']),
+  lineSeconds: z.number().positive(), rowsPerLine: z.number().int().positive(),
+  status: z.enum(['canonical', 'compatibility']),
+});
+export type ImageSstvModeInfo = z.infer<typeof ImageSstvModeInfoSchema>;
+
+export const ImageRadioCapabilitySchema = z.object({
+  available: z.boolean(),
+  reason: z.string().optional(),
+  sstv: z.object({ rx: z.literal(true), tx: z.literal(true) }),
+  fax: z.object({ rx: z.literal(true), tx: z.literal(false) }),
+});
+export type ImageRadioCapability = z.infer<typeof ImageRadioCapabilitySchema>;
+
+export const ImageRadioServiceStateSchema = z.enum(['stopped', 'starting', 'ready', 'degraded', 'unavailable']);
+export const ImageRxStateSchema = z.enum(['off', 'searching', 'acquiring', 'receiving', 'completed', 'aborted', 'error']);
+export const SstvTxPhaseSchema = z.enum([
+  'idle', 'preparing', 'waiting_for_lease', 'keying', 'on_air', 'draining',
+  'completed', 'cancelled', 'error', 'ptt_unknown',
+]);
+export const SstvStationIdModeSchema = z.enum(['fsk', 'cw', 'none']);
+export type SstvStationIdMode = z.infer<typeof SstvStationIdModeSchema>;
+export const SstvTxEnvelopeSelectionSchema = z.object({
+  enhancedPreamble: z.boolean().default(true),
+  stationIdMode: SstvStationIdModeSchema.default('fsk'),
+});
+export type SstvTxEnvelopeSelection = z.infer<typeof SstvTxEnvelopeSelectionSchema>;
+export const SstvTxEnvelopeSnapshotSchema = SstvTxEnvelopeSelectionSchema.extend({
+  callsign: z.string().optional(),
+  postImageGapMs: z.literal(500),
+  endGuardMs: z.literal(300),
+  cwWpm: z.literal(20),
+  cwToneHz: z.literal(800),
+});
+export type SstvTxEnvelopeSnapshot = z.infer<typeof SstvTxEnvelopeSnapshotSchema>;
+export const SstvTxPreferencesSchema = SstvTxEnvelopeSelectionSchema.extend({
+  operatorId: z.string().min(1),
+  updatedAt: z.number(),
+});
+export type SstvTxPreferences = z.infer<typeof SstvTxPreferencesSchema>;
+
+export const ImageSessionSummarySchema = z.object({
+  sessionId: z.string(),
+  family: ImageFamilySchema,
+  generation: z.number().int().nonnegative(),
+  revision: z.number().int().nonnegative(),
+  codecMode: z.string().optional(),
+  width: z.number().int().positive().optional(),
+  height: z.number().int().positive().optional(),
+  receivedLines: z.number().int().nonnegative().default(0),
+  firstAvailableLine: z.number().int().nonnegative().default(0),
+  startedAt: z.number(),
+});
+export type ImageSessionSummary = z.infer<typeof ImageSessionSummarySchema>;
+
+export const SstvTxStatusSchema = z.object({
+  phase: SstvTxPhaseSchema,
+  sessionId: z.string().optional(),
+  requestId: z.string().optional(),
+  operatorId: z.string().optional(),
+  artifactId: z.string().optional(),
+  historyId: z.string().optional(),
+  mode: z.string().optional(),
+  encoderStage: z.enum(['preamble', 'vis', 'raster', 'stationId', 'guard', 'finished']).optional(),
+  envelope: SstvTxEnvelopeSnapshotSchema.optional(),
+  revision: z.number().int().nonnegative().default(0),
+  samplesEmitted: z.number().int().nonnegative().default(0),
+  estimatedTotalSamples: z.number().int().nonnegative().default(0),
+  currentRow: z.number().int().nonnegative().optional(),
+  startedAt: z.number().optional(),
+  errorCode: z.string().optional(),
+});
+export type SstvTxStatus = z.infer<typeof SstvTxStatusSchema>;
+
+export const ImageRadioStatusSchema = z.object({
+  serviceState: ImageRadioServiceStateSchema,
+  family: ImageFamilySchema.nullable(),
+  receiveProfile: ImageReceiveProfileSchema.nullable(),
+  rxState: ImageRxStateSchema,
+  rxCaptureActive: z.boolean().default(false),
+  capability: ImageRadioCapabilitySchema,
+  currentSession: ImageSessionSummarySchema.nullable(),
+  tx: SstvTxStatusSchema,
+  nativeQueuedSamples: z.number().int().nonnegative().default(0),
+  jsBacklogSamples: z.number().int().nonnegative().default(0),
+  discontinuities: z.number().int().nonnegative().default(0),
+  updatedAt: z.number(),
+});
+export type ImageRadioStatus = z.infer<typeof ImageRadioStatusSchema>;
+
+export const ImageRowPatchSchema = z.object({
+  rowIndex: z.number().int().nonnegative(),
+  width: z.number().int().positive(),
+  rowRevision: z.number().int().nonnegative(),
+  completeness: z.enum(['provisional', 'final']).optional(),
+  dataBase64: z.string(),
+});
+
+export const ImagePaperBoundaryKindSchema = z.enum([
+  'initial', 'vis', 'syncTiming', 'aptPhasing', 'protocolEnd',
+  'manualMode', 'discontinuity', 'reset', 'truncated', 'protocolObserved',
+  'localTxStart', 'localTxEnd',
+]);
+export type ImagePaperBoundaryKind = z.infer<typeof ImagePaperBoundaryKindSchema>;
+export const ImagePaperSourceSchema = z.enum(['rx', 'localTx']);
+export type ImagePaperSource = z.infer<typeof ImagePaperSourceSchema>;
+
+export const ImagePaperBoundarySchema = z.object({
+  boundaryId: z.string(), lineIndex: z.number().int().nonnegative(),
+  kind: ImagePaperBoundaryKindSchema, trusted: z.boolean(),
+  codecMode: z.string(), width: z.number().int().positive(),
+  pixelFormat: ImagePixelFormatSchema, timestamp: z.number(),
+  detection: z.string().optional(), nominalHeight: z.number().int().positive().optional(),
+  source: ImagePaperSourceSchema.optional(),
+  txSessionId: z.string().optional(),
+  txOutcome: z.enum(['completed', 'interrupted']).optional(),
+});
+export type ImagePaperBoundary = z.infer<typeof ImagePaperBoundarySchema>;
+
+export const ImageFaxCalibrationPointSchema = z.object({
+  revision: z.number().int().nonnegative(),
+  referenceLine: z.number().int().nonnegative(),
+  phasePixels: z.number().finite(),
+  clockPpm: z.number().finite(),
+  confidence: z.number().min(0).max(1),
+  source: z.enum(['nominal', 'phasing', 'imageContent', 'manual']),
+  status: z.enum(['nominal', 'acquiring', 'locked', 'tracking', 'degraded']),
+});
+export type ImageFaxCalibrationPoint = z.infer<typeof ImageFaxCalibrationPointSchema>;
+
+export const ImageFaxCalibrationSchema = z.object({
+  boundaryId: z.string().min(1),
+  revision: z.number().int().nonnegative(),
+  autoEnabled: z.boolean(),
+  autoPoints: z.array(ImageFaxCalibrationPointSchema).max(256),
+  manualPhasePixels: z.number().finite(),
+  manualClockPpm: z.number().finite(),
+  updatedAt: z.number(),
+});
+export type ImageFaxCalibration = z.infer<typeof ImageFaxCalibrationSchema>;
+
+export const ImageRxEventSchema = z.discriminatedUnion('type', [
+  z.object({ type: z.literal('paperStarted'), session: ImageSessionSummarySchema, pixelFormat: ImagePixelFormatSchema }),
+  z.object({ type: z.literal('boundary'), sessionId: z.string(), generation: z.number().int().nonnegative(), revision: z.number().int().nonnegative(), boundary: ImagePaperBoundarySchema }),
+  z.object({ type: z.literal('faxCalibration'), sessionId: z.string(), generation: z.number().int().nonnegative(), revision: z.number().int().nonnegative(), calibration: ImageFaxCalibrationSchema }),
+  z.object({ type: z.literal('signalDetected'), family: ImageFamilySchema, confidence: z.number().min(0).max(1), candidates: z.array(z.string()), timestamp: z.number() }),
+  z.object({ type: z.literal('imageStarted'), session: ImageSessionSummarySchema, pixelFormat: ImagePixelFormatSchema, detection: z.string().optional(), confidence: z.number().min(0).max(1).optional() }),
+  z.object({ type: z.literal('rows'), sessionId: z.string(), generation: z.number().int().nonnegative(), revision: z.number().int().nonnegative(), pixelFormat: ImagePixelFormatSchema, rows: z.array(ImageRowPatchSchema).min(1).max(8) }),
+  z.object({ type: z.literal('imageCompleted'), sessionId: z.string(), generation: z.number().int().nonnegative(), revision: z.number().int().nonnegative(), artifactId: z.string(), previewUrl: z.string(), partial: z.boolean() }),
+  z.object({ type: z.literal('imageAborted'), sessionId: z.string(), generation: z.number().int().nonnegative(), revision: z.number().int().nonnegative(), reason: z.string(), lastRow: z.number().int().nonnegative().optional(), temporary: z.boolean() }),
+  z.object({ type: z.literal('snapshotRequired'), sessionId: z.string(), generation: z.number().int().nonnegative(), revision: z.number().int().nonnegative(), snapshotUrl: z.string() }),
+  z.object({ type: z.literal('captureSaved'), sessionId: z.string(), generation: z.number().int().nonnegative(), revision: z.number().int().nonnegative(), artifactId: z.string(), previewUrl: z.string(), saveReason: z.enum(['manual', 'protocolEnd']), complete: z.boolean(), startLine: z.number().int().nonnegative(), endLine: z.number().int().positive() }),
+]);
+export type ImageRxEvent = z.infer<typeof ImageRxEventSchema>;
+
+export const ImageArtifactSchema = z.object({
+  id: z.string(),
+  family: ImageFamilySchema,
+  direction: z.enum(['rx', 'tx']),
+  operatorId: z.string().optional(),
+  codecMode: z.string(),
+  pixelFormat: ImagePixelFormatSchema,
+  width: z.number().int().positive(),
+  height: z.number().int().positive(),
+  frequency: z.number().positive(),
+  radioMode: z.string().optional(),
+  complete: z.boolean(),
+  saveReason: z.enum(['manual', 'protocolEnd']).optional(),
+  captureStartedAt: z.number().optional(),
+  captureEndedAt: z.number().optional(),
+  truncated: z.boolean().default(false),
+  pinned: z.boolean().default(false),
+  qsoId: z.string().optional(),
+  contentHash: z.string(),
+  createdAt: z.number(),
+  imageUrl: z.string(),
+  faxCalibration: ImageFaxCalibrationSchema.optional(),
+});
+export type ImageArtifact = z.infer<typeof ImageArtifactSchema>;
+
+const ImageHistoryRecordBaseSchema = z.object({
+  id: z.string(),
+  artifactId: z.string(),
+  family: ImageFamilySchema,
+  operatorId: z.string().optional(),
+  occurredAt: z.number(),
+  qsoId: z.string().optional(),
+});
+
+export const ImageHistoryRecordSchema = z.discriminatedUnion('direction', [
+  ImageHistoryRecordBaseSchema.extend({
+    direction: z.literal('rx'),
+    saveReason: z.enum(['manual', 'protocolEnd']),
+    complete: z.boolean(),
+    truncated: z.boolean().default(false),
+  }),
+  ImageHistoryRecordBaseSchema.extend({
+    direction: z.literal('tx'),
+    operatorId: z.string().min(1),
+    sessionId: z.string().min(1),
+    startedAt: z.number(),
+    endedAt: z.number().optional(),
+    outcome: z.enum(['transmitting', 'completed', 'interrupted']),
+    errorCode: z.string().optional(),
+    envelope: SstvTxEnvelopeSnapshotSchema.optional(),
+    sampleRate: z.number().int().positive().optional(),
+    estimatedTotalSamples: z.number().int().nonnegative().optional(),
+  }),
+]);
+export type ImageHistoryRecord = z.infer<typeof ImageHistoryRecordSchema>;
+
+export const ImageHistoryEntrySchema = z.object({
+  record: ImageHistoryRecordSchema,
+  artifact: ImageArtifactSchema,
+});
+export type ImageHistoryEntry = z.infer<typeof ImageHistoryEntrySchema>;
+
+export const ImageTemplateTextLayerSchema = z.object({
+  id: z.string().min(1).max(64),
+  text: z.string().max(256),
+  x: z.number().min(-2).max(2),
+  y: z.number().min(-2).max(2),
+  width: z.number().positive().max(4),
+  height: z.number().positive().max(4),
+  fontSize: z.number().positive().max(1),
+  color: z.string().regex(/^#[0-9a-fA-F]{6}$/),
+  strokeColor: z.string().regex(/^#[0-9a-fA-F]{6}$/).optional(),
+  strokeWidth: z.number().min(0).max(0.5).default(0.12),
+  align: z.enum(['left', 'center', 'right']).default('center'),
+  rotation: z.number().min(-180).max(180).default(0),
+});
+export type ImageTemplateTextLayer = z.infer<typeof ImageTemplateTextLayerSchema>;
+
+export const ImageTemplateSchema = z.object({
+  id: z.string(),
+  operatorId: z.string().optional(),
+  name: z.string().min(1).max(80),
+  builtIn: z.boolean().default(false),
+  backgroundArtifactId: z.string().optional(),
+  layers: z.array(ImageTemplateTextLayerSchema).max(16),
+  createdAt: z.number(),
+  updatedAt: z.number(),
+});
+export type ImageTemplate = z.infer<typeof ImageTemplateSchema>;
+
+export const ImageComposerBackgroundSchema = z.object({
+  operatorId: z.string().min(1),
+  width: z.number().int().positive(),
+  height: z.number().int().positive(),
+  updatedAt: z.number(),
+  imageUrl: z.string(),
+});
+export type ImageComposerBackground = z.infer<typeof ImageComposerBackgroundSchema>;
+
+export const ImageRxSubscriptionSchema = z.object({ enabled: z.boolean() });
+export const SstvTxStartCommandSchema = z.object({
+  requestId: z.string().min(1).max(128),
+  operatorId: z.string().min(1),
+  artifactId: z.string().min(1),
+  mode: z.string().min(1),
+  expectedFrequency: z.number().positive(),
+  interruptActiveCapture: z.boolean().optional(),
+  envelope: SstvTxEnvelopeSelectionSchema.default({ enhancedPreamble: true, stationIdMode: 'fsk' }),
+});
+export type SstvTxStartCommand = z.infer<typeof SstvTxStartCommandSchema>;
+export const SstvTxCancelCommandSchema = z.object({
+  requestId: z.string().min(1).max(128),
+  operatorId: z.string().min(1),
+  sessionId: z.string().min(1),
+  expectedRevision: z.number().int().nonnegative(),
+});
+export type SstvTxCancelCommand = z.infer<typeof SstvTxCancelCommandSchema>;
+export const SstvTxCommandResultSchema = z.object({
+  requestId: z.string(),
+  accepted: z.boolean(),
+  sessionId: z.string().optional(),
+  errorCode: z.string().optional(),
+});
+export type SstvTxCommandResult = z.infer<typeof SstvTxCommandResultSchema>;
+
+export const ImagePaperSaveCommandSchema = z.object({
+  requestId: z.string().min(1).max(128),
+  operatorId: z.string().min(1),
+  expectedRevision: z.number().int().nonnegative(),
+});
+export type ImagePaperSaveCommand = z.infer<typeof ImagePaperSaveCommandSchema>;
+
+const FaxCalibrationCommandBaseSchema = z.object({
+  requestId: z.string().min(1).max(128),
+  operatorId: z.string().min(1),
+  sessionId: z.string().min(1),
+  boundaryId: z.string().min(1),
+  expectedRevision: z.number().int().nonnegative(),
+});
+export const FaxCalibrationSetCommandSchema = FaxCalibrationCommandBaseSchema.extend({
+  autoEnabled: z.boolean(),
+  phasePixels: z.number().finite(),
+  clockPpm: z.number().finite().min(-5000).max(5000),
+});
+export type FaxCalibrationSetCommand = z.infer<typeof FaxCalibrationSetCommandSchema>;
+export const FaxCalibrationResetCommandSchema = FaxCalibrationCommandBaseSchema;
+export type FaxCalibrationResetCommand = z.infer<typeof FaxCalibrationResetCommandSchema>;
+export const FaxCalibrationCommandResultSchema = z.object({
+  requestId: z.string(), accepted: z.boolean(),
+  calibration: ImageFaxCalibrationSchema.optional(), errorCode: z.string().optional(),
+});
+export type FaxCalibrationCommandResult = z.infer<typeof FaxCalibrationCommandResultSchema>;

package/src/schema/logbook.schema.ts

@@ -1,4 +1,50 @@
 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_CONFLICT',
+  '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 +73,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 +150,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 +476,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 +488,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(),
@@ -71,6 +69,22 @@ export const MODES = {
     transmitTiming: 0,
     encodeAdvance: 0,
   } as ModeDescriptor,
+  SSTV: {
+    name: 'SSTV',
+    slotMs: 0,
+    toleranceMs: 0,
+    windowTiming: [],
+    transmitTiming: 0,
+    encodeAdvance: 0,
+  } as ModeDescriptor,
+  FAX: {
+    name: 'FAX',
+    slotMs: 0,
+    toleranceMs: 0,
+    windowTiming: [],
+    transmitTiming: 0,
+    encodeAdvance: 0,
+  } as ModeDescriptor,
 } as const;
 
 /**
@@ -109,9 +123,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>;