ダウンロードエンジンアーキテクチャ

┌─────────────────────────────────────────────────┐
│                   ダウンロードエンジン              │
│                                                  │
│  ┌──────────┐  ┌──────────┐  ┌───────────────┐  │
│  │ セグメント │→│ セグメント │→│ ファイル書き込み  │  │
│  │ ダウンロー │  │ 処理      │  │               │  │
│  │ ドモジュール│  │ モジュール │  │ モジュール      │  │
│  │          │  │          │  │                │  │
│  │ · 並列   │  │ · 復号   │  │ · FSA ストリーム│  │
│  │ · リトライ│  │ · 連結   │  │ · StreamSaver  │  │
│  │ · 速度制限│  │ · リマックス│  │ · Blob 兜底    │  │
│  └──────────┘  └──────────┘  └───────────────┘  │
│                                                  │
│  ┌─────────────────────────────────────────────┐ │
│  │           メモリセキュリティマネージャー         │ │
│  │  · サイズ見積もり · 閾値チェック · 戦略選択     │ │
│  └─────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────┘

ユーザーがダウンロードをクリック
    │
    ▼
┌──────────────┐     ┌──────────────┐     ┌──────────────┐
│ 1. マニフェスト│ ──→ │ 2. セグメント │ ──→ │ 3. セグメント │
│ 解析          │     │ ダウンロード  │     │ 処理          │
│              │     │              │     │              │
│ · M3U8 を   │     │ · Worker Pool│     │ · AES 復号   │
│   ダウンロード│     │ · 並列制御   │     │ · TS 連結    │
│ · セグメント │     │ · 指数バックオフ│     │ · FFmpeg リマックス│
│   リストを解析│     │ · 進捗報告   │     │ · 音声/動画マージ│
│ · キーを抽出 │     │              │     │              │
│ · サイズを見積│     │              │     │              │
└──────────────┘     └──────────────┘     └──────┬───────┘
                                                  │
                                                  ▼
┌──────────────┐     ┌──────────────┐     ┌──────────────┐
│ 6. 完了通知   │ ←── │ 5. クリーン   │ ←── │ 4. ファイル   │
│              │     │ アップ        │     │ 書き込み      │
│ · デスクトップ│     │              │     │              │
│   通知       │     │ · メモリ解放 │     │ · FSA ストリーム│
│ · パスコピー │     │ · 一時ファイル│     │ · StreamSaver│
│ · キュー進行 │     │   削除       │     │ · Blob 兜底  │
│              │     │ · 状態リセット│     │              │
└──────────────┘     └──────────────┘     └──────────────┘

  [アイドル]
    │ ユーザーがダウンロードをトリガー
    ▼
  [初期化] ──── WASM の読み込み、API 利用可能性チェック、書き込み戦略の選択
    │
    ▼
  [マニフェスト解析] ── M3U8/MPD をダウンロードして解析し、セグメントリストとキーを抽出
    │
    ▼
  [セグメントダウンロード] ── Worker Pool で並列ダウンロード、リアルタイム進捗報告
    │
    ▼
  [セグメント処理] ── 復号 → 連結/リマックス → ディスクに書き込み
    │
    ├── 成功 → [クリーンアップ] → [完了] → [アイドル]
    │
    ├── キャンセル → [クリーンアップ] → [アイドル]
    │
    └── 失敗 → [クリーンアップ] → [エラー] → [アイドル]

const downloadSegmentsConcurrently = async (
  segments: SegmentInfo[],
  onSegmentDownloaded: (buffer: ArrayBuffer, index: number) => void
) => {
  const concurrency = Math.min(config.concurrency, 8)
  let nextIndex = 0

  const worker = async () => {
    while (nextIndex < segments.length) {
      const index = nextIndex++
      const buffer = await downloadWithRetry(segments[index]!)
      onSegmentDownloaded(buffer, index)
    }
  }

  const workers = Array.from(
    { length: Math.min(concurrency, segments.length) },
    () => worker()
  )
  await Promise.all(workers)
}

事前分割（非推奨）：
Worker 1: [セグメント 0-49]   ← これらのセグメントが大きい場合、Worker 1 がボトルネックに
Worker 2: [セグメント 50-99]  ← 早く完了してからアイドル待機する可能性あり

