@tx5dr/contracts 1.7.12 → 2.5.0

package/src/schema/__tests__/logbook-health.schema.test.ts

@@ -0,0 +1,117 @@
+import { describe, expect, it } from 'vitest';
+
+import {
+  CreateLogbookBackupRequestSchema,
+  LogBookInfoSchema,
+  LogbookHealthSchema,
+  RestoreLogbookRequestSchema,
+  WSMessageSchema,
+  WSMessageType,
+} from '../../index.js';
+
+const loadingHealth = {
+  state: 'loading' as const,
+  readable: false,
+  writable: false,
+  issues: [],
+  updatedAt: 1_775_394_000_000,
+};
+
+describe('logbook health contracts', () => {
+  it('requires every logbook listing to expose health', () => {
+    const info = {
+      id: 'logbook-N0CALL',
+      name: 'N0CALL QSO Log',
+      fileName: 'N0CALL.adi',
+      storageKind: 'managed' as const,
+      createdAt: 1,
+      lastUsed: 2,
+      isActive: true,
+    };
+
+    expect(LogBookInfoSchema.safeParse(info).success).toBe(false);
+    const parsed = LogBookInfoSchema.parse({ ...info, health: loadingHealth });
+    expect(parsed.health).toEqual(loadingHealth);
+    expect(parsed).not.toHaveProperty('filePath');
+  });
+
+  it('rejects path-bearing fields in backup and restore mutations', () => {
+    expect(CreateLogbookBackupRequestSchema.safeParse({
+      filePath: '/tmp/escape.adi',
+    }).success).toBe(false);
+    expect(RestoreLogbookRequestSchema.safeParse({
+      preflightToken: 'preflight-token-1',
+      confirmation: 'logbook-N0CALL',
+      artifactPath: '../another.adi',
+    }).success).toBe(false);
+  });
+
+  it('rejects negative affected record and byte counts', () => {
+    expect(LogbookHealthSchema.safeParse({
+      ...loadingHealth,
+      issues: [{
+        code: 'OPAQUE_RECORDS',
+        message: 'One record was skipped',
+        affectedRecords: -1,
+        affectedBytes: -1,
+        occurredAt: loadingHealth.updatedAt,
+      }],
+    }).success).toBe(false);
+  });
+
+  it('validates health and write-failure websocket payloads', () => {
+    expect(WSMessageSchema.safeParse({
+      type: WSMessageType.LOGBOOK_HEALTH_CHANGED,
+      timestamp: new Date().toISOString(),
+      data: { logBookId: 'logbook-N0CALL', health: loadingHealth },
+    }).success).toBe(true);
+    expect(WSMessageSchema.safeParse({
+      type: WSMessageType.LOGBOOK_WRITE_FAILED,
+      timestamp: new Date().toISOString(),
+      data: {
+        logBookId: 'logbook-N0CALL',
+        operatorId: 'operator-1',
+        attemptId: 'attempt-12345678',
+        unsavedCount: 1,
+        error: {
+          code: 'LOGBOOK_WRITE_FAILED',
+          message: 'No space left on device',
+          systemCode: 'ENOSPC',
+          occurredAt: loadingHealth.updatedAt,
+        },
+      },
+    }).success).toBe(true);
+    expect(WSMessageSchema.safeParse({
+      type: WSMessageType.LOGBOOK_WRITE_FAILED,
+      timestamp: new Date().toISOString(),
+      data: {
+        logBookId: 'logbook-N0CALL',
+        qsoRecord: {
+          id: 'private-qso',
+          callsign: 'N0CALL',
+          frequency: 14_074_000,
+          mode: 'FT8',
+          startTime: loadingHealth.updatedAt,
+          messageHistory: ['CQ N0CALL AA00'],
+        },
+        error: {
+          code: 'LOGBOOK_WRITE_FAILED',
+          message: 'write failed',
+          occurredAt: loadingHealth.updatedAt,
+        },
+      },
+    }).success).toBe(false);
+    expect(WSMessageSchema.safeParse({
+      type: WSMessageType.LOGBOOK_WRITE_FAILED,
+      timestamp: new Date().toISOString(),
+      data: {
+        logBookId: 'logbook-N0CALL',
+        error: {
+          code: 'ARBITRARY_ERROR',
+          message: 'Unstable error code',
+          occurredAt: loadingHealth.updatedAt,
+        },
+      },
+    }).success).toBe(false);
+  });
+});

