@camstack/server 1.0.0 → 1.0.1

package/src/core/repl/repl-engine.service.ts

@@ -1,155 +0,0 @@
-import { ReplEngine } from '@camstack/core'
-import type { IReplContextProvider } from '@camstack/core'
-import { SystemMirror, type SystemMirrorApi, type DeviceProxy } from '@camstack/types'
-import { AddonRegistryService } from '../addon/addon-registry.service'
-import { EventBusService } from '../events/event-bus.service'
-import { LoggingService } from '../logging/logging.service'
-
-export class ReplEngineService extends ReplEngine {
-  /**
-   * Lazily-instantiated `SystemMirror` shared across REPL sessions.
-   * Holds a single warm-boot mirror that every `sm.getDeviceById(id)`
-   * lookup serves from. Init runs at first access (Promise cached so
-   * concurrent sessions don't double-fetch).
-   */
-  private static systemMirror: SystemMirror | null = null
-  private static systemMirrorInit: Promise<SystemMirror> | null = null
-
-  /**
-   * Build a `SystemMirrorApi` for in-process server use. The cap-method
-   * surface (deviceManager / deviceState queries) goes through the
-   * standard broker tRPC client — those resolve locally via
-   * `localProviderLink`. The `live.onEvent` channel is NOT a cap, so
-   * the broker can't route it; we synthesize the same shape over the
-   * local `EventBusService` so SystemMirror subscriptions work without
-   * crossing the network boundary or polling the broker for a
-   * non-existent `live` service.
-   */
-  private static buildInProcessApi(
-    addonRegistry: AddonRegistryService,
-    eventBus: EventBusService,
-  ): SystemMirrorApi {
-    const baseApi = addonRegistry.getBrokerApi() as unknown as SystemMirrorApi
-    return {
-      ...baseApi,
-      live: {
-        onEvent: {
-          subscribe: (input, opts) => {
-            const off = eventBus.subscribe({ category: input.category }, (evt) => {
-              try {
-                opts.onData({ data: evt.data })
-              } catch (err) {
-                opts.onError?.(err)
-              }
-            })
-            return { unsubscribe: off }
-          },
-        },
-      },
-    }
-  }
-
-  private static getOrInitSystemMirror(
-    addonRegistry: AddonRegistryService,
-    eventBus: EventBusService,
-  ): Promise<SystemMirror> {
-    if (this.systemMirror) return Promise.resolve(this.systemMirror)
-    if (!this.systemMirrorInit) {
-      const api = this.buildInProcessApi(addonRegistry, eventBus)
-      const sm = new SystemMirror(api)
-      this.systemMirrorInit = sm.init().then(() => {
-        this.systemMirror = sm
-        return sm
-      })
-    }
-    return this.systemMirrorInit
-  }
-
-  constructor(
-    addonRegistry: AddonRegistryService,
-    eventBus: EventBusService,
-    _loggingService: LoggingService,
-  ) {
-    const contextProvider: IReplContextProvider = {
-      async getSystemSandbox() {
-        const integrationRegistry = addonRegistry.getIntegrationRegistry()
-        const deviceRegistry = addonRegistry.getDeviceRegistry()
-        // Warm-boot the SystemMirror so `sm.getDeviceById(id)` is sync
-        // for the first user expression.
-        const sm = await ReplEngineService.getOrInitSystemMirror(addonRegistry, eventBus)
-        return {
-          // ── New canonical API ───────────────────────────────────────
-          /**
-           * SystemMirror — the cap-driven, reactive view of every
-           * device. Sync `getDeviceById(id)`, typed `state.<cap>.value`
-           * reads, full method dispatch, query helpers.
-           */
-          sm,
-          // ── Legacy (kept for backward-compat) ──────────────────────
-          addonRegistry,
-          eventBus,
-          integrationRegistry,
-          devices: () => deviceRegistry.getAll(),
-          integrations: async () => (await integrationRegistry?.listIntegrations()) ?? [],
-          addons: () => addonRegistry.listAddons(),
-          getDevice: (id: number) => deviceRegistry.getById(id),
-          getIntegration: async (id: string) =>
-            (await integrationRegistry?.getIntegration(id)) ?? null,
-          getSystemMirror: () => Promise.resolve(sm),
-        }
-      },
-      async getDeviceSandbox(deviceId: number) {
-        const deviceRegistry = addonRegistry.getDeviceRegistry()
-        const rawDevice = deviceRegistry.getById(deviceId)
-        const sm = await ReplEngineService.getOrInitSystemMirror(addonRegistry, eventBus)
-        // `device` is the typed DeviceProxy backed by the SystemMirror
-        // mirror — same shape as `sm.getDeviceById(deviceId)`. Sync
-        // state reads + cap-method dispatch via the wrapper chain.
-        const device: DeviceProxy | null = sm.getDeviceById(deviceId)
-        return {
-          /** SystemMirror — full cluster view. */
-          sm,
-          /**
-           * The current device as a DeviceProxy. Sync state reads
-           * (`device.state.battery.value`) + async cap methods
-           * (`await device.snapshot.getSnapshot({})`).
-           */
-          device,
-          /** Numeric device id (same as URL). */
-          deviceId,
-          /** Device metadata (name, addonId, type, online, …). */
-          info: sm.getDeviceInfo(deviceId),
-          /** Raw IDevice instance — escape hatch for legacy access.
-           *  Prefer `device` (DeviceProxy) for new code. */
-          rawDevice,
-        }
-      },
-      getProviderSandbox(addonId: string) {
-        const integrationRegistry = addonRegistry.getIntegrationRegistry()
-        const deviceRegistry = addonRegistry.getDeviceRegistry()
-        const devices = deviceRegistry.getAllForAddon(addonId)
-        return {
-          getIntegration: () =>
-            integrationRegistry?.getIntegration(addonId) ?? Promise.resolve(null),
-          devices,
-        }
-      },
-      getAddonSandbox(addonId: string) {
-        // REPL exposes addon metadata only — never the live in-process
-        // instance. Direct addon access only works for hub-local addons
-        // and breaks for remote-agent addons. To invoke addon behaviour
-        // from the REPL, use the cap router via tRPC instead.
-        const entry = addonRegistry.listAddons().find((e) => e.manifest.id === addonId)
-        return {
-          manifest: entry?.manifest,
-          declaration: entry?.declaration,
-          source: entry?.source,
-          installSource: entry?.installSource,
-          process: entry?.process,
-        }
-      },
-    }
-
-    super(contextProvider)
-  }
-}