共有カウンタ（FlowPick 採用）：
Worker 1: セグメント 0 → セグメント 3 → セグメント 5 → ...
Worker 2: セグメント 1 → セグメント 4 → セグメント 7 → ...
Worker 3: セグメント 2 → セグメント 6 → セグメント 8 → ...

async function* segmentGenerator(
  segments: SegmentInfo[],
  signal?: AbortSignal
): AsyncGenerator<ArrayBuffer> {
  for (const segment of segments) {
    if (signal?.aborted) break
    const buffer = await downloadWithRetry(segment)
    yield buffer
  }
}

const downloadWithRetry = async (
  segment: SegmentInfo,
  maxRetries = 3
): Promise<ArrayBuffer> => {
  let lastError: unknown
  for (let attempt = 0; attempt < maxRetries; attempt++) {
    try {
      return await downloadAndDecryptSegment(segment)
    } catch (e) {
      lastError = e
      if (attempt < maxRetries - 1) {
        // 指数バックオフ：400ms, 800ms, 1600ms
        await new Promise(r => setTimeout(r, Math.pow(2, attempt) * 400))
      }
    }
  }
  throw lastError
}

class FetchError extends Error {
  constructor(
    message: string,
    public status: number,
    public url: string
  ) {
    super(message)
    this.name = 'FetchError'
  }
}

const decryptAES128 = async (
  encryptedData: ArrayBuffer,
  key: ArrayBuffer,
  iv?: Uint8Array
): Promise<ArrayBuffer> => {
  const keyBytes = await crypto.subtle.importKey(
    'raw', key,
    { name: 'AES-CBC' },
    false,
    ['decrypt']
  )

  const ivBuffer = iv ? new Uint8Array(iv) : new Uint8Array(16)

  const decrypted = await crypto.subtle.decrypt(
    { name: 'AES-CBC', iv: ivBuffer },
    keyBytes,
    encryptedData
  )

  return decrypted
}

// 疑似コード
const merged = new Uint8Array(totalSize)
let offset = 0
for (const segment of segments) {
  merged.set(new Uint8Array(segment), offset)
  offset += segment.byteLength
}

HLS ストリーム処理：
  セグメント 0 → セグメント 1 → セグメント 2 → ... → 連結 → 出力

DASH ストリーム処理（音声/動画分離）：
  初期化セグメント → 動画セグメント 0 → 動画セグメント 1 → ... ─┐
                                                    ├→ FFmpeg マージ → 出力
  初期化セグメント → 音声セグメント 0 → 音声セグメント 1 → ... ─┘

async function createFSAStream(
  filename: string,
  dirHandle?: FileSystemDirectoryHandle | null
): Promise<WritableStream<Uint8Array>> {
  let handle: FileSystemFileHandle

  if (dirHandle) {
    // 既にディレクトリ権限がある場合、直接ファイルを作成
    handle = await dirHandle.getFileHandle(filename, { create: true })
  } else {
    // ポップアップでユーザーに保存場所を選択させる
    handle = await window.showSaveFilePicker!({
      suggestedName: filename,
      types: [{
        description: 'Video',
        accept: { 'video/mp4': ['.mp4'] }
      }]
    })
  }

  const writable = await handle.createWritable()

  return new WritableStream<Uint8Array>({
    async write(chunk) { await writable.write(chunk) },
    async close() { await writable.close() },
    async abort(reason) { await writable.abort(reason) }
  }, {
    highWaterMark: 16 * 1024 * 1024 // 16MB バッファ
  })
}

async function createStreamSaverStream(
  filename: string,
  fileSize?: number
): Promise<WritableStream<Uint8Array>> {
  const ss = await getStreamSaver()
  const fileStream = ss.createWriteStream(filename, { size: fileSize })
  return fileStream
}

// 疑似コード
const blob = new Blob([mergedData], { type: 'video/mp4' })
const url = URL.createObjectURL(blob)
const a = document.createElement('a')
a.href = url
a.download = filename
a.click()
URL.revokeObjectURL(url)

async function estimateSegmentsSize(
  segments: ArrayBuffer[] | AsyncGenerator<ArrayBuffer>,
  totalCount: number
): Promise<{ estimatedSize: number; isEstimate: boolean }> {
  // サンプリング数：min(5, max(1, totalCount * 0.1))
  const sampleCount = Math.min(5, Math.max(1, Math.floor(totalCount * 0.1)))

  // 最初の数セグメントをダウンロードして平均サイズを計算
  let sampledTotal = 0
  for (let i = 0; i < sampleCount; i++) {
    sampledTotal += sampleSegment.byteLength
  }

  const avgSample = sampledTotal / sampleCount
  return {
    estimatedSize: Math.round(avgSample * totalCount),
    isEstimate: true
  }
}

