expo-video-subtitle 0.7.6 → 0.8.1

package/CHANGELOG.md

@@ -7,6 +7,86 @@ Changes inherited from the upstream base version are not repeated here — see t
 [upstream changelog](https://github.com/expo/expo/blob/main/packages/expo-video/CHANGELOG.md)
 for the history of everything that isn't subtitle related.
 
+## 0.8.1
+
+### Fixed
+
+- **A plain `.vtt` track sat flush against the bottom edge and ignored `bottomOffset` (Android).**
+  `.srt` and `.ass` tracks in the same player were fine.
+
+  Media3's `WebvttCueParser` leaves a cue with no `line:` setting unpositioned, but that is not what
+  reaches the screen. `WebvttParser.parse` hands its cues through `WebvttSubtitle.getCues`, which
+  runs the WebVTT spec's snap-to-lines stacking on every cue, unconditionally — a lone cue comes out
+  as `line = -1, LINE_TYPE_NUMBER`. `SubtitlePainter` then takes its number-line branch, where `-1`
+  is `parentBottom - textHeight` and `bottomPaddingFraction` is never read; the painter only consults
+  it when `line` is unset. So a WebVTT cue landed `parentHeight × padding` lower than the identical
+  SubRip cue — 54px on a 1080-tall frame at the app's 5% — and no offset could move it.
+
+  SubRip never had this because `SubripParser` leaves `line` alone. ASS had it and was already fixed:
+  `SsaCueNormalizer` strips the placement `SsaParser` stamps on. WebVTT was the one format with the
+  stamp and no normalizer. It now goes through `StackingSubtitleParser` behind `WebvttCueNormalizer`,
+  which clears a negative line number and the derived centre `position`, so a plain cue takes the
+  app's padding and simultaneous cues stack — exactly as `.srt` does.
+
+  Verified against the 1.9.0 artefacts the app ships, from source and from decompiled bytecode; the
+  logic is byte for byte identical to 1.8.0, so this was never a version question.
+
+  One honest limit: after `getCues` has run, a parser-stacked `line = -1` is indistinguishable from
+  an author's explicit `line:-1`, so both are reset. `line:-1` means "the last line", and "the last
+  line, lifted by the app's padding" is where every other format's bottom cue already goes;
+  percentages and non-negative line numbers are untouched.
+
+### Why it surfaced now
+
+Nothing changed in this path for a long time. Until `SUBTITLE_PRESERVE_FORMAT` was switched on, every
+anikoto sidecar was converted to SubRip before it reached the app, so the WebVTT path was never
+exercised. Storing the `.vtt` as-is is what put the first real WebVTT track in front of it.
+
+## 0.8.0
+
+### Added
+
+- **ASS signs are drawn with their transforms on iOS too.** AVFoundation renders a sideloaded
+  WebVTT track itself, and WebVTT can express no rotation, no scale and no per-cue opacity;
+  `AVTextStyleRule` has no attribute for any of them either. So the same split the Android side
+  makes: `SubtitleConverter.splitAss` takes the typeset events out of the script before the WebVTT
+  is built, and `AssSignOverlayView` draws them in `AVPlayerViewController.contentOverlayView`,
+  sized to `videoBounds` and driven by a `CADisplayLink`.
+
+  Signs travel on the `AVPlayerItem` that owns them rather than through a store of their own. A
+  store would have to be keyed by something both ends can see, and the only identity a sideloaded
+  track keeps inside a composition is its language — so two players loading different videos in the
+  same language would overwrite each other, and the next episode would inherit the previous one's
+  typesetting. The item is the identity, and the overlay re-resolves whenever the item or the
+  selected language changes.
+
+  Read and honoured: `\pos`, `\move` (at its destination), `\org`, `\an` and the legacy `\a`,
+  `\frz`, `\fscx`, `\fscy`, `\fs`, `\c` / `\1c`, `\alpha` / `\1a`, `\b`, `\i`, `\u`, and the
+  style columns behind them.
+
+### Known limitations on iOS
+
+- `\frx` and `\fry` are not applied. `CGAffineTransform` is two-dimensional, and the values are
+  almost always under 3° in practice; `\frz` is what carries the effect.
+- Signs do not appear in Picture in Picture. The system renders that window from the video layer
+  alone, not from the view hierarchy `contentOverlayView` belongs to.
+- `\t` animation, `\fad`, `\clip`, `\blur`, `\be`, `\fax` shear, vector drawings and karaoke are
+  dropped, as on Android. Fonts fall back to the system face.
+
+### Fixed
+
+- **Non-finite numbers are refused.** `Double("nan")` and `Double("inf")` parse, and a subtitle is
+  untrusted scraper output; either one reaching a transform makes a sign silently fail to draw,
+  which looks exactly like a sign that was never parsed. Every number out of a tag or a style column
+  now goes through a finiteness check.
+
+### Changed
+
+- The override-block scanner reads a leading digit as part of a tag name, so `\1c`, `\1a` and `\4a`
+  are recognised. The WebVTT path ignores them as before — 91 existing checks confirm its output is
+  unchanged — but the sign path needs them.
+- The Swift harness is at 119 checks, up from 91.
+
 ## 0.7.6
 
 ### Fixed

package/FORK.md

@@ -29,6 +29,7 @@ Measured against the published `expo-video@56.1.4` tarball. `+`/`-` are added/re
 | `android/…/records/SubtitleStyle.kt` | 152 | Record → `CaptionStyleCompat`; hex colour parsing; font-family resolution (`res/font` → `ReactFontManager`); the `applyEmbeddedStyles` flag, which `SubtitleUtils` reads directly rather than `toCaptionStyle` and which defaults to `true` since 0.5.0. |
 | `android/…/utils/StackingSubtitleParser.kt` | 342 | `SubtitleParser` that segments the cue timeline and merges simultaneous **unpositioned** cues into one stacked block, plus the `SubtitleParser.Factory` that routes SubRip and ASS/SSA to it and wraps every parser in `FilteringSubtitleParser`. ASS gets there through `SsaCueNormalizer` as the `prepare` step — without it `SsaParser` sets both `line` and `position` on every cue and they would all take the passthrough branch. Assigns each cue a vertical slot it keeps for its whole time on screen — a finished cue's line is held blank (`\u200B`) so the cues above it do not drop. Merges through a `SpannableStringBuilder` so cue spans survive. |
 | `android/…/utils/SsaCueNormalizer.kt` | 93 | Clears the `line`/`position` Media3's `SsaParser` fills in on cues the ASS author never placed, so `bottomOffset` and cue stacking work on `.ass` the way they already do on `.srt`. The test is exact rather than heuristic: those values are a pure function of the cue's anchors, so matching both defaults for the bottom-centre anchors *is* "no positioning tag". Also drops events on a style the author made invisible (`Fontsize 0`, or a primary colour whose inverted alpha byte is `FF`) — that is where typesetters park working notes, and nothing downstream can carry "invisible". |
+| `android/…/utils/WebvttCueNormalizer.kt` | 61 | Clears the `line = -1 - i` that Media3's `WebvttSubtitle.getCues` stamps on every unpositioned WebVTT cue, plus the derived centre `position`, so `.vtt` takes the app's bottom padding and stacks like `.srt`. **Not exact the way the SSA one is**: once `getCues` has run, a parser-stacked `-1` and an author's `line:-1` are the same cue, so both are reset — a defensible reading, since `line:-1` means "the last line". Percentages and non-negative numbers are untouched. |
 | `android/…/utils/AssSignParser.kt` | 505 | Splits an ASS script into the typeset events this package draws and a copy of the script with those lines removed for Media3's parser. One pass, no matching step, so an event is in exactly one of the two outputs and cannot be drawn twice. Pure Kotlin with no Android imports, which is what makes it unit-testable on the JVM. Reads `\pos`, `\move`, `\org`, `\an`, `\frz`, `\frx`, `\fry`, `\fscx/y`, `\fs`, `\c`, `\alpha`, `\b`, `\i`, `\u` and the style columns behind them. The tag scanner takes the longest name first — `\c` must not swallow `\clip`, `\b` must not swallow `\bord`, `\blur` or `\be` — and reads a leading digit as part of the name for `\1c` and `\4a`. |
 | `android/…/utils/AssSignOverlay.kt` | 330 | Draws those signs on a canvas in front of the captions, with `Matrix` for rotation and scale and `Camera` for the two 3-D axes. Drives itself from the player's clock on a `Choreographer` callback, because signs do not ride the cue stream and nothing else would tell it when one starts; 40 ms events need frame granularity anyway. **Media3 cannot do this**: `SubtitlePainter` has no rotate, skew, Matrix or Camera call, and `Cue` has no rotation field. Sits in the same parent as `SubtitleView` — the content frame, sized to the video, which is why `\pos` survives letterboxing. Lays text out on change rather than per frame, because frame-by-frame typesetting changes the on-screen set every 40 ms. |
 | `android/…/utils/AssSignStore.kt` | 61 | Hands parsed signs from the parser to the overlay, keyed by the track's `Format.id`. **Not** the cue stream: `CueEncoder` marshals every cue through `Parcel`, and a custom span that is neither a framework `ParcelableSpan` nor one of Media3's three `CustomSpanBundler` types is dropped without a word — which is how 0.7.0 shipped with signs that parsed correctly and never appeared. Staying out of the cue stream also keeps 12,616 sign events from putting ~26,000 boundaries through the O(n²) timeline pass. |

package/android/src/main/java/expo/modules/video/utils/StackingSubtitleParser.kt

@@ -364,8 +364,8 @@ class StackingSsaParser(
 }
 
 /**
- * Routes SubRip and ASS/SSA through the stacking parsers so simultaneous cues stack, delegates every
- * other subtitle format to Media3's default handling, and wraps the result in
+ * Routes SubRip, ASS/SSA and WebVTT through the stacking parsers so simultaneous cues stack and the
+ * app's bottom padding applies, delegates every other subtitle format to Media3's default handling, and wraps the result in
  * [FilteringSubtitleParser] so the appearance a track asks for never overrides the app's own
  * subtitle style — except for cues the track positions itself, which keep theirs.
  */
@@ -377,8 +377,8 @@ class ExpoVideoSubtitleParserFactory : SubtitleParser.Factory {
     format.isSubrip() || defaultFactory.supportsFormat(format)
 
   override fun getCueReplacementBehavior(format: Format): Int =
-    if (format.isSubrip() || format.isSsa()) {
-      // Both stacking parsers emit whole-screen segments, whatever the delegate's own behaviour is.
+    if (format.isSubrip() || format.isSsa() || format.isWebvtt()) {
+      // Every stacking parser emits whole-screen segments, whatever the delegate's own behaviour is.
       Format.CUE_REPLACEMENT_BEHAVIOR_REPLACE
     } else {
       defaultFactory.getCueReplacementBehavior(format)
@@ -393,6 +393,13 @@ class ExpoVideoSubtitleParserFactory : SubtitleParser.Factory {
       StackingSsaParser(defaultFactory.create(format), format.id),
       keepAppearanceOfPositionedCues = true,
     )
+    // WebVTT gets the stacking parser too, with the placement Media3 stamps on every unpositioned
+    // cue taken back off first. Without that, a plain `.vtt` sat flush against the bottom edge and
+    // ignored `bottomOffset` entirely — see WebvttCueNormalizer. Not the sign carve-out: a
+    // positioned WebVTT cue is a cue setting on ordinary dialogue, not typesetting.
+    format.isWebvtt() -> FilteringSubtitleParser(
+      StackingSubtitleParser(defaultFactory.create(format), WebvttCueNormalizer::normalize)
+    )
     else -> FilteringSubtitleParser(defaultFactory.create(format))
   }
 
@@ -401,4 +408,7 @@ class ExpoVideoSubtitleParserFactory : SubtitleParser.Factory {
 
   private fun Format.isSsa(): Boolean =
     MimeTypes.TEXT_SSA.equals(sampleMimeType, ignoreCase = true)
+
+  private fun Format.isWebvtt(): Boolean =
+    MimeTypes.TEXT_VTT.equals(sampleMimeType, ignoreCase = true)
 }

package/android/src/main/java/expo/modules/video/utils/WebvttCueNormalizer.kt

@@ -0,0 +1,64 @@
+package expo.modules.video.utils
+
+import androidx.annotation.OptIn
+import androidx.media3.common.text.Cue
+import androidx.media3.common.util.UnstableApi
+
+/**
+ * Undoes the placement Media3's WebVTT path stamps on every cue that had none, so a `.vtt` track
+ * behaves like a `.srt` one: it takes the app's bottom padding, and simultaneous cues stack.
+ *
+ * ### What Media3 does
+ *
+ * `WebvttCueParser` leaves a cue with no `line:` setting at `line = DIMEN_UNSET`. That is not what
+ * reaches the screen. `WebvttParser.parse` wraps its cues in a `WebvttSubtitle` and hands them
+ * through `LegacySubtitleUtil`, and `WebvttSubtitle.getCues` runs the spec's snap-to-lines stacking
+ * on every query, unconditionally:
+ *
+ * ```java
+ * // Steps 4 - 10 of https://www.w3.org/TR/webvtt1/#cue-computed-line
+ * currentCues.add(cue.buildUpon().setLine((float) (-1 - i), Cue.LINE_TYPE_NUMBER).build());
+ * ```
+ *
+ * A lone cue gets `line = -1`. `SubtitlePainter` then takes its `LINE_TYPE_NUMBER` branch, where
+ * `line = -1` is `parentBottom - textHeight` — flush against the bottom edge — and
+ * `bottomPaddingFraction` is never read; the painter only consults it when `line` is unset. So a
+ * plain WebVTT track sits `parentHeight × padding` lower than the identical SubRip track, and
+ * `SubtitleSource.bottomOffset` has no effect on it at all. Verified against the 1.9.0 artefacts the
+ * app ships, byte for byte identical to 1.8.0.
+ *
+ * `position` gets the same treatment: with no setting, `derivePosition(CENTER)` yields `0.5` with
+ * `ANCHOR_TYPE_MIDDLE`. That is harmless for the painter but it makes [StackingSubtitleParser] read
+ * the cue as author-placed and pass it through unstacked.
+ *
+ * ### Why this cannot be exact, and why that is acceptable
+ *
+ * [SsaCueNormalizer] can recognise "the parser filled this in" precisely, because Media3's SSA
+ * defaults are a pure function of the anchors. WebVTT's are not: once `getCues` has run, a cue the
+ * parser stacked to `line = -1` is identical to one whose author wrote `line:-1`. Both are reset
+ * here. That is a defensible reading rather than a loss — `line:-1` means "the last line", and
+ * "the last line, lifted by the app's padding" is where every other format's bottom cue already
+ * goes. An author who wants an exact placement writes a percentage, and percentages are untouched.
+ *
+ * Only negative line *numbers* qualify. A fraction (`line:80%`), a non-negative number (`line:3`,
+ * counted from the top) or an explicit `position` off centre is a placement someone chose.
+ */
+@OptIn(UnstableApi::class)
+internal object WebvttCueNormalizer {
+  private const val DEFAULT_POSITION = 0.5f
+  private const val EPSILON = 0.0001f
+
+  fun normalize(cue: Cue): Cue {
+    val stackedLine = cue.lineType == Cue.LINE_TYPE_NUMBER && cue.line != Cue.DIMEN_UNSET && cue.line < 0f
+    val derivedPosition = cue.positionAnchor == Cue.ANCHOR_TYPE_MIDDLE &&
+      cue.position != Cue.DIMEN_UNSET &&
+      kotlin.math.abs(cue.position - DEFAULT_POSITION) < EPSILON
+
+    if (!stackedLine && !derivedPosition) return cue
+
+    val builder = cue.buildUpon()
+    if (stackedLine) builder.setLine(Cue.DIMEN_UNSET, Cue.LINE_TYPE_FRACTION)
+    if (derivedPosition) builder.setPosition(Cue.DIMEN_UNSET)
+    return builder.build()
+  }
+}

package/ios/AssSign.swift

@@ -0,0 +1,264 @@
+import Foundation
+
+/// One typeset event, in script coordinates. `AssSignOverlayView` maps it onto the video rect.
+///
+/// The Android side has the same shape, field for field, and for the same reason: this is what a
+/// renderer needs to put a sign on a placard, and AVFoundation can carry almost none of it.
+struct AssSign: Equatable {
+  let startMs: Int
+  let endMs: Int
+  let text: String
+
+  let x: Double
+  let y: Double
+  let alignment: Int
+
+  /// Clockwise, having already been flipped from ASS's counter-clockwise measure.
+  let rotationZ: Double
+  let rotationX: Double
+  let rotationY: Double
+  let pivotX: Double
+  let pivotY: Double
+
+  let scaleX: Double
+  let scaleY: Double
+  let fontSize: Double
+  let colour: Int
+  let alpha: Double
+  let outlineColour: Int
+  let outlineWidth: Double
+  let bold: Bool
+  let italic: Bool
+  let underline: Bool
+
+  /// The coordinate space the values above are expressed in.
+  let playResX: Double
+  let playResY: Double
+}
+
+extension AssSign {
+  /// `AVMediaSelectionOption` reports a full locale identifier (`id_ID`, `pt-BR`) where the track was
+  /// given a bare language tag. Comparing the language subtag is what makes the two ends meet.
+  static func normalizeLanguage(_ language: String) -> String {
+    let lowered = language.lowercased()
+    if let cut = lowered.firstIndex(where: { $0 == "-" || $0 == "_" }) {
+      return String(lowered[lowered.startIndex..<cut])
+    }
+    return lowered
+  }
+}
+
+/// A script split into the part this package draws and the part AVFoundation draws.
+struct AssSplit {
+  /// Typeset events, drawn by `AssSignOverlayView`.
+  let signs: [AssSign]
+  /// The script with every sign, drawing and invisible event cut out, for the WebVTT converter.
+  let dialogueOnly: String
+}
+
+extension SubtitleConverter {
+
+  /// Takes the typesetting out of a script and hands back what is left.
+  ///
+  /// ### Why signs cannot go through WebVTT
+  ///
+  /// AVFoundation renders a `.text` track itself, and WebVTT has no rotation, no scale and no
+  /// per-cue opacity to express. `AVTextStyleRule` has no attribute for any of it either. A sign
+  /// tilted to lie on a placard comes out flat, which reads as pasted over the picture rather than
+  /// part of it — in one episode of Jujutsu Kaisen S3, 3,723 events carry `\frz`, 1,304 of them past
+  /// 5°.
+  ///
+  /// So the same split the Android side makes: typeset events to us, dialogue to the platform, and
+  /// the sign lines removed from the copy the platform parses. There is no matching step to get
+  /// wrong, because an event is in exactly one of the two outputs.
+  ///
+  /// ### What counts as a sign
+  ///
+  /// Anything the author placed: an event carrying `\pos` or `\move`, or whose effective alignment
+  /// is not bottom-centre. The complement is dialogue, and AVFoundation is welcome to it.
+  static func splitAss(_ ass: String) -> AssSplit {
+    let normalized = normalizeNewlines(ass)
+    let script = AssScript(parsing: normalized)
+    let lines = normalized.components(separatedBy: "\n")
+
+    var signs: [AssSign] = []
+    var removed = Set<Int>()
+
+    for event in script.events {
+      guard event.endMs > event.startMs else { continue }
+      let style = script.styles[event.styleName]
+
+      // A style that draws nothing is where a typesetter parks working notes. Neither renderer
+      // should show it, and the WebVTT converter drops it too — cut here so both agree.
+      if style?.invisible == true {
+        removed.insert(event.lineIndex)
+        continue
+      }
+
+      guard let sign = buildSign(event: event, style: style, script: script) else { continue }
+
+      switch sign {
+      case .drop:
+        removed.insert(event.lineIndex)
+      case .sign(let value):
+        signs.append(value)
+        removed.insert(event.lineIndex)
+      case .dialogue:
+        break
+      }
+    }
+
+    let dialogueOnly = removed.isEmpty
+      ? normalized
+      : lines.enumerated().filter { !removed.contains($0.offset) }.map(\.element).joined(separator: "\n")
+
+    return AssSplit(signs: signs, dialogueOnly: dialogueOnly)
+  }
+
+  private enum SignResolution {
+    case sign(AssSign)
+    case dialogue
+    case drop
+  }
+
+  private static func buildSign(
+    event: AssScript.Event,
+    style: AssScript.Style?,
+    script: AssScript
+  ) -> SignResolution? {
+    var alignment: Int = style?.alignment ?? 2
+    var position: (x: Double, y: Double)?
+    var origin: (x: Double, y: Double)?
+    var rotationZ: Double = style?.angle ?? 0
+    var rotationX: Double = 0
+    var rotationY: Double = 0
+    var scaleX: Double = style?.scaleX ?? 1
+    var scaleY: Double = style?.scaleY ?? 1
+    var fontSize: Double = style?.fontSize ?? 48
+    var colour: Int = style?.colour ?? 0xFFFFFF
+    var alpha: Double = style?.alpha ?? 1
+    var bold: Bool = style?.bold ?? false
+    var italic: Bool = style?.italic ?? false
+    var underline: Bool = style?.underline ?? false
+    var isDrawing = false
+
+    for block in overrideBlocks(in: event.text) {
+      for tag in parseOverrideBlock(block) {
+        switch tag {
+        case .alignment(let value): alignment = value
+        case .position(let x, let y): position = (x, y)
+        case .origin(let x, let y): origin = (x, y)
+        case .rotationZ(let value): rotationZ = value
+        case .rotationX(let value): rotationX = value
+        case .rotationY(let value): rotationY = value
+        case .scaleX(let value): scaleX = value
+        case .scaleY(let value): scaleY = value
+        case .fontSize(let value): fontSize = value
+        case .primaryColour(let value): colour = value
+        case .primaryAlpha(let value): alpha = value
+        case .bold(let on): bold = on
+        case .italic(let on): italic = on
+        case .underline(let on): underline = on
+        case .drawing: isDrawing = true
+        case .reset: break
+        }
+      }
+    }
+
+    if isDrawing { return .drop }
+
+    let text = strippedText(event.text)
+    if text.trimmingCharacters(in: CharacterSet.whitespacesAndNewlines).isEmpty { return .drop }
+
+    // The complement of what AVFoundation lays out at the bottom by itself.
+    guard position != nil || alignment != 2 else { return .dialogue }
+
+    // Style margins only. A per-event margin override would need the Event to carry one, and it
+    // only ever matters for a sign with no `\pos` at all — which in a typeset script is close to
+    // none of them. Media3 ignores per-event margins outright, so both platforms agree here.
+    let marginL: Double = style?.marginL ?? 0
+    let marginR: Double = style?.marginR ?? 0
+    let marginV: Double = style?.marginV ?? 0
+
+    let x: Double = position?.x ?? {
+      switch (alignment - 1) % 3 {
+      case 0: return marginL
+      case 2: return script.playResX - marginR
+      default: return script.playResX / 2
+      }
+    }()
+    let y: Double = position?.y ?? {
+      switch (alignment - 1) / 3 {
+      case 0: return script.playResY - marginV
+      case 2: return marginV
+      default: return script.playResY / 2
+      }
+    }()
+
+    return .sign(AssSign(
+      startMs: event.startMs,
+      endMs: event.endMs,
+      text: text,
+      x: x,
+      y: y,
+      alignment: alignment,
+      // ASS measures counter-clockwise; every renderer here turns clockwise.
+      rotationZ: -rotationZ,
+      rotationX: rotationX,
+      rotationY: -rotationY,
+      pivotX: origin?.x ?? x,
+      pivotY: origin?.y ?? y,
+      scaleX: scaleX,
+      scaleY: scaleY,
+      fontSize: fontSize,
+      colour: colour,
+      alpha: alpha,
+      outlineColour: style?.outlineColour ?? 0x000000,
+      outlineWidth: style?.outlineWidth ?? 0,
+      bold: bold,
+      italic: italic,
+      underline: underline,
+      playResX: script.playResX,
+      playResY: script.playResY
+    ))
+  }
+
+  /// The contents of every `{...}` block, in order.
+  private static func overrideBlocks(in text: String) -> [String] {
+    var blocks: [String] = []
+    let chars = Array(text)
+    var i = 0
+    while i < chars.count {
+      guard chars[i] == "{" else { i += 1; continue }
+      guard let close = chars[(i + 1)...].firstIndex(of: "}") else { break }
+      blocks.append(String(chars[(i + 1)..<close]))
+      i = close + 1
+    }
+    return blocks
+  }
+
+  /// Override blocks out, ASS escapes in.
+  private static func strippedText(_ raw: String) -> String {
+    var out = ""
+    let chars = Array(raw)
+    var i = 0
+    while i < chars.count {
+      if chars[i] == "{", let close = chars[(i + 1)...].firstIndex(of: "}") {
+        i = close + 1
+        continue
+      }
+      if chars[i] == "\\", i + 1 < chars.count {
+        switch chars[i + 1] {
+        case "N", "n": out.append("\n"); i += 2; continue
+        // A hard space: U+00A0, not U+0020. A plain space would let the layout break the line
+        // exactly where the typesetter wrote the escape to stop it doing so.
+        case "h": out.append("\u{00A0}"); i += 2; continue
+        default: break
+        }
+      }
+      out.append(chars[i])
+      i += 1
+    }
+    return out
+  }
+}

package/ios/AssSignOverlayView.swift

@@ -0,0 +1,302 @@
+import AVKit
+import ExpoModulesCore
+import UIKit
+
+/// Draws ASS typesetting — signs, placards, on-screen labels — with the transforms the script asks
+/// for.
+///
+/// AVFoundation cannot: it renders a `.text` track itself, WebVTT can express no rotation, scale or
+/// per-cue opacity, and `AVTextStyleRule` has no attribute for any of them. So `SubtitleConverter`
+/// takes those events out of the WebVTT it builds and leaves them in `AssSignStore`, and this view
+/// draws them.
+///
+/// ### Where it sits
+///
+/// In `AVPlayerViewController.contentOverlayView`, which is the frame Apple provides between the
+/// video and the transport controls. Sized to `videoBounds` on every frame, so `\pos` — which is in
+/// `PlayResX`/`PlayResY` space — maps onto the picture rather than onto the player, and survives
+/// letterboxing and rotation without any arithmetic of its own.
+///
+/// ### Why it drives itself from the clock
+///
+/// Signs do not ride the subtitle track, so nothing announces when one starts. It reads the player's
+/// time on each frame instead, which is also the only granularity that works: frame-by-frame
+/// typesetting writes one event per frame, and a sign on screen for 40 ms has to arrive and leave on
+/// the frame it was authored for.
+final class AssSignOverlayView: UIView {
+
+  private weak var playerViewController: AVPlayerViewController?
+  private var displayLink: CADisplayLink?
+
+  private var signs: [AssSign] = []
+  private var active: [AssSign] = []
+  /// What `signs` was resolved from. Both halves matter: the item changes when the next episode
+  /// loads, the language when the viewer switches track.
+  private var resolvedItem: ObjectIdentifier?
+  private var resolvedLanguage: String?
+  private var lastLookup: CFTimeInterval = 0
+
+  /// Rebuilt only when the on-screen set changes, not per frame.
+  private var rendered: [RenderedSign] = []
+
+  private struct RenderedSign {
+    let text: NSAttributedString
+    let size: CGSize
+    let origin: CGPoint
+    let transform: CGAffineTransform
+  }
+
+  // MARK: - Lifecycle
+
+  init(playerViewController: AVPlayerViewController) {
+    self.playerViewController = playerViewController
+    super.init(frame: .zero)
+    isUserInteractionEnabled = false
+    backgroundColor = .clear
+    contentMode = .redraw
+  }
+
+  @available(*, unavailable)
+  required init?(coder: NSCoder) {
+    fatalError("init(coder:) is not used")
+  }
+
+  /// Adds the overlay to the controller's content overlay, or returns the one already there.
+  @discardableResult
+  static func install(in controller: AVPlayerViewController) -> AssSignOverlayView? {
+    guard let host = controller.contentOverlayView else { return nil }
+
+    for subview in host.subviews {
+      if let existing = subview as? AssSignOverlayView { return existing }
+    }
+
+    let overlay = AssSignOverlayView(playerViewController: controller)
+    host.addSubview(overlay)
+    overlay.start()
+    return overlay
+  }
+
+  static func remove(from controller: AVPlayerViewController) {
+    guard let host = controller.contentOverlayView else { return }
+    for subview in host.subviews {
+      guard let overlay = subview as? AssSignOverlayView else { continue }
+      overlay.stop()
+      overlay.removeFromSuperview()
+    }
+  }
+
+  private func start() {
+    guard displayLink == nil else { return }
+    let link = CADisplayLink(target: self, selector: #selector(tick))
+    link.add(to: .main, forMode: .common)
+    displayLink = link
+  }
+
+  private func stop() {
+    displayLink?.invalidate()
+    displayLink = nil
+    clearResolved()
+  }
+
+  override func willMove(toWindow newWindow: UIWindow?) {
+    super.willMove(toWindow: newWindow)
+    if newWindow == nil {
+      displayLink?.invalidate()
+      displayLink = nil
+    } else {
+      start()
+    }
+  }
+
+  // MARK: - The clock
+
+  @objc private func tick() {
+    guard let controller = playerViewController, let player = controller.player else { return }
+
+    // The picture moves under us: rotation, full screen, and a letterbox that changes with the
+    // video's own aspect all land here rather than in any positioning arithmetic.
+    let bounds = controller.videoBounds
+    if bounds != frame, bounds.width > 0, bounds.height > 0 {
+      frame = bounds
+      // Every measurement in `prepare` is in view pixels, so all of it is stale after a resize.
+      rendered = []
+      setNeedsDisplay()
+    }
+
+    // Re-resolved on a timer rather than only when empty. Gating on "no signs yet" is the same
+    // mistake twice: it never fires again once a video with typesetting has loaded, so the next
+    // episode inherits the previous one's signs and matches them against its own timeline. The
+    // Android side shipped exactly that and it took two releases to unpick.
+    let now = CACurrentMediaTime()
+    if now - lastLookup >= AssSignOverlayView.lookupInterval {
+      lastLookup = now
+      resolveSigns(for: player)
+    }
+    if signs.isEmpty { return }
+
+    let positionMs = Int(CMTimeGetSeconds(player.currentTime()) * 1000)
+    setActive(signs.filter { positionMs >= $0.startMs && positionMs < $0.endMs })
+  }
+
+  private func resolveSigns(for player: AVPlayer) {
+    guard let item = player.currentItem else {
+      if resolvedItem != nil { clearResolved() }
+      return
+    }
+
+    let identity = ObjectIdentifier(item)
+    let language = selectedSubtitleLanguage(of: item)
+    guard identity != resolvedItem || language != resolvedLanguage else { return }
+
+    resolvedItem = identity
+    resolvedLanguage = language
+
+    // Typesetting rides on the item that owns it, so there is no key to mismatch and no store to go
+    // stale: a different item simply has different signs.
+    let found = (item as? VideoPlayerItem)
+      .flatMap { playerItem in language.map { playerItem.assSigns[AssSign.normalizeLanguage($0)] } }
+      ?? nil
+
+    signs = found ?? []
+    rendered = []
+    setActive([])
+    log.info("[expo-video] ASS signs for \(language ?? "nil"): \(signs.count)")
+  }
+
+  private func clearResolved() {
+    resolvedItem = nil
+    resolvedLanguage = nil
+    signs = []
+    rendered = []
+    setActive([])
+  }
+
+  /// The locale of the selected legible option, which is the only identity a sideloaded track keeps
+  /// once it is inside the composition.
+  private func selectedSubtitleLanguage(of item: AVPlayerItem) -> String? {
+    guard let group = item.asset.mediaSelectionGroup(forMediaCharacteristic: .legible),
+          let option = item.currentMediaSelection.selectedMediaOption(in: group) else {
+      return nil
+    }
+    return option.locale?.identifier ?? option.extendedLanguageTag
+  }
+
+  private func setActive(_ next: [AssSign]) {
+    // Value equality across the whole sign, not a (time, text) stand-in: two events can share both
+    // and differ in where they sit, which is the case a frame-by-frame animation is made of.
+    guard next != active else { return }
+    active = next
+    rendered = []
+    setNeedsDisplay()
+  }
+
+  // MARK: - Drawing
+
+  override func draw(_ rect: CGRect) {
+    guard let context = UIGraphicsGetCurrentContext(), bounds.width > 0, bounds.height > 0 else { return }
+
+    if rendered.isEmpty && !active.isEmpty {
+      rendered = active.compactMap(prepare)
+    }
+
+    for sign in rendered {
+      context.saveGState()
+      context.concatenate(sign.transform)
+      sign.text.draw(at: sign.origin)
+      context.restoreGState()
+    }
+  }
+
+  private func prepare(_ sign: AssSign) -> RenderedSign? {
+    let alpha = max(0, min(1, sign.alpha))
+    if alpha == 0 { return nil }
+
+    // Script space to view space. Both axes scale independently, so a script authored at a different
+    // aspect ratio than the video still lands where it was drawn.
+    let scaleToViewX = bounds.width / CGFloat(sign.playResX)
+    let scaleToViewY = bounds.height / CGFloat(sign.playResY)
+
+    let attributed = attributedText(for: sign, scaleToViewY: scaleToViewY, alpha: alpha)
+    let size = attributed.boundingRect(
+      with: CGSize(width: CGFloat.greatestFiniteMagnitude, height: CGFloat.greatestFiniteMagnitude),
+      options: [.usesLineFragmentOrigin, .usesFontLeading],
+      context: nil
+    ).size
+
+    let anchorX = CGFloat(sign.x) * scaleToViewX
+    let anchorY = CGFloat(sign.y) * scaleToViewY
+    // \pos names the point the cue's alignment corner sits on, so the box is offset from it.
+    let left: CGFloat
+    switch (sign.alignment - 1) % 3 {
+    case 0: left = anchorX
+    case 2: left = anchorX - size.width
+    default: left = anchorX - size.width / 2
+    }
+    let top: CGFloat
+    switch (sign.alignment - 1) / 3 {
+    case 0: top = anchorY - size.height
+    case 2: top = anchorY
+    default: top = anchorY - size.height / 2
+    }
+
+    // \org moves the centre of rotation away from the text, which is how a sign stays glued to a
+    // placard pivoting off-screen. Without it every rotation would spin about the text's own middle.
+    let pivotX = CGFloat(sign.pivotX) * scaleToViewX
+    let pivotY = CGFloat(sign.pivotY) * scaleToViewY
+
+    // Scale first, then turn — ASS scales the glyph and then rotates it, and with an anisotropic
+    // scale the two do not commute. `concatenating` applies the receiver first, so the order reads
+    // in the order it happens.
+    let transform = CGAffineTransform(translationX: -pivotX, y: -pivotY)
+      .concatenating(CGAffineTransform(scaleX: CGFloat(sign.scaleX), y: CGFloat(sign.scaleY)))
+      .concatenating(CGAffineTransform(rotationAngle: CGFloat(sign.rotationZ) * .pi / 180))
+      .concatenating(CGAffineTransform(translationX: pivotX, y: pivotY))
+
+    return RenderedSign(text: attributed, size: size, origin: CGPoint(x: left, y: top), transform: transform)
+  }
+
+  private func attributedText(for sign: AssSign, scaleToViewY: CGFloat, alpha: Double) -> NSAttributedString {
+    let pointSize = max(1, CGFloat(sign.fontSize) * scaleToViewY)
+    var font = UIFont.systemFont(ofSize: pointSize, weight: sign.bold ? .bold : .regular)
+    if sign.italic, let descriptor = font.fontDescriptor.withSymbolicTraits(.traitItalic) {
+      font = UIFont(descriptor: descriptor, size: pointSize)
+    }
+
+    let paragraph = NSMutableParagraphStyle()
+    switch (sign.alignment - 1) % 3 {
+    case 0: paragraph.alignment = .left
+    case 2: paragraph.alignment = .right
+    default: paragraph.alignment = .center
+    }
+
+    var attributes: [NSAttributedString.Key: Any] = [
+      .font: font,
+      .foregroundColor: colour(sign.colour, alpha: alpha),
+      .paragraphStyle: paragraph
+    ]
+    if sign.underline {
+      attributes[.underlineStyle] = NSUnderlineStyle.single.rawValue
+    }
+    if sign.outlineWidth > 0 {
+      attributes[.strokeColor] = colour(sign.outlineColour, alpha: alpha)
+      // Negative means stroke *and* fill. A positive width would draw the outline only, leaving the
+      // letters hollow.
+      attributes[.strokeWidth] = -sign.outlineWidth * 2
+    }
+
+    return NSAttributedString(string: sign.text, attributes: attributes)
+  }
+
+  /// ASS colours carry no alpha byte; opacity travels separately.
+  private func colour(_ rgb: Int, alpha: Double) -> UIColor {
+    UIColor(
+      red: CGFloat((rgb >> 16) & 0xFF) / 255,
+      green: CGFloat((rgb >> 8) & 0xFF) / 255,
+      blue: CGFloat(rgb & 0xFF) / 255,
+      alpha: CGFloat(alpha)
+    )
+  }
+
+  /// How often to ask the store for signs that have not been parsed yet.
+  private static let lookupInterval: CFTimeInterval = 0.25
+}

package/ios/SubtitleConverterText.swift

@@ -285,12 +285,14 @@ internal struct RenderedSubtitleText {
   var isDrawing: Bool
 }
 
-private enum InlineToken {
+internal enum InlineToken {
   case text(String)
   case markup(String)
 }
 
-private extension SubtitleConverter {
+// Internal rather than private: `AssSign.swift` reuses the override-block scanner and the colour
+// parser, and reimplementing either would be two copies that have to agree about ASS forever.
+internal extension SubtitleConverter {
   /// Escapes only the parts of a cue that came from the source text.
   ///
   /// Order matters: `&` first, then `<`, then `>`. Escaping `&` last would double-escape the one in
@@ -370,6 +372,9 @@ private extension SubtitleConverter {
           case .underline(let on): on ? openTag("u") : closeTag("u")
           case .drawing: isDrawing = true
           case .reset: closeAll()
+          // The transform tags are for signs, which never reach this converter — a sign is taken
+          // out of the script before the WebVTT is built, because WebVTT can express none of them.
+          default: break
           }
         }
         i = end + 1
@@ -479,6 +484,50 @@ private extension SubtitleConverter {
     case underline(Bool)
     case drawing
     case reset
+    // Read for signs only. The WebVTT path ignores every one of them, because WebVTT can express
+    // none of it — which is the whole reason signs are drawn separately.
+    case origin(Double, Double)
+    case rotationZ(Double)
+    case rotationX(Double)
+    case rotationY(Double)
+    case scaleX(Double)
+    case scaleY(Double)
+    case fontSize(Double)
+    case primaryColour(Int)
+    case primaryAlpha(Double)
+    case bold(Bool)
+  }
+
+  struct AssColour {
+    let rgb: Int
+    let alpha: Double
+  }
+
+  /// `&HAABBGGRR&` or `&HBBGGRR&`, with or without the ampersands.
+  ///
+  /// The bytes are reversed against RGB and the alpha byte is inverted — `FF` is fully transparent.
+  /// A six-digit value carries no alpha byte and is therefore opaque.
+  static func parseAssColour(_ value: String, alphaOnly: Bool = false) -> AssColour? {
+    var text = value.trimmingCharacters(in: .whitespaces)
+    if text.hasSuffix("&") { text = String(text.dropLast()) }
+    if text.lowercased().hasPrefix("&h") { text = String(text.dropFirst(2)) }
+    guard !text.isEmpty, let hex = UInt32(text, radix: 16) else { return nil }
+
+    if alphaOnly || text.count <= 2 {
+      return AssColour(rgb: 0xFFFFFF, alpha: 1 - Double(hex & 0xFF) / 255)
+    }
+
+    let red: UInt32 = hex & 0xFF
+    let green: UInt32 = (hex >> 8) & 0xFF
+    let blue: UInt32 = (hex >> 16) & 0xFF
+    let rgb: Int = Int(red) << 16 | Int(green) << 8 | Int(blue)
+
+    var alpha: Double = 1
+    if text.count > 6 {
+      let transparency: UInt32 = (hex >> 24) & 0xFF
+      alpha = 1 - Double(transparency) / 255
+    }
+    return AssColour(rgb: rgb, alpha: alpha)
   }
 
   /// Scans one `{...}` block left to right.
@@ -487,6 +536,14 @@ private extension SubtitleConverter {
   /// one pass and the `\i1` keeps its position within the text. Reading the tag name as a run of
   /// letters is also what makes the longest-match problem disappear: `\c` cannot eat `\clip` and
   /// `\b` cannot eat `\bord`, because those parse as the names "clip" and "bord".
+  /// A number, or nothing. `Double` parses "nan" and "inf", and neither belongs in a transform.
+  static func finite(_ text: String) -> Double? {
+    guard let value = Double(text.trimmingCharacters(in: CharacterSet.whitespaces)), value.isFinite else {
+      return nil
+    }
+    return value
+  }
+
   static func parseOverrideBlock(_ block: String) -> [OverrideTag] {
     var tags: [OverrideTag] = []
     let chars = Array(block)
@@ -497,6 +554,10 @@ private extension SubtitleConverter {
       i += 1
 
       var name = ""
+      // A leading digit belongs to the name: \1c, \1a and \4a all start with one. Reading only
+      // letters left those as the empty name, which was harmless while colour was being dropped and
+      // is not once signs need it.
+      while i < chars.count, chars[i].isNumber { name.append(chars[i]); i += 1 }
       while i < chars.count, chars[i].isLetter { name.append(chars[i]); i += 1 }
 
       var argument = ""
@@ -526,9 +587,7 @@ private extension SubtitleConverter {
           tags.append(.alignment(value))
         }
       case "pos":
-        let parts = argument.split(separator: ",").map {
-          Double($0.trimmingCharacters(in: .whitespaces)) ?? 0
-        }
+        let parts = argument.split(separator: ",").compactMap { finite(String($0)) }
         if parts.count >= 2 { tags.append(.position(parts[0], parts[1])) }
       case "i": tags.append(.italic(argument.trimmingCharacters(in: .whitespaces) == "1"))
       case "u": tags.append(.underline(argument.trimmingCharacters(in: .whitespaces) == "1"))
@@ -539,6 +598,34 @@ private extension SubtitleConverter {
           tags.append(.drawing)
         }
       case "r": tags.append(.reset)
+      case "move":
+        // A move ends where it ends; drawing it at the destination beats drawing it at the start.
+        let parts = argument.split(separator: ",").compactMap { finite(String($0)) }
+        if parts.count >= 4 { tags.append(.position(parts[2], parts[3])) }
+      case "org":
+        let parts = argument.split(separator: ",").compactMap { finite(String($0)) }
+        if parts.count >= 2 { tags.append(.origin(parts[0], parts[1])) }
+      // `Double("nan")` and `Double("inf")` parse. A subtitle is untrusted scraper output, and a
+      // non-finite value carried into a transform makes the sign silently fail to draw — so every
+      // number here goes through `finite`.
+      case "frz", "fr":
+        if let value = finite(argument) { tags.append(.rotationZ(value)) }
+      case "frx":
+        if let value = finite(argument) { tags.append(.rotationX(value)) }
+      case "fry":
+        if let value = finite(argument) { tags.append(.rotationY(value)) }
+      case "fscx":
+        if let value = finite(argument) { tags.append(.scaleX(value / 100)) }
+      case "fscy":
+        if let value = finite(argument) { tags.append(.scaleY(value / 100)) }
+      case "fs":
+        if let value = finite(argument), value > 0 { tags.append(.fontSize(value)) }
+      case "c", "1c":
+        if let colour = parseAssColour(argument) { tags.append(.primaryColour(colour.rgb)) }
+      case "alpha", "1a":
+        if let colour = parseAssColour(argument, alphaOnly: true) { tags.append(.primaryAlpha(colour.alpha)) }
+      case "b":
+        tags.append(.bold(argument.trimmingCharacters(in: .whitespaces) != "0"))
       default: break
       }
     }
@@ -610,16 +697,35 @@ private extension SubtitleConverter {
 /// Header fields are read from their own `Format:` lines rather than assumed, because encoders
 /// reorder them and reading the Text column one position off produces a file that still parses and
 /// is entirely wrong.
-private struct AssScript {
+internal struct AssScript {
   struct Style {
+
     var alignment: Int
     var italic: Bool
     var underline: Bool
     /// The author asked for this style to draw nothing. See `isInvisibleStyle`.
     var invisible: Bool
+    // Read for signs. The WebVTT path uses none of it: colour, size and weight are the app's to
+    // decide there, and a sign is the one case where they are not.
+    var fontSize: Double = 48
+    var colour: Int = 0xFFFFFF
+    var alpha: Double = 1
+    var outlineColour: Int = 0x000000
+    var outlineWidth: Double = 0
+    var bold: Bool = false
+    var scaleX: Double = 1
+    var scaleY: Double = 1
+    var angle: Double = 0
+    var marginL: Double = 0
+    var marginR: Double = 0
+    var marginV: Double = 0
   }
 
   struct Event {
+    /// Index of the line this came from, so a sign can be cut out of the script handed to the
+    /// WebVTT converter. Mirrors the split on Android; it is what makes drawing an event twice
+    /// structurally impossible rather than merely avoided.
+    var lineIndex: Int = -1
     var startMs: Int
     var endMs: Int
     var styleName: String
@@ -639,7 +745,7 @@ private struct AssScript {
     var sawPlayResX = false
     var sawPlayResY = false
 
-    for rawLine in content.components(separatedBy: "\n") {
+    for (lineIndex, rawLine) in content.components(separatedBy: "\n").enumerated() {
       let line = rawLine.trimmingCharacters(in: .whitespaces)
       if line.isEmpty || line.hasPrefix(";") { continue }
 
@@ -685,7 +791,19 @@ private struct AssScript {
               : ((1...9).contains(rawAlignment) ? rawAlignment : 2),
             italic: field("italic") == "-1",
             underline: field("underline") == "-1",
-            invisible: Self.isInvisibleStyle(fontSize: field("fontsize"), primaryColour: field("primarycolour"))
+            invisible: Self.isInvisibleStyle(fontSize: field("fontsize"), primaryColour: field("primarycolour")),
+            fontSize: field("fontsize").flatMap(SubtitleConverter.finite) ?? 48,
+            colour: field("primarycolour").flatMap { SubtitleConverter.parseAssColour($0)?.rgb } ?? 0xFFFFFF,
+            alpha: field("primarycolour").flatMap { SubtitleConverter.parseAssColour($0)?.alpha } ?? 1,
+            outlineColour: field("outlinecolour").flatMap { SubtitleConverter.parseAssColour($0)?.rgb } ?? 0x000000,
+            outlineWidth: field("outline").flatMap(SubtitleConverter.finite) ?? 0,
+            bold: field("bold") == "-1",
+            scaleX: (field("scalex").flatMap(SubtitleConverter.finite) ?? 100) / 100,
+            scaleY: (field("scaley").flatMap(SubtitleConverter.finite) ?? 100) / 100,
+            angle: field("angle").flatMap(SubtitleConverter.finite) ?? 0,
+            marginL: field("marginl").flatMap(SubtitleConverter.finite) ?? 0,
+            marginR: field("marginr").flatMap(SubtitleConverter.finite) ?? 0,
+            marginV: field("marginv").flatMap(SubtitleConverter.finite) ?? 0
           )
         }
 
@@ -697,7 +815,8 @@ private struct AssScript {
         } else if key.caseInsensitiveCompare("Dialogue") == .orderedSame {
           // Only Dialogue reaches the screen. Comment carries typesetting notes and unused
           // alternates, and Picture/Sound/Movie/Command are not text at all.
-          guard let event = Self.parseEvent(value, fields: eventFields) else { continue }
+          guard var event = Self.parseEvent(value, fields: eventFields) else { continue }
+          event.lineIndex = lineIndex
           events.append(event)
         }
 

package/ios/VideoPlayerItem.swift

@@ -7,6 +7,13 @@ class VideoPlayerItem: AVPlayerItem {
   let urlAsset: VideoAsset
   let videoSource: VideoSource
   let isHls: Bool
+  /// ASS typesetting taken out of this item's subtitle tracks, keyed by language subtag.
+  ///
+  /// Carried on the item rather than in a store of its own, because the item *is* the identity the
+  /// overlay needs: two players can be loading different videos at once, and a store keyed by
+  /// anything a subtitle track keeps inside a composition — which is only its language — would have
+  /// them overwrite each other.
+  let assSigns: [String: [AssSign]]
   var videoTracks: [VideoTrack] {
     get async {
       return await tracksLoadingTask?.value ?? []
@@ -24,6 +31,8 @@ class VideoPlayerItem: AVPlayerItem {
     let asset = VideoAsset(url: url, videoSource: videoSource)
     self.urlAsset = asset
     self.isHls = asset.effectivePlaybackURL.isHLS || asset.effectiveContentType == .hls
+    // This initializer builds no composition, so it sideloads nothing and has no typesetting.
+    self.assSigns = [:]
     super.init(asset: urlAsset, automaticallyLoadedAssetKeys: nil)
     self.createTracksLoadingTask()
   }
@@ -51,15 +60,18 @@ class VideoPlayerItem: AVPlayerItem {
     // (non-HLS, non-DRM) sources — HLS declares its own subtitle renditions, and a composition would
     // bypass the DRM/resource-loader path used by protected content.
     var playbackAsset: AVAsset = asset
+    var signs: [String: [AssSign]] = [:]
     if let subtitleTracks = videoSource.subtitleTracks, !subtitleTracks.isEmpty, !isHls, videoSource.drm == nil {
-      if let composition = await VideoPlayerSubtitleSideload.buildComposition(
+      if let sideloaded = await VideoPlayerSubtitleSideload.buildComposition(
         from: asset,
         subtitleTracks: subtitleTracks,
         headers: videoSource.headers
       ) {
-        playbackAsset = composition
+        playbackAsset = sideloaded.composition
+        signs = sideloaded.signsByLanguage
       }
     }
+    self.assSigns = signs
 
     super.init(asset: playbackAsset, automaticallyLoadedAssetKeys: nil)
     self.createTracksLoadingTask()

package/ios/VideoPlayerSubtitleSideload.swift

@@ -13,14 +13,27 @@ import ExpoModulesCore
 /// pipeline already understands. Only WebVTT is natively supported, so `SRT` files are converted first, and
 /// remote files are downloaded to a temporary location because `insertTimeRange` requires a readable local track.
 internal enum VideoPlayerSubtitleSideload {
+  /// A composition plus the typesetting taken out of its subtitle tracks, keyed by language.
+  ///
+  /// The signs travel with the composition rather than through a store of their own. A store would
+  /// have to be keyed by something both ends can see, and the only identity a sideloaded track keeps
+  /// inside a composition is its language — which means two players loading different videos in the
+  /// same language would overwrite each other, and a second episode would inherit the first one's
+  /// signs. Handing them back here makes the `AVPlayerItem` itself the identity.
+  struct SideloadResult {
+    let composition: AVMutableComposition
+    let signsByLanguage: [String: [AssSign]]
+  }
+
   static func buildComposition(
     from asset: AVURLAsset,
     subtitleTracks: [SubtitleSource],
     headers: [String: String]?
-  ) async -> AVMutableComposition? {
+  ) async -> SideloadResult? {
     do {
       let mainDuration = try await asset.load(.duration)
       let composition = AVMutableComposition()
+      var signsByLanguage: [String: [AssSign]] = [:]
 
       // Copy the original audio + video tracks.
       let tracks = try await asset.load(.tracks)
@@ -54,7 +67,7 @@ internal enum VideoPlayerSubtitleSideload {
 
       var didAddSubtitle = false
       for subtitle in subtitleTracks {
-        guard let localURL = await resolveLocalVttURL(for: subtitle, headers: headers) else {
+        guard let localURL = await resolveLocalVttURL(for: subtitle, headers: headers, signs: &signsByLanguage) else {
           continue
         }
         let subtitleAsset = AVURLAsset(url: localURL)
@@ -94,7 +107,7 @@ internal enum VideoPlayerSubtitleSideload {
         }
       }
 
-      return didAddSubtitle ? composition : nil
+      return didAddSubtitle ? SideloadResult(composition: composition, signsByLanguage: signsByLanguage) : nil
     } catch {
       log.warn("[expo-video] Failed to build subtitle composition: \(error.localizedDescription)")
       return nil
@@ -108,7 +121,11 @@ internal enum VideoPlayerSubtitleSideload {
   /// also preserved the colours and weights a WebVTT file carries in `<c.yellow>` and `<b>`, which
   /// would then beat `subtitleStyle`. The temp-file cache means the work happens once per
   /// (uri, language, format, offset).
-  private static func resolveLocalVttURL(for subtitle: SubtitleSource, headers: [String: String]?) async -> URL? {
+  private static func resolveLocalVttURL(
+    for subtitle: SubtitleSource,
+    headers: [String: String]?,
+    signs: inout [String: [AssSign]]
+  ) async -> URL? {
     guard let uri = subtitle.uri else {
       return nil
     }
@@ -130,7 +147,15 @@ internal enum VideoPlayerSubtitleSideload {
     }
 
     switch subtitle.resolvedFormat {
-    case .ass: text = SubtitleConverter.assToVtt(text)
+    case .ass:
+      // Typesetting is taken out here rather than converted. WebVTT can express no rotation, scale
+      // or per-cue opacity, and AVFoundation renders the track itself, so a sign that went through
+      // would come out flat. `AssSignOverlayView` draws them instead.
+      let split = SubtitleConverter.splitAss(text)
+      if !split.signs.isEmpty {
+        signs[AssSign.normalizeLanguage(subtitle.language ?? "und")] = split.signs
+      }
+      text = SubtitleConverter.assToVtt(split.dialogueOnly)
     case .srt: text = SubtitleConverter.srtToVtt(text)
     case .vtt: text = SubtitleConverter.sanitizeVtt(text)
     }

package/ios/VideoView.swift

@@ -11,6 +11,14 @@ public final class VideoView: ExpoView, AVPlayerViewControllerDelegate {
       playerViewController.player = player?.ref
       // Forward any subtitle style set before the player was attached.
       player?.subtitleStyle = subtitleStyle
+      // ASS typesetting is drawn by us, not by AVFoundation, which can express none of its
+      // transforms. Installed whenever a player arrives and torn down with the view; the overlay
+      // sits idle and costs a display-link tick until a track with signs is actually loaded.
+      if player != nil {
+        AssSignOverlayView.install(in: playerViewController)
+      } else {
+        AssSignOverlayView.remove(from: playerViewController)
+      }
     }
   }
 
@@ -74,6 +82,7 @@ public final class VideoView: ExpoView, AVPlayerViewControllerDelegate {
   deinit {
     VideoManager.shared.unregister(videoView: self)
     removeFirstFrameObserver()
+    AssSignOverlayView.remove(from: playerViewController)
   }
 
   func enterFullscreen() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-video-subtitle",
-  "version": "0.7.6",
+  "version": "0.8.1",
   "description": "A cross-platform, performant video component for React Native and Expo with external subtitle sideloading and custom subtitle styling.",
   "keywords": [
     "expo",