package/src/core/storage/fs-storage-backend.spec.ts

@@ -1,70 +0,0 @@
-// server/backend/src/core/storage/fs-storage-backend.spec.ts
-import { describe, it, expect, beforeEach, afterEach } from 'vitest'
-import { mkdirSync, rmSync } from 'node:fs'
-import { join } from 'node:path'
-import { tmpdir } from 'node:os'
-import { FsStorageBackend } from './fs-storage-backend'
-
-describe('FsStorageBackend', () => {
-  let tempDir: string
-  let backend: FsStorageBackend
-
-  beforeEach(() => {
-    tempDir = join(tmpdir(), `fs-backend-test-${Date.now()}`)
-    mkdirSync(tempDir, { recursive: true })
-    backend = new FsStorageBackend(tempDir)
-  })
-
-  afterEach(() => {
-    rmSync(tempDir, { recursive: true, force: true })
-  })
-
-  it('type is local', () => {
-    expect(backend.type).toBe('local')
-  })
-
-  it('basePath is resolved to absolute', () => {
-    const relative = new FsStorageBackend('./relative/path')
-    expect(relative.basePath).toContain('/')
-    expect(relative.basePath).not.toContain('./')
-  })
-
-  it('resolve joins subpath', () => {
-    expect(backend.resolve('models/yolov8n.onnx')).toBe(join(tempDir, 'models/yolov8n.onnx'))
-  })
-
-  it('resolve returns absolute paths as-is', () => {
-    expect(backend.resolve('/absolute/path')).toBe('/absolute/path')
-  })
-
-  it('isAvailable returns true for existing writable dir', () => {
-    expect(backend.isAvailable()).toBe(true)
-  })
-
-  it('isAvailable returns false when no existing ancestor is writable', () => {
-    // Nothing under /nonexistent exists, so no writable ancestor →
-    // the backend cannot be created when needed.
-    const missing = new FsStorageBackend('/nonexistent/path/xyz')
-    expect(missing.isAvailable()).toBe(false)
-  })
-
-  it('isAvailable returns true for a not-yet-existing dir whose parent is writable', () => {
-    // Lazy creation: the backend reports itself as available when the
-    // nearest existing ancestor (tempDir) is writable, because we can
-    // `mkdir -p` the missing segments on first write.
-    const notYet = new FsStorageBackend(join(tempDir, 'sub', 'dir'))
-    expect(notYet.isAvailable()).toBe(true)
-  })
-
-  it('initialize is a no-op — directory is created lazily on first write', async () => {
-    const { existsSync } = await import('node:fs')
-    const newPath = join(tempDir, 'sub', 'dir')
-    const newBackend = new FsStorageBackend(newPath)
-    // The base dir doesn't exist yet, but the ancestor chain is
-    // writable — so the backend is available and initialize is a
-    // no-op (doesn't create the dir eagerly).
-    expect(newBackend.isAvailable()).toBe(true)
-    await newBackend.initialize()
-    expect(existsSync(newPath)).toBe(false)
-  })
-})