見積もりサイズ < 800MB  → 任意の戦略を使用可能
見積もりサイズ 800MB-1.5GB → ストリーミング書き込み優先、Blob モードで警告表示
見積もりサイズ > 1.5GB → 強制的にストリーミング書き込み、Blob モード拒否

const MEMORY_CONFIG = {
  maxBlobSize: 1500 * 1024 * 1024,    // 1.5GB 硬制限
  warnBlobSize: 800 * 1024 * 1024,    // 800MB 警告閾値
}

const checkMemoryPressure = (): 'normal' | 'warning' | 'critical' => {
  // 現在割り当て済みのセグメントバッファ合計サイズを確認
  const allocatedMB = allocatedBuffers.reduce((sum, buf) => sum + buf.byteLength, 0) / 1048576

  if (allocatedMB > 1200) return 'critical'
  if (allocatedMB > 600) return 'warning'
  return 'normal'
}

interface DownloadProgress {
  percentage: number           // 完了パーセント (0-100)
  downloadedBytes: number      // ダウンロード済みバイト数
  totalBytes: number           // 推定総バイト数
  speed: number                // 現在の速度 (bytes/sec)
  eta: number                  // 推定残り時間 (秒)
  currentPhase: DownloadPhase  // 現在のフェーズ
}

type DownloadPhase =
  | 'parsing'      // マニフェスト解析中
  | 'downloading'  // セグメントダウンロード中
  | 'processing'   // セグメント処理（復号/マージ）中
  | 'writing'      // ファイル書き込み中
  | 'completed'    // 完了
  | 'error'        // エラー発生
  | 'cancelled'    // ユーザーによりキャンセル

全体パーセンテージ = (現在のフェーズ基本値 + フェーズ内進捗) / 総フェーズ重み

フェーズ重み：
- 解析：5% (0% ~ 5%)
- ダウンロード：80% (5% ~ 85%)
- 処理・書き込み：15% (85% ~ 100%)

const calculateSpeed = (
  downloadedBytes: number[],
  windowSize: number = 10
): number => {
  if (downloadedBytes.length < 2) return 0

  const recent = downloadedBytes.slice(-windowSize)
  const timeDiff = (recent.length - 1) * intervalMs
  const bytesDiff = recent[recent.length - 1] - recent[0]

  return bytesDiff / timeDiff
}

const calculateETA = (
  remainingBytes: number,
  speed: number
): number => {
  if (speed <= 0) return Infinity
  return remainingBytes / speed
}

enum ErrorLevel {
  Warning = 'warning',    // 回復可能、継続可能
  Error = 'error',        // 回復不能、再試行可能
  Fatal = 'fatal'         // 致命的、即座に停止
}

低層（Worker）
  ↓ FetchError / CryptoError
中層（セグメント処理）
  ↓ SegmentError / MergeError
高層（エンジンコーディネーター）
  ↓ DownloadError
UI 層
  ↓ ユーザーにフレンドリーなプロンプトを表示

enum LogLevel {
  Debug = 0,    // 開発者向け詳細情報
  Info = 1,     // 通常操作ログ
  Warn = 2,     // 注意が必要な状況
  Error = 3,    // エラー発生
  None = 4      // ログ無効
}

// コンソールで実行
localStorage.setItem('flowpick_debug', 'true')
ページをリロード

[FlowPick] [Engine] Initializing with strategy: fsa
[FlowPick] [Engine] Manifest parsed: 180 segments, estimated 450MB
[FlowPick] [Download] Starting worker pool with concurrency: 6
[FlowPick] [Download] Segment 42/180 downloaded (23%), speed: 2.5 MB/s
[FlowPick] [Merge] Using TSToMP4Muxer for streaming remux
[FlowPick] [Engine] Download completed: 450MB in 185s

const perfMarks = [
  'engine:init',
  'manifest:parse',
  'segments:download:start',
  'segments:download:end',
  'segments:process:start',
  'segments:process:end',
  'file:write:start',
  'file:write:end'
]