From 13cccf2a1c0f1198aca2dc81382b256a1782eeb5 Mon Sep 17 00:00:00 2001
From: bluebird42 <2034043+bluebird42@users.noreply.github.com>
Date: Sun, 1 Nov 2026 16:44:39 +0100
Subject: [PATCH 1/2] Add opt-in audio description for videos

Spaces can turn on audio description. New uploads then get, in English and
Dutch, a full-mix MP3 of the video's audio with spoken descriptions of what is
on screen, and a descriptions WebVTT. Descriptions play in the pauses of the
speech, or over it with the original audio ducked to 20%, and stay with the
scene they describe.

Five optional background flow steps detect scenes, describe the video with
labelled stills, translate, speak and mix. They skip themselves unless the run
asks for audio description, and publication never waits for them. The MP3 is
published as an HLS alternate audio rendition marked describes-video and listed
under a new audio_descriptions manifest key.

Hosts decide who may use it through the optional
UsageLimits.can_use_audio_description?/1 callback.
---
 CONTRIBUTING.md                               |   1 +
 README.md                                     |   4 +-
 docs/audio_description.md                     | 140 ++++++
 docs/flow_engine.md                           |   8 +
 lib/mave_core/assets.ex                       |  36 +-
 lib/mave_core/assets/audio_description.ex     |  48 ++
 lib/mave_core/assets/video.ex                 |   3 +-
 lib/mave_core/audio_description.ex            |  79 ++++
 lib/mave_core/audio_description/cues.ex       | 177 ++++++++
 .../audio_description/mistral_speech.ex       |  95 ++++
 lib/mave_core/audio_description/mix.ex        |  85 ++++
 lib/mave_core/audio_description/prompts.ex    | 165 +++++++
 lib/mave_core/audio_description/scaleway.ex   | 108 +++++
 lib/mave_core/audio_description/timeline.ex   | 360 +++++++++++++++
 lib/mave_core/audio_description/wav.ex        | 169 +++++++
 lib/mave_core/embeds.ex                       |  26 ++
 lib/mave_core/embeds/manifest_publisher.ex    |  49 +-
 lib/mave_core/flow.ex                         |  47 +-
 lib/mave_core/flow/presets.ex                 |  77 +++-
 lib/mave_core/flow/step_registry.ex           |  48 ++
 .../flow/steps/ai_describe_video_step.ex      | 241 ++++++++++
 .../flow/steps/ai_speak_descriptions_step.ex  |  84 ++++
 .../steps/ai_translate_descriptions_step.ex   |  57 +++
 .../flow/steps/audio_description_support.ex   | 169 +++++++
 .../flow/steps/media_build_hls_master_step.ex |  30 +-
 .../flow/steps/media_detect_scenes_step.ex    | 206 +++++++++
 .../steps/media_mix_audio_description_step.ex | 256 +++++++++++
 lib/mave_core/public_api.ex                   |  33 +-
 lib/mave_core/spaces.ex                       |  40 +-
 lib/mave_core/spaces/space.ex                 |   3 +-
 lib/mave_core/uploads.ex                      |   4 +-
 lib/mave_core/usage_limits.ex                 |  14 +-
 .../live/dashboard/settings/general_tab.ex    |  99 +++-
 .../videos/video_settings_component.ex        |  43 ++
 .../20261101120000_add_audio_descriptions.exs |  25 +
 .../audio_description_publication_test.exs    | 117 +++++
 .../audio_description/media_test.exs          | 177 ++++++++
 .../audio_description/timeline_test.exs       | 281 ++++++++++++
 test/mave_core/audio_description_test.exs     |  71 +++
 .../steps/audio_description_steps_test.exs    | 427 ++++++++++++++++++
 .../audio_description_setting_test.exs        |  80 ++++
 41 files changed, 4143 insertions(+), 39 deletions(-)
 create mode 100644 docs/audio_description.md
 create mode 100644 lib/mave_core/assets/audio_description.ex
 create mode 100644 lib/mave_core/audio_description.ex
 create mode 100644 lib/mave_core/audio_description/cues.ex
 create mode 100644 lib/mave_core/audio_description/mistral_speech.ex
 create mode 100644 lib/mave_core/audio_description/mix.ex
 create mode 100644 lib/mave_core/audio_description/prompts.ex
 create mode 100644 lib/mave_core/audio_description/scaleway.ex
 create mode 100644 lib/mave_core/audio_description/timeline.ex
 create mode 100644 lib/mave_core/audio_description/wav.ex
 create mode 100644 lib/mave_core/flow/steps/ai_describe_video_step.ex
 create mode 100644 lib/mave_core/flow/steps/ai_speak_descriptions_step.ex
 create mode 100644 lib/mave_core/flow/steps/ai_translate_descriptions_step.ex
 create mode 100644 lib/mave_core/flow/steps/audio_description_support.ex
 create mode 100644 lib/mave_core/flow/steps/media_detect_scenes_step.ex
 create mode 100644 lib/mave_core/flow/steps/media_mix_audio_description_step.ex
 create mode 100644 priv/repo/migrations/20261101120000_add_audio_descriptions.exs
 create mode 100644 test/mave_core/assets/audio_description_publication_test.exs
 create mode 100644 test/mave_core/audio_description/media_test.exs
 create mode 100644 test/mave_core/audio_description/timeline_test.exs
 create mode 100644 test/mave_core/audio_description_test.exs
 create mode 100644 test/mave_core/flow/steps/audio_description_steps_test.exs
 create mode 100644 test/mave_core_web/live/dashboard/settings/audio_description_setting_test.exs

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 11f6d26..1357ebb 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -191,6 +191,7 @@ published manifests/media and send playback events to Core.
 Technical reference, as needed:
 
 - [Flow engine](docs/flow_engine.md): templates, execution, retries and debugging.
+- [Audio description](docs/audio_description.md): steps, outputs, providers and host policy.
 - [Prepared analytics](docs/analytics_sessions.md): setup and data lifecycle.
 - [Webhook delivery](docs/webhook_delivery_outbox.md): signed lifecycle events.
 - [Encoding boosters](deploy/encoding-booster/README.md): optional remote compute;
diff --git a/README.md b/README.md
index 1329327..b67fc01 100644
--- a/README.md
+++ b/README.md
@@ -20,8 +20,8 @@ and publish videos — with your media in S3-compatible storage that you control
 
 - **Manage:** organize videos into folders, invite your team, and replace a
   video without changing its public embed.
-- **Publish:** resumable uploads, adaptive HLS, posters, subtitles, and
-  customizable player settings.
+- **Publish:** resumable uploads, adaptive HLS, posters, subtitles,
+  [audio description](docs/audio_description.md), and customizable player settings.
 - **Integrate:** embed with web components, iframe, React, or Vue; automate
   with the video API and signed webhooks.
 - **Understand:** see views, drop-off, and viewing sources in your dashboard,
diff --git a/docs/audio_description.md b/docs/audio_description.md
new file mode 100644
index 0000000..34ea2fc
--- /dev/null
+++ b/docs/audio_description.md
@@ -0,0 +1,140 @@
+# Audio description
+
+Audio description makes a video followable for blind and low-vision viewers: a
+voice describes what happens on screen. A space opts in under **Settings →
+Features → Audio description**. From then on, every new upload and reprocessing
+run of a video of at most 10 minutes gets, in English and Dutch:
+
+- `audio_description_<lang>.mp3`: a full mix of the video's own audio with the
+  spoken descriptions. It is also an HLS alternate audio rendition, so players
+  can switch to it.
+- `descriptions_<lang>.vtt`: a WebVTT with `Kind: descriptions`, containing exactly
+  the spoken descriptions, timed to when they are spoken.
+
+Existing videos only get audio descriptions when they are processed again.
+
+## How descriptions are placed
+
+- **English first.** The video is described in English from what is on screen.
+  Every other language is a translation of that English text, never a separate
+  description.
+- **In the pauses, otherwise ducked.** Where speech is, is measured with
+  speech-to-text (the `ai.transcribe_audio` segments, or a transcription made for
+  this purpose), never guessed by the description model. A description that fits a
+  pause near its moment (up to 1 s earlier or 2 s later) plays there and leaves the
+  original audio untouched. When none fits, it plays at its moment and the original
+  audio fades to 20% underneath it (0.3 s fades). Descriptions are not shortened to
+  make room.
+- **In sync with the picture.** Cuts are detected with FFmpeg `scdet` and grouped
+  into scenes of at least 3 s, so a fast montage is still described. A description
+  starts while its scene is on screen and at least half of it is spoken during the
+  scene; a pause after the cut never counts as room for it. One that can no longer
+  start in its scene, because earlier descriptions ran long, is left out.
+- **Labelled stills.** The image model gets one 360p still per ~3 s per shot
+  (at least one per cut), labelled `S<scene> at <time>`, in batches of 12, with the
+  scenes, speech and numbered pauses (each with a word budget) as context.
+
+## Flow steps
+
+The publishing presets (`publish_default`, `publish_local`, `publish_remote`,
+`publish_remote_local`) contain these optional background steps. Each one skips
+itself (`status: "skipped"`, `reason: "not_requested"`) unless the run input has
+`audio_description`, so other spaces pay nothing for them. Nothing in the publish
+path waits for them; when a mix step finishes, Core stores the result, rebuilds the
+HLS master playlist and republishes `manifest.json`.
+
+| Step | Type | Runs on | Does |
+| --- | --- | --- | --- |
+| `detect_scenes` | `media.detect_scenes` | FLAME (media pool) | Cuts, scenes and stills in one decode of the canonical source |
+| `describe_video` | `ai.describe_video` | inline | English cues |
+| `translate_descriptions_nl` | `ai.translate_descriptions` | inline | Dutch cues, same timings |
+| `speak_descriptions_<lang>` | `ai.speak_descriptions` | inline | Text-to-speech per cue; existing clips are reused on retry |
+| `mix_audio_description_<lang>` | `media.mix_audio_description` | FLAME (media pool) | Timeline, ducked mix, VTT and the HLS audio rendition |
+
+Run input:
+
+```json
+{"audio_description": {"languages": ["en", "nl"]}}
+```
+
+Uploads and the public `input_url` API add this when the space has the feature on
+and the host allows it at that moment (see below). English is always included.
+Videos longer than `MAVE_AUDIO_DESCRIPTION_MAX_SECONDS` (default `600`) are
+skipped with `reason: "video_too_long"`, `video_duration_seconds` and
+`max_duration_seconds`; videos without a video stream with `no_video`.
+
+Transient provider and storage errors (timeouts, 408/429/5xx) are retried with the
+flow engine's retry budget. Other failures make the step `unavailable`; they never
+block publication. Working objects (stills, cues, speech clips) are private and
+live under `<embed>/vN/audio_description/`.
+
+## Outputs
+
+Files sit next to the other media of the video version (`<embed>/vN/`):
+`audio_description_<lang>.mp3`, `audio_description_<lang>_hls/playlist.m3u8` and
+`descriptions_<lang>.vtt`. The `audio_descriptions` table holds one row per video
+version and language.
+
+The HLS master playlist lists each MP3 in the `audio` group:
+
+```text
+#EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="audio",NAME="Dutch (audio description)",LANGUAGE="nl",DEFAULT=NO,AUTOSELECT=YES,CHARACTERISTICS="public.accessibility.describes-video",CHANNELS="2",URI="audio_description_nl_hls/playlist.m3u8"
+```
+
+`manifest.json` has a separate key, so players that don't know it are unaffected
+(the existing `audio_tracks` and `subtitles` don't include audio descriptions):
+
+```json
+"audio_descriptions": [
+  {
+    "language": "nl",
+    "label": "Dutch (audio description)",
+    "audio": {"path": "https://…/audio_description_nl.mp3", "hls_playlist": "audio_description_nl_hls/playlist.m3u8", "file_size": 123456},
+    "vtt": {"path": "https://…/descriptions_nl.vtt", "file_size": 1234}
+  }
+]
+```
+
+The key is omitted when a video has none. The detailed video API payload has the
+same `audio_descriptions` list, and the dashboard video page links the MP3 and VTT
+files.
+
+## Who may use it
+
+`MaveCore.UsageLimits.can_use_audio_description?/1` is an optional host callback.
+Without a host policy every space may turn the feature on. A host can refuse with
+`{:error, reason}` and provide `restriction_copy(:audio_description, reason)`;
+the dashboard then shows the notice and keeps the toggle off. Turning the feature
+off is always allowed. The check is repeated for every new run, so a space that
+loses access stops getting audio descriptions without changing its setting.
+
+## Providers and configuration
+
+Everything runs on EU providers: Scaleway Generative APIs (nl-ams) and Mistral.
+Video stills, the speech timings and the description text are sent to them.
+
+| Variable | Default | Purpose |
+| --- | --- | --- |
+| `SCALEWAY_API_KEY` | — | Scaleway IAM application with only `GenerativeApisModelAccess` |
+| `MISTRAL_API_KEY` | — | Already used for transcription; also used for text-to-speech |
+| `MAVE_AUDIO_DESCRIPTION_MODEL` | `gemma-4-26b-a4b-it` | Describe and translate model |
+| `MAVE_AUDIO_DESCRIPTION_REASONING_EFFORT` | `none` | Scaleway `reasoning_effort`; with reasoning, Gemma runs out of tokens |
+| `MAVE_AUDIO_DESCRIPTION_TTS_MODEL` | `voxtral-mini-tts-2603` | Mistral text-to-speech model |
+| `MAVE_AUDIO_DESCRIPTION_VOICES` | `en:gb_jane_neutral,nl:nl_kore_neutral` | Voice per language |
+| `MAVE_AUDIO_DESCRIPTION_VOICE` | `gb_jane_neutral` | Voice for languages without one |
+| `MAVE_AUDIO_DESCRIPTION_MAX_SECONDS` | `600` | Longest video that gets descriptions |
+
+Every language needs a voice in that language: Voxtral keeps the accent of its
+voice prompt. Mistral has no Dutch preset, so `nl_kore_neutral` is a cloned voice
+that must exist in the Mistral account of `MISTRAL_API_KEY`. Create voices only
+from a speaker who consented or from a synthetic sample, never from customer
+videos.
+
+Tests replace the providers through application config:
+
+```elixir
+config :mave_core, :audio_description,
+  chat_provider: MyChatStub,     # chat_json(system, content, opts)
+  speech_provider: MySpeechStub, # speak(text, language) -> {:ok, wav_bytes}
+  max_seconds: 600
+```
diff --git a/docs/flow_engine.md b/docs/flow_engine.md
index f6a6bca..8d1b773 100644
--- a/docs/flow_engine.md
+++ b/docs/flow_engine.md
@@ -117,6 +117,14 @@ New runs select the current built-in preset version. Existing runs and pinned
 custom versions do not gain steps automatically; reprocess with an updated flow
 when peaks are needed for older media.
 
+## Audio description
+
+The publishing presets include optional background steps that generate an audio
+description (a full-mix MP3 and a descriptions VTT, in English and Dutch) for
+spaces that opted in. They skip themselves unless the run input has
+`audio_description`, and nothing in the publish path waits for them. See
+[audio description](audio_description.md).
+
 ## Execution and recovery
 
 By default:
diff --git a/lib/mave_core/assets.ex b/lib/mave_core/assets.ex
index 18f9843..8b4194b 100644
--- a/lib/mave_core/assets.ex
+++ b/lib/mave_core/assets.ex
@@ -5,7 +5,7 @@ defmodule MaveCore.Assets do
 
   import Ecto.Query, warn: false
 
-  alias MaveCore.Assets.{AudioTrack, Subtitle, Video}
+  alias MaveCore.Assets.{AudioDescription, AudioTrack, Subtitle, Video}
   alias MaveCore.Embeds
   alias MaveCore.Embeds.{Embed, ManifestPublisher, SettingsSerializer}
   alias MaveCore.EncodingBooster
@@ -13,6 +13,7 @@ defmodule MaveCore.Assets do
   alias MaveCore.Flow.Steps.{
     MediaBuildHlsMasterStep,
     MediaExtractFrameStep,
+    MediaMixAudioDescriptionStep,
     MediaPackageHlsAudioStep
   }
 
@@ -1036,6 +1037,12 @@ defmodule MaveCore.Assets do
               "status" => "ok",
               "audio_tracks" => audio_tracks
             }},
+           {"hls_audio_descriptions",
+            %{
+              "step_type" => "media.mix_audio_description",
+              "status" => "ok",
+              "audio_tracks" => hls_audio_descriptions(embed)
+            }},
            {"hls_subtitles",
             %{
               "step_type" => "subtitle.collect",
@@ -1223,6 +1230,33 @@ defmodule MaveCore.Assets do
     end)
   end
 
+  defp hls_audio_descriptions(%Embed{} = embed) do
+    embed.asset.current_video.id
+    |> list_audio_descriptions()
+    |> Enum.map(fn description ->
+      %{
+        "id" => "audio_description_#{description.language}",
+        "label" => MediaMixAudioDescriptionStep.label(description.language),
+        "language" => description.language,
+        "default" => false,
+        "hls_playlist" => AudioDescription.hls_playlist(description),
+        "hls_bandwidth" => @audio_hls_bandwidth,
+        "hls_channels" => @audio_hls_channels,
+        "characteristics" => MediaMixAudioDescriptionStep.characteristics()
+      }
+    end)
+  end
+
+  @doc "Audio descriptions of a video version, by language."
+  def list_audio_descriptions(video_id) when is_binary(video_id) do
+    AudioDescription
+    |> where([description], description.video_id == ^video_id)
+    |> order_by([description], asc: description.language)
+    |> Repo.all()
+  end
+
+  def list_audio_descriptions(_video_id), do: []
+
   defp hls_subtitles(%Embed{} = embed) do
     version = Embeds.current_video_version(embed)
 
diff --git a/lib/mave_core/assets/audio_description.ex b/lib/mave_core/assets/audio_description.ex
new file mode 100644
index 0000000..bba9667
--- /dev/null
+++ b/lib/mave_core/assets/audio_description.ex
@@ -0,0 +1,48 @@
+defmodule MaveCore.Assets.AudioDescription do
+  @moduledoc """
+  A generated audio-description track of a video in one language: a full-mix MP3
+  (the video's audio with spoken descriptions) and the matching descriptions VTT.
+  """
+  use MaveCore.Schema
+  import Ecto.Changeset
+
+  alias MaveCore.Assets.Video
+
+  schema "audio_descriptions" do
+    field :language, :string
+    field :audio_filename, :string
+    field :audio_file_size, :integer
+    field :vtt_filename, :string
+    field :vtt_file_size, :integer
+    field :cue_count, :integer
+    field :ducked_cue_count, :integer
+
+    belongs_to :video, Video
+
+    timestamps()
+  end
+
+  def changeset(audio_description, attrs) do
+    audio_description
+    |> cast(attrs, [
+      :video_id,
+      :language,
+      :audio_filename,
+      :audio_file_size,
+      :vtt_filename,
+      :vtt_file_size,
+      :cue_count,
+      :ducked_cue_count
+    ])
+    |> validate_required([:video_id, :language, :audio_filename, :vtt_filename])
+    |> foreign_key_constraint(:video_id)
+    |> unique_constraint([:video_id, :language])
+  end
+
+  @doc "HLS playlist of the audio track, relative to the video version's prefix."
+  def hls_playlist(%__MODULE__{audio_filename: filename}), do: hls_playlist(filename)
+
+  def hls_playlist(filename) when is_binary(filename) do
+    (filename |> Path.basename() |> Path.rootname()) <> "_hls/playlist.m3u8"
+  end
+end
diff --git a/lib/mave_core/assets/video.ex b/lib/mave_core/assets/video.ex
index a452159..d988c1c 100644
--- a/lib/mave_core/assets/video.ex
+++ b/lib/mave_core/assets/video.ex
@@ -3,7 +3,7 @@ defmodule MaveCore.Assets.Video do
   use MaveCore.Schema
   import Ecto.Changeset
 
-  alias MaveCore.Assets.{Asset, AudioTrack, Rendition, Subtitle}
+  alias MaveCore.Assets.{Asset, AudioDescription, AudioTrack, Rendition, Subtitle}
 
   schema "videos" do
     field :status, :string
@@ -19,6 +19,7 @@ defmodule MaveCore.Assets.Video do
     field :language, :string
 
     belongs_to :asset, Asset
+    has_many :audio_descriptions, AudioDescription
     has_many :audio_tracks, AudioTrack
     has_many :renditions, Rendition
     has_many :subtitles, Subtitle
diff --git a/lib/mave_core/audio_description.ex b/lib/mave_core/audio_description.ex
new file mode 100644
index 0000000..ba28ee1
--- /dev/null
+++ b/lib/mave_core/audio_description.ex
@@ -0,0 +1,79 @@
+defmodule MaveCore.AudioDescription do
+  @moduledoc """
+  Audio description: per video, a full-mix MP3 (the video's audio with spoken
+  descriptions of what is on screen) and a descriptions VTT, in English and Dutch.
+
+  English is always described first, from the picture; every other language is a
+  translation of that English text. See `docs/audio_description.md`.
+  """
+
+  alias MaveCore.Spaces
+  alias MaveCore.Spaces.Space
+
+  @source_language "en"
+  @languages ["en", "nl"]
+  @default_max_seconds 600
+
+  def source_language, do: @source_language
+  def languages, do: @languages
+
+  @doc """
+  The `audio_description` run input for a new flow run in `space`, or `nil` when
+  the space doesn't get audio descriptions.
+  """
+  def run_input(%Space{} = space) do
+    if Spaces.audio_description_active?(space),
+      do: %{"languages" => @languages},
+      else: nil
+  end
+
+  def run_input(_space), do: nil
+
+  @doc "Languages requested by a run, or `[]` when it has no audio description."
+  def requested_languages(%{"audio_description" => %{"languages" => languages}})
+      when is_list(languages) do
+    languages = Enum.filter(languages, &is_binary/1)
+    if languages == [], do: [], else: Enum.uniq([@source_language | languages])
+  end
+
+  def requested_languages(_run_input), do: []
+
+  def requested?(run_input), do: requested_languages(run_input) != []
+
+  @doc "Longest video that gets an audio description, in seconds."
+  def max_seconds do
+    case config(:max_seconds, System.get_env("MAVE_AUDIO_DESCRIPTION_MAX_SECONDS")) do
+      value when is_integer(value) and value > 0 ->
+        value
+
+      value when is_binary(value) ->
+        case Integer.parse(value) do
+          {seconds, ""} when seconds > 0 -> seconds
+          _ -> @default_max_seconds
+        end
+
+      _ ->
+        @default_max_seconds
+    end
+  end
+
+  @doc "Object key prefix of a video version (`<embed>/vN` or `<embed>`)."
+  def version_prefix(embed_hash, version) when is_integer(version) and version > 0,
+    do: "#{embed_hash}/v#{version}"
+
+  def version_prefix(embed_hash, _version), do: embed_hash
+
+  @doc "Private working objects (stills, cues, speech clips) of a video version."
+  def work_prefix(embed_hash, version),
+    do: "#{version_prefix(embed_hash, version)}/audio_description"
+
+  def audio_filename(language), do: "audio_description_#{language}.mp3"
+  def vtt_filename(language), do: "descriptions_#{language}.vtt"
+
+  @doc false
+  def config(key, default \\ nil) do
+    :mave_core
+    |> Application.get_env(:audio_description, [])
+    |> Keyword.get(key, default)
+  end
+end
diff --git a/lib/mave_core/audio_description/cues.ex b/lib/mave_core/audio_description/cues.ex
new file mode 100644
index 0000000..cf79e32
--- /dev/null
+++ b/lib/mave_core/audio_description/cues.ex
@@ -0,0 +1,177 @@
+defmodule MaveCore.AudioDescription.Cues do
+  @moduledoc """
+  Description cues: parsing model output, cleaning it up and writing the
+  descriptions WebVTT (`Kind: descriptions`).
+
+  A cue is `%{start: seconds, end: seconds, text: String.t()}`, optionally with
+  `scene: %{start, end}` (the scene it is tied to).
+  """
+
+  alias MaveCore.AudioDescription.Timeline
+
+  @min_cue_seconds 0.5
+
+  @doc """
+  Parse a timestamp into seconds. Accepts numbers and strings like `HH:MM:SS.mmm`,
+  `MM:SS`, `MM:SS.mmm` or `SS.mmm` (comma decimals allowed).
+  """
+  def parse_timestamp(value) when is_number(value) and value >= 0, do: value * 1.0
+
+  def parse_timestamp(value) when is_binary(value) do
+    value = value |> String.trim() |> String.replace(",", ".", global: false)
+
+    if Regex.match?(~r/^\d+(:\d+){0,2}(\.\d+)?$/, value) do
+      value
+      |> String.split(":")
+      |> Enum.reduce(0.0, fn part, acc -> acc * 60 + parse_number(part) end)
+    end
+  end
+
+  def parse_timestamp(_value), do: nil
+
+  defp parse_number(part) do
+    {number, ""} = Float.parse(part)
+    number
+  end
+
+  @doc "WebVTT timestamp `HH:MM:SS.mmm`."
+  def format_timestamp(seconds) do
+    total_ms = max(0, round(seconds * 1000))
+    ms = rem(total_ms, 1000)
+    total_s = div(total_ms, 1000)
+
+    :io_lib.format("~2..0B:~2..0B:~2..0B.~3..0B", [
+      div(total_s, 3600),
+      rem(div(total_s, 60), 60),
+      rem(total_s, 60),
+      ms
+    ])
+    |> IO.iodata_to_binary()
+  end
+
+  @doc "Rough time needed to speak a text aloud, in seconds."
+  def estimate_speech_seconds(text) do
+    words = text |> String.split(~r/\s+/, trim: true) |> length()
+    max(1.0, words / 2.5)
+  end
+
+  @doc """
+  Clean up cues: drop invalid ones, sort, merge cues that start at the same
+  moment, repair end times, remove overlaps and clamp to the video duration.
+  """
+  def normalize(cues, duration \\ nil) do
+    limit = if is_number(duration) and duration > 0, do: duration * 1.0
+
+    cues
+    |> Enum.flat_map(&parse_cue(&1, limit))
+    |> Enum.sort_by(&{&1.start, &1.end})
+    |> Enum.reduce([], fn cue, acc ->
+      case acc do
+        [prev | rest] when cue.start - prev.start < 0.05 ->
+          [%{prev | text: prev.text <> " " <> cue.text, end: max(prev.end, cue.end)} | rest]
+
+        _ ->
+          [cue | acc]
+      end
+    end)
+    |> Enum.reverse()
+    |> fix_ends(limit)
+    |> Enum.filter(&(&1.end > &1.start))
+  end
+
+  defp parse_cue(cue, limit) do
+    text = cue |> field(:text) |> clean_text()
+    start = cue |> field(:start) |> parse_timestamp()
+
+    if text == "" or is_nil(start) or (limit && start >= limit) do
+      []
+    else
+      stop = cue |> field(:end) |> parse_timestamp()
+
+      stop =
+        if is_nil(stop) or stop <= start, do: start + estimate_speech_seconds(text), else: stop
+
+      [%{start: start, end: stop, text: text} |> maybe_put_scene(field(cue, :scene))]
+    end
+  end
+
+  defp fix_ends(cues, limit) do
+    next_starts = cues |> Enum.drop(1) |> Enum.map(& &1.start) |> Kernel.++([nil])
+
+    cues
+    |> Enum.zip(next_starts)
+    |> Enum.map(fn {cue, next_start} ->
+      stop = if next_start && cue.end > next_start, do: next_start, else: cue.end
+      stop = if limit && stop > limit, do: limit, else: stop
+      stop = min_length_end(cue.start, stop, next_start || limit)
+
+      %{cue | start: Timeline.round3(cue.start), end: Timeline.round3(stop)}
+    end)
+  end
+
+  # Short cues are stretched to the minimum length, but never past the next cue or the end.
+  defp min_length_end(start, stop, _ceiling) when stop - start >= @min_cue_seconds, do: stop
+  defp min_length_end(start, _stop, nil), do: start + @min_cue_seconds
+  defp min_length_end(start, _stop, ceiling), do: min(start + @min_cue_seconds, ceiling)
+
+  defp maybe_put_scene(cue, %{start: start, end: stop}) when is_number(start) and is_number(stop),
+    do: Map.put(cue, :scene, %{start: start, end: stop})
+
+  defp maybe_put_scene(cue, %{"start" => start, "end" => stop}),
+    do: maybe_put_scene(cue, %{start: start, end: stop})
+
+  defp maybe_put_scene(cue, _scene), do: cue
+
+  defp clean_text(text) when is_binary(text),
+    do: text |> String.replace(~r/\s+/u, " ") |> String.trim()
+
+  defp clean_text(_text), do: ""
+
+  defp field(map, key) when is_map(map), do: Map.get(map, key, Map.get(map, Atom.to_string(key)))
+
+  @doc "The descriptions WebVTT for `cues` in `language`."
+  def to_vtt(cues, language) do
+    body =
+      cues
+      |> Enum.with_index(1)
+      |> Enum.map(fn {cue, i} ->
+        "#{i}\n#{format_timestamp(cue.start)} --> #{format_timestamp(cue.end)}\n#{escape(cue.text)}\n"
+      end)
+
+    Enum.join(["WEBVTT\nKind: descriptions\nLanguage: #{language}\n" | body], "\n")
+  end
+
+  defp escape(text) do
+    text
+    |> String.replace("&", "&amp;")
+    |> String.replace("<", "&lt;")
+    |> String.replace(">", "&gt;")
+  end
+
+  @doc "Cues as JSON-safe maps (string keys) for storage."
+  def to_json(cues) do
+    Enum.map(cues, fn cue ->
+      %{"start" => cue.start, "end" => cue.end, "text" => cue.text}
+      |> put_scene_json(cue[:scene])
+    end)
+  end
+
+  defp put_scene_json(map, %{start: start, end: stop}),
+    do: Map.put(map, "scene", %{"start" => start, "end" => stop})
+
+  defp put_scene_json(map, _scene), do: map
+
+  @doc "Cues read back from `to_json/1`."
+  def from_json(list) when is_list(list) do
+    Enum.flat_map(list, fn
+      %{"start" => start, "end" => stop, "text" => text} = cue
+      when is_number(start) and is_number(stop) and is_binary(text) ->
+        [%{start: start * 1.0, end: stop * 1.0, text: text} |> maybe_put_scene(cue["scene"])]
+
+      _ ->
+        []
+    end)
+  end
+
+  def from_json(_), do: []
+end
diff --git a/lib/mave_core/audio_description/mistral_speech.ex b/lib/mave_core/audio_description/mistral_speech.ex
new file mode 100644
index 0000000..8b24f9d
--- /dev/null
+++ b/lib/mave_core/audio_description/mistral_speech.ex
@@ -0,0 +1,95 @@
+defmodule MaveCore.AudioDescription.MistralSpeech do
+  @moduledoc """
+  Text-to-speech with Voxtral on the Mistral API.
+
+  Every language gets a voice in that language, because Voxtral keeps the accent
+  of its voice prompt. Voices come from `MAVE_AUDIO_DESCRIPTION_VOICES`
+  (`en:gb_jane_neutral,nl:nl_kore_neutral` by default); a language without one
+  falls back to `MAVE_AUDIO_DESCRIPTION_VOICE`. Never clone voices from customer
+  videos.
+  """
+
+  @endpoint "https://api.mistral.ai/v1/audio/speech"
+  @default_model "voxtral-mini-tts-2603"
+  @default_voices "en:gb_jane_neutral,nl:nl_kore_neutral"
+  @default_voice "gb_jane_neutral"
+  @pool_timeout_ms 30_000
+  @receive_timeout_ms 2 * 60 * 1000
+
+  @doc "Speaks `text` in `language` and returns WAV bytes."
+  def speak(text, language) when is_binary(text) and is_binary(language) do
+    with {:ok, api_key} <- fetch_api_key() do
+      body = %{
+        "model" => env("MAVE_AUDIO_DESCRIPTION_TTS_MODEL", @default_model),
+        "input" => text,
+        "voice_id" => voice(language),
+        "response_format" => "wav"
+      }
+
+      case Req.post(@endpoint,
+             json: body,
+             headers: [{"authorization", "Bearer #{api_key}"}, {"accept", "application/json"}],
+             finch: [pool_timeout: @pool_timeout_ms],
+             receive_timeout: @receive_timeout_ms,
+             retry: :transient,
+             max_retries: 3
+           ) do
+        {:ok, %{status: status, body: %{"audio_data" => audio}}}
+        when status in 200..299 and is_binary(audio) ->
+          decode_audio(audio)
+
+        {:ok, %{status: status}} when status in 200..299 ->
+          {:error, :empty_speech_audio}
+
+        {:ok, %{status: status, body: body}} ->
+          {:error, {:http_error, status, body |> inspect() |> String.slice(0, 600)}}
+
+        {:error, reason} ->
+          {:error, reason}
+      end
+    end
+  end
+
+  defp decode_audio(audio) do
+    case Base.decode64(audio, ignore: :whitespace) do
+      {:ok, bytes} -> {:ok, bytes}
+      :error -> {:error, :invalid_speech_audio}
+    end
+  end
+
+  @doc "The voice for `language`: its exact tag, then its base language, then the fallback."
+  def voice(language) do
+    voices = voices()
+    base = language |> String.split("-") |> hd()
+
+    Map.get(voices, language) || Map.get(voices, base) ||
+      env("MAVE_AUDIO_DESCRIPTION_VOICE", @default_voice)
+  end
+
+  defp voices do
+    "MAVE_AUDIO_DESCRIPTION_VOICES"
+    |> env(@default_voices)
+    |> String.split(",", trim: true)
+    |> Enum.flat_map(fn pair ->
+      case String.split(pair, ":", parts: 2) do
+        [lang, voice] when lang != "" and voice != "" -> [{String.trim(lang), String.trim(voice)}]
+        _ -> []
+      end
+    end)
+    |> Map.new()
+  end
+
+  defp fetch_api_key do
+    case System.get_env("MISTRAL_API_KEY") do
+      key when is_binary(key) and key != "" -> {:ok, key}
+      _ -> {:error, :mistral_api_key_missing}
+    end
+  end
+
+  defp env(name, default) do
+    case System.get_env(name) do
+      value when is_binary(value) and value != "" -> String.trim(value)
+      _ -> default
+    end
+  end
+end
diff --git a/lib/mave_core/audio_description/mix.ex b/lib/mave_core/audio_description/mix.ex
new file mode 100644
index 0000000..61503f7
--- /dev/null
+++ b/lib/mave_core/audio_description/mix.ex
@@ -0,0 +1,85 @@
+defmodule MaveCore.AudioDescription.Mix do
+  @moduledoc """
+  FFmpeg arguments that mix the video's own audio with the description track.
+
+  The original audio fades to `duck_volume` (20%) under every description that
+  plays over speech, with `fade` (0.3 s) ramps; descriptions in pauses leave it
+  untouched. The result is a 48 kHz stereo MP3 as long as the original audio.
+  """
+
+  alias MaveCore.AudioDescription.Wav
+
+  @duck_volume 0.2
+  @fade_seconds 0.3
+  @kbps 128
+  @normalize "aresample=48000,aformat=sample_fmts=fltp:channel_layouts=stereo"
+
+  def duck_volume, do: @duck_volume
+  def fade_seconds, do: @fade_seconds
+
+  @doc "Gain expression for ffmpeg's `volume` filter: 1, fading to `duck_volume` in each interval."
+  def duck_expression(ducks, duck_volume \\ @duck_volume, fade \\ @fade_seconds)
+  def duck_expression([], _duck_volume, _fade), do: "1"
+
+  def duck_expression(ducks, duck_volume, fade) do
+    f = fixed(max(fade, 0.01))
+
+    # Trapezoid per interval: 0 before start-fade, 1 from start to end, 0 after end+fade.
+    ramps =
+      Enum.map(ducks, fn %{start: start, end: stop} ->
+        "clip(min((t-#{fixed(start - max(fade, 0.01))})/#{f},(#{fixed(stop + max(fade, 0.01))}-t)/#{f}),0,1)"
+      end)
+
+    max = Enum.reduce(tl(ramps), hd(ramps), fn ramp, acc -> "max(#{acc},#{ramp})" end)
+    "1-#{fixed(1 - duck_volume)}*#{max}"
+  end
+
+  @doc """
+  Arguments for the mix. `original` is the video's audio (`nil` when the video
+  has none), `description` the raw s16le mono description track.
+  """
+  def ffmpeg_args(original, description, output, ducks, duration) do
+    description_input = [
+      "-f",
+      "s16le",
+      "-ar",
+      Integer.to_string(Wav.sample_rate()),
+      "-ac",
+      "1",
+      "-i",
+      description
+    ]
+
+    {inputs, filter} =
+      if original do
+        {["-i", original | description_input],
+         "[0:a]#{@normalize},volume='#{duck_expression(ducks)}':eval=frame[orig];" <>
+           "[1:a]#{@normalize}[desc];" <>
+           "[orig][desc]amix=inputs=2:duration=first:normalize=0,alimiter=limit=0.97[out]"}
+      else
+        # No original audio: the descriptions alone, padded to the video length.
+        {description_input, "[0:a]#{@normalize}#{pad(duration)}[out]"}
+      end
+
+    ["-y", "-v", "error"] ++
+      inputs ++
+      [
+        "-filter_complex",
+        filter,
+        "-map",
+        "[out]",
+        "-c:a",
+        "libmp3lame",
+        "-b:a",
+        "#{@kbps}k",
+        output
+      ]
+  end
+
+  defp pad(duration) when is_number(duration) and duration > 0,
+    do: ",apad=whole_dur=#{fixed(duration)}"
+
+  defp pad(_duration), do: ""
+
+  defp fixed(value), do: :erlang.float_to_binary(value * 1.0, decimals: 3)
+end
diff --git a/lib/mave_core/audio_description/prompts.ex b/lib/mave_core/audio_description/prompts.ex
new file mode 100644
index 0000000..30e9a17
--- /dev/null
+++ b/lib/mave_core/audio_description/prompts.ex
@@ -0,0 +1,165 @@
+defmodule MaveCore.AudioDescription.Prompts do
+  @moduledoc """
+  Instructions and response schemas for the description and translation models.
+  """
+
+  alias MaveCore.Languages
+
+  @cues_schema %{
+    "type" => "object",
+    "properties" => %{
+      "duration_seconds" => %{"type" => "number"},
+      "cues" => %{
+        "type" => "array",
+        "items" => %{
+          "type" => "object",
+          "properties" => %{
+            "shot" => %{
+              "type" => "integer",
+              "description" => "Number of the scene this describes (S3 -> 3)"
+            },
+            "pause" => %{
+              "type" => "integer",
+              "description" =>
+                "Number of the pause it is placed in (P2 -> 2), or -1 during speech"
+            },
+            "max_words" => %{
+              "type" => "integer",
+              "description" => "Word limit for text: the pause's max words, or 6 during speech"
+            },
+            "start" => %{"type" => "string", "description" => "HH:MM:SS.mmm"},
+            "end" => %{"type" => "string", "description" => "HH:MM:SS.mmm"},
+            "text" => %{"type" => "string"}
+          },
+          "required" => ["shot", "pause", "max_words", "start", "end", "text"]
+        }
+      }
+    },
+    "required" => ["duration_seconds", "cues"]
+  }
+
+  @translations_schema %{
+    "type" => "object",
+    "properties" => %{"translations" => %{"type" => "array", "items" => %{"type" => "string"}}},
+    "required" => ["translations"]
+  }
+
+  def cues_schema, do: @cues_schema
+  def translations_schema, do: @translations_schema
+
+  @doc "The describer's instructions, followed by the timing context (`Timeline.timing_prompt/4`)."
+  def describe_instruction(duration, timing) do
+    [
+      "You are a professional audio describer. You write the audio description track for a video,",
+      "so that blind and low-vision viewers can follow what happens on screen.",
+      "",
+      "Rules:",
+      "- Write every description in English, regardless of the language spoken in the video.",
+      "- Describe what is visible: actions, people (by appearance and role, use names only if shown on screen),",
+      "  setting, scene and location changes, facial expressions and on-screen text (read text out; keep brand names,",
+      "  logos and URLs exactly as written).",
+      "- Do not describe what can be heard (dialogue, narration, music) unless it is needed to understand the image.",
+      "- Present tense, objective, concise. No interpretation, no speculation, no 'we see' or 'the camera shows'.",
+      "",
+      "Sync with the picture (scenes come from cut detection, listed below):",
+      "- Every description is about one scene. Set `shot` to that scene's number (S3 -> 3). The description must",
+      "  start while that scene is on screen and be timed to the moment the thing it describes is visible.",
+      "  Never describe a scene after the video has cut away from it.",
+      "- A scene can contain several quick cuts. Then say in one description what the cuts show together, most",
+      "  important first (e.g. 'Terrace, garden pond, women with headphones.'), rather than only the first cut.",
+      "- Describe what is new or changed. Don't repeat what an earlier description already said; skip a moment",
+      "  when nothing new happens.",
+      "- At most one description per scene, plus one more for every further 6 seconds of a long scene. More",
+      "  descriptions don't fit between the speech and get dropped.",
+      "",
+      "Timing around the original speech (measured with speech recognition, listed below):",
+      "- Put descriptions inside a pause that overlaps their shot, so the original audio stays clear. Set `pause`",
+      "  to its number (P2 -> 2); the description must start and end inside that pause.",
+      "- First set `max_words`: the pause's 'max words', or at most 6 for a description during speech. Then",
+      "  write `text` with no more than `max_words` words. Short beats complete: 'Kitchen, dirty dishes.' is a",
+      "  good 3-word description. Never write two sentences for one cue.",
+      "- A long pause can hold several descriptions, each at the moment its event happens.",
+      "- Skip pauses with a budget under 2 words.",
+      "- When a shot has no usable pause but needs a description, place a short one during that shot's speech",
+      "  with `pause` = -1; the original audio is then lowered while it plays.",
+      "- Each cue lasts 1 to 8 seconds. Cues are chronological and never overlap each other.",
+      "- Timestamps are relative to the start of the video, formatted HH:MM:SS.mmm.",
+      duration_line(duration),
+      "- Also report the total video duration in seconds as duration_seconds.",
+      "",
+      timing
+    ]
+    |> Enum.reject(&(&1 == ""))
+    |> Enum.join("\n")
+  end
+
+  defp duration_line(duration) when is_number(duration) and duration > 0 do
+    "- The video is #{:erlang.float_to_binary(duration * 1.0, decimals: 3)} seconds long; no cue may end after that."
+  end
+
+  defp duration_line(_duration), do: ""
+
+  @doc "The closing text of a batch of labelled stills."
+  def stills_request(window, previous_texts) do
+    previous =
+      case previous_texts do
+        [] ->
+          nil
+
+        texts ->
+          "Already described just before this part (don't repeat):\n" <>
+            Enum.map_join(texts, "\n", &"- #{&1}")
+      end
+
+    [
+      "These are stills from #{seconds(window.start)}-#{seconds(window.end)} s of the video (at least one per camera",
+      "cut), labelled with their scene and time. Write the audio description cues for this part, in English.",
+      previous
+    ]
+    |> Enum.reject(&is_nil/1)
+    |> Enum.join("\n")
+  end
+
+  @doc "Translation instructions and the JSON input list for `cues`."
+  def translation_request(cues, language) do
+    name = "#{Languages.spoken_language(language) || language} (#{language})"
+
+    input =
+      cues
+      |> Enum.with_index()
+      |> Enum.map(fn {cue, i} ->
+        %{"i" => i, "seconds" => Float.round((cue.end - cue.start) * 1.0, 1), "text" => cue.text}
+      end)
+
+    instruction =
+      Enum.join(
+        [
+          "You translate an English audio description track for blind and low-vision viewers into #{name}.",
+          "Each item is spoken in a time slot of the video, so it must not run longer than its 'seconds'.",
+          "Rules:",
+          "- Translate every item; return exactly one translation per input item, in the same order, as `translations`.",
+          "- Keep the meaning, tone and present tense. Natural, idiomatic, concise spoken language.",
+          "- Each translation must be speakable within the item's 'seconds' at about 2.5 words per second;",
+          "  shorten the wording rather than exceed it.",
+          "- Keep brand names, logos and URLs exactly as written.",
+          "- Don't add information, notes, numbering or quotes."
+        ],
+        "\n"
+      )
+
+    {instruction, input}
+  end
+
+  @doc "Exactly one non-empty translation per cue, or an error."
+  def check_translations(results, count) when is_list(results) do
+    if length(results) == count and Enum.all?(results, &(is_binary(&1) and String.trim(&1) != "")) do
+      {:ok, Enum.map(results, &String.trim/1)}
+    else
+      {:error, {:translation_count_mismatch, length(results), count}}
+    end
+  end
+
+  def check_translations(_results, count), do: {:error, {:translation_count_mismatch, 0, count}}
+
+  defp seconds(value), do: :erlang.float_to_binary(value * 1.0, decimals: 2)
+end
diff --git a/lib/mave_core/audio_description/scaleway.ex b/lib/mave_core/audio_description/scaleway.ex
new file mode 100644
index 0000000..00bfb6b
--- /dev/null
+++ b/lib/mave_core/audio_description/scaleway.ex
@@ -0,0 +1,108 @@
+defmodule MaveCore.AudioDescription.Scaleway do
+  @moduledoc """
+  Chat completions with a JSON-schema answer on Scaleway Generative APIs (EU).
+
+  Describing uses an image model (Gemma 4) that gets labelled stills; it runs
+  with `reasoning_effort: "none"`, because with reasoning it runs out of tokens.
+  Requires `SCALEWAY_API_KEY` (an IAM application with only
+  `GenerativeApisModelAccess`).
+  """
+
+  @endpoint "https://api.scaleway.ai/v1/chat/completions"
+  @default_model "gemma-4-26b-a4b-it"
+  @pool_timeout_ms 30_000
+  @receive_timeout_ms 5 * 60 * 1000
+
+  @doc """
+  Sends `system` and the user `content` parts and decodes the JSON answer.
+
+  Options: `:schema` (required), `:max_tokens`, `:model`.
+  """
+  def chat_json(system, content, opts) when is_binary(system) and is_list(content) do
+    with {:ok, api_key} <- fetch_api_key() do
+      body =
+        %{
+          "model" => Keyword.get(opts, :model) || model(),
+          "max_tokens" => Keyword.get(opts, :max_tokens, 8_000),
+          "temperature" => 0.3,
+          "response_format" => %{
+            "type" => "json_schema",
+            "json_schema" => %{"name" => "result", "schema" => Keyword.fetch!(opts, :schema)}
+          },
+          "messages" => [
+            %{"role" => "system", "content" => system},
+            %{"role" => "user", "content" => content}
+          ]
+        }
+        |> maybe_put("reasoning_effort", reasoning_effort())
+
+      body
+      |> request(api_key)
+      |> decode_answer()
+    end
+  end
+
+  defp request(body, api_key) do
+    case Req.post(endpoint(),
+           json: body,
+           headers: [{"authorization", "Bearer #{api_key}"}, {"accept", "application/json"}],
+           finch: [pool_timeout: @pool_timeout_ms],
+           receive_timeout: @receive_timeout_ms,
+           retry: :transient,
+           max_retries: 3
+         ) do
+      {:ok, %{status: status, body: body}} when status in 200..299 -> {:ok, body}
+      {:ok, %{status: status, body: body}} -> {:error, {:http_error, status, truncate(body)}}
+      {:error, reason} -> {:error, reason}
+    end
+  end
+
+  defp decode_answer({:ok, %{"choices" => [%{"message" => %{"content" => content}} | _]}})
+       when is_binary(content) and content != "" do
+    content
+    |> String.trim()
+    |> String.replace(~r/^```(?:json)?\s*/i, "")
+    |> String.replace(~r/```\s*$/, "")
+    |> Jason.decode()
+    |> case do
+      {:ok, %{} = answer} -> {:ok, answer}
+      _ -> {:error, :invalid_model_json}
+    end
+  end
+
+  defp decode_answer({:ok, %{"choices" => [%{"finish_reason" => reason} | _]}}),
+    do: {:error, {:empty_model_answer, reason}}
+
+  defp decode_answer({:ok, _body}), do: {:error, :empty_model_answer}
+  defp decode_answer({:error, _reason} = error), do: error
+
+  defp fetch_api_key do
+    case System.get_env("SCALEWAY_API_KEY") do
+      key when is_binary(key) and key != "" -> {:ok, key}
+      _ -> {:error, :scaleway_api_key_missing}
+    end
+  end
+
+  defp model, do: env("MAVE_AUDIO_DESCRIPTION_MODEL", @default_model)
+  defp endpoint, do: env("MAVE_AUDIO_DESCRIPTION_ENDPOINT", @endpoint)
+
+  defp reasoning_effort do
+    case env("MAVE_AUDIO_DESCRIPTION_REASONING_EFFORT", "none") do
+      "" -> nil
+      value -> value
+    end
+  end
+
+  defp env(name, default) do
+    case System.get_env(name) do
+      value when is_binary(value) and value != "" -> String.trim(value)
+      _ -> default
+    end
+  end
+
+  defp maybe_put(map, _key, nil), do: map
+  defp maybe_put(map, key, value), do: Map.put(map, key, value)
+
+  defp truncate(body) when is_binary(body), do: String.slice(body, 0, 600)
+  defp truncate(body), do: body |> inspect() |> String.slice(0, 600)
+end
diff --git a/lib/mave_core/audio_description/timeline.ex b/lib/mave_core/audio_description/timeline.ex
new file mode 100644
index 0000000..8935c42
--- /dev/null
+++ b/lib/mave_core/audio_description/timeline.ex
@@ -0,0 +1,360 @@
+defmodule MaveCore.AudioDescription.Timeline do
+  @moduledoc """
+  Pure timing logic for audio descriptions: where speech is, which scenes the
+  video has, and where each spoken description goes.
+
+  Descriptions play in the pauses of the original speech. When one doesn't fit a
+  nearby pause it plays at its own moment and the original audio is ducked under
+  it. A description always stays with its scene: it starts while the scene is on
+  screen and at least half of it is spoken during the scene.
+
+  Intervals are maps `%{start: seconds, end: seconds}`. All results are rounded
+  to milliseconds.
+  """
+
+  # Words closer together than this belong to the same stretch of speech.
+  @merge_gap_seconds 0.5
+  # Margin kept around speech, so a description never clips a syllable.
+  @speech_pad_seconds 0.15
+  # How far a description may move away from its moment to fit in a pause.
+  @max_shift_later 2.0
+  @max_shift_earlier 1.0
+  # Silence between two consecutive descriptions.
+  @breath_seconds 0.15
+  # Shortest scene: quick cuts are grouped until a scene is at least this long.
+  @min_scene_seconds 3.0
+  @epsilon 1.0e-9
+
+  def min_scene_seconds, do: @min_scene_seconds
+
+  @doc "Padded, merged stretches of speech within `[0, duration]` from word or segment timings."
+  def speech_from_words(
+        words,
+        duration,
+        merge_gap \\ @merge_gap_seconds,
+        pad \\ @speech_pad_seconds
+      ) do
+    words
+    |> Enum.filter(&(&1.end > &1.start))
+    |> Enum.sort_by(& &1.start)
+    |> Enum.reduce([], fn word, acc ->
+      case acc do
+        [prev | rest] when word.start - prev.end <= merge_gap ->
+          [%{prev | end: max(prev.end, word.end)} | rest]
+
+        _ ->
+          [%{start: word.start, end: word.end} | acc]
+      end
+    end)
+    |> Enum.reverse()
+    |> Enum.reduce([], fn stretch, acc ->
+      start = max(0.0, stretch.start - pad)
+      stop = min(duration * 1.0, stretch.end + pad)
+
+      cond do
+        stop <= start -> acc
+        match?([prev | _] when start <= prev.end, acc) -> merge_into_head(acc, stop)
+        true -> [%{start: start, end: stop} | acc]
+      end
+    end)
+    |> Enum.reverse()
+    |> Enum.map(&round_interval/1)
+  end
+
+  defp merge_into_head([prev | rest], stop), do: [%{prev | end: max(prev.end, stop)} | rest]
+
+  @doc "The pauses between speech, within `[0, duration]`."
+  def free_gaps(speech, duration) do
+    duration = duration * 1.0
+
+    {gaps, cursor} =
+      Enum.reduce_while(speech, {[], 0.0}, fn stretch, {gaps, cursor} ->
+        gaps =
+          if stretch.start > cursor,
+            do: [%{start: cursor, end: min(stretch.start, duration)} | gaps],
+            else: gaps
+
+        cursor = max(cursor, stretch.end)
+        if cursor >= duration, do: {:halt, {gaps, cursor}}, else: {:cont, {gaps, cursor}}
+      end)
+
+    gaps = if cursor < duration, do: [%{start: cursor, end: duration} | gaps], else: gaps
+
+    gaps
+    |> Enum.reverse()
+    |> Enum.filter(&(&1.end - &1.start > 0.001))
+    |> Enum.map(&round_interval/1)
+  end
+
+  @doc "Shot intervals from cut times."
+  def shots_from_cuts(cuts, duration) do
+    inner = cuts |> Enum.filter(&(&1 > 0 and &1 < duration)) |> Enum.sort()
+
+    ([0.0 | inner] ++ [duration * 1.0])
+    |> Enum.chunk_every(2, 1, :discard)
+    |> Enum.filter(fn [a, b] -> b > a end)
+    |> Enum.map(fn [a, b] -> round_interval(%{start: a, end: b}) end)
+  end
+
+  @doc """
+  Group consecutive short shots into scenes of at least `min_seconds`, so a fast
+  montage gets described (what its cuts show together) instead of not at all. A
+  short remainder at the end joins the scene before it.
+  """
+  def scenes_from_shots(shots, min_seconds \\ @min_scene_seconds) do
+    {scenes, current} =
+      Enum.reduce(shots, {[], nil}, fn shot, {scenes, current} ->
+        current = if current, do: %{current | end: shot.end}, else: Map.take(shot, [:start, :end])
+
+        if current.end - current.start >= min_seconds,
+          do: {[current | scenes], nil},
+          else: {scenes, current}
+      end)
+
+    scenes =
+      case {current, scenes} do
+        {nil, _} -> scenes
+        {current, []} -> [current]
+        {current, [last | rest]} -> [%{last | end: current.end} | rest]
+      end
+
+    scenes |> Enum.reverse() |> Enum.map(&round_interval/1)
+  end
+
+  @doc "Words a description can have to be spoken within `seconds` (about 2.5 words per second)."
+  def word_budget(seconds), do: max(0, floor((seconds - 0.2) * 2.5))
+
+  @doc """
+  Scenes, speech and numbered pauses (with a word budget each) as context for the
+  description model. With a `window`, only what overlaps it is listed, keeping the
+  global numbers.
+  """
+  def timing_prompt(speech, scenes, duration, window \\ nil) do
+    gaps = free_gaps(speech, duration)
+    in_window? = fn i -> is_nil(window) or (i.start < window.end and i.end > window.start) end
+
+    scene_lines =
+      scenes
+      |> Enum.with_index()
+      |> Enum.filter(fn {scene, _} -> in_window?.(scene) end)
+      |> Enum.map(fn {scene, i} -> "S#{i}: #{format_interval(scene)}" end)
+
+    gap_lines =
+      gaps
+      |> Enum.with_index()
+      |> Enum.filter(fn {gap, _} -> in_window?.(gap) end)
+      |> Enum.map(fn {gap, i} ->
+        length = gap.end - gap.start
+
+        "P#{i}: #{format_interval(gap)} (#{format_decimal(length, 1)} s, max #{word_budget(length)} words)"
+      end)
+
+    speech_in_window = Enum.filter(speech, in_window?)
+
+    speech_line =
+      if speech_in_window == [],
+        do: "none",
+        else: Enum.map_join(speech_in_window, ", ", &format_interval/1)
+
+    Enum.join(
+      ["Scenes (index: seconds), from cut detection; quick cuts are grouped into one scene:"] ++
+        if(scenes == [], do: ["S0: the whole video"], else: scene_lines) ++
+        [
+          "Speech (seconds): #{speech_line}",
+          "Pauses without speech (index: seconds, length, max words):"
+        ] ++ if(gap_lines == [], do: ["none"], else: gap_lines),
+      "\n"
+    )
+  end
+
+  @doc """
+  Stills for image-only vision models: at least one per camera shot, and one per
+  `every` seconds in longer shots, spread inside the shot (never on the cut). Each
+  still carries the index of the scene it belongs to.
+  """
+  def plan_stills(scenes, duration, every \\ 3, cuts \\ nil) do
+    cuts = cuts || scenes
+    list = if cuts == [], do: [%{start: 0.0, end: duration * 1.0}], else: cuts
+
+    Enum.flat_map(list, &shot_stills(&1, scenes, every))
+  end
+
+  defp shot_stills(%{start: start, end: stop}, _scenes, _every) when stop <= start, do: []
+
+  defp shot_stills(shot, scenes, every) do
+    length = shot.end - shot.start
+    count = max(1, round(length / every))
+
+    for k <- 0..(count - 1) do
+      time = round3(shot.start + (k + 0.5) * length / count)
+      %{scene: scene_index(scenes, time), time: time}
+    end
+  end
+
+  defp scene_index(scenes, time) do
+    Enum.find_index(scenes, &(time >= &1.start and time < &1.end)) ||
+      max(0, length(scenes) - 1)
+  end
+
+  @doc "Stills in batches of at most `max` (the provider's image limit per prompt)."
+  def batch_stills(stills, max \\ 12), do: Enum.chunk_every(stills, max)
+
+  @doc """
+  Pin each cue to the scene it describes and, when the model chose one, the pause
+  it goes in. A pause that doesn't overlap the scene is ignored (the description
+  would be out of sync); `-1` means during speech.
+  """
+  def snap_cues(cues, gaps, scenes), do: Enum.map(cues, &snap_cue(&1, gaps, scenes))
+
+  defp snap_cue(cue, gaps, scenes) do
+    scene = cue_scene(cue, scenes)
+    {lo, hi} = cue_bounds(scene, indexed(gaps, cue[:pause]))
+    start = min_inf(max(cue.start, lo), max_inf(lo, sub_inf(hi, 0.3)))
+    stop = min_inf(hi, max(cue.end, start + 0.5))
+
+    %{start: round3(start), end: round3(max(stop, start + 0.1)), text: cue.text}
+    |> put_scene(scene)
+  end
+
+  defp cue_scene(cue, scenes) do
+    indexed(scenes, cue[:scene]) ||
+      Enum.find(scenes, &(cue.start >= &1.start and cue.start < &1.end))
+  end
+
+  defp indexed(list, index) when is_integer(index) and index >= 0, do: Enum.at(list, index)
+  defp indexed(_list, _index), do: nil
+
+  # Within the scene; within the chosen pause too when that pause overlaps the scene.
+  defp cue_bounds(nil, gap), do: narrow_to_gap({0.0, :infinity}, gap)
+  defp cue_bounds(scene, gap), do: narrow_to_gap({scene.start, scene.end}, gap)
+
+  defp narrow_to_gap({lo, hi}, %{start: gap_start, end: gap_end}) do
+    if lt?(gap_start, hi) and gap_end > lo,
+      do: {max(lo, gap_start), min_inf(hi, gap_end)},
+      else: {lo, hi}
+  end
+
+  defp narrow_to_gap(bounds, nil), do: bounds
+
+  @doc """
+  Place every spoken description. `lengths` are clip lengths in samples.
+
+  Returns `%{placements: [%{index, start, length}], cues: [...], ducks: [...],
+  skipped: [index], total_samples: n}`. `cues` are timed to when each description
+  is actually spoken; `ducks` are where the original audio is lowered.
+  """
+  def plan_timeline(cues, lengths, speech, duration, sample_rate) do
+    gaps = free_gaps(speech, duration)
+    duration = duration * 1.0
+
+    initial = %{cursor: 0.0, placements: [], cues: [], ducks: [], skipped: []}
+
+    state =
+      cues
+      |> Enum.with_index()
+      |> Enum.reduce(initial, fn {cue, index}, state ->
+        length = Enum.at(lengths, index) || 0
+
+        if length <= 0,
+          do: state,
+          else: place(cue, index, length, sample_rate, gaps, speech, duration, state)
+      end)
+
+    timed = Enum.reverse(state.cues)
+    last_end = if timed == [], do: 0.0, else: List.last(timed).end
+
+    %{
+      placements: Enum.reverse(state.placements),
+      cues: timed,
+      ducks: Enum.reverse(state.ducks),
+      skipped: Enum.reverse(state.skipped),
+      total_samples: round(max(duration, last_end) * sample_rate)
+    }
+  end
+
+  defp place(cue, index, length, sample_rate, gaps, speech, duration, state) do
+    seconds = length / sample_rate
+    scene = cue[:scene]
+    scene_start = if scene, do: scene.start, else: :neg_infinity
+    latest_start = if scene, do: scene.end - seconds / 2, else: :infinity
+
+    case pause_start(cue, seconds, gaps, state.cursor, scene_start, latest_start) do
+      nil -> place_over_speech(cue, index, length, seconds, sample_rate, speech, duration, state)
+      start -> put_placement(state, cue, index, length, start, seconds, sample_rate, false)
+    end
+  end
+
+  # 1. A pause near the cue, within its scene, that holds the whole clip.
+  defp pause_start(cue, seconds, gaps, cursor, scene_start, latest_start) do
+    gaps
+    |> Enum.flat_map(fn gap ->
+      lo = Enum.max([gap.start, cursor, cue.start - @max_shift_earlier, num(scene_start)])
+      hi = min_inf(min(gap.end - seconds, cue.start + @max_shift_later), latest_start)
+      if lo > hi + @epsilon, do: [], else: [min(max(cue.start, lo), hi)]
+    end)
+    |> Enum.min_by(&abs(&1 - cue.start), fn -> nil end)
+  end
+
+  # 2. Otherwise at its own moment in the scene (after the previous description), over the speech.
+  defp place_over_speech(cue, index, length, seconds, sample_rate, speech, duration, state) do
+    scene = cue[:scene]
+    latest_start = if scene, do: scene.end - seconds / 2, else: :infinity
+    start = Enum.max([cue.start, state.cursor, if(scene, do: scene.start, else: cue.start)])
+    start = if start + seconds > duration, do: max(state.cursor, duration - seconds), else: start
+
+    if gt_inf?(start, latest_start) or start + seconds > duration + 0.5 do
+      %{state | skipped: [index | state.skipped]}
+    else
+      ducked? = Enum.any?(speech, &(start < &1.end and &1.start < start + seconds))
+      put_placement(state, cue, index, length, start, seconds, sample_rate, ducked?)
+    end
+  end
+
+  defp put_placement(state, cue, index, length, start, seconds, sample_rate, ducked?) do
+    stop = start + seconds
+    timed = %{start: round3(start), end: round3(stop), text: cue.text} |> put_scene(cue[:scene])
+    duck = %{start: round3(start), end: round3(stop)}
+
+    %{
+      state
+      | cursor: stop + @breath_seconds,
+        placements: [
+          %{index: index, start: round(start * sample_rate), length: length} | state.placements
+        ],
+        cues: [timed | state.cues],
+        ducks: if(ducked?, do: [duck | state.ducks], else: state.ducks)
+    }
+  end
+
+  defp put_scene(cue, nil), do: cue
+  defp put_scene(cue, scene), do: Map.put(cue, :scene, Map.take(scene, [:start, :end]))
+
+  defp num(:neg_infinity), do: -1.0e18
+  defp num(value), do: value
+
+  defp min_inf(:infinity, b), do: b
+  defp min_inf(a, :infinity), do: a
+  defp min_inf(a, b), do: min(a, b)
+
+  defp max_inf(_a, :infinity), do: :infinity
+  defp max_inf(a, b), do: max(a, b)
+
+  defp sub_inf(:infinity, _b), do: :infinity
+  defp sub_inf(a, b), do: a - b
+
+  defp lt?(_a, :infinity), do: true
+  defp lt?(a, b), do: a < b
+
+  defp gt_inf?(_a, :infinity), do: false
+  defp gt_inf?(a, b), do: a > b + @epsilon
+
+  defp round_interval(%{start: start, end: stop}), do: %{start: round3(start), end: round3(stop)}
+
+  @doc false
+  def round3(value), do: Float.round(value * 1.0, 3)
+
+  defp format_interval(i), do: "#{format_decimal(i.start, 2)}-#{format_decimal(i.end, 2)}"
+
+  defp format_decimal(value, decimals),
+    do: :erlang.float_to_binary(value * 1.0, decimals: decimals)
+end
diff --git a/lib/mave_core/audio_description/wav.ex b/lib/mave_core/audio_description/wav.ex
new file mode 100644
index 0000000..f3bf5f2
--- /dev/null
+++ b/lib/mave_core/audio_description/wav.ex
@@ -0,0 +1,169 @@
+defmodule MaveCore.AudioDescription.Wav do
+  @moduledoc """
+  Speech clips from text-to-speech, normalized to mono signed 16-bit
+  little-endian PCM at `sample_rate/0` with leading and trailing silence trimmed.
+  """
+
+  import Bitwise
+
+  @sample_rate 24_000
+
+  def sample_rate, do: @sample_rate
+
+  @doc """
+  Decode RIFF/WAVE bytes (PCM 8/16/24/32-bit or 32-bit float, any channel count)
+  to `{samples, sample_rate}`, where `samples` is mono s16le. Bytes without a RIFF
+  header are taken as raw s16le mono at 24 kHz.
+  """
+  def decode(<<"RIFF", _size::little-32, "WAVE", chunks::binary>>) do
+    with {:ok, format, data} <- read_chunks(chunks, nil) do
+      {:ok, {downmix(data, format), format.sample_rate}}
+    end
+  end
+
+  def decode(bytes) when is_binary(bytes) do
+    even = byte_size(bytes) - rem(byte_size(bytes), 2)
+    {:ok, {binary_part(bytes, 0, even), @sample_rate}}
+  end
+
+  defp read_chunks(<<"fmt ", size::little-32, body::binary-size(size), rest::binary>>, _format) do
+    <<tag::little-16, channels::little-16, rate::little-32, _byte_rate::little-32,
+      _align::little-16, bits::little-16, extra::binary>> = body
+
+    tag =
+      case {tag, extra} do
+        {0xFFFE,
+         <<_cb::little-16, _valid::little-16, _mask::little-32, sub::little-16, _::binary>>} ->
+          sub
+
+        {tag, _} ->
+          tag
+      end
+
+    read_chunks(skip_pad(rest, size), %{
+      tag: tag,
+      channels: channels,
+      sample_rate: rate,
+      bits: bits
+    })
+  end
+
+  defp read_chunks(<<"data", size::little-32, rest::binary>>, %{} = format) do
+    # Streamed WAVs may carry 0 or 0xFFFFFFFF as size; use what is there.
+    size = if size in [0, 0xFFFFFFFF] or size > byte_size(rest), do: byte_size(rest), else: size
+    {:ok, format, binary_part(rest, 0, size)}
+  end
+
+  defp read_chunks(<<_id::binary-size(4), size::little-32, rest::binary>>, format)
+       when byte_size(rest) >= size do
+    read_chunks(skip_pad(binary_part(rest, size, byte_size(rest) - size), size), format)
+  end
+
+  defp read_chunks(_rest, _format), do: {:error, :invalid_wav}
+
+  defp skip_pad(<<_pad, rest::binary>>, size) when rem(size, 2) == 1, do: rest
+  defp skip_pad(rest, _size), do: rest
+
+  defp downmix(data, %{tag: tag, channels: channels, bits: bits}) do
+    bytes = div(bits, 8)
+    frame = bytes * channels
+
+    for <<frame_bytes::binary-size(^frame) <- data>>, into: <<>> do
+      sum =
+        for <<sample::binary-size(^bytes) <- frame_bytes>>, reduce: 0 do
+          acc -> acc + read_sample(sample, tag, bits)
+        end
+
+      <<clamp(round(sum / channels))::little-signed-16>>
+    end
+  end
+
+  defp read_sample(<<value::little-float-32>>, 3, 32), do: max(-1.0, min(1.0, value)) * 32_767
+  defp read_sample(<<value>>, _tag, 8), do: (value - 128) <<< 8
+  defp read_sample(<<value::little-signed-16>>, _tag, 16), do: value
+  defp read_sample(<<value::little-signed-24>>, _tag, 24), do: value >>> 8
+  defp read_sample(<<value::little-signed-32>>, _tag, 32), do: value >>> 16
+
+  @doc "Linear-interpolation resample of s16le mono samples."
+  def resample(samples, from_rate, to_rate \\ @sample_rate)
+  def resample(samples, rate, rate), do: samples
+
+  def resample(samples, from_rate, to_rate) do
+    input = for <<s::little-signed-16 <- samples>>, do: s
+    tuple = List.to_tuple(input)
+    count = tuple_size(tuple)
+    ratio = from_rate / to_rate
+    length = floor(count / ratio)
+
+    if length == 0 do
+      <<>>
+    else
+      for i <- 0..(length - 1), into: <<>> do
+        pos = i * ratio
+        i0 = floor(pos)
+        i1 = min(i0 + 1, count - 1)
+        t = pos - i0
+        <<round(elem(tuple, i0) * (1 - t) + elem(tuple, i1) * t)::little-signed-16>>
+      end
+    end
+  end
+
+  @doc "Trim leading and trailing near-silence, keeping a little padding."
+  def trim_silence(samples, sample_rate \\ @sample_rate, threshold \\ 400, pad_seconds \\ 0.05) do
+    count = div(byte_size(samples), 2)
+
+    case first_loud(samples, threshold) do
+      nil ->
+        <<>>
+
+      first ->
+        last = last_loud(samples, count, threshold)
+        pad = round(pad_seconds * sample_rate)
+        from = max(0, first - pad)
+        to = min(count, last + 1 + pad)
+        binary_part(samples, from * 2, (to - from) * 2)
+    end
+  end
+
+  defp first_loud(samples, threshold) do
+    Enum.find_value(0..(div(byte_size(samples), 2) - 1)//1, fn i ->
+      offset = i * 2
+      <<_::binary-size(^offset), s::little-signed-16, _::binary>> = samples
+      if abs(s) >= threshold, do: i
+    end)
+  end
+
+  defp last_loud(samples, count, threshold) do
+    Enum.find_value((count - 1)..0//-1, fn i ->
+      offset = i * 2
+      <<_::binary-size(^offset), s::little-signed-16, _::binary>> = samples
+      if abs(s) >= threshold, do: i
+    end)
+  end
+
+  @doc "Decode TTS output into a trimmed mono s16le clip at `sample_rate/0`."
+  def clip(bytes) do
+    with {:ok, {samples, rate}} <- decode(bytes) do
+      {:ok, samples |> resample(rate, @sample_rate) |> trim_silence(@sample_rate)}
+    end
+  end
+
+  @doc "Silence and clips laid out on one timeline, as s16le iodata."
+  def render(placements, total_samples, load_clip) do
+    {parts, position} =
+      Enum.reduce(placements, {[], 0}, fn %{index: index, start: start, length: length},
+                                          {parts, position} ->
+        clip = load_clip.(index)
+        clip = binary_part(clip, 0, min(byte_size(clip), length * 2))
+        silence = silence(max(0, start - position))
+        {[clip, silence | parts], max(position, start) + div(byte_size(clip), 2)}
+      end)
+
+    Enum.reverse([silence(max(0, total_samples - position)) | parts])
+  end
+
+  defp silence(0), do: <<>>
+  defp silence(samples), do: :binary.copy(<<0, 0>>, samples)
+
+  defp clamp(value), do: value |> max(-32_768) |> min(32_767)
+end
diff --git a/lib/mave_core/embeds.ex b/lib/mave_core/embeds.ex
index 18eda64..e27fea6 100644
--- a/lib/mave_core/embeds.ex
+++ b/lib/mave_core/embeds.ex
@@ -598,12 +598,38 @@ defmodule MaveCore.Embeds do
           audio_only?
         ),
       audio_tracks: audio_tracks,
+      audio_descriptions:
+        audio_descriptions_for(space, video_embed, current_video, current_version),
       subtitles: subtitles_for(space, video_embed, current_video, current_version),
       renditions: renditions_for(current_video, flow_run),
       flow: flow_summary_for(flow_run)
     }
   end
 
+  defp audio_descriptions_for(_space, _embed, nil, _version), do: []
+
+  defp audio_descriptions_for(%Space{} = space, %Embed{} = embed, %Video{id: video_id}, version) do
+    bucket = Storage.bucket_for_space(space.hash, space.region)
+
+    video_id
+    |> MaveCore.Assets.list_audio_descriptions()
+    |> Enum.map(fn description ->
+      serialized =
+        ManifestPublisher.serialize_audio_description(description, bucket, embed.hash, version)
+
+      %{
+        language: description.language,
+        label:
+          Languages.spoken_language(description.language) || String.upcase(description.language),
+        mp3_url: get_in(serialized, ["audio", "path"]),
+        vtt_url: get_in(serialized, ["vtt", "path"]),
+        cue_count: description.cue_count
+      }
+    end)
+  end
+
+  defp audio_descriptions_for(_space, _embed, _video, _version), do: []
+
   defp dashboard_payload_analytics(payload) do
     %{
       views: %{
diff --git a/lib/mave_core/embeds/manifest_publisher.ex b/lib/mave_core/embeds/manifest_publisher.ex
index c2aa4b4..824c255 100644
--- a/lib/mave_core/embeds/manifest_publisher.ex
+++ b/lib/mave_core/embeds/manifest_publisher.ex
@@ -3,9 +3,11 @@ defmodule MaveCore.Embeds.ManifestPublisher do
 
   import Ecto.Query
 
-  alias MaveCore.Assets.{AudioTrack, Video}
+  alias MaveCore.Assets
+  alias MaveCore.Assets.{AudioDescription, AudioTrack, Video}
   alias MaveCore.Embeds
   alias MaveCore.Embeds.{Embed, SettingsSerializer}
+  alias MaveCore.Flow.Steps.MediaMixAudioDescriptionStep
   alias MaveCore.Languages
   alias MaveCore.LegacyShortUUID
   alias MaveCore.Media.CdnCache
@@ -110,6 +112,7 @@ defmodule MaveCore.Embeds.ManifestPublisher do
           hls_ready?
         )
     }
+    |> maybe_put("audio_descriptions", manifest_audio_descriptions(embed, version))
   end
 
   defp manifest_waveform(opts, manifest, version) do
@@ -588,6 +591,50 @@ defmodule MaveCore.Embeds.ManifestPublisher do
     "#{embed_hash}/#{filename}"
   end
 
+  # Omitted when there are none, so manifests without audio description don't change.
+  defp manifest_audio_descriptions(%Embed{} = embed, version) do
+    case current_video(embed) do
+      %Video{id: video_id} ->
+        bucket = Storage.bucket_for_space(embed.space.hash, embed.space.region)
+
+        video_id
+        |> Assets.list_audio_descriptions()
+        |> Enum.map(&serialize_audio_description(&1, bucket, embed.hash, version))
+        |> case do
+          [] -> nil
+          descriptions -> descriptions
+        end
+
+      _ ->
+        nil
+    end
+  end
+
+  @doc false
+  def serialize_audio_description(%AudioDescription{} = description, bucket, embed_hash, version) do
+    %{
+      "language" => description.language,
+      "label" => MediaMixAudioDescriptionStep.label(description.language),
+      "audio" => %{
+        "path" =>
+          SettingsSerializer.storage_object_url(
+            bucket,
+            audio_track_key(embed_hash, version, description.audio_filename)
+          ),
+        "hls_playlist" => AudioDescription.hls_playlist(description),
+        "file_size" => description.audio_file_size
+      },
+      "vtt" => %{
+        "path" =>
+          SettingsSerializer.storage_object_url(
+            bucket,
+            audio_track_key(embed_hash, version, description.vtt_filename)
+          ),
+        "file_size" => description.vtt_file_size
+      }
+    }
+  end
+
   defp manifest_subtitles(%Embed{} = embed, version) do
     bucket = Storage.bucket_for_space(embed.space.hash, embed.space.region)
 
diff --git a/lib/mave_core/flow.ex b/lib/mave_core/flow.ex
index 8a0a266..7edde5f 100644
--- a/lib/mave_core/flow.ex
+++ b/lib/mave_core/flow.ex
@@ -7,7 +7,7 @@ defmodule MaveCore.Flow do
 
   alias Ecto.Adapters.SQL
   alias MaveCore.Assets
-  alias MaveCore.Assets.{Asset, AudioTrack, Rendition, Subtitle, Video}
+  alias MaveCore.Assets.{Asset, AudioDescription, AudioTrack, Rendition, Subtitle, Video}
   alias MaveCore.Embeds
   alias MaveCore.Embeds.{Embed, ManifestPublisher, PlayerPublisher}
   alias MaveCore.Embeds.Events, as: EmbedEvents
@@ -67,10 +67,12 @@ defmodule MaveCore.Flow do
   @failed_run_pending_step_error "not executed because flow run failed"
   @default_flame_pool MaveCore.Workers.FlameRunner
   @media_step_types ~w(
+    media.detect_scenes
     media.extract_frame
     media.generate_audio_peaks
     media.generate_segments
     media.generate_storyboard
+    media.mix_audio_description
     media.package_hls_audio
     media.package_hls_variant
     media.transcode_audio
@@ -4550,6 +4552,7 @@ defmodule MaveCore.Flow do
                 "media.generate_audio_peaks",
                 "ai.transcribe_audio",
                 "ai.translate_subtitles",
+                "media.mix_audio_description",
                 "manifest.build"
               ] do
     with %Run{input: %{"space_hash" => space_hash, "embed_hash" => embed_hash}} = run <-
@@ -4561,6 +4564,9 @@ defmodule MaveCore.Flow do
         "media.transcode_audio" ->
           sync_audio_tracks(video.id, step_runs)
 
+        "media.mix_audio_description" ->
+          sync_audio_descriptions(video.id, step_runs)
+
         subtitle_step when subtitle_step in ["ai.transcribe_audio", "ai.translate_subtitles"] ->
           sync_subtitles(video.id, step_runs)
 
@@ -4637,7 +4643,12 @@ defmodule MaveCore.Flow do
   end
 
   defp maybe_refresh_completed_hls_master(step_type, %Embed{} = embed)
-       when step_type in ["ai.transcribe_audio", "ai.translate_subtitles", "manifest.build"] do
+       when step_type in [
+              "ai.transcribe_audio",
+              "ai.translate_subtitles",
+              "media.mix_audio_description",
+              "manifest.build"
+            ] do
     Assets.refresh_hls_master_playlist(embed)
   end
 
@@ -4775,6 +4786,37 @@ defmodule MaveCore.Flow do
     end)
   end
 
+  # Upserts per language, so a run that skipped audio description (or one language of
+  # it) keeps the descriptions this video version already has.
+  defp sync_audio_descriptions(video_id, step_runs) when is_binary(video_id) do
+    Enum.each(step_runs, fn
+      %StepRun{
+        step_type: "media.mix_audio_description",
+        status: "succeeded",
+        output: %{"status" => "ok", "audio_description" => %{} = description}
+      } ->
+        %AudioDescription{}
+        |> AudioDescription.changeset(Map.put(description, "video_id", video_id))
+        |> Repo.insert!(
+          on_conflict:
+            {:replace,
+             [
+               :audio_filename,
+               :audio_file_size,
+               :vtt_filename,
+               :vtt_file_size,
+               :cue_count,
+               :ducked_cue_count,
+               :updated_at
+             ]},
+          conflict_target: [:video_id, :language]
+        )
+
+      _step_run ->
+        :ok
+    end)
+  end
+
   defp sync_subtitles(video_id, step_runs) when is_binary(video_id) do
     from(subtitle in Subtitle, where: subtitle.video_id == ^video_id)
     |> Repo.delete_all()
@@ -5166,6 +5208,7 @@ defmodule MaveCore.Flow do
     sync_video_renditions(video.id, step_runs)
     sync_audio_tracks(video.id, step_runs)
     sync_subtitles(video.id, step_runs)
+    sync_audio_descriptions(video.id, step_runs)
     maybe_apply_detected_audio_track_language(video.id, step_runs)
   end
 
diff --git a/lib/mave_core/flow/presets.ex b/lib/mave_core/flow/presets.ex
index c85bd1f..a50c976 100644
--- a/lib/mave_core/flow/presets.ex
+++ b/lib/mave_core/flow/presets.ex
@@ -3,6 +3,7 @@ defmodule MaveCore.Flow.Presets do
   Built-in flow templates used as migration starting points.
   """
 
+  alias MaveCore.AudioDescription
   alias MaveCore.Media.ProductionEncodingProfile
 
   @spec all() :: [map()]
@@ -31,7 +32,8 @@ defmodule MaveCore.Flow.Presets do
        "name" => "Publish Default",
        "description" =>
          "Encoder-compatible default publish flow with upload, transcode, manifest, and webhook steps.",
-       "definition" => publish_default_definition() |> with_audio_peaks()
+       "definition" =>
+         publish_default_definition() |> with_audio_peaks() |> with_audio_description()
      }
      |> maybe_override_preset("publish_default")}
   end
@@ -43,7 +45,8 @@ defmodule MaveCore.Flow.Presets do
        "name" => "Publish Local",
        "description" =>
          "Lighter local-development publish flow that skips heavy codec variants while still producing a manifest.",
-       "definition" => publish_local_definition() |> with_audio_peaks()
+       "definition" =>
+         publish_local_definition() |> with_audio_peaks() |> with_audio_description()
      }
      |> maybe_override_preset("publish_local")}
   end
@@ -83,7 +86,10 @@ defmodule MaveCore.Flow.Presets do
         step -> step
       end)
 
-    definition |> Map.put("steps", durable_steps) |> with_audio_peaks()
+    definition
+    |> Map.put("steps", durable_steps)
+    |> with_audio_peaks()
+    |> with_audio_description()
   end
 
   defp with_audio_peaks(definition) do
@@ -104,6 +110,71 @@ defmodule MaveCore.Flow.Presets do
     )
   end
 
+  # Audio description (English + translations). The steps skip themselves unless the
+  # run asks for it, and nothing waits for them: the mix steps republish the HLS master
+  # and manifest when they finish.
+  defp with_audio_description(definition) do
+    source = AudioDescription.source_language()
+    translations = AudioDescription.languages() -- [source]
+
+    steps =
+      [
+        background_step("detect_scenes", "media.detect_scenes", "Detect Scenes", ["inspect_media"]),
+        background_step(
+          "describe_video",
+          "ai.describe_video",
+          "Describe Video",
+          ["detect_scenes", "transcribe_audio", "transcode_audio"]
+        )
+      ] ++
+        Enum.map(translations, fn language ->
+          background_step(
+            "translate_descriptions_#{language}",
+            "ai.translate_descriptions",
+            "Translate Descriptions (#{language})",
+            ["describe_video"],
+            %{"language" => language, "source_step_id" => "describe_video"}
+          )
+        end) ++
+        Enum.flat_map([source | translations], &speak_and_mix_steps(&1, source))
+
+    Map.update!(definition, "steps", &(&1 ++ steps))
+  end
+
+  defp speak_and_mix_steps(language, source) do
+    cues_step =
+      if language == source, do: "describe_video", else: "translate_descriptions_#{language}"
+
+    [
+      background_step(
+        "speak_descriptions_#{language}",
+        "ai.speak_descriptions",
+        "Speak Descriptions (#{language})",
+        [cues_step],
+        %{"language" => language, "source_step_id" => cues_step}
+      ),
+      background_step(
+        "mix_audio_description_#{language}",
+        "media.mix_audio_description",
+        "Mix Audio Description (#{language})",
+        ["speak_descriptions_#{language}", "transcode_audio"],
+        %{"language" => language, "source_step_id" => "speak_descriptions_#{language}"}
+      )
+    ]
+  end
+
+  defp background_step(id, type, name, depends_on, params \\ nil) do
+    %{
+      "id" => id,
+      "type" => type,
+      "name" => name,
+      "depends_on" => depends_on,
+      "lane" => "background",
+      "required" => false
+    }
+    |> then(fn step -> if params, do: Map.put(step, "params", params), else: step end)
+  end
+
   defp maybe_override_preset(preset, slug) do
     case Application.get_env(:mave_core, :flow_preset_overrides, %{}) do
       overrides when is_map(overrides) ->
diff --git a/lib/mave_core/flow/step_registry.ex b/lib/mave_core/flow/step_registry.ex
index 8b60022..74a6beb 100644
--- a/lib/mave_core/flow/step_registry.ex
+++ b/lib/mave_core/flow/step_registry.ex
@@ -4,18 +4,23 @@ defmodule MaveCore.Flow.StepRegistry do
   """
 
   alias MaveCore.Flow.Steps.{
+    AiDescribeVideoStep,
+    AiSpeakDescriptionsStep,
     AiTranscribeAudioStep,
+    AiTranslateDescriptionsStep,
     AiTranslateSubtitlesStep,
     AssetUploadOriginalStep,
     CdnPurgeStep,
     EventNotifyWebhookStep,
     ManifestBuildStep,
     MediaBuildHlsMasterStep,
+    MediaDetectScenesStep,
     MediaExtractFrameStep,
     MediaGenerateAudioPeaksStep,
     MediaGenerateSegmentsStep,
     MediaGenerateStoryboardStep,
     MediaInspectStep,
+    MediaMixAudioDescriptionStep,
     MediaPackageHlsAudioStep,
     MediaPackageHlsVariantStep,
     MediaTranscodeAudioStep,
@@ -167,6 +172,49 @@ defmodule MaveCore.Flow.StepRegistry do
       options: [@strict_option],
       executor: :inline
     },
+    "media.detect_scenes" => %{
+      name: "Detect Scenes",
+      category: "media",
+      description:
+        "Detects camera cuts, groups them into scenes and extracts labelled stills for audio description.",
+      handler: MediaDetectScenesStep,
+      options: [@strict_option],
+      executor: :flame
+    },
+    "ai.describe_video" => %{
+      name: "Describe Video",
+      category: "ai",
+      description:
+        "Writes English audio description cues for the scenes, placed in the pauses of the speech.",
+      handler: AiDescribeVideoStep,
+      options: [@strict_option],
+      executor: :inline
+    },
+    "ai.translate_descriptions" => %{
+      name: "Translate Descriptions",
+      category: "ai",
+      description: "Translates the English audio description cues into another language.",
+      handler: AiTranslateDescriptionsStep,
+      options: [@strict_option],
+      executor: :inline
+    },
+    "ai.speak_descriptions" => %{
+      name: "Speak Descriptions",
+      category: "ai",
+      description: "Speaks the audio description cues of one language with text-to-speech.",
+      handler: AiSpeakDescriptionsStep,
+      options: [@strict_option],
+      executor: :inline
+    },
+    "media.mix_audio_description" => %{
+      name: "Mix Audio Description",
+      category: "media",
+      description:
+        "Mixes the spoken descriptions into the video's audio (ducked under speech) and writes the descriptions VTT.",
+      handler: MediaMixAudioDescriptionStep,
+      options: [@strict_option],
+      executor: :flame
+    },
     "subtitle.upload" => %{
       name: "Upload Subtitle",
       category: "subtitle",
diff --git a/lib/mave_core/flow/steps/ai_describe_video_step.ex b/lib/mave_core/flow/steps/ai_describe_video_step.ex
new file mode 100644
index 0000000..a2b686e
--- /dev/null
+++ b/lib/mave_core/flow/steps/ai_describe_video_step.ex
@@ -0,0 +1,241 @@
+defmodule MaveCore.Flow.Steps.AiDescribeVideoStep do
+  @moduledoc """
+  Writes the English audio description cues from the labelled stills of
+  `media.detect_scenes`, around the speech measured by speech-to-text.
+
+  Speech comes from the `ai.transcribe_audio` segments (never from the description
+  model); when that step has none, this step transcribes the audio itself. The
+  English cues are the only source for every other language.
+  """
+  @behaviour MaveCore.Flow.Step
+
+  alias MaveCore.AudioDescription
+  alias MaveCore.AudioDescription.{Cues, Prompts, Timeline}
+  alias MaveCore.Embeds.SettingsSerializer
+  alias MaveCore.Flow.Steps.AudioDescriptionSupport, as: AD
+
+  @step_type "ai.describe_video"
+  # Scaleway's vision models accept at most this many images per prompt.
+  @max_images 12
+
+  @impl true
+  def run(step, context) do
+    ctx = AD.run_context(step, context)
+
+    with :ok <- AD.check_requested(ctx),
+         {:ok, scenes_output} <- AD.check_dependency(ctx, AD.source_step_id(ctx, "detect_scenes")) do
+      describe(ctx, scenes_output)
+    else
+      {:skip, reason} -> {:ok, AD.skipped(@step_type, ctx, reason), []}
+    end
+  end
+
+  defp describe(ctx, scenes_output) do
+    with {:ok, document} <- AD.get_json(ctx, scenes_output["scenes_key"]),
+         duration = document["duration"] * 1.0,
+         {:ok, speech} <- speech(ctx, duration),
+         scenes = intervals(document["scenes"]),
+         {:ok, raw_cues} <- describe_batches(ctx, document["stills"], scenes, speech, duration),
+         cues = clean_cues(raw_cues, speech, scenes, duration),
+         :ok <- require_cues(cues),
+         language = AudioDescription.source_language(),
+         {:ok, cues_key} <-
+           AD.put_json(ctx, AD.work_key(ctx, "#{language}/cues.json"), Cues.to_json(cues)),
+         {:ok, speech_key} <-
+           AD.put_json(ctx, AD.work_key(ctx, "speech.json"), Enum.map(speech, &interval_json/1)),
+         {:ok, _} <- AD.put_json(ctx, AD.work_key(ctx, "raw-cues.json"), raw_cues) do
+      {:ok,
+       %{
+         "status" => "ok",
+         "step_type" => @step_type,
+         "step_id" => ctx.step_id,
+         "language" => language,
+         "cues_key" => cues_key,
+         "speech_key" => speech_key,
+         "duration" => duration,
+         "cue_count" => length(cues),
+         "scene_count" => length(scenes),
+         "speech_seconds" =>
+           speech |> Enum.map(&(&1.end - &1.start)) |> Enum.sum() |> Float.round(1)
+       }, []}
+    else
+      {:error, :no_descriptions} ->
+        {:ok, AD.skipped(@step_type, ctx, "no_descriptions"), []}
+
+      {:error, reason} ->
+        AD.failure(@step_type, ctx, reason)
+    end
+  end
+
+  defp describe_batches(ctx, stills, scenes, speech, duration) do
+    stills
+    |> Enum.map(&%{scene: &1["scene"], time: &1["time"] * 1.0, key: &1["key"]})
+    |> Timeline.batch_stills(@max_images)
+    |> Enum.reduce_while({:ok, []}, fn batch, {:ok, cues} ->
+      case describe_batch(ctx, batch, cues, scenes, speech, duration) do
+        {:ok, batch_cues} -> {:cont, {:ok, cues ++ batch_cues}}
+        {:error, reason} -> {:halt, {:error, reason}}
+      end
+    end)
+  end
+
+  defp describe_batch(ctx, batch, previous_cues, scenes, speech, duration) do
+    window = %{
+      start: scene_bound(scenes, hd(batch).scene, :start, 0.0),
+      end: scene_bound(scenes, List.last(batch).scene, :end, duration)
+    }
+
+    timing = Timeline.timing_prompt(speech, scenes, duration, window)
+    previous = previous_cues |> Enum.take(-3) |> Enum.map(&to_string(&1["text"]))
+
+    with {:ok, images} <- load_stills(ctx, batch) do
+      content =
+        images ++ [%{"type" => "text", "text" => Prompts.stills_request(window, previous)}]
+
+      case AD.chat_provider().chat_json(Prompts.describe_instruction(duration, timing), content,
+             schema: Prompts.cues_schema(),
+             max_tokens: 8_000
+           ) do
+        {:ok, %{"cues" => cues}} when is_list(cues) -> {:ok, Enum.filter(cues, &is_map/1)}
+        {:ok, _answer} -> {:ok, []}
+        {:error, reason} -> {:error, reason}
+      end
+    end
+  end
+
+  defp load_stills(ctx, batch) do
+    Enum.reduce_while(batch, {:ok, []}, fn still, {:ok, parts} ->
+      case ctx.storage.get(ctx.bucket, still.key, ctx.region) do
+        {:ok, image} ->
+          label = "S#{still.scene} at #{:erlang.float_to_binary(still.time, decimals: 2)} s:"
+
+          {:cont,
+           {:ok,
+            parts ++
+              [
+                %{"type" => "text", "text" => label},
+                %{
+                  "type" => "image_url",
+                  "image_url" => %{"url" => "data:image/jpeg;base64," <> Base.encode64(image)}
+                }
+              ]}}
+
+        {:error, reason} ->
+          {:halt, {:error, {:still_unavailable, still.key, reason}}}
+      end
+    end)
+  end
+
+  # Pin cues to their scene and chosen pause, using the same scenes and pauses the model was given.
+  defp clean_cues(raw_cues, speech, scenes, duration) do
+    gaps = Timeline.free_gaps(speech, duration)
+
+    raw_cues
+    |> Enum.flat_map(fn cue ->
+      start = Cues.parse_timestamp(cue["start"])
+      text = cue["text"]
+
+      if is_nil(start) or not is_binary(text) do
+        []
+      else
+        [
+          %{
+            start: start,
+            end: Cues.parse_timestamp(cue["end"]) || start + 2,
+            text: text,
+            pause: integer_or_nil(cue["pause"]),
+            scene: integer_or_nil(cue["shot"])
+          }
+        ]
+      end
+    end)
+    |> Timeline.snap_cues(gaps, scenes)
+    |> Cues.normalize(duration)
+  end
+
+  defp require_cues([]), do: {:error, :no_descriptions}
+  defp require_cues(_cues), do: :ok
+
+  defp speech(ctx, duration) do
+    case Map.get(ctx.outputs, "transcribe_audio") do
+      %{"status" => "ok", "subtitle_json_key" => key} when is_binary(key) ->
+        with {:ok, %{"segments" => segments}} <- AD.get_json(ctx, key) do
+          {:ok, speech_from_segments(segments, duration)}
+        end
+
+      _ ->
+        transcribe(ctx, duration)
+    end
+  end
+
+  # Without a transcription from the flow, measure the speech here. A video without
+  # audio has no speech, so every moment is a pause.
+  defp transcribe(ctx, duration) do
+    case Map.get(ctx.outputs, "transcode_audio") do
+      %{"status" => "ok", "key" => key} when is_binary(key) ->
+        provider =
+          Application.get_env(:mave_core, :transcription_provider, MaveCore.Transcription.Mistral)
+
+        with {:ok, transcription} <- transcribe_with(provider, ctx, key) do
+          {:ok, speech_from_segments(Map.get(transcription, :segments, []), duration)}
+        end
+
+      _ ->
+        {:ok, []}
+    end
+  end
+
+  defp transcribe_with(provider, ctx, key) do
+    opts = [filename: Path.basename(key), content_type: "audio/mpeg"]
+    url = SettingsSerializer.storage_object_url(ctx.bucket, key)
+
+    url_result =
+      if is_binary(url) and function_exported?(provider, :transcribe_url, 2),
+        do: provider.transcribe_url(url, opts),
+        else: {:error, :url_unsupported}
+
+    case url_result do
+      {:ok, transcription} ->
+        {:ok, transcription}
+
+      {:error, _reason} ->
+        with {:ok, body} <- ctx.storage.get(ctx.bucket, key, ctx.region) do
+          provider.transcribe(body, opts)
+        end
+    end
+  end
+
+  defp speech_from_segments(segments, duration) when is_list(segments) do
+    segments
+    |> Enum.flat_map(fn segment ->
+      start = number(segment[:start] || segment["start"])
+      stop = number(segment[:end] || segment["end"])
+      if start && stop, do: [%{start: start, end: stop}], else: []
+    end)
+    |> Timeline.speech_from_words(duration)
+  end
+
+  defp speech_from_segments(_segments, _duration), do: []
+
+  defp scene_bound(scenes, index, key, default) do
+    case Enum.at(scenes, index || 0) do
+      %{} = scene -> Map.fetch!(scene, key)
+      nil -> default
+    end
+  end
+
+  defp intervals(list) when is_list(list) do
+    Enum.map(list, &%{start: &1["start"] * 1.0, end: &1["end"] * 1.0})
+  end
+
+  defp intervals(_list), do: []
+
+  defp interval_json(%{start: start, end: stop}), do: %{"start" => start, "end" => stop}
+
+  defp integer_or_nil(value) when is_integer(value), do: value
+  defp integer_or_nil(value) when is_float(value), do: trunc(value)
+  defp integer_or_nil(_value), do: nil
+
+  defp number(value) when is_number(value), do: value * 1.0
+  defp number(_value), do: nil
+end
diff --git a/lib/mave_core/flow/steps/ai_speak_descriptions_step.ex b/lib/mave_core/flow/steps/ai_speak_descriptions_step.ex
new file mode 100644
index 0000000..b3ba1a5
--- /dev/null
+++ b/lib/mave_core/flow/steps/ai_speak_descriptions_step.ex
@@ -0,0 +1,84 @@
+defmodule MaveCore.Flow.Steps.AiSpeakDescriptionsStep do
+  @moduledoc """
+  Speaks every description cue of one language with text-to-speech, in a voice
+  of that language. Clips are stored privately as trimmed mono 24 kHz PCM; a
+  clip that already exists is reused, so a retry only speaks what is missing.
+  """
+  @behaviour MaveCore.Flow.Step
+
+  alias MaveCore.AudioDescription.{Cues, Wav}
+  alias MaveCore.Flow.Steps.AudioDescriptionSupport, as: AD
+
+  @step_type "ai.speak_descriptions"
+  @concurrency 5
+  @timeout_ms 3 * 60 * 1000
+
+  @impl true
+  def run(step, context) do
+    ctx = AD.run_context(step, context)
+    language = AD.language(ctx)
+    source_step_id = AD.source_step_id(ctx, "describe_video")
+
+    with :ok <- AD.check_requested(ctx),
+         {:ok, source} <- AD.check_dependency(ctx, source_step_id) do
+      speak(ctx, source, language)
+    else
+      {:skip, reason} -> {:ok, AD.skipped(@step_type, ctx, reason, %{"language" => language}), []}
+    end
+  end
+
+  defp speak(ctx, source, language) do
+    with {:ok, json} <- AD.get_json(ctx, source["cues_key"]),
+         cues = Cues.from_json(json),
+         {:ok, clips} <- speak_cues(ctx, cues, language) do
+      {:ok,
+       source
+       |> Map.take(["speech_key", "duration", "cues_key"])
+       |> Map.merge(%{
+         "status" => "ok",
+         "step_type" => @step_type,
+         "step_id" => ctx.step_id,
+         "language" => language,
+         "sample_rate" => Wav.sample_rate(),
+         "clips" => clips
+       }), []}
+    else
+      {:error, reason} -> AD.failure(@step_type, ctx, reason)
+    end
+  end
+
+  defp speak_cues(ctx, cues, language) do
+    cues
+    |> Enum.with_index()
+    |> Task.async_stream(fn {cue, index} -> speak_cue(ctx, cue, index, language) end,
+      max_concurrency: @concurrency,
+      timeout: @timeout_ms,
+      ordered: true
+    )
+    |> Enum.reduce_while({:ok, []}, fn
+      {:ok, {:ok, clip}}, {:ok, clips} -> {:cont, {:ok, [clip | clips]}}
+      {:ok, {:error, reason}}, _acc -> {:halt, {:error, reason}}
+      {:exit, reason}, _acc -> {:halt, {:error, {:speech_task_exit, reason}}}
+    end)
+    |> case do
+      {:ok, clips} -> {:ok, Enum.reverse(clips)}
+      error -> error
+    end
+  end
+
+  defp speak_cue(ctx, cue, index, language) do
+    key = AD.work_key(ctx, "#{language}/speech/#{String.pad_leading("#{index}", 5, "0")}.pcm")
+
+    case ctx.storage.get(ctx.bucket, key, ctx.region) do
+      {:ok, pcm} ->
+        {:ok, %{"key" => key, "samples" => div(byte_size(pcm), 2)}}
+
+      {:error, _not_found} ->
+        with {:ok, audio} <- AD.speech_provider().speak(cue.text, language),
+             {:ok, pcm} <- Wav.clip(audio),
+             {:ok, _} <- AD.put_private(ctx, key, pcm, "application/octet-stream") do
+          {:ok, %{"key" => key, "samples" => div(byte_size(pcm), 2)}}
+        end
+    end
+  end
+end
diff --git a/lib/mave_core/flow/steps/ai_translate_descriptions_step.ex b/lib/mave_core/flow/steps/ai_translate_descriptions_step.ex
new file mode 100644
index 0000000..9e12f86
--- /dev/null
+++ b/lib/mave_core/flow/steps/ai_translate_descriptions_step.ex
@@ -0,0 +1,57 @@
+defmodule MaveCore.Flow.Steps.AiTranslateDescriptionsStep do
+  @moduledoc """
+  Translates the English description cues into `params["language"]`. Timings stay
+  the same; each translation has to fit the time slot of its cue.
+  """
+  @behaviour MaveCore.Flow.Step
+
+  alias MaveCore.AudioDescription.{Cues, Prompts}
+  alias MaveCore.Flow.Steps.AudioDescriptionSupport, as: AD
+
+  @step_type "ai.translate_descriptions"
+
+  @impl true
+  def run(step, context) do
+    ctx = AD.run_context(step, context)
+    language = AD.language(ctx)
+
+    with :ok <- AD.check_requested(ctx),
+         {:ok, source} <- AD.check_dependency(ctx, AD.source_step_id(ctx, "describe_video")) do
+      translate(ctx, source, language)
+    else
+      {:skip, reason} -> {:ok, AD.skipped(@step_type, ctx, reason, %{"language" => language}), []}
+    end
+  end
+
+  defp translate(ctx, source, language) do
+    with {:ok, json} <- AD.get_json(ctx, source["cues_key"]),
+         cues = Cues.from_json(json),
+         {instruction, input} = Prompts.translation_request(cues, language),
+         {:ok, answer} <-
+           AD.chat_provider().chat_json(
+             instruction,
+             [%{"type" => "text", "text" => Jason.encode!(input)}],
+             schema: Prompts.translations_schema(),
+             max_tokens: 16_000
+           ),
+         {:ok, texts} <- Prompts.check_translations(answer["translations"], length(cues)),
+         translated =
+           cues |> Enum.zip(texts) |> Enum.map(fn {cue, text} -> %{cue | text: text} end),
+         {:ok, cues_key} <-
+           AD.put_json(ctx, AD.work_key(ctx, "#{language}/cues.json"), Cues.to_json(translated)) do
+      {:ok,
+       source
+       |> Map.take(["speech_key", "duration"])
+       |> Map.merge(%{
+         "status" => "ok",
+         "step_type" => @step_type,
+         "step_id" => ctx.step_id,
+         "language" => language,
+         "cues_key" => cues_key,
+         "cue_count" => length(translated)
+       }), []}
+    else
+      {:error, reason} -> AD.failure(@step_type, ctx, reason)
+    end
+  end
+end
diff --git a/lib/mave_core/flow/steps/audio_description_support.ex b/lib/mave_core/flow/steps/audio_description_support.ex
new file mode 100644
index 0000000..c1e3e1c
--- /dev/null
+++ b/lib/mave_core/flow/steps/audio_description_support.ex
@@ -0,0 +1,169 @@
+defmodule MaveCore.Flow.Steps.AudioDescriptionSupport do
+  @moduledoc """
+  Shared plumbing of the audio-description flow steps: run coordinates, private
+  working objects and the result shapes.
+
+  Every step skips itself when the run didn't ask for audio descriptions, so the
+  steps cost nothing in the publishing presets for other spaces. Transient
+  provider and storage errors are returned as errors (the flow engine retries
+  them); anything else makes the step `unavailable`, which never blocks
+  publication.
+  """
+
+  alias MaveCore.AudioDescription
+  alias MaveCore.Flow.RetryPolicy
+  alias MaveCore.Flow.Steps.Support, as: StepSupport
+  alias MaveCore.Media.Storage
+
+  @failure_tags %{
+    "media.detect_scenes" => :media_detect_scenes_failed,
+    "ai.describe_video" => :ai_describe_video_failed,
+    "ai.translate_descriptions" => :ai_translate_descriptions_failed,
+    "ai.speak_descriptions" => :ai_speak_descriptions_failed,
+    "media.mix_audio_description" => :media_mix_audio_description_failed
+  }
+
+  def run_context(step, context) do
+    run_input = Map.get(context, :run_input, %{})
+    outputs = Map.get(context, :dependency_outputs, %{})
+    source = Map.get(outputs, "source", %{})
+    params = Map.get(step, "params", %{})
+    space_hash = source["space_hash"] || run_input["space_hash"]
+    region = run_input["region"]
+
+    %{
+      step_id: Map.get(step, "id"),
+      params: params,
+      run_input: run_input,
+      outputs: outputs,
+      space_hash: space_hash,
+      embed_hash: source["embed_hash"] || run_input["embed_hash"],
+      version: StepSupport.normalize_version(source["version"] || run_input["version"]),
+      region: region,
+      bucket: Storage.bucket_for_space(space_hash, region),
+      storage: Application.get_env(:mave_core, :flow_storage_adapter, Storage),
+      languages: AudioDescription.requested_languages(run_input),
+      strict?: StepSupport.strict_enabled?(params, run_input, "audio_description_strict")
+    }
+  end
+
+  @doc "`:ok`, or the reason the step has nothing to do."
+  def check_requested(%{languages: []}), do: {:skip, "not_requested"}
+
+  def check_requested(%{params: %{"language" => language}, languages: languages}) do
+    if language in languages, do: :ok, else: {:skip, "language_not_requested"}
+  end
+
+  def check_requested(_ctx), do: :ok
+
+  @doc "The status of a dependency step that must have succeeded."
+  def check_dependency(ctx, step_id) do
+    case Map.get(ctx.outputs, step_id) do
+      %{"status" => "ok"} = output ->
+        {:ok, output}
+
+      %{"status" => status, "reason" => reason} when status in ["skipped", "unavailable"] ->
+        {:skip, reason}
+
+      %{"status" => status} when status in ["skipped", "unavailable"] ->
+        {:skip, "#{step_id}_#{status}"}
+
+      _ ->
+        {:skip, "#{step_id}_missing"}
+    end
+  end
+
+  @doc "The dependency named by `params[\"source_step_id\"]`."
+  def source_step_id(ctx, default), do: Map.get(ctx.params, "source_step_id", default)
+
+  def language(ctx), do: Map.get(ctx.params, "language", AudioDescription.source_language())
+
+  def work_key(ctx, name),
+    do: "#{AudioDescription.work_prefix(ctx.embed_hash, ctx.version)}/#{name}"
+
+  def output_key(ctx, filename),
+    do: "#{AudioDescription.version_prefix(ctx.embed_hash, ctx.version)}/#{filename}"
+
+  @doc "Stores a private JSON working object."
+  def put_json(ctx, key, value) do
+    body = Jason.encode!(value)
+
+    case ctx.storage.put(ctx.bucket, key, body, "application/json", ctx.region) do
+      {:ok, _} -> {:ok, key}
+      {:error, reason} -> {:error, {:storage_put_failed, key, reason}}
+    end
+  end
+
+  def get_json(ctx, key) when is_binary(key) do
+    with {:ok, body} <- ctx.storage.get(ctx.bucket, key, ctx.region),
+         {:ok, value} <- Jason.decode(body) do
+      {:ok, value}
+    else
+      {:error, %Jason.DecodeError{}} -> {:error, {:invalid_json, key}}
+      {:error, reason} -> {:error, {:storage_get_failed, key, reason}}
+    end
+  end
+
+  def get_json(_ctx, key), do: {:error, {:missing_key, key}}
+
+  def put_private(ctx, key, body, content_type) do
+    case ctx.storage.put(ctx.bucket, key, body, content_type, ctx.region) do
+      {:ok, _} -> {:ok, key}
+      {:error, reason} -> {:error, {:storage_put_failed, key, reason}}
+    end
+  end
+
+  def chat_provider do
+    AudioDescription.config(:chat_provider, MaveCore.AudioDescription.Scaleway)
+  end
+
+  def speech_provider do
+    AudioDescription.config(:speech_provider, MaveCore.AudioDescription.MistralSpeech)
+  end
+
+  def skipped(step_type, ctx, reason, extra \\ %{}) do
+    Map.merge(
+      %{
+        "status" => "skipped",
+        "step_type" => step_type,
+        "step_id" => ctx.step_id,
+        "reason" => reason
+      },
+      extra
+    )
+  end
+
+  @doc "The step result for a failure: retried when transient, otherwise `unavailable`."
+  def failure(step_type, ctx, reason) do
+    if ctx.strict? or RetryPolicy.transient_error?(reason) do
+      {:error, {Map.fetch!(@failure_tags, step_type), reason}}
+    else
+      {:ok,
+       %{
+         "status" => "unavailable",
+         "step_type" => step_type,
+         "step_id" => ctx.step_id,
+         "error" => inspect(reason)
+       }, []}
+    end
+  end
+
+  def artifact(name, ctx, key, media_type, size, metadata \\ %{}) do
+    %{
+      name: name,
+      uri: "s3://#{ctx.bucket}/#{key}",
+      media_type: media_type,
+      size_bytes: size,
+      metadata:
+        Map.merge(
+          %{
+            "type" => "audio_description",
+            "space_hash" => ctx.space_hash,
+            "embed_hash" => ctx.embed_hash,
+            "version" => ctx.version
+          },
+          metadata
+        )
+    }
+  end
+end
diff --git a/lib/mave_core/flow/steps/media_build_hls_master_step.ex b/lib/mave_core/flow/steps/media_build_hls_master_step.ex
index b3ee77b..2ed39ae 100644
--- a/lib/mave_core/flow/steps/media_build_hls_master_step.ex
+++ b/lib/mave_core/flow/steps/media_build_hls_master_step.ex
@@ -220,6 +220,21 @@ defmodule MaveCore.Flow.Steps.MediaBuildHlsMasterStep do
           |> Enum.filter(&is_map/1)
           |> Enum.map(&normalize_audio_track_map/1)
 
+        # Audio descriptions: full mixes marked for assistive technology, never the default.
+        %{
+          "step_type" => "media.mix_audio_description",
+          "status" => "ok",
+          "audio_tracks" => tracks
+        }
+        when is_list(tracks) ->
+          tracks
+          |> Enum.filter(&is_map/1)
+          |> Enum.map(&normalize_audio_track_map/1)
+
+        %{"step_type" => "media.mix_audio_description", "status" => "ok", "audio_track" => track}
+        when is_map(track) ->
+          [normalize_audio_track_map(track)]
+
         _ ->
           []
       end
@@ -324,7 +339,8 @@ defmodule MaveCore.Flow.Steps.MediaBuildHlsMasterStep do
       "channels" => normalize_string(first_map_value(track, ["hls_channels", "channels"], "2")),
       "bandwidth" => normalize_integer(first_map_value(track, ["hls_bandwidth", "bandwidth"])),
       "playlist_path" => first_map_value(track, ["hls_playlist", "playlist_path"]),
-      "playlist_uri" => first_map_value(track, ["hls_src", "playlist_uri"])
+      "playlist_uri" => first_map_value(track, ["hls_src", "playlist_uri"]),
+      "characteristics" => first_map_value(track, ["characteristics"])
     }
   end
 
@@ -546,8 +562,11 @@ defmodule MaveCore.Flow.Steps.MediaBuildHlsMasterStep do
 
   defp audio_media_line(track, group_id) do
     default? = track["default"] in [true, "true", 1, "1"]
+    characteristics = track["characteristics"]
     default_flag = if default?, do: "YES", else: "NO"
-    autoselect_flag = if default?, do: "YES", else: "NO"
+    # Players select an accessibility track by its characteristics when the viewer asks
+    # for audio description, which requires AUTOSELECT=YES.
+    autoselect_flag = if default? or is_binary(characteristics), do: "YES", else: "NO"
 
     attrs =
       [
@@ -556,10 +575,13 @@ defmodule MaveCore.Flow.Steps.MediaBuildHlsMasterStep do
         ~s(NAME="#{escape_attr(track["name"] || "Audio")}"),
         ~s(LANGUAGE="#{escape_attr(track["language"] || "und")}"),
         "DEFAULT=#{default_flag}",
-        "AUTOSELECT=#{autoselect_flag}",
+        "AUTOSELECT=#{autoselect_flag}"
+      ]
+      |> append_quoted_attr("CHARACTERISTICS", characteristics)
+      |> Kernel.++([
         ~s(CHANNELS="#{escape_attr(track["channels"] || "2")}"),
         ~s(URI="#{escape_attr(track["playlist_path"] || "")}")
-      ]
+      ])
       |> append_attr("BANDWIDTH", track["bandwidth"])
 
     "#EXT-X-MEDIA:#{Enum.join(attrs, ",")}"
diff --git a/lib/mave_core/flow/steps/media_detect_scenes_step.ex b/lib/mave_core/flow/steps/media_detect_scenes_step.ex
new file mode 100644
index 0000000..f119235
--- /dev/null
+++ b/lib/mave_core/flow/steps/media_detect_scenes_step.ex
@@ -0,0 +1,206 @@
+defmodule MaveCore.Flow.Steps.MediaDetectScenesStep do
+  @moduledoc """
+  Detects camera cuts with FFmpeg (`scdet`), groups them into scenes of at least
+  3 s and extracts labelled 360p stills (one per ~3 s per shot) for the
+  description model. One decode of the canonical source does both.
+
+  Stores the private `audio_description/scenes.json` and `audio_description/stills/*`.
+  """
+  @behaviour MaveCore.Flow.Step
+
+  alias MaveCore.AudioDescription
+  alias MaveCore.AudioDescription.Timeline
+  alias MaveCore.Flow.Steps.AudioDescriptionSupport, as: AD
+  alias MaveCore.Flow.Steps.Support, as: StepSupport
+
+  @step_type "media.detect_scenes"
+  # Cuts closer together than this (or to the start) are detection noise.
+  @min_shot_seconds 0.5
+  @scdet_threshold 10
+
+  @impl true
+  def run(step, context) do
+    ctx = AD.run_context(step, context)
+    duration_ms = StepSupport.inspect_duration_ms(ctx.outputs)
+
+    cond do
+      AD.check_requested(ctx) != :ok ->
+        {:skip, reason} = AD.check_requested(ctx)
+        {:ok, AD.skipped(@step_type, ctx, reason), []}
+
+      StepSupport.inspect_reports_no_video?(ctx.outputs) ->
+        {:ok, AD.skipped(@step_type, ctx, "no_video"), []}
+
+      not (is_number(duration_ms) and duration_ms > 0) ->
+        {:ok, AD.skipped(@step_type, ctx, "unknown_duration"), []}
+
+      duration_ms / 1000 > AudioDescription.max_seconds() ->
+        {:ok,
+         AD.skipped(@step_type, ctx, "video_too_long", %{
+           "video_duration_seconds" => Float.round(duration_ms / 1000, 3),
+           "max_duration_seconds" => AudioDescription.max_seconds()
+         }), []}
+
+      true ->
+        detect(ctx, context, duration_ms / 1000)
+    end
+  end
+
+  defp detect(ctx, context, duration) do
+    source = Map.get(ctx.outputs, "source", %{})
+    source_url = source["source_url"] || ctx.run_input["input_url"] || ctx.run_input["source_url"]
+    fps = if duration > 180, do: 1, else: 2
+
+    progress =
+      StepSupport.ffmpeg_progress(context[:progress_reporter], %{
+        stage: "detect_scenes",
+        step_id: ctx.step_id,
+        total_ms: round(duration * 1000)
+      })
+
+    result =
+      StepSupport.with_temp_dir("detect_scenes", fn dir ->
+        with {:ok, scd_path} <- StepSupport.tmp_file_path(dir, "scd", "txt"),
+             {:ok, null_path} <- StepSupport.tmp_file_path(dir, "cuts", "null"),
+             {:ok, frames_dir} <- StepSupport.tmp_file_path(dir, "frames"),
+             :ok <- StepSupport.mkdir_tmp_dir(frames_dir),
+             {:ok, _, _} <-
+               StepSupport.run_ffmpeg_with_storage_fallback(
+                 dir,
+                 ctx.run_input,
+                 source_url,
+                 ctx.outputs,
+                 &{:ok, ffmpeg_args(&1, scd_path, null_path, frames_dir, fps)},
+                 progress: progress
+               ),
+             {:ok, scd} <- StepSupport.read_tmp_file(scd_path) do
+          cuts = parse_cuts(scd)
+          shots = Timeline.shots_from_cuts(cuts, duration)
+          scenes = Timeline.scenes_from_shots(shots)
+          stills = Timeline.plan_stills(scenes, duration, 3, shots)
+          store(ctx, frames_dir, fps, duration, cuts, shots, scenes, stills)
+        end
+      end)
+
+    case result do
+      {:ok, output, artifacts} -> {:ok, output, artifacts}
+      {:error, reason} -> AD.failure(@step_type, ctx, reason)
+    end
+  end
+
+  defp store(ctx, frames_dir, fps, duration, cuts, shots, scenes, stills) do
+    stills
+    |> Enum.with_index()
+    |> Enum.reduce_while({:ok, []}, fn {still, index}, {:ok, acc} ->
+      key = AD.work_key(ctx, "stills/#{pad(index)}.jpg")
+
+      with {:ok, image} <- read_frame(frames_dir, round(still.time * fps) + 1),
+           {:ok, _} <- AD.put_private(ctx, key, image, "image/jpeg") do
+        {:cont, {:ok, [Map.put(still, :key, key) | acc]}}
+      else
+        {:error, reason} -> {:halt, {:error, reason}}
+      end
+    end)
+    |> case do
+      {:ok, stored} ->
+        scenes_key = AD.work_key(ctx, "scenes.json")
+
+        document = %{
+          "duration" => duration,
+          "cuts" => cuts,
+          "shots" => Enum.map(shots, &interval_json/1),
+          "scenes" => Enum.map(scenes, &interval_json/1),
+          "stills" =>
+            stored
+            |> Enum.reverse()
+            |> Enum.map(&%{"scene" => &1.scene, "time" => &1.time, "key" => &1.key})
+        }
+
+        with {:ok, _} <- AD.put_json(ctx, scenes_key, document) do
+          {:ok,
+           %{
+             "status" => "ok",
+             "step_type" => @step_type,
+             "step_id" => ctx.step_id,
+             "scenes_key" => scenes_key,
+             "duration" => duration,
+             "cut_count" => length(cuts),
+             "scene_count" => length(scenes),
+             "still_count" => length(stored)
+           }, []}
+        end
+
+      {:error, reason} ->
+        {:error, reason}
+    end
+  end
+
+  # The fps filter emits frame n (1-based) at (n - 1) / fps; a still near the very end
+  # may round past the last frame.
+  defp read_frame(frames_dir, number) when number >= 1 do
+    with {:ok, path} <- StepSupport.tmp_file_path(frames_dir, pad(number), "jpg") do
+      case StepSupport.read_tmp_file(path) do
+        {:ok, image} -> {:ok, image}
+        {:error, _reason} when number > 1 -> read_frame(frames_dir, number - 1)
+        {:error, reason} -> {:error, {:missing_still, reason}}
+      end
+    end
+  end
+
+  defp ffmpeg_args(source, scd_path, null_path, frames_dir, fps) do
+    filter =
+      "[0:v]split=2[a][b];" <>
+        "[a]scale=320:-2,scdet=threshold=#{@scdet_threshold}," <>
+        "metadata=print:key=lavfi.scd.time:file='#{escape_filter_path(scd_path)}'[cuts];" <>
+        "[b]fps=#{fps},scale=-2:360[stills]"
+
+    [
+      "-y",
+      "-v",
+      "error",
+      "-i",
+      source,
+      "-an",
+      "-sn",
+      "-filter_complex",
+      filter,
+      "-map",
+      "[cuts]",
+      "-f",
+      "null",
+      # Keep an explicit output path so the sandbox grants this job's directory.
+      null_path,
+      "-map",
+      "[stills]",
+      "-q:v",
+      "5",
+      Path.join(frames_dir, "%05d.jpg")
+    ]
+  end
+
+  @doc false
+  def parse_cuts(body) do
+    ~r/lavfi\.scd\.time=([0-9.]+)/
+    |> Regex.scan(body, capture: :all_but_first)
+    |> Enum.flat_map(fn [value] ->
+      case Float.parse(value) do
+        {time, _} -> [time]
+        :error -> []
+      end
+    end)
+    |> Enum.sort()
+    |> Enum.reduce([], fn time, kept ->
+      previous = List.first(kept) || 0.0
+      if time - previous >= @min_shot_seconds, do: [time | kept], else: kept
+    end)
+    |> Enum.reverse()
+    |> Enum.map(&Timeline.round3/1)
+  end
+
+  defp interval_json(%{start: start, end: stop}), do: %{"start" => start, "end" => stop}
+
+  defp pad(number), do: number |> Integer.to_string() |> String.pad_leading(5, "0")
+
+  defp escape_filter_path(path),
+    do: path |> String.replace("\\", "\\\\") |> String.replace("'", "'\\''")
+end
diff --git a/lib/mave_core/flow/steps/media_mix_audio_description_step.ex b/lib/mave_core/flow/steps/media_mix_audio_description_step.ex
new file mode 100644
index 0000000..c17a0db
--- /dev/null
+++ b/lib/mave_core/flow/steps/media_mix_audio_description_step.ex
@@ -0,0 +1,256 @@
+defmodule MaveCore.Flow.Steps.MediaMixAudioDescriptionStep do
+  @moduledoc """
+  Builds the audio description of one language: places the spoken clips on the
+  timeline (in a pause, or over speech with the original ducked to 20%), mixes
+  them with the video's own audio into `audio_description_<lang>.mp3`, writes
+  `descriptions_<lang>.vtt` timed to when each description is spoken, and
+  packages the MP3 as an HLS audio rendition marked
+  `public.accessibility.describes-video`.
+  """
+  @behaviour MaveCore.Flow.Step
+
+  alias MaveCore.AudioDescription
+  alias MaveCore.AudioDescription.{Cues, Mix, Timeline, Wav}
+  alias MaveCore.Flow.Steps.AudioDescriptionSupport, as: AD
+  alias MaveCore.Flow.Steps.MediaPackageHlsAudioStep
+  alias MaveCore.Flow.Steps.Support, as: StepSupport
+  alias MaveCore.Languages
+
+  @step_type "media.mix_audio_description"
+  @characteristics "public.accessibility.describes-video"
+
+  def characteristics, do: @characteristics
+
+  @impl true
+  def run(step, context) do
+    ctx = AD.run_context(step, context)
+    language = AD.language(ctx)
+
+    with :ok <- AD.check_requested(ctx),
+         {:ok, speech} <-
+           AD.check_dependency(ctx, AD.source_step_id(ctx, "speak_descriptions_#{language}")) do
+      mix(ctx, context, speech, language)
+    else
+      {:skip, reason} -> {:ok, AD.skipped(@step_type, ctx, reason, %{"language" => language}), []}
+    end
+  end
+
+  defp mix(ctx, context, speech_output, language) do
+    duration = speech_output["duration"] * 1.0
+
+    with {:ok, cues_json} <- AD.get_json(ctx, speech_output["cues_key"]),
+         {:ok, speech_json} <- AD.get_json(ctx, speech_output["speech_key"]),
+         {:ok, clips} <- load_clips(ctx, speech_output["clips"]),
+         cues = Cues.from_json(cues_json),
+         speech = Enum.map(speech_json, &%{start: &1["start"] * 1.0, end: &1["end"] * 1.0}),
+         lengths = Enum.map(clips, &div(byte_size(&1), 2)),
+         timeline = Timeline.plan_timeline(cues, lengths, speech, duration, Wav.sample_rate()),
+         :ok <- require_placements(timeline),
+         {:ok, audio_size} <- render_and_mix(ctx, context, timeline, clips, duration, language),
+         vtt = Cues.to_vtt(timeline.cues, language),
+         vtt_key = AD.output_key(ctx, AudioDescription.vtt_filename(language)),
+         {:ok, _} <- ctx.storage.put_public(ctx.bucket, vtt_key, vtt, "text/vtt", ctx.region),
+         {:ok, hls} <- package_hls(ctx, language, audio_size) do
+      output(ctx, language, timeline, audio_size, byte_size(vtt), hls)
+    else
+      {:error, :no_placements} ->
+        {:ok, AD.skipped(@step_type, ctx, "no_descriptions", %{"language" => language}), []}
+
+      {:error, reason} ->
+        AD.failure(@step_type, ctx, reason)
+    end
+  end
+
+  defp load_clips(ctx, clips) when is_list(clips) do
+    Enum.reduce_while(clips, {:ok, []}, fn %{"key" => key}, {:ok, acc} ->
+      case ctx.storage.get(ctx.bucket, key, ctx.region) do
+        {:ok, pcm} -> {:cont, {:ok, [pcm | acc]}}
+        {:error, reason} -> {:halt, {:error, {:speech_clip_unavailable, key, reason}}}
+      end
+    end)
+    |> case do
+      {:ok, loaded} -> {:ok, Enum.reverse(loaded)}
+      error -> error
+    end
+  end
+
+  defp load_clips(_ctx, _clips), do: {:error, :missing_speech_clips}
+
+  defp require_placements(%{placements: []}), do: {:error, :no_placements}
+  defp require_placements(_timeline), do: :ok
+
+  defp render_and_mix(ctx, context, timeline, clips, duration, language) do
+    clips = List.to_tuple(clips)
+    audio_key = AD.output_key(ctx, AudioDescription.audio_filename(language))
+
+    progress =
+      StepSupport.ffmpeg_progress(context[:progress_reporter], %{
+        stage: "mix_audio_description",
+        step_id: ctx.step_id,
+        total_ms: round(duration * 1000)
+      })
+
+    StepSupport.with_temp_dir("audio_description", fn dir ->
+      with {:ok, description_path} <- StepSupport.tmp_file_path(dir, "description", "pcm"),
+           {:ok, output_path} <- StepSupport.tmp_file_path(dir, "mix", "mp3"),
+           pcm = Wav.render(timeline.placements, timeline.total_samples, &elem(clips, &1)),
+           :ok <- StepSupport.write_tmp_file(description_path, pcm),
+           build = &Mix.ffmpeg_args(&1, description_path, output_path, timeline.ducks, duration),
+           :ok <- run_mix(ctx, dir, build, progress),
+           {:ok, %{size: size}} <- MaveCore.SafeFile.stat_regular(output_path),
+           {:ok, _} <-
+             ctx.storage.put_file_public(
+               ctx.bucket,
+               audio_key,
+               output_path,
+               "audio/mpeg",
+               ctx.region
+             ) do
+        {:ok, size}
+      end
+    end)
+  end
+
+  # Mix with the video's own audio, or the descriptions alone when the video has none.
+  defp run_mix(ctx, dir, build, progress) do
+    case Map.get(ctx.outputs, "transcode_audio") do
+      %{"status" => "ok", "key" => key} when is_binary(key) ->
+        case StepSupport.run_ffmpeg_with_storage_fallback(
+               dir,
+               ctx.run_input,
+               nil,
+               ctx.outputs,
+               &{:ok, build.(&1)},
+               progress: progress,
+               preferred_storage_step_id: "transcode_audio"
+             ) do
+          {:ok, _output, _fallback?} -> :ok
+          {:error, reason} -> {:error, reason}
+        end
+
+      _ ->
+        with {:ok, ffmpeg} <- StepSupport.find_ffmpeg(),
+             {_output, 0} <- StepSupport.run_media_cmd(ffmpeg, build.(nil)) do
+          :ok
+        else
+          {:error, reason} -> {:error, reason}
+          {output, status} -> {:error, {output, status}}
+        end
+    end
+  end
+
+  defp package_hls(ctx, language, audio_size) do
+    filename = AudioDescription.audio_filename(language)
+    key = AD.output_key(ctx, filename)
+    track = audio_track(ctx, language, filename, audio_size)
+
+    step = %{
+      "id" => "#{ctx.step_id}_hls",
+      "type" => "media.package_hls_audio",
+      "params" => %{"source_step_id" => "audio_description", "default" => false, "strict" => true}
+    }
+
+    context = %{
+      run_input: Map.take(ctx.run_input, ["space_hash", "embed_hash", "version", "region"]),
+      dependency_outputs: %{
+        "source" => Map.get(ctx.outputs, "source", %{}),
+        "audio_description" => %{
+          "step_type" => "media.transcode_audio",
+          "status" => "ok",
+          "bucket" => ctx.bucket,
+          "key" => key,
+          "uri" => "s3://#{ctx.bucket}/#{key}",
+          "audio_track" => track,
+          "audio_tracks" => [track]
+        }
+      }
+    }
+
+    case MediaPackageHlsAudioStep.run(step, context) do
+      {:ok, %{"status" => "ok", "audio_track" => packaged}, _artifacts} ->
+        {:ok, packaged}
+
+      {:ok, other, _artifacts} ->
+        {:error, {:hls_packaging_unavailable, other["error"] || other["reason"]}}
+
+      {:error, reason} ->
+        {:error, reason}
+    end
+  end
+
+  defp audio_track(ctx, language, filename, size) do
+    key = AD.output_key(ctx, filename)
+
+    %{
+      "id" => "audio_description_#{language}",
+      "label" => label(language),
+      "language" => language,
+      "default" => false,
+      "codec" => "mp3",
+      "file_size" => size,
+      "filename" => filename,
+      "bucket" => ctx.bucket,
+      "key" => key,
+      "path" => "s3://#{ctx.bucket}/#{key}",
+      "src" => "s3://#{ctx.bucket}/#{key}"
+    }
+  end
+
+  @doc "Name of the audio-description track of `language`, e.g. `English (audio description)`."
+  def label(language) do
+    "#{Languages.spoken_language(language) || String.upcase(language)} (audio description)"
+  end
+
+  defp output(ctx, language, timeline, audio_size, vtt_size, hls) do
+    audio_filename = AudioDescription.audio_filename(language)
+    vtt_filename = AudioDescription.vtt_filename(language)
+    audio_key = AD.output_key(ctx, audio_filename)
+    vtt_key = AD.output_key(ctx, vtt_filename)
+
+    description = %{
+      "language" => language,
+      "label" => label(language),
+      "audio_filename" => audio_filename,
+      "audio_file_size" => audio_size,
+      "vtt_filename" => vtt_filename,
+      "vtt_file_size" => vtt_size,
+      "cue_count" => length(timeline.cues),
+      "ducked_cue_count" => length(timeline.ducks),
+      "hls_playlist" => hls["hls_playlist"]
+    }
+
+    track =
+      hls
+      |> Map.take([
+        "id",
+        "label",
+        "language",
+        "hls_playlist",
+        "hls_src",
+        "hls_bandwidth",
+        "hls_channels"
+      ])
+      |> Map.merge(%{"default" => false, "characteristics" => @characteristics})
+
+    {:ok,
+     %{
+       "status" => "ok",
+       "step_type" => @step_type,
+       "step_id" => ctx.step_id,
+       "language" => language,
+       "audio_description" => description,
+       "audio_track" => track,
+       "cue_count" => length(timeline.cues),
+       "ducked_cue_count" => length(timeline.ducks),
+       "skipped_cue_count" => length(timeline.skipped)
+     },
+     [
+       AD.artifact("audio_description_#{language}", ctx, audio_key, "audio/mpeg", audio_size, %{
+         "language" => language
+       }),
+       AD.artifact("descriptions_#{language}", ctx, vtt_key, "text/vtt", vtt_size, %{
+         "language" => language
+       })
+     ]}
+  end
+end
diff --git a/lib/mave_core/public_api.ex b/lib/mave_core/public_api.ex
index adc4d17..8278de2 100644
--- a/lib/mave_core/public_api.ex
+++ b/lib/mave_core/public_api.ex
@@ -3,10 +3,12 @@ defmodule MaveCore.PublicApi do
 
   import Ecto.Query, warn: false
 
+  alias MaveCore.Assets
   alias MaveCore.Assets.{AudioTrack, Subtitle, Video}
+  alias MaveCore.AudioDescription
   alias MaveCore.Collections.CollectionEmbed
   alias MaveCore.Embeds
-  alias MaveCore.Embeds.{Embed, Events, SettingsSerializer}
+  alias MaveCore.Embeds.{Embed, Events, ManifestPublisher, SettingsSerializer}
   alias MaveCore.Flow
   alias MaveCore.Languages
   alias MaveCore.Playback.URLs
@@ -579,10 +581,31 @@ defmodule MaveCore.PublicApi do
         video_src: nil
       },
       subtitles: detailed_subtitles(space, embed, version),
-      audio_tracks: detailed_audio_tracks(space, embed, version)
+      audio_tracks: detailed_audio_tracks(space, embed, version),
+      audio_descriptions: detailed_audio_descriptions(space, current_video, embed, version)
     }
   end
 
+  defp detailed_audio_descriptions(_space, nil, _embed, _version), do: []
+
+  defp detailed_audio_descriptions(
+         %Space{} = space,
+         %Video{id: video_id},
+         %Embed{} = embed,
+         version
+       ) do
+    video_id
+    |> Assets.list_audio_descriptions()
+    |> Enum.map(
+      &ManifestPublisher.serialize_audio_description(
+        &1,
+        "space-#{space.hash}",
+        embed.hash,
+        version
+      )
+    )
+  end
+
   defp detailed_video_renditions(nil), do: nil
 
   defp detailed_video_renditions(%Video{id: video_id}) do
@@ -861,6 +884,12 @@ defmodule MaveCore.PublicApi do
       "durable_source_required" => true,
       "version" => current_video_version(embed)
     }
+    |> then(fn input ->
+      case AudioDescription.run_input(space) do
+        nil -> input
+        audio_description -> Map.put(input, "audio_description", audio_description)
+      end
+    end)
   end
 
   defp input_url_priority(%Space{} = space, params) do
diff --git a/lib/mave_core/spaces.ex b/lib/mave_core/spaces.ex
index d146ba5..4274136 100644
--- a/lib/mave_core/spaces.ex
+++ b/lib/mave_core/spaces.ex
@@ -627,25 +627,37 @@ defmodule MaveCore.Spaces do
     attrs =
       attrs
       |> stringify_keys()
-      |> Map.take(["hotlink_protection_enabled"])
+      |> Map.take(["hotlink_protection_enabled", "audio_description_enabled"])
 
-    space
-    |> Space.features_changeset(attrs)
-    |> Repo.update()
-    |> case do
-      {:ok, updated_space} ->
-        if Map.has_key?(attrs, "hotlink_protection_enabled") do
-          sync_domain_cors(updated_space.id)
-        end
-
-        Events.broadcast_updated(updated_space.id)
-        {:ok, updated_space}
+    with :ok <- authorize_feature_change(space, attrs),
+         {:ok, updated_space} <- space |> Space.features_changeset(attrs) |> Repo.update() do
+      if Map.has_key?(attrs, "hotlink_protection_enabled") do
+        sync_domain_cors(updated_space.id)
+      end
 
-      {:error, changeset} ->
-        {:error, changeset}
+      Events.broadcast_updated(updated_space.id)
+      {:ok, updated_space}
     end
   end
 
+  @doc """
+  Whether new uploads in the space get audio descriptions: the space opted in and
+  the host still allows it (a downgraded space stops getting them).
+  """
+  def audio_description_active?(%Space{audio_description_enabled: true} = space) do
+    UsageLimits.can_use_audio_description?(space) == :ok
+  end
+
+  def audio_description_active?(_space), do: false
+
+  # Turning audio descriptions off is always allowed; turning them on needs the host's consent.
+  defp authorize_feature_change(%Space{} = space, %{"audio_description_enabled" => value})
+       when value in [true, "true"] do
+    UsageLimits.can_use_audio_description?(space)
+  end
+
+  defp authorize_feature_change(_space, _attrs), do: :ok
+
   def update_space_processing(%Space{} = space, attrs) when is_map(attrs) do
     attrs =
       attrs
diff --git a/lib/mave_core/spaces/space.ex b/lib/mave_core/spaces/space.ex
index 6e169e9..1c4e4a8 100644
--- a/lib/mave_core/spaces/space.ex
+++ b/lib/mave_core/spaces/space.ex
@@ -11,6 +11,7 @@ defmodule MaveCore.Spaces.Space do
     field :region, :string
     field :public_sharing_enabled, :boolean
     field :hotlink_protection_enabled, :boolean
+    field :audio_description_enabled, :boolean, default: false
     field :default_flow_template, :string
     field :deleted_at, :utc_datetime_usec
 
@@ -36,7 +37,7 @@ defmodule MaveCore.Spaces.Space do
 
   def features_changeset(space, attrs) do
     space
-    |> cast(attrs, [:hotlink_protection_enabled])
+    |> cast(attrs, [:hotlink_protection_enabled, :audio_description_enabled])
     |> validate_shared_storage_features()
   end
 
diff --git a/lib/mave_core/uploads.ex b/lib/mave_core/uploads.ex
index 5906860..42382ed 100644
--- a/lib/mave_core/uploads.ex
+++ b/lib/mave_core/uploads.ex
@@ -6,6 +6,7 @@ defmodule MaveCore.Uploads do
   require Logger
 
   alias MaveCore.Assets
+  alias MaveCore.AudioDescription
   alias MaveCore.EmbedId
   alias MaveCore.Embeds
   alias MaveCore.Embeds.Embed
@@ -714,7 +715,8 @@ defmodule MaveCore.Uploads do
         "callback_url" =>
           present(metadata, "callback_url") ||
             present(metadata, "webhook_url") ||
-            present(metadata, "notify_webhook_url")
+            present(metadata, "notify_webhook_url"),
+        "audio_description" => AudioDescription.run_input(space)
       }
       |> Enum.reject(fn {_key, value} -> is_nil(value) end)
       |> Map.new()
diff --git a/lib/mave_core/usage_limits.ex b/lib/mave_core/usage_limits.ex
index a9851ed..caa5b9f 100644
--- a/lib/mave_core/usage_limits.ex
+++ b/lib/mave_core/usage_limits.ex
@@ -10,9 +10,13 @@ defmodule MaveCore.UsageLimits do
   @callback can_add_space_member?(Space.t(), String.t() | atom()) :: :ok | {:error, term()}
   @callback can_view_space_data?(Space.t()) :: :ok | {:error, term()}
   @callback can_upload_file?(Space.t(), non_neg_integer() | nil) :: :ok | {:error, term()}
+  @callback can_use_audio_description?(Space.t()) :: :ok | {:error, term()}
   @callback restriction_copy(atom(), term()) :: %{optional(atom()) => String.t()}
 
-  @optional_callbacks can_view_space_data?: 1, can_upload_file?: 2, restriction_copy: 2
+  @optional_callbacks can_view_space_data?: 1,
+                      can_upload_file?: 2,
+                      can_use_audio_description?: 1,
+                      restriction_copy: 2
 
   def can_create_video_embed?(%Space{} = space) do
     dispatch(:can_create_video_embed?, [space])
@@ -26,6 +30,14 @@ defmodule MaveCore.UsageLimits do
     dispatch(:can_view_space_data?, [space])
   end
 
+  @doc """
+  Whether a space may generate audio descriptions. Allowed when the host has no
+  policy for it.
+  """
+  def can_use_audio_description?(%Space{} = space) do
+    dispatch(:can_use_audio_description?, [space])
+  end
+
   def can_upload_file?(%Space{} = space, size) when is_integer(size) or is_nil(size) do
     with :ok <- enforce_core_media_input_limit(size) do
       dispatch(:can_upload_file?, [space, size])
diff --git a/lib/mave_core_web/live/dashboard/settings/general_tab.ex b/lib/mave_core_web/live/dashboard/settings/general_tab.ex
index db57555..99cca79 100644
--- a/lib/mave_core_web/live/dashboard/settings/general_tab.ex
+++ b/lib/mave_core_web/live/dashboard/settings/general_tab.ex
@@ -9,6 +9,7 @@ defmodule MaveCoreWeb.Dashboard.Settings.GeneralTab do
   alias MaveCore.Spaces
   alias MaveCore.Spaces.Domain
   alias MaveCore.Spaces.Space
+  alias MaveCore.UsageLimits
   alias Phoenix.LiveView.JS
 
   @show_flow_settings false
@@ -182,6 +183,34 @@ defmodule MaveCoreWeb.Dashboard.Settings.GeneralTab do
               </div>
             </:actions>
           </.data_table_row>
+          <.data_table_row id="audio-description-feature">
+            <div>
+              <div>{gettext("Audio description")}</div>
+              <div
+                :if={@features.audio_description_notice}
+                id="audio-description-notice"
+                class="text-xs text-stone-400 mt-1"
+              >
+                {@features.audio_description_notice}
+              </div>
+            </div>
+            <.info_hover>
+              {gettext(
+                "New videos get spoken descriptions of what happens on screen, in English and Dutch: an audio track with the descriptions mixed in, and a descriptions VTT."
+              )}
+            </.info_hover>
+            <:actions>
+              <div class="p-4">
+                <.toggle
+                  id="audio-description-toggle"
+                  enabled={@features.audio_description}
+                  disabled={@features.audio_description_disabled}
+                  phx-click="toggle_audio_description"
+                  phx-target={@myself}
+                />
+              </div>
+            </:actions>
+          </.data_table_row>
         </.data_table>
       </div>
 
@@ -519,6 +548,34 @@ defmodule MaveCoreWeb.Dashboard.Settings.GeneralTab do
     end
   end
 
+  def handle_event("toggle_audio_description", _params, socket) do
+    attrs = %{
+      audio_description_enabled: !socket.assigns.current_space.audio_description_enabled
+    }
+
+    case Spaces.update_space_features(socket.assigns.current_space, attrs) do
+      {:ok, updated_space} ->
+        {:noreply,
+         socket
+         |> notify_parent(updated_space)
+         |> assign(:current_space, updated_space)
+         |> reload_state()}
+
+      {:error, %Ecto.Changeset{}} ->
+        {:noreply, put_flash(socket, :error, gettext("Could not update audio description."))}
+
+      {:error, reason} ->
+        copy = UsageLimits.restriction_copy(:audio_description, reason)
+
+        {:noreply,
+         put_flash(
+           socket,
+           :error,
+           Map.get(copy, :error, gettext("Audio description isn't available for this space."))
+         )}
+    end
+  end
+
   def handle_event("change_default_flow_template", %{"processing" => params}, socket) do
     case Spaces.update_space_processing(socket.assigns.current_space, %{
            default_flow_template: Map.get(params, "default_flow_template")
@@ -634,12 +691,42 @@ defmodule MaveCoreWeb.Dashboard.Settings.GeneralTab do
     |> assign(:region_help, dashboard_region_help(current_space))
     |> assign(:account_deletion_requirements, AccountDeletion.requirements())
     |> assign(:google_oauth_enabled, GoogleOAuth.enabled?())
-    |> assign(:features, %{
-      public_sharing: current_space.public_sharing_enabled,
-      create_spaces: false,
-      hotlink_protection: hotlink_protection_enabled?(current_space),
-      hotlink_protection_disabled: SharedStorageSpace.shared?(current_space)
-    })
+    |> assign(
+      :features,
+      Map.merge(
+        %{
+          public_sharing: current_space.public_sharing_enabled,
+          create_spaces: false,
+          hotlink_protection: hotlink_protection_enabled?(current_space),
+          hotlink_protection_disabled: SharedStorageSpace.shared?(current_space)
+        },
+        audio_description_features(current_space)
+      )
+    )
+  end
+
+  # A space that lost access can still switch the feature off, but not back on.
+  defp audio_description_features(%Space{} = space) do
+    enabled? = space.audio_description_enabled == true
+
+    case UsageLimits.can_use_audio_description?(space) do
+      :ok ->
+        %{
+          audio_description: enabled?,
+          audio_description_disabled: false,
+          audio_description_notice: nil
+        }
+
+      {:error, reason} ->
+        copy = UsageLimits.restriction_copy(:audio_description, reason)
+
+        %{
+          audio_description: enabled?,
+          audio_description_disabled: not enabled?,
+          audio_description_notice:
+            Map.get(copy, :notice, gettext("Audio description isn't available for this space."))
+        }
+    end
   end
 
   defp notify_parent(socket, updated_space) do
diff --git a/lib/mave_core_web/live/dashboard/videos/video_settings_component.ex b/lib/mave_core_web/live/dashboard/videos/video_settings_component.ex
index 16d7b5f..69462d7 100644
--- a/lib/mave_core_web/live/dashboard/videos/video_settings_component.ex
+++ b/lib/mave_core_web/live/dashboard/videos/video_settings_component.ex
@@ -611,6 +611,8 @@ defmodule MaveCoreWeb.Dashboard.Videos.VideoSettingsComponent do
         subtitles={@video.subtitles}
       />
 
+      <.audio_descriptions_section descriptions={Map.get(@video, :audio_descriptions, [])} />
+
       <.settings_header
         :if={@show_flow_info && @video.flow}
         title="flow"
@@ -2301,6 +2303,47 @@ defmodule MaveCoreWeb.Dashboard.Videos.VideoSettingsComponent do
     """
   end
 
+  attr :descriptions, :list, default: []
+
+  defp audio_descriptions_section(assigns) do
+    ~H"""
+    <div :if={@descriptions != []} id="audio-descriptions">
+      <.settings_header title="audio description" />
+      <div class="py-1.5">
+        <div
+          :for={description <- @descriptions}
+          id={"audio-description-#{description.language}"}
+          class="flex items-center pl-3.5 pr-2 py-1.5"
+        >
+          <.rendition_led progress={100} />
+          <div class="w-full text-sm text-stone-500 mb-0.5 h-[1.225rem]">
+            {description.label}
+          </div>
+          <div class="flex-grow"></div>
+          <a
+            :if={description.mp3_url}
+            href={description.mp3_url}
+            target="_blank"
+            rel="noopener"
+            class="hover:text-stone-300"
+          >
+            <.format_badge>MP3</.format_badge>
+          </a>
+          <a
+            :if={description.vtt_url}
+            href={description.vtt_url}
+            target="_blank"
+            rel="noopener"
+            class="hover:text-stone-300"
+          >
+            <.format_badge>VTT</.format_badge>
+          </a>
+        </div>
+      </div>
+    </div>
+    """
+  end
+
   attr :renditions, :list, required: true
   attr :audio_tracks, :list, default: []
   attr :subtitles, :list, default: []
diff --git a/priv/repo/migrations/20261101120000_add_audio_descriptions.exs b/priv/repo/migrations/20261101120000_add_audio_descriptions.exs
new file mode 100644
index 0000000..89e95f6
--- /dev/null
+++ b/priv/repo/migrations/20261101120000_add_audio_descriptions.exs
@@ -0,0 +1,25 @@
+defmodule MaveCore.Repo.Migrations.AddAudioDescriptions do
+  use Ecto.Migration
+
+  def change do
+    alter table(:spaces) do
+      add :audio_description_enabled, :boolean, null: false, default: false
+    end
+
+    create table(:audio_descriptions, primary_key: false) do
+      add :id, :binary_id, primary_key: true
+      add :video_id, references(:videos, type: :binary_id, on_delete: :delete_all), null: false
+      add :language, :language_code, null: false
+      add :audio_filename, :string, null: false
+      add :audio_file_size, :bigint
+      add :vtt_filename, :string, null: false
+      add :vtt_file_size, :bigint
+      add :cue_count, :integer
+      add :ducked_cue_count, :integer
+
+      timestamps(type: :utc_datetime_usec)
+    end
+
+    create unique_index(:audio_descriptions, [:video_id, :language])
+  end
+end
diff --git a/test/mave_core/assets/audio_description_publication_test.exs b/test/mave_core/assets/audio_description_publication_test.exs
new file mode 100644
index 0000000..8e78cd8
--- /dev/null
+++ b/test/mave_core/assets/audio_description_publication_test.exs
@@ -0,0 +1,117 @@
+defmodule MaveCore.Assets.AudioDescriptionPublicationTest do
+  use MaveCore.DataCase, async: false
+
+  alias MaveCore.Assets
+  alias MaveCore.Assets.{Asset, AudioDescription, AudioTrack, Rendition, Video}
+  alias MaveCore.Embeds.{Embed, ManifestPublisher}
+  alias MaveCore.Spaces.Space
+  alias MaveCore.TestSupport.FlowStorageAdapterStub, as: Storage
+
+  setup do
+    previous = Application.get_env(:mave_core, :flow_storage_adapter)
+    previous_purger = Application.get_env(:mave_core, :cdn_cache_purger)
+    Application.put_env(:mave_core, :flow_storage_adapter, Storage)
+    Application.put_env(:mave_core, :cdn_cache_purger, fn _, _, _ -> :ok end)
+    Storage.reset!()
+
+    on_exit(fn ->
+      restore_env(:flow_storage_adapter, previous)
+      restore_env(:cdn_cache_purger, previous_purger)
+      Storage.reset!()
+    end)
+
+    :ok
+  end
+
+  test "the rebuilt HLS master lists audio descriptions next to the original audio" do
+    embed = embed_fixture()
+    description(embed, "en")
+    description(embed, "nl")
+
+    assert :ok = Assets.refresh_hls_master_playlist(embed)
+    {:ok, body} = Storage.get("space-abcde", "abcdefghij/playlist.m3u8", "eu")
+
+    assert body =~ ~s(NAME="Original",LANGUAGE="en",DEFAULT=YES,AUTOSELECT=YES,CHANNELS="2")
+
+    for {language, name} <- [{"en", "English"}, {"nl", "Dutch"}] do
+      assert body =~
+               ~s|NAME="#{name} (audio description)",LANGUAGE="#{language}",DEFAULT=NO,AUTOSELECT=YES,| <>
+                 ~s|CHARACTERISTICS="public.accessibility.describes-video",CHANNELS="2",| <>
+                 ~s|URI="audio_description_#{language}_hls/playlist.m3u8"|
+    end
+  end
+
+  test "the manifest has audio descriptions only when there are some" do
+    embed = embed_fixture()
+
+    assert {:ok, manifest} = ManifestPublisher.current(embed)
+    refute Map.has_key?(manifest, "audio_descriptions")
+    assert [%{"filename" => "audio.mp3"}] = manifest["audio_tracks"]
+
+    description(embed, "nl")
+    assert {:ok, manifest} = ManifestPublisher.current(embed)
+
+    assert [
+             %{
+               "language" => "nl",
+               "label" => "Dutch (audio description)",
+               "audio" => %{
+                 "path" => mp3,
+                 "hls_playlist" => "audio_description_nl_hls/playlist.m3u8"
+               },
+               "vtt" => %{"path" => vtt}
+             }
+           ] = manifest["audio_descriptions"]
+
+    assert String.ends_with?(mp3, "/abcdefghij/audio_description_nl.mp3")
+    assert String.ends_with?(vtt, "/abcdefghij/descriptions_nl.vtt")
+    assert [%{"filename" => "audio.mp3"}] = manifest["audio_tracks"]
+  end
+
+  defp embed_fixture do
+    space = Repo.insert!(%Space{hash: "abcde", region: "eu"})
+    asset = Repo.insert!(%Asset{space_id: space.id})
+    video = Repo.insert!(%Video{asset_id: asset.id, duration: 10.0})
+    asset |> Ecto.Changeset.change(current_video_id: video.id) |> Repo.update!()
+
+    Repo.insert!(%Rendition{
+      video_id: video.id,
+      rendition_key: "abcdefghij/h264_hd_hls/playlist.m3u8",
+      type: :video,
+      codec: :h264,
+      container: :hls,
+      size: :hd,
+      progress: 100.0
+    })
+
+    Repo.insert!(%AudioTrack{
+      video_id: video.id,
+      filename: "audio.mp3",
+      label: "Original",
+      language: "en",
+      codec: "mp3",
+      default: true
+    })
+
+    Repo.insert!(%Embed{space_id: space.id, asset_id: asset.id, hash: "abcdefghij"})
+    |> Repo.preload([:space, asset: [:current_video]])
+  end
+
+  defp description(embed, language) do
+    %AudioDescription{}
+    |> AudioDescription.changeset(%{
+      video_id: embed.asset.current_video.id,
+      language: language,
+      audio_filename: "audio_description_#{language}.mp3",
+      audio_file_size: 1000,
+      vtt_filename: "descriptions_#{language}.vtt",
+      vtt_file_size: 100,
+      cue_count: 2,
+      ducked_cue_count: 1
+    })
+    |> Repo.insert!()
+  end
+
+  defp restore_env(key, nil), do: Application.delete_env(:mave_core, key)
+  defp restore_env(key, value), do: Application.put_env(:mave_core, key, value)
+end
diff --git a/test/mave_core/audio_description/media_test.exs b/test/mave_core/audio_description/media_test.exs
new file mode 100644
index 0000000..84d4f3e
--- /dev/null
+++ b/test/mave_core/audio_description/media_test.exs
@@ -0,0 +1,177 @@
+defmodule MaveCore.AudioDescription.MediaTest do
+  use ExUnit.Case, async: true
+
+  alias MaveCore.AudioDescription.{Cues, Mix, Prompts, Wav}
+
+  describe "Cues" do
+    test "parses timestamps in several formats" do
+      assert Cues.parse_timestamp("00:01:02.500") == 62.5
+      assert Cues.parse_timestamp("01:02") == 62.0
+      assert Cues.parse_timestamp("3,25") == 3.25
+      assert Cues.parse_timestamp(4) == 4.0
+      assert Cues.parse_timestamp("soon") == nil
+      assert Cues.parse_timestamp(-1) == nil
+    end
+
+    test "normalizes cues: sorts, merges equal starts, repairs ends and clamps" do
+      cues =
+        Cues.normalize(
+          [
+            %{"start" => "00:00:04.000", "end" => "00:00:03.000", "text" => " A  door "},
+            %{"start" => 1.0, "end" => 6.0, "text" => "Kitchen."},
+            %{"start" => 1.02, "end" => 2.0, "text" => "Dishes."},
+            %{"start" => 9.8, "end" => 12.0, "text" => "End."},
+            %{"start" => 11.0, "end" => 12.0, "text" => "Past the end."},
+            %{"start" => 2.0, "text" => ""}
+          ],
+          10
+        )
+
+      assert cues == [
+               %{start: 1.0, end: 4.0, text: "Kitchen. Dishes."},
+               %{start: 4.0, end: 5.0, text: "A door"},
+               %{start: 9.8, end: 10.0, text: "End."}
+             ]
+    end
+
+    test "writes a descriptions WebVTT and escapes markup" do
+      vtt = Cues.to_vtt([%{start: 1.0, end: 2.5, text: "Tom & <Jerry>"}], "nl")
+
+      assert vtt ==
+               "WEBVTT\nKind: descriptions\nLanguage: nl\n\n1\n00:00:01.000 --> 00:00:02.500\nTom &amp; &lt;Jerry&gt;\n"
+    end
+
+    test "round-trips through JSON with the scene" do
+      cues = [%{start: 1.0, end: 2.0, text: "a", scene: %{start: 0.0, end: 3.0}}]
+
+      assert cues |> Cues.to_json() |> Jason.encode!() |> Jason.decode!() |> Cues.from_json() ==
+               cues
+    end
+  end
+
+  describe "Wav" do
+    test "decodes 16-bit stereo WAV, downmixes and keeps the rate" do
+      samples =
+        <<1000::little-signed-16, 3000::little-signed-16, -200::little-signed-16,
+          -400::little-signed-16>>
+
+      {:ok, {mono, rate}} = Wav.decode(wav(samples, 2, 48_000, 16))
+
+      assert rate == 48_000
+      assert mono == <<2000::little-signed-16, -300::little-signed-16>>
+    end
+
+    test "decodes 32-bit float WAV" do
+      {:ok, {mono, 24_000}} = Wav.decode(wav(<<0.5::little-float-32>>, 1, 24_000, 32, 3))
+      assert mono == <<16_384::little-signed-16>>
+    end
+
+    test "treats bytes without a header as raw 24 kHz PCM" do
+      assert Wav.decode(<<1, 0, 2, 0, 3>>) == {:ok, {<<1, 0, 2, 0>>, 24_000}}
+    end
+
+    test "resamples linearly" do
+      input = for s <- [0, 100, 200, 300], into: <<>>, do: <<s::little-signed-16>>
+      assert Wav.resample(input, 48_000, 24_000) == <<0::little-signed-16, 200::little-signed-16>>
+    end
+
+    test "trims near-silence and keeps padding" do
+      quiet = :binary.copy(<<0, 0>>, 100)
+      loud = :binary.copy(<<1000::little-signed-16>>, 10)
+      trimmed = Wav.trim_silence(quiet <> loud <> quiet, 1000, 400, 0.005)
+
+      assert byte_size(trimmed) == (10 + 5 + 5) * 2
+      assert Wav.trim_silence(quiet) == <<>>
+    end
+
+    test "renders clips on a timeline with silence in between" do
+      clip = <<7::little-signed-16, 7::little-signed-16>>
+
+      rendered =
+        [%{index: 0, start: 1, length: 2}, %{index: 1, start: 4, length: 2}]
+        |> Wav.render(8, fn _ -> clip end)
+        |> IO.iodata_to_binary()
+
+      assert for(<<s::little-signed-16 <- rendered>>, do: s) == [0, 7, 7, 0, 7, 7, 0, 0]
+    end
+  end
+
+  describe "Mix" do
+    test "ducks with a trapezoid per interval" do
+      assert Mix.duck_expression([]) == "1"
+
+      assert Mix.duck_expression([%{start: 2.0, end: 4.0}, %{start: 6.0, end: 7.0}]) ==
+               "1-0.800*max(clip(min((t-1.700)/0.300,(4.300-t)/0.300),0,1)," <>
+                 "clip(min((t-5.700)/0.300,(7.300-t)/0.300),0,1))"
+    end
+
+    test "mixes the original audio with the description track" do
+      args = Mix.ffmpeg_args("orig.mp3", "desc.pcm", "out.mp3", [%{start: 1.0, end: 2.0}], 10.0)
+
+      assert [
+               "-y",
+               "-v",
+               "error",
+               "-i",
+               "orig.mp3",
+               "-f",
+               "s16le",
+               "-ar",
+               "24000",
+               "-ac",
+               "1",
+               "-i",
+               "desc.pcm" | _
+             ] =
+               args
+
+      filter = Enum.at(args, Enum.find_index(args, &(&1 == "-filter_complex")) + 1)
+      assert filter =~ "volume='1-0.800*clip("
+      assert filter =~ "amix=inputs=2:duration=first:normalize=0,alimiter=limit=0.97[out]"
+      assert List.last(args) == "out.mp3"
+    end
+
+    test "pads the descriptions to the video length when there is no original audio" do
+      args = Mix.ffmpeg_args(nil, "desc.pcm", "out.mp3", [], 12.5)
+      refute "orig.mp3" in args
+      assert Enum.any?(args, &(&1 =~ "apad=whole_dur=12.500"))
+    end
+  end
+
+  describe "Prompts" do
+    test "puts the duration and timing into the describer's instructions" do
+      text = Prompts.describe_instruction(12.0, "Scenes ...")
+      assert text =~ "The video is 12.000 seconds long"
+      assert String.ends_with?(text, "Scenes ...")
+      refute text =~ "\n\n"
+    end
+
+    test "builds the translation request with time slots" do
+      {instruction, input} =
+        Prompts.translation_request([%{start: 1.0, end: 2.26, text: "A door opens."}], "nl")
+
+      assert instruction =~ "into Dutch (nl)"
+      assert input == [%{"i" => 0, "seconds" => 1.3, "text" => "A door opens."}]
+    end
+
+    test "requires exactly one translation per cue" do
+      assert Prompts.check_translations([" Een deur. "], 1) == {:ok, ["Een deur."]}
+      assert {:error, _} = Prompts.check_translations(["a", ""], 2)
+      assert {:error, _} = Prompts.check_translations(["a"], 2)
+    end
+  end
+
+  defp wav(data, channels, rate, bits, tag \\ 1) do
+    block = channels * div(bits, 8)
+
+    fmt =
+      <<tag::little-16, channels::little-16, rate::little-32, rate * block::little-32,
+        block::little-16, bits::little-16>>
+
+    body =
+      <<"WAVE", "fmt ", byte_size(fmt)::little-32, fmt::binary, "data",
+        byte_size(data)::little-32, data::binary>>
+
+    <<"RIFF", byte_size(body)::little-32, body::binary>>
+  end
+end
diff --git a/test/mave_core/audio_description/timeline_test.exs b/test/mave_core/audio_description/timeline_test.exs
new file mode 100644
index 0000000..53eb9cf
--- /dev/null
+++ b/test/mave_core/audio_description/timeline_test.exs
@@ -0,0 +1,281 @@
+defmodule MaveCore.AudioDescription.TimelineTest do
+  use ExUnit.Case, async: true
+
+  alias MaveCore.AudioDescription.Timeline
+
+  # 1 sample = 1 ms keeps the numbers readable.
+  @sr 1000
+
+  defp i(start, stop), do: %{start: start * 1.0, end: stop * 1.0}
+
+  describe "speech_from_words/2" do
+    test "merges close words, pads and clamps" do
+      speech =
+        Timeline.speech_from_words(
+          [i(0.72, 1.28), i(1.28, 2.68), i(4.82, 5.38), i(5.6, 6.68), i(9.9, 10.4)],
+          10
+        )
+
+      assert speech == [i(0.57, 2.83), i(4.67, 6.83), i(9.75, 10)]
+    end
+
+    test "returns nothing for silence" do
+      assert Timeline.speech_from_words([], 30) == []
+    end
+  end
+
+  describe "free_gaps/2" do
+    test "returns the pauses between speech" do
+      assert Timeline.free_gaps([i(2, 4), i(6, 7)], 10) == [i(0, 2), i(4, 6), i(7, 10)]
+    end
+
+    test "is the whole video without speech, and empty when speech never stops" do
+      assert Timeline.free_gaps([], 30) == [i(0, 30)]
+      assert Timeline.free_gaps([i(0, 30)], 30) == []
+    end
+  end
+
+  describe "plan_timeline/5" do
+    @speech [%{start: 2.0, end: 4.0}, %{start: 6.0, end: 9.0}]
+
+    test "keeps a description that fits its pause, without ducking" do
+      t = Timeline.plan_timeline([cue(0.5, 1.5, "A door opens.")], [1200], @speech, 10, @sr)
+
+      assert t.placements == [%{index: 0, start: 500, length: 1200}]
+      assert t.cues == [cue(0.5, 1.7, "A door opens.")]
+      assert t.ducks == []
+      assert t.total_samples == 10_000
+    end
+
+    test "moves a description into a nearby pause when the whole clip fits there" do
+      t = Timeline.plan_timeline([cue(3.5, 5, "She sits down.")], [1500], @speech, 10, @sr)
+
+      assert hd(t.cues) == cue(4, 5.5, "She sits down.")
+      assert t.ducks == []
+    end
+
+    test "plays over speech and ducks when no pause fits" do
+      t = Timeline.plan_timeline([cue(6.5, 9, "Long description.")], [3000], @speech, 10, @sr)
+
+      assert hd(t.cues) == cue(6.5, 9.5, "Long description.")
+      assert t.ducks == [i(6.5, 9.5)]
+    end
+
+    test "never overlaps two descriptions and keeps the clip inside the video" do
+      t =
+        Timeline.plan_timeline(
+          [cue(0, 1, "a"), cue(0.5, 1, "b"), cue(9.5, 10, "c")],
+          [1500, 1000, 2000],
+          [],
+          10,
+          @sr
+        )
+
+      assert Enum.map(t.cues, &{&1.start, &1.end}) == [{0.0, 1.5}, {1.65, 2.65}, {8.0, 10.0}]
+      assert t.ducks == []
+    end
+
+    test "skips descriptions without speech audio" do
+      t = Timeline.plan_timeline([cue(1, 2, "a")], [0], [], 10, @sr)
+      assert t.placements == []
+      assert t.cues == []
+    end
+  end
+
+  describe "plan_timeline/5 with scenes" do
+    @speech [
+      %{start: 4.35, end: 8.91},
+      %{start: 9.43, end: 10.41},
+      %{start: 11.97, end: 15.59}
+    ]
+    @lawn %{start: 7.88, end: 10.24}
+
+    test "never moves a description into a pause after its scene has ended" do
+      t =
+        Timeline.plan_timeline(
+          [Map.put(cue(8, 9.5, "An un-mowed lawn."), :scene, @lawn)],
+          [1600],
+          @speech,
+          27,
+          @sr
+        )
+
+      assert hd(t.cues).start == 8.0
+      assert t.ducks == [i(8, 9.6)]
+    end
+
+    test "uses a pause inside the scene when the clip fits there" do
+      scene = %{start: 10.24, end: 13.28}
+      t = Timeline.plan_timeline([cue(11.5, 12.5, "A messy attic.")], [1200], @speech, 27, @sr)
+      assert hd(t.cues) == cue(10.77, 11.97, "A messy attic.")
+
+      in_scene =
+        Timeline.plan_timeline(
+          [Map.put(cue(10.3, 12, "A messy attic."), :scene, scene)],
+          [1200],
+          @speech,
+          27,
+          @sr
+        )
+
+      assert hd(in_scene.cues).start >= scene.start
+      assert in_scene.ducks == []
+    end
+
+    test "skips a description that earlier long ones pushed out of its scene" do
+      t =
+        Timeline.plan_timeline(
+          [
+            Map.put(cue(0, 2, "A very long first description."), :scene, i(0, 3)),
+            Map.put(cue(3, 4, "Second shot."), :scene, i(3, 4)),
+            Map.put(cue(4, 9, "Third shot."), :scene, i(4, 10))
+          ],
+          [5000, 1000, 1000],
+          [],
+          10,
+          @sr
+        )
+
+      assert t.skipped == [1]
+      assert Enum.map(t.cues, & &1.text) == ["A very long first description.", "Third shot."]
+      assert Enum.at(t.cues, 1).start == 5.15
+    end
+
+    test "speaks at least half of the clip during its scene" do
+      t =
+        Timeline.plan_timeline([Map.put(cue(1.8, 2, "a"), :scene, i(0, 2))], [1000], [], 10, @sr)
+
+      assert hd(t.cues).start <= 1.5
+    end
+  end
+
+  test "shots_from_cuts/2 turns cut times into shot intervals" do
+    assert Timeline.shots_from_cuts([5.28, 7.88, 30], 10) == [
+             i(0, 5.28),
+             i(5.28, 7.88),
+             i(7.88, 10)
+           ]
+
+    assert Timeline.shots_from_cuts([], 10) == [i(0, 10)]
+  end
+
+  describe "timing_prompt/4" do
+    test "lists numbered scenes, speech and numbered pauses with word budgets" do
+      assert Timeline.timing_prompt([i(1, 3)], [i(0, 2), i(2, 5)], 5) ==
+               Enum.join(
+                 [
+                   "Scenes (index: seconds), from cut detection; quick cuts are grouped into one scene:",
+                   "S0: 0.00-2.00",
+                   "S1: 2.00-5.00",
+                   "Speech (seconds): 1.00-3.00",
+                   "Pauses without speech (index: seconds, length, max words):",
+                   "P0: 0.00-1.00 (1.0 s, max 2 words)",
+                   "P1: 3.00-5.00 (2.0 s, max 4 words)"
+                 ],
+                 "\n"
+               )
+    end
+
+    test "budgets about 2.5 words per second with a small margin" do
+      assert Timeline.word_budget(0.5) == 0
+      assert Timeline.word_budget(1.5) == 3
+      assert Timeline.word_budget(4) == 9
+    end
+
+    test "with a window lists only overlapping scenes and pauses, with their global numbers" do
+      scenes = [i(0, 5), i(5, 10), i(10, 15)]
+      speech = [i(1, 4), i(6, 9), i(11, 14)]
+      text = Timeline.timing_prompt(speech, scenes, 15, i(5, 10))
+
+      assert text =~ "S1: 5.00-10.00"
+      refute text =~ "S0:"
+      refute text =~ "S2:"
+      assert text =~ "P1: 4.00-6.00"
+      assert text =~ "P2: 9.00-11.00"
+      refute text =~ "P0:"
+      assert text =~ "Speech (seconds): 6.00-9.00"
+    end
+  end
+
+  describe "snap_cues/3" do
+    @gaps [%{start: 0.0, end: 0.5}, %{start: 2.8, end: 4.4}, %{start: 10.4, end: 12.0}]
+    @scenes [%{start: 0.0, end: 5.0}, %{start: 7.9, end: 10.2}, %{start: 10.2, end: 13.0}]
+
+    test "moves a cue into its pause when the pause overlaps its scene" do
+      assert Timeline.snap_cues(
+               [%{start: 1.07, end: 2.5, text: "Kitchen.", pause: 1, scene: 0}],
+               @gaps,
+               @scenes
+             ) == [%{start: 2.8, end: 3.3, text: "Kitchen.", scene: i(0, 5)}]
+    end
+
+    test "ignores a pause outside the scene, so the description stays in sync" do
+      [cue] =
+        Timeline.snap_cues(
+          [%{start: 10.42, end: 11.9, text: "A lawn.", pause: 2, scene: 1}],
+          @gaps,
+          @scenes
+        )
+
+      assert cue.start < 10.2
+      assert cue.start >= 7.9
+      assert cue.scene == i(7.9, 10.2)
+    end
+
+    test "finds the scene from the start time when the model gave none" do
+      assert Timeline.snap_cues(
+               [%{start: 8.5, end: 9.5, text: "x", pause: -1, scene: nil}],
+               @gaps,
+               @scenes
+             ) == [%{start: 8.5, end: 9.5, text: "x", scene: i(7.9, 10.2)}]
+    end
+  end
+
+  describe "plan_stills/4" do
+    test "takes at least one still per shot and one per ~3 s in longer shots, never on a cut" do
+      assert Timeline.plan_stills([i(0, 1), i(1, 10)], 10) == [
+               %{scene: 0, time: 0.5},
+               %{scene: 1, time: 2.5},
+               %{scene: 1, time: 5.5},
+               %{scene: 1, time: 8.5}
+             ]
+    end
+
+    test "covers a video without cuts as one shot" do
+      assert Timeline.plan_stills([], 6) == [%{scene: 0, time: 1.5}, %{scene: 0, time: 4.5}]
+    end
+
+    test "batches stills to the provider's image limit, in order" do
+      stills = Timeline.plan_stills([i(0, 75)], 75)
+      batches = Timeline.batch_stills(stills, 12)
+
+      assert Enum.map(batches, &length/1) == [12, 12, 1]
+      assert List.flatten(batches) == stills
+    end
+
+    test "takes a still from every cut, labelled with its scene" do
+      cuts = [i(0, 1.2), i(1.2, 2.4), i(2.4, 3.6)]
+      scenes = Timeline.scenes_from_shots(cuts)
+
+      assert Timeline.plan_stills(scenes, 3.6, 3, cuts) == [
+               %{scene: 0, time: 0.6},
+               %{scene: 0, time: 1.8},
+               %{scene: 0, time: 3.0}
+             ]
+    end
+  end
+
+  describe "scenes_from_shots/2" do
+    test "groups quick cuts into scenes of at least 3 s and keeps long shots as they are" do
+      cuts = [i(0, 1.3), i(1.3, 2.6), i(2.6, 3.9), i(3.9, 10), i(10, 11.2)]
+      assert Timeline.scenes_from_shots(cuts) == [i(0, 3.9), i(3.9, 11.2)]
+    end
+
+    test "keeps a single short video as one scene" do
+      assert Timeline.scenes_from_shots([i(0, 2)]) == [i(0, 2)]
+      assert Timeline.scenes_from_shots([]) == []
+    end
+  end
+
+  defp cue(start, stop, text), do: %{start: start * 1.0, end: stop * 1.0, text: text}
+end
diff --git a/test/mave_core/audio_description_test.exs b/test/mave_core/audio_description_test.exs
new file mode 100644
index 0000000..ac8edd5
--- /dev/null
+++ b/test/mave_core/audio_description_test.exs
@@ -0,0 +1,71 @@
+defmodule MaveCore.AudioDescriptionTest do
+  use MaveCore.DataCase, async: false
+
+  alias MaveCore.Accounts
+  alias MaveCore.AudioDescription
+  alias MaveCore.Repo
+  alias MaveCore.Spaces
+  alias MaveCore.Spaces.Space
+
+  defmodule PaidOnly do
+    @behaviour MaveCore.UsageLimits
+
+    def can_create_video_embed?(_space), do: :ok
+    def can_add_space_member?(_space, _role), do: :ok
+    def can_use_audio_description?(_space), do: {:error, :paid_plan_required}
+  end
+
+  setup do
+    old_backend = Application.get_env(:mave_core, :usage_limits_backend)
+
+    on_exit(fn ->
+      if old_backend,
+        do: Application.put_env(:mave_core, :usage_limits_backend, old_backend),
+        else: Application.delete_env(:mave_core, :usage_limits_backend)
+    end)
+
+    {:ok, user} = Accounts.create_user("ad-#{System.unique_integer([:positive])}@example.com")
+    %{space: user.current_space_membership.space}
+  end
+
+  test "spaces opt in; without a host policy every space may", %{space: space} do
+    refute space.audio_description_enabled
+    assert AudioDescription.run_input(space) == nil
+
+    assert {:ok, %Space{audio_description_enabled: true} = space} =
+             Spaces.update_space_features(space, %{audio_description_enabled: true})
+
+    assert AudioDescription.run_input(space) == %{"languages" => ["en", "nl"]}
+    assert Repo.get!(Space, space.id).audio_description_enabled
+  end
+
+  test "the host decides who may turn it on", %{space: space} do
+    Application.put_env(:mave_core, :usage_limits_backend, PaidOnly)
+
+    assert {:error, :paid_plan_required} =
+             Spaces.update_space_features(space, %{audio_description_enabled: true})
+
+    refute Repo.get!(Space, space.id).audio_description_enabled
+  end
+
+  test "a space that lost access stops getting descriptions and can still turn them off", %{
+    space: space
+  } do
+    {:ok, space} = Spaces.update_space_features(space, %{audio_description_enabled: true})
+    Application.put_env(:mave_core, :usage_limits_backend, PaidOnly)
+
+    refute Spaces.audio_description_active?(space)
+    assert AudioDescription.run_input(space) == nil
+
+    assert {:ok, %Space{audio_description_enabled: false}} =
+             Spaces.update_space_features(space, %{audio_description_enabled: false})
+  end
+
+  test "English is always described first" do
+    assert AudioDescription.requested_languages(%{}) == []
+
+    assert AudioDescription.requested_languages(%{
+             "audio_description" => %{"languages" => ["nl"]}
+           }) == ["en", "nl"]
+  end
+end
diff --git a/test/mave_core/flow/steps/audio_description_steps_test.exs b/test/mave_core/flow/steps/audio_description_steps_test.exs
new file mode 100644
index 0000000..5f0328f
--- /dev/null
+++ b/test/mave_core/flow/steps/audio_description_steps_test.exs
@@ -0,0 +1,427 @@
+defmodule MaveCore.Flow.Steps.AudioDescriptionStepsTest do
+  use ExUnit.Case, async: false
+
+  alias MaveCore.Flow.{Definition, Presets, StepRegistry}
+
+  alias MaveCore.Flow.Steps.{
+    AiDescribeVideoStep,
+    AiSpeakDescriptionsStep,
+    AiTranslateDescriptionsStep,
+    MediaBuildHlsMasterStep,
+    MediaDetectScenesStep,
+    MediaMixAudioDescriptionStep
+  }
+
+  alias MaveCore.TestSupport.FlowStorageAdapterStub, as: Storage
+
+  @space "ubg50"
+  @embed "LeDE9v86ye"
+  @bucket "space-ubg50"
+  @requested %{"languages" => ["en", "nl"]}
+
+  defmodule ChatStub do
+    @moduledoc false
+
+    # Describes every batch of stills with one cue per scene and translates by prefixing.
+    def chat_json(system, content, opts) do
+      send(Process.get(:ad_test_pid) || self(), {:chat, system, content})
+
+      case opts[:schema]["required"] do
+        ["duration_seconds", "cues"] ->
+          images = Enum.count(content, &(&1["type"] == "image_url"))
+          if images == 0, do: raise("no stills sent")
+
+          {:ok,
+           %{
+             "duration_seconds" => 8,
+             "cues" => [
+               cue(0, 0, "00:00:00.200", "00:00:01.000", "A red screen."),
+               cue(1, -1, "00:00:05.500", "00:00:06.500", "It turns blue.")
+             ]
+           }}
+
+        ["translations"] ->
+          [%{"text" => json}] = content
+          {:ok, %{"translations" => json |> Jason.decode!() |> Enum.map(&"NL #{&1["text"]}")}}
+      end
+    end
+
+    defp cue(shot, pause, start, stop, text),
+      do: %{
+        "shot" => shot,
+        "pause" => pause,
+        "max_words" => 4,
+        "start" => start,
+        "end" => stop,
+        "text" => text
+      }
+  end
+
+  defmodule SpeechStub do
+    @moduledoc false
+
+    # One second of a 440 Hz tone as a 24 kHz WAV.
+    def speak(_text, language) do
+      send(test_pid(), {:speak, language})
+
+      pcm =
+        for i <- 0..23_999, into: <<>> do
+          <<round(8000 * :math.sin(i * 2 * :math.pi() * 440 / 24_000))::little-signed-16>>
+        end
+
+      size = byte_size(pcm)
+
+      {:ok,
+       <<"RIFF", size + 36::little-32, "WAVEfmt ", 16::little-32, 1::little-16, 1::little-16,
+         24_000::little-32, 48_000::little-32, 2::little-16, 16::little-16, "data",
+         size::little-32, pcm::binary>>}
+    end
+
+    # Speech runs in tasks; report to the test process that started them.
+    defp test_pid, do: Process.get(:ad_test_pid) || List.last(Process.get(:"$callers", [self()]))
+  end
+
+  setup do
+    old = %{
+      storage: Application.get_env(:mave_core, :flow_storage_adapter),
+      direct: Application.get_env(:mave_core, :flow_direct_storage_ffmpeg_input),
+      ad: Application.get_env(:mave_core, :audio_description)
+    }
+
+    Application.put_env(:mave_core, :flow_storage_adapter, Storage)
+    Application.put_env(:mave_core, :flow_direct_storage_ffmpeg_input, false)
+
+    Application.put_env(:mave_core, :audio_description,
+      chat_provider: ChatStub,
+      speech_provider: SpeechStub
+    )
+
+    Storage.reset!()
+
+    on_exit(fn ->
+      restore(:flow_storage_adapter, old.storage)
+      restore(:flow_direct_storage_ffmpeg_input, old.direct)
+      restore(:audio_description, old.ad)
+    end)
+
+    :ok
+  end
+
+  test "the publishing presets contain optional background steps that nothing waits for" do
+    for slug <- ["publish_default", "publish_local", "publish_remote", "publish_remote_local"] do
+      {:ok, preset} = Presets.fetch(slug)
+      definition = preset["definition"]
+      assert :ok = Definition.validate(definition)
+      steps = definition["steps"]
+
+      ids =
+        ~w(detect_scenes describe_video translate_descriptions_nl speak_descriptions_en
+           speak_descriptions_nl mix_audio_description_en mix_audio_description_nl)
+
+      for id <- ids do
+        step = Enum.find(steps, &(&1["id"] == id))
+        assert %{"required" => false, "lane" => "background"} = step
+        assert StepRegistry.known_type?(step["type"])
+        refute Enum.any?(steps, &(id in Map.get(&1, "depends_on", []) and &1["id"] not in ids))
+      end
+    end
+
+    assert StepRegistry.executor_for("media.detect_scenes") == :flame
+    assert StepRegistry.executor_for("media.mix_audio_description") == :flame
+    assert StepRegistry.executor_for("ai.describe_video") == :inline
+  end
+
+  test "every step skips itself when the run didn't ask for audio description" do
+    context = %{run_input: base_input(), dependency_outputs: %{}}
+
+    for {module, params} <- [
+          {MediaDetectScenesStep, %{}},
+          {AiDescribeVideoStep, %{}},
+          {AiTranslateDescriptionsStep, %{"language" => "nl"}},
+          {AiSpeakDescriptionsStep, %{"language" => "en"}},
+          {MediaMixAudioDescriptionStep, %{"language" => "en"}}
+        ] do
+      assert {:ok, %{"status" => "skipped", "reason" => "not_requested"}, []} =
+               module.run(%{"id" => "step", "params" => params}, context)
+    end
+  end
+
+  test "videos over the limit are skipped with their length" do
+    context = %{
+      run_input: Map.put(base_input(), "audio_description", @requested),
+      dependency_outputs: %{"inspect_media" => %{"duration" => 601.0, "has_video" => true}}
+    }
+
+    assert {:ok, output, []} = MediaDetectScenesStep.run(%{"id" => "detect_scenes"}, context)
+
+    assert %{
+             "status" => "skipped",
+             "reason" => "video_too_long",
+             "video_duration_seconds" => 601.0,
+             "max_duration_seconds" => 600
+           } = output
+  end
+
+  test "the HLS master marks audio descriptions for assistive technology" do
+    outputs = %{
+      "hls_sd" => %{
+        "step_type" => "media.package_hls_variant",
+        "status" => "ok",
+        "codec" => "h264",
+        "size" => "sd",
+        "playlist_path" => "h264_sd_hls/playlist.m3u8"
+      },
+      "hls_audio" => %{
+        "step_type" => "media.package_hls_audio",
+        "status" => "ok",
+        "audio_tracks" => [
+          %{
+            "id" => "default",
+            "label" => "Original",
+            "language" => "en",
+            "default" => true,
+            "hls_playlist" => "audio_hls/playlist.m3u8"
+          }
+        ]
+      },
+      "mix_audio_description_nl" => %{
+        "step_type" => "media.mix_audio_description",
+        "status" => "ok",
+        "audio_track" => %{
+          "id" => "audio_description_nl",
+          "label" => "Dutch (audio description)",
+          "language" => "nl",
+          "default" => false,
+          "hls_playlist" => "audio_description_nl_hls/playlist.m3u8",
+          "characteristics" => "public.accessibility.describes-video"
+        }
+      }
+    }
+
+    assert {:ok, %{"key" => key}, _} =
+             MediaBuildHlsMasterStep.run(%{"id" => "hls_master"}, %{
+               run_input: base_input(),
+               dependency_outputs: outputs
+             })
+
+    {:ok, playlist} = Storage.get(@bucket, key, nil)
+
+    assert playlist =~
+             ~s|#EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="audio",NAME="Dutch (audio description)",LANGUAGE="nl",DEFAULT=NO,AUTOSELECT=YES,CHARACTERISTICS="public.accessibility.describes-video",CHANNELS="2",URI="audio_description_nl_hls/playlist.m3u8"|
+
+    assert playlist =~ ~s(NAME="Original",LANGUAGE="en",DEFAULT=YES,AUTOSELECT=YES,CHANNELS="2")
+  end
+
+  @tag :integration
+  test "turns a video into a ducked full mix and descriptions VTT per language" do
+    if System.find_executable("ffmpeg") == nil, do: flunk("ffmpeg is required")
+    Process.put(:ad_test_pid, self())
+
+    {video, audio} = media_fixtures()
+    input = Map.put(base_input(), "audio_description", @requested)
+    Storage.put_public(@bucket, "#{@embed}/audio.mp3", audio, "audio/mpeg", nil)
+
+    transcript = %{
+      "segments" => [%{"start" => 1.0, "end" => 3.0}, %{"start" => 4.5, "end" => 7.5}]
+    }
+
+    Storage.put_public(
+      @bucket,
+      "#{@embed}/subtitle.json",
+      Jason.encode!(transcript),
+      "application/json",
+      nil
+    )
+
+    base_outputs = %{
+      "source" => %{"space_hash" => @space, "embed_hash" => @embed, "version" => 0},
+      "inspect_media" => %{"duration" => 8.0, "has_video" => true, "has_audio" => true},
+      "transcribe_audio" => %{"status" => "ok", "subtitle_json_key" => "#{@embed}/subtitle.json"},
+      "transcode_audio" => %{
+        "status" => "ok",
+        "bucket" => @bucket,
+        "key" => "#{@embed}/audio.mp3",
+        "uri" => "s3://#{@bucket}/#{@embed}/audio.mp3"
+      }
+    }
+
+    # 1. Scenes and stills from the video itself.
+    assert {:ok, scenes, []} =
+             MediaDetectScenesStep.run(%{"id" => "detect_scenes"}, %{
+               run_input:
+                 Map.merge(input, %{"source_body" => video, "source_content_type" => "video/mp4"}),
+               dependency_outputs: base_outputs
+             })
+
+    assert %{"status" => "ok", "scene_count" => 2, "still_count" => 2, "cut_count" => 1} = scenes
+
+    # 2. English cues, pinned to their scenes around the measured speech.
+    outputs = Map.put(base_outputs, "detect_scenes", scenes)
+
+    assert {:ok, english, []} =
+             AiDescribeVideoStep.run(%{"id" => "describe_video"}, %{
+               run_input: input,
+               dependency_outputs: outputs
+             })
+
+    assert %{"status" => "ok", "cue_count" => 2, "language" => "en"} = english
+    assert_received {:chat, system, _content}
+    assert system =~ "S1: 4."
+    assert system =~ "Speech (seconds): 0.85-3.15, 4.35-7.65"
+
+    # 3. Dutch from the English cues.
+    outputs = Map.put(outputs, "describe_video", english)
+
+    assert {:ok, dutch, []} =
+             AiTranslateDescriptionsStep.run(
+               %{"id" => "translate_descriptions_nl", "params" => %{"language" => "nl"}},
+               %{run_input: input, dependency_outputs: outputs}
+             )
+
+    assert %{"status" => "ok", "language" => "nl", "cue_count" => 2} = dutch
+
+    # 4. Speech per language, then the mix.
+    outputs = Map.put(outputs, "translate_descriptions_nl", dutch)
+
+    for {language, cues_step} <- [{"en", "describe_video"}, {"nl", "translate_descriptions_nl"}] do
+      assert {:ok, speech, []} =
+               AiSpeakDescriptionsStep.run(
+                 %{
+                   "id" => "speak_descriptions_#{language}",
+                   "params" => %{"language" => language, "source_step_id" => cues_step}
+                 },
+                 %{run_input: input, dependency_outputs: outputs}
+               )
+
+      assert %{"status" => "ok", "clips" => [_, _]} = speech
+
+      assert {:ok, mix, [mp3_artifact, vtt_artifact]} =
+               MediaMixAudioDescriptionStep.run(
+                 %{
+                   "id" => "mix_audio_description_#{language}",
+                   "params" => %{"language" => language}
+                 },
+                 %{
+                   run_input: input,
+                   dependency_outputs: Map.put(outputs, "speak_descriptions_#{language}", speech)
+                 }
+               )
+
+      assert %{"status" => "ok", "cue_count" => 2, "ducked_cue_count" => 2} = mix
+      assert mix["audio_track"]["characteristics"] == "public.accessibility.describes-video"
+
+      assert mix["audio_track"]["hls_playlist"] ==
+               "audio_description_#{language}_hls/playlist.m3u8"
+
+      assert mp3_artifact.uri == "s3://#{@bucket}/#{@embed}/audio_description_#{language}.mp3"
+      assert vtt_artifact.uri == "s3://#{@bucket}/#{@embed}/descriptions_#{language}.vtt"
+
+      {:ok, mp3} = Storage.get(@bucket, "#{@embed}/audio_description_#{language}.mp3", nil)
+      assert Storage.public?(@bucket, "#{@embed}/audio_description_#{language}.mp3", nil)
+      assert duration(mp3) > 7.5
+
+      {:ok, vtt} = Storage.get(@bucket, "#{@embed}/descriptions_#{language}.vtt", nil)
+      assert vtt =~ "WEBVTT\nKind: descriptions\nLanguage: #{language}\n"
+      assert vtt =~ if(language == "nl", do: "NL A red screen.", else: "A red screen.")
+
+      assert {:ok, _} =
+               Storage.get(
+                 @bucket,
+                 "#{@embed}/audio_description_#{language}_hls/playlist.m3u8",
+                 nil
+               )
+    end
+
+    # A retry reuses the clips it already spoke.
+    assert_received {:speak, "en"}
+
+    {:ok, _, []} =
+      AiSpeakDescriptionsStep.run(
+        %{"id" => "speak_descriptions_en", "params" => %{"language" => "en"}},
+        %{run_input: input, dependency_outputs: outputs}
+      )
+
+    flush_speak()
+    refute_received {:speak, _}
+  end
+
+  defp flush_speak do
+    receive do
+      {:speak, _} -> flush_speak()
+    after
+      0 -> :ok
+    end
+  end
+
+  # An 8 s video that cuts from red to blue at 4 s, with a tone, and its audio as MP3.
+  defp media_fixtures do
+    dir = Path.join(System.tmp_dir!(), "ad-fixture-#{System.unique_integer([:positive])}")
+    File.mkdir_p!(dir)
+    on_exit(fn -> File.rm_rf(dir) end)
+    video = Path.join(dir, "video.mp4")
+    audio = Path.join(dir, "audio.mp3")
+
+    {_, 0} =
+      System.cmd("ffmpeg", [
+        "-v",
+        "error",
+        "-y",
+        "-f",
+        "lavfi",
+        "-i",
+        "color=c=red:s=320x240:d=4:r=25",
+        "-f",
+        "lavfi",
+        "-i",
+        "color=c=blue:s=320x240:d=4:r=25",
+        "-f",
+        "lavfi",
+        "-i",
+        "sine=frequency=330:duration=8",
+        "-filter_complex",
+        "[0:v][1:v]concat=n=2:v=1:a=0[v]",
+        "-map",
+        "[v]",
+        "-map",
+        "2:a",
+        "-c:v",
+        "libx264",
+        "-pix_fmt",
+        "yuv420p",
+        "-c:a",
+        "aac",
+        video
+      ])
+
+    {_, 0} =
+      System.cmd("ffmpeg", ["-v", "error", "-y", "-i", video, "-vn", "-c:a", "libmp3lame", audio])
+
+    {File.read!(video), File.read!(audio)}
+  end
+
+  defp duration(mp3) do
+    path = Path.join(System.tmp_dir!(), "ad-check-#{System.unique_integer([:positive])}.mp3")
+    File.write!(path, mp3)
+
+    {out, 0} =
+      System.cmd("ffprobe", [
+        "-v",
+        "error",
+        "-show_entries",
+        "format=duration",
+        "-of",
+        "csv=p=0",
+        path
+      ])
+
+    File.rm(path)
+    out |> String.trim() |> String.to_float()
+  end
+
+  defp base_input do
+    %{"space_hash" => @space, "embed_hash" => @embed, "version" => 0, "region" => nil}
+  end
+
+  defp restore(key, nil), do: Application.delete_env(:mave_core, key)
+  defp restore(key, value), do: Application.put_env(:mave_core, key, value)
+end
diff --git a/test/mave_core_web/live/dashboard/settings/audio_description_setting_test.exs b/test/mave_core_web/live/dashboard/settings/audio_description_setting_test.exs
new file mode 100644
index 0000000..b9c5145
--- /dev/null
+++ b/test/mave_core_web/live/dashboard/settings/audio_description_setting_test.exs
@@ -0,0 +1,80 @@
+defmodule MaveCoreWeb.Live.Dashboard.Settings.AudioDescriptionSettingTest do
+  use MaveCoreWeb.ConnCase, async: false
+
+  import Phoenix.LiveViewTest
+
+  alias MaveCore.Accounts
+  alias MaveCore.Repo
+  alias MaveCore.Spaces.Space
+
+  defmodule PaidOnly do
+    @behaviour MaveCore.UsageLimits
+
+    def can_create_video_embed?(_space), do: :ok
+    def can_add_space_member?(_space, _role), do: :ok
+    def can_use_audio_description?(_space), do: {:error, :paid_plan_required}
+
+    def restriction_copy(:audio_description, :paid_plan_required),
+      do: %{notice: "Available on paid plans", error: "Upgrade to use audio description."}
+
+    def restriction_copy(_operation, _reason), do: %{}
+  end
+
+  setup do
+    old_backend = Application.get_env(:mave_core, :usage_limits_backend)
+
+    on_exit(fn ->
+      if old_backend,
+        do: Application.put_env(:mave_core, :usage_limits_backend, old_backend),
+        else: Application.delete_env(:mave_core, :usage_limits_backend)
+    end)
+
+    :ok
+  end
+
+  test "toggles audio description for the space", %{conn: conn} do
+    {conn, space} = authenticated_conn(conn)
+    {:ok, view, _html} = live(conn, "/settings")
+
+    assert has_element?(view, "#audio-description-feature")
+    refute has_element?(view, "#audio-description-notice")
+
+    view |> element("#audio-description-toggle") |> render_click()
+    assert Repo.get!(Space, space.id).audio_description_enabled
+
+    view |> element("#audio-description-toggle") |> render_click()
+    refute Repo.get!(Space, space.id).audio_description_enabled
+  end
+
+  test "shows the host's notice and keeps the toggle off when not allowed", %{conn: conn} do
+    {conn, space} = authenticated_conn(conn)
+    Application.put_env(:mave_core, :usage_limits_backend, PaidOnly)
+    {:ok, view, html} = live(conn, "/settings")
+
+    assert html =~ "Available on paid plans"
+    assert has_element?(view, "#audio-description-toggle.pointer-events-none")
+    refute Repo.get!(Space, space.id).audio_description_enabled
+  end
+
+  defp authenticated_conn(conn) do
+    email = "ad-settings-#{System.unique_integer([:positive])}@example.com"
+    {:ok, user} = Accounts.create_user(email)
+    login_token = Accounts.generate_user_login_token(user)
+    {:ok, {logged_in_user, persisted_login_token}} = Accounts.login_user(login_token)
+    session_token = Accounts.generate_user_session_token(persisted_login_token, logged_in_user)
+
+    conn =
+      conn
+      |> with_manage_host()
+      |> init_test_session(user_token: session_token)
+
+    {conn, logged_in_user.current_space_membership.space}
+  end
+
+  defp with_manage_host(conn) do
+    case System.get_env("MAVE_MANAGE_HOST") do
+      host when is_binary(host) and host != "" -> %{conn | host: host}
+      _ -> conn
+    end
+  end
+end

From 4815697304f2b07b8a3cfb21bbbe99a909290e6b Mon Sep 17 00:00:00 2001
From: David <hi@davidvanleeuwen.nl>
Date: Wed, 4 Nov 2026 12:02:46 +0100
Subject: [PATCH 2/2] Complete audio description processing and track
 management

Generate descriptions in the source language with a configurable fallback.
Add file menus for uploading, replacing, downloading and removing tracks.
Preserve manually managed descriptions when background work completes.
---
 assets/js/app.js                              |    2 +
 assets/js/hooks/file_menu.js                  |   89 ++
 docs/analytics_sessions.md                    |    7 +-
 docs/audio_description.md                     |   71 +-
 lib/mave_core/analytics/sessions.ex           |   53 +-
 lib/mave_core/assets.ex                       |  148 ++-
 lib/mave_core/assets/audio_description.ex     |   21 +-
 lib/mave_core/audio_description.ex            |   38 +-
 .../audio_description/mistral_speech.ex       |    6 +-
 lib/mave_core/audio_description/prompts.ex    |    4 +-
 lib/mave_core/embeds.ex                       |    7 +-
 lib/mave_core/embeds/manifest_publisher.ex    |   22 +-
 lib/mave_core/flow.ex                         |   33 +-
 lib/mave_core/flow/presets.ex                 |   62 +-
 .../flow/steps/ai_describe_video_step.ex      |   13 +-
 .../flow/steps/ai_speak_descriptions_step.ex  |   17 +-
 .../flow/steps/audio_description_support.ex   |   31 +-
 lib/mave_core/uploads.ex                      |   14 +-
 .../dashboard_components/settings.ex          |   32 +-
 ...controller.ex => media_file_controller.ex} |   49 +-
 lib/mave_core_web/dashboard_routes.ex         |   13 +
 .../live/dashboard/videos/show.ex             |   35 +-
 .../videos/video_settings_component.ex        | 1022 +++++++++++------
 lib/mave_core_web/router.ex                   |   18 +-
 ...261102100000_manage_audio_descriptions.exs |   33 +
 test/mave_core/analytics/sessions_test.exs    |   58 +-
 .../audio_description_publication_test.exs    |   64 ++
 test/mave_core/audio_description_test.exs     |   31 +-
 .../steps/audio_description_steps_test.exs    |  134 ++-
 .../api/upload/tusd_hooks_controller_test.exs |  182 ++-
 .../live/dashboard/data/index_test.exs        |   32 +-
 .../live/dashboard/videos/show_test.exs       |  186 ++-
 32 files changed, 1995 insertions(+), 532 deletions(-)
 create mode 100644 assets/js/hooks/file_menu.js
 rename lib/mave_core_web/controllers/dashboard/{subtitle_controller.ex => media_file_controller.ex} (64%)
 create mode 100644 priv/repo/migrations/20261102100000_manage_audio_descriptions.exs

diff --git a/assets/js/app.js b/assets/js/app.js
index 14d3eaf..2b93a2f 100644
--- a/assets/js/app.js
+++ b/assets/js/app.js
@@ -28,6 +28,7 @@ import topbar from "../vendor/topbar"
 import "@lottiefiles/lottie-player"
 import { ChartHook } from "./hooks/chart"
 import { cdn } from "./upload"
+import { FileMenuHook } from "./hooks/file_menu"
 
 let selectedEmbed = null
 
@@ -717,6 +718,7 @@ const liveSocket = new LiveSocket("/live", Socket, {
     draggable: DraggableEmbedHook,
     thumbnail_preview: ThumbnailPreviewHook,
     auto_open_file_picker: AutoOpenFilePickerHook,
+    file_menu: FileMenuHook,
     preserve_scroll: PreserveScrollHook,
   },
   uploaders: { cdn },
diff --git a/assets/js/hooks/file_menu.js b/assets/js/hooks/file_menu.js
new file mode 100644
index 0000000..1b74394
--- /dev/null
+++ b/assets/js/hooks/file_menu.js
@@ -0,0 +1,89 @@
+export const FileMenuHook = {
+  mounted() {
+    this.onClick = (event) => {
+      const trigger = event.target.closest("[data-file-menu-trigger='true']")
+      if (trigger && this.el.contains(trigger)) {
+        this.isOpen ? this.closeMenu() : this.openMenu(event.detail === 0)
+      } else if (event.target.closest("[role='menuitem']")) {
+        this.closeMenu()
+      }
+    }
+    this.onOutside = (event) => {
+      if (!this.el.contains(event.target)) this.closeMenu()
+    }
+    this.onKey = (event) => {
+      if (!this.isOpen) return
+      if (event.key === "Escape") {
+        event.preventDefault()
+        this.closeMenu(true)
+      } else if (event.key === "Tab") {
+        this.closeMenu()
+      } else if (["ArrowDown", "ArrowUp", "Home", "End"].includes(event.key)) {
+        event.preventDefault()
+        const items = [...this.panel.querySelectorAll("[role='menuitem']:not(:disabled)")]
+        const current = items.indexOf(document.activeElement)
+        const next = event.key === "Home" ? 0 : event.key === "End" ? items.length - 1 :
+          current < 0 ? (event.key === "ArrowDown" ? 0 : items.length - 1) :
+          (current + (event.key === "ArrowDown" ? 1 : -1) + items.length) % items.length
+        items[next]?.focus()
+      }
+    }
+    this.onScroll = (event) => {
+      if (this.isOpen && !this.panel?.contains(event.target)) this.positionMenu()
+    }
+    this.onResize = () => this.closeMenu()
+    this.el.addEventListener("click", this.onClick)
+    this.el.addEventListener("keydown", this.onKey)
+    document.addEventListener("pointerdown", this.onOutside)
+    document.addEventListener("scroll", this.onScroll, true)
+    window.addEventListener("resize", this.onResize)
+  },
+
+  updated() {
+    this.closeMenu()
+  },
+
+  openMenu(focusFirst = false) {
+    this.trigger = this.el.querySelector("[data-file-menu-trigger='true']")
+    this.panel = this.el.querySelector("[data-file-menu-panel]")
+    if (!this.trigger || !this.panel) return
+
+    // Keep the menu clear of the narrow sidebar's scroll clipping and viewport edges.
+    this.panel.style.display = "block"
+    this.positionMenu()
+    this.trigger.setAttribute("aria-expanded", "true")
+    this.isOpen = true
+    if (focusFirst) this.panel.querySelector("[role='menuitem']:not(:disabled)")?.focus({ preventScroll: true })
+  },
+
+  positionMenu() {
+    const anchor = this.trigger.getBoundingClientRect()
+    if (anchor.bottom <= 0 || anchor.top >= window.innerHeight) {
+      this.closeMenu()
+      return
+    }
+    const menu = this.panel.getBoundingClientRect()
+    const inset = 8
+    const rowRight = this.el.parentElement.getBoundingClientRect().right
+    const left = Math.max(inset, Math.min(rowRight - menu.width, window.innerWidth - menu.width - inset))
+    const top = anchor.bottom + menu.height + inset <= window.innerHeight ?
+      anchor.bottom + inset : Math.max(inset, anchor.top - menu.height - inset)
+    this.panel.style.left = `${left}px`
+    this.panel.style.top = `${top}px`
+  },
+
+  closeMenu(returnFocus = false) {
+    if (this.panel) this.panel.style.display = "none"
+    this.trigger?.setAttribute("aria-expanded", "false")
+    this.isOpen = false
+    if (returnFocus) this.trigger?.focus({ preventScroll: true })
+  },
+
+  destroyed() {
+    this.el.removeEventListener("click", this.onClick)
+    this.el.removeEventListener("keydown", this.onKey)
+    document.removeEventListener("pointerdown", this.onOutside)
+    document.removeEventListener("scroll", this.onScroll, true)
+    window.removeEventListener("resize", this.onResize)
+  },
+}
diff --git a/docs/analytics_sessions.md b/docs/analytics_sessions.md
index 8724863..def67e4 100644
--- a/docs/analytics_sessions.md
+++ b/docs/analytics_sessions.md
@@ -93,7 +93,12 @@ mix analytics.sessions.backfill --materialize-inventory --materialize-session-re
 Source deletion, copying or restoration must invalidate affected prepared data
 with `Sessions.invalidate/1` under the caller's existing authorization, then
 rebuild it. Do not reuse a retired space identifier before invalidation succeeds.
-Normal event arrival needs no explicit invalidation.
+Invalidation atomically hides the published generations in PostgreSQL and records
+them for cleanup; it does not wait for ClickHouse deletion. New readers cannot
+select the old generations, while reads already in progress retain the reader
+grace period. The background processor rebuilds from current source events, and
+cleanup reclaims retired generations independently. Normal event arrival needs
+no explicit invalidation.
 
 ## Query semantics
 
diff --git a/docs/audio_description.md b/docs/audio_description.md
index 34ea2fc..31f708d 100644
--- a/docs/audio_description.md
+++ b/docs/audio_description.md
@@ -3,7 +3,8 @@
 Audio description makes a video followable for blind and low-vision viewers: a
 voice describes what happens on screen. A space opts in under **Settings →
 Features → Audio description**. From then on, every new upload and reprocessing
-run of a video of at most 10 minutes gets, in English and Dutch:
+run of a video of at most 10 minutes gets one description in its detected
+spoken language (English when no language is known):
 
 - `audio_description_<lang>.mp3`: a full mix of the video's own audio with the
   spoken descriptions. It is also an HLS alternate audio rendition, so players
@@ -13,11 +14,16 @@ run of a video of at most 10 minutes gets, in English and Dutch:
 
 Existing videos only get audio descriptions when they are processed again.
 
+The flow input can set `audio_description.fallback_language` (default `en`).
+A `fallback_language` step parameter overrides that default. These values are
+used only when the original language is unknown; hosts can snapshot a space's
+preferred fallback in the flow input without coupling the pipeline to space settings.
+
 ## How descriptions are placed
 
-- **English first.** The video is described in English from what is on screen.
-  Every other language is a translation of that English text, never a separate
-  description.
+- **Original language.** The picture is described directly in the language
+  detected by transcription. If no language is known, English is used. No second
+  language or translation is generated by default.
 - **In the pauses, otherwise ducked.** Where speech is, is measured with
   speech-to-text (the `ai.transcribe_audio` segments, or a transcription made for
   this purpose), never guessed by the description model. A description that fits a
@@ -39,26 +45,26 @@ Existing videos only get audio descriptions when they are processed again.
 The publishing presets (`publish_default`, `publish_local`, `publish_remote`,
 `publish_remote_local`) contain these optional background steps. Each one skips
 itself (`status: "skipped"`, `reason: "not_requested"`) unless the run input has
-`audio_description`, so other spaces pay nothing for them. Nothing in the publish
+`audio_description`, so disabled spaces do not call the AI providers. Nothing in the publish
 path waits for them; when a mix step finishes, Core stores the result, rebuilds the
 HLS master playlist and republishes `manifest.json`.
 
 | Step | Type | Runs on | Does |
 | --- | --- | --- | --- |
 | `detect_scenes` | `media.detect_scenes` | FLAME (media pool) | Cuts, scenes and stills in one decode of the canonical source |
-| `describe_video` | `ai.describe_video` | inline | English cues |
-| `translate_descriptions_nl` | `ai.translate_descriptions` | inline | Dutch cues, same timings |
-| `speak_descriptions_<lang>` | `ai.speak_descriptions` | inline | Text-to-speech per cue; existing clips are reused on retry |
-| `mix_audio_description_<lang>` | `media.mix_audio_description` | FLAME (media pool) | Timeline, ducked mix, VTT and the HLS audio rendition |
+| `describe_video` | `ai.describe_video` | inline | Original-language cues |
+| `speak_descriptions_original` | `ai.speak_descriptions` | inline | Text-to-speech per cue; existing clips are reused on retry |
+| `mix_audio_description_original` | `media.mix_audio_description` | FLAME (media pool) | Timeline, ducked mix, VTT and the HLS audio rendition |
 
 Run input:
 
 ```json
-{"audio_description": {"languages": ["en", "nl"]}}
+{"audio_description": {"languages": ["original"], "fallback_language": "en"}}
 ```
 
 Uploads and the public `input_url` API add this when the space has the feature on
-and the host allows it at that moment (see below). English is always included.
+and the host allows it at that moment (see below). Existing runs keep their
+original versioned flow definition; newly started runs use the single-language preset.
 Videos longer than `MAVE_AUDIO_DESCRIPTION_MAX_SECONDS` (default `600`) are
 skipped with `reason: "video_too_long"`, `video_duration_seconds` and
 `max_duration_seconds`; videos without a video stream with `no_video`.
@@ -72,8 +78,8 @@ live under `<embed>/vN/audio_description/`.
 
 Files sit next to the other media of the video version (`<embed>/vN/`):
 `audio_description_<lang>.mp3`, `audio_description_<lang>_hls/playlist.m3u8` and
-`descriptions_<lang>.vtt`. The `audio_descriptions` table holds one row per video
-version and language.
+`descriptions_<lang>.vtt`. Generated rows are identified by video version and
+generation language; uploaded tracks may share the same language.
 
 The HLS master playlist lists each MP3 in the `audio` group:
 
@@ -96,8 +102,20 @@ The HLS master playlist lists each MP3 in the `audio` group:
 ```
 
 The key is omitted when a video has none. The detailed video API payload has the
-same `audio_descriptions` list, and the dashboard video page links the MP3 and VTT
-files.
+same `audio_descriptions` list. The dashboard video page lists the available
+languages and HLS/MP3/VTT formats under **Audio descriptions** in Settings and
+**Audio** in Info, where descriptions are marked `(AD)`.
+
+The file menu on audio tracks, audio descriptions and subtitles provides file
+downloads and replacement. Removing a track asks for confirmation.
+
+Under **Settings → Audio descriptions**, tracks can be uploaded, renamed,
+retagged with a language, replaced, or removed. Upload a complete MP3 mix with
+both the original audio and spoken descriptions; the player switches tracks
+rather than mixing them. Uploaded tracks can share a language. A manually
+replaced track has no generated VTT, since the old text may not match the new
+audio. The replacement menu also supports uploading or replacing the associated
+VTT. The generated pipeline creates both files automatically. Background publication preserves manually edited and removed tracks.
 
 ## Who may use it
 
@@ -110,25 +128,30 @@ loses access stops getting audio descriptions without changing its setting.
 
 ## Providers and configuration
 
-Everything runs on EU providers: Scaleway Generative APIs (nl-ams) and Mistral.
-Video stills, the speech timings and the description text are sent to them.
+The default providers are Scaleway Generative APIs and Mistral. Video stills,
+speech timings and description text are sent to the configured providers.
 
 | Variable | Default | Purpose |
 | --- | --- | --- |
 | `SCALEWAY_API_KEY` | — | Scaleway IAM application with only `GenerativeApisModelAccess` |
 | `MISTRAL_API_KEY` | — | Already used for transcription; also used for text-to-speech |
+| `MAVE_AUDIO_DESCRIPTION_ENDPOINT` | `https://api.scaleway.ai/v1/chat/completions` | Override with `https://api.scaleway.ai/<project-id>/v1/chat/completions` for a project-scoped key |
 | `MAVE_AUDIO_DESCRIPTION_MODEL` | `gemma-4-26b-a4b-it` | Describe and translate model |
 | `MAVE_AUDIO_DESCRIPTION_REASONING_EFFORT` | `none` | Scaleway `reasoning_effort`; with reasoning, Gemma runs out of tokens |
-| `MAVE_AUDIO_DESCRIPTION_TTS_MODEL` | `voxtral-mini-tts-2603` | Mistral text-to-speech model |
-| `MAVE_AUDIO_DESCRIPTION_VOICES` | `en:gb_jane_neutral,nl:nl_kore_neutral` | Voice per language |
+| `MAVE_AUDIO_DESCRIPTION_TTS_MODEL` | `voxtral-mini-tts-3-0` | Mistral text-to-speech model |
+| `MAVE_AUDIO_DESCRIPTION_VOICES` | `en:gb_jane_neutral,nl:voice_3145` | Voice per language |
 | `MAVE_AUDIO_DESCRIPTION_VOICE` | `gb_jane_neutral` | Voice for languages without one |
 | `MAVE_AUDIO_DESCRIPTION_MAX_SECONDS` | `600` | Longest video that gets descriptions |
 
-Every language needs a voice in that language: Voxtral keeps the accent of its
-voice prompt. Mistral has no Dutch preset, so `nl_kore_neutral` is a cloned voice
-that must exist in the Mistral account of `MISTRAL_API_KEY`. Create voices only
-from a speaker who consented or from a synthetic sample, never from customer
-videos.
+The default voices are Jane (English) and Lotte (Dutch), both presets. Lotte
+requires Voxtral 3; the older `voxtral-mini-tts-2603` model rejects this voice.
+When overriding the model or voices, verify that they are compatible. See
+[Mistral's voice catalog](https://docs.mistral.ai/studio/audio/text-to-speech/voices).
+
+Scope the Scaleway application's `GenerativeApisModelAccess` policy to the
+intended project and use that project's endpoint above. Setting a key's default
+project alone does not restrict its permissions. Prefer expiring credentials
+and keep them in the runtime environment, outside version control.
 
 Tests replace the providers through application config:
 
diff --git a/lib/mave_core/analytics/sessions.ex b/lib/mave_core/analytics/sessions.ex
index e78ecfb..38ea35a 100644
--- a/lib/mave_core/analytics/sessions.ex
+++ b/lib/mave_core/analytics/sessions.ex
@@ -565,7 +565,7 @@ defmodule MaveCore.Analytics.Sessions do
     :ok
   end
 
-  @doc "Hide retired analytics immediately; obsolete generations are collected separately."
+  @doc "Hide prepared analytics immediately; physical cleanup runs after the reader grace period."
   def invalidate(space_hash) do
     with :ok <- validate_hash(space_hash), do: invalidate_transaction(space_hash)
   end
@@ -579,43 +579,22 @@ defmodule MaveCore.Analytics.Sessions do
 
   defp invalidate_locked(space) do
     lock!(space)
-    Repo.query!("DELETE FROM analytics_session_buckets WHERE space_hash = $1", [space])
 
-    with {:ok, _} <-
-           ch(
-             "ALTER TABLE analytics_sessions DELETE WHERE space_hash = {$0:String} SETTINGS mutations_sync = 1",
-             [space],
-             60_000
-           ),
-         {:ok, _} <-
-           ch(
-             "ALTER TABLE analytics_session_years DELETE WHERE space_hash = {$0:String} SETTINGS mutations_sync = 1",
-             [space],
-             60_000
-           ),
-         {:ok, _} <-
-           ch(
-             "ALTER TABLE analytics_session_reports DELETE WHERE space_hash = {$0:String} SETTINGS mutations_sync = 1",
-             [space],
-             60_000
-           ),
-         {:ok, _} <-
-           ch(
-             "ALTER TABLE analytics_overview_days DELETE WHERE space_hash = {$0:String} SETTINGS mutations_sync = 1",
-             [space],
-             60_000
-           ),
-         {:ok, _} <-
-           ch(
-             "ALTER TABLE analytics_overview_views DELETE WHERE space_hash = {$0:String} SETTINGS mutations_sync = 1",
-             [space],
-             60_000
-           ) do
-      Repo.query!("DELETE FROM analytics_session_retirements WHERE space_hash = $1", [space])
-      :ok
-    else
-      _ -> {:error, :analytics_unavailable}
-    end
+    # Unpublish and retain a durable cleanup record in one transaction. Readers
+    # already using a generation keep it for the grace period; new readers cannot
+    # select it. A ClickHouse outage must not block this visibility change.
+    Repo.query!(
+      """
+      INSERT INTO analytics_session_retirements (space_hash, generation, retired_at)
+      SELECT space_hash, generation, now() FROM analytics_session_buckets
+      WHERE space_hash = $1
+      ON CONFLICT (space_hash, generation) DO NOTHING
+      """,
+      [space]
+    )
+
+    Repo.query!("DELETE FROM analytics_session_buckets WHERE space_hash = $1", [space])
+    :ok
   end
 
   @doc "Delete retired generations after the reader grace period, in batches per space."
diff --git a/lib/mave_core/assets.ex b/lib/mave_core/assets.ex
index 8b4194b..fa0bd9b 100644
--- a/lib/mave_core/assets.ex
+++ b/lib/mave_core/assets.ex
@@ -173,6 +173,148 @@ defmodule MaveCore.Assets do
     Repo.delete(track)
   end
 
+  def get_audio_description_for_embed(id, %Embed{} = embed) when is_binary(id) do
+    embed = Repo.preload(embed, :asset)
+    video_id = embed.asset && embed.asset.current_video_id
+
+    if is_binary(video_id) do
+      AudioDescription
+      |> where([description], is_nil(description.deleted_at))
+      |> Repo.get_by(id: id, video_id: video_id)
+    end
+  end
+
+  def get_audio_description_for_embed(_, _), do: nil
+
+  def update_audio_description_outputs(%Embed{} = embed, id, attrs) do
+    case get_audio_description_for_embed(id, embed) do
+      nil ->
+        {:error, :audio_description_not_found}
+
+      description ->
+        attrs = Map.take(attrs, [:label, :language]) |> Map.put(:user_managed, true)
+
+        with {:ok, updated} <- description |> AudioDescription.changeset(attrs) |> Repo.update(),
+             :ok <- refresh_audio_outputs(embed) do
+          {:ok, updated}
+        end
+    end
+  end
+
+  def delete_audio_description_outputs(%Embed{} = embed, id) do
+    case get_audio_description_for_embed(id, embed) do
+      nil ->
+        {:error, :audio_description_not_found}
+
+      description ->
+        with {:ok, deleted} <-
+               description
+               |> AudioDescription.changeset(%{
+                 deleted_at: DateTime.utc_now(),
+                 user_managed: true
+               })
+               |> Repo.update(),
+             :ok <- refresh_audio_outputs(embed) do
+          {:ok, deleted}
+        end
+    end
+  end
+
+  def ingest_uploaded_audio_description(%Embed{} = embed, attrs, source_bucket, source_key) do
+    embed = Repo.preload(embed, [:space, asset: [:current_video]])
+    id = Map.get(attrs, "audio_track_id")
+
+    target =
+      if id in [nil, ""],
+        do: %AudioDescription{},
+        else: get_audio_description_for_embed(id, embed)
+
+    with %Video{} = video <- embed.asset && embed.asset.current_video,
+         %AudioDescription{} = description <- target,
+         {:ok, original_name} <- require_binary(attrs["filename"], :filename),
+         filename =
+           "audio_description_upload_#{Ecto.UUID.generate()}_#{Path.rootname(Path.basename(original_name))}.mp3",
+         region = embed.space.region || "default",
+         changeset =
+           AudioDescription.changeset(description, %{
+             video_id: video.id,
+             language: attrs["language"],
+             label: blank_to_nil(attrs["label"]),
+             audio_filename: filename,
+             audio_file_size: attrs["file_size"],
+             vtt_filename: nil,
+             vtt_file_size: nil,
+             cue_count: nil,
+             ducked_cue_count: nil,
+             user_managed: true
+           }),
+         {:ok, candidate} <- Ecto.Changeset.apply_action(changeset, :insert),
+         {:ok, copied} <-
+           copy_audio_source(
+             embed,
+             filename,
+             source_bucket,
+             source_key,
+             attrs,
+             region,
+             upload_source_storage_profile()
+           ),
+         {:ok, %{"status" => "ok"}} <-
+           package_audio_track(
+             embed,
+             %AudioTrack{
+               id: candidate.id || Ecto.UUID.generate(),
+               label: AudioDescription.display_label(candidate),
+               language: candidate.language,
+               default: false,
+               filename: filename,
+               codec: "mp3"
+             },
+             copied,
+             region
+           ),
+         {:ok, saved} <- Repo.insert_or_update(changeset),
+         :ok <- refresh_audio_outputs(embed) do
+      {:ok, saved}
+    else
+      nil -> {:error, :audio_description_not_found}
+      {:error, _} = error -> error
+      {:ok, output} -> {:error, {:audio_description_packaging_failed, output["status"]}}
+    end
+  end
+
+  def ingest_uploaded_audio_description_vtt(%Embed{} = embed, attrs, source_bucket, source_key) do
+    embed = Repo.preload(embed, [:space, asset: [:current_video]])
+    storage = storage_adapter()
+    region = embed.space.region || "default"
+    filename = "descriptions_upload_#{Ecto.UUID.generate()}.vtt"
+    key = audio_source_key(embed.hash, Embeds.current_video_version(embed), filename)
+    bucket = Storage.bucket_for_space(embed.space.hash, region)
+
+    with %AudioDescription{} = description <-
+           get_audio_description_for_embed(attrs["subtitle_id"], embed),
+         {:ok, body} <- storage.get(source_bucket, source_key, upload_source_storage_profile()),
+         true <-
+           is_binary(body) and String.valid?(body) and
+             String.starts_with?(String.trim_leading(body, "\uFEFF"), "WEBVTT"),
+         {:ok, _} <- storage.put_public(bucket, key, body, "text/vtt", region),
+         {:ok, saved} <-
+           description
+           |> AudioDescription.changeset(%{
+             vtt_filename: filename,
+             vtt_file_size: byte_size(body),
+             user_managed: true
+           })
+           |> Repo.update(),
+         :ok <- refresh_audio_outputs(embed) do
+      {:ok, saved}
+    else
+      nil -> {:error, :audio_description_not_found}
+      false -> {:error, :invalid_vtt}
+      {:error, _} = error -> error
+    end
+  end
+
   def ingest_uploaded_thumbnail(%Embed{} = embed, source_bucket, source_key, attrs \\ %{})
       when is_binary(source_bucket) and is_binary(source_key) and is_map(attrs) do
     embed = Repo.preload(embed, [:space, :settings, asset: [:current_video]])
@@ -1235,8 +1377,8 @@ defmodule MaveCore.Assets do
     |> list_audio_descriptions()
     |> Enum.map(fn description ->
       %{
-        "id" => "audio_description_#{description.language}",
-        "label" => MediaMixAudioDescriptionStep.label(description.language),
+        "id" => "audio_description_#{description.id}",
+        "label" => AudioDescription.display_label(description),
         "language" => description.language,
         "default" => false,
         "hls_playlist" => AudioDescription.hls_playlist(description),
@@ -1250,7 +1392,7 @@ defmodule MaveCore.Assets do
   @doc "Audio descriptions of a video version, by language."
   def list_audio_descriptions(video_id) when is_binary(video_id) do
     AudioDescription
-    |> where([description], description.video_id == ^video_id)
+    |> where([description], description.video_id == ^video_id and is_nil(description.deleted_at))
     |> order_by([description], asc: description.language)
     |> Repo.all()
   end
diff --git a/lib/mave_core/assets/audio_description.ex b/lib/mave_core/assets/audio_description.ex
index bba9667..4a757d0 100644
--- a/lib/mave_core/assets/audio_description.ex
+++ b/lib/mave_core/assets/audio_description.ex
@@ -10,6 +10,10 @@ defmodule MaveCore.Assets.AudioDescription do
 
   schema "audio_descriptions" do
     field :language, :string
+    field :label, :string
+    field :generation_language, :string
+    field :user_managed, :boolean, default: false
+    field :deleted_at, :utc_datetime_usec
     field :audio_filename, :string
     field :audio_file_size, :integer
     field :vtt_filename, :string
@@ -27,6 +31,10 @@ defmodule MaveCore.Assets.AudioDescription do
     |> cast(attrs, [
       :video_id,
       :language,
+      :label,
+      :generation_language,
+      :user_managed,
+      :deleted_at,
       :audio_filename,
       :audio_file_size,
       :vtt_filename,
@@ -34,9 +42,18 @@ defmodule MaveCore.Assets.AudioDescription do
       :cue_count,
       :ducked_cue_count
     ])
-    |> validate_required([:video_id, :language, :audio_filename, :vtt_filename])
+    |> validate_required([:video_id, :language, :audio_filename])
+    |> validate_format(:language, ~r/^[a-z]{2,3}(?:-[A-Za-z0-9]{2,8})*$/)
     |> foreign_key_constraint(:video_id)
-    |> unique_constraint([:video_id, :language])
+    |> unique_constraint([:video_id, :generation_language])
+  end
+
+  def display_label(%__MODULE__{} = description) do
+    name =
+      description.label || MaveCore.Languages.spoken_language(description.language) ||
+        String.upcase(description.language)
+
+    "#{name} (audio description)"
   end
 
   @doc "HLS playlist of the audio track, relative to the video version's prefix."
diff --git a/lib/mave_core/audio_description.ex b/lib/mave_core/audio_description.ex
index ba28ee1..669f0c0 100644
--- a/lib/mave_core/audio_description.ex
+++ b/lib/mave_core/audio_description.ex
@@ -1,10 +1,10 @@
 defmodule MaveCore.AudioDescription do
   @moduledoc """
   Audio description: per video, a full-mix MP3 (the video's audio with spoken
-  descriptions of what is on screen) and a descriptions VTT, in English and Dutch.
+  descriptions of what is on screen) and a descriptions VTT in the original language.
 
-  English is always described first, from the picture; every other language is a
-  translation of that English text. See `docs/audio_description.md`.
+  New runs describe the picture directly in the detected language, falling back
+  to English when no language is known. See `docs/audio_description.md`.
   """
 
   alias MaveCore.Spaces
@@ -23,7 +23,7 @@ defmodule MaveCore.AudioDescription do
   """
   def run_input(%Space{} = space) do
     if Spaces.audio_description_active?(space),
-      do: %{"languages" => @languages},
+      do: %{"languages" => ["original"], "fallback_language" => "en"},
       else: nil
   end
 
@@ -33,11 +33,39 @@ defmodule MaveCore.AudioDescription do
   def requested_languages(%{"audio_description" => %{"languages" => languages}})
       when is_list(languages) do
     languages = Enum.filter(languages, &is_binary/1)
-    if languages == [], do: [], else: Enum.uniq([@source_language | languages])
+
+    cond do
+      languages == [] -> []
+      "original" in languages -> ["original"]
+      true -> Enum.uniq([@source_language | languages])
+    end
   end
 
   def requested_languages(_run_input), do: []
 
+  @doc "Original language from transcription or run metadata, with a configurable fallback."
+  def original_language(run_input, outputs, fallback_language \\ nil) do
+    candidates = [
+      get_in(outputs, ["transcribe_audio", "transcription_language"]),
+      get_in(outputs, ["transcribe_audio", "language"]),
+      run_input["language"]
+    ]
+
+    fallback =
+      normalize_language(fallback_language) ||
+        normalize_language(get_in(run_input, ["audio_description", "fallback_language"])) ||
+        @source_language
+
+    Enum.find_value(candidates, fallback, &normalize_language/1)
+  end
+
+  defp normalize_language(value) when is_binary(value) do
+    value = value |> String.trim() |> String.downcase() |> String.split(~r/[-_]/) |> hd()
+    if value =~ ~r/^[a-z]{2,3}$/ and value not in ["und", "zxx"], do: value
+  end
+
+  defp normalize_language(_), do: nil
+
   def requested?(run_input), do: requested_languages(run_input) != []
 
   @doc "Longest video that gets an audio description, in seconds."
diff --git a/lib/mave_core/audio_description/mistral_speech.ex b/lib/mave_core/audio_description/mistral_speech.ex
index 8b24f9d..872c889 100644
--- a/lib/mave_core/audio_description/mistral_speech.ex
+++ b/lib/mave_core/audio_description/mistral_speech.ex
@@ -4,14 +4,14 @@ defmodule MaveCore.AudioDescription.MistralSpeech do
 
   Every language gets a voice in that language, because Voxtral keeps the accent
   of its voice prompt. Voices come from `MAVE_AUDIO_DESCRIPTION_VOICES`
-  (`en:gb_jane_neutral,nl:nl_kore_neutral` by default); a language without one
+  (`en:gb_jane_neutral,nl:voice_3145` by default); a language without one
   falls back to `MAVE_AUDIO_DESCRIPTION_VOICE`. Never clone voices from customer
   videos.
   """
 
   @endpoint "https://api.mistral.ai/v1/audio/speech"
-  @default_model "voxtral-mini-tts-2603"
-  @default_voices "en:gb_jane_neutral,nl:nl_kore_neutral"
+  @default_model "voxtral-mini-tts-3-0"
+  @default_voices "en:gb_jane_neutral,nl:voice_3145"
   @default_voice "gb_jane_neutral"
   @pool_timeout_ms 30_000
   @receive_timeout_ms 2 * 60 * 1000
diff --git a/lib/mave_core/audio_description/prompts.ex b/lib/mave_core/audio_description/prompts.ex
index 30e9a17..56ada3c 100644
--- a/lib/mave_core/audio_description/prompts.ex
+++ b/lib/mave_core/audio_description/prompts.ex
@@ -48,13 +48,13 @@ defmodule MaveCore.AudioDescription.Prompts do
   def translations_schema, do: @translations_schema
 
   @doc "The describer's instructions, followed by the timing context (`Timeline.timing_prompt/4`)."
-  def describe_instruction(duration, timing) do
+  def describe_instruction(duration, timing, language \\ "en") do
     [
       "You are a professional audio describer. You write the audio description track for a video,",
       "so that blind and low-vision viewers can follow what happens on screen.",
       "",
       "Rules:",
-      "- Write every description in English, regardless of the language spoken in the video.",
+      "- Write every description in #{Languages.spoken_language(language) || language} (#{language}).",
       "- Describe what is visible: actions, people (by appearance and role, use names only if shown on screen),",
       "  setting, scene and location changes, facial expressions and on-screen text (read text out; keep brand names,",
       "  logos and URLs exactly as written).",
diff --git a/lib/mave_core/embeds.ex b/lib/mave_core/embeds.ex
index e27fea6..90a7ce7 100644
--- a/lib/mave_core/embeds.ex
+++ b/lib/mave_core/embeds.ex
@@ -618,10 +618,15 @@ defmodule MaveCore.Embeds do
         ManifestPublisher.serialize_audio_description(description, bucket, embed.hash, version)
 
       %{
+        id: description.id,
         language: description.language,
         label:
-          Languages.spoken_language(description.language) || String.upcase(description.language),
+          description.label || Languages.spoken_language(description.language) ||
+            String.upcase(description.language),
+        default: false,
+        codec: "mp3",
         mp3_url: get_in(serialized, ["audio", "path"]),
+        hls_playlist: get_in(serialized, ["audio", "hls_playlist"]),
         vtt_url: get_in(serialized, ["vtt", "path"]),
         cue_count: description.cue_count
       }
diff --git a/lib/mave_core/embeds/manifest_publisher.ex b/lib/mave_core/embeds/manifest_publisher.ex
index 824c255..62d0b65 100644
--- a/lib/mave_core/embeds/manifest_publisher.ex
+++ b/lib/mave_core/embeds/manifest_publisher.ex
@@ -7,7 +7,6 @@ defmodule MaveCore.Embeds.ManifestPublisher do
   alias MaveCore.Assets.{AudioDescription, AudioTrack, Video}
   alias MaveCore.Embeds
   alias MaveCore.Embeds.{Embed, SettingsSerializer}
-  alias MaveCore.Flow.Steps.MediaMixAudioDescriptionStep
   alias MaveCore.Languages
   alias MaveCore.LegacyShortUUID
   alias MaveCore.Media.CdnCache
@@ -614,7 +613,7 @@ defmodule MaveCore.Embeds.ManifestPublisher do
   def serialize_audio_description(%AudioDescription{} = description, bucket, embed_hash, version) do
     %{
       "language" => description.language,
-      "label" => MediaMixAudioDescriptionStep.label(description.language),
+      "label" => AudioDescription.display_label(description),
       "audio" => %{
         "path" =>
           SettingsSerializer.storage_object_url(
@@ -624,14 +623,17 @@ defmodule MaveCore.Embeds.ManifestPublisher do
         "hls_playlist" => AudioDescription.hls_playlist(description),
         "file_size" => description.audio_file_size
       },
-      "vtt" => %{
-        "path" =>
-          SettingsSerializer.storage_object_url(
-            bucket,
-            audio_track_key(embed_hash, version, description.vtt_filename)
-          ),
-        "file_size" => description.vtt_file_size
-      }
+      "vtt" =>
+        if(description.vtt_filename,
+          do: %{
+            "path" =>
+              SettingsSerializer.storage_object_url(
+                bucket,
+                audio_track_key(embed_hash, version, description.vtt_filename)
+              ),
+            "file_size" => description.vtt_file_size
+          }
+        )
     }
   end
 
diff --git a/lib/mave_core/flow.ex b/lib/mave_core/flow.ex
index 7edde5f..36e8229 100644
--- a/lib/mave_core/flow.ex
+++ b/lib/mave_core/flow.ex
@@ -4796,20 +4796,29 @@ defmodule MaveCore.Flow do
         output: %{"status" => "ok", "audio_description" => %{} = description}
       } ->
         %AudioDescription{}
-        |> AudioDescription.changeset(Map.put(description, "video_id", video_id))
+        |> AudioDescription.changeset(
+          description
+          |> Map.put("video_id", video_id)
+          |> Map.put("generation_language", description["language"])
+        )
         |> Repo.insert!(
           on_conflict:
-            {:replace,
-             [
-               :audio_filename,
-               :audio_file_size,
-               :vtt_filename,
-               :vtt_file_size,
-               :cue_count,
-               :ducked_cue_count,
-               :updated_at
-             ]},
-          conflict_target: [:video_id, :language]
+            from(existing in AudioDescription,
+              where: not existing.user_managed and is_nil(existing.deleted_at),
+              update: [
+                set: [
+                  audio_filename: fragment("EXCLUDED.audio_filename"),
+                  audio_file_size: fragment("EXCLUDED.audio_file_size"),
+                  vtt_filename: fragment("EXCLUDED.vtt_filename"),
+                  vtt_file_size: fragment("EXCLUDED.vtt_file_size"),
+                  cue_count: fragment("EXCLUDED.cue_count"),
+                  ducked_cue_count: fragment("EXCLUDED.ducked_cue_count"),
+                  updated_at: fragment("EXCLUDED.updated_at")
+                ]
+              ]
+            ),
+          conflict_target: [:video_id, :generation_language],
+          allow_stale: true
         )
 
       _step_run ->
diff --git a/lib/mave_core/flow/presets.ex b/lib/mave_core/flow/presets.ex
index a50c976..af4eda8 100644
--- a/lib/mave_core/flow/presets.ex
+++ b/lib/mave_core/flow/presets.ex
@@ -3,7 +3,6 @@ defmodule MaveCore.Flow.Presets do
   Built-in flow templates used as migration starting points.
   """
 
-  alias MaveCore.AudioDescription
   alias MaveCore.Media.ProductionEncodingProfile
 
   @spec all() :: [map()]
@@ -110,57 +109,32 @@ defmodule MaveCore.Flow.Presets do
     )
   end
 
-  # Audio description (English + translations). The steps skip themselves unless the
-  # run asks for it, and nothing waits for them: the mix steps republish the HLS master
-  # and manifest when they finish.
+  # A single original-language track is generated in the background.
   defp with_audio_description(definition) do
-    source = AudioDescription.source_language()
-    translations = AudioDescription.languages() -- [source]
-
-    steps =
-      [
-        background_step("detect_scenes", "media.detect_scenes", "Detect Scenes", ["inspect_media"]),
-        background_step(
-          "describe_video",
-          "ai.describe_video",
-          "Describe Video",
-          ["detect_scenes", "transcribe_audio", "transcode_audio"]
-        )
-      ] ++
-        Enum.map(translations, fn language ->
-          background_step(
-            "translate_descriptions_#{language}",
-            "ai.translate_descriptions",
-            "Translate Descriptions (#{language})",
-            ["describe_video"],
-            %{"language" => language, "source_step_id" => "describe_video"}
-          )
-        end) ++
-        Enum.flat_map([source | translations], &speak_and_mix_steps(&1, source))
-
-    Map.update!(definition, "steps", &(&1 ++ steps))
-  end
-
-  defp speak_and_mix_steps(language, source) do
-    cues_step =
-      if language == source, do: "describe_video", else: "translate_descriptions_#{language}"
-
-    [
+    steps = [
+      background_step("detect_scenes", "media.detect_scenes", "Detect Scenes", ["inspect_media"]),
+      background_step("describe_video", "ai.describe_video", "Describe Video", [
+        "detect_scenes",
+        "transcribe_audio",
+        "transcode_audio"
+      ]),
       background_step(
-        "speak_descriptions_#{language}",
+        "speak_descriptions_original",
         "ai.speak_descriptions",
-        "Speak Descriptions (#{language})",
-        [cues_step],
-        %{"language" => language, "source_step_id" => cues_step}
+        "Speak Descriptions",
+        ["describe_video"],
+        %{"language" => "original", "source_step_id" => "describe_video"}
       ),
       background_step(
-        "mix_audio_description_#{language}",
+        "mix_audio_description_original",
         "media.mix_audio_description",
-        "Mix Audio Description (#{language})",
-        ["speak_descriptions_#{language}", "transcode_audio"],
-        %{"language" => language, "source_step_id" => "speak_descriptions_#{language}"}
+        "Mix Audio Description",
+        ["speak_descriptions_original", "transcode_audio"],
+        %{"language" => "original", "source_step_id" => "speak_descriptions_original"}
       )
     ]
+
+    Map.update!(definition, "steps", &(&1 ++ steps))
   end
 
   defp background_step(id, type, name, depends_on, params \\ nil) do
diff --git a/lib/mave_core/flow/steps/ai_describe_video_step.ex b/lib/mave_core/flow/steps/ai_describe_video_step.ex
index a2b686e..63059ae 100644
--- a/lib/mave_core/flow/steps/ai_describe_video_step.ex
+++ b/lib/mave_core/flow/steps/ai_describe_video_step.ex
@@ -1,15 +1,14 @@
 defmodule MaveCore.Flow.Steps.AiDescribeVideoStep do
   @moduledoc """
-  Writes the English audio description cues from the labelled stills of
+  Writes the original-language audio description cues from the labelled stills of
   `media.detect_scenes`, around the speech measured by speech-to-text.
 
   Speech comes from the `ai.transcribe_audio` segments (never from the description
   model); when that step has none, this step transcribes the audio itself. The
-  English cues are the only source for every other language.
+  cues are the source for the spoken description.
   """
   @behaviour MaveCore.Flow.Step
 
-  alias MaveCore.AudioDescription
   alias MaveCore.AudioDescription.{Cues, Prompts, Timeline}
   alias MaveCore.Embeds.SettingsSerializer
   alias MaveCore.Flow.Steps.AudioDescriptionSupport, as: AD
@@ -38,7 +37,7 @@ defmodule MaveCore.Flow.Steps.AiDescribeVideoStep do
          {:ok, raw_cues} <- describe_batches(ctx, document["stills"], scenes, speech, duration),
          cues = clean_cues(raw_cues, speech, scenes, duration),
          :ok <- require_cues(cues),
-         language = AudioDescription.source_language(),
+         language = AD.language(ctx),
          {:ok, cues_key} <-
            AD.put_json(ctx, AD.work_key(ctx, "#{language}/cues.json"), Cues.to_json(cues)),
          {:ok, speech_key} <-
@@ -56,7 +55,7 @@ defmodule MaveCore.Flow.Steps.AiDescribeVideoStep do
          "cue_count" => length(cues),
          "scene_count" => length(scenes),
          "speech_seconds" =>
-           speech |> Enum.map(&(&1.end - &1.start)) |> Enum.sum() |> Float.round(1)
+           speech |> Enum.reduce(0.0, &(&2 + &1.end - &1.start)) |> Float.round(1)
        }, []}
     else
       {:error, :no_descriptions} ->
@@ -92,7 +91,9 @@ defmodule MaveCore.Flow.Steps.AiDescribeVideoStep do
       content =
         images ++ [%{"type" => "text", "text" => Prompts.stills_request(window, previous)}]
 
-      case AD.chat_provider().chat_json(Prompts.describe_instruction(duration, timing), content,
+      case AD.chat_provider().chat_json(
+             Prompts.describe_instruction(duration, timing, AD.language(ctx)),
+             content,
              schema: Prompts.cues_schema(),
              max_tokens: 8_000
            ) do
diff --git a/lib/mave_core/flow/steps/ai_speak_descriptions_step.ex b/lib/mave_core/flow/steps/ai_speak_descriptions_step.ex
index b3ba1a5..fed75b5 100644
--- a/lib/mave_core/flow/steps/ai_speak_descriptions_step.ex
+++ b/lib/mave_core/flow/steps/ai_speak_descriptions_step.ex
@@ -67,7 +67,22 @@ defmodule MaveCore.Flow.Steps.AiSpeakDescriptionsStep do
   end
 
   defp speak_cue(ctx, cue, index, language) do
-    key = AD.work_key(ctx, "#{language}/speech/#{String.pad_leading("#{index}", 5, "0")}.pcm")
+    # Retrying a description run can change its text or voice at the same index.
+    # Reuse a clip only while all inputs to speech generation stay the same.
+    fingerprint =
+      {cue.text, language, AD.speech_provider(),
+       System.get_env("MAVE_AUDIO_DESCRIPTION_TTS_MODEL"),
+       System.get_env("MAVE_AUDIO_DESCRIPTION_VOICES"),
+       System.get_env("MAVE_AUDIO_DESCRIPTION_VOICE")}
+      |> :erlang.term_to_binary()
+      |> then(&:crypto.hash(:sha256, &1))
+      |> Base.encode16(case: :lower)
+
+    key =
+      AD.work_key(
+        ctx,
+        "#{language}/speech/#{String.pad_leading("#{index}", 5, "0")}-#{fingerprint}.pcm"
+      )
 
     case ctx.storage.get(ctx.bucket, key, ctx.region) do
       {:ok, pcm} ->
diff --git a/lib/mave_core/flow/steps/audio_description_support.ex b/lib/mave_core/flow/steps/audio_description_support.ex
index c1e3e1c..2aa5515 100644
--- a/lib/mave_core/flow/steps/audio_description_support.ex
+++ b/lib/mave_core/flow/steps/audio_description_support.ex
@@ -76,7 +76,30 @@ defmodule MaveCore.Flow.Steps.AudioDescriptionSupport do
   @doc "The dependency named by `params[\"source_step_id\"]`."
   def source_step_id(ctx, default), do: Map.get(ctx.params, "source_step_id", default)
 
-  def language(ctx), do: Map.get(ctx.params, "language", AudioDescription.source_language())
+  def language(ctx) do
+    case Map.get(ctx.params, "language") do
+      "original" ->
+        get_in(ctx.outputs, [source_step_id(ctx, "describe_video"), "language"]) ||
+          AudioDescription.original_language(
+            ctx.run_input,
+            ctx.outputs,
+            ctx.params["fallback_language"]
+          )
+
+      nil ->
+        if "original" in ctx.languages,
+          do:
+            AudioDescription.original_language(
+              ctx.run_input,
+              ctx.outputs,
+              ctx.params["fallback_language"]
+            ),
+          else: AudioDescription.source_language()
+
+      language ->
+        language
+    end
+  end
 
   def work_key(ctx, name),
     do: "#{AudioDescription.work_prefix(ctx.embed_hash, ctx.version)}/#{name}"
@@ -96,7 +119,7 @@ defmodule MaveCore.Flow.Steps.AudioDescriptionSupport do
 
   def get_json(ctx, key) when is_binary(key) do
     with {:ok, body} <- ctx.storage.get(ctx.bucket, key, ctx.region),
-         {:ok, value} <- Jason.decode(body) do
+         {:ok, value} <- decode_json(body) do
       {:ok, value}
     else
       {:error, %Jason.DecodeError{}} -> {:error, {:invalid_json, key}}
@@ -106,6 +129,10 @@ defmodule MaveCore.Flow.Steps.AudioDescriptionSupport do
 
   def get_json(_ctx, key), do: {:error, {:missing_key, key}}
 
+  # HTTP storage adapters may already decode application/json responses.
+  defp decode_json(body) when is_map(body) or is_list(body), do: {:ok, body}
+  defp decode_json(body), do: Jason.decode(body)
+
   def put_private(ctx, key, body, content_type) do
     case ctx.storage.put(ctx.bucket, key, body, content_type, ctx.region) do
       {:ok, _} -> {:ok, key}
diff --git a/lib/mave_core/uploads.ex b/lib/mave_core/uploads.ex
index 42382ed..0d1ed5c 100644
--- a/lib/mave_core/uploads.ex
+++ b/lib/mave_core/uploads.ex
@@ -333,10 +333,15 @@ defmodule MaveCore.Uploads do
   end
 
   defp handle_custom_audio_track(scope, bucket, key, metadata, upload) do
+    ingest =
+      if present(metadata, "audio_description") in ["true", "1", "yes"],
+        do: &Assets.ingest_uploaded_audio_description/4,
+        else: &Assets.ingest_uploaded_audio_track/4
+
     with {:ok, %Embed{space: %Space{hash: space_hash}, hash: embed_hash} = embed} <-
            upload_scope_existing_video(scope),
          {:ok, track} <-
-           Assets.ingest_uploaded_audio_track(
+           ingest.(
              embed,
              %{
                "audio_track_id" => present(metadata, "audio_track_id"),
@@ -366,10 +371,15 @@ defmodule MaveCore.Uploads do
   end
 
   defp handle_custom_subtitle(scope, bucket, key, metadata) do
+    ingest =
+      if present(metadata, "audio_description") in ["true", "1", "yes"],
+        do: &Assets.ingest_uploaded_audio_description_vtt/4,
+        else: &Assets.ingest_uploaded_subtitle/4
+
     with {:ok, %Embed{space: %Space{hash: space_hash}, hash: embed_hash} = embed} <-
            upload_scope_existing_video(scope),
          {:ok, subtitle} <-
-           Assets.ingest_uploaded_subtitle(
+           ingest.(
              embed,
              %{
                "subtitle_id" => present(metadata, "subtitle_id"),
diff --git a/lib/mave_core_web/components/dashboard_components/settings.ex b/lib/mave_core_web/components/dashboard_components/settings.ex
index 6a3d4c7..72f3351 100644
--- a/lib/mave_core_web/components/dashboard_components/settings.ex
+++ b/lib/mave_core_web/components/dashboard_components/settings.ex
@@ -86,7 +86,7 @@ defmodule MaveCoreWeb.DashboardComponents.Settings do
     ~H"""
     <div
       class={[
-        "w-full h-8 px-2.5 border-y border-stone-800 font-semibold flex items-center text-xs uppercase text-stone-500",
+        "w-full h-8 px-3 border-y border-stone-800 font-semibold flex items-center text-xs uppercase text-stone-500",
         @disclosable && !@disabled && "cursor-pointer",
         !@disclosable && "cursor-default",
         @disabled && "opacity-50"
@@ -115,25 +115,31 @@ defmodule MaveCoreWeb.DashboardComponents.Settings do
 
       <div
         :if={@addable}
-        class="h-[1.125rem] w-[1.125rem] bg-stone-800 border-stone-900 mx-[0.1875rem] rounded-full flex items-center justify-center cursor-pointer hover:bg-stone-700"
-        {@rest}
+        data-settings-control="add"
+        class="h-6 w-6 flex-none flex items-center justify-center"
       >
-        <svg
-          xmlns="http://www.w3.org/2000/svg"
-          fill="none"
-          viewBox="0 0 24 24"
-          stroke-width="2"
-          stroke="currentColor"
-          class="w-4 h-4 border-transparent border-b-[0.5px]"
+        <div
+          class="h-[1.125rem] w-[1.125rem] bg-stone-800 border-stone-900 mx-[0.1875rem] rounded-full flex items-center justify-center cursor-pointer hover:bg-stone-700"
+          {@rest}
         >
-          <path stroke-linecap="round" stroke-linejoin="round" d="M12 4.5v15m7.5-7.5h-15" />
-        </svg>
+          <svg
+            xmlns="http://www.w3.org/2000/svg"
+            fill="none"
+            viewBox="0 0 24 24"
+            stroke-width="2"
+            stroke="currentColor"
+            class="w-4 h-4 border-transparent border-b-[0.5px]"
+          >
+            <path stroke-linecap="round" stroke-linejoin="round" d="M12 4.5v15m7.5-7.5h-15" />
+          </svg>
+        </div>
       </div>
 
       <div
         :if={@toggable}
+        data-settings-control="toggle"
         class={[
-          "h-6 flex items-center",
+          "h-6 w-6 flex-none flex items-center justify-center",
           @disabled && "opacity-50",
           !@disabled && "cursor-pointer"
         ]}
diff --git a/lib/mave_core_web/controllers/dashboard/subtitle_controller.ex b/lib/mave_core_web/controllers/dashboard/media_file_controller.ex
similarity index 64%
rename from lib/mave_core_web/controllers/dashboard/subtitle_controller.ex
rename to lib/mave_core_web/controllers/dashboard/media_file_controller.ex
index 2742f86..b466c80 100644
--- a/lib/mave_core_web/controllers/dashboard/subtitle_controller.ex
+++ b/lib/mave_core_web/controllers/dashboard/media_file_controller.ex
@@ -1,4 +1,4 @@
-defmodule MaveCoreWeb.Dashboard.SubtitleController do
+defmodule MaveCoreWeb.Dashboard.MediaFileController do
   @moduledoc false
 
   use MaveCoreWeb, :controller
@@ -7,6 +7,7 @@ defmodule MaveCoreWeb.Dashboard.SubtitleController do
   alias MaveCore.Assets
   alias MaveCore.Assets.Subtitle
   alias MaveCore.Assets.Video
+  alias MaveCore.AudioDescription
   alias MaveCore.Embeds
   alias MaveCore.Embeds.Embed
   alias MaveCore.Media.Storage
@@ -34,6 +35,52 @@ defmodule MaveCoreWeb.Dashboard.SubtitleController do
     end
   end
 
+  def audio(conn, %{"id" => embed_id, "track_id" => id} = params) do
+    with {:ok, space} <- resolve_space(conn.assigns.current_user, params),
+         {:ok, embed} <- Embeds.resolve_dashboard_embed(space, embed_id),
+         %{} = track <- Assets.get_audio_track_for_embed(id, embed) do
+      download_file(conn, space, embed, track.filename, track.label || track.language || "audio")
+    else
+      _ -> not_found(conn)
+    end
+  end
+
+  def description(conn, %{"id" => embed_id, "track_id" => id, "format" => format} = params) do
+    with true <- format in ["mp3", "vtt"],
+         {:ok, space} <- resolve_space(conn.assigns.current_user, params),
+         {:ok, embed} <- Embeds.resolve_dashboard_embed(space, embed_id),
+         %{} = track <- Assets.get_audio_description_for_embed(id, embed) do
+      filename = if format == "mp3", do: track.audio_filename, else: track.vtt_filename
+      download_file(conn, space, embed, filename, track.label || track.language || "description")
+    else
+      _ -> not_found(conn)
+    end
+  end
+
+  defp download_file(conn, space, embed, filename, label) when is_binary(filename) do
+    key =
+      "#{AudioDescription.version_prefix(embed.hash, Embeds.current_video_version(embed))}/#{filename}"
+
+    bucket = Storage.bucket_for_space(space.hash, space.region)
+
+    case storage_adapter().get(bucket, key, space.region) do
+      {:ok, body} when is_binary(body) ->
+        extension = Path.extname(filename)
+        name = String.replace(label, ~r/[^\p{L}\p{N} _.-]/u, "_") <> extension
+
+        conn
+        |> put_resp_content_type("application/octet-stream")
+        |> put_resp_header("x-content-type-options", "nosniff")
+        |> send_download({:binary, body}, filename: name, disposition: :attachment)
+
+      _ ->
+        not_found(conn)
+    end
+  end
+
+  defp download_file(conn, _space, _embed, _filename, _label), do: not_found(conn)
+  defp not_found(conn), do: conn |> put_status(:not_found) |> text("File not found")
+
   defp resolve_space(current_user, %{"space_id" => space_id}) when is_binary(space_id) do
     case Accounts.set_current_space_by_id(current_user, space_id) do
       {:ok, user} -> current_space(user)
diff --git a/lib/mave_core_web/dashboard_routes.ex b/lib/mave_core_web/dashboard_routes.ex
index 6023022..ab11947 100644
--- a/lib/mave_core_web/dashboard_routes.ex
+++ b/lib/mave_core_web/dashboard_routes.ex
@@ -19,6 +19,19 @@ defmodule MaveCoreWeb.DashboardRoutes do
     path_for(space_or_user, "/videos/#{video_id}/subtitles/#{subtitle_id}/download", [], opts)
   end
 
+  def audio_download_path(space, video_id, track_id) do
+    path_for(space, "/videos/#{video_id}/audio-tracks/#{track_id}/download", [], [])
+  end
+
+  def description_download_path(space, video_id, track_id, format) do
+    path_for(
+      space,
+      "/videos/#{video_id}/audio-descriptions/#{track_id}/#{format}/download",
+      [],
+      []
+    )
+  end
+
   def data_path(space_or_user, opts \\ []) do
     path_for(space_or_user, "/data", period_params(opts), opts)
   end
diff --git a/lib/mave_core_web/live/dashboard/videos/show.ex b/lib/mave_core_web/live/dashboard/videos/show.ex
index b231e45..9571d70 100644
--- a/lib/mave_core_web/live/dashboard/videos/show.ex
+++ b/lib/mave_core_web/live/dashboard/videos/show.ex
@@ -233,8 +233,13 @@ defmodule MaveCoreWeb.Dashboard.Videos.Show do
 
   def handle_info({VideoSettingsComponent, {:audio_track_uploaded, pending_track}}, socket) do
     if socket.assigns.resource_embed do
-      previous_signature = media_signature(socket.assigns.video, :audio_tracks)
-      previous_count = socket.assigns.video |> Map.get(:audio_tracks, []) |> length()
+      field =
+        if Map.get(pending_track || %{}, :kind) == :audio_description,
+          do: :audio_descriptions,
+          else: :audio_tracks
+
+      previous_signature = media_signature(socket.assigns.video, field)
+      previous_count = socket.assigns.video |> Map.get(field, []) |> length()
 
       Process.send_after(
         self(),
@@ -368,8 +373,9 @@ defmodule MaveCoreWeb.Dashboard.Videos.Show do
   def handle_info({:reload_audio_tracks, embed_id, previous_count, attempts_left}, socket) do
     case resolve_current_video_embed(socket, embed_id) do
       {:ok, %Embed{} = embed} ->
-        audio_count = dashboard_payload_count(socket, embed, :audio_tracks)
-        audio_signature = dashboard_payload_signature(socket, embed, :audio_tracks)
+        field = pending_audio_field(socket)
+        audio_count = dashboard_payload_count(socket, embed, field)
+        audio_signature = dashboard_payload_signature(socket, embed, field)
 
         if audio_count > previous_count or
              uploaded_media_signature_changed?(
@@ -941,7 +947,7 @@ defmodule MaveCoreWeb.Dashboard.Videos.Show do
     |> maybe_complete_poster_upload(video_embed, video)
     |> maybe_clear_materialized_media_processing(
       video,
-      :audio_tracks,
+      pending_audio_field(socket),
       :processing_uploaded_audio_track,
       :processing_uploaded_audio_track_signature
     )
@@ -1062,6 +1068,12 @@ defmodule MaveCoreWeb.Dashboard.Videos.Show do
     end
   end
 
+  defp pending_audio_field(socket) do
+    if get_in(socket.assigns, [:processing_uploaded_audio_track, :kind]) == :audio_description,
+      do: :audio_descriptions,
+      else: :audio_tracks
+  end
+
   defp media_signature(video, field) when is_map(video) do
     video
     |> Map.get(field, [])
@@ -1072,7 +1084,18 @@ defmodule MaveCoreWeb.Dashboard.Videos.Show do
 
   defp media_signature_item(item) when is_map(item) do
     item
-    |> Map.take([:id, :filename, :path, :label, :language, :codec, :file_size, :default])
+    |> Map.take([
+      :id,
+      :filename,
+      :path,
+      :label,
+      :language,
+      :codec,
+      :file_size,
+      :default,
+      :mp3_url,
+      :vtt_url
+    ])
     |> Enum.sort()
   end
 
diff --git a/lib/mave_core_web/live/dashboard/videos/video_settings_component.ex b/lib/mave_core_web/live/dashboard/videos/video_settings_component.ex
index 69462d7..bbeb966 100644
--- a/lib/mave_core_web/live/dashboard/videos/video_settings_component.ex
+++ b/lib/mave_core_web/live/dashboard/videos/video_settings_component.ex
@@ -3,6 +3,7 @@ defmodule MaveCoreWeb.Dashboard.Videos.VideoSettingsComponent do
 
   use MaveCoreWeb, :live_component
 
+  import MaveCoreWeb.DashboardComponents.Modals, only: [dialog: 1]
   import MaveCoreWeb.DashboardComponents.Settings
   import MaveCoreWeb.DashboardComponents.States, only: [progress_bar: 1]
 
@@ -38,6 +39,8 @@ defmodule MaveCoreWeb.Dashboard.Videos.VideoSettingsComponent do
       socket
       |> maybe_allow_poster_upload()
       |> maybe_allow_audio_track_upload()
+      |> maybe_allow_audio_description_upload()
+      |> maybe_allow_audio_description_vtt_upload()
       |> maybe_allow_subtitle_upload()
       |> assign(assigns)
       |> MaveCoreWeb.SpaceLiveAuth.attach_component()
@@ -49,7 +52,10 @@ defmodule MaveCoreWeb.Dashboard.Videos.VideoSettingsComponent do
       |> assign(:show_flow_info, @show_flow_info)
       |> assign_new(:show_flow_details, fn -> false end)
       |> assign_new(:audio_track_form, fn -> nil end)
+      |> assign_new(:audio_description_form, fn -> nil end)
+      |> assign_new(:audio_description_vtt_form, fn -> nil end)
       |> assign_new(:subtitle_form, fn -> nil end)
+      |> assign_new(:pending_media_delete, fn -> nil end)
 
     socket =
       cond do
@@ -61,7 +67,10 @@ defmodule MaveCoreWeb.Dashboard.Videos.VideoSettingsComponent do
           |> assign(:uploading_poster, false)
           |> assign(:show_flow_details, false)
           |> assign(:audio_track_form, nil)
+          |> assign(:audio_description_form, nil)
+          |> assign(:audio_description_vtt_form, nil)
           |> assign(:subtitle_form, nil)
+          |> assign(:pending_media_delete, nil)
 
         socket.assigns.has_changes ->
           assign(socket, :persisted_settings, incoming_settings)
@@ -72,6 +81,8 @@ defmodule MaveCoreWeb.Dashboard.Videos.VideoSettingsComponent do
           |> assign(:persisted_settings, incoming_settings)
           |> assign(:has_changes, false)
           |> assign(:audio_track_form, nil)
+          |> assign(:audio_description_form, nil)
+          |> assign(:audio_description_vtt_form, nil)
           |> assign(:subtitle_form, nil)
       end
 
@@ -252,6 +263,12 @@ defmodule MaveCoreWeb.Dashboard.Videos.VideoSettingsComponent do
     update_audio_track_if_changed(socket, id, :label, blank_to_nil(Map.get(params, "label")))
   end
 
+  def handle_event(event, %{"_track_id" => id} = params, socket)
+      when event in ["change_audio_track_language", "change_audio_description_language"] do
+    params = params |> Map.delete("_track_id") |> Map.put("id", id)
+    handle_event(event, params, socket)
+  end
+
   def handle_event("change_audio_track_language", %{"id" => id, "value" => language}, socket) do
     handle_event(
       "change_audio_track_language",
@@ -285,6 +302,84 @@ defmodule MaveCoreWeb.Dashboard.Videos.VideoSettingsComponent do
     end
   end
 
+  def handle_event("add_audio_description", _params, socket) do
+    {:noreply,
+     assign(socket, :audio_description_form, %{
+       mode: :new,
+       audio_track_id: nil,
+       label: gettext("Audio description"),
+       language: ""
+     })}
+  end
+
+  def handle_event("cancel_audio_description", _params, socket) do
+    {:noreply, assign(socket, :audio_description_form, nil)}
+  end
+
+  def handle_event("change_new_audio_description", %{"audio_track" => params}, socket) do
+    form = socket.assigns.audio_description_form || %{mode: :new, audio_track_id: nil}
+
+    {:noreply,
+     assign(
+       socket,
+       :audio_description_form,
+       Map.merge(form, %{label: params["label"] || "", language: params["language"] || ""})
+     )}
+  end
+
+  def handle_event("replace_audio_description", %{"id" => id}, socket) do
+    case Assets.get_audio_description_for_embed(id, socket.assigns.embed) do
+      nil ->
+        {:noreply, socket}
+
+      track ->
+        {:noreply,
+         assign(socket, :audio_description_form, %{
+           mode: :replace,
+           audio_track_id: track.id,
+           label: track.label || Languages.spoken_language(track.language),
+           language: track.language,
+           picker_ref: System.unique_integer([:positive])
+         })}
+    end
+  end
+
+  def handle_event(event, %{"id" => id} = params, socket)
+      when event in ["blur_audio_description_label", "change_audio_description_language"] do
+    field = if event == "blur_audio_description_label", do: :label, else: :language
+    value = params["value"] || get_in(params, ["audio_track", Atom.to_string(field)])
+
+    audio_description_result(
+      socket,
+      Assets.update_audio_description_outputs(socket.assigns.embed, id, %{
+        field => blank_to_nil(value)
+      })
+    )
+  end
+
+  def handle_event("upload_audio_description_vtt", %{"id" => id}, socket) do
+    case Assets.get_audio_description_for_embed(id, socket.assigns.embed) do
+      nil ->
+        {:noreply, socket}
+
+      description ->
+        {:noreply,
+         assign(socket, :audio_description_vtt_form, %{
+           audio_track_id: description.id,
+           label: description.label,
+           language: description.language,
+           picker_ref: System.unique_integer([:positive])
+         })}
+    end
+  end
+
+  def handle_event("delete_audio_description", %{"id" => id}, socket) do
+    audio_description_result(
+      socket,
+      Assets.delete_audio_description_outputs(socket.assigns.embed, id)
+    )
+  end
+
   def handle_event("add_subtitle", _params, socket) do
     {:noreply,
      assign(socket, :subtitle_form, %{
@@ -359,6 +454,43 @@ defmodule MaveCoreWeb.Dashboard.Videos.VideoSettingsComponent do
     end
   end
 
+  def handle_event("request_media_delete", %{"kind" => kind, "id" => id}, socket) do
+    target =
+      case kind do
+        "audio_track" -> scoped_audio_track(socket, id)
+        "audio_description" -> Assets.get_audio_description_for_embed(id, socket.assigns.embed)
+        "subtitle" -> scoped_subtitle(socket, id)
+        _ -> nil
+      end
+
+    if target && !Map.get(target, :default, false) do
+      label = Map.get(target, :label) || Map.get(target, :language) || gettext("this track")
+      {:noreply, assign(socket, :pending_media_delete, %{kind: kind, id: id, label: label})}
+    else
+      {:noreply, socket}
+    end
+  end
+
+  def handle_event("cancel_media_delete", _, socket),
+    do: {:noreply, assign(socket, :pending_media_delete, nil)}
+
+  def handle_event("confirm_media_delete", _, socket) do
+    case socket.assigns.pending_media_delete do
+      %{kind: kind, id: id} ->
+        event =
+          %{
+            "audio_track" => "delete_audio_track",
+            "audio_description" => "delete_audio_description",
+            "subtitle" => "delete_subtitle"
+          }[kind]
+
+        handle_event(event, %{"id" => id}, assign(socket, :pending_media_delete, nil))
+
+      _ ->
+        {:noreply, socket}
+    end
+  end
+
   @impl true
   def handle_event("noop", _params, socket), do: {:noreply, socket}
 
@@ -403,6 +535,54 @@ defmodule MaveCoreWeb.Dashboard.Videos.VideoSettingsComponent do
     {:noreply, socket}
   end
 
+  def handle_progress(:audio_description_file, entry, socket) do
+    form = socket.assigns.audio_description_form || %{}
+
+    pending = %{
+      id: form[:audio_track_id],
+      mode: form[:mode] || :new,
+      label: form[:label],
+      language: form[:language],
+      kind: :audio_description
+    }
+
+    if entry.done? do
+      consume_uploaded_entries(socket, :audio_description_file, fn _meta, _entry ->
+        {:ok, :uploaded}
+      end)
+
+      notify_parent({:audio_track_uploaded, pending})
+      {:noreply, assign(socket, :audio_description_form, nil)}
+    else
+      {:noreply, socket}
+    end
+  end
+
+  def handle_progress(:audio_description_vtt_file, entry, socket) do
+    form = socket.assigns.audio_description_vtt_form || %{}
+
+    if entry.done? do
+      consume_uploaded_entries(socket, :audio_description_vtt_file, fn _, _ ->
+        {:ok, :uploaded}
+      end)
+
+      notify_parent(
+        {:audio_track_uploaded,
+         %{
+           id: form[:audio_track_id],
+           mode: :replace,
+           label: form[:label],
+           language: form[:language],
+           kind: :audio_description
+         }}
+      )
+
+      {:noreply, assign(socket, :audio_description_vtt_form, nil)}
+    else
+      {:noreply, socket}
+    end
+  end
+
   def handle_progress(:subtitle_file, entry, socket) do
     pending_subtitle = pending_subtitle_upload(socket)
 
@@ -470,6 +650,25 @@ defmodule MaveCoreWeb.Dashboard.Videos.VideoSettingsComponent do
     {:ok, options, socket}
   end
 
+  def presign_audio_description_upload(entry, socket) do
+    description_socket = assign(socket, :audio_track_form, socket.assigns.audio_description_form)
+    {:ok, options, _} = presign_audio_track_upload(entry, description_socket)
+    {:ok, Map.put(options, :audio_description, true), socket}
+  end
+
+  def presign_audio_description_vtt_upload(entry, socket) do
+    form = socket.assigns.audio_description_vtt_form || %{}
+
+    subtitle_socket =
+      assign(socket, :subtitle_form, %{
+        subtitle_id: form[:audio_track_id],
+        language: form[:language]
+      })
+
+    {:ok, options, _} = presign_subtitle_upload(entry, subtitle_socket)
+    {:ok, Map.put(options, :audio_description, true), socket}
+  end
+
   def presign_subtitle_upload(_entry, socket) do
     form = socket.assigns.subtitle_form || %{}
 
@@ -519,6 +718,8 @@ defmodule MaveCoreWeb.Dashboard.Videos.VideoSettingsComponent do
               uploads={@uploads}
               uploading_poster={@uploading_poster}
               audio_track_form={@audio_track_form}
+              audio_description_form={@audio_description_form}
+              audio_description_vtt_form={@audio_description_vtt_form}
               subtitle_form={@subtitle_form}
               processing_uploaded_audio_track={@processing_uploaded_audio_track}
               processing_uploaded_subtitle={@processing_uploaded_subtitle}
@@ -538,6 +739,23 @@ defmodule MaveCoreWeb.Dashboard.Videos.VideoSettingsComponent do
           <.tab_navigation current_tab={@current_tab} myself={@myself} />
         </:footer>
       </.settings_panel>
+      <.dialog
+        :if={@pending_media_delete}
+        id="delete-media-dialog"
+        show={true}
+        title={gettext("Delete track?")}
+        confirm_label={gettext("Delete")}
+        confirm_variant="danger"
+        on_confirm={JS.push("confirm_media_delete", target: @myself)}
+        on_cancel={JS.push("cancel_media_delete", target: @myself)}
+      >
+        {gettext("Are you sure you want to delete “%{name}” from this video?",
+          name: @pending_media_delete.label
+        )}
+        <span :if={@pending_media_delete.kind == "audio_description"} class="block mt-2">
+          {gettext("Its audio and description text will both be removed.")}
+        </span>
+      </.dialog>
     </div>
     """
   end
@@ -608,11 +826,10 @@ defmodule MaveCoreWeb.Dashboard.Videos.VideoSettingsComponent do
         audio_only={@video.original.audio_only}
         renditions={@video.renditions}
         audio_tracks={@video.audio_tracks}
+        audio_descriptions={Map.get(@video, :audio_descriptions, [])}
         subtitles={@video.subtitles}
       />
 
-      <.audio_descriptions_section descriptions={Map.get(@video, :audio_descriptions, [])} />
-
       <.settings_header
         :if={@show_flow_info && @video.flow}
         title="flow"
@@ -870,6 +1087,8 @@ defmodule MaveCoreWeb.Dashboard.Videos.VideoSettingsComponent do
   attr :uploads, :map, required: true
   attr :uploading_poster, :boolean, required: true
   attr :audio_track_form, :map, default: nil
+  attr :audio_description_form, :map, default: nil
+  attr :audio_description_vtt_form, :map, default: nil
   attr :subtitle_form, :map, default: nil
   attr :processing_uploaded_audio_track, :map, default: nil
   attr :processing_uploaded_subtitle, :map, default: nil
@@ -915,8 +1134,26 @@ defmodule MaveCoreWeb.Dashboard.Videos.VideoSettingsComponent do
       <.audio_tracks_options_section
         :if={@show_audio_tracks_section}
         tracks={@video.audio_tracks}
+        current_space={@current_space}
+        video_id={@video.id}
         audio_track_form={@audio_track_form}
-        processing_uploaded_audio_track={@processing_uploaded_audio_track}
+        processing_uploaded_audio_track={
+          audio_upload_pending(@processing_uploaded_audio_track, :audio_track)
+        }
+        uploads={@uploads}
+        myself={@myself}
+      />
+      <.audio_tracks_options_section
+        :if={@show_audio_tracks_section}
+        kind={:audio_description}
+        current_space={@current_space}
+        video_id={@video.id}
+        tracks={Map.get(@video, :audio_descriptions, [])}
+        audio_track_form={@audio_description_form}
+        vtt_form={@audio_description_vtt_form}
+        processing_uploaded_audio_track={
+          audio_upload_pending(@processing_uploaded_audio_track, :audio_description)
+        }
         uploads={@uploads}
         myself={@myself}
       />
@@ -1598,9 +1835,9 @@ defmodule MaveCoreWeb.Dashboard.Videos.VideoSettingsComponent do
 
   defp processing_audio_track_row(assigns) do
     ~H"""
-    <div class="relative w-full flex items-center my-1.5 pointer-events-none">
+    <div class="relative w-full flex items-center pointer-events-none">
       <div class="flex-grow border-r border-stone-900 pr-2">
-        <div class="flex flex-col space-y-1.5">
+        <div class="flex flex-col space-y-2">
           <input
             type="text"
             value={Map.get(@track, :label) || gettext("Audio track")}
@@ -1639,13 +1876,9 @@ defmodule MaveCoreWeb.Dashboard.Videos.VideoSettingsComponent do
         </div>
       </div>
 
-      <div class="relative flex-none h-6 px-1 text-sm bg-stone-800 text-stone-400 outline-none overflow-hidden rounded-sm flex items-center justify-center">
+      <div class="flex-none h-6 w-6 flex items-center justify-center text-stone-400">
         <.media_spinner />
       </div>
-
-      <div class="border-l border-stone-900 flex-none h-6 px-1 text-sm outline-none overflow-hidden rounded-sm flex items-center justify-end">
-        <.remove_icon />
-      </div>
     </div>
     """
   end
@@ -1655,7 +1888,7 @@ defmodule MaveCoreWeb.Dashboard.Videos.VideoSettingsComponent do
 
   defp processing_subtitle_row(assigns) do
     ~H"""
-    <div class="relative w-full flex items-center my-1.5 pointer-events-none">
+    <div class="relative w-full flex items-center pointer-events-none">
       <div class="relative flex-grow flex border-r border-stone-900 pr-2">
         <div class="w-full">
           <div class="relative">
@@ -1690,80 +1923,242 @@ defmodule MaveCoreWeb.Dashboard.Videos.VideoSettingsComponent do
         </div>
       </div>
 
-      <div class="relative flex-none h-6 px-1 text-sm bg-stone-800 text-stone-400 outline-none overflow-hidden rounded-sm flex items-center justify-center">
-        <.download_icon />
-      </div>
-
-      <div class="relative ml-px flex-none h-6 px-1 text-sm bg-stone-800 text-stone-400 outline-none overflow-hidden rounded-sm flex items-center justify-center">
+      <div class="flex-none h-6 w-6 flex items-center justify-center text-stone-400">
         <.media_spinner />
       </div>
-
-      <div class="border-l border-stone-900 flex-none h-6 px-1 text-sm outline-none overflow-hidden rounded-sm flex items-center justify-end">
-        <.remove_icon />
-      </div>
     </div>
     """
   end
 
-  defp download_icon(assigns) do
+  defp media_spinner(assigns) do
     ~H"""
-    <svg
-      xmlns="http://www.w3.org/2000/svg"
-      fill="none"
-      viewBox="0 0 24 24"
-      stroke-width="1.5"
-      stroke="currentColor"
-      class="w-4 h-4"
-    >
-      <path
-        stroke-linecap="round"
-        stroke-linejoin="round"
-        d="M12 4.5v15m0 0l6.75-6.75M12 19.5l-6.75-6.75"
-      />
-    </svg>
+    <div class="h-4 w-4 animate-spin rounded-full border border-stone-500 border-t-transparent"></div>
     """
   end
 
-  defp replace_icon(assigns) do
+  attr :id, :string, required: true
+  attr :trigger_id, :string, required: true
+  attr :label, :string, required: true
+  attr :items, :list, required: true
+  attr :busy, :boolean, default: false
+  attr :myself, :any, required: true
+  slot :inner_block
+
+  defp media_file_menu(assigns) do
     ~H"""
-    <svg
-      xmlns="http://www.w3.org/2000/svg"
-      fill="none"
-      viewBox="0 0 24 24"
-      stroke-width="2"
-      stroke="currentColor"
-      class="h-3.5 w-3.5"
+    <div
+      id={"#{@id}-root"}
+      phx-hook="file_menu"
+      data-settings-control="menu"
+      class="relative flex-none h-6 w-6 flex items-center justify-center text-stone-500"
     >
-      <path
-        stroke-linecap="round"
-        stroke-linejoin="round"
-        d="M16.023 9.348h4.992v-.001M2.985 19.644v-4.992m0 0h4.992m-4.992 0 3.181 3.183a8.25 8.25 0 0 0 13.803-3.7M4.031 9.865a8.25 8.25 0 0 1 13.803-3.7l3.181 3.182"
-      />
-    </svg>
+      <button
+        type="button"
+        id={@trigger_id}
+        aria-label={@label}
+        aria-haspopup="menu"
+        aria-expanded="false"
+        aria-controls={@id}
+        data-file-menu-trigger="true"
+        disabled={@busy}
+        class="flex h-6 w-6 items-center justify-center cursor-pointer rounded-sm transition-colors hover:bg-stone-800 hover:text-stone-300 outline-none focus-visible:bg-stone-800 focus-visible:ring-1 focus-visible:ring-blue-500"
+      >
+        <.media_spinner :if={@busy} />
+        <.icon :if={!@busy} name="hero-ellipsis-horizontal" class="h-4 w-4" />
+      </button>
+      <div
+        id={@id}
+        role="menu"
+        aria-labelledby={@trigger_id}
+        data-file-menu-panel
+        style="display: none;"
+        class="fixed z-[100] w-52 overflow-hidden rounded-lg bg-stone-800 text-sm shadow-xl shadow-black/40 ring-1 ring-white/10"
+      >
+        <div :for={item <- @items} class={item.separator && "border-t border-white/10"}>
+          <a
+            :if={item.href}
+            id={item.id}
+            href={item.href}
+            download={item.filename}
+            role="menuitem"
+            tabindex="-1"
+            class="group flex w-full items-center gap-2.5 px-3.5 py-3 text-left text-stone-200 outline-none transition-colors duration-150 hover:bg-white/[0.05] hover:text-white focus-visible:bg-white/[0.05] focus-visible:ring-1 focus-visible:ring-inset focus-visible:ring-white/20 cursor-pointer"
+          >
+            <.icon
+              name={item.icon}
+              class="h-4 w-4 shrink-0 text-stone-400 transition-colors group-hover:text-stone-300 group-focus-visible:text-stone-300"
+            />
+            <span class="flex-1 text-xs font-medium">{item.label}</span>
+            <span
+              :if={item.format}
+              class="rounded border border-stone-600/60 px-1 py-0.5 text-[10px] leading-none text-stone-400"
+            >{item.format}</span>
+          </a>
+          <button
+            :if={!item.href}
+            id={item.id}
+            type="button"
+            role="menuitem"
+            tabindex="-1"
+            disabled={item.disabled}
+            aria-label={item.label}
+            phx-click={JS.push(item.event, target: @myself, value: item.value)}
+            class={[
+              "group flex w-full items-center gap-2.5 px-3.5 py-3 text-left outline-none transition-colors duration-150 focus-visible:ring-1 focus-visible:ring-inset focus-visible:ring-white/20",
+              item.disabled && "opacity-35 cursor-not-allowed",
+              !item.disabled && "hover:bg-white/[0.05] focus-visible:bg-white/[0.05] cursor-pointer",
+              item.danger && "text-red-400",
+              !item.danger && "text-stone-200 hover:text-white"
+            ]}
+          >
+            <.icon
+              name={item.icon}
+              class={[
+                "h-4 w-4 shrink-0 transition-colors",
+                item.danger && "text-red-400",
+                !item.danger &&
+                  "text-stone-400 group-hover:text-stone-300 group-focus-visible:text-stone-300"
+              ]}
+            />
+            <span class="flex-1 text-xs font-medium">{item.label}</span>
+            <span
+              :if={item.format}
+              class="rounded border border-stone-600/60 px-1 py-0.5 text-[10px] leading-none text-stone-400"
+            >{item.format}</span>
+          </button>
+        </div>
+      </div>
+      {render_slot(@inner_block)}
+    </div>
     """
   end
 
-  defp remove_icon(assigns) do
-    ~H"""
-    <svg
-      xmlns="http://www.w3.org/2000/svg"
-      fill="none"
-      viewBox="0 0 24 24"
-      stroke-width="2"
-      stroke="currentColor"
-      class="h-4 w-4 rotate-45"
-    >
-      <path stroke-linecap="round" stroke-linejoin="round" d="M12 4.5v15m7.5-7.5h-15" />
-    </svg>
-    """
+  defp menu_item(id, label, icon, opts) do
+    Map.merge(
+      %{
+        id: id,
+        label: label,
+        icon: icon,
+        href: nil,
+        filename: nil,
+        format: nil,
+        event: nil,
+        value: %{},
+        danger: false,
+        disabled: false,
+        separator: false
+      },
+      Map.new(opts)
+    )
   end
 
-  defp media_spinner(assigns) do
-    ~H"""
-    <div class="h-4 w-4 animate-spin rounded-full border border-stone-500 border-t-transparent"></div>
-    """
+  defp audio_menu_items(kind, track, space, video_id, events) do
+    prefix = if kind == :audio_description, do: "audio-description", else: "audio-track"
+    format = if kind == :audio_description, do: "MP3", else: audio_track_format(track)
+
+    href =
+      if kind == :audio_description,
+        do: DashboardRoutes.description_download_path(space, video_id, track.id, "mp3"),
+        else: DashboardRoutes.audio_download_path(space, video_id, track.id)
+
+    base = [
+      menu_item(
+        "#{prefix}-download-#{track.id}",
+        gettext("Download audio"),
+        "hero-arrow-down-tray",
+        href: href,
+        filename: true,
+        format: format
+      ),
+      menu_item(
+        "#{prefix}-replace-audio-#{track.id}",
+        gettext("Replace audio"),
+        "hero-arrow-path",
+        event: events.replace,
+        value: %{id: track.id},
+        format: format
+      )
+    ]
+
+    text =
+      if kind == :audio_description do
+        download =
+          if track.vtt_url do
+            [
+              menu_item(
+                "#{prefix}-download-vtt-#{track.id}",
+                gettext("Download text"),
+                "hero-arrow-down-tray",
+                href: DashboardRoutes.description_download_path(space, video_id, track.id, "vtt"),
+                filename: true,
+                format: "VTT",
+                separator: true
+              )
+            ]
+          else
+            []
+          end
+
+        download ++
+          [
+            menu_item(
+              "#{prefix}-vtt-#{track.id}",
+              if(track.vtt_url, do: gettext("Replace text"), else: gettext("Upload text")),
+              "hero-document-text",
+              event: "upload_audio_description_vtt",
+              value: %{id: track.id},
+              format: "VTT",
+              separator: download == []
+            )
+          ]
+      else
+        []
+      end
+
+    base ++
+      text ++
+      [
+        menu_item(
+          "delete-#{prefix}-#{track.id}",
+          gettext("Delete"),
+          "hero-trash",
+          event: "request_media_delete",
+          value: %{kind: Atom.to_string(kind), id: track.id},
+          danger: true,
+          separator: true,
+          disabled: track.default
+        )
+      ]
   end
 
+  defp subtitle_menu_items(subtitle, space, video_id) do
+    [
+      menu_item(
+        "subtitle-download-#{subtitle.id}",
+        gettext("Download text"),
+        "hero-arrow-down-tray",
+        href: DashboardRoutes.subtitle_download_path(space, video_id, subtitle.id),
+        filename: subtitle_download_filename(subtitle),
+        format: "VTT"
+      ),
+      menu_item("subtitle-replace-#{subtitle.id}", gettext("Replace text"), "hero-arrow-path",
+        event: "replace_subtitle",
+        value: %{id: subtitle.id},
+        format: "VTT"
+      ),
+      menu_item("delete-subtitle-#{subtitle.id}", gettext("Delete"), "hero-trash",
+        event: "request_media_delete",
+        value: %{kind: "subtitle", id: subtitle.id},
+        danger: true,
+        separator: true
+      )
+    ]
+  end
+
+  attr :current_space, :map, required: true
+  attr :video_id, :string, required: true
+  attr :kind, :atom, default: :audio_track
+  attr :vtt_form, :map, default: nil
   attr :tracks, :list, required: true
   attr :audio_track_form, :map, default: nil
   attr :processing_uploaded_audio_track, :map, default: nil
@@ -1773,12 +2168,38 @@ defmodule MaveCoreWeb.Dashboard.Videos.VideoSettingsComponent do
   defp audio_tracks_options_section(assigns) do
     assigns = assign(assigns, :language_options, language_options())
     has_tracks = Enum.any?(assigns.tracks || [])
-    assigns = assign(assigns, :has_tracks, has_tracks)
+
+    assigns =
+      assigns
+      |> assign(:has_tracks, has_tracks)
+      |> assign(
+        :heading,
+        if(assigns.kind == :audio_description, do: "audio descriptions", else: "audio tracks")
+      )
+      |> assign(
+        :track_label,
+        if(assigns.kind == :audio_description,
+          do: gettext("Audio description"),
+          else: gettext("Audio track")
+        )
+      )
+      |> assign(
+        :control_prefix,
+        if(assigns.kind == :audio_description, do: "audio-description", else: "audio-track")
+      )
+      |> assign(
+        :upload_name,
+        if(assigns.kind == :audio_description,
+          do: :audio_description_file,
+          else: :audio_track_file
+        )
+      )
+      |> assign(:events, audio_management_events(assigns.kind))
 
     ~H"""
-    <div>
-      <.settings_header title="audio tracks" addable phx-click="add_audio_track" phx-target={@myself} />
-      <div class="pl-3 pr-2.5 py-1.5 text-sm text-stone-400">
+    <div id={"#{@control_prefix}-settings"}>
+      <.settings_header title={@heading} addable phx-click={@events.add} phx-target={@myself} />
+      <div class="px-3 py-1 space-y-2 text-sm text-stone-400">
         <div
           :if={!@has_tracks and is_nil(@audio_track_form) and !@processing_uploaded_audio_track}
           class="h-1"
@@ -1787,29 +2208,32 @@ defmodule MaveCoreWeb.Dashboard.Videos.VideoSettingsComponent do
         <div
           :for={track <- @tracks}
           class={[
-            "relative w-full flex items-center my-1.5",
+            "relative w-full flex items-center",
             processing_audio_track?(@processing_uploaded_audio_track, track) && "pointer-events-none"
           ]}
         >
           <div class="flex-grow border-r border-stone-900 pr-2">
-            <div class="flex flex-col space-y-1.5">
+            <div class="flex flex-col space-y-2">
               <input
                 name="audio_track[label]"
                 type="text"
                 value={track.label}
-                placeholder="Audio track"
+                placeholder={@track_label}
                 class="w-full h-6 bg-stone-800 border-b border-stone-800 px-2 py-0.5 text-sm text-stone-400 outline-none focus:ring-blue-600 ring-1 rounded-sm ring-transparent"
-                phx-blur="blur_audio_track_label"
+                phx-blur={@events.blur}
                 phx-target={@myself}
                 phx-value-id={track.id}
               />
-              <div class="relative">
+              <form
+                id={"#{@control_prefix}-language-form-#{track.id}"}
+                class="relative"
+                phx-change={@events.language}
+                phx-target={@myself}
+              >
+                <input type="hidden" name="_track_id" value={track.id} />
                 <select
                   name="audio_track[language]"
                   class="w-full h-6 bg-stone-800 border-b border-stone-800 px-2 py-0.5 pr-7 text-sm text-stone-400 outline-none focus:ring-blue-600 ring-1 rounded-sm ring-transparent appearance-none"
-                  phx-change="change_audio_track_language"
-                  phx-target={@myself}
-                  phx-value-id={track.id}
                 >
                   {Phoenix.HTML.Form.options_for_select(@language_options, track.language || "")}
                 </select>
@@ -1831,97 +2255,52 @@ defmodule MaveCoreWeb.Dashboard.Videos.VideoSettingsComponent do
                     />
                   </svg>
                 </div>
-              </div>
-            </div>
-          </div>
-
-          <div class={
-              "relative flex-none h-6 px-1 text-sm bg-stone-800 text-stone-400 outline-none overflow-hidden rounded-sm flex items-center justify-center #{if active_audio_upload_target?(@audio_track_form, track), do: "hover:bg-stone-600", else: "cursor-pointer hover:bg-stone-600"}"
-            }>
-            <%= if active_audio_upload_target?(@audio_track_form, track) do %>
-              <form
-                id={"audio-track-picker-#{track.id}-#{@audio_track_form[:picker_ref]}"}
-                phx-change="noop"
-                phx-target={@myself}
-                class="absolute inset-0"
-                phx-hook="auto_open_file_picker"
-                data-picker-ref={@audio_track_form[:picker_ref]}
-              >
-                <.live_file_input
-                  upload={@uploads.audio_track_file}
-                  class="absolute inset-0 opacity-0 cursor-pointer"
-                />
               </form>
-            <% end %>
-
-            <%= if (@uploads.audio_track_file.entries != [] and active_audio_upload_target?(@audio_track_form, track)) or
-                      processing_audio_track?(@processing_uploaded_audio_track, track) do %>
-              <.media_spinner />
-            <% else %>
-              <button
-                type="button"
-                class="flex h-full items-center justify-center cursor-pointer"
-                phx-click="replace_audio_track"
-                phx-target={@myself}
-                phx-value-id={track.id}
-              >
-                <svg
-                  xmlns="http://www.w3.org/2000/svg"
-                  fill="none"
-                  viewBox="0 0 24 24"
-                  stroke-width="2"
-                  stroke="currentColor"
-                  class="h-3.5 w-3.5"
-                >
-                  <path
-                    stroke-linecap="round"
-                    stroke-linejoin="round"
-                    d="M16.023 9.348h4.992v-.001M2.985 19.644v-4.992m0 0h4.992m-4.992 0 3.181 3.183a8.25 8.25 0 0 0 13.803-3.7M4.031 9.865a8.25 8.25 0 0 1 13.803-3.7l3.181 3.182"
-                  />
-                </svg>
-              </button>
-            <% end %>
+            </div>
           </div>
 
-          <div class="border-l border-stone-900 flex-none h-6 px-1 text-sm outline-none overflow-hidden rounded-sm flex items-center justify-end">
-            <button
-              id={"delete-audio-track-#{track.id}"}
-              type="button"
-              aria-label={gettext("Remove audio track")}
-              class={[
-                "relative w-4 h-6 flex items-center justify-end text-stone-500 phx-click-loading:pointer-events-none phx-click-loading:cursor-wait phx-click-loading:text-stone-300",
-                track.default && "opacity-40 pointer-events-none",
-                !track.default && "cursor-pointer hover:text-stone-300"
-              ]}
-              phx-click={
-                JS.push("delete_audio_track",
-                  target: @myself,
-                  value: %{id: track.id},
-                  loading: "#delete-audio-track-#{track.id}"
-                )
-              }
+          <.media_file_menu
+            id={"#{@control_prefix}-files-#{track.id}"}
+            trigger_id={"#{@control_prefix}-replace-#{track.id}"}
+            label={
+              if @kind == :audio_description,
+                do: gettext("Edit audio description"),
+                else: gettext("Edit audio track")
+            }
+            items={audio_menu_items(@kind, track, @current_space, @video_id, @events)}
+            busy={
+              processing_audio_track?(@processing_uploaded_audio_track, track) ||
+                (@uploads[@upload_name].entries != [] &&
+                   active_audio_upload_target?(@audio_track_form, track))
+            }
+            myself={@myself}
+          >
+            <form
+              :if={active_audio_upload_target?(@audio_track_form, track)}
+              id={"#{@control_prefix}-picker-#{track.id}-#{@audio_track_form[:picker_ref]}"}
+              phx-change="noop"
+              phx-target={@myself}
+              class="absolute inset-0 pointer-events-none"
+              phx-hook="auto_open_file_picker"
+              data-picker-ref={@audio_track_form[:picker_ref]}
             >
-              <span class="inline-flex items-center justify-end phx-click-loading:hidden">
-                <svg
-                  xmlns="http://www.w3.org/2000/svg"
-                  fill="none"
-                  viewBox="0 0 24 24"
-                  stroke-width="2"
-                  stroke="currentColor"
-                  class="h-4 w-4 rotate-45"
-                >
-                  <path
-                    stroke-linecap="round"
-                    stroke-linejoin="round"
-                    d="M12 4.5v15m7.5-7.5h-15"
-                  />
-                </svg>
-              </span>
-              <span class="hidden h-4 w-4 items-center justify-center phx-click-loading:inline-flex">
-                <span class="h-3.5 w-3.5 animate-spin rounded-full border border-stone-500 border-t-transparent"></span>
-              </span>
-            </button>
-          </div>
+              <.live_file_input upload={@uploads[@upload_name]} class="absolute inset-0 opacity-0" />
+            </form>
+            <form
+              :if={@vtt_form && @vtt_form.audio_track_id == track.id}
+              id={"audio-description-vtt-picker-#{track.id}-#{@vtt_form.picker_ref}"}
+              phx-change="noop"
+              phx-target={@myself}
+              class="absolute inset-0 pointer-events-none"
+              phx-hook="auto_open_file_picker"
+              data-picker-ref={@vtt_form.picker_ref}
+            >
+              <.live_file_input
+                upload={@uploads.audio_description_vtt_file}
+                class="absolute inset-0 opacity-0"
+              />
+            </form>
+          </.media_file_menu>
         </div>
 
         <.processing_audio_track_row
@@ -1931,19 +2310,19 @@ defmodule MaveCoreWeb.Dashboard.Videos.VideoSettingsComponent do
         />
 
         <%= if @audio_track_form && @audio_track_form.mode == :new do %>
-          <div class="w-full flex items-center my-1.5">
+          <div class="w-full flex items-center">
             <div class="flex-grow border-r border-stone-900 pr-2">
               <form
-                id="new-audio-track-form"
-                phx-change="change_new_audio_track"
+                id={"new-#{@control_prefix}-form"}
+                phx-change={@events.change}
                 phx-target={@myself}
-                class="flex flex-col space-y-1.5"
+                class="flex flex-col space-y-2"
               >
                 <input
                   name="audio_track[label]"
                   type="text"
                   value={@audio_track_form.label}
-                  placeholder="Audio track"
+                  placeholder={@track_label}
                   class="w-full h-6 bg-stone-800 border-b border-stone-800 px-2 py-0.5 text-sm text-stone-400 outline-none focus:ring-blue-600 ring-1 rounded-sm ring-transparent"
                 />
                 <div class="relative">
@@ -1979,16 +2358,16 @@ defmodule MaveCoreWeb.Dashboard.Videos.VideoSettingsComponent do
             </div>
 
             <form
-              id="new-audio-track-upload-form"
+              id={"new-#{@control_prefix}-upload-form"}
               phx-change="noop"
               phx-target={@myself}
               class="relative flex-none h-6 px-1 text-sm bg-stone-800 text-stone-400 outline-none overflow-hidden rounded-sm flex items-center justify-center cursor-pointer hover:bg-stone-600"
             >
               <.live_file_input
-                upload={@uploads.audio_track_file}
+                upload={@uploads[@upload_name]}
                 class="absolute inset-0 opacity-0 cursor-pointer"
               />
-              <%= if @uploads.audio_track_file.entries == [] do %>
+              <%= if @uploads[@upload_name].entries == [] do %>
                 <svg
                   xmlns="http://www.w3.org/2000/svg"
                   fill="none"
@@ -2013,7 +2392,7 @@ defmodule MaveCoreWeb.Dashboard.Videos.VideoSettingsComponent do
               <button
                 type="button"
                 class="w-4 h-6 flex items-center justify-end text-stone-500 cursor-pointer hover:text-stone-300"
-                phx-click="cancel_audio_track"
+                phx-click={@events.cancel}
                 phx-target={@myself}
               >
                 <svg
@@ -2051,7 +2430,7 @@ defmodule MaveCoreWeb.Dashboard.Videos.VideoSettingsComponent do
     ~H"""
     <div>
       <.settings_header title="subtitles" addable phx-click="add_subtitle" phx-target={@myself} />
-      <div class="pl-3 pr-2.5 py-1.5 text-sm text-stone-400">
+      <div class="px-3 py-1 space-y-2 text-sm text-stone-400">
         <div
           :if={!@has_subtitles and is_nil(@subtitle_form) and !@processing_uploaded_subtitle}
           class="h-1"
@@ -2060,7 +2439,7 @@ defmodule MaveCoreWeb.Dashboard.Videos.VideoSettingsComponent do
         <div
           :for={subtitle <- @subtitles}
           class={[
-            "relative w-full flex items-center my-1.5",
+            "relative w-full flex items-center",
             processing_subtitle?(@processing_uploaded_subtitle, subtitle) && "pointer-events-none"
           ]}
         >
@@ -2101,99 +2480,30 @@ defmodule MaveCoreWeb.Dashboard.Videos.VideoSettingsComponent do
             </form>
           </div>
 
-          <a
-            href={DashboardRoutes.subtitle_download_path(@current_space, @video.id, subtitle.id)}
-            download={subtitle_download_filename(subtitle)}
-            class="relative flex-none h-6 px-1 text-sm bg-stone-800 text-stone-400 outline-none overflow-hidden rounded-sm flex items-center justify-center cursor-pointer hover:bg-stone-600"
+          <.media_file_menu
+            id={"subtitle-files-#{subtitle.id}"}
+            trigger_id={"subtitle-edit-#{subtitle.id}"}
+            label={gettext("Edit subtitles")}
+            items={subtitle_menu_items(subtitle, @current_space, @video.id)}
+            busy={
+              processing_subtitle?(@processing_uploaded_subtitle, subtitle) ||
+                (@uploads.subtitle_file.entries != [] &&
+                   active_subtitle_upload_target?(@subtitle_form, subtitle))
+            }
+            myself={@myself}
           >
-            <svg
-              xmlns="http://www.w3.org/2000/svg"
-              fill="none"
-              viewBox="0 0 24 24"
-              stroke-width="1.5"
-              stroke="currentColor"
-              class="w-4 h-4"
-            >
-              <path
-                stroke-linecap="round"
-                stroke-linejoin="round"
-                d="M12 4.5v15m0 0l6.75-6.75M12 19.5l-6.75-6.75"
-              />
-            </svg>
-          </a>
-
-          <div class="relative ml-px flex-none h-6 px-1 text-sm bg-stone-800 text-stone-400 outline-none overflow-hidden rounded-sm flex items-center justify-center cursor-pointer hover:bg-stone-600">
-            <%= if active_subtitle_upload_target?(@subtitle_form, subtitle) do %>
-              <form
-                id={"subtitle-picker-#{subtitle.id}-#{@subtitle_form[:picker_ref]}"}
-                phx-change="noop"
-                phx-target={@myself}
-                class="absolute inset-0"
-                phx-hook="auto_open_file_picker"
-                data-picker-ref={@subtitle_form[:picker_ref]}
-              >
-                <.live_file_input
-                  upload={@uploads.subtitle_file}
-                  class="absolute inset-0 opacity-0 cursor-pointer"
-                />
-              </form>
-              <%= if @uploads.subtitle_file.entries != [] do %>
-                <.media_spinner />
-              <% else %>
-                <.replace_icon />
-              <% end %>
-            <% else %>
-              <%= if processing_subtitle?(@processing_uploaded_subtitle, subtitle) do %>
-                <.media_spinner />
-              <% else %>
-                <button
-                  type="button"
-                  class="flex h-full items-center justify-center cursor-pointer"
-                  phx-click="replace_subtitle"
-                  phx-target={@myself}
-                  phx-value-id={subtitle.id}
-                >
-                  <.replace_icon />
-                </button>
-              <% end %>
-            <% end %>
-          </div>
-
-          <div class="border-l border-stone-900 flex-none h-6 px-1 text-sm outline-none overflow-hidden rounded-sm flex items-center justify-end">
-            <button
-              id={"delete-subtitle-#{subtitle.id}"}
-              type="button"
-              aria-label={gettext("Remove subtitle")}
-              class="relative w-4 h-6 flex items-center justify-end text-stone-500 cursor-pointer hover:text-stone-300 phx-click-loading:pointer-events-none phx-click-loading:cursor-wait phx-click-loading:text-stone-300"
-              phx-click={
-                JS.push("delete_subtitle",
-                  target: @myself,
-                  value: %{id: subtitle.id},
-                  loading: "#delete-subtitle-#{subtitle.id}"
-                )
-              }
+            <form
+              :if={active_subtitle_upload_target?(@subtitle_form, subtitle)}
+              id={"subtitle-picker-#{subtitle.id}-#{@subtitle_form[:picker_ref]}"}
+              phx-change="noop"
+              phx-target={@myself}
+              class="absolute inset-0 pointer-events-none"
+              phx-hook="auto_open_file_picker"
+              data-picker-ref={@subtitle_form[:picker_ref]}
             >
-              <span class="inline-flex items-center justify-end phx-click-loading:hidden">
-                <svg
-                  xmlns="http://www.w3.org/2000/svg"
-                  fill="none"
-                  viewBox="0 0 24 24"
-                  stroke-width="2"
-                  stroke="currentColor"
-                  class="h-4 w-4 rotate-45"
-                >
-                  <path
-                    stroke-linecap="round"
-                    stroke-linejoin="round"
-                    d="M12 4.5v15m7.5-7.5h-15"
-                  />
-                </svg>
-              </span>
-              <span class="hidden h-4 w-4 items-center justify-center phx-click-loading:inline-flex">
-                <span class="h-3.5 w-3.5 animate-spin rounded-full border border-stone-500 border-t-transparent"></span>
-              </span>
-            </button>
-          </div>
+              <.live_file_input upload={@uploads.subtitle_file} class="absolute inset-0 opacity-0" />
+            </form>
+          </.media_file_menu>
         </div>
 
         <.processing_subtitle_row
@@ -2203,7 +2513,7 @@ defmodule MaveCoreWeb.Dashboard.Videos.VideoSettingsComponent do
         />
 
         <%= if @subtitle_form && @subtitle_form.mode == :new do %>
-          <div class="w-full flex items-center my-1.5">
+          <div class="w-full flex items-center">
             <div class="flex-grow border-r border-stone-900 pr-2">
               <form
                 id="new-subtitle-form"
@@ -2303,49 +2613,9 @@ defmodule MaveCoreWeb.Dashboard.Videos.VideoSettingsComponent do
     """
   end
 
-  attr :descriptions, :list, default: []
-
-  defp audio_descriptions_section(assigns) do
-    ~H"""
-    <div :if={@descriptions != []} id="audio-descriptions">
-      <.settings_header title="audio description" />
-      <div class="py-1.5">
-        <div
-          :for={description <- @descriptions}
-          id={"audio-description-#{description.language}"}
-          class="flex items-center pl-3.5 pr-2 py-1.5"
-        >
-          <.rendition_led progress={100} />
-          <div class="w-full text-sm text-stone-500 mb-0.5 h-[1.225rem]">
-            {description.label}
-          </div>
-          <div class="flex-grow"></div>
-          <a
-            :if={description.mp3_url}
-            href={description.mp3_url}
-            target="_blank"
-            rel="noopener"
-            class="hover:text-stone-300"
-          >
-            <.format_badge>MP3</.format_badge>
-          </a>
-          <a
-            :if={description.vtt_url}
-            href={description.vtt_url}
-            target="_blank"
-            rel="noopener"
-            class="hover:text-stone-300"
-          >
-            <.format_badge>VTT</.format_badge>
-          </a>
-        </div>
-      </div>
-    </div>
-    """
-  end
-
   attr :renditions, :list, required: true
   attr :audio_tracks, :list, default: []
+  attr :audio_descriptions, :list, default: []
   attr :subtitles, :list, default: []
 
   attr :audio_only, :boolean, default: false
@@ -2366,7 +2636,9 @@ defmodule MaveCoreWeb.Dashboard.Videos.VideoSettingsComponent do
       <%= for {label, types} <- @groups, not (@audio_only and label in ["videos", "clips", "keyframes"]) do %>
         <% grouped = renditions_of_group(@renditions, types) %>
         <% audio_group_rows =
-          if label == "audio", do: audio_group_rows(@audio_tracks, grouped), else: [] %>
+          if label == "audio",
+            do: audio_group_rows(@audio_tracks, grouped, @audio_descriptions),
+            else: [] %>
         <% subtitle_group_rows =
           if label == "subtitles", do: subtitle_group_rows(@subtitles, grouped), else: [] %>
         <%= unless grouped == [] and audio_group_rows == [] and subtitle_group_rows == [] do %>
@@ -2791,7 +3063,7 @@ defmodule MaveCoreWeb.Dashboard.Videos.VideoSettingsComponent do
       (is_integer(progress) and progress > 0 and progress < 100)
   end
 
-  defp audio_group_rows(audio_tracks, renditions) do
+  defp audio_group_rows(audio_tracks, renditions, audio_descriptions) do
     audio_renditions = Enum.filter(renditions, &(Map.get(&1, :type) == "audio"))
 
     completed_container_badges =
@@ -2802,31 +3074,52 @@ defmodule MaveCoreWeb.Dashboard.Videos.VideoSettingsComponent do
       |> Enum.uniq()
       |> Enum.sort_by(&format_index/1)
 
-    audio_tracks
-    |> List.wrap()
-    |> Enum.map(fn track ->
-      base_badges =
-        track
-        |> audio_track_format()
-        |> case do
-          nil -> []
-          format -> [format]
-        end
-
-      label = Map.get(track, :label) || gettext("Audio track")
+    track_rows =
+      audio_tracks
+      |> List.wrap()
+      |> Enum.map(fn track ->
+        base_badges =
+          track
+          |> audio_track_format()
+          |> case do
+            nil -> []
+            format -> [format]
+          end
+
+        label = Map.get(track, :label) || gettext("Audio track")
+
+        %{
+          progress: audio_track_progress(audio_renditions),
+          status: audio_track_status(audio_renditions),
+          size: nil,
+          label: label,
+          badges:
+            (completed_container_badges ++
+               Enum.reject(base_badges, &(&1 in completed_container_badges)))
+            |> Enum.uniq()
+            |> Enum.sort_by(&format_index/1)
+        }
+      end)
 
-      %{
-        progress: audio_track_progress(audio_renditions),
-        status: audio_track_status(audio_renditions),
-        size: nil,
-        label: label,
-        badges:
-          (completed_container_badges ++
-             Enum.reject(base_badges, &(&1 in completed_container_badges)))
-          |> Enum.uniq()
-          |> Enum.sort_by(&format_index/1)
-      }
-    end)
+    rows = if track_rows == [], do: grouped_rows_for("audio", renditions), else: track_rows
+
+    rows ++
+      Enum.map(audio_descriptions, fn description ->
+        %{
+          progress: 100,
+          status: "succeeded",
+          size: nil,
+          label: "#{description.label} (AD)",
+          badges:
+            [
+              {Map.get(description, :hls_playlist), "HLS"},
+              {description.mp3_url, "MP3"},
+              {description.vtt_url, "VTT"}
+            ]
+            |> Enum.filter(fn {url, _format} -> url not in [nil, ""] end)
+            |> Enum.map(fn {_url, format} -> format end)
+        }
+      end)
   end
 
   defp subtitle_group_rows(subtitles, renditions) do
@@ -2987,6 +3280,35 @@ defmodule MaveCoreWeb.Dashboard.Videos.VideoSettingsComponent do
   defp upload_error_to_string(other) when is_binary(other), do: other
   defp upload_error_to_string(other), do: inspect(other)
 
+  defp audio_management_events(kind) do
+    name = Atom.to_string(kind)
+
+    %{
+      add: "add_#{name}",
+      replace: "replace_#{name}",
+      delete: "delete_#{name}",
+      change: "change_new_#{name}",
+      cancel: "cancel_#{name}",
+      blur: "blur_#{name}_label",
+      language: "change_#{name}_language"
+    }
+  end
+
+  defp audio_upload_pending(nil, _kind), do: nil
+
+  defp audio_upload_pending(pending, kind) do
+    if Map.get(pending, :kind, :audio_track) == kind, do: pending
+  end
+
+  defp audio_description_result(socket, {:ok, _description}) do
+    notify_parent(:audio_tracks_updated)
+    {:noreply, socket}
+  end
+
+  defp audio_description_result(socket, {:error, _reason}) do
+    {:noreply, put_flash(socket, :error, gettext("Could not update audio description."))}
+  end
+
   defp scoped_audio_track(socket, id) do
     Assets.get_audio_track_for_embed(id, socket.assigns.embed)
   end
@@ -3174,6 +3496,36 @@ defmodule MaveCoreWeb.Dashboard.Videos.VideoSettingsComponent do
     end
   end
 
+  defp maybe_allow_audio_description_upload(socket) do
+    if Map.has_key?(socket.assigns[:uploads] || %{}, :audio_description_file) do
+      socket
+    else
+      allow_upload(socket, :audio_description_file,
+        accept: ~w(.mp3),
+        max_entries: 1,
+        auto_upload: true,
+        external: &presign_audio_description_upload/2,
+        progress: &handle_progress/3,
+        max_file_size: 104_857_600
+      )
+    end
+  end
+
+  defp maybe_allow_audio_description_vtt_upload(socket) do
+    if Map.has_key?(socket.assigns[:uploads] || %{}, :audio_description_vtt_file) do
+      socket
+    else
+      allow_upload(socket, :audio_description_vtt_file,
+        accept: ~w(.vtt),
+        max_entries: 1,
+        max_file_size: 10_485_760,
+        external: &presign_audio_description_vtt_upload/2,
+        progress: &handle_progress/3,
+        auto_upload: true
+      )
+    end
+  end
+
   defp maybe_allow_subtitle_upload(socket) do
     uploads = socket.assigns[:uploads] || %{}
 
diff --git a/lib/mave_core_web/router.ex b/lib/mave_core_web/router.ex
index 20cca1b..3ae471f 100644
--- a/lib/mave_core_web/router.ex
+++ b/lib/mave_core_web/router.ex
@@ -306,11 +306,25 @@ defmodule MaveCoreWeb.Router do
       live "/cli/auth/:user_code", CliAuthLive, :authorize
     end
 
-    get "/videos/:id/subtitles/:subtitle_id/download", Dashboard.SubtitleController, :download
+    get "/videos/:id/subtitles/:subtitle_id/download", Dashboard.MediaFileController, :download
 
     get "/:space_id/videos/:id/subtitles/:subtitle_id/download",
-        Dashboard.SubtitleController,
+        Dashboard.MediaFileController,
         :download
+
+    get "/videos/:id/audio-tracks/:track_id/download", Dashboard.MediaFileController, :audio
+
+    get "/:space_id/videos/:id/audio-tracks/:track_id/download",
+        Dashboard.MediaFileController,
+        :audio
+
+    get "/videos/:id/audio-descriptions/:track_id/:format/download",
+        Dashboard.MediaFileController,
+        :description
+
+    get "/:space_id/videos/:id/audio-descriptions/:track_id/:format/download",
+        Dashboard.MediaFileController,
+        :description
   end
 
   use MaveCoreWeb.DevRoutes
diff --git a/priv/repo/migrations/20261102100000_manage_audio_descriptions.exs b/priv/repo/migrations/20261102100000_manage_audio_descriptions.exs
new file mode 100644
index 0000000..673a0e2
--- /dev/null
+++ b/priv/repo/migrations/20261102100000_manage_audio_descriptions.exs
@@ -0,0 +1,33 @@
+defmodule MaveCore.Repo.Migrations.ManageAudioDescriptions do
+  use Ecto.Migration
+
+  def up do
+    alter table(:audio_descriptions) do
+      add :label, :string
+      add :generation_language, :language_code
+      add :user_managed, :boolean, null: false, default: false
+      add :deleted_at, :utc_datetime_usec
+      modify :vtt_filename, :string, null: true
+    end
+
+    execute "UPDATE audio_descriptions SET generation_language = language"
+    drop unique_index(:audio_descriptions, [:video_id, :language])
+    create unique_index(:audio_descriptions, [:video_id, :generation_language])
+  end
+
+  def down do
+    drop unique_index(:audio_descriptions, [:video_id, :generation_language])
+
+    # User-uploaded tracks may share a language or have no VTT. They cannot be
+    # represented by the previous schema, so require an explicit data migration.
+    create unique_index(:audio_descriptions, [:video_id, :language])
+
+    alter table(:audio_descriptions) do
+      modify :vtt_filename, :string, null: false
+      remove :deleted_at
+      remove :user_managed
+      remove :generation_language
+      remove :label
+    end
+  end
+end
diff --git a/test/mave_core/analytics/sessions_test.exs b/test/mave_core/analytics/sessions_test.exs
index 5a489e8..5e59a5e 100644
--- a/test/mave_core/analytics/sessions_test.exs
+++ b/test/mave_core/analytics/sessions_test.exs
@@ -219,14 +219,29 @@ defmodule MaveCore.Analytics.SessionsTest do
     assert {:ok, 0} = Sessions.refresh_changed(limit: 32)
   end
 
-  test "failed physical invalidation hides pointers and reports an error for retry" do
+  test "invalidation hides pointers and records cleanup without requiring ClickHouse deletion" do
     pair(1, "AAAAA", "video", 20, 25, 0, 5)
     assert {:ok, _} = Sessions.refresh_changed(limit: 32)
+    assert {:ok, generations} = Sessions.generations("AAAAA")
     ClickHouseRepo.query!("RENAME TABLE analytics_session_years TO temporarily_unavailable_years")
 
     try do
-      assert {:error, :analytics_unavailable} = Sessions.invalidate("AAAAA")
+      assert {:ok, :ok} = Sessions.invalidate("AAAAA")
+      assert {:ok, :ok} = Sessions.invalidate("AAAAA")
       assert {:error, :preparing} = Sessions.generations("AAAAA")
+
+      retired =
+        Repo.query!(
+          "SELECT generation::text FROM analytics_session_retirements WHERE space_hash='AAAAA'"
+        ).rows
+        |> List.flatten()
+
+      assert Enum.sort(retired) == Enum.sort(generations)
+
+      assert [[1]] =
+               ClickHouseRepo.query!(
+                 "SELECT count() FROM analytics_sessions WHERE space_hash='AAAAA'"
+               ).rows
     after
       ClickHouseRepo.query!(
         "RENAME TABLE temporarily_unavailable_years TO analytics_session_years"
@@ -234,6 +249,45 @@ defmodule MaveCore.Analytics.SessionsTest do
     end
   end
 
+  test "invalidation preserves the grace period and cleanup cannot remove rebuilt or unrelated data" do
+    pair(1, "AAAAA", "video", 20, 25, 0, 5)
+    pair(2, "BBBBB", "other", 20, 25, 0, 5)
+    assert {:ok, _} = Sessions.refresh_changed(limit: 32)
+    assert {:ok, old_generations} = Sessions.generations("AAAAA")
+    assert {:ok, other_generations} = Sessions.generations("BBBBB")
+
+    assert {:ok, :ok} = Sessions.invalidate("AAAAA")
+    assert {:error, :preparing} = Sessions.data("AAAAA")
+    assert {:ok, ^other_generations} = Sessions.generations("BBBBB")
+    assert :ok = Sessions.cleanup()
+
+    assert [[1]] =
+             ClickHouseRepo.query!(
+               "SELECT count() FROM analytics_sessions WHERE space_hash='AAAAA'"
+             ).rows
+
+    pair(3, "AAAAA", "new-video", 10, 15, 0, 5)
+    assert {:ok, _} = Sessions.refresh_changed(limit: 32)
+    assert {:ok, new_generations} = Sessions.generations("AAAAA")
+    assert MapSet.disjoint?(MapSet.new(old_generations), MapSet.new(new_generations))
+
+    Repo.query!(
+      "UPDATE analytics_session_retirements SET retired_at=now()-interval '2 hours' WHERE space_hash='AAAAA'"
+    )
+
+    assert :ok = Sessions.cleanup()
+    assert {:ok, ^new_generations} = Sessions.generations("AAAAA")
+    assert {:ok, ^other_generations} = Sessions.generations("BBBBB")
+    assert {:ok, %{views: %{year: 2}}} = Sessions.data("AAAAA")
+    assert {:ok, %{views: %{year: 1}}} = Sessions.data("BBBBB")
+
+    assert [[0]] =
+             ClickHouseRepo.query!(
+               "SELECT count() FROM analytics_sessions WHERE space_hash='AAAAA' AND generation IN {$0:Array(UUID)}",
+               [old_generations]
+             ).rows
+  end
+
   test "source deletion invalidates the inventory and cannot retain old totals" do
     pair(1, "AAAAA", "video", 20, 25, 0, 5)
     assert {:ok, _} = Sessions.refresh_changed(limit: 32)
diff --git a/test/mave_core/assets/audio_description_publication_test.exs b/test/mave_core/assets/audio_description_publication_test.exs
index 8e78cd8..c73c51c 100644
--- a/test/mave_core/assets/audio_description_publication_test.exs
+++ b/test/mave_core/assets/audio_description_publication_test.exs
@@ -4,6 +4,8 @@ defmodule MaveCore.Assets.AudioDescriptionPublicationTest do
   alias MaveCore.Assets
   alias MaveCore.Assets.{Asset, AudioDescription, AudioTrack, Rendition, Video}
   alias MaveCore.Embeds.{Embed, ManifestPublisher}
+  alias MaveCore.Flow
+  alias MaveCore.Flow.StepRun
   alias MaveCore.Spaces.Space
   alias MaveCore.TestSupport.FlowStorageAdapterStub, as: Storage
 
@@ -68,6 +70,68 @@ defmodule MaveCore.Assets.AudioDescriptionPublicationTest do
     assert [%{"filename" => "audio.mp3"}] = manifest["audio_tracks"]
   end
 
+  test "late generation updates untouched descriptions and preserves managed or deleted ones" do
+    embed = embed_fixture()
+    original = description(embed, "en")
+
+    {:ok, template} =
+      Flow.create_template(%{"slug" => "description-publication", "name" => "Descriptions"})
+
+    {:ok, _} =
+      Flow.create_version(template.id, %{
+        "definition" => %{
+          "steps" => [
+            %{"id" => "mix", "type" => "media.mix_audio_description", "name" => "Mix"}
+          ]
+        }
+      })
+
+    complete_generation = fn filename ->
+      {:ok, run} =
+        Flow.start_run(
+          template.slug,
+          %{
+            "space_hash" => embed.space.hash,
+            "embed_hash" => embed.hash
+          }, enqueue: false)
+
+      Repo.get_by!(StepRun, flow_run_id: run.id, step_id: "mix")
+      |> StepRun.changeset(%{
+        status: "succeeded",
+        output: %{
+          "status" => "ok",
+          "audio_description" => %{
+            "language" => "en",
+            "audio_filename" => filename,
+            "vtt_filename" => "descriptions_en.vtt"
+          }
+        }
+      })
+      |> Repo.update!()
+
+      assert {:ok, %{status: "succeeded"}} = Flow.reconcile_run(run.id, enqueue_jobs: false)
+    end
+
+    original |> Ecto.Changeset.change(generation_language: "en") |> Repo.update!()
+    complete_generation.("regenerated.mp3")
+    assert Repo.get!(AudioDescription, original.id).audio_filename == "regenerated.mp3"
+
+    original
+    |> Ecto.Changeset.change(user_managed: true, label: "Custom", language: "nl")
+    |> Repo.update!()
+
+    complete_generation.("late.mp3")
+    managed = Repo.get!(AudioDescription, original.id)
+    assert managed.audio_filename == "regenerated.mp3"
+    assert managed.label == "Custom"
+    assert managed.language == "nl"
+
+    managed |> Ecto.Changeset.change(deleted_at: DateTime.utc_now()) |> Repo.update!()
+    complete_generation.("later.mp3")
+    assert Repo.get!(AudioDescription, original.id).deleted_at
+    assert Assets.list_audio_descriptions(embed.asset.current_video.id) == []
+  end
+
   defp embed_fixture do
     space = Repo.insert!(%Space{hash: "abcde", region: "eu"})
     asset = Repo.insert!(%Asset{space_id: space.id})
diff --git a/test/mave_core/audio_description_test.exs b/test/mave_core/audio_description_test.exs
index ac8edd5..5168d21 100644
--- a/test/mave_core/audio_description_test.exs
+++ b/test/mave_core/audio_description_test.exs
@@ -35,7 +35,11 @@ defmodule MaveCore.AudioDescriptionTest do
     assert {:ok, %Space{audio_description_enabled: true} = space} =
              Spaces.update_space_features(space, %{audio_description_enabled: true})
 
-    assert AudioDescription.run_input(space) == %{"languages" => ["en", "nl"]}
+    assert AudioDescription.run_input(space) == %{
+             "languages" => ["original"],
+             "fallback_language" => "en"
+           }
+
     assert Repo.get!(Space, space.id).audio_description_enabled
   end
 
@@ -68,4 +72,29 @@ defmodule MaveCore.AudioDescriptionTest do
              "audio_description" => %{"languages" => ["nl"]}
            }) == ["en", "nl"]
   end
+
+  test "original language uses transcription and defaults to English when unknown" do
+    assert AudioDescription.original_language(%{}, %{"transcribe_audio" => %{"language" => "nl"}}) ==
+             "nl"
+
+    assert AudioDescription.original_language(%{"language" => "fr-FR"}, %{}) == "fr"
+    assert AudioDescription.original_language(%{}, %{}) == "en"
+    assert AudioDescription.original_language(%{"language" => "und"}, %{}) == "en"
+
+    assert AudioDescription.requested_languages(%{
+             "audio_description" => %{"languages" => ["original"]}
+           }) == ["original"]
+  end
+
+  test "a flow or step can specify its fallback without overriding detected speech" do
+    input = %{"audio_description" => %{"fallback_language" => "nl"}}
+    assert AudioDescription.original_language(input, %{}) == "nl"
+    assert AudioDescription.original_language(input, %{}, "de") == "de"
+
+    assert AudioDescription.original_language(
+             input,
+             %{"transcribe_audio" => %{"language" => "fr"}},
+             "de"
+           ) == "fr"
+  end
 end
diff --git a/test/mave_core/flow/steps/audio_description_steps_test.exs b/test/mave_core/flow/steps/audio_description_steps_test.exs
index 5f0328f..57b7e6e 100644
--- a/test/mave_core/flow/steps/audio_description_steps_test.exs
+++ b/test/mave_core/flow/steps/audio_description_steps_test.exs
@@ -7,6 +7,7 @@ defmodule MaveCore.Flow.Steps.AudioDescriptionStepsTest do
     AiDescribeVideoStep,
     AiSpeakDescriptionsStep,
     AiTranslateDescriptionsStep,
+    AudioDescriptionSupport,
     MediaBuildHlsMasterStep,
     MediaDetectScenesStep,
     MediaMixAudioDescriptionStep
@@ -19,6 +20,21 @@ defmodule MaveCore.Flow.Steps.AudioDescriptionStepsTest do
   @bucket "space-ubg50"
   @requested %{"languages" => ["en", "nl"]}
 
+  defmodule DecodedJsonStorage do
+    def get(_bucket, "object.json", _region), do: {:ok, %{"duration" => 12}}
+    def get(_bucket, "array.json", _region), do: {:ok, [%{"text" => "A red square."}]}
+  end
+
+  test "working JSON accepts bodies already decoded by the HTTP storage adapter" do
+    ctx = %{storage: DecodedJsonStorage, bucket: "test", region: nil}
+
+    assert {:ok, %{"duration" => 12}} =
+             AudioDescriptionSupport.get_json(ctx, "object.json")
+
+    assert {:ok, [%{"text" => "A red square."}]} =
+             AudioDescriptionSupport.get_json(ctx, "array.json")
+  end
+
   defmodule ChatStub do
     @moduledoc false
 
@@ -115,8 +131,10 @@ defmodule MaveCore.Flow.Steps.AudioDescriptionStepsTest do
       steps = definition["steps"]
 
       ids =
-        ~w(detect_scenes describe_video translate_descriptions_nl speak_descriptions_en
-           speak_descriptions_nl mix_audio_description_en mix_audio_description_nl)
+        ~w(detect_scenes describe_video speak_descriptions_original mix_audio_description_original)
+
+      refute Enum.any?(steps, &(&1["type"] == "ai.translate_descriptions"))
+      assert Enum.count(steps, &(&1["type"] == "media.mix_audio_description")) == 1
 
       for id <- ids do
         step = Enum.find(steps, &(&1["id"] == id))
@@ -212,6 +230,118 @@ defmodule MaveCore.Flow.Steps.AudioDescriptionStepsTest do
     assert playlist =~ ~s(NAME="Original",LANGUAGE="en",DEFAULT=YES,AUTOSELECT=YES,CHANNELS="2")
   end
 
+  test "speech retries reuse unchanged cues but regenerate changed text" do
+    key = "#{@embed}/audio_description/en/cues.json"
+    step = %{"id" => "speak_descriptions_en", "params" => %{"language" => "en"}}
+
+    context = %{
+      run_input: Map.put(base_input(), "audio_description", @requested),
+      dependency_outputs: %{
+        "describe_video" => %{
+          "status" => "ok",
+          "cues_key" => key,
+          "speech_key" => "speech.json",
+          "duration" => 8
+        }
+      }
+    }
+
+    put_cue = fn text ->
+      Storage.put(
+        @bucket,
+        key,
+        Jason.encode!([%{"start" => 0, "end" => 1, "text" => text}]),
+        "application/json",
+        nil
+      )
+    end
+
+    put_cue.("A red screen.")
+    assert {:ok, first, []} = AiSpeakDescriptionsStep.run(step, context)
+    assert_received {:speak, "en"}
+    assert {:ok, retry, []} = AiSpeakDescriptionsStep.run(step, context)
+    assert retry["clips"] == first["clips"]
+    refute_received {:speak, "en"}
+
+    put_cue.("A blue screen.")
+    assert {:ok, changed, []} = AiSpeakDescriptionsStep.run(step, context)
+    assert_received {:speak, "en"}
+    refute changed["clips"] == first["clips"]
+  end
+
+  @tag :integration
+  test "original-language preset describes and packages just the detected language" do
+    Process.put(:ad_test_pid, self())
+    {video, audio} = media_fixtures()
+
+    input =
+      Map.merge(base_input(), %{
+        "audio_description" => %{"languages" => ["original"]},
+        "source_body" => video,
+        "source_content_type" => "video/mp4"
+      })
+
+    Storage.put_public(@bucket, "#{@embed}/audio.mp3", audio, "audio/mpeg", nil)
+
+    Storage.put(
+      @bucket,
+      "#{@embed}/subtitle.json",
+      Jason.encode!(%{"segments" => []}),
+      "application/json",
+      nil
+    )
+
+    outputs = %{
+      "source" => %{"space_hash" => @space, "embed_hash" => @embed, "version" => 0},
+      "inspect_media" => %{"duration" => 8.0, "has_video" => true, "has_audio" => true},
+      "transcribe_audio" => %{
+        "status" => "ok",
+        "language" => "nl",
+        "subtitle_json_key" => "#{@embed}/subtitle.json"
+      },
+      "transcode_audio" => %{
+        "status" => "ok",
+        "bucket" => @bucket,
+        "key" => "#{@embed}/audio.mp3",
+        "uri" => "s3://#{@bucket}/#{@embed}/audio.mp3"
+      }
+    }
+
+    {:ok, preset} = Presets.fetch("publish_local")
+
+    steps =
+      Enum.filter(
+        preset["definition"]["steps"],
+        &(&1["id"] in ~w(detect_scenes describe_video speak_descriptions_original mix_audio_description_original))
+      )
+
+    outputs =
+      Enum.reduce(steps, outputs, fn step, acc ->
+        assert {:ok, %{"status" => "ok"} = output, _artifacts} =
+                 Map.fetch!(
+                   %{
+                     "media.detect_scenes" => MediaDetectScenesStep,
+                     "ai.describe_video" => AiDescribeVideoStep,
+                     "ai.speak_descriptions" => AiSpeakDescriptionsStep,
+                     "media.mix_audio_description" => MediaMixAudioDescriptionStep
+                   },
+                   step["type"]
+                 ).run(step, %{run_input: input, dependency_outputs: acc})
+
+        Map.put(acc, step["id"], output)
+      end)
+
+    assert outputs["describe_video"]["language"] == "nl"
+    assert outputs["speak_descriptions_original"]["language"] == "nl"
+    assert outputs["mix_audio_description_original"]["audio_description"]["language"] == "nl"
+    assert_received {:chat, instruction, _}
+    assert instruction =~ "Dutch (nl)"
+    assert_received {:speak, "nl"}
+    refute_received {:speak, "en"}
+    assert {:ok, _} = Storage.get(@bucket, "#{@embed}/audio_description_nl.mp3", nil)
+    assert {:error, _} = Storage.get(@bucket, "#{@embed}/audio_description_en.mp3", nil)
+  end
+
   @tag :integration
   test "turns a video into a ducked full mix and descriptions VTT per language" do
     if System.find_executable("ffmpeg") == nil, do: flunk("ffmpeg is required")
diff --git a/test/mave_core_web/controllers/api/upload/tusd_hooks_controller_test.exs b/test/mave_core_web/controllers/api/upload/tusd_hooks_controller_test.exs
index 0a8aa9b..4610cd8 100644
--- a/test/mave_core_web/controllers/api/upload/tusd_hooks_controller_test.exs
+++ b/test/mave_core_web/controllers/api/upload/tusd_hooks_controller_test.exs
@@ -4,10 +4,11 @@ defmodule MaveCoreWeb.Api.Upload.TusdHooksControllerTest do
 
   alias MaveCore.Accounts
   alias MaveCore.Assets
-  alias MaveCore.Assets.{Asset, AudioTrack, Subtitle, Video}
+  alias MaveCore.Assets.{Asset, AudioDescription, AudioTrack, Rendition, Subtitle, Video}
   alias MaveCore.Collections.CollectionEmbed
   alias MaveCore.Embeds
   alias MaveCore.Embeds.Embed
+  alias MaveCore.Embeds.ManifestPublisher
   alias MaveCore.Embeds.SettingsSerializer
   alias MaveCore.Flow
   alias MaveCore.Flow.Run
@@ -1463,6 +1464,185 @@ defmodule MaveCoreWeb.Api.Upload.TusdHooksControllerTest do
     end
   end
 
+  @tag :tmp_dir
+  test "audio description uploads support duplicate languages and replacement", %{
+    conn: conn,
+    tmp_dir: tmp_dir
+  } do
+    space = space_fixture()
+    embed = video_embed_fixture(space, %{name: "Uploaded descriptions"})
+    asset = Repo.get!(Asset, embed.asset_id)
+
+    Repo.insert!(%Rendition{
+      video_id: asset.current_video_id,
+      rendition_key: "#{embed.hash}/h264_hd_hls/playlist.m3u8",
+      type: :video,
+      codec: :h264,
+      container: :hls,
+      size: :hd,
+      progress: 100.0
+    })
+
+    path = Path.join(tmp_dir, "description.mp3")
+
+    {_, 0} =
+      System.cmd(
+        "ffmpeg",
+        ["-v", "error", "-y", "-f", "lavfi", "-i", "sine=duration=1", "-c:a", "libmp3lame", path],
+        stderr_to_stdout: true
+      )
+
+    body = File.read!(path)
+
+    upload = fn name, extra ->
+      key = "uploads/#{name}.mp3"
+
+      {:ok, _} =
+        FlowStorageAdapterStub.put("mave-upload", key, body, "audio/mpeg", @upload_source_region)
+
+      response =
+        post(recycle(conn), ~p"/internal/upload-hooks/tusd?secret=hook_secret", %{
+          "Type" => "post-finish",
+          "Event" => %{
+            "Upload" => %{
+              "ID" => name,
+              "Size" => byte_size(body),
+              "MetaData" =>
+                upload_metadata(
+                  embed,
+                  Map.merge(
+                    %{
+                      "custom_audio_track" => "true",
+                      "audio_description" => "true",
+                      "label" => name,
+                      "language" => "en",
+                      "filetype" => "audio/mpeg"
+                    },
+                    extra
+                  )
+                ),
+              "Storage" => %{"Bucket" => "mave-upload", "Key" => key}
+            }
+          }
+        })
+
+      json_response(response, 200)["audio_track_id"]
+    end
+
+    first_id = upload.("first-description", %{})
+    second_id = upload.("second-description", %{})
+    assert first_id != second_id
+    first = Repo.get!(AudioDescription, first_id)
+    assert first.language == "en"
+    assert first.user_managed
+    assert first.vtt_filename == nil
+    assert first.generation_language == nil
+
+    first |> Ecto.Changeset.change(vtt_filename: "old.vtt") |> Repo.update!()
+    assert upload.("replacement", %{"audio_track_id" => first_id, "language" => "nl"}) == first_id
+    replaced = Repo.get!(AudioDescription, first_id)
+    assert replaced.language == "nl"
+    assert replaced.label == "replacement"
+    assert replaced.vtt_filename == nil
+    {:ok, manifest} = ManifestPublisher.current(embed)
+
+    assert Enum.any?(
+             manifest["audio_descriptions"],
+             &(&1["label"] == "replacement (audio description)")
+           )
+
+    {:ok, playlist} =
+      FlowStorageAdapterStub.get(
+        "space-#{space.hash}",
+        "#{embed.hash}/playlist.m3u8",
+        space.region
+      )
+
+    assert playlist =~ "public.accessibility.describes-video"
+
+    vtt = "WEBVTT\n\n00:00:00.000 --> 00:00:01.000\nA blue square appears.\n"
+
+    {:ok, _} =
+      FlowStorageAdapterStub.put(
+        "mave-upload",
+        "description.vtt",
+        vtt,
+        "text/vtt",
+        @upload_source_region
+      )
+
+    response =
+      post(recycle(conn), ~p"/internal/upload-hooks/tusd?secret=hook_secret", %{
+        "Type" => "post-finish",
+        "Event" => %{
+          "Upload" => %{
+            "ID" => "description-vtt",
+            "Size" => byte_size(vtt),
+            "MetaData" =>
+              upload_metadata(embed, %{
+                "custom_subtitle" => "true",
+                "audio_description" => "true",
+                "subtitle_id" => first_id,
+                "filetype" => "text/vtt"
+              }),
+            "Storage" => %{"Bucket" => "mave-upload", "Key" => "description.vtt"}
+          }
+        }
+      })
+
+    assert json_response(response, 200)["subtitle_id"] == first_id
+    with_vtt = Repo.get!(AudioDescription, first_id)
+    assert with_vtt.vtt_file_size == byte_size(vtt)
+
+    assert {:ok, ^vtt} =
+             FlowStorageAdapterStub.get(
+               "space-#{space.hash}",
+               "#{embed.hash}/#{with_vtt.vtt_filename}",
+               space.region
+             )
+
+    assert {:ok, replaced_vtt} =
+             Assets.ingest_uploaded_audio_description_vtt(
+               embed,
+               %{"subtitle_id" => first_id},
+               "mave-upload",
+               "description.vtt"
+             )
+
+    refute replaced_vtt.vtt_filename == with_vtt.vtt_filename
+
+    {:ok, _} =
+      FlowStorageAdapterStub.put(
+        "mave-upload",
+        "invalid.vtt",
+        "not VTT",
+        "text/vtt",
+        @upload_source_region
+      )
+
+    assert {:error, :invalid_vtt} =
+             Assets.ingest_uploaded_audio_description_vtt(
+               embed,
+               %{"subtitle_id" => first_id},
+               "mave-upload",
+               "invalid.vtt"
+             )
+
+    other = video_embed_fixture(space, %{name: "Other description video"})
+
+    assert {:error, :audio_description_not_found} =
+             Assets.ingest_uploaded_audio_description_vtt(
+               other,
+               %{"subtitle_id" => first_id},
+               "mave-upload",
+               "description.vtt"
+             )
+
+    assert {:ok, _} = Assets.delete_audio_description_outputs(embed, first_id)
+    assert Repo.get!(AudioDescription, first_id).deleted_at
+    assert Assets.get_audio_description_for_embed(first_id, embed) == nil
+  end
+
   test "custom audio track uploads create an audio track and package hls audio", %{conn: conn} do
     ffmpeg_bin = System.find_executable("ffmpeg")
 
diff --git a/test/mave_core_web/live/dashboard/data/index_test.exs b/test/mave_core_web/live/dashboard/data/index_test.exs
index 75fcedc..c563a71 100644
--- a/test/mave_core_web/live/dashboard/data/index_test.exs
+++ b/test/mave_core_web/live/dashboard/data/index_test.exs
@@ -22,24 +22,38 @@ defmodule MaveCoreWeb.Live.Dashboard.Data.IndexTest do
 
   test "/data renders space analytics from clickhouse", %{conn: conn, db_name: db_name} do
     {conn, space} = authenticated_conn(conn)
+    now = DateTime.utc_now()
+
+    timestamps = [
+      DateTime.add(now, -172_800, :second),
+      DateTime.add(now, -172_797, :second),
+      DateTime.add(now, -30, :second),
+      DateTime.add(now, -28, :second)
+    ]
 
     sql = """
     INSERT INTO #{db_name}.events
     (timestamp, name, session_id, space_hash, embed_hash, video_time, duration, source_url, browser, browser_version, os, os_version, device, device_brand)
     VALUES
-    (addSeconds(now64(6), -172800), 'play',  '00000000-0000-0000-0000-000000001002', '#{space.hash}', 'BBBBBBBBBB', 0.0, 10, 'https://example.com/2daysago', 'Safari', '17', 'Mac', '14', 'Mobile', 'Apple'),
-    (addSeconds(now64(6), -172797), 'pause', '00000000-0000-0000-0000-000000001002', '#{space.hash}', 'BBBBBBBBBB', 3.0, 10, 'https://example.com/2daysago', 'Safari', '17', 'Mac', '14', 'Mobile', 'Apple'),
-    (addSeconds(now64(6), -30), 'play',  '00000000-0000-0000-0000-000000001003', '#{space.hash}', 'CCCCCCCCCC', 0.0, 10, 'https://example.com/today', 'Chrome', '100', 'Mac', '14', 'Desktop', 'Apple'),
-    (addSeconds(now64(6), -28), 'pause', '00000000-0000-0000-0000-000000001003', '#{space.hash}', 'CCCCCCCCCC', 2.0, 10, 'https://example.com/today', 'Chrome', '100', 'Mac', '14', 'Desktop', 'Apple')
+    ({$0:DateTime64(6)}, 'play',  '00000000-0000-0000-0000-000000001002', '#{space.hash}', 'BBBBBBBBBB', 0.0, 10, 'https://example.com/2daysago', 'Safari', '17', 'Mac', '14', 'Mobile', 'Apple'),
+    ({$1:DateTime64(6)}, 'pause', '00000000-0000-0000-0000-000000001002', '#{space.hash}', 'BBBBBBBBBB', 3.0, 10, 'https://example.com/2daysago', 'Safari', '17', 'Mac', '14', 'Mobile', 'Apple'),
+    ({$2:DateTime64(6)}, 'play',  '00000000-0000-0000-0000-000000001003', '#{space.hash}', 'CCCCCCCCCC', 0.0, 10, 'https://example.com/today', 'Chrome', '100', 'Mac', '14', 'Desktop', 'Apple'),
+    ({$3:DateTime64(6)}, 'pause', '00000000-0000-0000-0000-000000001003', '#{space.hash}', 'CCCCCCCCCC', 2.0, 10, 'https://example.com/today', 'Chrome', '100', 'Mac', '14', 'Desktop', 'Apple')
     """
 
-    {:ok, _} = ClickHouseRepo.query(sql)
+    {:ok, _} = ClickHouseRepo.query(sql, timestamps)
     ClickHouseRepo.query("OPTIMIZE TABLE #{db_name}.events FINAL")
 
     {:ok, view, _html} = live(conn, "/data")
     # Real ClickHouse queries can exceed the default 100 ms on a cold test stack.
     _ = render_async(view, 5_000)
     html = render(view)
+    month_start = Date.beginning_of_month(Date.utc_today())
+
+    expected_views =
+      timestamps
+      |> Enum.take_every(2)
+      |> Enum.count(&(Date.compare(DateTime.to_date(&1), month_start) != :lt))
 
     assert html =~ "Views"
     assert html =~ "Watch time"
@@ -50,10 +64,12 @@ defmodule MaveCoreWeb.Live.Dashboard.Data.IndexTest do
     assert html =~ "Device"
     assert html =~ "Browser"
     assert has_element?(view, "#data-trend .w-1")
-    assert has_element?(view, "#data-trend .bg-blue-500")
+    if expected_views > 0, do: assert(has_element?(view, "#data-trend .bg-blue-500"))
     refute has_element?(view, "#data-trend svg")
-    # The default calendar month includes both views.
-    assert view |> element("#data-kpis") |> render() =~ ~r/>\s*2\s*</
+    # Two days ago may belong to the previous calendar month.
+    assert view |> element("#data-kpis > div:first-child") |> render() =~
+             ~r/>\s*#{expected_views}\s*</
+
     refute html =~ "font-family: 'Sofia'"
   end
 
diff --git a/test/mave_core_web/live/dashboard/videos/show_test.exs b/test/mave_core_web/live/dashboard/videos/show_test.exs
index d6c0a01..2181a1d 100644
--- a/test/mave_core_web/live/dashboard/videos/show_test.exs
+++ b/test/mave_core_web/live/dashboard/videos/show_test.exs
@@ -5,7 +5,7 @@ defmodule MaveCoreWeb.Live.Dashboard.Videos.ShowTest do
   import Phoenix.LiveViewTest
 
   alias MaveCore.Accounts
-  alias MaveCore.Assets.{Asset, AudioTrack, Subtitle, Video}
+  alias MaveCore.Assets.{Asset, AudioDescription, AudioTrack, Subtitle, Video}
   alias MaveCore.ClickHouseRepo
   alias MaveCore.Collections.{Collection, CollectionEmbed}
   alias MaveCore.Embeds.{Embed, SettingsSerializer}
@@ -1624,6 +1624,101 @@ defmodule MaveCoreWeb.Live.Dashboard.Videos.ShowTest do
     stop_live_view(reloaded_view)
   end
 
+  test "audio descriptions have their own editable settings and appear under Audio in Info", %{
+    conn: conn
+  } do
+    {conn, space} = authenticated_conn(conn)
+
+    embed =
+      video_embed_fixture(space, %{name: "Description management"})
+      |> Repo.preload(asset: [:current_video])
+
+    description =
+      Repo.insert!(%AudioDescription{
+        video_id: embed.asset.current_video_id,
+        language: "nl",
+        generation_language: "nl",
+        audio_filename: "description.mp3",
+        vtt_filename: "description.vtt"
+      })
+
+    {:ok, view, _html} = live(conn, "/videos/#{embed.id}")
+    assert has_element?(view, "#audio-description-settings")
+    refute render(view) =~ "Upload a full audio mix"
+    assert has_element?(view, "#audio-description-settings [phx-click=add_audio_description]")
+    assert has_element?(view, "#audio-description-replace-#{description.id}[aria-haspopup=menu]")
+
+    assert has_element?(
+             view,
+             "#audio-description-files-#{description.id} [role=menuitem]",
+             "Replace text"
+           )
+
+    render_click(element(view, "#audio-description-replace-audio-#{description.id}"))
+    assert has_element?(view, "input[type=file][accept='.mp3']")
+
+    render_click(element(view, "#audio-description-vtt-#{description.id}"))
+    assert has_element?(view, "input[type=file][accept='.vtt']")
+    assert has_element?(view, "#delete-audio-description-#{description.id}")
+
+    view
+    |> element("#audio-description-settings input[name='audio_track[label]']")
+    |> render_blur(%{"id" => description.id, "value" => "Dutch accessible audio"})
+
+    assert Repo.get!(AudioDescription, description.id).label == "Dutch accessible audio"
+
+    view
+    |> element("#audio-description-language-form-#{description.id}")
+    |> render_change(%{"audio_track" => %{"language" => "en"}})
+
+    assert Repo.get!(AudioDescription, description.id).language == "en"
+
+    render_click(element(view, "[phx-value-tab=info]"))
+    assert has_element?(view, "#rendition-group-audio", "Dutch accessible audio (AD)")
+    assert has_element?(view, "#rendition-group-audio", "HLS")
+    assert has_element?(view, "#rendition-group-audio", "MP3")
+    assert has_element?(view, "#rendition-group-audio", "VTT")
+    refute has_element?(view, "#audio-descriptions")
+    refute has_element?(view, "#rendition-group-audio a")
+
+    render_click(element(view, "[phx-value-tab=options]"))
+    render_click(element(view, "#delete-audio-description-#{description.id}"))
+    assert Repo.get!(AudioDescription, description.id).deleted_at == nil
+    assert has_element?(view, "#delete-media-dialog", "Dutch accessible audio")
+    render_click(element(view, "#delete-media-dialog-confirm"))
+    assert Repo.get!(AudioDescription, description.id).deleted_at
+    refute has_element?(view, "#delete-audio-description-#{description.id}")
+    stop_live_view(view)
+  end
+
+  test "audio description settings ignore changes to another video's description", %{conn: conn} do
+    {conn, space} = authenticated_conn(conn)
+    embed = video_embed_fixture(space, %{name: "Description scope"})
+
+    other =
+      video_embed_fixture(space, %{name: "Other video"}) |> Repo.preload(asset: [:current_video])
+
+    description =
+      Repo.insert!(%AudioDescription{
+        video_id: other.asset.current_video_id,
+        language: "en",
+        audio_filename: "other.mp3"
+      })
+
+    {:ok, view, _html} = live(conn, "/videos/#{embed.id}")
+    target = with_target(view, "#video-settings")
+
+    render_hook(target, "blur_audio_description_label", %{
+      "id" => description.id,
+      "value" => "Changed"
+    })
+
+    render_hook(target, "delete_audio_description", %{"id" => description.id})
+    assert Repo.get!(AudioDescription, description.id).label == nil
+    assert Repo.get!(AudioDescription, description.id).deleted_at == nil
+    stop_live_view(view)
+  end
+
   test "/videos/:id renders an empty audio tracks state when there are no tracks", %{conn: conn} do
     {conn, space} = authenticated_conn(conn)
     video = video_embed_fixture(space, %{name: "Audio Track Settings"})
@@ -1653,13 +1748,22 @@ defmodule MaveCoreWeb.Live.Dashboard.Videos.ShowTest do
       })
       |> Repo.insert!()
 
-    {:ok, _view, html} = live(conn, "/videos/#{video.id}")
+    {:ok, view, html} = live(conn, "/videos/#{video.id}")
+
+    render_click(element(view, "#delete-audio-track-#{track.id}"))
+    assert Repo.get(AudioTrack, track.id)
+    render_click(element(view, "#delete-media-dialog button", "cancel"))
+    assert Repo.get(AudioTrack, track.id)
+    refute has_element?(view, "#delete-media-dialog")
+    render_click(element(view, "#delete-audio-track-#{track.id}"))
+    render_click(element(view, "#delete-media-dialog-confirm"))
+    refute Repo.get(AudioTrack, track.id)
 
     assert html =~ "audio tracks"
     assert html =~ "Commentary"
     assert html =~ ~s(id="delete-audio-track-#{track.id}")
-    assert html =~ "Remove audio track"
-    assert html =~ "phx-click-loading:inline-flex"
+    assert html =~ "Delete"
+    assert html =~ "file_menu"
   end
 
   test "/videos/:id saves audio track label on blur", %{conn: conn} do
@@ -1691,8 +1795,13 @@ defmodule MaveCoreWeb.Live.Dashboard.Videos.ShowTest do
       "value" => "Director Commentary"
     })
 
+    view
+    |> element("#audio-track-language-form-#{track.id}")
+    |> render_change(%{"audio_track" => %{"language" => "nl"}})
+
     stop_live_view(view)
     assert Repo.get!(AudioTrack, track.id).label == "Director Commentary"
+    assert Repo.get!(AudioTrack, track.id).language == "nl"
   end
 
   test "/videos/:id ignores audio track mutations from another space", %{conn: conn} do
@@ -1858,8 +1967,73 @@ defmodule MaveCoreWeb.Live.Dashboard.Videos.ShowTest do
     assert has_element?(view, ~s(a[href="#{subtitle_download_path}"][download="en.vtt"]))
     refute has_element?(view, ~s(a[href="#{subtitle_download_path}"][target]))
     assert html =~ ~s(id="delete-subtitle-#{subtitle.id}")
-    assert html =~ "Remove subtitle"
-    assert html =~ "phx-click-loading:inline-flex"
+    assert html =~ "Delete"
+    assert html =~ "file_menu"
+  end
+
+  test "audio downloads are attachments scoped to the current video", %{conn: conn} do
+    {conn, space} = authenticated_conn(conn)
+
+    embed =
+      video_embed_fixture(space, %{name: "Audio downloads"})
+      |> Repo.preload(asset: [:current_video])
+
+    other = video_embed_fixture(space, %{name: "Other video"})
+
+    track =
+      Repo.insert!(%AudioTrack{
+        video_id: embed.asset.current_video_id,
+        label: "Original",
+        filename: "audio.mp3",
+        codec: "mp3"
+      })
+
+    description =
+      Repo.insert!(%AudioDescription{
+        video_id: embed.asset.current_video_id,
+        label: "Accessible",
+        language: "en",
+        audio_filename: "ad.mp3",
+        vtt_filename: "ad.vtt"
+      })
+
+    bucket = Storage.bucket_for_space(space.hash, space.region)
+
+    for {file, body, type} <- [
+          {"audio.mp3", "audio bytes", "audio/mpeg"},
+          {"ad.mp3", "description bytes", "audio/mpeg"},
+          {"ad.vtt", "WEBVTT\n", "text/vtt"}
+        ] do
+      {:ok, _} =
+        FlowStorageAdapterStub.put_public(
+          bucket,
+          "#{embed.hash}/#{file}",
+          body,
+          type,
+          space.region
+        )
+    end
+
+    for {suffix, body} <- [
+          {"audio-tracks/#{track.id}/download", "audio bytes"},
+          {"audio-descriptions/#{description.id}/mp3/download", "description bytes"},
+          {"audio-descriptions/#{description.id}/vtt/download", "WEBVTT\n"}
+        ] do
+      downloaded = get(conn, "/#{space.id}/videos/#{embed.id}/#{suffix}")
+      assert response(downloaded, 200) == body
+      assert hd(get_resp_header(downloaded, "content-disposition")) =~ "attachment"
+      assert response(get(conn, "/#{space.id}/videos/#{other.id}/#{suffix}"), 404)
+    end
+
+    description |> Ecto.Changeset.change(deleted_at: DateTime.utc_now()) |> Repo.update!()
+
+    assert response(
+             get(
+               conn,
+               "/#{space.id}/videos/#{embed.id}/audio-descriptions/#{description.id}/mp3/download"
+             ),
+             404
+           )
   end
 
   test "/videos/:id subtitle download returns VTT as an attachment", %{conn: conn} do