package/src/core/storage/fs-storage-backend.ts

@@ -1,3 +0,0 @@
-// Re-export from @camstack/core
-export { FsStorageBackend } from '@camstack/core'
-export type { IStorageBackend } from '@camstack/core'

package/src/core/storage/storage-location-manager.spec.ts

@@ -1,130 +0,0 @@
-// server/backend/src/core/storage/storage-location-manager.spec.ts
-import { describe, it, expect, beforeEach, afterEach } from 'vitest'
-import { existsSync, mkdirSync, rmSync } from 'node:fs'
-import { join } from 'node:path'
-import { tmpdir } from 'node:os'
-import { StorageLocationManager, type StorageLocationName } from './storage-location-manager'
-
-describe('StorageLocationManager', () => {
-  let tempDir: string
-  let manager: StorageLocationManager
-
-  beforeEach(() => {
-    tempDir = join(tmpdir(), `slm-test-${Date.now()}`)
-    mkdirSync(tempDir, { recursive: true })
-    manager = new StorageLocationManager(tempDir)
-  })
-
-  afterEach(() => {
-    rmSync(tempDir, { recursive: true, force: true })
-    rmSync('/tmp/camstack-cache', { recursive: true, force: true })
-  })
-
-  it('initializeDefaults registers all 6 location backends', async () => {
-    await manager.initializeDefaults()
-    const names = manager.getLocationNames()
-    expect(names).toHaveLength(6)
-    expect(names).toContain('data')
-    expect(names).toContain('media')
-    expect(names).toContain('recordings')
-    expect(names).toContain('models')
-    expect(names).toContain('cache')
-    expect(names).toContain('logs')
-  })
-
-  it('initializeDefaults does NOT create the location directories on disk (lazy)', async () => {
-    await manager.initializeDefaults()
-    // None of the 6 location paths should exist — directories are
-    // created on first write by the filesystem storage provider, not
-    // eagerly at boot. This is the anti-bloat invariant: a fresh
-    // installation should not materialise empty `recordings/`,
-    // `media/`, `logs/` folders just because StorageLocationManager
-    // was initialized.
-    expect(existsSync(join(tempDir, 'db'))).toBe(false)
-    expect(existsSync(join(tempDir, 'media'))).toBe(false)
-    expect(existsSync(join(tempDir, 'recordings'))).toBe(false)
-    expect(existsSync(join(tempDir, 'models'))).toBe(false)
-    expect(existsSync(join(tempDir, 'logs'))).toBe(false)
-  })
-
-  it('initializeDefaults reports all locations as available (parent dir writable)', async () => {
-    await manager.initializeDefaults()
-    const status = manager.getStatus()
-    // A backend is "available" as long as it can be created when
-    // needed (nearest existing ancestor is writable). Since `tempDir`
-    // exists and is writable, every location underneath it is
-    // available even though the location dir itself does not yet
-    // exist.
-    for (const entry of status) {
-      expect(entry.available).toBe(true)
-    }
-  })
-
-  it('getLocationNames returns all 6 location names', async () => {
-    await manager.initializeDefaults()
-    const names = manager.getLocationNames()
-    const expected: StorageLocationName[] = [
-      'data',
-      'media',
-      'recordings',
-      'models',
-      'cache',
-      'logs',
-    ]
-    expect(names.toSorted()).toEqual(expected.toSorted())
-  })
-
-  it('resolve joins subpath correctly within a location', async () => {
-    await manager.initializeDefaults()
-    const resolved = manager.resolve('data', 'camstack.db')
-    expect(resolved).toBe(join(tempDir, 'db', 'camstack.db'))
-  })
-
-  it('resolve for cache uses /tmp/camstack-cache base', async () => {
-    await manager.initializeDefaults()
-    const resolved = manager.resolve('cache', 'thumbnails')
-    expect(resolved).toBe('/tmp/camstack-cache/thumbnails')
-  })
-
-  it('setLocationPath overrides a location with absolute path', async () => {
-    await manager.initializeDefaults()
-    const newPath = join(tempDir, 'custom-media')
-    await manager.setLocationPath('media', newPath)
-    const backend = manager.getBackend('media')
-    expect(backend.basePath).toBe(newPath)
-    // Still lazy — overriding the path doesn't eagerly create it.
-    expect(backend.isAvailable()).toBe(true)
-    expect(existsSync(newPath)).toBe(false)
-  })
-
-  it('setLocationPath overrides a location with relative path (resolved against dataPath)', async () => {
-    await manager.initializeDefaults()
-    await manager.setLocationPath('logs', 'custom-logs')
-    const backend = manager.getBackend('logs')
-    expect(backend.basePath).toBe(join(tempDir, 'custom-logs'))
-    expect(backend.isAvailable()).toBe(true)
-  })
-
-  it('getStatus reports all locations with name, available, path', async () => {
-    await manager.initializeDefaults()
-    const status = manager.getStatus()
-    expect(status).toHaveLength(6)
-    for (const entry of status) {
-      expect(entry).toHaveProperty('name')
-      expect(entry).toHaveProperty('available')
-      expect(entry).toHaveProperty('path')
-      expect(typeof entry.available).toBe('boolean')
-    }
-  })
-
-  it('missing location throws error', () => {
-    // not initialized
-    expect(() => manager.getBackend('data')).toThrow('Storage location "data" not initialized')
-  })
-
-  it('resolve on uninitialized location throws error', () => {
-    expect(() => manager.resolve('media', 'file.mp4')).toThrow(
-      'Storage location "media" not initialized',
-    )
-  })
-})