package/src/schema/__tests__/meter.schema.test.ts

@@ -0,0 +1,28 @@
+import { describe, expect, it } from 'vitest';
+import { MeterDataSchema } from '../websocket.schema.js';
+
+describe('MeterDataSchema', () => {
+  it('accepts watts without an invented normalized percentage', () => {
+    expect(MeterDataSchema.parse({
+      swr: null,
+      alc: null,
+      level: null,
+      power: { raw: 12.5, percent: null, watts: 12.5, maxWatts: null },
+    }).power?.percent).toBeNull();
+  });
+
+  it('accepts native dBFS ALC while keeping legacy percent messages compatible', () => {
+    expect(MeterDataSchema.parse({
+      swr: null,
+      alc: { raw: -2.5, percent: 87.5, alert: true, unit: 'dbfs' },
+      level: null,
+      power: null,
+    }).alc?.unit).toBe('dbfs');
+    expect(MeterDataSchema.parse({
+      swr: null,
+      alc: { raw: 120, percent: 100, alert: true },
+      level: null,
+      power: null,
+    }).alc?.unit).toBeUndefined();
+  });
+});

package/src/schema/__tests__/observability.schema.test.ts

@@ -0,0 +1,15 @@
+import { describe, expect, it } from 'vitest';
+import {
+  OBSERVABILITY_NOTICE_VERSION,
+  UpdateObservabilitySettingsSchema,
+} from '../observability.schema.js';
+
+describe('observability settings schema', () => {
+  it('requires acknowledgment of the current notice', () => {
+    expect(UpdateObservabilitySettingsSchema.parse({
+      enabled: true,
+      noticeVersion: OBSERVABILITY_NOTICE_VERSION,
+    })).toEqual({ enabled: true, noticeVersion: 1 });
+    expect(() => UpdateObservabilitySettingsSchema.parse({ enabled: true, noticeVersion: 0 })).toThrow();
+  });
+});

package/src/schema/__tests__/operator-context-report.schema.test.ts

@@ -0,0 +1,77 @@
+import { describe, expect, it } from 'vitest';
+import {
+  StrategyRuntimeSnapshotSchema,
+  WSMessageSchema,
+  WSMessageType,
+} from '../../index.js';
+
+describe('operator context report contracts', () => {
+  it('accepts null only as an explicit WebSocket clear command', () => {
+    expect(WSMessageSchema.safeParse({
+      type: WSMessageType.SET_OPERATOR_CONTEXT,
+      timestamp: new Date(0).toISOString(),
+      data: {
+        operatorId: 'operator-1',
+        context: {
+          reportSent: null,
+          reportReceived: null,
+        },
+      },
+    }).success).toBe(true);
+  });
+
+  it('keeps normalized strategy snapshots free of nullable reports', () => {
+    expect(StrategyRuntimeSnapshotSchema.safeParse({
+      currentState: 'TX6',
+      context: {
+        reportSent: null,
+      },
+    }).success).toBe(false);
+
+    expect(StrategyRuntimeSnapshotSchema.safeParse({
+      currentState: 'TX6',
+      context: {
+        reportSent: 0,
+        reportReceived: 0,
+      },
+    }).success).toBe(true);
+  });
+
+  it('accepts protocol-neutral history presentation, navigation and transmit gates', () => {
+    expect(StrategyRuntimeSnapshotSchema.safeParse({
+      currentState: 'idle',
+      actions: [{
+        id: 'open-settings',
+        label: 'openSettings',
+        navigation: { kind: 'plugin-page', pageId: 'settings' },
+      }],
+      messagePresentation: {
+        revision: 2,
+        mode: 'replace-logbook',
+        subject: 'sender-callsign',
+        partitionBy: 'band',
+        eligiblePartitions: ['20M'],
+        defaultClass: 'new',
+        classes: {
+          new: {
+            badges: [{ label: 'newCall', tone: 'secondary' }],
+            row: { tone: 'secondary', background: 'soft', accent: true },
+            emphasisWhen: [
+              { firstTokenIn: ['CQ'] },
+              { anyTokenIn: ['RR73', 'RRR', '73'] },
+            ],
+          },
+          worked: { textDecoration: 'line-through', opacity: 'muted' },
+        },
+        assignments: [{ subject: 'JA1AAA', partition: '20M', classId: 'worked' }],
+        noveltyRules: [{
+          fact: 'grid-field-2', knownValuesByPartition: { '20M': ['PM'] }, classId: 'new',
+        }],
+        tagRules: [{
+          id: 'cq', match: { firstTokenIn: ['CQ'] }, badge: { label: 'CQ', tone: 'primary' },
+        }],
+      },
+      transmitGate: { allowed: false, reason: 'confirmSettings', actionId: 'open-settings' },
+    }).success).toBe(true);
+  });
+});