package/src/core/storage/storage-location-manager.ts

@@ -1,3 +0,0 @@
-// Re-export from @camstack/core
-export { StorageLocationManager } from '@camstack/core'
-export type { StorageLocationName } from '@camstack/core'

package/src/core/storage/storage.service.spec.ts

@@ -1,73 +0,0 @@
-import { describe, it, expect, vi } from 'vitest'
-import { StorageService } from './storage.service'
-import type { ICoreStorageProvider as IStorageProvider, IStorageLocation } from '@camstack/core'
-
-const createMockProvider = (): IStorageProvider => {
-  const mockLocation: IStorageLocation = { structured: undefined, files: undefined }
-  return {
-    initialize: vi.fn(),
-    shutdown: vi.fn(),
-    getLocation: vi.fn().mockReturnValue(mockLocation),
-    export: vi.fn(),
-    import: vi.fn(),
-  }
-}
-
-describe('StorageService', () => {
-  const createService = (): StorageService => {
-    return new StorageService()
-  }
-
-  it('delegates getLocation to active provider', () => {
-    const service = createService()
-    const provider = createMockProvider()
-    // eslint-disable-next-line @typescript-eslint/no-deprecated
-    service.setProvider(provider)
-
-    const result = service.getLocation('data')
-
-    expect(provider.getLocation).toHaveBeenCalledWith('data')
-    expect(result).toBeDefined()
-  })
-
-  it('maps legacy location names to new names', () => {
-    const service = createService()
-    const provider = createMockProvider()
-    // eslint-disable-next-line @typescript-eslint/no-deprecated
-    service.setProvider(provider)
-
-    // Legacy 'config' and 'events' both map to 'data'.
-    // StorageManager.getLocation accepts `StorageLocationName | string`,
-    // so string literals flow through without casts.
-    service.getLocation('config')
-    expect(provider.getLocation).toHaveBeenCalledWith('data')
-
-    service.getLocation('events')
-    expect(provider.getLocation).toHaveBeenNthCalledWith(2, 'data')
-  })
-
-  it('throws if no provider set', () => {
-    const service = createService()
-
-    expect(() => service.getLocation('data')).toThrow('No storage provider configured')
-    expect(() => service.getProvider()).toThrow('No storage provider configured')
-  })
-
-  it('setProvider changes the active provider', () => {
-    const service = createService()
-    const provider1 = createMockProvider()
-    const provider2 = createMockProvider()
-
-    // eslint-disable-next-line @typescript-eslint/no-deprecated
-    service.setProvider(provider1)
-    expect(service.getProvider()).toBe(provider1)
-
-    // eslint-disable-next-line @typescript-eslint/no-deprecated
-    service.setProvider(provider2)
-    expect(service.getProvider()).toBe(provider2)
-
-    service.getLocation('data')
-    expect(provider2.getLocation).toHaveBeenCalledWith('data')
-    expect(provider1.getLocation).not.toHaveBeenCalled()
-  })
-})

package/src/core/storage/storage.service.ts

@@ -1,3 +0,0 @@
-import { StorageManager } from '@camstack/core'
-
-export class StorageService extends StorageManager {}

package/src/core/streaming/stream-probe.service.ts

@@ -1,221 +0,0 @@
-import { execFile } from 'child_process'
-import { promisify } from 'util'
-
-import { LoggingService } from '../logging/logging.service'
-import type { StreamMetadata, StreamAudioMetadata } from '@camstack/types'
-import type { IScopedLogger } from '@camstack/types'
-import { errMsg } from '@camstack/types'
-
-const execFileAsync = promisify(execFile)
-
-const CACHE_TTL_MS = 3_600_000 // 1 hour
-const PROBE_TIMEOUT_MS = 5_000
-
-/** Codec aliases normalised to canonical names. */
-const CODEC_ALIASES: Readonly<Record<string, string>> = {
-  hevc: 'h265',
-}
-
-interface CacheEntry {
-  readonly metadata: StreamMetadata
-  readonly timestamp: number
-}
-
-export class StreamProbeService {
-  private readonly logger: IScopedLogger
-  private readonly cache = new Map<string, CacheEntry>()
-
-  constructor(loggingService: LoggingService) {
-    this.logger = loggingService.createLogger('StreamProbeService')
-  }
-
-  // ---------------------------------------------------------------------------
-  // Public API
-  // ---------------------------------------------------------------------------
-
-  /** Probe a stream URL and return its metadata (cached for 1 hour). */
-  async probe(url: string, options?: { force?: boolean }): Promise<StreamMetadata> {
-    const force = options?.force ?? false
-
-    if (!force) {
-      const cached = this.cache.get(url)
-      if (cached && Date.now() - cached.timestamp < CACHE_TTL_MS) {
-        return cached.metadata
-      }
-    }
-
-    const metadata = await this.runProbe(url)
-    this.cache.set(url, { metadata, timestamp: Date.now() })
-    return metadata
-  }
-
-  /**
-   * Generic field probe: given a field key and value, decides how to probe.
-   * Stream fields (stream_*) → ffprobe, other URLs → HTTP HEAD check.
-   */
-  async probeField(
-    key: string,
-    value: unknown,
-  ): Promise<{ status: 'ok' | 'error'; labels?: string[]; error?: string }> {
-    const url = String(value ?? '').trim()
-    if (!url) {
-      return { status: 'error', error: 'No URL provided' }
-    }
-
-    // Stream fields: use ffprobe
-    if (key.startsWith('stream')) {
-      const meta = await this.probe(url, { force: true })
-      const labels: string[] = []
-      if (meta.width && meta.height) labels.push(`${meta.width}\u00d7${meta.height}`)
-      if (meta.codec) {
-        const codecDisplay: Record<string, string> = { h265: 'H.265', h264: 'H.264', hevc: 'H.265' }
-        labels.push(codecDisplay[meta.codec] ?? meta.codec.toUpperCase())
-      }
-      if (meta.fps) labels.push(`${Math.round(meta.fps)}fps`)
-      if (meta.audio?.codec) {
-        const audioCodec = meta.audio.codec.toUpperCase()
-        const audioBits: string[] = [audioCodec]
-        if (meta.audio.sampleRate) audioBits.push(`${Math.round(meta.audio.sampleRate / 1000)}kHz`)
-        if (meta.audio.channels === 1) audioBits.push('mono')
-        else if (meta.audio.channels === 2) audioBits.push('stereo')
-        else if (meta.audio.channels) audioBits.push(`${meta.audio.channels}ch`)
-        labels.push(`audio: ${audioBits.join(' ')}`)
-      }
-      if (labels.length === 0) {
-        return { status: 'error', error: 'No video streams found at URL' }
-      }
-      return { status: 'ok', labels }
-    }
-
-    // Other URL fields (snapshot, etc.): GET with early abort to check reachability + content-type
-    try {
-      const controller = new AbortController()
-      const timeout = AbortSignal.timeout(5000)
-      timeout.addEventListener('abort', () => controller.abort(timeout.reason))
-      const response = await fetch(url, { method: 'GET', signal: controller.signal })
-      if (!response.ok) {
-        controller.abort()
-        return { status: 'error', error: `HTTP ${response.status} ${response.statusText}` }
-      }
-      const contentType = response.headers.get('content-type') ?? ''
-      controller.abort() // Don't download the full body
-      const labels: string[] = ['Reachable']
-      if (contentType.startsWith('image/')) {
-        labels.push(contentType.replace('image/', '').toUpperCase())
-      }
-      return { status: 'ok', labels }
-    } catch (err) {
-      if (err instanceof Error && err.name === 'AbortError') {
-        // We aborted intentionally after reading headers — that's success
-        return { status: 'ok', labels: ['Reachable'] }
-      }
-      const msg = errMsg(err)
-      return { status: 'error', error: `Unreachable: ${msg}` }
-    }
-  }
-
-  /** Clear cached metadata for a single URL or all URLs. */
-  clearCache(url?: string): void {
-    if (url) {
-      this.cache.delete(url)
-    } else {
-      this.cache.clear()
-    }
-  }
-
-  // ---------------------------------------------------------------------------
-  // Internal
-  // ---------------------------------------------------------------------------
-
-  private async runProbe(url: string): Promise<StreamMetadata> {
-    try {
-      // Query first video + first audio stream in one ffprobe pass.
-      // `-show_streams` returns every stream in the container; we filter
-      // by codec_type when parsing. Fields cover both kinds.
-      const { stdout } = await execFileAsync(
-        'ffprobe',
-        [
-          '-v',
-          'error',
-          '-rtsp_transport',
-          'tcp',
-          '-timeout',
-          '5000000',
-          '-show_entries',
-          'stream=codec_type,codec_name,profile,width,height,r_frame_rate,bit_rate,sample_rate,channels',
-          '-of',
-          'json',
-          url,
-        ],
-        { timeout: PROBE_TIMEOUT_MS },
-      )
-
-      return this.parseOutput(stdout)
-    } catch (err) {
-      this.logger.error('ffprobe failed', { meta: { url, error: String(err) } })
-      return {}
-    }
-  }
-
-  private parseOutput(stdout: string): StreamMetadata {
-    const parsed: unknown = JSON.parse(stdout)
-    const streams = (parsed as { streams?: unknown[] }).streams
-    if (!Array.isArray(streams) || streams.length === 0) {
-      return {}
-    }
-
-    const meta: StreamMetadata = {}
-
-    for (const raw of streams) {
-      const stream = raw as Record<string, unknown>
-      const codecType = typeof stream.codec_type === 'string' ? stream.codec_type : undefined
-
-      if (codecType === 'video' && meta.codec === undefined) {
-        const rawCodec = typeof stream.codec_name === 'string' ? stream.codec_name : undefined
-        meta.codec = rawCodec ? (CODEC_ALIASES[rawCodec] ?? rawCodec) : undefined
-        if (typeof stream.width === 'number') meta.width = stream.width
-        if (typeof stream.height === 'number') meta.height = stream.height
-        const fps = this.parseFps(stream.r_frame_rate)
-        if (fps !== undefined) meta.fps = fps
-        const bitrateKbps = this.parseBitrateKbps(stream.bit_rate)
-        if (bitrateKbps !== undefined) meta.bitrateKbps = bitrateKbps
-      } else if (codecType === 'audio' && meta.audio === undefined) {
-        const audio: StreamAudioMetadata = {}
-        if (typeof stream.codec_name === 'string') audio.codec = stream.codec_name
-        if (typeof stream.profile === 'string') audio.profile = stream.profile
-        const sampleRate = this.parseIntField(stream.sample_rate)
-        if (sampleRate !== undefined) audio.sampleRate = sampleRate
-        if (typeof stream.channels === 'number') audio.channels = stream.channels
-        const audioBitrateKbps = this.parseBitrateKbps(stream.bit_rate)
-        if (audioBitrateKbps !== undefined) audio.bitrateKbps = audioBitrateKbps
-        meta.audio = audio
-      }
-    }
-
-    return meta
-  }
-
-  private parseIntField(value: unknown): number | undefined {
-    const n = typeof value === 'string' ? Number(value) : typeof value === 'number' ? value : NaN
-    if (!Number.isFinite(n) || n <= 0) return undefined
-    return Math.round(n)
-  }
-
-  /** Parse fractional frame rate string like "25/1" → 25. */
-  private parseFps(value: unknown): number | undefined {
-    if (typeof value !== 'string') return undefined
-    const parts = value.split('/')
-    if (parts.length !== 2) return undefined
-    const num = Number(parts[0])
-    const den = Number(parts[1])
-    if (!Number.isFinite(num) || !Number.isFinite(den) || den === 0) return undefined
-    return Math.round((num / den) * 100) / 100
-  }
-
-  /** Parse bit_rate string (bps) → kbps. */
-  private parseBitrateKbps(value: unknown): number | undefined {
-    const n = typeof value === 'string' ? Number(value) : typeof value === 'number' ? value : NaN
-    if (!Number.isFinite(n) || n <= 0) return undefined
-    return Math.round(n / 1000)
-  }
-}