package/src/schema/__tests__/operator.schema.test.ts

@@ -2,7 +2,8 @@ import { describe, expect, it } from 'vitest';
 import {
   CreateRadioOperatorRequestSchema,
   UpdateRadioOperatorRequestSchema,
-  sanitizeCallsignInput
+  sanitizeCallsignInput,
+  sanitizeGridInput,
 } from '../../index.js';
 import { MODES } from '../mode.schema.js';
 
@@ -11,19 +12,26 @@ describe('operator callsign normalization', () => {
     expect(sanitizeCallsignInput(' bg5abc/p ')).toBe('BG5ABC/P');
   });
 
-  it('normalizes callsigns in create and update payloads', () => {
+  it('uppercases grids and removes whitespace', () => {
+    expect(sanitizeGridInput(' ol 63aa ')).toBe('OL63AA');
+  });
+
+  it('normalizes callsigns and grids in create and update payloads', () => {
     const createPayload = CreateRadioOperatorRequestSchema.parse({
       myCallsign: 'bg5abc/p',
-      myGrid: 'OL63',
+      myGrid: 'ol63aa',
       frequency: 1000,
       transmitCycles: [0],
       mode: MODES.FT8,
     });
     const updatePayload = UpdateRadioOperatorRequestSchema.parse({
       myCallsign: 'vk9/bg3yza',
+      myGrid: 'pm01',
     });
 
     expect(createPayload.myCallsign).toBe('BG5ABC/P');
+    expect(createPayload.myGrid).toBe('OL63AA');
     expect(updatePayload.myCallsign).toBe('VK9/BG3YZA');
+    expect(updatePayload.myGrid).toBe('PM01');
   });
 });

package/src/schema/__tests__/plugin-market.schema.test.ts

@@ -1,16 +1,20 @@
 import { describe, expect, it } from 'vitest';
 import {
+  PluginArtifactManifestSchema,
   PluginMarketCatalogResponseSchema,
   PluginMarketCatalogSchema,
   PluginMarketChannelSchema,
+  PluginManifestSchema,
   PluginPermissionSchema,
+  PluginsConfigSchema,
   PluginSourceSchema,
+  PluginStatusSchema,
 } from '../../index.js';
 
 describe('plugin market schema', () => {
   it('accepts a valid stable catalog', () => {
     const catalog = PluginMarketCatalogSchema.parse({
-      schemaVersion: 1,
+      schemaVersion: 2,
       generatedAt: '2026-04-22T12:00:00.000Z',
       channel: 'stable',
       plugins: [
@@ -18,6 +22,8 @@ describe('plugin market schema', () => {
           name: 'heartbeat-demo',
           title: 'Heartbeat Demo',
           description: 'Example timer and quick-action plugin.',
+          readmeMarkdown: '# Heartbeat Demo\n\nExample timer and quick-action plugin.',
+          readmeSourceUrl: 'https://github.com/boybook/tx-5dr-plugins/blob/main/heartbeat-demo/README.md',
           locales: {
             en: {
               pluginName: 'Heartbeat Demo',
@@ -29,7 +35,8 @@ describe('plugin market schema', () => {
             },
           },
           latestVersion: '1.2.3',
-          minHostVersion: '1.0.0',
+          minPluginApiVersion: '1.2.0',
+          artifactManifestVersion: 1,
           author: 'TX-5DR',
           license: 'GPL-3.0-only',
           repository: 'https://github.com/boybook/tx-5dr-plugins',
@@ -53,16 +60,172 @@ describe('plugin market schema', () => {
 
     expect(catalog.channel).toBe('stable');
     expect(catalog.plugins[0]?.name).toBe('heartbeat-demo');
+    expect(catalog.plugins[0]?.readmeMarkdown).toContain('# Heartbeat Demo');
+    expect(catalog.plugins[0]?.readmeSourceUrl).toContain('/heartbeat-demo/README.md');
+    expect(catalog.plugins[0]?.minPluginApiVersion).toBe('1.2.0');
+  });
+
+  it('normalizes the catalog v1 minimum Host field as a Plugin API floor', () => {
+    const catalog = PluginMarketCatalogSchema.parse({
+      schemaVersion: 1,
+      generatedAt: '2026-04-22T12:00:00.000Z',
+      channel: 'nightly',
+      plugins: [{
+        name: 'legacy-plugin',
+        title: 'Legacy Plugin',
+        description: 'Legacy catalog entry.',
+        latestVersion: '1.0.0',
+        minHostVersion: '1.7.11',
+        artifactUrl: 'https://cdn.example.com/plugins/legacy-plugin-1.0.0.zip',
+        sha256: '0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef',
+        size: 123,
+        publishedAt: '2026-04-22T12:00:00.000Z',
+      }],
+    });
+
+    expect(catalog.plugins[0]?.minPluginApiVersion).toBe('1.7.11');
+    expect('minHostVersion' in catalog.plugins[0]!).toBe(false);
+  });
+
+  it('requires a static artifact manifest declaration in catalog v2', () => {
+    const result = PluginMarketCatalogSchema.safeParse({
+      schemaVersion: 2,
+      generatedAt: '2026-04-22T12:00:00.000Z',
+      channel: 'nightly',
+      plugins: [{
+        name: 'manifestless-plugin',
+        title: 'Manifestless Plugin',
+        description: 'Invalid v2 catalog entry.',
+        latestVersion: '1.0.0',
+        minPluginApiVersion: '2.1.0',
+        artifactUrl: 'https://cdn.example.com/plugins/manifestless-plugin-1.0.0.zip',
+        sha256: '0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef',
+        size: 123,
+        publishedAt: '2026-04-22T12:00:00.000Z',
+      }],
+    });
+
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.error.issues).toContainEqual(expect.objectContaining({
+        path: ['plugins', 0, 'artifactManifestVersion'],
+      }));
+    }
+  });
+
+  it('keeps minHostVersion limited to catalog v1 compatibility', () => {
+    const result = PluginMarketCatalogSchema.safeParse({
+      schemaVersion: 2,
+      generatedAt: '2026-04-22T12:00:00.000Z',
+      channel: 'nightly',
+      plugins: [{
+        name: 'legacy-field-plugin',
+        title: 'Legacy Field Plugin',
+        description: 'Invalid v2 catalog entry.',
+        latestVersion: '1.0.0',
+        minHostVersion: '2.1.0',
+        artifactManifestVersion: 1,
+        artifactUrl: 'https://cdn.example.com/plugins/legacy-field-plugin-1.0.0.zip',
+        sha256: '0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef',
+        size: 123,
+        publishedAt: '2026-04-22T12:00:00.000Z',
+      }],
+    });
+
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.error.issues).toContainEqual(expect.objectContaining({
+        path: ['plugins', 0, 'minHostVersion'],
+      }));
+    }
   });
 
   it('rejects unsupported channels', () => {
     expect(() => PluginMarketChannelSchema.parse('beta')).toThrow();
   });
 
+  it('rejects a catalog with an invalid minimum Plugin API version', () => {
+    const result = PluginMarketCatalogSchema.safeParse({
+      schemaVersion: 1,
+      generatedAt: '2026-04-22T12:00:00.000Z',
+      channel: 'stable',
+      plugins: [{
+        name: 'heartbeat-demo',
+        title: 'Heartbeat Demo',
+        description: 'Example plugin.',
+        latestVersion: '1.2.3',
+        minPluginApiVersion: 'current',
+        artifactUrl: 'https://cdn.example.com/plugins/heartbeat-demo-1.2.3.zip',
+        sha256: '0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef',
+        size: 12345,
+        publishedAt: '2026-04-22T12:00:00.000Z',
+      }],
+    });
+
+    expect(result.success).toBe(false);
+  });
+
+  it('validates a static artifact manifest', () => {
+    expect(PluginArtifactManifestSchema.parse({
+      schemaVersion: 1,
+      name: 'heartbeat-demo',
+      version: '1.0.0',
+      minPluginApiVersion: '1.2.0',
+      type: 'utility',
+      permissions: [],
+    })).toMatchObject({
+      instanceScope: 'operator',
+      minPluginApiVersion: '1.2.0',
+    });
+  });
+
   it('accepts host settings permissions', () => {
+    expect(PluginPermissionSchema.parse('plugin:event-bus')).toBe('plugin:event-bus');
     expect(PluginPermissionSchema.parse('host:hamlib')).toBe('host:hamlib');
+    expect(PluginPermissionSchema.parse('operator:transmit-control')).toBe('operator:transmit-control');
+    expect(PluginPermissionSchema.parse('logbook:session')).toBe('logbook:session');
     expect(PluginPermissionSchema.parse('settings:ft8')).toBe('settings:ft8');
     expect(PluginPermissionSchema.parse('settings:ntp')).toBe('settings:ntp');
+    expect(() => PluginPermissionSchema.parse('operator:transmit')).toThrow();
+  });
+
+  it('accepts transmit-control permission and auto-call status in plugin snapshots', () => {
+    const manifest = PluginManifestSchema.parse({
+      name: 'autocall-demo',
+      version: '1.0.0',
+      type: 'utility',
+      permissions: ['operator:transmit-control'],
+    });
+    expect(manifest.permissions).toEqual(['operator:transmit-control']);
+
+    const status = PluginStatusSchema.parse({
+      name: 'autocall-demo',
+      version: '1.0.0',
+      type: 'utility',
+      isBuiltIn: false,
+      loaded: true,
+      enabled: true,
+      errorCount: 0,
+      permissions: ['operator:transmit-control'],
+      capabilities: ['auto_call_control'],
+      autoCallEnabledOperatorIds: ['operator-1'],
+      pausedOperatorIds: ['operator-2'],
+    });
+    expect(status.autoCallEnabledOperatorIds).toEqual(['operator-1']);
+    expect(status.pausedOperatorIds).toEqual(['operator-2']);
+    expect(status.capabilities).toContain('auto_call_control');
+  });
+
+  it('accepts persisted operator plugin pause state with defaults', () => {
+    const emptyConfig = PluginsConfigSchema.parse({});
+    expect(emptyConfig.operatorPluginPauses).toEqual({});
+
+    const config = PluginsConfigSchema.parse({
+      operatorPluginPauses: {
+        'operator-1': ['scheduled-cq-autocall'],
+      },
+    });
+    expect(config.operatorPluginPauses['operator-1']).toEqual(['scheduled-cq-autocall']);
   });
 
   it('accepts the route response envelope', () => {

package/src/schema/__tests__/qso.schema.test.ts

@@ -0,0 +1,91 @@
+import { describe, expect, it } from 'vitest';
+
+import {
+  CONTEST_QSO_ENVELOPE_MAX_BYTES,
+  ContestQsoEnvelopeSchema,
+  QSORecordSchema,
+  parseContestQsoEnvelope,
+  serializeContestQsoEnvelope,
+} from '../qso.schema.js';
+
+function envelope() {
+  return {
+    schemaVersion: 1 as const,
+    contestId: 'FT-CHALLENGE',
+    editionId: '2026-weekend-1',
+    rulesetVersion: '2026.1',
+    sent: { grid: 'PL05', snr: '-09' },
+    received: { grid: 'PM96', snr: '-12' },
+    annotations: { status: 'included', transmitter: 1, reviewed: false, note: '台北' },
+  };
+}
+
+describe('ContestQsoEnvelopeSchema', () => {
+  it('accepts shallow typed facts and round-trips Unicode through durable JSON', () => {
+    const parsed = ContestQsoEnvelopeSchema.parse(envelope());
+    const serialized = serializeContestQsoEnvelope(parsed);
+
+    expect(serialized).toContain('\\u53f0\\u5317');
+    expect(new TextEncoder().encode(serialized).byteLength).toBeLessThanOrEqual(
+      CONTEST_QSO_ENVELOPE_MAX_BYTES,
+    );
+    expect(parseContestQsoEnvelope(serialized)).toEqual(parsed);
+  });
+
+  it('rejects arbitrary nested values and unknown envelope fields', () => {
+    expect(ContestQsoEnvelopeSchema.safeParse({
+      ...envelope(),
+      annotations: { nested: { value: true } },
+    }).success).toBe(false);
+    expect(ContestQsoEnvelopeSchema.safeParse({
+      ...envelope(),
+      privateState: 'not part of the contract',
+    }).success).toBe(false);
+  });
+
+  it.each([Number.NaN, Number.POSITIVE_INFINITY, Number.NEGATIVE_INFINITY])(
+    'rejects non-finite annotation number %s',
+    (value) => {
+      expect(ContestQsoEnvelopeSchema.safeParse({
+        ...envelope(),
+        annotations: { distance: value },
+      }).success).toBe(false);
+    },
+  );
+
+  it('enforces the UTF-8 JSON byte limit', () => {
+    const result = ContestQsoEnvelopeSchema.safeParse({
+      ...envelope(),
+      received: { payload: '台'.repeat(Math.ceil(CONTEST_QSO_ENVELOPE_MAX_BYTES / 6)) },
+    });
+
+    expect(result.success).toBe(false);
+  });
+});
+
+describe('QSORecordSchema contest identity', () => {
+  const qso = {
+    id: 'qso-1',
+    callsign: 'N0CALL',
+    frequency: 14_074_000,
+    mode: 'FT8',
+    startTime: 1,
+    messageHistory: [],
+  };
+
+  it('accepts a matching standard and atomic contest identity', () => {
+    expect(QSORecordSchema.safeParse({
+      ...qso,
+      contestId: 'FT-CHALLENGE',
+      contestEntry: envelope(),
+    }).success).toBe(true);
+  });
+
+  it('rejects conflicting standard and atomic contest identities', () => {
+    expect(QSORecordSchema.safeParse({
+      ...qso,
+      contestId: 'WW-DIGI',
+      contestEntry: envelope(),
+    }).success).toBe(false);
+  });
+});

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

@@ -23,4 +23,21 @@ describe('radio power support', () => {
       }),
     ).not.toThrow();
   });
+
+  it('does not expose physical power controls for TCI radios', () => {
+    const decision = decidePowerSupport({
+      type: 'tci',
+      tci: {
+        host: '127.0.0.1', port: 40001, dialect: 'auto', autoDiscoverPorts: true,
+        receiver: 0, trx: 0, vfo: 0, audioEnabled: true, audioSampleRate: 12000,
+      },
+    });
+
+    expect(decision).toMatchObject({
+      canPowerOn: false,
+      canPowerOff: false,
+      supportedStates: [],
+      reason: 'model-unsupported',
+    });
+  });
 });

package/src/schema/__tests__/radio-profile.schema.test.ts

@@ -0,0 +1,44 @@
+import { describe, expect, it } from 'vitest';
+import {
+  CreateProfileRequestSchema,
+  RadioProfileSchema,
+  UpdateProfileRequestSchema,
+} from '../radio-profile.schema.js';
+
+const audio = {
+  inputDeviceName: 'Headset microphone',
+  inputRouteKey: 'android:wired-headset:input',
+  outputDeviceName: 'Headset headphones',
+  outputRouteKey: 'android:wired-headset:output',
+  inputSampleRate: 48000,
+  outputSampleRate: 48000,
+};
+
+describe('radio profile audio route identity', () => {
+  it('preserves stable route keys through create and update requests', () => {
+    expect(CreateProfileRequestSchema.parse({
+      name: 'Android 3.5 mm',
+      radio: { type: 'none' },
+      audio,
+    }).audio).toMatchObject(audio);
+
+    expect(UpdateProfileRequestSchema.parse({ audio }).audio).toMatchObject(audio);
+  });
+
+  it('loads stable route keys while accepting legacy name-only profiles', () => {
+    const baseProfile = {
+      id: 'profile-1',
+      name: 'Android 3.5 mm',
+      radio: { type: 'none' as const },
+      audioLockedToRadio: false,
+      createdAt: 1,
+      updatedAt: 2,
+    };
+
+    expect(RadioProfileSchema.parse({ ...baseProfile, audio }).audio).toMatchObject(audio);
+    expect(RadioProfileSchema.parse({
+      ...baseProfile,
+      audio: { inputDeviceName: 'Legacy USB Audio' },
+    }).audio).toEqual({ inputDeviceName: 'Legacy USB Audio' });
+  });
+});