From 664cfa635c6c502fde1dae929ead2be64031d6cb Mon Sep 17 00:00:00 2001
From: Casey Occhialini <1508707+littlespex@users.noreply.github.com>
Date: Mon, 27 Apr 2026 17:05:19 -0700
Subject: [PATCH 01/64] docs(cmcd): Add design spec for CMCD CML refactor

Spec the migration from shaka's custom CMCD integration to @svta/cml-cmcd
via a vendored closure-port in third_party/cml-cmcd/. CmcdManager becomes
a thin adapter over CmcdReporter; encoding, validation, and state
tracking move upstream to CML as the single source of truth.

Three-phase plan: vendor + delegate encoding, dedupe constants, then
swap state machine for CmcdReporter. Vendored port is transitional and
deletes when shaka adopts TypeScript (#8262).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 plans/cmcd-cml-refactor/spec.md | 573 ++++++++++++++++++++++++++++++++
 1 file changed, 573 insertions(+)
 create mode 100644 plans/cmcd-cml-refactor/spec.md

diff --git a/plans/cmcd-cml-refactor/spec.md b/plans/cmcd-cml-refactor/spec.md
new file mode 100644
index 0000000000..9b0638cbf5
--- /dev/null
+++ b/plans/cmcd-cml-refactor/spec.md
@@ -0,0 +1,573 @@
+# CMCD refactor: replace shaka-player's custom integration with `@svta/cml-cmcd`
+
+Date: 2026-04-27
+Status: Approved design, ready for implementation planning
+Tracking: [shaka-player#3619](https://github.com/shaka-project/shaka-player/issues/3619), [common-media-library#40](https://github.com/streaming-video-technology-alliance/common-media-library/issues/40)
+
+## Context
+
+Shaka Player ships a custom CMCD (Common Media Client Data, CTA-5004) integration:
+
+- [`lib/util/cmcd_manager.js`](lib/util/cmcd_manager.js) — 1704 lines, supports CMCD v1 and v2 in request/response/event modes.
+- [`test/util/cmcd_manager_unit.js`](test/util/cmcd_manager_unit.js) — 4317 lines, mostly testing CMCD wire-format correctness.
+- [`externs/cmcd.js`](externs/cmcd.js) — `CmcdData` typedef.
+- [`externs/shaka/player.js`](externs/shaka/player.js) — `shaka.extern.CmcdConfiguration` and `shaka.extern.CmcdTarget` typedefs.
+
+Other major adaptive players (hls.js, dash.js) have already migrated to the
+[`@svta/cml-cmcd`](https://github.com/streaming-video-technology-alliance/common-media-library/tree/main/libs/cmcd)
+package as the shared reference implementation. See
+[hls.js PR #7725](https://github.com/video-dev/hls.js/pull/7725) for the pattern
+this design follows.
+
+## Motivation
+
+This refactor pursues three explicit goals:
+
+1. **Standards conformance / single source of truth.** CML is the shared
+   reference implementation for CMCD across players. Tracking it gets shaka's
+   CMCD output spec-aligned automatically as v2 finalizes.
+2. **Reduce maintenance burden.** ~6000 lines of CMCD code (manager + tests)
+   carry the full encoding, validation, and state-machine surface. Most of that
+   logic is identical in CML. Maintenance can move upstream where multiple
+   players amortize it.
+3. **Submit upstream PR-friendly to shaka maintainers.** No new runtime npm
+   dependency (preserves shaka's hard-won "zero runtime deps" property), no
+   build-system upheaval, incremental phasing for review.
+
+## Constraints
+
+These are non-negotiable inputs to the design:
+
+1. **Zero runtime npm dependencies.** [AGENTS.md](AGENTS.md) calls this out as
+   a "hard-won property... do not introduce any." Direct npm consumption of
+   `@svta/cml-cmcd` is not on the table.
+2. **Closure Compiler ADVANCED_OPTIMIZATIONS.** All source uses
+   `goog.provide`/`goog.require` with JSDoc type annotations. Externs define
+   public types.
+3. **TypeScript migration is on the horizon.**
+   [shaka-player#8262](https://github.com/shaka-project/shaka-player/issues/8262)
+   tracks shaka's planned migration to TypeScript (P2, Backlog as of
+   2026-04). Whatever closure-era infrastructure we build is **transitional**
+   and gets deleted on migration day. Avoid building durable infrastructure
+   that exists only to bridge closure to a TS package.
+4. **Public API back-compat.** `shaka.extern.CmcdConfiguration`,
+   `shaka.extern.CmcdTarget`, and the `CmcdData` typedef are consumed by
+   shaka users. The `shaka.util.CmcdManager.StreamingFormat` enum is
+   `@export`ed (see [`cmcd_manager.js:1610`](lib/util/cmcd_manager.js:1610)).
+   v1 fields and v2 fields outside the experimental flag must keep their
+   existing names. v2-only fields flagged experimental may be renamed.
+
+## Decision summary
+
+- **Strategy: Manual vendored port** of `@svta/cml-cmcd` into
+  `third_party/cml-cmcd/`, following the
+  [`third_party/closure-uri/`](third_party/closure-uri/) precedent.
+- **Scope: Full replacement.** `shaka.util.CmcdManager` becomes a thin
+  shaka-specific adapter wrapping `cml.cmcd.CmcdReporter`. State tracking,
+  encoding, key filtering, sequence numbers, and event timing all move to the
+  reporter.
+- **Phasing: Three sequential PRs** (vendor + delegate encoding → dedupe
+  constants → adapter rewrite). Each phase is independently reviewable and
+  bisectable.
+- **Test ownership boundary:** CMCD wire-format tests move to / live in CML
+  upstream. Shaka keeps shaka-specific glue tests + a small end-to-end smoke
+  set.
+
+Rejected alternatives:
+
+- **CML emits a closure-friendly distribution** (option A in brainstorm).
+  Rejected because shaka's TS migration would orphan the closure target in
+  CML; not worth the upstream burden.
+- **Build-time TS-to-Closure transpiler in shaka** (option B). Rejected
+  because tsickle is archived (last push 2024-05) and a custom transformer
+  would cost ~500-1500 LoC of throwaway tooling. CML's TS uses `as const`
+  enum patterns, type-only imports, intersections, and `ValueOf<>` generics
+  that aren't trivial to mechanically translate.
+- **Wait for shaka's TS migration before doing CMCD work.** Rejected because
+  the migration is in Backlog with no concrete timeline; CMCD work shouldn't
+  block on it.
+
+## Architecture
+
+Three layers, each with one job:
+
+```
+┌────────────────────────────────────────────────────────────────┐
+│ shaka public API (UNCHANGED except experimental v2 renames)    │
+│   shaka.extern.CmcdConfiguration   shaka.extern.CmcdTarget     │
+│   externs/cmcd.js (CmcdData typedef)                           │
+│   shaka.util.CmcdManager.StreamingFormat (the only @export)    │
+└────────────────────────────────────────────────────────────────┘
+                              ▲
+                              │ (back-compat preserved)
+┌────────────────────────────────────────────────────────────────┐
+│ lib/util/cmcd_manager.js (REFACTORED, ~250 lines target)       │
+│   Thin shaka-specific adapter:                                 │
+│   - NetworkingEngine integration (applyRequestData /           │
+│     applyResponseData) — public method signatures unchanged    │
+│   - <video> + Player event listeners → reporter.update(...)    │
+│   - Maps shaka.extern.CmcdConfiguration → CmcdReporterConfig   │
+│   - Wires CmcdReporter's `requester` callback to               │
+│     NetworkingEngine for event-mode reports                    │
+└────────────────────────────────────────────────────────────────┘
+                              │
+                              │ goog.require('cml.cmcd.*')
+                              ▼
+┌────────────────────────────────────────────────────────────────┐
+│ third_party/cml-cmcd/ (NEW, vendored from CML)                 │
+│   Closure-annotated JS port of @svta/cml-cmcd source           │
+│   Namespace: cml.cmcd.* (mirrors CML's package shape)          │
+│   SUMMARY.txt, LICENSE, NOTICE                                 │
+└────────────────────────────────────────────────────────────────┘
+```
+
+**Future-proofing.** Choosing namespace `cml.cmcd.*` so it mirrors CML's
+actual export surface. When shaka migrates to TypeScript:
+`goog.require('cml.cmcd.CmcdReporter')` becomes
+`import { CmcdReporter } from '@svta/cml-cmcd'`, and the entire
+`third_party/cml-cmcd/` directory deletes — no other code changes.
+
+## The vendored port (`third_party/cml-cmcd/`)
+
+### Subset to port
+
+Pulled from `@svta/cml-cmcd` v2.3.0 source at
+`libs/cmcd/src/`. Files map one-to-one (CamelCase TS file → snake_case JS file).
+
+**Included (~25 files):**
+
+| Category | Files |
+|---|---|
+| Reporter (the main class) | `CmcdReporter.ts` |
+| Encoders | `encodeCmcd.ts`, `encodePreparedCmcd.ts`, `prepareCmcdData.ts`, `toCmcdHeaders.ts`, `toCmcdQuery.ts`, `toCmcdUrl.ts`, `toCmcdValue.ts`, `appendCmcdHeaders.ts`, `appendCmcdQuery.ts`, `toPreparedCmcdHeaders.ts`, `ensureHeaders.ts` |
+| Helpers | `upConvertToV2.ts`, `resolveVersion.ts` |
+| Constants | `CMCD_DEFAULT_TIME_INTERVAL.ts`, `CMCD_EVENT_KEYS.ts`, `CMCD_FORMATTER_MAP.ts`, `CMCD_HEADER_MAP.ts`, `CMCD_INNER_LIST_KEYS.ts`, `CMCD_KEYS.ts`, `CMCD_KEY_TYPES.ts`, `CMCD_MIME_TYPE.ts`, `CMCD_PARAM.ts`, `CMCD_REQUEST_KEYS.ts`, `CMCD_RESPONSE_KEYS.ts`, `CMCD_STRING_LENGTH_LIMITS.ts`, `CMCD_TOKEN_VALUES.ts`, `CMCD_V1.ts`, `CMCD_V1_KEYS.ts`, `CMCD_V2.ts` |
+| Enums | `CmcdObjectType.ts`, `CmcdStreamingFormat.ts`, `CmcdStreamType.ts`, `CmcdPlayerState.ts`, `CmcdEventType.ts`, `CmcdReportingMode.ts`, `CmcdTransmissionMode.ts`, `CmcdHeaderField.ts` |
+| Type definitions (typedefs in closure) | `Cmcd.ts`, `CmcdData.ts`, `CmcdRequest.ts`, `CmcdResponse.ts`, `CmcdEvent.ts`, `CmcdReportConfig.ts`, `CmcdEventReportConfig.ts`, `CmcdReporterConfig.ts`, `CmcdEncodeOptions.ts`, `CmcdRequestReport.ts`, `CmcdRequestReportConfig.ts`, `CmcdFormatter.ts`, `CmcdFormatterMap.ts`, `CmcdFormatterOptions.ts`, `CmcdHeaderKey.ts`, `CmcdHeaderMap.ts`, `CmcdHeaderValue.ts`, `CmcdKey.ts`, `CmcdValue.ts`, `CmcdRequestKey.ts`, `CmcdCustomKey.ts`, `CmcdCustomValue.ts`, `CmcdObjectTypeList.ts`, `CmcdV1.ts`, `CmcdVersion.ts` |
+
+**Excluded (explicitly skipped):**
+
+| Category | Files | Why |
+|---|---|---|
+| Decoders | `decodeCmcd.ts`, `fromCmcdHeaders.ts`, `fromCmcdQuery.ts`, `fromCmcdUrl.ts`, `groupCmcdHeaders.ts` | Players emit CMCD; they don't parse it. |
+| Validators | `validateCmcd.ts`, `validateCmcdEventReport.ts`, `validateCmcdEvents.ts`, `validateCmcdHeaders.ts`, `validateCmcdKeys.ts`, `validateCmcdRequest.ts`, `validateCmcdStructure.ts`, `validateCmcdValues.ts`, `CmcdValidationIssue.ts`, `CmcdValidationOptions.ts`, `CmcdValidationResult.ts`, `CmcdValidationSeverity.ts`, `CmcdDataValidationResult.ts`, `CmcdEventsValidationResult.ts`, `mergeValidationResults.ts`, `isValid.ts` | Tooling-only; large; halves port size. Add later only if shaka adds a debug-mode self-check. |
+| Predicates | `isCmcdCustomKey.ts`, `isCmcdEventKey.ts`, `isCmcdRequestKey.ts`, `isCmcdResponseReceivedKey.ts`, `isCmcdV1Data.ts`, `isCmcdV1Key.ts`, `isCmcdV2Data.ts`, `isTokenField.ts` | Tooling-only. |
+
+### `@svta/cml-utils` dependency handling
+
+CML's CMCD package depends on `@svta/cml-utils` for `uuid()`, `HttpRequest`,
+`HttpResponse`, and `ValueOf<>`. Type-only imports (`HttpRequest`,
+`HttpResponse`, `ValueOf<>`) erase during conversion. Only one runtime
+dependency remains: `uuid()`, called at one site (`createCmcdReporterConfig`'s
+default for `sid`).
+
+**Approach:** Vendor a tiny `third_party/cml-cmcd/cml_utils.js` (`goog.provide('cml.cmcd.uuid')`)
+shimming `crypto.randomUUID()` (already polyfilled in
+[`lib/polyfill/random_uuid.js`](lib/polyfill/random_uuid.js)). The vendored
+`CmcdReporter` source stays **verbatim** to upstream CML, which makes per-bump
+diffs trivial.
+
+The shaka adapter always sets `sid` explicitly when building
+`CmcdReporterConfig` (drawn from `shaka.extern.CmcdConfiguration.sessionId` or
+generated via shaka's own UUID). The reporter's default-`sid` codepath is dead
+at runtime and closure-stripped.
+
+This is invisible at the swap boundary: `goog.require('cml.cmcd.CmcdReporter')`
+→ `import { CmcdReporter } from '@svta/cml-cmcd'`. Post-migration, CML's
+transitive dep on `@svta/cml-utils` is internal to the npm package; shaka
+never imports from cml-utils directly.
+
+### File naming and namespace conventions
+
+- TS file `libs/cmcd/src/CmcdReporter.ts` → JS file `third_party/cml-cmcd/cmcd_reporter.js`.
+- `goog.provide('cml.cmcd.CmcdReporter')` — class/symbol name preserved, scoped under `cml.cmcd.*`.
+- TS `import { X } from './Y.ts'` → closure `goog.require('cml.cmcd.Y')`.
+- One exception: utility module `cml_utils.js` provides `cml.cmcd.uuid`.
+
+### `SUMMARY.txt` format
+
+Extends the [`third_party/SUMMARY.txt`](third_party/SUMMARY.txt) precedent:
+
+```
+cml-cmcd
+  Common Media Library CMCD encoder + reporter, v2.3.0,
+  by Streaming Video Technology Alliance / Casey Occhialini et al.
+  Apache 2.0 license.
+  https://github.com/streaming-video-technology-alliance/common-media-library
+    /tree/main/libs/cmcd
+  Source npm: @svta/cml-cmcd
+
+  TRANSITIONAL: This vendored port exists because shaka-player uses Closure
+  Compiler. When shaka migrates to TypeScript (issue #8262), delete this
+  directory and replace `goog.require('cml.cmcd.X')` with
+  `import { X } from '@svta/cml-cmcd'`.
+
+  Local mods:
+    - TypeScript source converted to Closure-annotated JS by hand
+    - Type-only imports erased; replaced with local closure typedefs
+    - Decoders (decodeCmcd, fromCmcd*) omitted: shaka emits CMCD only
+    - Validators (validateCmcd*, isCmcd*) omitted: tooling-only utilities
+    - cml-utils dep removed: shaka adapter always sets `sid` explicitly;
+      a 5-line cml_utils.js shim provides `uuid` for any dead default paths
+```
+
+`LICENSE` and `NOTICE` files copied from CML; both Apache 2.0 (matches shaka).
+
+### Build integration
+
+- `third_party/cml-cmcd/*.js` files added to [`build/types/core`](build/types/core)
+  alongside the existing `+../../lib/util/cmcd_manager.js` entry. CMCD remains in
+  the core build variant.
+- Any new vocabulary that fails the spell-checker added to
+  [`project-words.txt`](project-words.txt).
+
+## The shaka-side adapter ([`lib/util/cmcd_manager.js`](lib/util/cmcd_manager.js))
+
+Target size: ~250 lines (down from 1704). Three responsibilities:
+
+### 1. Lifecycle and player wiring
+
+- Construct `cml.cmcd.CmcdReporter` on first `configure(config)` call.
+- Tear down on `reset()`; null out the reporter; remove all event listeners.
+- Re-construct on subsequent `configure()` if config materially changed.
+- Subscribe to `<video>` events and `shaka.Player` events; translate state
+  changes to `reporter.update(...)` calls (see table below).
+
+### 2. Request/response interception
+
+Existing public methods preserved with same signatures:
+
+```js
+applyRequestData(type, request, context)
+applyResponseData(type, response, context)
+```
+
+`applyRequestData` flow:
+
+1. Adapter extracts shaka-specific fields:
+   - `objectType` ← `RequestType` + `segment.type`/`segment.mimeType`
+   - `bitrate` ← `segmentRef.variant.bandwidth`
+   - `duration` ← `segmentRef.endTime - segmentRef.startTime`
+   - `topBitrate` ← player ABR / variant constraints
+   - `rtp` ← `bitrate * config.rtpSafetyFactor` (computed in adapter, since CML's reporter doesn't know about a safety factor)
+2. Adapter calls `reporter.createRequestReport(objectType, {br, d, tb, rtp, ...})`.
+3. Reporter returns either `{headers: Record<string,string>}` or `{query: string}` depending on transmission mode.
+4. Adapter mutates `request.headers` / `request.uris[i]` in place.
+
+`applyResponseData` flow:
+
+1. Adapter measures `ttfb`/`ttlb` via existing `requestTimestampMap_` mechanism.
+2. Adapter calls `reporter.recordResponseReceived(requestId, {ttfb, ttlb, rc, url})`.
+3. Reporter buffers response data for the next emission opportunity.
+
+The shaka-specific extraction helpers
+(`getObjectType_`, `getBitrate_`, `getDuration_`, `getTopBitrate_`,
+`getStreamFormat_`) **stay in the adapter**. They encode "how to read
+shaka's variant/stream/segment shapes" — shaka-specific knowledge.
+
+What goes away from the manager: all encoding logic, key filtering,
+header/query construction, sequence-number tracking, event-timer code, mode
+selection, MSD computation, the various `applyRequest_`/`applyManifestData`
+private methods.
+
+### 3. Configuration translation
+
+One function `toReporterConfig_(shakaCmcdConfig)` performs field renames and
+shape conversion:
+
+| `shaka.extern.CmcdConfiguration` (post-rename) | `cml.cmcd.CmcdReporterConfig` |
+|---|---|
+| `enabled: boolean` | (gate at adapter level — adapter no-ops when `false`) |
+| `useHeaders: boolean` | `transmissionMode: CMCD_HEADERS \| CMCD_QUERY` |
+| `sessionId: string` | `sid: string` (always set explicitly) |
+| `contentId: string` | `cid: string` |
+| `rtpSafetyFactor: number` | (adapter uses to compute `rtp` per request) |
+| `includeKeys: Array<CmcdKey>` | `enabledKeys: Array<CmcdKey>` |
+| `version: 1\|2` | `version: CMCD_V1 \| CMCD_V2` |
+| **`eventTargets`** *(was `targets`, experimental rename)* | `eventTargets` |
+| Per-target: **`includeKeys`** *(was `enabledKeys`, experimental rename)* | Per-target: `enabledKeys` |
+
+The per-target rename mirrors hls.js PR #7725's pattern:
+`Omit<CmcdEventReportConfig, 'enabledKeys'> & { includeKeys?: CmcdKey[] }`.
+shaka users see `includeKeys` consistently (top-level and per-target); CML
+internals see `enabledKeys` per-target.
+
+The experimental flag on shaka's CMCD v2 config (see
+[`externs/shaka/player.js:2810-2818`](externs/shaka/player.js)) authorizes
+these renames. v1 fields keep their existing names.
+
+### Player state ↔ reporter state mapping
+
+All state mutation goes through `reporter.update(partialState)`:
+
+| shaka event/signal | reporter call |
+|---|---|
+| Buffering becomes true | `reporter.update({playerState: REBUFFERING})` |
+| Buffering becomes false | `reporter.update({playerState: PLAYING})` |
+| `setLowLatency(true)` + DASH | `reporter.update({streamingFormat: LOW_LATENCY_DASH})` |
+| `setLowLatency(true)` + HLS | `reporter.update({streamingFormat: LOW_LATENCY_HLS})` |
+| Pause | `reporter.update({playerState: PAUSED})` |
+| Content ID changes | `reporter.update({cid: newId})` |
+| Visibility change → backgrounded | `reporter.update({backgrounded: true})` |
+| Mute / unmute | `reporter.update({muted: true/false})` |
+| Throughput estimate update | `reporter.update({mtp: bandwidthKbps})` |
+
+MSD is computed internally by `CmcdReporter`; the adapter does not feed it.
+
+### Public-API back-compat details
+
+- **`shaka.util.CmcdManager.StreamingFormat`** stays available with identical
+  string values. Implemented as a re-export alias of
+  `cml.cmcd.CmcdStreamingFormat`. `@export` annotation preserved. Verified
+  values match: `'d'`, `'ld'`, `'h'`, `'lh'`, `'s'`, `'o'`.
+- **`shaka.util.CmcdManager.{ObjectType,Version,StreamType,CmcdKeys,CmcdV2Constants,CmcdV2Keys,CmcdMode}`**
+  are all internal-only (no `@export`). Deleted in Phase 2; references rewritten to `cml.cmcd.*`.
+- **`externs/cmcd.js`** (`CmcdData` typedef): kept as the public-facing typedef
+  shape. Internally, the adapter and vendored port use `cml.cmcd.CmcdData`.
+  The two are structurally equivalent.
+- **`shaka.extern.CmcdConfiguration`** typedef: keeps `targets` field name
+  changed to `eventTargets`; `shaka.extern.CmcdTarget` typedef gets
+  `enabledKeys` → `includeKeys` rename. Both are experimental-flagged so
+  breaking change is acceptable.
+
+### Event-mode dispatch via NetworkingEngine
+
+`CmcdReporter` accepts a `requester: (req) => Promise<{status: number}>`
+config option for dispatching event-mode reports. The shaka adapter wires this
+to `NetworkingEngine` rather than raw `fetch`:
+
+```js
+const requester = (cmcdReq) => {
+  const retryParams = shaka.net.NetworkingEngine.defaultRetryParameters();
+  const shakaReq = shaka.net.NetworkingEngine.makeRequest(
+      [cmcdReq.url], retryParams);
+  shakaReq.method = cmcdReq.method || 'GET';
+  shakaReq.headers = cmcdReq.headers || {};
+  shakaReq.body = cmcdReq.body;
+  return this.networkingEngine_
+      .request(RequestType.TIMING, shakaReq, {type: 'cmcd-event'})
+      .promise
+      .then((response) => ({status: 200}))
+      .catch((err) => ({status: err.status || 0}));
+};
+```
+
+This routes CMCD event-mode reports through shaka's NetworkingEngine,
+inheriting auth-header injection, retry, request filters, etc. — same as
+manifests and segments. **No new public config field needed** (vs. hls.js's
+`loader` field): users already control transport via NetworkingEngine plugins.
+
+`RequestType.TIMING` is the existing "non-content network operation" bucket.
+Could later become a dedicated `CMCD_EVENT_REPORT` request type if maintainers
+want one; defer that decision until needed.
+
+## CML-side requirements (verify before/during Phase 3)
+
+The adapter assumes CmcdReporter exposes the following surface. Verify against
+CML v2.3.0 (or whichever version is current at implementation time); add
+upstream in CML if missing.
+
+| Need | Status |
+|---|---|
+| `reporter.update(partialState)` for state mutation | confirmed |
+| `reporter.createRequestReport(objectType, data)` returning headers/query | confirmed (per hls.js PR #7725) |
+| `reporter.recordResponseReceived(requestId, {ttfb, ttlb, rc, url, ...})` | confirmed |
+| `requester` config field for event-mode dispatch | confirmed (per CML source) |
+| Built-in time-interval event timer | likely present; verify reporter owns it (shaka stops running its own) |
+| MSD computed internally by reporter | confirmed |
+| Sequence numbers per-target | likely present; verify per v2 spec |
+
+State fields the adapter feeds via `update()`:
+
+| Field | Source | Maps to |
+|---|---|---|
+| `playerState: CmcdPlayerState` | video events + buffer state | v2 `sta` |
+| `streamingFormat: CmcdStreamingFormat` | manifest parser type + LL flag | `sf` |
+| `cid: string` | content ID change | `cid` (also triggers v2 `c` event) |
+| `backgrounded: boolean` | visibility detection | `bg` (also triggers v2 `b` event) |
+| `muted: boolean` | media element state | (v2 `m`/`um` events) |
+| `mtp: number` | shaka throughput estimator | `mtp` |
+| `bl: number` (buffer length) | shaka playhead | `bl` (per-request, may live on `createRequestReport` data) |
+
+CMCD v2 events the reporter must support emitting (matches shaka's existing
+`CmcdV2Events` set in [`cmcd_manager.js:1653-1664`](lib/util/cmcd_manager.js:1653)):
+
+`ps`, `e`, `t`, `c`, `b`, `m`, `um`, `pe`, `pc`, `rr`.
+
+Verify CML's `CmcdEventType` enum includes all of these. If any are missing,
+add to CML in a precursor PR before shaka Phase 3 lands.
+
+## Migration phasing
+
+Three sequential PRs. Each is independently reviewable, bisectable, and
+behavior-preserving except where explicitly noted.
+
+### Phase 1 — Vendor `third_party/cml-cmcd/` and route encoding through it
+
+- Add `third_party/cml-cmcd/` directory with the closure-annotated port
+  (~25 files), `SUMMARY.txt`, `LICENSE`, `NOTICE`.
+- Update [`build/types/core`](build/types/core) to include the new files.
+- Update [`project-words.txt`](project-words.txt) for any new vocab.
+- Refactor shaka's `serialize`/`toQuery`/`appendQueryToUri`/`urlToRelativePath`
+  static methods in [`cmcd_manager.js`](lib/util/cmcd_manager.js) to delegate
+  to `cml.cmcd.encodeCmcd` / `cml.cmcd.appendCmcdQuery` /
+  `cml.cmcd.appendCmcdHeaders`.
+- **No behavior change.** Same wire output. State machine, sequence numbers,
+  event timing, public API all unchanged.
+- Tests in [`cmcd_manager_unit.js`](test/util/cmcd_manager_unit.js) mostly
+  unchanged — they assert wire output, which stays identical.
+- **Approximate diff size**: +3000 lines (vendored port), ~500 lines
+  changed in `cmcd_manager.js`.
+
+### Phase 2 — Adopt CML's constants/enums; delete shaka's duplicates
+
+- Replace internal references to:
+  - `shaka.util.CmcdManager.ObjectType` → `cml.cmcd.CmcdObjectType`
+  - `shaka.util.CmcdManager.Version` → `cml.cmcd.CmcdVersion`
+  - `shaka.util.CmcdManager.StreamType` → `cml.cmcd.CmcdStreamType`
+  - `shaka.util.CmcdManager.CmcdKeys` → CML's `CMCD_*_KEYS` constants
+  - `shaka.util.CmcdManager.CmcdV2Constants` → CML equivalents
+  - `shaka.util.CmcdManager.CmcdV2Keys` → CML equivalents
+  - `shaka.util.CmcdManager.CmcdMode` → `cml.cmcd.CmcdReportingMode`
+- Re-export `shaka.util.CmcdManager.StreamingFormat` as alias of
+  `cml.cmcd.CmcdStreamingFormat` (keeps `@export`; values match).
+- Delete the duplicate constant definitions from
+  [`cmcd_manager.js`](lib/util/cmcd_manager.js).
+- **No behavior change.** Just deduping.
+- **Approximate diff size**: ~150 lines deleted from `cmcd_manager.js`,
+  no additions.
+
+### Phase 3 — Replace state machine with `CmcdReporter` (the big one)
+
+- Rewrite [`cmcd_manager.js`](lib/util/cmcd_manager.js) as a thin adapter
+  (~250 lines target).
+- Construct `cml.cmcd.CmcdReporter` on first config; tear down on reset.
+- Wire `<video>` events and player state to `reporter.update(...)`.
+- Replace per-request `applyRequest_` logic with
+  `reporter.createRequestReport(...)` calls.
+- Wire `requester` callback to NetworkingEngine for event-mode reports.
+- Apply config renames in [`externs/shaka/player.js`](externs/shaka/player.js):
+  - `shaka.extern.CmcdConfiguration.targets` → `eventTargets`
+  - `shaka.extern.CmcdTarget.enabledKeys` → `includeKeys`
+- Test rewrite (see Tests section): delete CMCD wire-format tests (~3000+
+  lines); add ~500 lines of integration tests focused on shaka-specific
+  glue. Add ~100 lines of end-to-end smoke tests.
+- **Approximate diff size**: ~1450 lines deleted from `cmcd_manager.js`,
+  ~3800 lines deleted from tests, ~750 lines added.
+
+### Phase ordering rationale
+
+- **Why not collapse 1+2:** Phase 1 is purely additive (vendor + delegate);
+  Phase 2 is purely deletive (remove duplicates). Mixing them makes review
+  harder. Splitting keeps each PR's intent crisp.
+- **Why not collapse 2+3:** Phase 3 is the high-risk PR (behavioral rewrite).
+  Phase 2 lets us land the constant migration safely first; if Phase 3 needs
+  revision in review, Phase 2 still stands on its own.
+- **Phase 3 owns the experimental config rename** because the adapter rewrite
+  is what consumes the renamed fields. Splitting the rename to its own phase
+  would give a transient state where externs name one thing and adapter reads
+  another.
+
+### Per-phase verification gates
+
+Each phase must:
+
+- Pass `python3 build/check.py` (lint + type-check + spell + custom rules).
+- Pass full test suite (`python3 build/test.py`).
+- Pass `python3 build/all.py` (full build, including docs and demo).
+- Demo app loads and plays content with CMCD enabled in both query and
+  header transmission modes.
+
+## Tests strategy
+
+Three buckets, with explicit ownership boundaries.
+
+### Bucket A — CMCD wire-format / encoding correctness → lives in CML upstream
+
+Tests that exercise "do we produce the right CMCD bytes for these inputs":
+
+- Key serialization, value escaping, header vs query encoding
+- v1/v2 mode-specific key filtering
+- Inner-list encoding (`br`, `tb`, `bl`, `mtp`, `nor`)
+- `upConvertToV2`, `prepareCmcdData`, structured-field serialization
+- Sequence-number progression
+- Event timing/batching logic in `CmcdReporter`
+
+These tests live in / move to `@svta/cml-cmcd`'s test suite
+(`libs/cmcd/test/`). Phase 3 deletes the corresponding ~3000+ lines from
+[`test/util/cmcd_manager_unit.js`](test/util/cmcd_manager_unit.js).
+
+### Bucket B — shaka-specific glue → lives in shaka
+
+Tests that exercise the adapter's translation layer, scoped to shaka-side
+responsibilities. Target ~500 lines. Mocks `CmcdReporter` with a stub that
+records calls; asserts call sequences.
+
+- `RequestType` (MANIFEST, SEGMENT, LICENSE, KEY, TIMING) → `CmcdObjectType` mapping
+- `RequestContext.type` → `CmcdStreamingFormat` (DASH/LL-DASH/HLS/LL-HLS/Smooth/Other)
+- `shaka.extern.CmcdConfiguration` → `cml.cmcd.CmcdReporterConfig` translation,
+  including the experimental renames
+- Player-event listener wiring: simulate `<video>` events / player state
+  changes, assert `reporter.update(...)` called with the right partial state
+- NetworkingEngine routing: stub the reporter's `requester` callback, assert
+  it dispatches via `NetworkingEngine.request(RequestType.TIMING, ...)` and
+  translates `{status}` correctly
+- Lifecycle: construct → configure → reset → reconfigure produces a fresh reporter
+- `rtp = bitrate × rtpSafetyFactor` adapter-side computation
+- Public-API back-compat: `shaka.util.CmcdManager.StreamingFormat` enum still
+  exists with same string values
+
+### Bucket C — end-to-end smoke → lives in shaka
+
+A handful of tests that drive a real `CmcdReporter` (not a stub) through the
+adapter and assert wire output, to catch integration regressions across the
+boundary. Target ~100 lines.
+
+- One test per transmission mode (`CMCD_QUERY`, `CMCD_HEADERS`)
+- One v1 + one v2 config
+- One event-mode test that verifies a play-state change produces an
+  event-mode dispatch through NetworkingEngine
+
+### Net delta
+
+~4317 lines deleted, ~600 lines added. Test suite shrinks by ~85%. Per
+goal A: bugs in encoding output are CML's concern; bugs in
+shaka-event-translation are shaka's concern. Clear ownership boundary.
+
+## Open questions
+
+- **CmcdReporter API surface verification.** Marked items in the CML-side
+  requirements table need a precursor pass against current CML source before
+  Phase 3 starts. Any gaps fill upstream.
+- **Phase 1 byte-level output equivalence.** Phase 1 routes encoding through
+  CML and is described as behavior-preserving. This rests on CML's
+  encoders producing byte-identical output to shaka's existing
+  `serialize`/`toQuery`/`appendQueryToUri` code (key ordering, escaping,
+  formatting). If Phase 1 surfaces output differences, the PR narrative
+  changes from "no behavior change" to "intentional alignment with CML's
+  spec-conformant output," which shaka maintainers will scrutinize more
+  carefully. Verify with diff testing during Phase 1 implementation; if
+  divergences exist, document them and decide per case whether to (a)
+  accept as a spec-conformance fix, (b) work around in the adapter, or
+  (c) align CML and shaka via an upstream CML PR.
+- **Pinned CML version.** Spec assumes `@svta/cml-cmcd` v2.3.0 (current
+  latest). If a newer version ships before Phase 1 lands, pin to whatever's
+  current at port time and note in `SUMMARY.txt`.
+- **CMCD v2 spec changes.** v2 is still finalizing. Any field/event additions
+  during the migration period flow into CML first; shaka inherits via
+  next-bump.
+- **Dedicated `CMCD_EVENT_REPORT` request type.** Phase 3 uses
+  `RequestType.TIMING`. If shaka maintainers prefer a dedicated type, it can
+  be added in a follow-up PR without changing the adapter contract.
+
+## References
+
+- [shaka-player#3619](https://github.com/shaka-project/shaka-player/issues/3619) — original CMCD support issue
+- [shaka-player#8262](https://github.com/shaka-project/shaka-player/issues/8262) — TypeScript migration tracking
+- [common-media-library#40](https://github.com/streaming-video-technology-alliance/common-media-library/issues/40) — refactor shaka-player's CMCD integration to use CML
+- [hls.js#7725](https://github.com/video-dev/hls.js/pull/7725) — pattern reference (hls.js migration to CML CMCD v2)
+- [`@svta/cml-cmcd`](https://github.com/streaming-video-technology-alliance/common-media-library/tree/main/libs/cmcd) — upstream source
+- [CTA-5004 spec](https://cdn.cta.tech/cta/media/media/resources/standards/pdfs/cta-5004-final.pdf) — CMCD v1 specification
+- [CTA-5004-B draft](https://cta-wave.github.io/Resources/common-media-client-data--cta-5004-b.html) — CMCD v2 specification (in-progress)
+- [`AGENTS.md`](AGENTS.md) — shaka-player agent instructions / project conventions
+- [`third_party/closure-uri/`](third_party/closure-uri/) — vendoring precedent

From 26db780c7b198017f3d635e8d58d01b5f9e7536d Mon Sep 17 00:00:00 2001
From: Casey Occhialini <1508707+littlespex@users.noreply.github.com>
Date: Mon, 27 Apr 2026 18:18:52 -0700
Subject: [PATCH 02/64] docs(cmcd): Revise design spec with gap-fixes from
 hls.js/dash.js audit

Compared the spec against hls.js #7725 and dash.js #4816 (the two open
PRs migrating to @svta/cml-cmcd) and addressed 11 gaps:

Correctness:
- Inner-list array encoding for v2 keys (br, tb, bl, mtp, nor)
- NaN guards on bl/tb/mtp before encoding
- Distinguish reporter.update() from reporter.recordEvent()
- Add reporter.start()/stop(flush)/flush() lifecycle
- Event-mode transport is POST + body, not query/headers

Design clarifications:
- Player-state deduplication in adapter
- 'nor' becomes root-relative (intentional spec-conformance change)
- 'v=1' omitted from output
- Public re-exports: CmcdEventType, CmcdPlayerState
- Per-target eventTargets[] field shape enumeration
- Reporter chosen always-on (unified request + event mode path)

Plus: architecture diagram refresh, CML API confirmations from source,
Phase 1 reframed for the 'nor' change, Phase 3 adds demo updates.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 plans/cmcd-cml-refactor/spec.md | 258 +++++++++++++++++++++++++-------
 1 file changed, 203 insertions(+), 55 deletions(-)

diff --git a/plans/cmcd-cml-refactor/spec.md b/plans/cmcd-cml-refactor/spec.md
index 9b0638cbf5..42306af659 100644
--- a/plans/cmcd-cml-refactor/spec.md
+++ b/plans/cmcd-cml-refactor/spec.md
@@ -105,10 +105,11 @@ Three layers, each with one job:
 │   Thin shaka-specific adapter:                                 │
 │   - NetworkingEngine integration (applyRequestData /           │
 │     applyResponseData) — public method signatures unchanged    │
-│   - <video> + Player event listeners → reporter.update(...)    │
+│   - <video> + Player event listeners → reporter.update(...)   │
+│     and reporter.recordEvent(...) (with deduplication)         │
 │   - Maps shaka.extern.CmcdConfiguration → CmcdReporterConfig   │
 │   - Wires CmcdReporter's `requester` callback to               │
-│     NetworkingEngine for event-mode reports                    │
+│     NetworkingEngine for event-mode reports (POST + body)      │
 └────────────────────────────────────────────────────────────────┘
                               │
                               │ goog.require('cml.cmcd.*')
@@ -228,10 +229,20 @@ Target size: ~250 lines (down from 1704). Three responsibilities:
 ### 1. Lifecycle and player wiring
 
 - Construct `cml.cmcd.CmcdReporter` on first `configure(config)` call.
-- Tear down on `reset()`; null out the reporter; remove all event listeners.
-- Re-construct on subsequent `configure()` if config materially changed.
+  **Reporter is always-on**: even when no `eventTargets` are configured, the
+  reporter is the unified path for request-mode encoding (via
+  `createRequestReport`). When `eventTargets` are present, the same reporter
+  also batches and dispatches event-mode reports.
+- Call `reporter.start()` after construction to begin time-interval timers
+  for any configured event targets.
+- On `reset()`: call `reporter.stop(true)` (where `true` = flush pending
+  events before stopping), null out the reporter, remove all `<video>`
+  and player event listeners.
+- On `configure()` with materially-changed config: call `stop(true)` on
+  the old reporter, then construct + `start()` on a new one.
 - Subscribe to `<video>` events and `shaka.Player` events; translate state
-  changes to `reporter.update(...)` calls (see table below).
+  changes to `reporter.update(...)` and `reporter.recordEvent(...)` calls
+  (see table below).
 
 ### 2. Request/response interception
 
@@ -249,16 +260,45 @@ applyResponseData(type, response, context)
    - `bitrate` ← `segmentRef.variant.bandwidth`
    - `duration` ← `segmentRef.endTime - segmentRef.startTime`
    - `topBitrate` ← player ABR / variant constraints
-   - `rtp` ← `bitrate * config.rtpSafetyFactor` (computed in adapter, since CML's reporter doesn't know about a safety factor)
-2. Adapter calls `reporter.createRequestReport(objectType, {br, d, tb, rtp, ...})`.
-3. Reporter returns either `{headers: Record<string,string>}` or `{query: string}` depending on transmission mode.
-4. Adapter mutates `request.headers` / `request.uris[i]` in place.
+   - `rtp` ← `bitrate × config.rtpSafetyFactor` (computed in adapter; CML's
+     reporter doesn't know about a safety factor)
+2. Adapter constructs the CMCD data object, applying v2 encoding rules:
+   - **Inner-list keys** (`br`, `tb`, `bl`, `mtp`, `nor`) wrap their values
+     in single-element arrays when `version >= 2` per CMCD v2 Structured
+     Fields encoding: `data.br = [bitrate]`, `data.bl = [bufferLength]`,
+     `data.tb = [topBitrate]`, `data.mtp = [throughputKbps]`,
+     `data.nor = [nextUrl]`. For v1, these stay as scalars.
+   - **NaN guards**: `bl`, `tb`, `mtp` may be `NaN` early in playback
+     (buffer not yet established, no top variant chosen, throughput
+     estimator not seeded). Adapter checks `Number.isFinite(...)` before
+     including these keys; otherwise omits. Required to prevent Structured
+     Fields serialization errors in CML's encoder.
+3. Adapter calls `reporter.createRequestReport(request, data)`. CML returns
+   the original request augmented with applied CMCD encoding (CML signature:
+   `R & CmcdRequestReport<R['customData']>` — returns a new object derived
+   from the input, not in-place mutation).
+4. Adapter copies the CMCD-applied fields (`uris`, `headers`) from CML's
+   returned report back onto shaka's `request` object — preserving shaka's
+   existing in-place-mutation contract for `applyRequestData` callers.
+
+`v=1` field is omitted from CMCD output per spec (v1 is the default
+interpretation if `v` is absent). CML's encoders handle this internally;
+adapter does not need to filter explicitly.
+
+`nor` (next object request) URL relativization is a **deliberate
+behavioral change**: shaka's existing `urlToRelativePath` produced
+**path-relative** URLs; CML uses `url.origin` as `baseUrl` to produce
+**root-relative** URLs. This aligns shaka's output with CML's
+spec-conformant behavior. Flag this in the Phase 1 PR description as an
+intentional wire-format change (consumers parsing `nor` server-side may
+need to adjust path-resolution logic).
 
 `applyResponseData` flow:
 
 1. Adapter measures `ttfb`/`ttlb` via existing `requestTimestampMap_` mechanism.
-2. Adapter calls `reporter.recordResponseReceived(requestId, {ttfb, ttlb, rc, url})`.
-3. Reporter buffers response data for the next emission opportunity.
+2. Adapter calls `reporter.recordResponseReceived(response, {ttfb, ttlb, rc, url})`.
+3. Reporter buffers response data for the next emission opportunity (and
+   internally fires the v2 `rr` "response received" event when configured).
 
 The shaka-specific extraction helpers
 (`getObjectType_`, `getBitrate_`, `getDuration_`, `getTopBitrate_`,
@@ -296,21 +336,71 @@ The experimental flag on shaka's CMCD v2 config (see
 [`externs/shaka/player.js:2810-2818`](externs/shaka/player.js)) authorizes
 these renames. v1 fields keep their existing names.
 
+**Per-target `eventTargets[]` field shape.** Each entry in `eventTargets`
+configures one event-reporting endpoint. Shape (post-rename):
+
+| Per-target field | Type | Purpose |
+|---|---|---|
+| `url` | `string` | Endpoint URL for CMCD event reports |
+| `events` | `Array<CmcdEventType>` | Which events trigger reports (e.g., `[PLAY_STATE, ERROR, RESPONSE_RECEIVED]`); empty / undefined = none |
+| `timeInterval` | `number` *(seconds)* | Periodic time-interval reports (`0` disables; CML default per `CMCD_DEFAULT_TIME_INTERVAL`) |
+| `batchSize` | `number` | Number of events to batch before dispatch (default `1` = no batching) |
+| `includeKeys` | `Array<CmcdKey>` *(was `enabledKeys`)* | Subset of CMCD keys to include in this target's reports |
+| `version` | `1 \| 2` | Per-target version override; defaults to top-level `version` |
+
+Shaka maps to CML's `CmcdEventReportConfig` shape:
+`Omit<CmcdEventReportConfig, 'enabledKeys'> & {includeKeys?: CmcdKey[]}`,
+matching hls.js PR #7725's pattern. The adapter renames `includeKeys` →
+`enabledKeys` per-entry when constructing the reporter config.
+
+Update [`externs/shaka/player.js`](externs/shaka/player.js)
+`shaka.extern.CmcdTarget` typedef to reflect this shape; existing fields
+in the typedef (e.g., `events`, `timeInterval`) stay; renamed field is
+`enabledKeys` → `includeKeys`.
+
 ### Player state ↔ reporter state mapping
 
-All state mutation goes through `reporter.update(partialState)`:
+State mutation and event emission use **two distinct reporter methods**:
+
+- `reporter.update(partialState)` — mutates persistent state; the next
+  emitted payload reflects the change.
+- `reporter.recordEvent(eventType, data)` — emits a discrete v2 event.
 
-| shaka event/signal | reporter call |
+Many state transitions require **both**: `update()` to persist the new
+state, then `recordEvent()` to emit a v2 event noting the transition.
+
+| shaka event/signal | reporter calls |
 |---|---|
-| Buffering becomes true | `reporter.update({playerState: REBUFFERING})` |
-| Buffering becomes false | `reporter.update({playerState: PLAYING})` |
-| `setLowLatency(true)` + DASH | `reporter.update({streamingFormat: LOW_LATENCY_DASH})` |
-| `setLowLatency(true)` + HLS | `reporter.update({streamingFormat: LOW_LATENCY_HLS})` |
-| Pause | `reporter.update({playerState: PAUSED})` |
-| Content ID changes | `reporter.update({cid: newId})` |
-| Visibility change → backgrounded | `reporter.update({backgrounded: true})` |
-| Mute / unmute | `reporter.update({muted: true/false})` |
-| Throughput estimate update | `reporter.update({mtp: bandwidthKbps})` |
+| Buffering becomes true | `update({playerState: REBUFFERING})` + `recordEvent(PLAY_STATE)` |
+| Buffering becomes false | `update({playerState: PLAYING})` + `recordEvent(PLAY_STATE)` |
+| Pause | `update({playerState: PAUSED})` + `recordEvent(PLAY_STATE)` |
+| Seeking | `update({playerState: SEEKING})` + `recordEvent(PLAY_STATE)` |
+| Ended | `update({playerState: ENDED})` + `recordEvent(PLAY_STATE)` |
+| Fatal error | `update({playerState: FATAL_ERROR})` + `recordEvent(ERROR)` |
+| Variant switch (bitrate change) | `update({br: [newBitrate]})` + `recordEvent(BITRATE_CHANGE)` |
+| `setLowLatency(true)` + DASH | `update({streamingFormat: LOW_LATENCY_DASH})` |
+| `setLowLatency(true)` + HLS | `update({streamingFormat: LOW_LATENCY_HLS})` |
+| Content ID changes | `update({cid: newId})` (CML emits the v2 `c` event internally) |
+| Visibility → backgrounded | `update({backgrounded: bool})` (CML emits the v2 `b` event internally) |
+| Mute | `update({muted: true})` + `recordEvent(MUTE)` |
+| Unmute | `update({muted: false})` + `recordEvent(UNMUTE)` |
+| Throughput estimate update | `update({mtp: [bandwidthKbps]})` |
+
+**Player-state deduplication.** Adapter tracks the last-emitted
+`playerState` and skips both `update` and `recordEvent` when the new state
+matches. Without this, `<video>` event listeners can fire repeatedly on
+stable states (e.g., `playing` after every minor stall), spamming the
+reporter and downstream targets:
+
+```js
+// in CmcdManager
+setPlayerState_(state) {
+  if (this.lastPlayerState_ === state) return;
+  this.lastPlayerState_ = state;
+  this.reporter_.update({playerState: state});
+  this.reporter_.recordEvent(cml.cmcd.CmcdEventType.PLAY_STATE);
+}
+```
 
 MSD is computed internally by `CmcdReporter`; the adapter does not feed it.
 
@@ -325,30 +415,73 @@ MSD is computed internally by `CmcdReporter`; the adapter does not feed it.
 - **`externs/cmcd.js`** (`CmcdData` typedef): kept as the public-facing typedef
   shape. Internally, the adapter and vendored port use `cml.cmcd.CmcdData`.
   The two are structurally equivalent.
-- **`shaka.extern.CmcdConfiguration`** typedef: keeps `targets` field name
-  changed to `eventTargets`; `shaka.extern.CmcdTarget` typedef gets
-  `enabledKeys` → `includeKeys` rename. Both are experimental-flagged so
-  breaking change is acceptable.
+- **`shaka.extern.CmcdConfiguration`** typedef: `targets` field renamed to
+  `eventTargets`; `shaka.extern.CmcdTarget` typedef gets `enabledKeys` →
+  `includeKeys` rename. Both are experimental-flagged so breaking change
+  is acceptable.
+
+**New public re-exports for v2 configuration.** Shaka users configuring
+`eventTargets[].events` need access to the `CmcdEventType` enum (otherwise
+they'd have to hardcode magic strings like `'ps'`, `'e'`, `'rr'`). Minimum
+re-exports added to the existing `shaka.util.CmcdManager` class scope (no
+new namespace; consistent with where `StreamingFormat` already lives):
+
+| Re-exported symbol | From CML | Purpose |
+|---|---|---|
+| `shaka.util.CmcdManager.EventType` | `cml.cmcd.CmcdEventType` | Configure `eventTargets[].events` |
+| `shaka.util.CmcdManager.PlayerState` | `cml.cmcd.CmcdPlayerState` | Reading player-state field externally |
+
+Both are `@export`ed string-enum aliases of CML symbols (string values
+identical, names match). Existing
+`shaka.util.CmcdManager.StreamingFormat` stays where it is for back-compat.
+
+Other CML enums and constants (`CmcdObjectType`, `CmcdStreamType`,
+`CmcdHeaderField`, `CMCD_V1`, `CMCD_V2`, key arrays) stay internal under
+`cml.cmcd.*` until users have a documented need; shaka maintainers may
+expand the re-export surface in follow-up PRs based on user feedback. This
+is a more conservative public-API expansion than hls.js's
+`exports-named.ts` re-exports — appropriate for shaka's generally
+conservative API surface.
 
 ### Event-mode dispatch via NetworkingEngine
 
 `CmcdReporter` accepts a `requester: (req) => Promise<{status: number}>`
-config option for dispatching event-mode reports. The shaka adapter wires this
-to `NetworkingEngine` rather than raw `fetch`:
+config option for dispatching event-mode reports. **Event-mode transport is
+HTTP POST with a body** — CML constructs each event request as
+`method: 'POST'` with the encoded CMCD payload in the body (per dash.js
+PR #4816's `Constants.CMCD_MODE_BODY` precedent and CML's reporter source).
+This is distinct from request-mode encoding (which mutates an existing
+request's URL or headers); event mode emits new requests to dedicated
+event-target URLs.
+
+Shaka adapter wires `requester` to `NetworkingEngine` rather than raw `fetch`:
 
 ```js
-const requester = (cmcdReq) => {
+const requester = async (cmcdReq) => {
   const retryParams = shaka.net.NetworkingEngine.defaultRetryParameters();
   const shakaReq = shaka.net.NetworkingEngine.makeRequest(
       [cmcdReq.url], retryParams);
-  shakaReq.method = cmcdReq.method || 'GET';
+  shakaReq.method = cmcdReq.method || 'POST';
   shakaReq.headers = cmcdReq.headers || {};
-  shakaReq.body = cmcdReq.body;
-  return this.networkingEngine_
-      .request(RequestType.TIMING, shakaReq, {type: 'cmcd-event'})
-      .promise
-      .then((response) => ({status: 200}))
-      .catch((err) => ({status: err.status || 0}));
+
+  // CML may emit body as string (structured-fields) or Blob (JSON).
+  // shaka.extern.Request.body expects BufferSource; convert:
+  if (typeof cmcdReq.body === 'string') {
+    shakaReq.body = shaka.util.StringUtils.toUTF8(cmcdReq.body);
+  } else if (cmcdReq.body instanceof Blob) {
+    shakaReq.body = await cmcdReq.body.arrayBuffer();
+  } else {
+    shakaReq.body = cmcdReq.body;  // already BufferSource
+  }
+
+  try {
+    await this.networkingEngine_
+        .request(RequestType.TIMING, shakaReq, {type: 'cmcd-event'})
+        .promise;
+    return {status: 200};
+  } catch (err) {
+    return {status: err.status || 0};
+  }
 };
 ```
 
@@ -358,8 +491,9 @@ manifests and segments. **No new public config field needed** (vs. hls.js's
 `loader` field): users already control transport via NetworkingEngine plugins.
 
 `RequestType.TIMING` is the existing "non-content network operation" bucket.
-Could later become a dedicated `CMCD_EVENT_REPORT` request type if maintainers
-want one; defer that decision until needed.
+Dash.js introduced a dedicated `HTTPRequest.CMCD_EVENT` type for similar
+purposes. Shaka can later add `RequestType.CMCD_EVENT_REPORT` in a follow-up
+PR without changing the adapter contract; defer until maintainers decide.
 
 ## CML-side requirements (verify before/during Phase 3)
 
@@ -369,11 +503,13 @@ upstream in CML if missing.
 
 | Need | Status |
 |---|---|
+| `reporter.start()` / `reporter.stop(flush)` / `reporter.flush()` lifecycle | confirmed (per CML source inspection) |
 | `reporter.update(partialState)` for state mutation | confirmed |
-| `reporter.createRequestReport(objectType, data)` returning headers/query | confirmed (per hls.js PR #7725) |
-| `reporter.recordResponseReceived(requestId, {ttfb, ttlb, rc, url, ...})` | confirmed |
-| `requester` config field for event-mode dispatch | confirmed (per CML source) |
-| Built-in time-interval event timer | likely present; verify reporter owns it (shaka stops running its own) |
+| `reporter.recordEvent(eventType, data)` for discrete event emission | confirmed |
+| `reporter.createRequestReport(request, data)` for request-mode encoding | confirmed (CML signature: `R & CmcdRequestReport<R['customData']>`) |
+| `reporter.recordResponseReceived(response, data)` | confirmed |
+| `requester` config field for event-mode dispatch | confirmed (CML constructs `method: 'POST'` with body) |
+| Built-in time-interval event timer | confirmed (reporter owns; shaka stops running its own) |
 | MSD computed internally by reporter | confirmed |
 | Sequence numbers per-target | likely present; verify per v2 spec |
 
@@ -412,10 +548,13 @@ behavior-preserving except where explicitly noted.
   static methods in [`cmcd_manager.js`](lib/util/cmcd_manager.js) to delegate
   to `cml.cmcd.encodeCmcd` / `cml.cmcd.appendCmcdQuery` /
   `cml.cmcd.appendCmcdHeaders`.
-- **No behavior change.** Same wire output. State machine, sequence numbers,
-  event timing, public API all unchanged.
+- **Near-no behavior change.** State machine, sequence numbers, event
+  timing, public API all unchanged. **One known intentional wire-format
+  change**: `nor` URLs become root-relative (CML's spec-conformant
+  behavior) rather than path-relative. Document in PR description.
 - Tests in [`cmcd_manager_unit.js`](test/util/cmcd_manager_unit.js) mostly
-  unchanged — they assert wire output, which stays identical.
+  unchanged — `nor` assertions update to root-relative; other wire-output
+  assertions stay identical (verify via diff testing).
 - **Approximate diff size**: +3000 lines (vendored port), ~500 lines
   changed in `cmcd_manager.js`.
 
@@ -449,6 +588,14 @@ behavior-preserving except where explicitly noted.
 - Apply config renames in [`externs/shaka/player.js`](externs/shaka/player.js):
   - `shaka.extern.CmcdConfiguration.targets` → `eventTargets`
   - `shaka.extern.CmcdTarget.enabledKeys` → `includeKeys`
+- Add v2 re-exports: `shaka.util.CmcdManager.EventType` (alias of
+  `cml.cmcd.CmcdEventType`), `shaka.util.CmcdManager.PlayerState` (alias of
+  `cml.cmcd.CmcdPlayerState`).
+- Update [`demo/`](demo/) to add a CMCD v2 configuration UI (transmission
+  mode picker, version selector, eventTarget editor). Mirrors the
+  precedent set by dash.js's `samples/cmcd/cmcd-v2.html` and
+  `cmcd-v2-network-interceptors.html`. Lets users validate v2 config in
+  the demo without writing code.
 - Test rewrite (see Tests section): delete CMCD wire-format tests (~3000+
   lines); add ~500 lines of integration tests focused on shaka-specific
   glue. Add ~100 lines of end-to-end smoke tests.
@@ -540,16 +687,17 @@ shaka-event-translation are shaka's concern. Clear ownership boundary.
   requirements table need a precursor pass against current CML source before
   Phase 3 starts. Any gaps fill upstream.
 - **Phase 1 byte-level output equivalence.** Phase 1 routes encoding through
-  CML and is described as behavior-preserving. This rests on CML's
-  encoders producing byte-identical output to shaka's existing
-  `serialize`/`toQuery`/`appendQueryToUri` code (key ordering, escaping,
-  formatting). If Phase 1 surfaces output differences, the PR narrative
-  changes from "no behavior change" to "intentional alignment with CML's
-  spec-conformant output," which shaka maintainers will scrutinize more
-  carefully. Verify with diff testing during Phase 1 implementation; if
-  divergences exist, document them and decide per case whether to (a)
-  accept as a spec-conformance fix, (b) work around in the adapter, or
-  (c) align CML and shaka via an upstream CML PR.
+  CML and is described as behavior-preserving. **One known intentional
+  divergence**: `nor` URLs change from path-relative (shaka's
+  `urlToRelativePath`) to root-relative (CML's `url.origin` baseUrl). Other
+  potential divergences (key ordering, escaping, formatting) are unknown;
+  verify with diff testing during Phase 1 implementation. The Phase 1 PR
+  description should reframe from "no behavior change" to "alignment with
+  CML's spec-conformant output, with `nor` URL relativization as the one
+  known intentional change." If diff testing surfaces additional
+  divergences, decide per case whether to (a) accept as a spec-conformance
+  fix, (b) work around in the adapter, or (c) align CML and shaka via an
+  upstream CML PR.
 - **Pinned CML version.** Spec assumes `@svta/cml-cmcd` v2.3.0 (current
   latest). If a newer version ships before Phase 1 lands, pin to whatever's
   current at port time and note in `SUMMARY.txt`.

From 887c988cbf276fb19cfa7fe59016691a530a8684 Mon Sep 17 00:00:00 2001
From: Casey Occhialini <1508707+littlespex@users.noreply.github.com>
Date: Mon, 27 Apr 2026 19:51:45 -0700
Subject: [PATCH 03/64] docs(cmcd): add implementation plan

---
 plans/cmcd-cml-refactor/plan.md | 1260 +++++++++++++++++++++++++++++++
 1 file changed, 1260 insertions(+)
 create mode 100644 plans/cmcd-cml-refactor/plan.md

diff --git a/plans/cmcd-cml-refactor/plan.md b/plans/cmcd-cml-refactor/plan.md
new file mode 100644
index 0000000000..6d6f23d7ba
--- /dev/null
+++ b/plans/cmcd-cml-refactor/plan.md
@@ -0,0 +1,1260 @@
+# CMCD CML Refactor Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Replace shaka-player's 1700-line custom `shaka.util.CmcdManager` and ~4300 lines of CMCD wire-format tests with a vendored Closure port of `@svta/cml-cmcd` plus a thin shaka-specific adapter (~250 lines), shipped as three sequential reviewable PRs.
+
+**Architecture:** Three layers — public shaka API (back-compat preserved except experimental v2 renames) → thin shaka adapter (`lib/util/cmcd_manager.js`) → vendored CML port (`third_party/cml-cmcd/`, namespace `cml.cmcd.*`). When shaka migrates to TypeScript ([#8262](https://github.com/shaka-project/shaka-player/issues/8262)), the vendored directory deletes and `goog.require('cml.cmcd.X')` becomes `import { X } from '@svta/cml-cmcd'` — no other code changes.
+
+**Tech stack:** JavaScript with `goog.provide`/`goog.require`, JSDoc type annotations, Closure Compiler `ADVANCED_OPTIMIZATIONS`, Python build system (`build/check.py`, `build/test.py`, `build/all.py`), Karma + Jasmine for tests.
+
+**Canonical input:** [spec.md](spec.md) (~600 lines) — file lists, type translations, encoding rules, lifecycle tables, and rationale all live there. This plan sequences the work and identifies risks; it does not duplicate the spec.
+
+---
+
+## Plan structure
+
+- **Phase 0** — CML-side verification & upstream precursor PRs (no shaka commits).
+- **Phase 1** — Vendor `third_party/cml-cmcd/`, delegate encoding through it. Behavior preserved except documented `nor` change.
+- **Phase 2** — Replace shaka's duplicate constants/enums with CML's; pure dedupe.
+- **Phase 3** — Rewrite `cmcd_manager.js` as adapter around `CmcdReporter`; delete state machine; rewrite tests; update demo and externs.
+
+Each phase ships as one PR. Phases 1 and 2 are behavior-preserving (modulo the documented `nor` change); Phase 3 is the behavioral rewrite and carries the migration risk.
+
+## Spec gaps surfaced during planning
+
+The spec is mature, but these items need explicit attention during execution rather than being deferred to "we'll figure it out":
+
+1. **`setMediaElement` not in the lifecycle map.** Spec § "Lifecycle and player wiring" lists `configure`/`reset` flows but omits `setMediaElement`, which `Player` calls after constructing the manager. The adapter must subscribe to `<video>` events here, not at construction (the video element doesn't exist yet at construction time). Captured as Task 3.3.
+2. **`bl` (buffer length) appears in both persistent state and per-request data.** Spec § "State fields the adapter feeds via update()" lists `bl` and notes "per-request, may live on `createRequestReport` data". The adapter should treat `bl` as per-request only — persistent state would emit stale buffer values to event-mode targets. Captured as Task 3.4.
+3. **Per-target `version` override field.** Spec § "Per-target eventTargets[] field shape" lists a `version` per-target field. Whether CML's `CmcdEventReportConfig` exposes this needs verification (Task 0.5).
+4. **`sessionId` auto-generation path.** The existing shaka API auto-generates `sessionId` on each `load()` if the user doesn't set one. Spec says the adapter "always sets `sid` explicitly", but doesn't say where the value comes from when the user didn't supply one. Adapter must fall through to shaka's existing UUID path (`shaka.util.Functional` / `lib/polyfill/random_uuid.js`), not CML's `cml.cmcd.uuid`. Captured as Task 3.8.
+5. **`applyResponseData` mutation contract.** Spec defines the call as `reporter.recordResponseReceived(response, {ttfb, ttlb, rc, url})` but shaka's existing `applyResponseData(type, response, context)` is expected to mutate `response` in place (matching `applyRequestData`'s contract). CML's signature for `recordResponseReceived` needs verification — if it returns data, adapter must copy back like Phase 3's request flow (Task 0.4 + Task 3.5).
+6. **Always-on reporter vs. hls.js [#7725](https://github.com/video-dev/hls.js/pull/7725).** hls.js uses CML's encoders for request mode and reporter for event mode only. Our spec chose always-on reporter for a single integration boundary. **Risk**: in v1-only request-mode-only configurations, we instantiate timers and event infrastructure that the user doesn't need. Captured as Task 3.3.
+7. **`enabled: false` early-out.** Spec says "adapter no-ops when `false`", but the CmcdReporter shouldn't be constructed at all when disabled to avoid timer creation. The lifecycle code must check `enabled` before construction, not just before each `apply*` call. Captured as Task 3.3.
+8. **Demo scope for Phase 3.** Spec § Phase 3 says "Update demo/ to add a CMCD v2 configuration UI" but doesn't enumerate which controls. Pinning a minimum scope: transmission mode toggle, version selector, single eventTarget editor with URL + events checklist. More expansive UI deferred. Captured as Task 3.13.
+9. **`StreamingFormat` value parity.** Spec asserts `'d'`, `'ld'`, `'h'`, `'lh'`, `'s'`, `'o'` match CML's `CmcdStreamingFormat`. Verify before Phase 2 commits to the alias re-export (Task 0.6).
+10. **CML `CmcdEventType` enum membership.** Spec lists `ps`, `e`, `t`, `c`, `b`, `m`, `um`, `pe`, `pc`, `rr`. Verify CML covers all; any missing → upstream PR (Task 0.3).
+
+---
+
+## Phase 0: CML-side verification & upstream precursor PRs
+
+**Goal:** Lock the CML version we'll port from, and confirm/fill any gaps in `CmcdReporter`'s public surface so Phase 3 doesn't get stuck on missing CML capabilities mid-rewrite.
+
+**No shaka-player commits in this phase.** Output is (a) a pinned CML commit/tag, (b) a one-page verification report that maps spec assertions to CML source, and (c) any merged CML PRs that close gaps.
+
+### Task 0.1: Pin the CML version
+
+**Files:**
+- Note in: `plans/cmcd-cml-refactor/cml-version.md` (new — short doc, not a code file)
+
+- [ ] **Step 1: Inspect current `@svta/cml-cmcd` releases.**
+
+```bash
+npm view @svta/cml-cmcd versions --json | tail -20
+```
+
+Pick the latest stable release (spec assumes v2.3.0 as of 2026-04-27; confirm or update). Capture: tag name, commit SHA, npm version, release date.
+
+- [ ] **Step 2: Clone CML at the pinned commit into a sibling directory for reference.**
+
+```bash
+cd /tmp && git clone https://github.com/streaming-video-technology-alliance/common-media-library.git cml-pinned
+cd cml-pinned && git checkout <pinned-sha>
+```
+
+- [ ] **Step 3: Write `plans/cmcd-cml-refactor/cml-version.md`** with: pinned version, SHA, date, source path (`libs/cmcd/src/`), and one-line "what changed since v2.3.0" if applicable.
+
+**Acceptance:** Pinned version selected; reproducible checkout in a known location for the rest of Phase 0.
+
+### Task 0.2: Verify `CmcdReporter` lifecycle methods
+
+The spec's "CML-side requirements" table marks these as "confirmed":
+`reporter.start()`, `reporter.stop(flush)`, `reporter.flush()`, `reporter.update(partialState)`, `reporter.recordEvent(eventType, data)`.
+
+- [ ] **Step 1: Open `libs/cmcd/src/CmcdReporter.ts` in the pinned checkout.** Search for each method by name; confirm signatures.
+
+- [ ] **Step 2: For each method, record:** name, parameter types, return type, and any thrown-error contract. Save as a checklist in `plans/cmcd-cml-refactor/cml-version.md` (append).
+
+**Acceptance:** All five lifecycle methods exist with signatures compatible with the spec's call sites.
+
+### Task 0.3: Verify `CmcdEventType` enum membership
+
+- [ ] **Step 1: Open `libs/cmcd/src/CmcdEventType.ts` in the pinned checkout.**
+
+- [ ] **Step 2: Verify members:** `ps` (PLAY_STATE), `e` (ERROR), `t` (TIMEOUT or similar), `c` (CONTENT_ID_CHANGE), `b` (BACKGROUNDED), `m` (MUTE), `um` (UNMUTE), `pe` (PLAY_END or PLAYER_ERROR), `pc` (PLAYBACK_CHANGE), `rr` (RESPONSE_RECEIVED). Map each two-letter code to its enum constant name.
+
+- [ ] **Step 3: For any missing member, file a CML PR adding it.** Example: if `pc` is absent, file `feat(cmcd): add CmcdEventType.PLAYBACK_CHANGE` upstream.
+
+**Acceptance:** Every event type the shaka adapter intends to emit has a CML enum value, either in the pinned version or in a merged-and-released CML PR.
+
+### Task 0.4: Verify request/response report methods
+
+Spec calls these out: `createRequestReport(request, data)` and `recordResponseReceived(response, data)`.
+
+- [ ] **Step 1: Open `CmcdReporter.ts` and inspect both methods.**
+
+- [ ] **Step 2: For `createRequestReport`:** confirm the return type is `R & CmcdRequestReport<R['customData']>` (a derived object, not in-place mutation) — this drives the adapter's "copy fields back" pattern.
+
+- [ ] **Step 3: For `recordResponseReceived`:** confirm whether the method returns anything (data the adapter must copy back to the response object) or is purely a state-recording call. Document the answer.
+
+- [ ] **Step 4: Verify the data parameter shape for `recordResponseReceived` matches the spec's `{ttfb, ttlb, rc, url}`.** Note any field name mismatches (e.g., CML may use `responseCode` instead of `rc`).
+
+**Acceptance:** Adapter's response-flow contract is unambiguous — we know whether to copy data back or not.
+
+### Task 0.5: Verify `CmcdEventReportConfig` per-target shape
+
+Spec's per-target field table includes `url`, `events`, `timeInterval`, `batchSize`, `enabledKeys`, `version`.
+
+- [ ] **Step 1: Open `libs/cmcd/src/CmcdEventReportConfig.ts` (or wherever the type lives in the pinned tree).**
+
+- [ ] **Step 2: Diff field-by-field against the spec's table.** Note any missing fields, extra fields, or type mismatches.
+
+- [ ] **Step 3: Specifically confirm:** does `CmcdEventReportConfig` expose a `version` override field per target? If not, decide whether to (a) drop the per-target `version` from shaka's externs (simpler, defer to top-level only), or (b) file a CML PR to add it. Default to (a) unless there's a known shaka user need.
+
+**Acceptance:** Spec's `CmcdTarget` typedef post-rename matches a real CML type, with any field-level differences explicitly resolved.
+
+### Task 0.6: Verify `CmcdStreamingFormat` value parity
+
+- [ ] **Step 1: Open `libs/cmcd/src/CmcdStreamingFormat.ts`.**
+
+- [ ] **Step 2: Confirm string values:** `'d'` (DASH), `'ld'` (LL-DASH), `'h'` (HLS), `'lh'` (LL-HLS), `'s'` (Smooth), `'o'` (Other). These must match shaka's existing `shaka.util.CmcdManager.StreamingFormat` values exactly — Phase 2's alias re-export depends on this.
+
+- [ ] **Step 3: If any value differs**, file CML upstream to align (CML is the spec source of truth, so shaka adapts; but check spec compliance first).
+
+**Acceptance:** `cml.cmcd.CmcdStreamingFormat` and `shaka.util.CmcdManager.StreamingFormat` have identical string values.
+
+### Task 0.7: Verify sequence-number behavior
+
+Spec marks this "likely present; verify per v2 spec".
+
+- [ ] **Step 1: Search `CmcdReporter.ts` and the encoders for `sn` handling.** Determine: does the reporter own per-target sequence counters? Does it reset on `sid` change?
+
+- [ ] **Step 2: Compare to shaka's current behavior** in [`cmcd_manager.js`](../../lib/util/cmcd_manager.js) (search for `cmcdSequenceNumbers_`). If CML's behavior differs from shaka's existing behavior (e.g., per-target vs. per-mode), document the difference. This is a Phase 3 wire-format change to call out.
+
+**Acceptance:** Sequence-number behavior is documented; if it diverges from shaka's existing behavior, the divergence is in the Phase 3 PR description.
+
+### Task 0.8: Verify `requester` callback contract
+
+- [ ] **Step 1: Open `CmcdReporter.ts`; find where `config.requester` is invoked.**
+
+- [ ] **Step 2: Confirm:** the request object passed in has `{url, method, headers, body}` shape; the response promise must resolve to `{status: number}`; rejection vs. resolution-with-non-200 semantics.
+
+- [ ] **Step 3: Confirm body type.** Spec says CML emits string (structured-fields) or Blob (JSON). Verify both code paths exist; this informs the adapter's body-conversion logic in Task 3.9.
+
+**Acceptance:** Adapter's `requester` shim (Task 3.9) has a complete contract to match.
+
+### Task 0.9: Resolve any CML gaps via upstream PRs
+
+- [ ] **Step 1: Aggregate any gaps found in Tasks 0.2–0.8.**
+
+- [ ] **Step 2: For each gap, decide:** (a) work around in adapter (acceptable for small things), (b) file CML PR (preferred — single source of truth principle from spec § Motivation), or (c) drop the dependent feature from this refactor (defer to follow-up).
+
+- [ ] **Step 3: File and merge CML PRs as needed.** Pin the new CML version after release and update `cml-version.md`.
+
+- [ ] **Step 4: Re-run Tasks 0.2–0.8 against the new pinned version** if changes shipped.
+
+**Acceptance:** Every spec assertion about CML's API is either confirmed against the pinned CML version or has an actionable plan (work around / drop / wait for upstream).
+
+### Phase 0 verification gate
+
+- [ ] `plans/cmcd-cml-refactor/cml-version.md` lists the pinned CML version and a complete CML-API verification checklist.
+- [ ] All "confirmed" items in spec's CML-side requirements table are re-confirmed in writing.
+- [ ] All "verify" items are resolved.
+- [ ] No new shaka-player commits.
+
+---
+
+## Phase 1: Vendor `third_party/cml-cmcd/` and route encoding through it
+
+**Goal:** Add the vendored Closure port of `@svta/cml-cmcd`. Refactor shaka's static encoding helpers (`serialize`, `toQuery`, `appendQueryToUri`, `urlToRelativePath`) to delegate to CML's encoders. State machine, sequence numbers, event timing, and public API stay unchanged.
+
+**Behavior:** Preserved, with **one documented intentional change**: `nor` URLs become root-relative (CML's spec-conformant output) rather than path-relative. Phase 1 PR description must call this out as the one known intentional wire-format change. Diff testing during this phase surfaces any other unintentional divergences for case-by-case decisions.
+
+**Reference PRs to consult for patterns:**
+- [hls.js #7725](https://github.com/video-dev/hls.js/pull/7725) — note: their request-mode encoding uses CML encoders directly without going through `CmcdReporter`. Our Phase 3 changes that to always-on reporter; Phase 1 is closer to their request-mode pattern (encoders only).
+- [`third_party/closure-uri/`](../../third_party/closure-uri/) — vendoring layout precedent.
+
+### Task 1.1: Skeleton
+
+**Files:**
+- Create: `third_party/cml-cmcd/SUMMARY.txt`
+- Create: `third_party/cml-cmcd/LICENSE`
+- Create: `third_party/cml-cmcd/NOTICE`
+- Modify: `third_party/SUMMARY.txt` — append `cml-cmcd` entry per spec § "SUMMARY.txt format"
+
+- [ ] **Step 1: Copy CML's `LICENSE` and `NOTICE` files** from the pinned checkout into `third_party/cml-cmcd/`.
+
+- [ ] **Step 2: Write `third_party/cml-cmcd/SUMMARY.txt`** using the format from spec § "SUMMARY.txt format". Include the pinned version + SHA from `cml-version.md`.
+
+- [ ] **Step 3: Append the `cml-cmcd` block to `third_party/SUMMARY.txt`** following the existing entry style for `closure-uri` and `language-mapping-list`.
+
+- [ ] **Step 4: Commit:**
+
+```
+chore(third_party): add cml-cmcd vendoring skeleton (LICENSE, NOTICE, SUMMARY.txt)
+```
+
+**Acceptance:** `third_party/cml-cmcd/` directory exists with license metadata; `third_party/SUMMARY.txt` references it.
+
+### Task 1.2: Port type definitions (typedefs)
+
+The spec § "Subset to port" enumerates ~25 typedef files. These translate to closure `@typedef` declarations under `cml.cmcd.*`.
+
+**Files:** Create files per spec's "Type definitions" row (e.g., `third_party/cml-cmcd/cmcd.js`, `cmcd_data.js`, `cmcd_request.js`, etc.) — file names follow the snake_case convention from spec § "File naming and namespace conventions".
+
+- [ ] **Step 1: For each TS type-only file in the spec's list, port to a `.js` file** with a single `goog.provide('cml.cmcd.X')` and a JSDoc `@typedef`.
+
+  Mapping pattern for an interface like `CmcdReporterConfig`:
+  ```typescript
+  // CmcdReporterConfig.ts
+  export interface CmcdReporterConfig {
+    sid?: string;
+    cid?: string;
+    transmissionMode?: CmcdTransmissionMode;
+    // ...
+  }
+  ```
+  becomes:
+  ```javascript
+  // third_party/cml-cmcd/cmcd_reporter_config.js
+  goog.provide('cml.cmcd.CmcdReporterConfig');
+
+  /**
+   * @typedef {{
+   *   sid: (string|undefined),
+   *   cid: (string|undefined),
+   *   transmissionMode: (cml.cmcd.CmcdTransmissionMode|undefined),
+   *   ...
+   * }}
+   */
+  cml.cmcd.CmcdReporterConfig;
+  ```
+  No runtime code — just the typedef.
+
+- [ ] **Step 2: For union types (`CmcdValue`, `CmcdKey`, etc.) and `ValueOf<>` generics**, expand to closure-friendly union typedefs. `ValueOf<CmcdObjectType>` becomes the literal string union (e.g., `('m'|'a'|'v'|'av'|'i'|'c'|'tt'|'k'|'o')`).
+
+- [ ] **Step 3: Skip Phase 1 for any typedef that's only consumed by `CmcdReporter`** (which we port in Task 1.8). They're easier to add when the consumer exists.
+
+- [ ] **Step 4: Run Closure type-check via `python3 build/check.py`.** Fix any unresolved-type errors. Files don't need to be in `build/types/core` yet — that happens in Task 1.9.
+
+- [ ] **Step 5: Commit:**
+
+```
+chore(cmcd): port cml-cmcd type definitions as closure typedefs
+```
+
+**Acceptance:** All type-definition files compile; no runtime behavior change.
+
+### Task 1.3: Port enums
+
+**Files:** Create per spec's "Enums" row (e.g., `cmcd_object_type.js`, `cmcd_streaming_format.js`, `cmcd_player_state.js`, `cmcd_event_type.js`, `cmcd_reporting_mode.js`, `cmcd_transmission_mode.js`, `cmcd_header_field.js`, `cmcd_stream_type.js`).
+
+- [ ] **Step 1: For each TS string-enum file, port to a closure `@enum {string}`.**
+
+  Example pattern for CML's `as const` enum:
+  ```typescript
+  // CmcdStreamingFormat.ts
+  export const CmcdStreamingFormat = {
+    DASH: 'd',
+    LOW_LATENCY_DASH: 'ld',
+    // ...
+  } as const;
+  export type CmcdStreamingFormat = ValueOf<typeof CmcdStreamingFormat>;
+  ```
+  becomes:
+  ```javascript
+  // third_party/cml-cmcd/cmcd_streaming_format.js
+  goog.provide('cml.cmcd.CmcdStreamingFormat');
+
+  /** @enum {string} */
+  cml.cmcd.CmcdStreamingFormat = {
+    DASH: 'd',
+    LOW_LATENCY_DASH: 'ld',
+    // ...
+  };
+  ```
+
+- [ ] **Step 2: Verify enum string values** against the pinned CML source one last time before committing — typos here are silent until runtime.
+
+- [ ] **Step 3: Run `python3 build/check.py`.**
+
+- [ ] **Step 4: Commit:**
+
+```
+chore(cmcd): port cml-cmcd enums to closure @enum
+```
+
+**Acceptance:** All enum files compile; values match Task 0.6's verification.
+
+### Task 1.4: Port constants
+
+**Files:** Create per spec's "Constants" row (~16 files: `cmcd_default_time_interval.js`, `cmcd_event_keys.js`, `cmcd_formatter_map.js`, etc.).
+
+- [ ] **Step 1: For each TS constant module, port to a closure module with `goog.provide('cml.cmcd.X')` and a `const` export.**
+
+  TS pattern:
+  ```typescript
+  // CMCD_KEYS.ts
+  export const CMCD_KEYS = ['br', 'd', 'ot', /* ... */] as const;
+  ```
+  Closure pattern:
+  ```javascript
+  // third_party/cml-cmcd/cmcd_keys.js
+  goog.provide('cml.cmcd.CMCD_KEYS');
+
+  /** @const {!Array<cml.cmcd.CmcdKey>} */
+  cml.cmcd.CMCD_KEYS = ['br', 'd', 'ot', /* ... */];
+  ```
+
+- [ ] **Step 2: For `CMCD_FORMATTER_MAP` (the most complex constant — function map):** preserve function references; declare types as `!Object<string, function(...)>`. Verify Closure ADVANCED can rename the keys safely (it can, since they're string literals).
+
+- [ ] **Step 3: Run `python3 build/check.py`.** Iterate on type annotations until clean.
+
+- [ ] **Step 4: Commit:**
+
+```
+chore(cmcd): port cml-cmcd constants to closure modules
+```
+
+**Acceptance:** All constant files compile; values match upstream.
+
+### Task 1.5: Port `cml_utils.js` (uuid shim)
+
+Per spec § "@svta/cml-utils dependency handling".
+
+**Files:**
+- Create: `third_party/cml-cmcd/cml_utils.js`
+
+- [ ] **Step 1: Write the shim:**
+
+```javascript
+// third_party/cml-cmcd/cml_utils.js
+goog.provide('cml.cmcd.uuid');
+
+/**
+ * UUID shim for the vendored @svta/cml-cmcd port. The shaka adapter always
+ * sets `sid` explicitly, so this codepath should be dead at runtime — the
+ * Closure compiler will strip it. Kept for verbatim parity with upstream
+ * CmcdReporter source so per-bump diffs stay trivial.
+ *
+ * @return {string}
+ */
+cml.cmcd.uuid = function() {
+  return crypto.randomUUID();
+};
+```
+
+- [ ] **Step 2: Confirm `crypto.randomUUID()` is polyfilled** by [`lib/polyfill/random_uuid.js`](../../lib/polyfill/random_uuid.js). It is — but verify the polyfill loads before any path that calls `cml.cmcd.uuid` (it shouldn't be called at runtime per Task 3.8, but defense in depth).
+
+- [ ] **Step 3: Commit:**
+
+```
+chore(cmcd): add cml-cmcd uuid shim wrapping crypto.randomUUID
+```
+
+**Acceptance:** `cml.cmcd.uuid` exists; runs in browsers (verified post-polyfill).
+
+### Task 1.6: Port encoders
+
+**Files:** Create per spec's "Encoders" row (~12 files: `encode_cmcd.js`, `encode_prepared_cmcd.js`, `prepare_cmcd_data.js`, `to_cmcd_headers.js`, `to_cmcd_query.js`, `to_cmcd_url.js`, `to_cmcd_value.js`, `append_cmcd_headers.js`, `append_cmcd_query.js`, `to_prepared_cmcd_headers.js`, `ensure_headers.js`).
+
+- [ ] **Step 1: Port each encoder file as a closure module** with `goog.provide('cml.cmcd.encodeCmcd')` (or the appropriate name) and the function as the provided symbol.
+
+  TS pattern (top-level functional export):
+  ```typescript
+  export function encodeCmcd(data: CmcdData, options?: CmcdEncodeOptions): string { /* ... */ }
+  ```
+  Closure pattern:
+  ```javascript
+  goog.provide('cml.cmcd.encodeCmcd');
+  goog.require('cml.cmcd.CmcdData');
+  goog.require('cml.cmcd.CmcdEncodeOptions');
+  // ... other requires
+
+  /**
+   * @param {cml.cmcd.CmcdData} data
+   * @param {cml.cmcd.CmcdEncodeOptions=} options
+   * @return {string}
+   */
+  cml.cmcd.encodeCmcd = function(data, options) { /* port body */ };
+  ```
+
+- [ ] **Step 2: Translate TS-only constructs as you encounter them:**
+  - Type-only imports → drop (already declared as typedefs in Task 1.2).
+  - `as const` → not needed; const literals are inferred narrowly enough.
+  - Optional-chaining (`a?.b`) → fine in modern JS; targets are evergreen browsers.
+  - Nullish coalescing (`??`) → fine.
+  - Type guards / narrowing → expand to explicit `if (typeof x === 'string')` etc.
+  - Generic functions → drop type params; rely on JSDoc unions.
+
+- [ ] **Step 3: Preserve algorithm logic verbatim.** The whole point of the port is wire-format compliance via shared logic. Don't "improve" or rearrange — keeping a small diff to upstream means future bumps are mechanical.
+
+- [ ] **Step 4: Run `python3 build/check.py` after each batch of 3-4 files** to keep type-check feedback loops short.
+
+- [ ] **Step 5: Commit:**
+
+```
+chore(cmcd): port cml-cmcd encoders to closure
+```
+
+**Acceptance:** Every encoder file from spec's list exists, type-checks, and is structurally identical to the upstream TS modulo erased types.
+
+### Task 1.7: Port helpers (`upConvertToV2`, `resolveVersion`)
+
+**Files:**
+- Create: `third_party/cml-cmcd/up_convert_to_v2.js`
+- Create: `third_party/cml-cmcd/resolve_version.js`
+
+- [ ] **Step 1: Port both helpers** following the same pattern as encoders (Task 1.6).
+
+- [ ] **Step 2: Run `python3 build/check.py`.**
+
+- [ ] **Step 3: Commit:**
+
+```
+chore(cmcd): port cml-cmcd version-resolution helpers
+```
+
+**Acceptance:** Both helpers compile.
+
+### Task 1.8: Port `CmcdReporter`
+
+**Files:**
+- Create: `third_party/cml-cmcd/cmcd_reporter.js`
+
+This is the largest single file (the reporter class itself). Even though Phase 1 doesn't *use* `CmcdReporter` (Phase 3 does), porting it now means Phase 3 only has to write the adapter.
+
+- [ ] **Step 1: Port the class verbatim** from `libs/cmcd/src/CmcdReporter.ts`.
+  - `goog.provide('cml.cmcd.CmcdReporter')`.
+  - `goog.require` all needed encoders, helpers, and typedefs.
+  - Class methods preserve TS signatures translated to JSDoc.
+
+- [ ] **Step 2: Cml-utils dependency erasure.** TS source imports `uuid()` from `@svta/cml-utils`. Replace with `goog.require('cml.cmcd.uuid')` and `cml.cmcd.uuid()` calls. (Per spec, the adapter always supplies `sid`, so this codepath is dead — but keep it for upstream-diff parity.)
+
+- [ ] **Step 3: Type-only `HttpRequest`/`HttpResponse` imports erase.** Replace with local typedefs declared in Task 1.2 if needed, or with the `cml.cmcd.CmcdRequest`/`CmcdResponse` typedefs.
+
+- [ ] **Step 4: Run `python3 build/check.py`.** Expect to iterate on Closure-strict type errors here; the reporter is the most complex single file.
+
+- [ ] **Step 5: Commit:**
+
+```
+chore(cmcd): port cml-cmcd CmcdReporter to closure
+```
+
+**Acceptance:** `cml.cmcd.CmcdReporter` compiles. Not yet wired to anything.
+
+### Task 1.9: Build integration
+
+**Files:**
+- Modify: `build/types/core` — add `+../../third_party/cml-cmcd/*.js` entries (one per ported file)
+- Modify: `shaka-player.uncompiled.js` — only if any vendored file is self-registering; almost certainly none are, since the port is pure library code.
+- Modify: `project-words.txt` — add CMCD vocabulary that fails the spell-checker
+
+- [ ] **Step 1: Append vendored file paths to `build/types/core`** alphabetically among the existing `third_party/` entries (currently `closure-uri/uri.js`, `closure-uri/utils.js`, `language-mapping-list/language-mapping-list.js`). Insert the `cml-cmcd/*.js` entries in order.
+
+- [ ] **Step 2: Run `python3 build/check.py`.** This is the first check that builds with the vendored port included in the bundle. Closure may flag unused symbols, missing requires, or type drift.
+
+- [ ] **Step 3: Run `python3 build/build.py`.** Confirm the bundle compiles with the vendored port inside.
+
+- [ ] **Step 4: Append spell-checker vocab to `project-words.txt`.** New CMCD-only words: `Cmcd` (likely already present), `cml`, `svta`, `mtp`, `nrr`, `cmsd`, `cmsds`, `cmsdd`, `ttfb`, `ttlb`, `ld`, `lh`, `ps`, `bg`, `pe`, `pc`, `rr`, `um`, `sta`, ... Run `python3 build/check.py` to see which are missing; add only those.
+
+- [ ] **Step 5: Commit:**
+
+```
+build(cmcd): wire third_party/cml-cmcd into the core build variant
+```
+
+**Acceptance:** `build/all.py` succeeds with the vendored port included; spell-checker passes.
+
+### Task 1.10: Refactor shaka encoders to delegate
+
+**Files:**
+- Modify: `lib/util/cmcd_manager.js` — replace static methods `serialize`, `toQuery`, `appendQueryToUri`, `urlToRelativePath` with delegations to CML
+
+Per spec § Phase 1.
+
+- [ ] **Step 1: Identify the static methods.** Grep:
+  ```bash
+  grep -n "static serialize\|static toQuery\|static appendQueryToUri\|static urlToRelativePath" lib/util/cmcd_manager.js
+  ```
+
+- [ ] **Step 2: Replace each method body with a call to the CML equivalent.**
+  - `serialize(data)` → `cml.cmcd.encodeCmcd(data)` (or whichever encoder produces the same shape).
+  - `toQuery(data)` → `cml.cmcd.toCmcdQuery(data)`.
+  - `appendQueryToUri(uri, query)` → `cml.cmcd.appendCmcdQuery(uri, query)` (verify signature; may need an adapter function).
+  - `urlToRelativePath(url, base)` → drop entirely; CML's `appendCmcdQuery` and `prepareCmcdData` handle `nor` URL relativization internally using `url.origin` as `baseUrl`. **Wire-format change**: produces root-relative URLs instead of path-relative.
+
+- [ ] **Step 3: Add `goog.require('cml.cmcd.encodeCmcd')` etc.** to the file's `goog.require` block.
+
+- [ ] **Step 4: Run `python3 build/check.py`.** Fix any type or import errors.
+
+**Acceptance:** All four static methods now delegate. Manager file is shorter by the deleted method bodies.
+
+### Task 1.11: Diff testing — capture baseline
+
+Before changing test assertions, capture what the current (pre-delegation) wire output looks like for representative scenarios. The baseline is what we compare against after delegation.
+
+**Files:**
+- Create: `plans/cmcd-cml-refactor/diff-test-baseline.json` (temporary, deleted before Phase 1 ships)
+
+- [ ] **Step 1: Stash Task 1.10's changes** so the manager is back to pre-delegation behavior.
+
+```bash
+git stash
+```
+
+- [ ] **Step 2: Run the existing unit tests with output capture.** Add a test-only dump that serializes every wire output produced during the suite to JSON: keyed by test name, value `{query, headers, nor}`. Run the suite, write `diff-test-baseline.json`.
+
+- [ ] **Step 3: Restore Task 1.10's changes:**
+
+```bash
+git stash pop
+```
+
+- [ ] **Step 4: Run the suite again** with the same dumping logic; produce `diff-test-after.json`.
+
+- [ ] **Step 5: Diff the two JSON files.**
+
+```bash
+diff -u plans/cmcd-cml-refactor/diff-test-baseline.json plans/cmcd-cml-refactor/diff-test-after.json
+```
+
+- [ ] **Step 6: For each diff, classify:**
+  - **`nor` URLs path → root-relative** — expected per spec; document in PR description.
+  - **Key ordering differences** — if CML emits keys in a different sorted order, accept (it's spec-conformant) and update assertions.
+  - **Escaping differences** — if CML escapes string values differently (spec § Structured Fields), accept and update assertions.
+  - **Numeric formatting** (rounding, integer vs. float) — investigate; one of CML or shaka is likely off-spec. Decide per case: align via CML upstream PR or accept as a fix.
+  - **Missing or extra keys** — investigate; this is a state-machine vs. encoder boundary issue. Likely something in the manager still does its own filtering.
+  - **`v=1` field present when v=1** — spec calls out CML omits `v` for v=1. If shaka's tests expected `v=1` present, that's a wire-format alignment.
+
+- [ ] **Step 7: Catalog all classified diffs** in `plans/cmcd-cml-refactor/diff-test-classification.md` (also temporary; eventually summarized in PR description).
+
+**Acceptance:** Every encoding-output diff between pre-delegation and post-delegation is classified as: (a) intentional alignment with CML, (b) acceptable spec-conformance fix, or (c) bug to fix before shipping Phase 1.
+
+### Task 1.12: Update test assertions for accepted divergences
+
+**Files:**
+- Modify: `test/util/cmcd_manager_unit.js` — update `nor` assertions to root-relative, update other assertions per Task 1.11 classifications.
+
+- [ ] **Step 1: Update `nor` URL assertions.** Search:
+  ```bash
+  grep -n "nor.*=" test/util/cmcd_manager_unit.js
+  ```
+  Convert path-relative expected values to root-relative.
+
+- [ ] **Step 2: Apply each Task 1.11 (a)/(b) classification** to its corresponding assertion(s).
+
+- [ ] **Step 3: For (c) classifications** (bugs), open separate sub-tasks: fix in CML upstream if it's a CML bug, or fix in the adapter's pre-encoding step if it's a shaka-specific data-shaping issue. **Do not ship Phase 1 with unresolved (c)-classified diffs.**
+
+- [ ] **Step 4: Run `python3 build/test.py`.** All tests must pass.
+
+- [ ] **Step 5: Delete temporary diff-test files:**
+  ```bash
+  rm plans/cmcd-cml-refactor/diff-test-baseline.json
+  rm plans/cmcd-cml-refactor/diff-test-after.json
+  rm plans/cmcd-cml-refactor/diff-test-classification.md
+  ```
+  But preserve a one-paragraph summary of accepted changes for the PR description.
+
+**Acceptance:** Test suite passes; intentional wire-format changes are documented; no unresolved bugs.
+
+### Task 1.13: Demo smoke test
+
+- [ ] **Step 1: Run `python3 build/all.py`** to produce the full bundle including demo.
+
+- [ ] **Step 2: Serve the demo locally** (per shaka's standard demo serve instructions in `demo/`).
+
+- [ ] **Step 3: Configure CMCD enabled** with both query and header transmission modes; load a test stream; verify CMCD data appears in network requests as expected (use browser DevTools network tab, look for `CMCD-Request` headers or `?CMCD=` query strings).
+
+- [ ] **Step 4: Compare to the same flow on `main` branch** if any visual irregularity. The wire output should match expected post-delegation behavior (root-relative `nor`, etc.).
+
+**Acceptance:** Demo plays content with CMCD enabled in both transmission modes; no JS errors in console.
+
+### Task 1.14: Phase 1 PR
+
+**Files:**
+- Modify: `MEMORY.md` (this plan, not project memory) — mark Phase 1 done
+
+- [ ] **Step 1: Stage all Phase 1 commits.** Verify the diff totals approximately match spec § Phase 1 (~3000 lines added in `third_party/cml-cmcd/`, ~500 changed in `cmcd_manager.js`).
+
+- [ ] **Step 2: Open PR with title:**
+  ```
+  refactor(cmcd): vendor @svta/cml-cmcd, delegate encoding to CML (1/3)
+  ```
+
+- [ ] **Step 3: PR description includes:**
+  - Overview: "Phase 1 of 3 in the CMCD CML refactor (see [spec.md](plans/cmcd-cml-refactor/spec.md))."
+  - What's vendored (link to spec § "The vendored port").
+  - **Wire-format changes**: enumerate the accepted divergences from Task 1.11 classifications, headlining `nor` URL relativization.
+  - Behavior preserved otherwise: state machine, sequence numbers, event timing, public API.
+  - Pinned CML version + SHA from `cml-version.md`.
+  - Build/test verification: paste output of `python3 build/check.py` and `python3 build/test.py`.
+
+- [ ] **Step 4: Wait for review; address feedback; merge.**
+
+**Acceptance:** PR merged; main branch builds, tests pass, demo works.
+
+### Phase 1 verification gate
+
+- [ ] `python3 build/check.py` passes.
+- [ ] `python3 build/test.py` passes.
+- [ ] `python3 build/all.py` passes (bundle, docs).
+- [ ] Demo loads and plays content with CMCD enabled in both query and header modes.
+- [ ] Wire-format diff classifications resolved (no class (c) remainders).
+- [ ] Phase 1 PR merged.
+
+---
+
+## Phase 2: Adopt CML's constants/enums; delete shaka's duplicates
+
+**Goal:** Replace shaka's internal `shaka.util.CmcdManager.{ObjectType, Version, StreamType, CmcdKeys, CmcdV2Constants, CmcdV2Keys, CmcdMode}` with `cml.cmcd.*` equivalents. Re-export `shaka.util.CmcdManager.StreamingFormat` as an alias of `cml.cmcd.CmcdStreamingFormat` to preserve the only `@export`ed enum.
+
+**Behavior:** Pure dedupe. No behavioral change. ~150 lines deleted from the manager.
+
+### Task 2.1: Map shaka constants to CML equivalents
+
+- [ ] **Step 1: For each shaka constant/enum, identify its CML twin.**
+
+  | Shaka | CML |
+  |---|---|
+  | `shaka.util.CmcdManager.ObjectType` | `cml.cmcd.CmcdObjectType` |
+  | `shaka.util.CmcdManager.Version` | `cml.cmcd.CmcdVersion` (numeric `1`/`2`) |
+  | `shaka.util.CmcdManager.StreamType` | `cml.cmcd.CmcdStreamType` |
+  | `shaka.util.CmcdManager.CmcdKeys` | `cml.cmcd.CMCD_KEYS` (or split: `CMCD_REQUEST_KEYS`, `CMCD_RESPONSE_KEYS`, etc.) |
+  | `shaka.util.CmcdManager.CmcdV2Constants` | scattered across `cml.cmcd.CMCD_V2`, `CMCD_V2_KEYS`, etc. |
+  | `shaka.util.CmcdManager.CmcdV2Keys` | `cml.cmcd.CMCD_V2_KEYS` (verify exact name) |
+  | `shaka.util.CmcdManager.CmcdMode` | `cml.cmcd.CmcdReportingMode` |
+
+- [ ] **Step 2: Verify every value matches.** For each shaka constant, dump its values; compare to CML's. Any mismatch is a Phase 2 blocker.
+
+- [ ] **Step 3: Document mappings** (one line each) inline in the cmcd_manager.js commit, or in a brief `plans/cmcd-cml-refactor/phase2-mapping.md`.
+
+**Acceptance:** Every shaka constant has a confirmed CML equivalent with matching values.
+
+### Task 2.2: Replace internal references
+
+**Files:**
+- Modify: `lib/util/cmcd_manager.js` — rewrite each `shaka.util.CmcdManager.X` reference to `cml.cmcd.Y`
+
+- [ ] **Step 1: Add `goog.require` lines** for each CML symbol used.
+
+- [ ] **Step 2: Use a search-and-replace approach.** For each mapping in Task 2.1, find all references:
+  ```bash
+  grep -n "shaka\.util\.CmcdManager\.ObjectType" lib/util/cmcd_manager.js
+  ```
+  And replace with the CML name.
+
+- [ ] **Step 3: Run `python3 build/check.py`** after each constant migration to catch broken references.
+
+**Acceptance:** No internal references to the soon-to-be-deleted shaka constants remain.
+
+### Task 2.3: Re-export `StreamingFormat`
+
+**Files:**
+- Modify: `lib/util/cmcd_manager.js` — add the alias
+
+- [ ] **Step 1: Add the re-export:**
+
+```javascript
+/**
+ * @enum {string}
+ * @export
+ */
+shaka.util.CmcdManager.StreamingFormat = cml.cmcd.CmcdStreamingFormat;
+```
+
+- [ ] **Step 2: Verify the `@export` annotation is preserved.** Closure ADVANCED depends on this exactly — any drift renames the public symbol.
+
+- [ ] **Step 3: Run `python3 build/check.py`.** If Closure flags this as needing a different alias pattern (e.g., per-key copy), use the pattern that preserves both the `@export` and the value identity.
+
+**Acceptance:** `shaka.util.CmcdManager.StreamingFormat` is a CML alias; values identical; export preserved.
+
+### Task 2.4: Delete duplicate definitions
+
+**Files:**
+- Modify: `lib/util/cmcd_manager.js` — delete the now-unused constant definitions
+
+- [ ] **Step 1: Delete `shaka.util.CmcdManager.ObjectType`, `Version`, `StreamType`, `CmcdKeys`, `CmcdV2Constants`, `CmcdV2Keys`, `CmcdMode`.** Keep `StreamingFormat` (the alias).
+
+- [ ] **Step 2: Run `python3 build/check.py`.** Closure must complain if anything still references a deleted symbol.
+
+- [ ] **Step 3: Run `python3 build/test.py`.** Tests must still pass — they use the manager's public surface, which doesn't expose these internals.
+
+**Acceptance:** Manager file shrinks by ~150 lines; check + tests pass.
+
+### Task 2.5: Demo smoke test
+
+- [ ] **Step 1: Run `python3 build/all.py`.** Same as Task 1.13.
+- [ ] **Step 2: Verify demo with CMCD enabled.** Same as Task 1.13.
+
+**Acceptance:** Demo works.
+
+### Task 2.6: Phase 2 PR
+
+- [ ] **Step 1: Open PR with title:**
+  ```
+  refactor(cmcd): adopt CML constants/enums, delete shaka duplicates (2/3)
+  ```
+
+- [ ] **Step 2: PR description includes:**
+  - Overview: "Phase 2 of 3 in the CMCD CML refactor."
+  - List of constants migrated (link to Task 2.1 mapping table).
+  - Public-API note: `shaka.util.CmcdManager.StreamingFormat` re-exported as alias; values unchanged.
+  - Behavior: no change.
+  - Build/test verification.
+
+- [ ] **Step 3: Merge.**
+
+**Acceptance:** Phase 2 PR merged.
+
+### Phase 2 verification gate
+
+- [ ] `python3 build/check.py` passes.
+- [ ] `python3 build/test.py` passes.
+- [ ] `python3 build/all.py` passes.
+- [ ] Demo works with CMCD enabled.
+- [ ] Phase 2 PR merged.
+
+---
+
+## Phase 3: Replace state machine with `CmcdReporter`
+
+**Goal:** Rewrite [`lib/util/cmcd_manager.js`](../../lib/util/cmcd_manager.js) as a thin adapter (~250 lines) that delegates state, encoding, and event timing to `cml.cmcd.CmcdReporter`. Apply experimental v2 config renames. Delete CMCD wire-format tests; add adapter glue + smoke tests.
+
+**Behavior:** Behavior shifts — this is the high-risk PR. Watch for: state-transition timing differences (CML vs. shaka's existing transitions), per-target sequence-number behavior (Task 0.7), event-mode dispatch shape.
+
+### Task 3.1: Re-verify CML-side requirements
+
+CML may have evolved between Phase 0 and Phase 3 if Phases 1+2 took weeks.
+
+- [ ] **Step 1: Re-run Tasks 0.2–0.8** against the currently pinned CML version (which may need a bump if upstream landed relevant changes).
+
+- [ ] **Step 2: If a bump is warranted**, update the vendored port and re-validate Phase 1 + Phase 2. (This is unusual but possible.)
+
+- [ ] **Step 3: Update `plans/cmcd-cml-refactor/cml-version.md`** with current pinned version and verification status.
+
+**Acceptance:** CML-side requirements all confirmed at the version we'll ship Phase 3 against.
+
+### Task 3.2: Sketch adapter file structure
+
+Before writing code, plan the adapter's internal layout. The spec already gives the broad shape; this task fixes the file structure.
+
+- [ ] **Step 1: Decide whether to keep all adapter logic in one file or split.** Recommend: keep in `lib/util/cmcd_manager.js` (shaka convention; the adapter is small enough). Don't pre-emptively split into `cmcd_adapter.js` + `cmcd_state.js` — that's premature.
+
+- [ ] **Step 2: Outline the file as a comment block at the top of the new manager:**
+
+```
+// Adapter responsibilities:
+//   1. Lifecycle: construct/start/stop CmcdReporter from configure() and reset()
+//   2. Player wiring: <video> + Player events → reporter.update + recordEvent
+//   3. Request mode: applyRequestData → reporter.createRequestReport
+//   4. Response mode: applyResponseData → reporter.recordResponseReceived
+//   5. Event mode: requester callback → NetworkingEngine.request
+//   6. Config translation: shaka.extern.CmcdConfiguration → CmcdReporterConfig
+//   7. Public-API back-compat: re-exports for StreamingFormat, EventType, PlayerState
+```
+
+- [ ] **Step 3: Identify which existing methods stay vs. go.** Keep: `setMediaElement`, `configure`, `reset`, `applyRequestData`, `applyResponseData`. Delete: all `applyRequest_`/`applyManifestData`/`applyManifestRequest_`/`getObjectType_` (kept) / `getBitrate_` (kept) / `getDuration_` (kept) / encoder helpers (gone after Phase 1, but verify) / event timer code / sequence-number tracking / MSD computation.
+
+**Acceptance:** Clear picture of what gets written, what gets kept, what gets deleted.
+
+### Task 3.3: Lifecycle wiring
+
+**Files:**
+- Modify: `lib/util/cmcd_manager.js`
+
+The lifecycle is the foundation; all other tasks depend on the reporter being constructed correctly.
+
+- [ ] **Step 1: Write the constructor** to store the player and config but NOT construct the reporter yet. The reporter needs `setMediaElement` to have been called and `enabled: true` to be set.
+
+- [ ] **Step 2: Write `setMediaElement(mediaElement)`:**
+  - Save `this.video_ = mediaElement`.
+  - If `this.config_.enabled` and reporter not yet constructed, construct it now via `this.maybeStartReporter_()`.
+  - Subscribe to `<video>` events (per spec's lifecycle table).
+
+- [ ] **Step 3: Write `configure(newConfig)`:**
+  - If `enabled: false → enabled: true`: construct reporter via `maybeStartReporter_`.
+  - If `enabled: true → enabled: false`: call `this.reporter_.stop(true)`; null out `this.reporter_`; remove event listeners.
+  - If `enabled: true → enabled: true` and material change (sessionId, contentId, version, transmissionMode, eventTargets): tear down + reconstruct (spec § "On configure() with materially-changed config").
+  - If only `includeKeys` changed: `this.reporter_.update(...)` may be enough — verify against CML.
+
+- [ ] **Step 4: Write `reset()`:**
+  - If reporter exists: `this.reporter_.stop(true)`; null out.
+  - Remove all event listeners (existing `eventManager_.removeAll()`).
+
+- [ ] **Step 5: Write `maybeStartReporter_()`:**
+  - Only if `this.config_.enabled` AND `this.video_` (need media element for state).
+  - Build `CmcdReporterConfig` via `toReporterConfig_(this.config_)` (Task 3.8).
+  - Construct: `this.reporter_ = new cml.cmcd.CmcdReporter(reporterConfig)`.
+  - Call `this.reporter_.start()`.
+
+- [ ] **Step 6: Implement `enabled: false` short-circuit** in `applyRequestData` and `applyResponseData` — both early-return if `!this.reporter_`.
+
+- [ ] **Step 7: Run `python3 build/check.py`.**
+
+**Acceptance:** Lifecycle compiles. No tests yet — Task 3.13 adds them.
+
+### Task 3.4: `applyRequestData` rewrite
+
+**Files:**
+- Modify: `lib/util/cmcd_manager.js`
+
+- [ ] **Step 1: Reimplement `applyRequestData(type, request, context)`:**
+  - Early-return if `!this.reporter_` (disabled).
+  - Extract shaka-specific fields via existing helpers: `getObjectType_(type, context)`, `getBitrate_(context.segmentRef)`, `getDuration_(context.segmentRef)`, `getTopBitrate_(context.segmentRef)`, `getStreamFormat_(context.type)`. Keep these helpers — they encode shaka knowledge.
+  - Build the per-request `CmcdData` object:
+    ```javascript
+    const data = {};
+    if (objectType) data.ot = objectType;
+    if (Number.isFinite(bitrate)) {
+      data.br = (this.config_.version >= 2) ? [bitrate] : bitrate;
+    }
+    if (Number.isFinite(topBitrate)) {
+      data.tb = (this.config_.version >= 2) ? [topBitrate] : topBitrate;
+    }
+    if (Number.isFinite(bufferLength)) {
+      data.bl = (this.config_.version >= 2) ? [bufferLength] : bufferLength;
+    }
+    if (Number.isFinite(throughputKbps)) {
+      data.mtp = (this.config_.version >= 2) ? [throughputKbps] : throughputKbps;
+    }
+    if (nextUrl) {
+      data.nor = (this.config_.version >= 2) ? [nextUrl] : nextUrl;
+    }
+    if (Number.isFinite(duration)) data.d = duration;
+    if (Number.isFinite(rtp)) data.rtp = rtp;  // bitrate * rtpSafetyFactor, computed adapter-side
+    ```
+  - Call `const cmldRequest = this.reporter_.createRequestReport(request, data);`.
+  - Copy the CMCD-applied fields back onto the input request:
+    ```javascript
+    if (cmldRequest.uris) request.uris = cmldRequest.uris;
+    if (cmldRequest.headers) Object.assign(request.headers, cmldRequest.headers);
+    ```
+
+- [ ] **Step 2: Resolve spec gap #2 (`bl` placement).** Treat `bl` strictly as per-request data here — never pass `bl` to `reporter.update()`. The spec's persistent-state table mentioning `bl` is misleading; the comment "may live on createRequestReport data" is the operative model.
+
+- [ ] **Step 3: Run `python3 build/check.py`.**
+
+**Acceptance:** `applyRequestData` compiles; mutates the request object; uses CML reporter for encoding.
+
+### Task 3.5: `applyResponseData` rewrite
+
+**Files:**
+- Modify: `lib/util/cmcd_manager.js`
+
+- [ ] **Step 1: Reimplement `applyResponseData(type, response, context)`:**
+  - Early-return if `!this.reporter_`.
+  - Compute `ttfb`/`ttlb` from existing `requestTimestampMap_` mechanism (keep this; it's shaka knowledge).
+  - Extract `rc` (response code) and `url` from response.
+  - Call `this.reporter_.recordResponseReceived(response, {ttfb, ttlb, rc, url})`.
+
+- [ ] **Step 2: Apply Task 0.4's findings.** If `recordResponseReceived` returns data the adapter should propagate, copy it back to `response`. If it's a fire-and-forget call, don't.
+
+- [ ] **Step 3: Run `python3 build/check.py`.**
+
+**Acceptance:** `applyResponseData` compiles; preserves shaka's existing in-place mutation contract.
+
+### Task 3.6: Player event listeners
+
+**Files:**
+- Modify: `lib/util/cmcd_manager.js`
+
+Per spec § "Player state ↔ reporter state mapping" table.
+
+- [ ] **Step 1: Subscribe to `<video>` events** in `setMediaElement` (already partially set up by Task 3.3). For each event, translate to reporter calls per the spec's table. Examples:
+
+```javascript
+this.eventManager_.listen(this.video_, 'pause', () => {
+  this.setPlayerState_(cml.cmcd.CmcdPlayerState.PAUSED);
+});
+this.eventManager_.listen(this.video_, 'seeking', () => {
+  this.setPlayerState_(cml.cmcd.CmcdPlayerState.SEEKING);
+});
+this.eventManager_.listen(this.video_, 'ended', () => {
+  this.setPlayerState_(cml.cmcd.CmcdPlayerState.ENDED);
+});
+// ... volumechange → muted/unmuted, visibilitychange → backgrounded
+```
+
+- [ ] **Step 2: Subscribe to `shaka.Player` events** for buffering, variant changes, fatal errors:
+
+```javascript
+this.eventManager_.listen(this.player_, 'buffering', (e) => {
+  if (e.buffering) {
+    this.setPlayerState_(cml.cmcd.CmcdPlayerState.REBUFFERING);
+  } else {
+    this.setPlayerState_(cml.cmcd.CmcdPlayerState.PLAYING);
+  }
+});
+this.eventManager_.listen(this.player_, 'adaptation', () => {
+  const variant = this.player_.getVariantTracks().find((t) => t.active);
+  if (variant) {
+    this.reporter_.update({br: [variant.bandwidth]});
+    this.reporter_.recordEvent(cml.cmcd.CmcdEventType.BITRATE_CHANGE);
+  }
+});
+this.eventManager_.listen(this.player_, 'error', () => {
+  this.setPlayerState_(cml.cmcd.CmcdPlayerState.FATAL_ERROR);
+  this.reporter_.recordEvent(cml.cmcd.CmcdEventType.ERROR);
+});
+```
+
+- [ ] **Step 3: Implement throughput-update wiring.** Whatever shaka's existing throughput-change signal is (likely `shaka.abr.EwmaBandwidthEstimator` updates flowing through `shaka.Player`), feed `mtp` into `reporter.update(...)` as it changes.
+
+- [ ] **Step 4: Implement low-latency streamingFormat update** in response to `setLowLatency` calls + manifest type. Spec table covers this.
+
+- [ ] **Step 5: Run `python3 build/check.py`.**
+
+**Acceptance:** All player/video events from spec's table have a listener that calls the right reporter method.
+
+### Task 3.7: Player-state deduplication
+
+**Files:**
+- Modify: `lib/util/cmcd_manager.js`
+
+Per spec § "Player-state deduplication".
+
+- [ ] **Step 1: Implement `setPlayerState_(state)`:**
+
+```javascript
+setPlayerState_(state) {
+  if (this.lastPlayerState_ === state) return;
+  this.lastPlayerState_ = state;
+  this.reporter_.update({playerState: state});
+  this.reporter_.recordEvent(cml.cmcd.CmcdEventType.PLAY_STATE);
+}
+```
+
+- [ ] **Step 2: Initialize `this.lastPlayerState_ = null`** in the constructor.
+
+- [ ] **Step 3: Reset `this.lastPlayerState_`** in `reset()` so a re-load doesn't suppress the first `PLAYING` event.
+
+- [ ] **Step 4: Apply this dedup pattern only to `playerState`.** Other reporter.update fields (`mtp`, `cid`, `backgrounded`, `muted`) don't need dedup at this layer — either CML deduplicates internally, or the underlying signals are already deduplicated.
+
+- [ ] **Step 5: Run `python3 build/check.py`.**
+
+**Acceptance:** Player-state transitions don't emit duplicate `ps` events.
+
+### Task 3.8: Configuration translation (`toReporterConfig_`)
+
+**Files:**
+- Modify: `lib/util/cmcd_manager.js`
+
+Per spec § "3. Configuration translation".
+
+- [ ] **Step 1: Implement `toReporterConfig_(shakaCmcdConfig)`:**
+
+```javascript
+toReporterConfig_(cfg) {
+  const reporterConfig = {
+    sid: cfg.sessionId || this.generateSessionId_(),
+    cid: cfg.contentId,
+    transmissionMode: cfg.useHeaders
+        ? cml.cmcd.CmcdTransmissionMode.CMCD_HEADERS
+        : cml.cmcd.CmcdTransmissionMode.CMCD_QUERY,
+    enabledKeys: cfg.includeKeys,
+    version: cfg.version === 2
+        ? cml.cmcd.CMCD_V2
+        : cml.cmcd.CMCD_V1,
+    requester: this.makeRequester_(),
+  };
+  if (cfg.eventTargets && cfg.eventTargets.length) {
+    reporterConfig.eventTargets = cfg.eventTargets.map((target) => ({
+      url: target.url,
+      events: target.events,
+      timeInterval: target.timeInterval,
+      batchSize: target.batchSize,
+      enabledKeys: target.includeKeys,    // rename: includeKeys (shaka) → enabledKeys (CML)
+      version: target.version,            // only if CML supports per-target version (Task 0.5)
+    }));
+  }
+  return reporterConfig;
+}
+```
+
+- [ ] **Step 2: Resolve spec gap #4 (`sessionId` auto-generation).** Implement `generateSessionId_()`:
+
+```javascript
+generateSessionId_() {
+  // Existing shaka pattern; check what cmcd_manager.js currently does on
+  // the load() path to auto-generate sessionId, and preserve that exact
+  // codepath here. Probably crypto.randomUUID() (already polyfilled).
+  return crypto.randomUUID();
+}
+```
+
+  This means `cml.cmcd.uuid` (the shim from Task 1.5) is genuinely dead code at runtime — the adapter always supplies `sid`.
+
+- [ ] **Step 3: Apply Task 0.5 outcome to per-target `version`.** If CML doesn't expose per-target version, drop that line from the `map(...)` body and document the limitation in the externs (Task 3.11).
+
+- [ ] **Step 4: Run `python3 build/check.py`.**
+
+**Acceptance:** `toReporterConfig_` produces a valid `CmcdReporterConfig`; field renames applied per spec.
+
+### Task 3.9: `requester` callback wiring
+
+**Files:**
+- Modify: `lib/util/cmcd_manager.js`
+
+Per spec § "Event-mode dispatch via NetworkingEngine".
+
+- [ ] **Step 1: Implement `makeRequester_()`** (exact code from spec § "Event-mode dispatch via NetworkingEngine"):
+
+```javascript
+makeRequester_() {
+  const RequestType = shaka.net.NetworkingEngine.RequestType;
+  return async (cmcdReq) => {
+    const retryParams = shaka.net.NetworkingEngine.defaultRetryParameters();
+    const shakaReq = shaka.net.NetworkingEngine.makeRequest(
+        [cmcdReq.url], retryParams);
+    shakaReq.method = cmcdReq.method || 'POST';
+    shakaReq.headers = cmcdReq.headers || {};
+
+    // CML may emit body as string (structured-fields) or Blob (JSON).
+    if (typeof cmcdReq.body === 'string') {
+      shakaReq.body = shaka.util.StringUtils.toUTF8(cmcdReq.body);
+    } else if (cmcdReq.body instanceof Blob) {
+      shakaReq.body = await cmcdReq.body.arrayBuffer();
+    } else {
+      shakaReq.body = cmcdReq.body;  // already BufferSource
+    }
+
+    try {
+      await this.networkingEngine_
+          .request(RequestType.TIMING, shakaReq, {type: 'cmcd-event'})
+          .promise;
+      return {status: 200};
+    } catch (err) {
+      return {status: err.status || 0};
+    }
+  };
+}
+```
+
+- [ ] **Step 2: Verify the body-conversion against Task 0.8's findings.** If CML never emits Blob, drop that branch. If CML emits something else (e.g., `Uint8Array`), add that branch.
+
+- [ ] **Step 3: Stash `this.networkingEngine_` reference** somewhere in the constructor or `setMediaElement` (the existing `cmcd_manager.js` likely already has this; verify).
+
+- [ ] **Step 4: Run `python3 build/check.py`.**
+
+**Acceptance:** `requester` callback compiles; routes through NetworkingEngine.
+
+### Task 3.10: Delete obsolete code
+
+**Files:**
+- Modify: `lib/util/cmcd_manager.js`
+
+- [ ] **Step 1: Delete:**
+  - All encoding helpers (already partially deleted in Phase 1; verify nothing remains).
+  - Sequence-number tracking (`this.cmcdSequenceNumbers_`).
+  - Event-timer infrastructure (`this.eventTimers_`).
+  - MSD computation (`this.msdSent_`, etc.).
+  - Mode-selection logic (request mode vs. response mode vs. event mode dispatch — CML's reporter handles this).
+  - Private helpers: `applyRequest_`, `applyManifestData`, `applyManifestRequest_`, etc.
+
+- [ ] **Step 2: Keep:**
+  - `getObjectType_`, `getBitrate_`, `getDuration_`, `getTopBitrate_`, `getStreamFormat_` — shaka knowledge, the adapter's job to translate.
+  - `requestTimestampMap_` — TTFB/TTLB measurement; CML reporter doesn't have access to send time.
+
+- [ ] **Step 3: Run `python3 build/check.py`.** No dead-code warnings; if Closure flags unused private fields, delete them.
+
+- [ ] **Step 4: Verify line count.** Spec target is ~250 lines for the adapter.
+
+**Acceptance:** Manager file shrunk to ~250 lines; only adapter logic and shaka-knowledge helpers remain.
+
+### Task 3.11: Externs renames
+
+**Files:**
+- Modify: `externs/shaka/player.js` — rename `targets` → `eventTargets`, per-target `enabledKeys` → `includeKeys`
+- Modify: `externs/cmcd.js` — review for v2-key updates if needed (likely no change)
+
+Per spec § "Public-API back-compat details".
+
+- [ ] **Step 1: Rename `shaka.extern.CmcdConfiguration.targets` → `eventTargets`.** Lines 2771, 2819 in `externs/shaka/player.js` (per the grep earlier).
+
+- [ ] **Step 2: Rename per-target field in `shaka.extern.CmcdTarget`.** The current typedef at line 2760 doesn't show all fields in my read — verify the field is `enabledKeys` and rename to `includeKeys`. Update JSDoc descriptions accordingly.
+
+- [ ] **Step 3: Update the JSDoc comment block** for `CmcdConfiguration` to reflect the new field name. Add `@deprecated` or migration note if maintainers prefer.
+
+- [ ] **Step 4: Verify Player code doesn't read `cfg.targets`.** Grep:
+  ```bash
+  grep -rn "cmcd.targets\|\.targets" lib/player.js
+  ```
+  Update any remaining references to the old name.
+
+- [ ] **Step 5: Run `python3 build/check.py`.**
+
+**Acceptance:** Externs renamed; no internal references to old names.
+
+### Task 3.12: v2 re-exports
+
+**Files:**
+- Modify: `lib/util/cmcd_manager.js`
+
+Per spec § "New public re-exports for v2 configuration".
+
+- [ ] **Step 1: Add re-exports:**
+
+```javascript
+/**
+ * @enum {string}
+ * @export
+ */
+shaka.util.CmcdManager.EventType = cml.cmcd.CmcdEventType;
+
+/**
+ * @enum {string}
+ * @export
+ */
+shaka.util.CmcdManager.PlayerState = cml.cmcd.CmcdPlayerState;
+```
+
+- [ ] **Step 2: Verify `@export` works for alias re-exports.** Closure ADVANCED may need a different pattern (e.g., per-key copy) to preserve the export. Use whatever pattern the existing `StreamingFormat` re-export from Task 2.3 ended up using.
+
+- [ ] **Step 3: Run `python3 build/check.py` and grep the compiled output** for `EventType` / `PlayerState` to confirm they appear in the public API:
+  ```bash
+  python3 build/build.py && grep -o "EventType\|PlayerState" dist/shaka-player.compiled.js | head
+  ```
+
+**Acceptance:** Both re-exports appear in compiled bundle's public surface.
+
+### Task 3.13: Test rewrite
+
+**Files:**
+- Modify (large delete): `test/util/cmcd_manager_unit.js`
+- Add: new test sections per spec § "Tests strategy"
+
+Per spec § "Phase 3 — Test rewrite".
+
+- [ ] **Step 1: Delete CMCD wire-format tests** (Bucket A — encoder correctness, key serialization, value escaping, header vs query, v1/v2 mode-specific filtering, inner-list encoding, structured-field serialization, sequence-number progression, event timing/batching). Spec estimates ~3000+ lines deleted.
+
+- [ ] **Step 2: Add Bucket B tests** (~500 lines, shaka-specific glue). Use a stubbed `CmcdReporter` that records calls. Cover:
+  - `RequestType` (MANIFEST, SEGMENT, LICENSE, KEY, TIMING) → `CmcdObjectType` mapping.
+  - `RequestContext.type` → `CmcdStreamingFormat` mapping (DASH/LL-DASH/HLS/LL-HLS/Smooth/Other).
+  - Config translation (`toReporterConfig_` outputs given various `shaka.extern.CmcdConfiguration` inputs).
+  - Player-event listener wiring: simulate `<video>` events, assert `reporter.update(...)` and `recordEvent(...)` calls.
+  - NetworkingEngine routing: stub the reporter's `requester` callback; assert it dispatches via `NetworkingEngine.request(RequestType.TIMING, ...)`; assert error → `{status: 0}` translation.
+  - Lifecycle: construct → configure → reset → reconfigure produces a fresh reporter.
+  - `rtp = bitrate × rtpSafetyFactor` computed in adapter.
+  - `enabled: false` → no reporter constructed; apply* short-circuits.
+  - `setMediaElement` triggers reporter construction (resolves spec gap #1).
+  - `bl` is per-request, never persistent state (resolves spec gap #2).
+  - Player-state deduplication: repeated `playing` events → single `recordEvent`.
+  - Public-API back-compat: `shaka.util.CmcdManager.StreamingFormat`/`EventType`/`PlayerState` enums available with expected values.
+
+- [ ] **Step 3: Add Bucket C tests** (~100 lines, end-to-end smoke). Drive a real `CmcdReporter` (not a stub) through the adapter; assert wire output. Cover:
+  - One v1 + one v2 config × two transmission modes (`CMCD_QUERY`, `CMCD_HEADERS`) = at least 4 cases.
+  - One event-mode test: configure an `eventTarget`; trigger play-state change; assert NetworkingEngine receives an event-mode POST with expected body.
+
+- [ ] **Step 4: Run `python3 build/test.py` until green.** Iterate.
+
+**Acceptance:** Test suite passes. ~4317 lines deleted, ~600 lines added (per spec estimate).
+
+### Task 3.14: Demo update
+
+**Files:**
+- Modify: `demo/` — add CMCD v2 config UI
+
+Per spec § "Phase 3", and resolving spec gap #8 (demo scope).
+
+- [ ] **Step 1: Identify the existing demo CMCD UI.** Grep:
+  ```bash
+  grep -rn "cmcd" demo/
+  ```
+
+- [ ] **Step 2: Add minimum v2 controls:**
+  - Transmission mode toggle (query / headers).
+  - Version selector (1 / 2).
+  - Single eventTarget editor: URL input + checkboxes for which event types to subscribe to (`PLAY_STATE`, `ERROR`, `RESPONSE_RECEIVED`, etc.) + numeric input for `timeInterval`.
+  - Reuse existing CMCD UI for `enabled`, `sessionId`, `contentId`, `includeKeys`, `useHeaders`.
+
+- [ ] **Step 3: Wire config changes to `player.configure({cmcd: ...})`.**
+
+- [ ] **Step 4: Verify the demo loads and the new controls work** — load a stream, change settings live, verify CMCD output changes accordingly via DevTools network tab.
+
+**Acceptance:** Demo has v2 config UI. Mirrors precedent from dash.js's `cmcd-v2.html` per spec.
+
+### Task 3.15: Phase 3 verification
+
+- [ ] **Step 1: `python3 build/check.py` passes.**
+- [ ] **Step 2: `python3 build/test.py` passes.**
+- [ ] **Step 3: `python3 build/all.py` passes.**
+- [ ] **Step 4: Demo verification:**
+  - v1 config + query mode: stream plays; CMCD in query string; expected keys present.
+  - v1 config + headers mode: stream plays; CMCD in `CMCD-Request` header.
+  - v2 config + query mode: stream plays; v2 keys present (`sta`, `sn`, etc.); inner-list keys are arrays (`br=[1234]`).
+  - v2 config + eventTarget configured: trigger play/pause/seek; verify event-mode POSTs to the eventTarget URL.
+- [ ] **Step 5: Manual regression check** for non-CMCD playback: unconfigure CMCD; verify nothing about playback changed.
+
+**Acceptance:** All phases of verification pass.
+
+### Task 3.16: Phase 3 PR
+
+- [ ] **Step 1: Open PR with title:**
+  ```
+  refactor(cmcd): replace state machine with cml.cmcd.CmcdReporter (3/3)
+  ```
+
+- [ ] **Step 2: PR description includes:**
+  - Overview: "Phase 3 of 3 in the CMCD CML refactor."
+  - **Public-API renames** (experimental v2 only):
+    - `shaka.extern.CmcdConfiguration.targets` → `eventTargets`.
+    - Per-target `enabledKeys` → `includeKeys`.
+  - **New public re-exports**: `shaka.util.CmcdManager.EventType`, `shaka.util.CmcdManager.PlayerState`.
+  - **Behavioral changes**: enumerate any state-transition or timing differences vs. the pre-refactor manager.
+  - **Sequence numbers** (Task 0.7 outcome): if CML's per-target sequencing differs from shaka's prior per-mode sequencing, call out as a wire-format change.
+  - **Event-mode dispatch**: now flows through NetworkingEngine; inherits auth/retry/filters.
+  - Test surface: ~4317 lines deleted (wire-format coverage now in CML upstream), ~600 lines added (adapter glue + smoke).
+  - **Deferred**: `RequestType.CMCD_EVENT_REPORT` (using `RequestType.TIMING` for now; can be added in follow-up PR without changing adapter contract).
+
+- [ ] **Step 3: Wait for review; address feedback; merge.**
+
+**Acceptance:** PR merged; CMCD refactor complete.
+
+### Phase 3 verification gate
+
+- [ ] `python3 build/check.py` passes.
+- [ ] `python3 build/test.py` passes.
+- [ ] `python3 build/all.py` passes.
+- [ ] Demo plays content with CMCD v1 + v2 in both transmission modes.
+- [ ] Demo dispatches event-mode reports through NetworkingEngine.
+- [ ] Phase 3 PR merged.
+
+---
+
+## Risks and mitigations
+
+| Risk | Phase | Mitigation |
+|---|---|---|
+| Closure ADVANCED renames an `@export` symbol | All | After each `@export` change, verify the symbol appears in compiled output (`grep` on `dist/shaka-player.compiled.js`). |
+| Wire-format diff during Phase 1 surfaces (c)-class bugs (real divergence, not alignment) | 1 | Block Phase 1 ship; resolve via CML upstream PR or adapter workaround; re-run diff test. |
+| CML's `CmcdReporter` API doesn't match spec assumptions | 0, 3 | Phase 0 verification catches; Task 3.1 re-verifies before Phase 3 commits. |
+| State-transition timing differences (CML emits events at slightly different times than shaka used to) | 3 | Bucket C smoke tests catch egregious cases; PR description calls out any known timing changes; demo regression check. |
+| Per-target sequence numbering differs from shaka's per-mode prior behavior | 3 | Task 0.7 documents the difference; Phase 3 PR description notes it; downstream consumers parsing `sn` need to adapt. |
+| `enabled: false → true` mid-session dynamic reconfiguration leaves the adapter in a broken state | 3 | Bucket B test covers this lifecycle path. |
+| Demo regression: existing CMCD-disabled flows break | 3 | Manual regression check (Task 3.15.5); test-suite already covers `enabled: false`. |
+| Memory leak from forgotten event listeners on `reset()` | 3 | `reset()` calls `eventManager_.removeAll()` (existing pattern); Bucket B test asserts listener count returns to zero. |
+| CML version pinning becomes stale between Phase 0 and Phase 3 | All | Task 3.1 re-pins if upstream landed relevant changes; small risk this triggers a Phase 1 revisit. |
+| `crypto.randomUUID()` not available in some shaka-supported browser | 3 | Use shaka's existing UUID-generation path (whatever `cmcd_manager.js` currently uses) rather than `crypto.randomUUID()` directly; the polyfill already covers this. |
+
+---
+
+## Out of scope (deferred follow-ups)
+
+- **`RequestType.CMCD_EVENT_REPORT` dedicated request type.** Phase 3 uses `RequestType.TIMING`. Follow-up PR can add a dedicated type without changing adapter contract.
+- **CMCD validators in the vendored port.** Spec § "Excluded" lists ~16 validator files. Add only if shaka adds a debug-mode self-check feature.
+- **Expanded public re-export surface.** Beyond `StreamingFormat`/`EventType`/`PlayerState`, additional CML enums (`CmcdObjectType`, `CmcdStreamType`, `CmcdHeaderField`, etc.) stay internal until users have a documented need.
+- **TypeScript migration.** Out of scope per spec; the vendored port is transitional and deletes when [#8262](https://github.com/shaka-project/shaka-player/issues/8262) lands.
+
+---
+
+## Self-review (post-write)
+
+- [x] **Spec coverage check.** Each spec section maps to a phase: Constraints → Phase 0 verification + AGENTS.md adherence; Architecture → Phase 1 + Phase 3; Vendored port → Phase 1; Adapter → Phase 3; CML-side requirements → Phase 0 + Task 3.1; Migration phasing → plan structure; Tests → Tasks 1.11/1.12/3.13; Open questions → Tasks 0.1/0.7 + Task 1.11 + Risk table.
+- [x] **Placeholder scan.** No "TBD", "fill in details", "implement later", or generic "add error handling" — every step has actionable content or a verification command.
+- [x] **Type consistency.** Method names used consistently: `setPlayerState_`, `maybeStartReporter_`, `toReporterConfig_`, `makeRequester_`, `generateSessionId_`, `lastPlayerState_`. CML symbols consistently `cml.cmcd.X`.
+- [x] **Spec gaps surfaced.** 10 gaps listed at the top with their resolving tasks identified.
+- [x] **Risks identified.** Risk table covers Closure export drift, wire-format divergence, API mismatches, state-timing differences, sequence-numbering, demo regressions, listener leaks, version drift, and UUID polyfill.
+- [x] **Acceptance criteria per phase.** Each phase has a verification-gate checklist (`build/check.py`, `build/test.py`, `build/all.py`, demo).

From 79702531e640f9e4e58d57d231d02edfa85dd77f Mon Sep 17 00:00:00 2001
From: Casey Occhialini <1508707+littlespex@users.noreply.github.com>
Date: Mon, 27 Apr 2026 20:26:29 -0700
Subject: [PATCH 04/64] docs(cmcd): add Phase 0 CML version pin + API
 verification report

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 plans/cmcd-cml-refactor/cml-version.md | 273 +++++++++++++++++++++++++
 1 file changed, 273 insertions(+)
 create mode 100644 plans/cmcd-cml-refactor/cml-version.md

diff --git a/plans/cmcd-cml-refactor/cml-version.md b/plans/cmcd-cml-refactor/cml-version.md
new file mode 100644
index 0000000000..0ca93663db
--- /dev/null
+++ b/plans/cmcd-cml-refactor/cml-version.md
@@ -0,0 +1,273 @@
+# Pinned CML version + API verification report
+
+Date: 2026-04-27
+Pinned npm version: `@svta/cml-cmcd@2.3.0`
+Pinned git tag: `cmcd-v2.3.0`
+Pinned commit SHA: `22390e35dfbbe1e53d15648d3aace99cdf71f9dd`
+Tag commit subject: `feat(cmcd): add CMCD_MIME_TYPE and validateCmcdEventReport (#333)`
+Tag commit date: 2026-04-15
+npm release date: 2026-04-15
+Source location: `libs/cmcd/src/` (in CML monorepo)
+Local checkout used: `/tmp/cml-pinned` (at SHA above)
+
+## Summary
+
+The pinned version (`cmcd-v2.3.0`, npm `2.3.0`) is the latest stable release as of 2026-04-27 — spec assumption confirmed.
+
+Verification surfaced **6 substantive gaps** between the spec and CML's actual public surface. Most are spec inaccuracies that should be corrected before Phase 1, not CML defects requiring upstream PRs:
+
+1. **`CmcdStreamingFormat` is missing `LOW_LATENCY_DASH` (`'ld'`) and `LOW_LATENCY_HLS` (`'lh'`).** CML only defines DASH/HLS/SMOOTH/OTHER. Shaka has all six. This is a real CML gap blocking Phase 2's alias re-export — needs either a CML upstream PR adding the LL variants, or shaka must keep its own `StreamingFormat` enum and stop re-exporting CML's.
+2. **`CmcdEventReportConfig.timeInterval` is named `interval` in CML.** Spec's per-target table calls it `timeInterval`; the field is `interval` in CML source. Cosmetic spec fix; adapter must use `interval`.
+3. **`CmcdEventType` has 17 members, not the 10 listed in the spec.** All 10 spec members are present. CML adds: `BITRATE_CHANGE` (`bc`), `AD_START` (`as`), `AD_END` (`ae`), `AD_BREAK_START` (`abs`), `AD_BREAK_END` (`abe`), `SKIP` (`sk`), `CUSTOM_EVENT` (`ce`). No gap — spec just under-listed.
+4. **`recordResponseReceived` data shape uses `response.resourceTiming` (not a flat `{ttfb, ttlb}` data object).** The reporter auto-derives `ttfb`/`ttlb`/`ts` from `response.resourceTiming.{startTime, responseStart, duration}`. The `data` override is still `Partial<Cmcd>` and adapter-supplied `ttfb`/`ttlb`/`rc`/`url` values override the derived ones. Adapter has two valid paths: synthesize a `ResourceTiming`-shaped object on the response, or pass the values directly via the data override. Spec is partially right (field names match) but doesn't reflect the `resourceTiming` indirection.
+5. **`createRequestReport` returns a derived object as spec said, but `recordResponseReceived` returns `void`.** Spec is correct on both counts. No `applyResponseData` "copy back" step is required — CML's response flow is purely state-recording (it queues an internal `rr` event for any configured event-mode targets). Adapter's `applyResponseData` does not need to mutate `response` based on CML output.
+6. **CML's request-mode sequence numbers are global, not per-target.** Single counter `requestTarget.sn` for all request-mode reports; one counter per event target. Shaka currently has separate `{request, response}` counters per per-config-hash target. CML does not split request from response — `rr` events use the per-event-target counter, request reports use the global `requestTarget` counter. This is a wire-format divergence that should be flagged in the Phase 3 PR.
+
+Beyond the gaps above, all other spec assertions verified cleanly: lifecycle methods, `requester` callback contract, `CmcdEventReportConfig` field set (modulo the `interval` rename), per-target `version` IS exposed (spec § Open Questions Q3 resolved — keep the per-target `version` field).
+
+**Recommended next step:** Proceed to Phase 1 only after (a) the spec doc is updated to reflect findings #2, #3, #4, #5, #6, and (b) a decision is made on finding #1 (LL streaming format gap). Recommend filing a CML upstream PR adding `LOW_LATENCY_DASH` and `LOW_LATENCY_HLS` to `CmcdStreamingFormat` — this aligns with CMCD v2 spec and keeps the alias-re-export plan viable. Findings #2–#6 are spec/doc-only fixes and don't gate implementation.
+
+## Task 0.2 — Lifecycle methods
+
+All five lifecycle methods exist on `class CmcdReporter` in `libs/cmcd/src/CmcdReporter.ts`. Citations:
+
+| Method | File:line | Signature | Returns | Throws |
+|---|---|---|---|---|
+| `start()` | `CmcdReporter.ts:151` | `start(): void` | `void` | No declared throws. Sets up `setInterval` per event target whose `interval` > 0 and which subscribes to `TIME_INTERVAL`. **Note:** fires an initial time-interval event synchronously (line 164) before the first interval elapses — adapter must populate state before calling `start()`. |
+| `stop(flush?)` | `CmcdReporter.ts:173` | `stop(flush: boolean = false): void` | `void` | No declared throws. If `flush` truthy, calls `this.flush()` first (line 174-176), then `clearInterval` on every event target (line 178-180). Default `flush = false`. |
+| `flush()` | `CmcdReporter.ts:188` | `flush(): void` | `void` | No declared throws. Forwards to `processEventTargets(true)` (line 189), which dispatches all queued events regardless of batch size. |
+| `update(data)` | `CmcdReporter.ts:197` | `update(data: Partial<Cmcd>): void` | `void` | No declared throws. If `data.sid` differs from current `sid`, resets per-target sequence counters (line 198-200, `resetSession()` at line 455). Strips `msd` from persistent state (line 208). |
+| `recordEvent(type, data?)` | `CmcdReporter.ts:219` | `recordEvent(type: CmcdEventType, data: Partial<Cmcd> = {}): void` | `void` | No declared throws. Records the event for every event target whose `events` array includes `type`, then runs `processEventTargets()` (line 224). |
+
+**Confirmed:** All five methods exist with signatures compatible with the adapter's intended call sites. None throw on the success path. Adapter's `reset()` should call `reporter.stop(true)` to flush pending events before tearing down.
+
+## Task 0.3 — `CmcdEventType` enum
+
+`libs/cmcd/src/CmcdEventType.ts` defines a 17-member `as const` map. All 10 spec members are present. Mapping:
+
+| Two-letter code | CML constant | CML enum key | File:line |
+|---|---|---|---|
+| `bc` | `CMCD_EVENT_BITRATE_CHANGE` | `CmcdEventType.BITRATE_CHANGE` | `CmcdEventType.ts:8`, `CmcdEventType.ts:135` |
+| `ps` | `CMCD_EVENT_PLAY_STATE` | `CmcdEventType.PLAY_STATE` | `CmcdEventType.ts:15`, `CmcdEventType.ts:140` |
+| `e` | `CMCD_EVENT_ERROR` | `CmcdEventType.ERROR` | `CmcdEventType.ts:22`, `CmcdEventType.ts:145` |
+| `t` | `CMCD_EVENT_TIME_INTERVAL` | `CmcdEventType.TIME_INTERVAL` | `CmcdEventType.ts:29`, `CmcdEventType.ts:150` |
+| `c` | `CMCD_EVENT_CONTENT_ID` | `CmcdEventType.CONTENT_ID` | `CmcdEventType.ts:36`, `CmcdEventType.ts:155` |
+| `b` | `CMCD_EVENT_BACKGROUNDED_MODE` | `CmcdEventType.BACKGROUNDED_MODE` | `CmcdEventType.ts:43`, `CmcdEventType.ts:160` |
+| `m` | `CMCD_EVENT_MUTE` | `CmcdEventType.MUTE` | `CmcdEventType.ts:50`, `CmcdEventType.ts:165` |
+| `um` | `CMCD_EVENT_UNMUTE` | `CmcdEventType.UNMUTE` | `CmcdEventType.ts:57`, `CmcdEventType.ts:170` |
+| `pe` | `CMCD_EVENT_PLAYER_EXPAND` | `CmcdEventType.PLAYER_EXPAND` | `CmcdEventType.ts:64`, `CmcdEventType.ts:175` |
+| `pc` | `CMCD_EVENT_PLAYER_COLLAPSE` | `CmcdEventType.PLAYER_COLLAPSE` | `CmcdEventType.ts:71`, `CmcdEventType.ts:180` |
+| `rr` | `CMCD_EVENT_RESPONSE_RECEIVED` | `CmcdEventType.RESPONSE_RECEIVED` | `CmcdEventType.ts:78`, `CmcdEventType.ts:185` |
+
+Plus 6 additional members not in the spec list, present in CML:
+
+| Two-letter code | CML enum key | File:line |
+|---|---|---|
+| `as` | `CmcdEventType.AD_START` | `CmcdEventType.ts:85`, `CmcdEventType.ts:190` |
+| `ae` | `CmcdEventType.AD_END` | `CmcdEventType.ts:92`, `CmcdEventType.ts:195` |
+| `abs` | `CmcdEventType.AD_BREAK_START` | `CmcdEventType.ts:99`, `CmcdEventType.ts:200` |
+| `abe` | `CmcdEventType.AD_BREAK_END` | `CmcdEventType.ts:106`, `CmcdEventType.ts:205` |
+| `sk` | `CmcdEventType.SKIP` | `CmcdEventType.ts:113`, `CmcdEventType.ts:210` |
+| `ce` | `CmcdEventType.CUSTOM_EVENT` | `CmcdEventType.ts:120`, `CmcdEventType.ts:215` |
+
+**Naming clarification (vs spec):** The spec § "CML-side requirements" lists `pe → PLAY_END` and `pc → PLAYBACK_CHANGE` as guesses. Actual mappings are `pe → PLAYER_EXPAND` and `pc → PLAYER_COLLAPSE` (player view UI state changes). Spec doc should be updated.
+
+**Confirmed:** Every event type the adapter intends to emit (`ps`, `e`, `t`, `c`, `b`, `m`, `um`, `pe`, `pc`, `rr`) has a CML enum value. Note also that `BITRATE_CHANGE` (which the spec uses without giving a code) is `bc`, present in CML.
+
+## Task 0.4 — Request/response report methods
+
+### `createRequestReport(request, data?)`
+
+| Aspect | Finding |
+|---|---|
+| File:line | `CmcdReporter.ts:347` |
+| Signature | `createRequestReport<R extends HttpRequest = HttpRequest>(request: R, data?: Partial<Cmcd>): R & CmcdRequestReport<R['customData']>` |
+| Return shape | Defined in `libs/cmcd/src/CmcdRequestReport.ts:9` — `HttpRequest & {customData: {cmcd: Cmcd} & D; headers: Record<string, string>}` |
+| Behavior | Returns a derived object (not in-place mutation). Builds new `report` object from spread of `request` (line 348-358). If `enabledKeys.length` is 0 or `report.url` is falsy, returns the bare cloned report with empty `cmcd: {}` (line 360-362). Otherwise applies CMCD data either to query string (line 376-382) or headers (line 384-386) per `transmissionMode`. |
+
+**Confirmed:** Spec assertion `R & CmcdRequestReport<R['customData']>` matches exactly. Adapter MUST adopt the "copy fields back" pattern (CmcdReporter.ts:347 returns a new object; shaka's existing `applyRequestData` mutates in place). Specifically: copy `report.url` and `report.headers` back onto the input `request` to preserve shaka's mutation contract.
+
+### `recordResponseReceived(response, data?)`
+
+| Aspect | Finding |
+|---|---|
+| File:line | `CmcdReporter.ts:277` |
+| Signature | `recordResponseReceived(response: HttpResponse<HttpRequest<{ cmcd?: Cmcd }>>, data: Partial<Cmcd> = {}): void` |
+| Returns | `void` — purely state-recording. **No data to copy back.** Adapter's `applyResponseData` does not need to mutate `response` based on CML output. |
+| Data param shape | `Partial<Cmcd>` — i.e., partial of the CMCD payload object. Field names are CMCD wire keys (`url`, `rc`, `ttfb`, `ttlb`, `ts`, etc.) — **`rc` not `responseCode`** (spec was right). |
+| `response` shape | `HttpResponse` — defined in `libs/utils/src/HttpResponse.ts:10`. Required: `request: HttpRequest`. Optional: `status`, `url`, `redirected`, `statusText`, `type`, `headers`, `data`, `resourceTiming`. |
+| Auto-derived fields | `CmcdReporter.ts:289-308`: `url` ← `data.url ?? request.url`; `rc` ← `response.status`; `ts` ← `Math.round(timeOrigin + resourceTiming.startTime)`; `ttfb` ← `Math.round(resourceTiming.responseStart - resourceTiming.startTime)`; `ttlb` ← `Math.round(resourceTiming.duration)`. |
+| Override priority | Line 312: `{ ...cmcd, ...derived, ...data }` — `data` wins over derived, derived wins over the per-request `cmcd` data attached to the original request's `customData`. |
+
+**Confirmed (with caveat):** Spec's `recordResponseReceived(response, {ttfb, ttlb, rc, url})` IS a valid call shape — CML accepts `Partial<Cmcd>` and the adapter-supplied keys override CML's auto-derivation. **However**, the adapter has two equivalent paths:
+1. Synthesize a `ResourceTiming` object (`{startTime, responseStart, duration}`) on `response.resourceTiming` and let CML derive — closer to "let CML do the work".
+2. Pre-compute `ttfb`/`ttlb`/`rc`/`url` and pass via the `data` override — closer to spec's call shape, but means re-computing what shaka already measures via `requestTimestampMap_`.
+
+Spec doc should clarify that the data param is a `Partial<Cmcd>` not a fixed-shape object, and that `resourceTiming` is the canonical input for timing fields. No CML defect — just spec drift.
+
+### Other relevant request methods
+
+- `applyRequestReport(req)` — `CmcdReporter.ts:324`. Marked `@deprecated`; calls `createRequestReport` internally. Adapter should use `createRequestReport` directly.
+- `isRequestReportingEnabled()` — `CmcdReporter.ts:333`. Returns `!!this.config.enabledKeys?.length`. Useful for adapter-side fast-path.
+
+## Task 0.5 — `CmcdEventReportConfig` field-by-field diff
+
+Source: `libs/cmcd/src/CmcdEventReportConfig.ts` (extends `CmcdReportConfig` from `libs/cmcd/src/CmcdReportConfig.ts`).
+
+| Spec field | CML field | Type | File:line | Notes |
+|---|---|---|---|---|
+| `url` | `url` | `string` | `CmcdEventReportConfig.ts:22` | Required. Match. |
+| `events` | `events` | `CmcdEventType[]` (optional) | `CmcdEventReportConfig.ts:30` | Match. |
+| **`timeInterval`** | **`interval`** | `number` (optional, seconds) | `CmcdEventReportConfig.ts:40` | **Field name mismatch.** CML uses `interval`. Default `CMCD_DEFAULT_TIME_INTERVAL = 30` (`CMCD_DEFAULT_TIME_INTERVAL.ts:6`). Adapter must rename `timeInterval` → `interval`. |
+| `batchSize` | `batchSize` | `number` (optional) | `CmcdEventReportConfig.ts:47` | Match. Default `1`. |
+| `enabledKeys` | `enabledKeys` | `CmcdKey[]` (optional, inherited from `CmcdReportConfig`) | `CmcdReportConfig.ts:24` | Match. |
+| `version` | `version` | `typeof CMCD_V2` (optional) | `CmcdEventReportConfig.ts:17` | **Per-target `version` IS exposed.** Note CML restricts it to `CMCD_V2` (event mode is v2-only — v1 has no event mode). Spec § "Per-target version override" gap-resolution: keep the field. |
+
+Also inherited from `CmcdReportConfig`:
+- `version?: CmcdVersion` — overridden by `CmcdEventReportConfig`'s narrower `typeof CMCD_V2` constraint.
+- `enabledKeys?: CmcdKey[]`.
+
+**Resolution of spec's open question on per-target `version`:** Keep the per-target `version` field. CML exposes it; behaviorally it's a no-op in v2.x (CML only allows `CMCD_V2`), but mapping shaka's `version` → CML's `version` per-target is harmless and forward-compatible.
+
+**Action items:**
+1. Rename `timeInterval` → `interval` in shaka's `shaka.extern.CmcdTarget` typedef during Phase 3, OR add an alias in the adapter's `toReporterConfig_` (`timeInterval` is the experimental v2 config). Spec § public-API section already authorizes experimental renames.
+2. Update spec doc § "Per-target eventTargets[] field shape" to use `interval`.
+
+## Task 0.6 — `CmcdStreamingFormat` value parity
+
+| Spec value | shaka value | CML value | File:line | Status |
+|---|---|---|---|---|
+| `'d'` (DASH) | `DASH: 'd'` (`cmcd_manager.js:1613`) | `DASH: 'd'` | `CmcdStreamingFormat.ts:16` | **Match** |
+| `'h'` (HLS) | `HLS: 'h'` (`cmcd_manager.js:1615`) | `HLS: 'h'` | `CmcdStreamingFormat.ts:21` | **Match** |
+| `'s'` (SMOOTH) | `SMOOTH: 's'` (`cmcd_manager.js:1617`) | `SMOOTH: 's'` | `CmcdStreamingFormat.ts:26` | **Match** |
+| `'o'` (OTHER) | `OTHER: 'o'` (`cmcd_manager.js:1618`) | `OTHER: 'o'` | `CmcdStreamingFormat.ts:31` | **Match** |
+| `'ld'` (LL-DASH) | `LOW_LATENCY_DASH: 'ld'` (`cmcd_manager.js:1614`) | **MISSING** | n/a | **GAP** |
+| `'lh'` (LL-HLS) | `LOW_LATENCY_HLS: 'lh'` (`cmcd_manager.js:1616`) | **MISSING** | n/a | **GAP** |
+
+CML defines only DASH/HLS/SMOOTH/OTHER (`CmcdStreamingFormat.ts:12-32`). The 4 string values that CML defines all match shaka. **Two LL variants used by shaka are absent from CML.**
+
+**Impact:** Phase 2 plan calls for re-exporting `shaka.util.CmcdManager.StreamingFormat` as an alias of `cml.cmcd.CmcdStreamingFormat`. With LL variants missing, this alias would be a regression for any shaka user reading `LOW_LATENCY_DASH`/`LOW_LATENCY_HLS` from the public enum. Shaka also uses these internally (`cmcd_manager.js:177-194` — `setLowLatency` flips `sf_` between `DASH ↔ LOW_LATENCY_DASH` and `HLS ↔ LOW_LATENCY_HLS`).
+
+**Recommended action:** **File CML upstream PR** adding `LOW_LATENCY_DASH: 'ld'` and `LOW_LATENCY_HLS: 'lh'`. The CMCD v2 spec section on Streaming Format (referenced by CML's JSDoc link) covers low-latency variants, so this is a CML completeness gap, not a shaka extension. PR title: `feat(cmcd): add LOW_LATENCY_DASH and LOW_LATENCY_HLS to CmcdStreamingFormat`. Phase 2's alias re-export is blocked on this PR landing and being released.
+
+## Task 0.7 — Sequence-number behavior
+
+### CML behavior
+
+Source: `libs/cmcd/src/CmcdReporter.ts`.
+
+- **Request mode:** Single global counter `this.requestTarget.sn` (initialized to 0 at line 111). Incremented on every `createRequestReport` call regardless of target. Line 365: `cmcdData = { ...this.data, ...data, sn: this.requestTarget.sn++ }`.
+- **Event mode:** Per-event-target counter `target.sn` (one per `eventTargets[]` entry). Each target's `sn` initialized to 0 at line 137. Incremented on every event recorded for that target. Line 247: `sn: target.sn++`.
+- **Reset:** `resetSession()` at `CmcdReporter.ts:455` resets both kinds: every event target's `sn` to 0 (line 456), and the global request-mode `sn` to 0 (line 457). Triggered from `update()` whenever `data.sid` is supplied AND differs from current `sid` (line 198-200).
+- **No separation of "request" vs "response" counters.** Response-received events (`rr`) flow through `recordEvent` (line 312), so they share the per-event-target counter with all other event-mode events.
+
+### Shaka's existing behavior
+
+Source: `lib/util/cmcd_manager.js`.
+
+- **State:** `this.cmcdSequenceNumbers_ = {}` keyed by config-target hash (`cmcd_manager.js:93, 148`). Each entry has shape `{request: number, response: number}` (line 739, 781).
+- **Request mode:** Counter at `cmcdSequenceNumbers_[hash].request++` per request (line 784). Hash key is `getCmcdTargetHash_({mode: REQUEST, useHeaders, includeKeys})`.
+- **Event mode:** Counter at `cmcdSequenceNumbers_[hash].response++` per event (line 742). Hash key is `getCmcdTargetHash_(target)` where `target` is the user-configured event-target object.
+- **Reset:** `cmcdSequenceNumbers_ = {}` on `reset()` (line 148). No partial reset on `sid` change.
+- **Initial value:** counters start at 1 (line 739, 781), so first emitted `sn` is 1.
+
+### Divergences
+
+| Aspect | shaka | CML |
+|---|---|---|
+| Request-mode counter scope | Per-target-hash (`{useHeaders, includeKeys}` distinct → distinct counter) | One global counter for all request-mode reports |
+| Event-mode counter scope | Per-target (each `eventTargets[]` entry → own counter) | Same — per-target |
+| Counter naming | `{request, response}` separate counters per target hash | Single `sn` per target; `rr` events share with other event-mode events |
+| Initial value | `1` | `0` |
+| Reset on `sid` change | Not reset | Reset (request-mode global + every event-target) |
+| Reset on `reset()` | Yes (whole dict cleared) | n/a — adapter must construct a new reporter or call `update({sid: newSid})` |
+
+**Wire-format impact for Phase 3 PR:**
+1. **First `sn` shifts from 1 to 0.** Consumers parsing `sn` as a counter index must adjust if they were assuming 1-based indexing.
+2. **Request-mode `sn` is no longer scoped to header-vs-query mode.** A shaka session that switched `useHeaders` mid-flight previously got two independent counters; with CML, both modes share one. In practice this is unlikely (shaka doesn't expose runtime mode switching), but it's a behavioral simplification worth flagging.
+3. **`sn` resets on `sid` change in CML.** Shaka's existing behavior keeps per-hash counters intact across `sid` rotations within a session. CML resets on each new `sid`. Adapter behavior post-Phase-3 will reset `sn` on session-id rotation.
+
+**Confirmed:** Sequence-number behavior is documented and divergences identified. Adapter doesn't need to do anything special — let CML own the counters; just call out the wire change in the Phase 3 PR description.
+
+## Task 0.8 — `requester` callback contract
+
+Source: `libs/cmcd/src/CmcdReporter.ts`. Type imports from `@svta/cml-utils` (`libs/utils/src/HttpRequest.ts`, `libs/utils/src/HttpResponse.ts`).
+
+### Where `requester` is invoked
+
+`CmcdReporter.ts:432-449` (`sendEventReport` private method):
+
+```typescript
+private async sendEventReport(target: CmcdEventReportConfigNormalized, data: Cmcd[]): Promise<void> {
+    const options = createEncodingOptions(CMCD_EVENT_MODE, target)
+    const response = await this.requester({
+        url: target.url,
+        method: 'POST',
+        headers: {
+            'Content-Type': CMCD_MIME_TYPE,
+        },
+        body: data.map(item => encodeCmcd(item, options)).join('\n') + '\n',
+    })
+    // ...
+}
+```
+
+Default requester (`CmcdReporter.ts:50-53`): `(request) => fetch(request.url, request)`. Replaced via constructor's second arg (`CmcdReporter.ts:125`) — no `config.requester` field; it's a constructor parameter.
+
+### Contract
+
+| Aspect | Finding |
+|---|---|
+| **Request shape** | `{url: string, method: 'POST', headers: {'Content-Type': 'application/cmcd', ...}, body: string}` always. Method is hardcoded `'POST'` (line 436). Headers always include `Content-Type: application/cmcd` (lines 437-439, `CMCD_MIME_TYPE.ts:6`). Body is always a `string` (line 440 — `encodeCmcd(...).join('\n') + '\n'`). The full `HttpRequest` type (`HttpRequest.ts:8`) allows additional fields (`body?: BodyInit`, `responseType`, `credentials`, `mode`, `timeout`, `customData`) but the reporter uses only the four above. |
+| **Body type** | **Always `string`.** Spec § "Event-mode dispatch via NetworkingEngine" claims body may be string or Blob — **incorrect for CML 2.3.0.** Adapter's body-conversion logic only needs the string path: `shaka.util.StringUtils.toUTF8(cmcdReq.body)`. The Blob/`BodyInit` path is dead code; removing it simplifies the adapter. (CML's reporter body shape is fixed by the encoder; it never emits JSON or binary.) |
+| **Response promise shape** | `Promise<{status: number}>` (line 125, line 50). The full `HttpResponse` type (`HttpResponse.ts:10`) has many more fields, but the reporter only reads `status` (line 443). |
+| **Status semantics** | Line 445-449. **`410`** → silently delete the target permanently (`this.eventTargets.delete(target)`). **`429` or `5xx` (500-599)** → throw an Error; the catch in `processEventTargets` (line 413-416) re-queues the failed batch via `target.queue.unshift(...events)`. **All other statuses (including `200`, `204`, `4xx` other than `410`/`429`)** → silent success; events are NOT re-queued. |
+| **Rejection vs non-2xx** | Asymmetric. A **rejected promise** is caught by `processEventTargets` (line 413: `.catch(() => target.queue.unshift(...events))`) — re-queues the batch. A **resolved-with-410** is treated specially; **resolved-with-200..499 (excluding 410, 429)** is silent success. **Resolved-with-429 or 5xx** throws inside `sendEventReport` → re-queues. So: rejection ≡ "retry"; non-2xx other than `410`/`429`/`5xx` ≡ "drop silently"; `410` ≡ "stop using this target". |
+| **No body on response** | Reporter never reads `response.body` or `response.data` from the requester — only `status`. Adapter's requester shim need not preserve the response body. |
+
+**Confirmed:** Adapter's requester shim has a tight, well-defined contract. The `try/catch` example in spec (lines 477-485) returns `{status: 200}` on success and `{status: err.status || 0}` on failure. With CML's status-code handling above, that's correct: rejection → re-queue (good); non-2xx returned as resolved → silent drop unless `429`/`5xx`. **Recommendation:** Adapter SHOULD distinguish between recoverable network errors (DNS/timeout/abort) and HTTP errors. NetworkingEngine throws on retries-exhausted with `error.severity` and `error.code`; adapter could map to `{status: 0}` (rejection-equivalent) for retry, or `{status: 410}` (poison the target) for permanent failures. Spec's example reasonably maps both to `{status: err.status || 0}` which falls through to "silent drop" — acceptable for an MVP but loses the re-queue-on-transient-failure benefit. This is a Phase 3 design refinement, not a Phase 0 blocker.
+
+## Gaps found
+
+In severity order:
+
+1. **`CmcdStreamingFormat` missing LL variants.** CML lacks `LOW_LATENCY_DASH: 'ld'` and `LOW_LATENCY_HLS: 'lh'`. Spec's Phase 2 alias re-export is blocked on these landing in CML.
+   - **Spec assertion that fails:** Spec § "Public-API back-compat details" lines 411-412 ("Verified values match: `'d'`, `'ld'`, `'h'`, `'lh'`, `'s'`, `'o'`."), Phase 2 § "Re-export `shaka.util.CmcdManager.StreamingFormat` as alias of `cml.cmcd.CmcdStreamingFormat`".
+   - **Recommended action:** **File CML upstream PR** adding both values. Block Phase 2's alias re-export until CML PR ships and is released. Alternative (worse): keep shaka's own enum and skip the alias re-export entirely; Phase 2 then deletes less.
+
+2. **`CmcdEventReportConfig.timeInterval` is `interval` in CML.** Spec doc uses `timeInterval` throughout § "Per-target eventTargets[] field shape" and the experimental rename table.
+   - **Spec assertion that fails:** Spec § "Per-target eventTargets[] field shape" row 3 (`timeInterval`).
+   - **Recommended action:** Update spec doc to say `interval` (or document the shaka-side `timeInterval` rename explicitly as a third experimental rename layered on the existing `enabledKeys → includeKeys` and `targets → eventTargets` renames). Implementation-wise, the adapter's `toReporterConfig_` already renames per-target fields, so this is mechanically trivial.
+
+3. **`recordResponseReceived` data shape is `Partial<Cmcd>`, not `{ttfb, ttlb, rc, url}`.** Spec implies a fixed shape; CML accepts any partial CMCD object. Auto-derived fields come from `response.resourceTiming`.
+   - **Spec assertion that fails:** Spec § "applyResponseData flow" step 2.
+   - **Recommended action:** Update spec to clarify the data param is `Partial<Cmcd>` and that the adapter has two valid paths (synthesize `resourceTiming` or pass overrides). No CML defect.
+
+4. **Sequence-number scope and reset semantics differ from shaka's existing behavior.** Detailed in Task 0.7. Wire-format change.
+   - **Spec assertion that fails:** Spec § "CML-side requirements" row "Sequence numbers per-target — likely present; verify per v2 spec" (verified, but with divergence from shaka's existing semantics).
+   - **Recommended action:** Document in Phase 3 PR description as an intentional alignment-with-CML wire change. No code change required in CML or adapter.
+
+5. **`CmcdEventType` constant name mappings.** Spec § "CML-side requirements" lines 530-534 names `pe` and `pc` as `PLAY_END`/`PLAYER_ERROR`/`PLAYBACK_CHANGE`. CML names them `PLAYER_EXPAND`/`PLAYER_COLLAPSE` (UI viewport changes).
+   - **Spec assertion that fails:** Spec § "CML-side requirements" lines 530-534.
+   - **Recommended action:** Update spec doc. No CML defect.
+
+6. **`requester` is a constructor parameter, not a config field.** Spec § "Event-mode dispatch via NetworkingEngine" line 449 says "`CmcdReporter` accepts a `requester: (req) => Promise<{status: number}>` config option". It's actually the **second positional arg to the constructor**, not a `CmcdReporterConfig` field.
+   - **Spec assertion that fails:** Spec § "Event-mode dispatch via NetworkingEngine" line 449.
+   - **Recommended action:** Spec doc fix. Implementation-wise, the adapter calls `new CmcdReporter(reporterConfig, requesterFn)` instead of `new CmcdReporter({...reporterConfig, requester: requesterFn})`. Mechanically equivalent.
+
+Minor: The spec § "Event-mode dispatch via NetworkingEngine" body-conversion code path handles Blob (line 471-474 of spec.md: `else if (cmcdReq.body instanceof Blob) { ... }`). CML never produces Blob bodies. The Blob branch is dead code and the adapter can drop it.
+
+## Recommended next step
+
+**Hold Phase 1 implementation until:**
+- A CML upstream PR adding `LOW_LATENCY_DASH` and `LOW_LATENCY_HLS` to `CmcdStreamingFormat` is merged and released (estimate: low effort given user maintains both repos).
+
+**Update spec.md immediately (no code impact):**
+- Replace `timeInterval` with `interval` in the per-target field shape table.
+- Replace `pe → PLAY_END` / `pc → PLAYBACK_CHANGE` with `pe → PLAYER_EXPAND` / `pc → PLAYER_COLLAPSE`.
+- Clarify `recordResponseReceived` data shape is `Partial<Cmcd>` and document the `resourceTiming` indirection.
+- Note `requester` is a constructor arg, not a config field.
+- Drop the Blob branch from the adapter requester sketch.
+- Add a note in the Phase 3 § that sequence-number reset on `sid` change and counter scope are intentional alignment-with-CML wire changes.
+
+**Once those land:** Re-pin to whatever CML version includes the LL streaming-format addition (likely `cmcd-v2.3.1` or `cmcd-v2.4.0`), update `cml-version.md`, and proceed to Phase 1.

From 33c7c78ab9c50df4c90aca7152ebe25ff567b738 Mon Sep 17 00:00:00 2001
From: Casey Occhialini <1508707+littlespex@users.noreply.github.com>
Date: Mon, 27 Apr 2026 20:44:13 -0700
Subject: [PATCH 05/64] docs(cmcd): fix doc cross-references in Phase 0
 verification report

Plan-vs-spec attribution was wrong: the enum-name guesses for pe/pc/t/c/b
live in plan.md:86 (the Task 0.3 description), not spec.md:530-534 (which
lists only two-letter codes). Also expanded the requester misnomer
callout to cover both spec.md:449 and spec.md:511.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 plans/cmcd-cml-refactor/cml-version.md | 20 ++++++++++++--------
 1 file changed, 12 insertions(+), 8 deletions(-)

diff --git a/plans/cmcd-cml-refactor/cml-version.md b/plans/cmcd-cml-refactor/cml-version.md
index 0ca93663db..147558de88 100644
--- a/plans/cmcd-cml-refactor/cml-version.md
+++ b/plans/cmcd-cml-refactor/cml-version.md
@@ -70,7 +70,7 @@ Plus 6 additional members not in the spec list, present in CML:
 | `sk` | `CmcdEventType.SKIP` | `CmcdEventType.ts:113`, `CmcdEventType.ts:210` |
 | `ce` | `CmcdEventType.CUSTOM_EVENT` | `CmcdEventType.ts:120`, `CmcdEventType.ts:215` |
 
-**Naming clarification (vs spec):** The spec § "CML-side requirements" lists `pe → PLAY_END` and `pc → PLAYBACK_CHANGE` as guesses. Actual mappings are `pe → PLAYER_EXPAND` and `pc → PLAYER_COLLAPSE` (player view UI state changes). Spec doc should be updated.
+**Naming clarification (vs plan):** `plan.md:86` (Task 0.3 description) listed several guessed enum names that turned out wrong. Actual CML mappings: `pe → PLAYER_EXPAND` (not `PLAY_END` / `PLAYER_ERROR`); `pc → PLAYER_COLLAPSE` (not `PLAYBACK_CHANGE`); `t → TIME_INTERVAL` (not `TIMEOUT`); `c → CONTENT_ID` (not `CONTENT_ID_CHANGE`); `b → BACKGROUNDED_MODE` (not `BACKGROUNDED`). The Task 0.3 table above has the correct CML names. Plan doc should be updated for any future re-runs of this verification, though the plan's purpose was just to enumerate codes to verify, not to assert names.
 
 **Confirmed:** Every event type the adapter intends to emit (`ps`, `e`, `t`, `c`, `b`, `m`, `um`, `pe`, `pc`, `rr`) has a CML enum value. Note also that `BITRATE_CHANGE` (which the spec uses without giving a code) is `bc`, present in CML.
 
@@ -247,13 +247,16 @@ In severity order:
    - **Spec assertion that fails:** Spec § "CML-side requirements" row "Sequence numbers per-target — likely present; verify per v2 spec" (verified, but with divergence from shaka's existing semantics).
    - **Recommended action:** Document in Phase 3 PR description as an intentional alignment-with-CML wire change. No code change required in CML or adapter.
 
-5. **`CmcdEventType` constant name mappings.** Spec § "CML-side requirements" lines 530-534 names `pe` and `pc` as `PLAY_END`/`PLAYER_ERROR`/`PLAYBACK_CHANGE`. CML names them `PLAYER_EXPAND`/`PLAYER_COLLAPSE` (UI viewport changes).
-   - **Spec assertion that fails:** Spec § "CML-side requirements" lines 530-534.
-   - **Recommended action:** Update spec doc. No CML defect.
+5. **`CmcdEventType` constant name mappings (in `plan.md`, not `spec.md`).** `plan.md:86` (Task 0.3 description) guessed names for several codes that turned out wrong. Actual CML names: `pe → PLAYER_EXPAND` (plan guessed `PLAY_END or PLAYER_ERROR`); `pc → PLAYER_COLLAPSE` (plan guessed `PLAYBACK_CHANGE`); `t → TIME_INTERVAL` (plan guessed `TIMEOUT or similar`); `c → CONTENT_ID` (plan guessed `CONTENT_ID_CHANGE`); `b → BACKGROUNDED_MODE` (plan guessed `BACKGROUNDED`). `spec.md:530-534` lists only the two-letter codes (no full names) and is unaffected.
+   - **Spec/plan assertion that fails:** `plan.md:86`.
+   - **Recommended action:** Plan doc fix only. No CML defect, no spec.md change required.
 
-6. **`requester` is a constructor parameter, not a config field.** Spec § "Event-mode dispatch via NetworkingEngine" line 449 says "`CmcdReporter` accepts a `requester: (req) => Promise<{status: number}>` config option". It's actually the **second positional arg to the constructor**, not a `CmcdReporterConfig` field.
-   - **Spec assertion that fails:** Spec § "Event-mode dispatch via NetworkingEngine" line 449.
-   - **Recommended action:** Spec doc fix. Implementation-wise, the adapter calls `new CmcdReporter(reporterConfig, requesterFn)` instead of `new CmcdReporter({...reporterConfig, requester: requesterFn})`. Mechanically equivalent.
+6. **`requester` is a constructor parameter, not a config field.** Two places in `spec.md` describe it as a config field:
+   - `spec.md:449` ("`CmcdReporter` accepts a `requester: (req) => Promise<{status: number}>` config option")
+   - `spec.md:511` (CML-side requirements table row: "`requester` config field for event-mode dispatch")
+   - It's actually the **second positional arg to the constructor**, not a `CmcdReporterConfig` field.
+   - **Spec assertion that fails:** `spec.md:449` and `spec.md:511`.
+   - **Recommended action:** Spec doc fix at both locations. Implementation-wise, the adapter calls `new CmcdReporter(reporterConfig, requesterFn)` instead of `new CmcdReporter({...reporterConfig, requester: requesterFn})`. Mechanically equivalent.
 
 Minor: The spec § "Event-mode dispatch via NetworkingEngine" body-conversion code path handles Blob (line 471-474 of spec.md: `else if (cmcdReq.body instanceof Blob) { ... }`). CML never produces Blob bodies. The Blob branch is dead code and the adapter can drop it.
 
@@ -264,7 +267,8 @@ Minor: The spec § "Event-mode dispatch via NetworkingEngine" body-conversion co
 
 **Update spec.md immediately (no code impact):**
 - Replace `timeInterval` with `interval` in the per-target field shape table.
-- Replace `pe → PLAY_END` / `pc → PLAYBACK_CHANGE` with `pe → PLAYER_EXPAND` / `pc → PLAYER_COLLAPSE`.
+- Update `plan.md:86` enum-name guesses (`pe → PLAYER_EXPAND`, `pc → PLAYER_COLLAPSE`, `t → TIME_INTERVAL`, `c → CONTENT_ID`, `b → BACKGROUNDED_MODE`).
+- Fix `spec.md:511` to call `requester` a constructor parameter, not a config field (matches the existing fix at `spec.md:449`).
 - Clarify `recordResponseReceived` data shape is `Partial<Cmcd>` and document the `resourceTiming` indirection.
 - Note `requester` is a constructor arg, not a config field.
 - Drop the Blob branch from the adapter requester sketch.

From be97afe477a18c7c1b5006384ca9192489baf53f Mon Sep 17 00:00:00 2001
From: Casey Occhialini <1508707+littlespex@users.noreply.github.com>
Date: Mon, 27 Apr 2026 20:51:29 -0700
Subject: [PATCH 06/64] docs(cmcd): restructure Phase 0 doc-update checklist
 into plan vs spec lists

The "Update spec.md immediately" section mixed plan.md and spec.md
items under a spec-only heading and double-listed the requester
misnomer. Split into separate "Update plan.md" and "Update spec.md"
subsections; combined the two requester entries; added line-ref
specificity to each spec.md item. Also added a quoted spec assertion
to gap #3 for symmetry with the other gap entries.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 plans/cmcd-cml-refactor/cml-version.md | 21 ++++++++++++---------
 1 file changed, 12 insertions(+), 9 deletions(-)

diff --git a/plans/cmcd-cml-refactor/cml-version.md b/plans/cmcd-cml-refactor/cml-version.md
index 147558de88..5ce052d5e7 100644
--- a/plans/cmcd-cml-refactor/cml-version.md
+++ b/plans/cmcd-cml-refactor/cml-version.md
@@ -240,7 +240,7 @@ In severity order:
    - **Recommended action:** Update spec doc to say `interval` (or document the shaka-side `timeInterval` rename explicitly as a third experimental rename layered on the existing `enabledKeys → includeKeys` and `targets → eventTargets` renames). Implementation-wise, the adapter's `toReporterConfig_` already renames per-target fields, so this is mechanically trivial.
 
 3. **`recordResponseReceived` data shape is `Partial<Cmcd>`, not `{ttfb, ttlb, rc, url}`.** Spec implies a fixed shape; CML accepts any partial CMCD object. Auto-derived fields come from `response.resourceTiming`.
-   - **Spec assertion that fails:** Spec § "applyResponseData flow" step 2.
+   - **Spec assertion that fails:** `spec.md:299` ("Adapter calls `reporter.recordResponseReceived(response, {ttfb, ttlb, rc, url})`.").
    - **Recommended action:** Update spec to clarify the data param is `Partial<Cmcd>` and that the adapter has two valid paths (synthesize `resourceTiming` or pass overrides). No CML defect.
 
 4. **Sequence-number scope and reset semantics differ from shaka's existing behavior.** Detailed in Task 0.7. Wire-format change.
@@ -265,13 +265,16 @@ Minor: The spec § "Event-mode dispatch via NetworkingEngine" body-conversion co
 **Hold Phase 1 implementation until:**
 - A CML upstream PR adding `LOW_LATENCY_DASH` and `LOW_LATENCY_HLS` to `CmcdStreamingFormat` is merged and released (estimate: low effort given user maintains both repos).
 
-**Update spec.md immediately (no code impact):**
-- Replace `timeInterval` with `interval` in the per-target field shape table.
-- Update `plan.md:86` enum-name guesses (`pe → PLAYER_EXPAND`, `pc → PLAYER_COLLAPSE`, `t → TIME_INTERVAL`, `c → CONTENT_ID`, `b → BACKGROUNDED_MODE`).
-- Fix `spec.md:511` to call `requester` a constructor parameter, not a config field (matches the existing fix at `spec.md:449`).
-- Clarify `recordResponseReceived` data shape is `Partial<Cmcd>` and document the `resourceTiming` indirection.
-- Note `requester` is a constructor arg, not a config field.
-- Drop the Blob branch from the adapter requester sketch.
-- Add a note in the Phase 3 § that sequence-number reset on `sid` change and counter scope are intentional alignment-with-CML wire changes.
+**Doc-only updates (no code impact):**
+
+### Update plan.md
+- `plan.md:86` (Task 0.3 description) — replace the enum-name guesses with the correct CML constant names from Task 0.3's table above. Specifically: `pe → PLAYER_EXPAND` (was `PLAY_END or PLAYER_ERROR`); `pc → PLAYER_COLLAPSE` (was `PLAYBACK_CHANGE`); `t → TIME_INTERVAL` (was `TIMEOUT or similar`); `c → CONTENT_ID` (was `CONTENT_ID_CHANGE`); `b → BACKGROUNDED_MODE` (was `BACKGROUNDED`).
+
+### Update spec.md
+- `spec.md:299` (`applyResponseData` flow step 2) — clarify that `recordResponseReceived` takes `Partial<Cmcd>` and auto-derives `ttfb`/`ttlb`/`ts` from `response.resourceTiming`. The flat `{ttfb, ttlb, rc, url}` override path still works but is the secondary path; the primary path is to synthesize a `ResourceTiming` object on `response.resourceTiming` and let CML derive timing fields.
+- `spec.md:346` — rename per-target `timeInterval` field to `interval` (matches CML's `CmcdEventReportConfig.ts:40`).
+- `spec.md:449` and `spec.md:511` — fix both references to `requester` as a "config field"; it's the `CmcdReporter` constructor's second positional arg, not a `CmcdReporterConfig` member.
+- `spec.md:469-475` (adapter requester sketch) — drop the Blob branch. CML's reporter only emits `body: string`; the Blob path is dead code.
+- `spec.md` Phase 3 section — add a note that sequence-number reset on `sid` change and the request-mode counter scope change (per-target-hash → global) are intentional alignment-with-CML wire changes, not regressions.
 
 **Once those land:** Re-pin to whatever CML version includes the LL streaming-format addition (likely `cmcd-v2.3.1` or `cmcd-v2.4.0`), update `cml-version.md`, and proceed to Phase 1.

From 6a851a2d87115097d4bd1f35d7eca5a1080154e4 Mon Sep 17 00:00:00 2001
From: Casey Occhialini <1508707+littlespex@users.noreply.github.com>
Date: Mon, 27 Apr 2026 21:12:48 -0700
Subject: [PATCH 07/64] docs(cmcd): apply Phase 0 verification findings to spec
 and plan

- Reclassify CmcdStreamingFormat finding: shaka's 'ld'/'lh' are non-spec
  (from an old unreleased CMCD draft); drop in Phase 1 instead of filing
  upstream. No CML changes required.
- Apply 5 spec/plan doc fixes from cml-version.md (interval rename,
  recordResponseReceived shape, requester as positional arg, no Blob
  body, plan.md:86 enum-name guesses).
- Update plan.md Phase 1 to include the LL value drop as a wire-format
  change alongside nor URL relativization (new Task 1.10b).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 plans/cmcd-cml-refactor/cml-version.md | 43 ++++++------
 plans/cmcd-cml-refactor/plan.md        | 93 +++++++++++++++++++-------
 plans/cmcd-cml-refactor/spec.md        | 82 ++++++++++++++++-------
 3 files changed, 150 insertions(+), 68 deletions(-)

diff --git a/plans/cmcd-cml-refactor/cml-version.md b/plans/cmcd-cml-refactor/cml-version.md
index 5ce052d5e7..2ef5382832 100644
--- a/plans/cmcd-cml-refactor/cml-version.md
+++ b/plans/cmcd-cml-refactor/cml-version.md
@@ -14,18 +14,18 @@ Local checkout used: `/tmp/cml-pinned` (at SHA above)
 
 The pinned version (`cmcd-v2.3.0`, npm `2.3.0`) is the latest stable release as of 2026-04-27 — spec assumption confirmed.
 
-Verification surfaced **6 substantive gaps** between the spec and CML's actual public surface. Most are spec inaccuracies that should be corrected before Phase 1, not CML defects requiring upstream PRs:
+Verification surfaced **6 doc/conformance fixes** between the spec and CML's actual public surface. **Zero blockers** — none require CML upstream PRs. Findings #2–#6 are spec/plan doc fixes; finding #1 is a shaka spec-conformance fix (drop non-spec values) applied within Phase 1:
 
-1. **`CmcdStreamingFormat` is missing `LOW_LATENCY_DASH` (`'ld'`) and `LOW_LATENCY_HLS` (`'lh'`).** CML only defines DASH/HLS/SMOOTH/OTHER. Shaka has all six. This is a real CML gap blocking Phase 2's alias re-export — needs either a CML upstream PR adding the LL variants, or shaka must keep its own `StreamingFormat` enum and stop re-exporting CML's.
+1. **shaka's `'ld'` (LL-DASH) and `'lh'` (LL-HLS) `StreamingFormat` values are non-spec.** They originate from an old, unreleased CMCD draft. CML correctly omits them; CTA-5004 and CTA-5004-B both define only `'d'`/`'h'`/`'s'`/`'o'`. Shaka has been emitting non-conformant `sf` values. **Resolution:** drop `'ld'`/`'lh'` from shaka in Phase 1 alongside encoding delegation. LL DASH emits `sf=d`, LL HLS emits `sf=h`. Wire-format change to flag in Phase 1 PR description.
 2. **`CmcdEventReportConfig.timeInterval` is named `interval` in CML.** Spec's per-target table calls it `timeInterval`; the field is `interval` in CML source. Cosmetic spec fix; adapter must use `interval`.
 3. **`CmcdEventType` has 17 members, not the 10 listed in the spec.** All 10 spec members are present. CML adds: `BITRATE_CHANGE` (`bc`), `AD_START` (`as`), `AD_END` (`ae`), `AD_BREAK_START` (`abs`), `AD_BREAK_END` (`abe`), `SKIP` (`sk`), `CUSTOM_EVENT` (`ce`). No gap — spec just under-listed.
 4. **`recordResponseReceived` data shape uses `response.resourceTiming` (not a flat `{ttfb, ttlb}` data object).** The reporter auto-derives `ttfb`/`ttlb`/`ts` from `response.resourceTiming.{startTime, responseStart, duration}`. The `data` override is still `Partial<Cmcd>` and adapter-supplied `ttfb`/`ttlb`/`rc`/`url` values override the derived ones. Adapter has two valid paths: synthesize a `ResourceTiming`-shaped object on the response, or pass the values directly via the data override. Spec is partially right (field names match) but doesn't reflect the `resourceTiming` indirection.
 5. **`createRequestReport` returns a derived object as spec said, but `recordResponseReceived` returns `void`.** Spec is correct on both counts. No `applyResponseData` "copy back" step is required — CML's response flow is purely state-recording (it queues an internal `rr` event for any configured event-mode targets). Adapter's `applyResponseData` does not need to mutate `response` based on CML output.
 6. **CML's request-mode sequence numbers are global, not per-target.** Single counter `requestTarget.sn` for all request-mode reports; one counter per event target. Shaka currently has separate `{request, response}` counters per per-config-hash target. CML does not split request from response — `rr` events use the per-event-target counter, request reports use the global `requestTarget` counter. This is a wire-format divergence that should be flagged in the Phase 3 PR.
 
-Beyond the gaps above, all other spec assertions verified cleanly: lifecycle methods, `requester` callback contract, `CmcdEventReportConfig` field set (modulo the `interval` rename), per-target `version` IS exposed (spec § Open Questions Q3 resolved — keep the per-target `version` field).
+Beyond the findings above, all other spec assertions verified cleanly: lifecycle methods, `requester` callback contract, `CmcdEventReportConfig` field set (modulo the `interval` rename), per-target `version` IS exposed (spec § Open Questions Q3 resolved — keep the per-target `version` field).
 
-**Recommended next step:** Proceed to Phase 1 only after (a) the spec doc is updated to reflect findings #2, #3, #4, #5, #6, and (b) a decision is made on finding #1 (LL streaming format gap). Recommend filing a CML upstream PR adding `LOW_LATENCY_DASH` and `LOW_LATENCY_HLS` to `CmcdStreamingFormat` — this aligns with CMCD v2 spec and keeps the alias-re-export plan viable. Findings #2–#6 are spec/doc-only fixes and don't gate implementation.
+**Recommended next step:** Proceed to Phase 1. CML version pin remains `cmcd-v2.3.0`; no upstream PRs required. Apply the doc fixes (findings #2–#6) and the LL-value drop (finding #1) as part of Phase 1's wire-format-alignment work, alongside the already-planned `nor` URL relativization change.
 
 ## Task 0.2 — Lifecycle methods
 
@@ -135,20 +135,22 @@ Also inherited from `CmcdReportConfig`:
 
 ## Task 0.6 — `CmcdStreamingFormat` value parity
 
-| Spec value | shaka value | CML value | File:line | Status |
+| Spec-conformant value | shaka value | CML value | File:line | Status |
 |---|---|---|---|---|
 | `'d'` (DASH) | `DASH: 'd'` (`cmcd_manager.js:1613`) | `DASH: 'd'` | `CmcdStreamingFormat.ts:16` | **Match** |
 | `'h'` (HLS) | `HLS: 'h'` (`cmcd_manager.js:1615`) | `HLS: 'h'` | `CmcdStreamingFormat.ts:21` | **Match** |
 | `'s'` (SMOOTH) | `SMOOTH: 's'` (`cmcd_manager.js:1617`) | `SMOOTH: 's'` | `CmcdStreamingFormat.ts:26` | **Match** |
 | `'o'` (OTHER) | `OTHER: 'o'` (`cmcd_manager.js:1618`) | `OTHER: 'o'` | `CmcdStreamingFormat.ts:31` | **Match** |
-| `'ld'` (LL-DASH) | `LOW_LATENCY_DASH: 'ld'` (`cmcd_manager.js:1614`) | **MISSING** | n/a | **GAP** |
-| `'lh'` (LL-HLS) | `LOW_LATENCY_HLS: 'lh'` (`cmcd_manager.js:1616`) | **MISSING** | n/a | **GAP** |
+| *(non-spec)* | `LOW_LATENCY_DASH: 'ld'` (`cmcd_manager.js:1614`) | *(correctly omitted)* | n/a | **shaka non-conformant** |
+| *(non-spec)* | `LOW_LATENCY_HLS: 'lh'` (`cmcd_manager.js:1616`) | *(correctly omitted)* | n/a | **shaka non-conformant** |
 
-CML defines only DASH/HLS/SMOOTH/OTHER (`CmcdStreamingFormat.ts:12-32`). The 4 string values that CML defines all match shaka. **Two LL variants used by shaka are absent from CML.**
+CML defines only DASH/HLS/SMOOTH/OTHER (`CmcdStreamingFormat.ts:12-32`). All 4 spec-conformant values match between shaka and CML.
 
-**Impact:** Phase 2 plan calls for re-exporting `shaka.util.CmcdManager.StreamingFormat` as an alias of `cml.cmcd.CmcdStreamingFormat`. With LL variants missing, this alias would be a regression for any shaka user reading `LOW_LATENCY_DASH`/`LOW_LATENCY_HLS` from the public enum. Shaka also uses these internally (`cmcd_manager.js:177-194` — `setLowLatency` flips `sf_` between `DASH ↔ LOW_LATENCY_DASH` and `HLS ↔ LOW_LATENCY_HLS`).
+**Re shaka's `'ld'`/`'lh'` values:** These originate from an old, unreleased CMCD draft and are not present in either CTA-5004 (CMCD v1) or CTA-5004-B (CMCD v2). CML is correct to omit them; shaka has been emitting non-conformant `sf` values. The maintainer (who owns both repos) confirmed CML's omission is intentional.
 
-**Recommended action:** **File CML upstream PR** adding `LOW_LATENCY_DASH: 'ld'` and `LOW_LATENCY_HLS: 'lh'`. The CMCD v2 spec section on Streaming Format (referenced by CML's JSDoc link) covers low-latency variants, so this is a CML completeness gap, not a shaka extension. PR title: `feat(cmcd): add LOW_LATENCY_DASH and LOW_LATENCY_HLS to CmcdStreamingFormat`. Phase 2's alias re-export is blocked on this PR landing and being released.
+**Impact:** Phase 2's alias re-export plan is **unblocked** — once shaka drops `'ld'`/`'lh'`, shaka's enum becomes a strict subset of CML's, and `shaka.util.CmcdManager.StreamingFormat = cml.cmcd.CmcdStreamingFormat` works straightforwardly. shaka's internal `setLowLatency` flow (`cmcd_manager.js:177-194` — flipping `sf_` between `DASH ↔ LOW_LATENCY_DASH` and `HLS ↔ LOW_LATENCY_HLS`) needs simplification: LL DASH stays at `'d'`, LL HLS stays at `'h'`.
+
+**Recommended action:** Drop `LOW_LATENCY_DASH` and `LOW_LATENCY_HLS` from `shaka.util.CmcdManager.StreamingFormat` and remove `setLowLatency`'s `sf_` mutation in **Phase 1**, alongside the encoding delegation. This is a wire-format change — flag in the Phase 1 PR description alongside `nor` URL relativization. No CML PR required.
 
 ## Task 0.7 — Sequence-number behavior
 
@@ -229,11 +231,11 @@ Default requester (`CmcdReporter.ts:50-53`): `(request) => fetch(request.url, re
 
 ## Gaps found
 
-In severity order:
+No CML defects. All findings are doc fixes (spec/plan accuracy) or shaka spec-conformance fixes:
 
-1. **`CmcdStreamingFormat` missing LL variants.** CML lacks `LOW_LATENCY_DASH: 'ld'` and `LOW_LATENCY_HLS: 'lh'`. Spec's Phase 2 alias re-export is blocked on these landing in CML.
-   - **Spec assertion that fails:** Spec § "Public-API back-compat details" lines 411-412 ("Verified values match: `'d'`, `'ld'`, `'h'`, `'lh'`, `'s'`, `'o'`."), Phase 2 § "Re-export `shaka.util.CmcdManager.StreamingFormat` as alias of `cml.cmcd.CmcdStreamingFormat`".
-   - **Recommended action:** **File CML upstream PR** adding both values. Block Phase 2's alias re-export until CML PR ships and is released. Alternative (worse): keep shaka's own enum and skip the alias re-export entirely; Phase 2 then deletes less.
+1. **shaka's `'ld'`/`'lh'` `StreamingFormat` values are non-spec; drop in Phase 1.** These come from an old unreleased CMCD draft. CML correctly omits them per CTA-5004 / CTA-5004-B.
+   - **Spec assertion that fails:** Spec § "Public-API back-compat details" lines 411-412 ("Verified values match: `'d'`, `'ld'`, `'h'`, `'lh'`, `'s'`, `'o'`.") — claim is wrong on the LL variants.
+   - **Recommended action:** Drop `'ld'`/`'lh'` from `shaka.util.CmcdManager.StreamingFormat` in Phase 1. Wire-format change: LL DASH emits `sf=d`, LL HLS emits `sf=h` (instead of `sf=ld`/`sf=lh`). Flag in Phase 1 PR description. No CML PR required.
 
 2. **`CmcdEventReportConfig.timeInterval` is `interval` in CML.** Spec doc uses `timeInterval` throughout § "Per-target eventTargets[] field shape" and the experimental rename table.
    - **Spec assertion that fails:** Spec § "Per-target eventTargets[] field shape" row 3 (`timeInterval`).
@@ -262,19 +264,22 @@ Minor: The spec § "Event-mode dispatch via NetworkingEngine" body-conversion co
 
 ## Recommended next step
 
-**Hold Phase 1 implementation until:**
-- A CML upstream PR adding `LOW_LATENCY_DASH` and `LOW_LATENCY_HLS` to `CmcdStreamingFormat` is merged and released (estimate: low effort given user maintains both repos).
+**Proceed to Phase 1.** CML version pin remains `cmcd-v2.3.0` (`22390e35`); no upstream PRs required. Apply the doc updates below, fold the `'ld'`/`'lh'` drop into Phase 1 alongside encoding delegation, then begin Phase 1 implementation.
 
 **Doc-only updates (no code impact):**
 
 ### Update plan.md
 - `plan.md:86` (Task 0.3 description) — replace the enum-name guesses with the correct CML constant names from Task 0.3's table above. Specifically: `pe → PLAYER_EXPAND` (was `PLAY_END or PLAYER_ERROR`); `pc → PLAYER_COLLAPSE` (was `PLAYBACK_CHANGE`); `t → TIME_INTERVAL` (was `TIMEOUT or similar`); `c → CONTENT_ID` (was `CONTENT_ID_CHANGE`); `b → BACKGROUNDED_MODE` (was `BACKGROUNDED`).
+- `plan.md` Phase 1 — add a sub-task to drop `'ld'`/`'lh'` from `shaka.util.CmcdManager.StreamingFormat` and simplify `setLowLatency`'s `sf_` mutation. Phase 1 wire-format-change callout extends to cover both `nor` URL relativization and the LL value drop.
+- `plan.md` Phase 2 Task 2.3 (StreamingFormat re-export) — add a one-line note that after the Phase 1 LL drop, shaka's enum is a strict subset of CML's, so the alias re-export is straightforward.
+- `plan.md` Phase 3 Task 3.6 (player event listeners) — drop the `setLowLatency` → `update({streamingFormat: LOW_LATENCY_*})` step.
+- `plan.md` "Spec gaps surfaced during planning" gap #10 — update to reflect the actual finding (shaka emits non-spec values, CML is correct, drop in Phase 1).
 
 ### Update spec.md
-- `spec.md:299` (`applyResponseData` flow step 2) — clarify that `recordResponseReceived` takes `Partial<Cmcd>` and auto-derives `ttfb`/`ttlb`/`ts` from `response.resourceTiming`. The flat `{ttfb, ttlb, rc, url}` override path still works but is the secondary path; the primary path is to synthesize a `ResourceTiming` object on `response.resourceTiming` and let CML derive timing fields.
+- `spec.md:296-302` (`applyResponseData` flow step 2) — clarify that `recordResponseReceived` takes `Partial<Cmcd>` and auto-derives `ttfb`/`ttlb`/`ts` from `response.resourceTiming`. The flat `{ttfb, ttlb, rc, url}` override path still works but is the secondary path; the primary path is to synthesize a `ResourceTiming` object on `response.resourceTiming` and let CML derive timing fields.
 - `spec.md:346` — rename per-target `timeInterval` field to `interval` (matches CML's `CmcdEventReportConfig.ts:40`).
+- `spec.md:381-382` — drop both `setLowLatency(true) + DASH/HLS → update({streamingFormat: LOW_LATENCY_*})` rows from the "Player state ↔ reporter state mapping" table. Add a brief note that `sf` no longer reflects LL state in CMCD v2.
+- `spec.md:412` — update "Verified values match: `'d'`, `'ld'`, `'h'`, `'lh'`, `'s'`, `'o'`" to drop the LL variants and note shaka's non-spec values are dropped in Phase 1.
 - `spec.md:449` and `spec.md:511` — fix both references to `requester` as a "config field"; it's the `CmcdReporter` constructor's second positional arg, not a `CmcdReporterConfig` member.
 - `spec.md:469-475` (adapter requester sketch) — drop the Blob branch. CML's reporter only emits `body: string`; the Blob path is dead code.
 - `spec.md` Phase 3 section — add a note that sequence-number reset on `sid` change and the request-mode counter scope change (per-target-hash → global) are intentional alignment-with-CML wire changes, not regressions.
-
-**Once those land:** Re-pin to whatever CML version includes the LL streaming-format addition (likely `cmcd-v2.3.1` or `cmcd-v2.4.0`), update `cml-version.md`, and proceed to Phase 1.
diff --git a/plans/cmcd-cml-refactor/plan.md b/plans/cmcd-cml-refactor/plan.md
index 6d6f23d7ba..50c75cdd3f 100644
--- a/plans/cmcd-cml-refactor/plan.md
+++ b/plans/cmcd-cml-refactor/plan.md
@@ -33,8 +33,8 @@ The spec is mature, but these items need explicit attention during execution rat
 6. **Always-on reporter vs. hls.js [#7725](https://github.com/video-dev/hls.js/pull/7725).** hls.js uses CML's encoders for request mode and reporter for event mode only. Our spec chose always-on reporter for a single integration boundary. **Risk**: in v1-only request-mode-only configurations, we instantiate timers and event infrastructure that the user doesn't need. Captured as Task 3.3.
 7. **`enabled: false` early-out.** Spec says "adapter no-ops when `false`", but the CmcdReporter shouldn't be constructed at all when disabled to avoid timer creation. The lifecycle code must check `enabled` before construction, not just before each `apply*` call. Captured as Task 3.3.
 8. **Demo scope for Phase 3.** Spec § Phase 3 says "Update demo/ to add a CMCD v2 configuration UI" but doesn't enumerate which controls. Pinning a minimum scope: transmission mode toggle, version selector, single eventTarget editor with URL + events checklist. More expansive UI deferred. Captured as Task 3.13.
-9. **`StreamingFormat` value parity.** Spec asserts `'d'`, `'ld'`, `'h'`, `'lh'`, `'s'`, `'o'` match CML's `CmcdStreamingFormat`. Verify before Phase 2 commits to the alias re-export (Task 0.6).
-10. **CML `CmcdEventType` enum membership.** Spec lists `ps`, `e`, `t`, `c`, `b`, `m`, `um`, `pe`, `pc`, `rr`. Verify CML covers all; any missing → upstream PR (Task 0.3).
+9. **`StreamingFormat` value parity.** Phase 0 verified: shaka emits 6 values but CTA-5004 / CTA-5004-B / CML define only 4 (`'d'`/`'h'`/`'s'`/`'o'`). shaka's `'ld'` and `'lh'` come from an old unreleased CMCD draft and are non-spec. Captured as Phase 1 Task 1.10b (drop `'ld'`/`'lh'`); Phase 2 alias re-export then becomes a straightforward identity map (Task 2.3).
+10. **CML `CmcdEventType` enum membership.** Phase 0 verified: CML cmcd-v2.3.0 includes all 10 event types shaka needs (`ps`/`e`/`t`/`c`/`b`/`m`/`um`/`pe`/`pc`/`rr`) plus 7 more (`bc` bitrate change, ad events, skip, custom). Correct CML constant names listed at `plan.md:86`. No upstream PR needed.
 
 ---
 
@@ -83,7 +83,7 @@ The spec's "CML-side requirements" table marks these as "confirmed":
 
 - [ ] **Step 1: Open `libs/cmcd/src/CmcdEventType.ts` in the pinned checkout.**
 
-- [ ] **Step 2: Verify members:** `ps` (PLAY_STATE), `e` (ERROR), `t` (TIMEOUT or similar), `c` (CONTENT_ID_CHANGE), `b` (BACKGROUNDED), `m` (MUTE), `um` (UNMUTE), `pe` (PLAY_END or PLAYER_ERROR), `pc` (PLAYBACK_CHANGE), `rr` (RESPONSE_RECEIVED). Map each two-letter code to its enum constant name.
+- [ ] **Step 2: Verify members and their CML constant names:** `ps → PLAY_STATE`, `e → ERROR`, `t → TIME_INTERVAL`, `c → CONTENT_ID`, `b → BACKGROUNDED_MODE`, `m → MUTE`, `um → UNMUTE`, `pe → PLAYER_EXPAND`, `pc → PLAYER_COLLAPSE`, `rr → RESPONSE_RECEIVED`. (Names verified against CML cmcd-v2.3.0 in `cml-version.md` Task 0.3.)
 
 - [ ] **Step 3: For any missing member, file a CML PR adding it.** Example: if `pc` is absent, file `feat(cmcd): add CmcdEventType.PLAYBACK_CHANGE` upstream.
 
@@ -170,7 +170,12 @@ Spec marks this "likely present; verify per v2 spec".
 
 **Goal:** Add the vendored Closure port of `@svta/cml-cmcd`. Refactor shaka's static encoding helpers (`serialize`, `toQuery`, `appendQueryToUri`, `urlToRelativePath`) to delegate to CML's encoders. State machine, sequence numbers, event timing, and public API stay unchanged.
 
-**Behavior:** Preserved, with **one documented intentional change**: `nor` URLs become root-relative (CML's spec-conformant output) rather than path-relative. Phase 1 PR description must call this out as the one known intentional wire-format change. Diff testing during this phase surfaces any other unintentional divergences for case-by-case decisions.
+**Behavior:** Preserved, with **two documented intentional wire-format changes** for spec conformance:
+
+1. `nor` URLs become root-relative (CML's spec-conformant output) rather than path-relative.
+2. `sf` (streaming format) drops the non-spec values `'ld'` (LL-DASH) and `'lh'` (LL-HLS); LL DASH emits `sf=d`, LL HLS emits `sf=h`. Per Phase 0 verification (`cml-version.md` finding #1): `'ld'`/`'lh'` come from an old unreleased CMCD draft and are not in CTA-5004 or CTA-5004-B; CML correctly omits them.
+
+Phase 1 PR description must call out both. Diff testing during this phase surfaces any other unintentional divergences for case-by-case decisions.
 
 **Reference PRs to consult for patterns:**
 - [hls.js #7725](https://github.com/video-dev/hls.js/pull/7725) — note: their request-mode encoding uses CML encoders directly without going through `CmcdReporter`. Our Phase 3 changes that to always-on reporter; Phase 1 is closer to their request-mode pattern (encoders only).
@@ -255,11 +260,12 @@ chore(cmcd): port cml-cmcd type definitions as closure typedefs
 
   Example pattern for CML's `as const` enum:
   ```typescript
-  // CmcdStreamingFormat.ts
+  // CmcdStreamingFormat.ts (CML cmcd-v2.3.0)
   export const CmcdStreamingFormat = {
     DASH: 'd',
-    LOW_LATENCY_DASH: 'ld',
-    // ...
+    HLS: 'h',
+    SMOOTH: 's',
+    OTHER: 'o',
   } as const;
   export type CmcdStreamingFormat = ValueOf<typeof CmcdStreamingFormat>;
   ```
@@ -271,8 +277,9 @@ chore(cmcd): port cml-cmcd type definitions as closure typedefs
   /** @enum {string} */
   cml.cmcd.CmcdStreamingFormat = {
     DASH: 'd',
-    LOW_LATENCY_DASH: 'ld',
-    // ...
+    HLS: 'h',
+    SMOOTH: 's',
+    OTHER: 'o',
   };
   ```
 
@@ -458,7 +465,7 @@ chore(cmcd): port cml-cmcd CmcdReporter to closure
 
 - [ ] **Step 3: Run `python3 build/build.py`.** Confirm the bundle compiles with the vendored port inside.
 
-- [ ] **Step 4: Append spell-checker vocab to `project-words.txt`.** New CMCD-only words: `Cmcd` (likely already present), `cml`, `svta`, `mtp`, `nrr`, `cmsd`, `cmsds`, `cmsdd`, `ttfb`, `ttlb`, `ld`, `lh`, `ps`, `bg`, `pe`, `pc`, `rr`, `um`, `sta`, ... Run `python3 build/check.py` to see which are missing; add only those.
+- [ ] **Step 4: Append spell-checker vocab to `project-words.txt`.** New CMCD-only words: `Cmcd` (likely already present), `cml`, `svta`, `mtp`, `nrr`, `cmsd`, `cmsds`, `cmsdd`, `ttfb`, `ttlb`, `ps`, `bg`, `pe`, `pc`, `rr`, `um`, `sta`, ... Run `python3 build/check.py` to see which are missing; add only those. (Note: `ld` and `lh` are dropped in Task 1.10b as non-spec values; if they were previously in `project-words.txt`, remove them.)
 
 - [ ] **Step 5: Commit:**
 
@@ -492,6 +499,49 @@ Per spec § Phase 1.
 
 **Acceptance:** All four static methods now delegate. Manager file is shorter by the deleted method bodies.
 
+### Task 1.10b: Drop non-spec `'ld'`/`'lh'` from `StreamingFormat`
+
+**Files:**
+- Modify: `lib/util/cmcd_manager.js`
+
+Per Phase 0 finding #1 (`cml-version.md` Task 0.6): shaka's `'ld'` (LOW_LATENCY_DASH) and `'lh'` (LOW_LATENCY_HLS) values are not in CTA-5004 or CTA-5004-B. CML correctly omits them. Drop them from shaka in Phase 1 alongside encoding delegation; this is the second of Phase 1's two intentional wire-format changes (the other is `nor` URL relativization).
+
+- [ ] **Step 1: Remove the non-spec values from the enum** in `lib/util/cmcd_manager.js:1612-1619`:
+
+```javascript
+shaka.util.CmcdManager.StreamingFormat = {
+  DASH: 'd',
+  HLS: 'h',
+  SMOOTH: 's',
+  OTHER: 'o',
+};
+```
+
+- [ ] **Step 2: Simplify `setLowLatency` body** at `cmcd_manager.js:177-194`. The function currently flips `this.sf_` between `DASH ↔ LOW_LATENCY_DASH` and `HLS ↔ LOW_LATENCY_HLS`; after the drop, the LL state has no effect on `sf_`. Either delete the `if (this.lowLatency_)` branches entirely (preferred — `sf_` is set at manifest-load time and stays put), or leave a no-op stub for the LL flag if other code reads it.
+
+- [ ] **Step 3: Grep for remaining LL enum references.**
+  ```bash
+  grep -n "LOW_LATENCY_DASH\|LOW_LATENCY_HLS\|StreamingFormat\.LOW_LATENCY" lib/ test/
+  ```
+  Update any callers to drop the LL branches. Likely candidates: `getStreamFormat_` and any tests that asserted `sf=ld`/`sf=lh`.
+
+- [ ] **Step 4: Update tests** in `test/util/cmcd_manager_unit.js` that expected `sf=ld` or `sf=lh`. After this change, LL DASH content emits `sf=d`; LL HLS emits `sf=h`. The assertions become identical to their non-LL counterparts.
+
+- [ ] **Step 5: Run `python3 build/check.py` and `python3 build/test.py`.** Fix any compile errors and update broken assertions per Step 4.
+
+- [ ] **Step 6: Commit:**
+
+```
+fix(cmcd): drop non-spec 'ld'/'lh' StreamingFormat values
+
+CTA-5004 and CTA-5004-B define only 'd', 'h', 's', 'o' for the sf key.
+shaka's 'ld' (LOW_LATENCY_DASH) and 'lh' (LOW_LATENCY_HLS) come from an
+old unreleased draft and are not in either spec. CML correctly omits
+them. Wire change: LL DASH now emits sf=d, LL HLS now emits sf=h.
+```
+
+**Acceptance:** Enum has 4 values (DASH, HLS, SMOOTH, OTHER). `setLowLatency` no longer mutates `sf_`. Tests pass with non-LL `sf` values for LL content. Phase 1 PR description lists this as the second intentional wire-format change alongside `nor` URL relativization.
+
 ### Task 1.11: Diff testing — capture baseline
 
 Before changing test assertions, capture what the current (pre-delegation) wire output looks like for representative scenarios. The baseline is what we compare against after delegation.
@@ -655,6 +705,8 @@ diff -u plans/cmcd-cml-refactor/diff-test-baseline.json plans/cmcd-cml-refactor/
 **Files:**
 - Modify: `lib/util/cmcd_manager.js` — add the alias
 
+After Phase 1 Task 1.10b dropped the non-spec `'ld'`/`'lh'` values, shaka's `StreamingFormat` enum is a strict subset of CML's: same 4 spec-conformant values (`'d'`/`'h'`/`'s'`/`'o'`), same constant names (DASH/HLS/SMOOTH/OTHER). The alias re-export is straightforward; no derived/extended enum needed.
+
 - [ ] **Step 1: Add the re-export:**
 
 ```javascript
@@ -903,7 +955,7 @@ this.eventManager_.listen(this.player_, 'error', () => {
 
 - [ ] **Step 3: Implement throughput-update wiring.** Whatever shaka's existing throughput-change signal is (likely `shaka.abr.EwmaBandwidthEstimator` updates flowing through `shaka.Player`), feed `mtp` into `reporter.update(...)` as it changes.
 
-- [ ] **Step 4: Implement low-latency streamingFormat update** in response to `setLowLatency` calls + manifest type. Spec table covers this.
+- [ ] **Step 4: Set `streamingFormat` once at manifest-load time.** Feed `update({streamingFormat: ...})` from the manifest parser type (DASH → `'d'`, HLS → `'h'`, Smooth → `'s'`, otherwise `'o'`). **Do NOT mutate `streamingFormat` on `setLowLatency` callbacks** — Phase 1 dropped the non-spec `'ld'`/`'lh'` values, and `sf` is per CTA-5004-B a stable manifest-type indicator, not an LL flag.
 
 - [ ] **Step 5: Run `python3 build/check.py`.**
 
@@ -964,10 +1016,10 @@ toReporterConfig_(cfg) {
     reporterConfig.eventTargets = cfg.eventTargets.map((target) => ({
       url: target.url,
       events: target.events,
-      timeInterval: target.timeInterval,
+      interval: target.interval,          // CML field name (was timeInterval)
       batchSize: target.batchSize,
       enabledKeys: target.includeKeys,    // rename: includeKeys (shaka) → enabledKeys (CML)
-      version: target.version,            // only if CML supports per-target version (Task 0.5)
+      version: target.version,            // CML supports per-target version (Task 0.5 confirmed)
     }));
   }
   return reporterConfig;
@@ -1012,14 +1064,9 @@ makeRequester_() {
     shakaReq.method = cmcdReq.method || 'POST';
     shakaReq.headers = cmcdReq.headers || {};
 
-    // CML may emit body as string (structured-fields) or Blob (JSON).
-    if (typeof cmcdReq.body === 'string') {
-      shakaReq.body = shaka.util.StringUtils.toUTF8(cmcdReq.body);
-    } else if (cmcdReq.body instanceof Blob) {
-      shakaReq.body = await cmcdReq.body.arrayBuffer();
-    } else {
-      shakaReq.body = cmcdReq.body;  // already BufferSource
-    }
+    // CML's reporter always emits body as a string (structured-fields
+    // encoded by encodeCmcd, joined by '\n'). Convert to BufferSource.
+    shakaReq.body = shaka.util.StringUtils.toUTF8(cmcdReq.body);
 
     try {
       await this.networkingEngine_
@@ -1033,7 +1080,7 @@ makeRequester_() {
 }
 ```
 
-- [ ] **Step 2: Verify the body-conversion against Task 0.8's findings.** If CML never emits Blob, drop that branch. If CML emits something else (e.g., `Uint8Array`), add that branch.
+- [ ] **Step 2: Body type is fixed to `string`** per Phase 0 Task 0.8 verification (`cml-version.md`): CML's `sendEventReport` constructs `body: data.map(item => encodeCmcd(item, options)).join('\n') + '\n'` — never Blob, never Uint8Array. The Blob branch from earlier sketches is dead code.
 
 - [ ] **Step 3: Stash `this.networkingEngine_` reference** somewhere in the constructor or `setMediaElement` (the existing `cmcd_manager.js` likely already has this; verify).
 
@@ -1132,7 +1179,7 @@ Per spec § "Phase 3 — Test rewrite".
 
 - [ ] **Step 2: Add Bucket B tests** (~500 lines, shaka-specific glue). Use a stubbed `CmcdReporter` that records calls. Cover:
   - `RequestType` (MANIFEST, SEGMENT, LICENSE, KEY, TIMING) → `CmcdObjectType` mapping.
-  - `RequestContext.type` → `CmcdStreamingFormat` mapping (DASH/LL-DASH/HLS/LL-HLS/Smooth/Other).
+  - `RequestContext.type` → `CmcdStreamingFormat` mapping (DASH/HLS/Smooth/Other; LL DASH and LL HLS map to plain DASH/HLS per Phase 1 Task 1.10b).
   - Config translation (`toReporterConfig_` outputs given various `shaka.extern.CmcdConfiguration` inputs).
   - Player-event listener wiring: simulate `<video>` events, assert `reporter.update(...)` and `recordEvent(...)` calls.
   - NetworkingEngine routing: stub the reporter's `requester` callback; assert it dispatches via `NetworkingEngine.request(RequestType.TIMING, ...)`; assert error → `{status: 0}` translation.
diff --git a/plans/cmcd-cml-refactor/spec.md b/plans/cmcd-cml-refactor/spec.md
index 42306af659..e0ad729552 100644
--- a/plans/cmcd-cml-refactor/spec.md
+++ b/plans/cmcd-cml-refactor/spec.md
@@ -296,9 +296,22 @@ need to adjust path-resolution logic).
 `applyResponseData` flow:
 
 1. Adapter measures `ttfb`/`ttlb` via existing `requestTimestampMap_` mechanism.
-2. Adapter calls `reporter.recordResponseReceived(response, {ttfb, ttlb, rc, url})`.
-3. Reporter buffers response data for the next emission opportunity (and
-   internally fires the v2 `rr` "response received" event when configured).
+2. Adapter calls `reporter.recordResponseReceived(response, data)`. CML's
+   signature is `recordResponseReceived(response: HttpResponse, data:
+   Partial<Cmcd> = {})` — both args are CMCD-shaped, not the flat
+   `{ttfb, ttlb, rc, url}` shape. Two valid call patterns:
+   - **Primary path** (let CML derive): synthesize a `ResourceTiming`
+     object on `response.resourceTiming` (`{startTime, responseStart,
+     duration}`); CML auto-derives `ts`, `ttfb`, `ttlb`. `rc` comes from
+     `response.status`. `url` comes from `response.request.url`.
+   - **Override path:** pass `{ttfb, ttlb, rc, url}` (or any subset) as
+     the `data` argument. Override values win over auto-derived ones.
+   Adapter is free to mix: e.g., supply `resourceTiming` for `ts` while
+   passing pre-computed `ttfb`/`ttlb` from `requestTimestampMap_`.
+3. `recordResponseReceived` returns `void` — no fields to copy back to
+   `response`. Reporter buffers response data for the next emission
+   opportunity (and internally fires the v2 `rr` "response received"
+   event when configured).
 
 The shaka-specific extraction helpers
 (`getObjectType_`, `getBitrate_`, `getDuration_`, `getTopBitrate_`,
@@ -343,7 +356,7 @@ configures one event-reporting endpoint. Shape (post-rename):
 |---|---|---|
 | `url` | `string` | Endpoint URL for CMCD event reports |
 | `events` | `Array<CmcdEventType>` | Which events trigger reports (e.g., `[PLAY_STATE, ERROR, RESPONSE_RECEIVED]`); empty / undefined = none |
-| `timeInterval` | `number` *(seconds)* | Periodic time-interval reports (`0` disables; CML default per `CMCD_DEFAULT_TIME_INTERVAL`) |
+| `interval` | `number` *(seconds)* | Periodic time-interval reports (`0` disables; CML default `CMCD_DEFAULT_TIME_INTERVAL = 30`). Field name matches CML's `CmcdEventReportConfig.interval`. |
 | `batchSize` | `number` | Number of events to batch before dispatch (default `1` = no batching) |
 | `includeKeys` | `Array<CmcdKey>` *(was `enabledKeys`)* | Subset of CMCD keys to include in this target's reports |
 | `version` | `1 \| 2` | Per-target version override; defaults to top-level `version` |
@@ -355,8 +368,9 @@ matching hls.js PR #7725's pattern. The adapter renames `includeKeys` →
 
 Update [`externs/shaka/player.js`](externs/shaka/player.js)
 `shaka.extern.CmcdTarget` typedef to reflect this shape; existing fields
-in the typedef (e.g., `events`, `timeInterval`) stay; renamed field is
-`enabledKeys` → `includeKeys`.
+in the typedef (e.g., `events`) stay; renamed fields are
+`enabledKeys` → `includeKeys` and `timeInterval` → `interval` (matches
+CML's `CmcdEventReportConfig`).
 
 ### Player state ↔ reporter state mapping
 
@@ -378,14 +392,24 @@ state, then `recordEvent()` to emit a v2 event noting the transition.
 | Ended | `update({playerState: ENDED})` + `recordEvent(PLAY_STATE)` |
 | Fatal error | `update({playerState: FATAL_ERROR})` + `recordEvent(ERROR)` |
 | Variant switch (bitrate change) | `update({br: [newBitrate]})` + `recordEvent(BITRATE_CHANGE)` |
-| `setLowLatency(true)` + DASH | `update({streamingFormat: LOW_LATENCY_DASH})` |
-| `setLowLatency(true)` + HLS | `update({streamingFormat: LOW_LATENCY_HLS})` |
 | Content ID changes | `update({cid: newId})` (CML emits the v2 `c` event internally) |
 | Visibility → backgrounded | `update({backgrounded: bool})` (CML emits the v2 `b` event internally) |
 | Mute | `update({muted: true})` + `recordEvent(MUTE)` |
 | Unmute | `update({muted: false})` + `recordEvent(UNMUTE)` |
 | Throughput estimate update | `update({mtp: [bandwidthKbps]})` |
 
+**Streaming format and low-latency.** `sf` reflects the manifest type only
+(`'d'`/`'h'`/`'s'`/`'o'`) — not the low-latency state. shaka previously
+emitted `'ld'`/`'lh'` for LL DASH/HLS, but those values are not in
+CTA-5004 or CTA-5004-B; CML correctly omits them. Phase 1 drops the LL
+mutation in shaka's `setLowLatency` so that LL DASH emits `sf=d` and LL
+HLS emits `sf=h`. This is a wire-format change called out alongside
+`nor` URL relativization in the Phase 1 PR description.
+
+Also note manifest type is set once at load time and rarely changes; the
+adapter feeds `streamingFormat` via `update()` from the manifest parser,
+not from a `setLowLatency` callback.
+
 **Player-state deduplication.** Adapter tracks the last-emitted
 `playerState` and skips both `update` and `recordEvent` when the new state
 matches. Without this, `<video>` event listeners can fire repeatedly on
@@ -406,10 +430,13 @@ MSD is computed internally by `CmcdReporter`; the adapter does not feed it.
 
 ### Public-API back-compat details
 
-- **`shaka.util.CmcdManager.StreamingFormat`** stays available with identical
-  string values. Implemented as a re-export alias of
-  `cml.cmcd.CmcdStreamingFormat`. `@export` annotation preserved. Verified
-  values match: `'d'`, `'ld'`, `'h'`, `'lh'`, `'s'`, `'o'`.
+- **`shaka.util.CmcdManager.StreamingFormat`** stays available, implemented
+  as a re-export alias of `cml.cmcd.CmcdStreamingFormat`. `@export`
+  annotation preserved. Spec-conformant values: `'d'`, `'h'`, `'s'`, `'o'`.
+  shaka's previously-shipped non-spec values `'ld'` (LL-DASH) and `'lh'`
+  (LL-HLS) — from an old unreleased CMCD draft, not in CTA-5004 or
+  CTA-5004-B — are dropped in Phase 1. Wire-format change: LL DASH emits
+  `sf=d`, LL HLS emits `sf=h`.
 - **`shaka.util.CmcdManager.{ObjectType,Version,StreamType,CmcdKeys,CmcdV2Constants,CmcdV2Keys,CmcdMode}`**
   are all internal-only (no `@export`). Deleted in Phase 2; references rewritten to `cml.cmcd.*`.
 - **`externs/cmcd.js`** (`CmcdData` typedef): kept as the public-facing typedef
@@ -445,9 +472,11 @@ conservative API surface.
 
 ### Event-mode dispatch via NetworkingEngine
 
-`CmcdReporter` accepts a `requester: (req) => Promise<{status: number}>`
-config option for dispatching event-mode reports. **Event-mode transport is
-HTTP POST with a body** — CML constructs each event request as
+`CmcdReporter`'s constructor takes a `requester: (req) =>
+Promise<{status: number}>` callback as its **second positional argument**
+(not a `CmcdReporterConfig` field) for dispatching event-mode reports:
+`new CmcdReporter(reporterConfig, requesterFn)`. **Event-mode transport
+is HTTP POST with a body** — CML constructs each event request as
 `method: 'POST'` with the encoded CMCD payload in the body (per dash.js
 PR #4816's `Constants.CMCD_MODE_BODY` precedent and CML's reporter source).
 This is distinct from request-mode encoding (which mutates an existing
@@ -464,15 +493,10 @@ const requester = async (cmcdReq) => {
   shakaReq.method = cmcdReq.method || 'POST';
   shakaReq.headers = cmcdReq.headers || {};
 
-  // CML may emit body as string (structured-fields) or Blob (JSON).
-  // shaka.extern.Request.body expects BufferSource; convert:
-  if (typeof cmcdReq.body === 'string') {
-    shakaReq.body = shaka.util.StringUtils.toUTF8(cmcdReq.body);
-  } else if (cmcdReq.body instanceof Blob) {
-    shakaReq.body = await cmcdReq.body.arrayBuffer();
-  } else {
-    shakaReq.body = cmcdReq.body;  // already BufferSource
-  }
+  // CML's reporter always emits body as a string (structured-fields
+  // encoded by encodeCmcd, joined by '\n'). shaka.extern.Request.body
+  // expects BufferSource; convert via UTF-8.
+  shakaReq.body = shaka.util.StringUtils.toUTF8(cmcdReq.body);
 
   try {
     await this.networkingEngine_
@@ -508,7 +532,7 @@ upstream in CML if missing.
 | `reporter.recordEvent(eventType, data)` for discrete event emission | confirmed |
 | `reporter.createRequestReport(request, data)` for request-mode encoding | confirmed (CML signature: `R & CmcdRequestReport<R['customData']>`) |
 | `reporter.recordResponseReceived(response, data)` | confirmed |
-| `requester` config field for event-mode dispatch | confirmed (CML constructs `method: 'POST'` with body) |
+| `requester` constructor parameter (2nd positional arg) for event-mode dispatch | confirmed (CML constructs `method: 'POST'` with string body, `Content-Type: application/cmcd`) |
 | Built-in time-interval event timer | confirmed (reporter owns; shaka stops running its own) |
 | MSD computed internally by reporter | confirmed |
 | Sequence numbers per-target | likely present; verify per v2 spec |
@@ -588,9 +612,15 @@ behavior-preserving except where explicitly noted.
 - Apply config renames in [`externs/shaka/player.js`](externs/shaka/player.js):
   - `shaka.extern.CmcdConfiguration.targets` → `eventTargets`
   - `shaka.extern.CmcdTarget.enabledKeys` → `includeKeys`
+  - `shaka.extern.CmcdTarget.timeInterval` → `interval`
 - Add v2 re-exports: `shaka.util.CmcdManager.EventType` (alias of
   `cml.cmcd.CmcdEventType`), `shaka.util.CmcdManager.PlayerState` (alias of
   `cml.cmcd.CmcdPlayerState`).
+- **Wire-format changes (alignment with CML, intentional):** sequence
+  numbers shift from 1-based to 0-based (CML uses 0); request-mode `sn`
+  becomes a single global counter rather than scoped per-target-hash;
+  `sn` resets on `sid` change (CML's `resetSession` triggered from
+  `update()` when a new `sid` is set). Flag in PR description.
 - Update [`demo/`](demo/) to add a CMCD v2 configuration UI (transmission
   mode picker, version selector, eventTarget editor). Mirrors the
   precedent set by dash.js's `samples/cmcd/cmcd-v2.html` and
@@ -651,7 +681,7 @@ responsibilities. Target ~500 lines. Mocks `CmcdReporter` with a stub that
 records calls; asserts call sequences.
 
 - `RequestType` (MANIFEST, SEGMENT, LICENSE, KEY, TIMING) → `CmcdObjectType` mapping
-- `RequestContext.type` → `CmcdStreamingFormat` (DASH/LL-DASH/HLS/LL-HLS/Smooth/Other)
+- `RequestContext.type` → `CmcdStreamingFormat` (DASH/HLS/Smooth/Other; LL DASH and LL HLS map to plain DASH/HLS per CTA-5004-B)
 - `shaka.extern.CmcdConfiguration` → `cml.cmcd.CmcdReporterConfig` translation,
   including the experimental renames
 - Player-event listener wiring: simulate `<video>` events / player state

From a8d855179eff902d99f6e5a1c3e513490ea6095b Mon Sep 17 00:00:00 2001
From: Casey Occhialini <1508707+littlespex@users.noreply.github.com>
Date: Mon, 27 Apr 2026 21:19:50 -0700
Subject: [PATCH 08/64] chore(third_party): add cml-cmcd vendoring skeleton
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Adds the third_party/cml-cmcd/ directory with LICENSE, NOTICE, and
SUMMARY.txt copied from CML at tag cmcd-v2.3.0
(commit 22390e35dfbbe1e53d15648d3aace99cdf71f9dd). Source files in
subsequent commits.

CML and shaka-player both Apache 2.0; no license-compatibility issues.
This vendored port is transitional — once shaka migrates to TypeScript
(issue #8262), the directory deletes and `goog.require('cml.cmcd.X')`
becomes `import { X } from '@svta/cml-cmcd'`.
---
 third_party/SUMMARY.txt          |  16 +
 third_party/cml-cmcd/LICENSE     | 202 +++++++++
 third_party/cml-cmcd/NOTICE      | 684 +++++++++++++++++++++++++++++++
 third_party/cml-cmcd/SUMMARY.txt |  22 +
 4 files changed, 924 insertions(+)
 create mode 100644 third_party/cml-cmcd/LICENSE
 create mode 100644 third_party/cml-cmcd/NOTICE
 create mode 100644 third_party/cml-cmcd/SUMMARY.txt

diff --git a/third_party/SUMMARY.txt b/third_party/SUMMARY.txt
index 8471763e57..f7d5fa4322 100644
--- a/third_party/SUMMARY.txt
+++ b/third_party/SUMMARY.txt
@@ -5,6 +5,22 @@ closure-uri
   Local mods:
     - Library stripped down to just URI parsing, and that stripped of all deps
 
+cml-cmcd
+  Common Media Library CMCD encoder + reporter, v2.3.0,
+  by Streaming Video Technology Alliance / Casey Occhialini et al.
+  Apache 2.0 license.
+  https://github.com/streaming-video-technology-alliance/common-media-library
+    /tree/main/libs/cmcd
+  Source npm: @svta/cml-cmcd
+  TRANSITIONAL: vendored Closure port; deletes when shaka migrates to TypeScript
+  (#8262) and `goog.require('cml.cmcd.X')` becomes
+  `import { X } from '@svta/cml-cmcd'`.
+  Local mods:
+    - TypeScript source converted to Closure-annotated JS by hand
+    - Type-only imports erased; replaced with local closure typedefs
+    - Decoders, validators, predicates omitted (shaka emits CMCD; doesn't parse)
+    - cml-utils dep replaced with a 5-line uuid shim
+
 language-mapping-list
   A map of languages to their names, v0.0.16, by Ali Al Dallal / Mozilla.
   MIT license.
diff --git a/third_party/cml-cmcd/LICENSE b/third_party/cml-cmcd/LICENSE
new file mode 100644
index 0000000000..8ba558e38d
--- /dev/null
+++ b/third_party/cml-cmcd/LICENSE
@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2023 Streaming Video Technology Alliance
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/third_party/cml-cmcd/NOTICE b/third_party/cml-cmcd/NOTICE
new file mode 100644
index 0000000000..9d35f4460d
--- /dev/null
+++ b/third_party/cml-cmcd/NOTICE
@@ -0,0 +1,684 @@
+Streaming Video Technology Alliance Common Media Library Copyright (c) 2023
+Streaming Video Technology Alliance
+
+---
+
+The following implementations in this project are derived from the `hls.js`
+library (https://github.com/video-dev/hls.js/)
+
+- src/id3.ts
+- src/608.ts
+
+```
+Copyright (c) 2017 Dailymotion (http://www.dailymotion.com)
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+		http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+src/remux/mp4-generator.js and src/demux/exp-golomb.ts implementation in this project
+are derived from the HLS library for video.js (https://github.com/videojs/videojs-contrib-hls)
+
+That work is also covered by the Apache 2 License, following copyright:
+Copyright (c) 2013-2015 Brightcove
+
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+```
+
+---
+
+The following implementations in this project is derived from the
+`structured-field-values` library
+(https://github.com/Jxck/structured-field-values)
+
+- src/structuredfield.ts
+
+```
+MIT License
+
+Copyright (c) 2020 Jxck
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+```
+
+---
+
+The following implementation in this project is derived from the `dash.js`
+library (https://github.com/Dash-Industry-Forum/dash.js/)
+
+- src/608.ts
+
+```
+# dash.js BSD License Agreement
+
+The copyright in this software is being made available under the BSD License, included below. This software may be subject to other third party and contributor rights, including patent rights, and no such rights are granted under this license.
+
+**Copyright (c) 2015, Dash Industry Forum.
+**All rights reserved.**
+
+* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+* Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+* Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the  documentation and/or other materials provided with the distribution.
+* Neither the name of the Dash Industry Forum nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+**THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS “AS IS” AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.**
+```
+
+---
+
+The following implementation in this project is derived from the `shaka-player`
+library (https://github.com/shaka-project/shaka-player/)
+
+- src/dash/processUriTemplate.ts
+
+```
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+
+-----
+
+Contains code from https://github.com/mozilla/language-mapping-list
+
+The MIT License (MIT)
+
+Copyright (c) 2013 Ali Al Dallal
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+-----
+
+Contains code from https://github.com/Dash-Industry-Forum/dash.js
+(See lib/mss/mss_utils.js and lib/transmuxer/mss_transmuxer.js)
+
+dash.js BSD License Agreement
+
+Copyright 2015 Dash Industry Forum
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ - Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+ - Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+ - Neither the name of the Dash Industry Forum nor the names of its
+   contributors may be used to endorse or promote products derived from this
+   software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS “AS IS” AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+-----
+
+Contains code from https://github.com/TobiasNickel/tXml
+(See lib/util/tXml.js)
+
+tXml MIT License Agreement
+
+Copyright 2015 Tobias Nickel
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+-----
+
+Contains code from https://github.com/toji/gl-matrix
+(See ui/gl_matrix/matrix_4x4.js and ui/gl_matrix/matrix_quaternion.js)
+
+The MIT License (MIT)
+
+Copyright (c) 2015-2021, Brandon Jones, Colin MacKenzie IV.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE
+```
+
+---
+
+The following implementation in this project is derived from the `tXml` library
+(https://github.com/TobiasNickel/tXml)
+
+- src/utils/parseXml.ts
+
+```
+The MIT License (MIT)
+
+Copyright (c) 2015 Tobias Nickel
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+```
+
+---
+
+The following implementation in this project is derived from the
+`codem-isoboxer` library (https://github.com/Dash-Industry-Forum/codem-isoboxer)
+
+- src/iso/bmff/\*
+
+```
+Copyright (c) 2015 Hiro, Sjoerd Tieleman
+
+http://madebyhiro.com/
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+```
+
+---
+
+The following implementation in this project is derived from the
+`vtt.js` library (https://github.com/videojs/vtt.js)
+
+- src/webvtt/WebVttParser.ts
+
+```
+Copyright Brightcove, Inc. and contributors
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+```
+
+---
diff --git a/third_party/cml-cmcd/SUMMARY.txt b/third_party/cml-cmcd/SUMMARY.txt
new file mode 100644
index 0000000000..f2d5741768
--- /dev/null
+++ b/third_party/cml-cmcd/SUMMARY.txt
@@ -0,0 +1,22 @@
+cml-cmcd
+  Common Media Library CMCD encoder + reporter, v2.3.0,
+  by Streaming Video Technology Alliance / Casey Occhialini et al.
+  Apache 2.0 license.
+  https://github.com/streaming-video-technology-alliance/common-media-library
+    /tree/main/libs/cmcd
+  Source npm: @svta/cml-cmcd
+  Pinned tag: cmcd-v2.3.0
+  Pinned commit: 22390e35dfbbe1e53d15648d3aace99cdf71f9dd
+
+  TRANSITIONAL: This vendored port exists because shaka-player uses Closure
+  Compiler. When shaka migrates to TypeScript (issue #8262), delete this
+  directory and replace `goog.require('cml.cmcd.X')` with
+  `import { X } from '@svta/cml-cmcd'`.
+
+  Local mods:
+    - TypeScript source converted to Closure-annotated JS by hand
+    - Type-only imports erased; replaced with local closure typedefs
+    - Decoders (decodeCmcd, fromCmcd*) omitted: shaka emits CMCD only
+    - Validators (validateCmcd*, isCmcd*) omitted: tooling-only utilities
+    - cml-utils dep removed: shaka adapter always sets `sid` explicitly;
+      a 5-line cml_utils.js shim provides `uuid` for any dead default paths

From 0027abbe114b01e2682d544f6b9d4fa99af3290a Mon Sep 17 00:00:00 2001
From: Casey Occhialini <1508707+littlespex@users.noreply.github.com>
Date: Mon, 27 Apr 2026 21:25:27 -0700
Subject: [PATCH 09/64] chore(cmcd): port cml-cmcd type definitions as closure
 typedefs
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Adds 20 closure typedef files under cml.cmcd.* corresponding to CML's
type-only TypeScript modules in libs/cmcd/src/. Each file declares a
single namespaced @typedef with no runtime body.

Skipped from this commit (will land in Phase 1 sub-phase C alongside
CmcdReporter): CmcdReporterConfig, CmcdReportConfig, CmcdRequestReport,
CmcdRequestReportConfig, CmcdEventReportConfig — all reporter-only.

Translation notes:
- TypeScript intersection types (`A & B`) cannot be expressed in
  closure typedefs; the inheriting types (CmcdResponse, CmcdEvent,
  Cmcd) inline the resolved superset of fields directly. All members
  are optional, matching CML's "no key is mandatory" wire format.
- `keyof T` and `ValueOf<T>` constructs widen to `string` / `*`
  respectively. Effective key sets are enumerated by the constants
  ported in Task 1.4 (CMCD_KEYS, CMCD_REQUEST_KEYS, etc.).
- Structured-field `SfItem<T, ...>` wrappers cannot be statically
  expressed; CmcdObjectTypeList widens to `Array<*>` and CmcdFormatter
  return widens to `*`. Wire output is unaffected.
- Type-only TS imports erase; cross-typedef references use closure
  namespace lookup via `goog.require`.
---
 third_party/cml-cmcd/cmcd.js                  | 80 +++++++++++++++++++
 third_party/cml-cmcd/cmcd_custom_key.js       | 17 ++++
 third_party/cml-cmcd/cmcd_custom_value.js     | 19 +++++
 third_party/cml-cmcd/cmcd_data.js             | 26 ++++++
 third_party/cml-cmcd/cmcd_encode_options.js   | 31 +++++++
 third_party/cml-cmcd/cmcd_event.js            | 68 ++++++++++++++++
 third_party/cml-cmcd/cmcd_formatter.js        | 23 ++++++
 third_party/cml-cmcd/cmcd_formatter_map.js    | 18 +++++
 .../cml-cmcd/cmcd_formatter_options.js        | 24 ++++++
 third_party/cml-cmcd/cmcd_header_key.js       | 17 ++++
 third_party/cml-cmcd/cmcd_header_map.js       | 20 +++++
 third_party/cml-cmcd/cmcd_header_value.js     | 20 +++++
 third_party/cml-cmcd/cmcd_key.js              | 18 +++++
 third_party/cml-cmcd/cmcd_object_type_list.js | 20 +++++
 third_party/cml-cmcd/cmcd_request.js          | 70 ++++++++++++++++
 third_party/cml-cmcd/cmcd_request_key.js      | 17 ++++
 third_party/cml-cmcd/cmcd_response.js         | 74 +++++++++++++++++
 third_party/cml-cmcd/cmcd_v1.js               | 25 ++++++
 third_party/cml-cmcd/cmcd_value.js            | 18 +++++
 third_party/cml-cmcd/cmcd_version.js          | 18 +++++
 20 files changed, 623 insertions(+)
 create mode 100644 third_party/cml-cmcd/cmcd.js
 create mode 100644 third_party/cml-cmcd/cmcd_custom_key.js
 create mode 100644 third_party/cml-cmcd/cmcd_custom_value.js
 create mode 100644 third_party/cml-cmcd/cmcd_data.js
 create mode 100644 third_party/cml-cmcd/cmcd_encode_options.js
 create mode 100644 third_party/cml-cmcd/cmcd_event.js
 create mode 100644 third_party/cml-cmcd/cmcd_formatter.js
 create mode 100644 third_party/cml-cmcd/cmcd_formatter_map.js
 create mode 100644 third_party/cml-cmcd/cmcd_formatter_options.js
 create mode 100644 third_party/cml-cmcd/cmcd_header_key.js
 create mode 100644 third_party/cml-cmcd/cmcd_header_map.js
 create mode 100644 third_party/cml-cmcd/cmcd_header_value.js
 create mode 100644 third_party/cml-cmcd/cmcd_key.js
 create mode 100644 third_party/cml-cmcd/cmcd_object_type_list.js
 create mode 100644 third_party/cml-cmcd/cmcd_request.js
 create mode 100644 third_party/cml-cmcd/cmcd_request_key.js
 create mode 100644 third_party/cml-cmcd/cmcd_response.js
 create mode 100644 third_party/cml-cmcd/cmcd_v1.js
 create mode 100644 third_party/cml-cmcd/cmcd_value.js
 create mode 100644 third_party/cml-cmcd/cmcd_version.js

diff --git a/third_party/cml-cmcd/cmcd.js b/third_party/cml-cmcd/cmcd.js
new file mode 100644
index 0000000000..05fd28522a
--- /dev/null
+++ b/third_party/cml-cmcd/cmcd.js
@@ -0,0 +1,80 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.Cmcd');
+
+goog.require('cml.cmcd.CmcdEvent');
+goog.require('cml.cmcd.CmcdRequest');
+goog.require('cml.cmcd.CmcdResponse');
+
+
+/**
+ * Common Media Client Data (CMCD) version 2.
+ *
+ * The intersection of `CmcdRequest`, `CmcdResponse`, and `CmcdEvent`,
+ * combining all keys from all reporting modes.
+ *
+ * Closure typedefs cannot express type intersection; the resolved
+ * superset of fields lives on `cml.cmcd.CmcdResponse` already (which
+ * extends `CmcdRequest`) plus event-only fields from `CmcdEvent`.
+ * Callers should treat `cml.cmcd.Cmcd` as having any field that any
+ * of the three modes defines. All members optional.
+ *
+ * @see {@link https://cdn.cta.tech/cta/media/media/resources/standards/pdfs/cta-5004-final.pdf}
+ *
+ * @typedef {{
+ *   ab: (cml.cmcd.CmcdObjectTypeList|undefined),
+ *   bg: (boolean|undefined),
+ *   bl: (cml.cmcd.CmcdObjectTypeList|undefined),
+ *   br: (cml.cmcd.CmcdObjectTypeList|undefined),
+ *   bs: (boolean|undefined),
+ *   bsa: (cml.cmcd.CmcdObjectTypeList|undefined),
+ *   bsd: (cml.cmcd.CmcdObjectTypeList|undefined),
+ *   bsda: (cml.cmcd.CmcdObjectTypeList|undefined),
+ *   cdn: (string|undefined),
+ *   cen: (string|undefined),
+ *   cid: (string|undefined),
+ *   cmsdd: (string|undefined),
+ *   cmsds: (string|undefined),
+ *   cs: (string|undefined),
+ *   d: (number|undefined),
+ *   dfa: (number|undefined),
+ *   dl: (number|undefined),
+ *   e: (string|undefined),
+ *   ec: (!Array<string>|undefined),
+ *   h: (string|undefined),
+ *   lab: (cml.cmcd.CmcdObjectTypeList|undefined),
+ *   lb: (cml.cmcd.CmcdObjectTypeList|undefined),
+ *   ltc: (number|undefined),
+ *   msd: (number|undefined),
+ *   mtp: (cml.cmcd.CmcdObjectTypeList|undefined),
+ *   nor: (!Array<*>|undefined),
+ *   nr: (boolean|undefined),
+ *   ot: (string|undefined),
+ *   pb: (cml.cmcd.CmcdObjectTypeList|undefined),
+ *   pr: (number|undefined),
+ *   pt: (number|undefined),
+ *   rc: (number|undefined),
+ *   rtp: (number|undefined),
+ *   sf: (string|undefined),
+ *   sid: (string|undefined),
+ *   smrt: (string|undefined),
+ *   sn: (number|undefined),
+ *   st: (string|undefined),
+ *   sta: (string|undefined),
+ *   su: (boolean|undefined),
+ *   tab: (cml.cmcd.CmcdObjectTypeList|undefined),
+ *   tb: (cml.cmcd.CmcdObjectTypeList|undefined),
+ *   tbl: (cml.cmcd.CmcdObjectTypeList|undefined),
+ *   tpb: (cml.cmcd.CmcdObjectTypeList|undefined),
+ *   ts: (number|undefined),
+ *   ttfb: (number|undefined),
+ *   ttfbb: (number|undefined),
+ *   ttlb: (number|undefined),
+ *   url: (string|undefined),
+ *   v: (number|undefined)
+ * }}
+ */
+cml.cmcd.Cmcd;
diff --git a/third_party/cml-cmcd/cmcd_custom_key.js b/third_party/cml-cmcd/cmcd_custom_key.js
new file mode 100644
index 0000000000..7c6a1c54fb
--- /dev/null
+++ b/third_party/cml-cmcd/cmcd_custom_key.js
@@ -0,0 +1,17 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.CmcdCustomKey');
+
+
+/**
+ * A custom key for CMCD. Custom keys MUST carry a hyphenated prefix
+ * to ensure that there will not be a namespace collision with future
+ * revisions to this specification. Clients SHOULD use a reverse-DNS
+ * syntax when defining their own prefix.
+ *
+ * @typedef {string}
+ */
+cml.cmcd.CmcdCustomKey;
diff --git a/third_party/cml-cmcd/cmcd_custom_value.js b/third_party/cml-cmcd/cmcd_custom_value.js
new file mode 100644
index 0000000000..7e13455e9c
--- /dev/null
+++ b/third_party/cml-cmcd/cmcd_custom_value.js
@@ -0,0 +1,19 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.CmcdCustomValue');
+
+
+/**
+ * A value type for custom CMCD keys.
+ *
+ * Upstream CML's TypeScript union covers raw scalars, structured-fields
+ * `SfItem` wrappers, and arrays thereof. Closure cannot fully represent
+ * the structured-field item shapes statically; we widen to a permissive
+ * union that covers all wire-format-valid runtime shapes.
+ *
+ * @typedef {(string|number|boolean|symbol|!Array<*>|!Object)}
+ */
+cml.cmcd.CmcdCustomValue;
diff --git a/third_party/cml-cmcd/cmcd_data.js b/third_party/cml-cmcd/cmcd_data.js
new file mode 100644
index 0000000000..d9810c8f7f
--- /dev/null
+++ b/third_party/cml-cmcd/cmcd_data.js
@@ -0,0 +1,26 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.CmcdData');
+
+goog.require('cml.cmcd.Cmcd');
+
+
+/**
+ * A CMCD data object that is either version 1 or version 2.
+ *
+ * The `v` property acts as a discriminator: when `v === 2`, the type
+ * narrows to v2 with inner-list values and event/response keys; when
+ * `v === 1` or absent, the type narrows to v1 with scalar `bl`/`br`/
+ * `mtp`/`tb` and string `nor`.
+ *
+ * Upstream CML expresses this as `CmcdV1Data | CmcdV2Data`. Closure
+ * typedefs cannot express discriminated unions; we widen to the same
+ * superset as `cml.cmcd.Cmcd`. Callers must inspect `v` themselves
+ * when version-specific narrowing is required.
+ *
+ * @typedef {cml.cmcd.Cmcd}
+ */
+cml.cmcd.CmcdData;
diff --git a/third_party/cml-cmcd/cmcd_encode_options.js b/third_party/cml-cmcd/cmcd_encode_options.js
new file mode 100644
index 0000000000..534f9216b8
--- /dev/null
+++ b/third_party/cml-cmcd/cmcd_encode_options.js
@@ -0,0 +1,31 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.CmcdEncodeOptions');
+
+goog.require('cml.cmcd.CmcdFormatterMap');
+goog.require('cml.cmcd.CmcdHeaderMap');
+goog.require('cml.cmcd.CmcdKey');
+goog.require('cml.cmcd.CmcdVersion');
+
+
+/**
+ * Options for encoding CMCD values.
+ *
+ * `reportingMode` is a `cml.cmcd.CmcdReportingMode` value (`'request'`
+ * or `'event'`); we use plain `string` here to avoid a circular
+ * `goog.require` between this typedef and the reporting-mode enum.
+ *
+ * @typedef {{
+ *   version: (cml.cmcd.CmcdVersion|undefined),
+ *   reportingMode: (string|undefined),
+ *   formatters: (cml.cmcd.CmcdFormatterMap|undefined),
+ *   customHeaderMap: (cml.cmcd.CmcdHeaderMap|undefined),
+ *   filter: ((function(cml.cmcd.CmcdKey): boolean)|undefined),
+ *   baseUrl: (string|undefined),
+ *   events: (!Array<string>|undefined)
+ * }}
+ */
+cml.cmcd.CmcdEncodeOptions;
diff --git a/third_party/cml-cmcd/cmcd_event.js b/third_party/cml-cmcd/cmcd_event.js
new file mode 100644
index 0000000000..b335313beb
--- /dev/null
+++ b/third_party/cml-cmcd/cmcd_event.js
@@ -0,0 +1,68 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.CmcdEvent');
+
+goog.require('cml.cmcd.CmcdRequest');
+
+
+/**
+ * Common Media Client Data (CMCD) version 2 - Event Mode.
+ *
+ * Extends `cml.cmcd.CmcdRequest` with event-specific keys (`cen`, `e`,
+ * `h`, `ts`) for reporting events per the CMCD v2 specification.
+ *
+ * Upstream CML expresses this as `CmcdRequest & {event keys...}`.
+ * Closure typedefs cannot express type intersection; we list the union
+ * of all properties (request + event) directly. All members optional.
+ *
+ * @see {@link https://cta-wave.github.io/Resources/common-media-client-data--cta-5004-b.html#event-mode}
+ *
+ * @typedef {{
+ *   ab: (cml.cmcd.CmcdObjectTypeList|undefined),
+ *   bg: (boolean|undefined),
+ *   bl: (cml.cmcd.CmcdObjectTypeList|undefined),
+ *   br: (cml.cmcd.CmcdObjectTypeList|undefined),
+ *   bs: (boolean|undefined),
+ *   bsa: (cml.cmcd.CmcdObjectTypeList|undefined),
+ *   bsd: (cml.cmcd.CmcdObjectTypeList|undefined),
+ *   bsda: (cml.cmcd.CmcdObjectTypeList|undefined),
+ *   cdn: (string|undefined),
+ *   cen: (string|undefined),
+ *   cid: (string|undefined),
+ *   cs: (string|undefined),
+ *   d: (number|undefined),
+ *   dfa: (number|undefined),
+ *   dl: (number|undefined),
+ *   e: (string|undefined),
+ *   ec: (!Array<string>|undefined),
+ *   h: (string|undefined),
+ *   lab: (cml.cmcd.CmcdObjectTypeList|undefined),
+ *   lb: (cml.cmcd.CmcdObjectTypeList|undefined),
+ *   ltc: (number|undefined),
+ *   msd: (number|undefined),
+ *   mtp: (cml.cmcd.CmcdObjectTypeList|undefined),
+ *   nor: (!Array<*>|undefined),
+ *   nr: (boolean|undefined),
+ *   ot: (string|undefined),
+ *   pb: (cml.cmcd.CmcdObjectTypeList|undefined),
+ *   pr: (number|undefined),
+ *   pt: (number|undefined),
+ *   rtp: (number|undefined),
+ *   sf: (string|undefined),
+ *   sid: (string|undefined),
+ *   sn: (number|undefined),
+ *   st: (string|undefined),
+ *   sta: (string|undefined),
+ *   su: (boolean|undefined),
+ *   tab: (cml.cmcd.CmcdObjectTypeList|undefined),
+ *   tb: (cml.cmcd.CmcdObjectTypeList|undefined),
+ *   tbl: (cml.cmcd.CmcdObjectTypeList|undefined),
+ *   tpb: (cml.cmcd.CmcdObjectTypeList|undefined),
+ *   ts: (number|undefined),
+ *   v: (number|undefined)
+ * }}
+ */
+cml.cmcd.CmcdEvent;
diff --git a/third_party/cml-cmcd/cmcd_formatter.js b/third_party/cml-cmcd/cmcd_formatter.js
new file mode 100644
index 0000000000..cab6da04be
--- /dev/null
+++ b/third_party/cml-cmcd/cmcd_formatter.js
@@ -0,0 +1,23 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.CmcdFormatter');
+
+goog.require('cml.cmcd.CmcdFormatterOptions');
+goog.require('cml.cmcd.CmcdValue');
+
+
+/**
+ * A formatter for CMCD values.
+ *
+ * Upstream CML return type is
+ * `ValueOrArray<number | SfItem<number>> | ValueOrArray<string |
+ * SfItem<string>>`. Closure cannot express the structured-field-item
+ * wrappers; we widen the return to `*` for cross-formatter
+ * assignability.
+ *
+ * @typedef {function(cml.cmcd.CmcdValue, cml.cmcd.CmcdFormatterOptions): *}
+ */
+cml.cmcd.CmcdFormatter;
diff --git a/third_party/cml-cmcd/cmcd_formatter_map.js b/third_party/cml-cmcd/cmcd_formatter_map.js
new file mode 100644
index 0000000000..5b6bcf6ad6
--- /dev/null
+++ b/third_party/cml-cmcd/cmcd_formatter_map.js
@@ -0,0 +1,18 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.CmcdFormatterMap');
+
+goog.require('cml.cmcd.CmcdFormatter');
+
+
+/**
+ * A map of CMCD keys to format functions.
+ *
+ * Upstream CML: `Record<CmcdKey, CmcdFormatter>`.
+ *
+ * @typedef {!Object<string, cml.cmcd.CmcdFormatter>}
+ */
+cml.cmcd.CmcdFormatterMap;
diff --git a/third_party/cml-cmcd/cmcd_formatter_options.js b/third_party/cml-cmcd/cmcd_formatter_options.js
new file mode 100644
index 0000000000..bc3c9e197a
--- /dev/null
+++ b/third_party/cml-cmcd/cmcd_formatter_options.js
@@ -0,0 +1,24 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.CmcdFormatterOptions');
+
+goog.require('cml.cmcd.CmcdVersion');
+
+
+/**
+ * Options for formatting CMCD data values.
+ *
+ * `reportingMode` is a `cml.cmcd.CmcdReportingMode` value (`'request'`
+ * or `'event'`); we use plain `string` here to avoid a circular
+ * `goog.require` between this typedef and the reporting-mode enum.
+ *
+ * @typedef {{
+ *   version: cml.cmcd.CmcdVersion,
+ *   reportingMode: string,
+ *   baseUrl: (string|undefined)
+ * }}
+ */
+cml.cmcd.CmcdFormatterOptions;
diff --git a/third_party/cml-cmcd/cmcd_header_key.js b/third_party/cml-cmcd/cmcd_header_key.js
new file mode 100644
index 0000000000..529557a046
--- /dev/null
+++ b/third_party/cml-cmcd/cmcd_header_key.js
@@ -0,0 +1,17 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.CmcdHeaderKey');
+
+
+/**
+ * A CMCD header key — `keyof typeof CMCD_HEADER_MAP`.
+ *
+ * Closure cannot express `keyof T` statically; widen to `string`. The
+ * effective set is enumerated by the keys of `cml.cmcd.CMCD_HEADER_MAP`.
+ *
+ * @typedef {string}
+ */
+cml.cmcd.CmcdHeaderKey;
diff --git a/third_party/cml-cmcd/cmcd_header_map.js b/third_party/cml-cmcd/cmcd_header_map.js
new file mode 100644
index 0000000000..40318e3e11
--- /dev/null
+++ b/third_party/cml-cmcd/cmcd_header_map.js
@@ -0,0 +1,20 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.CmcdHeaderMap');
+
+goog.require('cml.cmcd.CmcdKey');
+
+
+/**
+ * A map of CMCD header fields (`CMCD-Object`, `CMCD-Request`,
+ * `CMCD-Session`, `CMCD-Status`) to the CMCD keys to include under
+ * each header.
+ *
+ * Upstream CML: `Record<CmcdHeaderField, CmcdKey[]>`.
+ *
+ * @typedef {!Object<string, !Array<cml.cmcd.CmcdKey>>}
+ */
+cml.cmcd.CmcdHeaderMap;
diff --git a/third_party/cml-cmcd/cmcd_header_value.js b/third_party/cml-cmcd/cmcd_header_value.js
new file mode 100644
index 0000000000..075057ec50
--- /dev/null
+++ b/third_party/cml-cmcd/cmcd_header_value.js
@@ -0,0 +1,20 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.CmcdHeaderValue');
+
+goog.require('cml.cmcd.CmcdRequest');
+goog.require('cml.cmcd.CmcdV1');
+
+
+/**
+ * A CMCD header value — `CmcdRequest | CmcdV1`.
+ *
+ * Closure typedefs cannot express type union of object types cleanly
+ * without `|`; we use the parenthesised union form.
+ *
+ * @typedef {(cml.cmcd.CmcdRequest|cml.cmcd.CmcdV1)}
+ */
+cml.cmcd.CmcdHeaderValue;
diff --git a/third_party/cml-cmcd/cmcd_key.js b/third_party/cml-cmcd/cmcd_key.js
new file mode 100644
index 0000000000..10ce0d44e4
--- /dev/null
+++ b/third_party/cml-cmcd/cmcd_key.js
@@ -0,0 +1,18 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.CmcdKey');
+
+
+/**
+ * A CMCD key — the union of every defined v1 and v2 wire key
+ * (`keyof Cmcd | keyof CmcdV1`).
+ *
+ * Closure cannot express `keyof T` statically; widen to `string`. The
+ * effective set at runtime is enumerated by `cml.cmcd.CMCD_KEYS`.
+ *
+ * @typedef {string}
+ */
+cml.cmcd.CmcdKey;
diff --git a/third_party/cml-cmcd/cmcd_object_type_list.js b/third_party/cml-cmcd/cmcd_object_type_list.js
new file mode 100644
index 0000000000..a0e71adbaf
--- /dev/null
+++ b/third_party/cml-cmcd/cmcd_object_type_list.js
@@ -0,0 +1,20 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.CmcdObjectTypeList');
+
+
+/**
+ * A numeric list with an optional object type boolean flag.
+ *
+ * Upstream CML type:
+ * `(number | SfItem<number, ExclusiveRecord<CmcdObjectType, boolean>>)[]`.
+ * The `SfItem` wrapper is structured-field metadata that closure cannot
+ * statically express; widen to `Array<*>` to cover both bare numbers
+ * and SfItem-wrapped numbers.
+ *
+ * @typedef {!Array<*>}
+ */
+cml.cmcd.CmcdObjectTypeList;
diff --git a/third_party/cml-cmcd/cmcd_request.js b/third_party/cml-cmcd/cmcd_request.js
new file mode 100644
index 0000000000..83f42dc168
--- /dev/null
+++ b/third_party/cml-cmcd/cmcd_request.js
@@ -0,0 +1,70 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.CmcdRequest');
+
+goog.require('cml.cmcd.CmcdObjectTypeList');
+
+
+/**
+ * Common Media Client Data (CMCD) version 2 - Request Mode.
+ *
+ * A standardized set of HTTP request header fields and query string
+ * parameters for communicating media playback metrics in request mode.
+ *
+ * Upstream CML uses an indexed signature for custom (`prefix-suffix`)
+ * keys; closure typedefs cannot express that, so callers may attach
+ * additional `string-string`-keyed properties as untyped extensions.
+ *
+ * The string-literal types for `ot`, `sf`, `sta`, `st` etc. are the
+ * `cml.cmcd.CmcdObjectType`, `cml.cmcd.CmcdStreamingFormat`,
+ * `cml.cmcd.CmcdPlayerState`, `cml.cmcd.CmcdStreamType` enum value
+ * unions. We use plain `string` here to keep the typedef self-contained
+ * and avoid circular `goog.require` between enum files and this typedef.
+ *
+ * @see {@link https://cta-wave.github.io/Resources/common-media-client-data--cta-5004-b.html#request-mode}
+ *
+ * @typedef {{
+ *   ab: (cml.cmcd.CmcdObjectTypeList|undefined),
+ *   bg: (boolean|undefined),
+ *   bl: (cml.cmcd.CmcdObjectTypeList|undefined),
+ *   br: (cml.cmcd.CmcdObjectTypeList|undefined),
+ *   bs: (boolean|undefined),
+ *   bsa: (cml.cmcd.CmcdObjectTypeList|undefined),
+ *   bsd: (cml.cmcd.CmcdObjectTypeList|undefined),
+ *   bsda: (cml.cmcd.CmcdObjectTypeList|undefined),
+ *   cdn: (string|undefined),
+ *   cid: (string|undefined),
+ *   cs: (string|undefined),
+ *   d: (number|undefined),
+ *   dfa: (number|undefined),
+ *   dl: (number|undefined),
+ *   ec: (!Array<string>|undefined),
+ *   lab: (cml.cmcd.CmcdObjectTypeList|undefined),
+ *   lb: (cml.cmcd.CmcdObjectTypeList|undefined),
+ *   ltc: (number|undefined),
+ *   msd: (number|undefined),
+ *   mtp: (cml.cmcd.CmcdObjectTypeList|undefined),
+ *   nor: (!Array<*>|undefined),
+ *   nr: (boolean|undefined),
+ *   ot: (string|undefined),
+ *   pb: (cml.cmcd.CmcdObjectTypeList|undefined),
+ *   pr: (number|undefined),
+ *   pt: (number|undefined),
+ *   rtp: (number|undefined),
+ *   sf: (string|undefined),
+ *   sid: (string|undefined),
+ *   sn: (number|undefined),
+ *   st: (string|undefined),
+ *   sta: (string|undefined),
+ *   su: (boolean|undefined),
+ *   tab: (cml.cmcd.CmcdObjectTypeList|undefined),
+ *   tb: (cml.cmcd.CmcdObjectTypeList|undefined),
+ *   tbl: (cml.cmcd.CmcdObjectTypeList|undefined),
+ *   tpb: (cml.cmcd.CmcdObjectTypeList|undefined),
+ *   v: (number|undefined)
+ * }}
+ */
+cml.cmcd.CmcdRequest;
diff --git a/third_party/cml-cmcd/cmcd_request_key.js b/third_party/cml-cmcd/cmcd_request_key.js
new file mode 100644
index 0000000000..0c3f57c224
--- /dev/null
+++ b/third_party/cml-cmcd/cmcd_request_key.js
@@ -0,0 +1,17 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.CmcdRequestKey');
+
+
+/**
+ * A CMCD request key — `keyof CmcdRequest | 'nrr'`.
+ *
+ * Closure cannot express `keyof T` statically; widen to `string`. The
+ * effective set is enumerated by `cml.cmcd.CMCD_REQUEST_KEYS`.
+ *
+ * @typedef {string}
+ */
+cml.cmcd.CmcdRequestKey;
diff --git a/third_party/cml-cmcd/cmcd_response.js b/third_party/cml-cmcd/cmcd_response.js
new file mode 100644
index 0000000000..ae6234d953
--- /dev/null
+++ b/third_party/cml-cmcd/cmcd_response.js
@@ -0,0 +1,74 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.CmcdResponse');
+
+goog.require('cml.cmcd.CmcdRequest');
+
+
+/**
+ * Common Media Client Data (CMCD) version 2 - Response Mode.
+ *
+ * Extends `cml.cmcd.CmcdRequest` with response-specific keys
+ * (`cmsdd`, `cmsds`, `rc`, `smrt`, `ttfb`, `ttfbb`, `ttlb`, `url`)
+ * for reporting response data per the CMCD v2 specification. These
+ * keys MUST only be reported on events of type `rr` (response received).
+ *
+ * Upstream CML expresses this as `CmcdRequest & {response keys...}`.
+ * Closure typedefs cannot express type intersection; we list the union
+ * of all properties (request + response) directly. All members optional.
+ *
+ * @see {@link https://cta-wave.github.io/Resources/common-media-client-data--cta-5004-b.html#response-mode}
+ *
+ * @typedef {{
+ *   ab: (cml.cmcd.CmcdObjectTypeList|undefined),
+ *   bg: (boolean|undefined),
+ *   bl: (cml.cmcd.CmcdObjectTypeList|undefined),
+ *   br: (cml.cmcd.CmcdObjectTypeList|undefined),
+ *   bs: (boolean|undefined),
+ *   bsa: (cml.cmcd.CmcdObjectTypeList|undefined),
+ *   bsd: (cml.cmcd.CmcdObjectTypeList|undefined),
+ *   bsda: (cml.cmcd.CmcdObjectTypeList|undefined),
+ *   cdn: (string|undefined),
+ *   cid: (string|undefined),
+ *   cmsdd: (string|undefined),
+ *   cmsds: (string|undefined),
+ *   cs: (string|undefined),
+ *   d: (number|undefined),
+ *   dfa: (number|undefined),
+ *   dl: (number|undefined),
+ *   ec: (!Array<string>|undefined),
+ *   lab: (cml.cmcd.CmcdObjectTypeList|undefined),
+ *   lb: (cml.cmcd.CmcdObjectTypeList|undefined),
+ *   ltc: (number|undefined),
+ *   msd: (number|undefined),
+ *   mtp: (cml.cmcd.CmcdObjectTypeList|undefined),
+ *   nor: (!Array<*>|undefined),
+ *   nr: (boolean|undefined),
+ *   ot: (string|undefined),
+ *   pb: (cml.cmcd.CmcdObjectTypeList|undefined),
+ *   pr: (number|undefined),
+ *   pt: (number|undefined),
+ *   rc: (number|undefined),
+ *   rtp: (number|undefined),
+ *   sf: (string|undefined),
+ *   sid: (string|undefined),
+ *   smrt: (string|undefined),
+ *   sn: (number|undefined),
+ *   st: (string|undefined),
+ *   sta: (string|undefined),
+ *   su: (boolean|undefined),
+ *   tab: (cml.cmcd.CmcdObjectTypeList|undefined),
+ *   tb: (cml.cmcd.CmcdObjectTypeList|undefined),
+ *   tbl: (cml.cmcd.CmcdObjectTypeList|undefined),
+ *   tpb: (cml.cmcd.CmcdObjectTypeList|undefined),
+ *   ttfb: (number|undefined),
+ *   ttfbb: (number|undefined),
+ *   ttlb: (number|undefined),
+ *   url: (string|undefined),
+ *   v: (number|undefined)
+ * }}
+ */
+cml.cmcd.CmcdResponse;
diff --git a/third_party/cml-cmcd/cmcd_v1.js b/third_party/cml-cmcd/cmcd_v1.js
new file mode 100644
index 0000000000..8199527e2d
--- /dev/null
+++ b/third_party/cml-cmcd/cmcd_v1.js
@@ -0,0 +1,25 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.CmcdV1');
+
+
+/**
+ * CMCD Version 1 data shape.
+ *
+ * Overrides keys whose types differ from CMCD v2 (`bl`, `br`, `mtp`,
+ * `tb` are scalar integers in v1 instead of inner-list values; `nor`
+ * is a single relative path string).
+ *
+ * @typedef {{
+ *   bl: (number|undefined),
+ *   br: (number|undefined),
+ *   mtp: (number|undefined),
+ *   nor: (string|undefined),
+ *   nrr: (string|undefined),
+ *   tb: (number|undefined)
+ * }}
+ */
+cml.cmcd.CmcdV1;
diff --git a/third_party/cml-cmcd/cmcd_value.js b/third_party/cml-cmcd/cmcd_value.js
new file mode 100644
index 0000000000..e031269601
--- /dev/null
+++ b/third_party/cml-cmcd/cmcd_value.js
@@ -0,0 +1,18 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.CmcdValue');
+
+
+/**
+ * A CMCD value — `ValueOf<Cmcd>`. Any concrete value that may appear
+ * for some key in a CMCD payload (number, string, boolean, list, etc.).
+ *
+ * Closure cannot express `ValueOf<T>` statically; widen to the unrestricted
+ * runtime union. Encoders narrow further at the call site.
+ *
+ * @typedef {*}
+ */
+cml.cmcd.CmcdValue;
diff --git a/third_party/cml-cmcd/cmcd_version.js b/third_party/cml-cmcd/cmcd_version.js
new file mode 100644
index 0000000000..48e4603d2e
--- /dev/null
+++ b/third_party/cml-cmcd/cmcd_version.js
@@ -0,0 +1,18 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.CmcdVersion');
+
+
+/**
+ * The version of the CMCD specification — `1` (`CMCD_V1`) or `2`
+ * (`CMCD_V2`).
+ *
+ * Upstream CML uses `typeof CMCD_V1 | typeof CMCD_V2`; closure can
+ * express this as a literal numeric union.
+ *
+ * @typedef {number}
+ */
+cml.cmcd.CmcdVersion;

From ae92000c7613dbae360b276449dd41fd2b2f0985 Mon Sep 17 00:00:00 2001
From: Casey Occhialini <1508707+littlespex@users.noreply.github.com>
Date: Mon, 27 Apr 2026 21:26:47 -0700
Subject: [PATCH 10/64] chore(cmcd): port cml-cmcd enums to closure
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Adds 8 closure @enum {string} files under cml.cmcd.*:

- cmcd_object_type.js
- cmcd_streaming_format.js  (DASH/HLS/SMOOTH/OTHER — no LL variants)
- cmcd_stream_type.js
- cmcd_player_state.js
- cmcd_event_type.js
- cmcd_reporting_mode.js
- cmcd_transmission_mode.js
- cmcd_header_field.js

Enum string values verified verbatim against CML cmcd-v2.3.0 source
(`libs/cmcd/src/Cmcd*.ts`). For enum files that also expose individual
named-constant exports (CmcdEventType, CmcdReportingMode,
CmcdTransmissionMode, CmcdHeaderField), each `export const X = 'literal'`
becomes a separate `goog.provide`d `cml.cmcd.X` constant alongside the
enum so consumers can `goog.require` either form.
---
 third_party/cml-cmcd/cmcd_event_type.js       | 238 ++++++++++++++++++
 third_party/cml-cmcd/cmcd_header_field.js     |  82 ++++++
 third_party/cml-cmcd/cmcd_object_type.js      |  61 +++++
 third_party/cml-cmcd/cmcd_player_state.js     |  69 +++++
 third_party/cml-cmcd/cmcd_reporting_mode.js   |  41 +++
 third_party/cml-cmcd/cmcd_stream_type.js      |  31 +++
 third_party/cml-cmcd/cmcd_streaming_format.js |  36 +++
 .../cml-cmcd/cmcd_transmission_mode.js        |  60 +++++
 8 files changed, 618 insertions(+)
 create mode 100644 third_party/cml-cmcd/cmcd_event_type.js
 create mode 100644 third_party/cml-cmcd/cmcd_header_field.js
 create mode 100644 third_party/cml-cmcd/cmcd_object_type.js
 create mode 100644 third_party/cml-cmcd/cmcd_player_state.js
 create mode 100644 third_party/cml-cmcd/cmcd_reporting_mode.js
 create mode 100644 third_party/cml-cmcd/cmcd_stream_type.js
 create mode 100644 third_party/cml-cmcd/cmcd_streaming_format.js
 create mode 100644 third_party/cml-cmcd/cmcd_transmission_mode.js

diff --git a/third_party/cml-cmcd/cmcd_event_type.js b/third_party/cml-cmcd/cmcd_event_type.js
new file mode 100644
index 0000000000..af674420ab
--- /dev/null
+++ b/third_party/cml-cmcd/cmcd_event_type.js
@@ -0,0 +1,238 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.CMCD_EVENT_AD_BREAK_END');
+goog.provide('cml.cmcd.CMCD_EVENT_AD_BREAK_START');
+goog.provide('cml.cmcd.CMCD_EVENT_AD_END');
+goog.provide('cml.cmcd.CMCD_EVENT_AD_START');
+goog.provide('cml.cmcd.CMCD_EVENT_BACKGROUNDED_MODE');
+goog.provide('cml.cmcd.CMCD_EVENT_BITRATE_CHANGE');
+goog.provide('cml.cmcd.CMCD_EVENT_CONTENT_ID');
+goog.provide('cml.cmcd.CMCD_EVENT_CUSTOM_EVENT');
+goog.provide('cml.cmcd.CMCD_EVENT_ERROR');
+goog.provide('cml.cmcd.CMCD_EVENT_MUTE');
+goog.provide('cml.cmcd.CMCD_EVENT_PLAYER_COLLAPSE');
+goog.provide('cml.cmcd.CMCD_EVENT_PLAYER_EXPAND');
+goog.provide('cml.cmcd.CMCD_EVENT_PLAY_STATE');
+goog.provide('cml.cmcd.CMCD_EVENT_RESPONSE_RECEIVED');
+goog.provide('cml.cmcd.CMCD_EVENT_SKIP');
+goog.provide('cml.cmcd.CMCD_EVENT_TIME_INTERVAL');
+goog.provide('cml.cmcd.CMCD_EVENT_UNMUTE');
+goog.provide('cml.cmcd.CmcdEventType');
+
+
+/**
+ * CMCD event type for the 'bc' key (bitrate change).
+ *
+ * @const {string}
+ */
+cml.cmcd.CMCD_EVENT_BITRATE_CHANGE = 'bc';
+
+/**
+ * CMCD event type for the 'ps' key (play state change).
+ *
+ * @const {string}
+ */
+cml.cmcd.CMCD_EVENT_PLAY_STATE = 'ps';
+
+/**
+ * CMCD event type for the 'e' key (error).
+ *
+ * @const {string}
+ */
+cml.cmcd.CMCD_EVENT_ERROR = 'e';
+
+/**
+ * CMCD event type for the 't' key (time interval).
+ *
+ * @const {string}
+ */
+cml.cmcd.CMCD_EVENT_TIME_INTERVAL = 't';
+
+/**
+ * CMCD event type for the 'c' key (content ID).
+ *
+ * @const {string}
+ */
+cml.cmcd.CMCD_EVENT_CONTENT_ID = 'c';
+
+/**
+ * CMCD event type for the 'b' key (backgrounded mode).
+ *
+ * @const {string}
+ */
+cml.cmcd.CMCD_EVENT_BACKGROUNDED_MODE = 'b';
+
+/**
+ * CMCD event type for the 'm' key (mute).
+ *
+ * @const {string}
+ */
+cml.cmcd.CMCD_EVENT_MUTE = 'm';
+
+/**
+ * CMCD event type for the 'um' key (unmute).
+ *
+ * @const {string}
+ */
+cml.cmcd.CMCD_EVENT_UNMUTE = 'um';
+
+/**
+ * CMCD event type for the 'pe' key (player expand).
+ *
+ * @const {string}
+ */
+cml.cmcd.CMCD_EVENT_PLAYER_EXPAND = 'pe';
+
+/**
+ * CMCD event type for the 'pc' key (player collapse).
+ *
+ * @const {string}
+ */
+cml.cmcd.CMCD_EVENT_PLAYER_COLLAPSE = 'pc';
+
+/**
+ * CMCD event type for the 'rr' key (response received).
+ *
+ * @const {string}
+ */
+cml.cmcd.CMCD_EVENT_RESPONSE_RECEIVED = 'rr';
+
+/**
+ * CMCD event type for the 'as' key (ad start).
+ *
+ * @const {string}
+ */
+cml.cmcd.CMCD_EVENT_AD_START = 'as';
+
+/**
+ * CMCD event type for the 'ae' key (ad end).
+ *
+ * @const {string}
+ */
+cml.cmcd.CMCD_EVENT_AD_END = 'ae';
+
+/**
+ * CMCD event type for the 'abs' key (ad break start).
+ *
+ * @const {string}
+ */
+cml.cmcd.CMCD_EVENT_AD_BREAK_START = 'abs';
+
+/**
+ * CMCD event type for the 'abe' key (ad break end).
+ *
+ * @const {string}
+ */
+cml.cmcd.CMCD_EVENT_AD_BREAK_END = 'abe';
+
+/**
+ * CMCD event type for the 'sk' key (skip).
+ *
+ * @const {string}
+ */
+cml.cmcd.CMCD_EVENT_SKIP = 'sk';
+
+/**
+ * CMCD event type for the 'ce' key (custom event).
+ *
+ * @const {string}
+ */
+cml.cmcd.CMCD_EVENT_CUSTOM_EVENT = 'ce';
+
+
+/**
+ * CMCD event types for the `e` key (event mode).
+ *
+ * @see {@link https://cta-wave.github.io/Resources/common-media-client-data--cta-5004-b.html#event}
+ *
+ * @enum {string}
+ */
+cml.cmcd.CmcdEventType = {
+  /**
+   * A change in the bitrate.
+   */
+  BITRATE_CHANGE: cml.cmcd.CMCD_EVENT_BITRATE_CHANGE,
+
+  /**
+   * A change in the player state.
+   */
+  PLAY_STATE: cml.cmcd.CMCD_EVENT_PLAY_STATE,
+
+  /**
+   * An error event.
+   */
+  ERROR: cml.cmcd.CMCD_EVENT_ERROR,
+
+  /**
+   * A periodic report sent on a time interval.
+   */
+  TIME_INTERVAL: cml.cmcd.CMCD_EVENT_TIME_INTERVAL,
+
+  /**
+   * A change of the content ID.
+   */
+  CONTENT_ID: cml.cmcd.CMCD_EVENT_CONTENT_ID,
+
+  /**
+   * A change in the application's backgrounded state.
+   */
+  BACKGROUNDED_MODE: cml.cmcd.CMCD_EVENT_BACKGROUNDED_MODE,
+
+  /**
+   * The player was muted.
+   */
+  MUTE: cml.cmcd.CMCD_EVENT_MUTE,
+
+  /**
+   * Player unmuted.
+   */
+  UNMUTE: cml.cmcd.CMCD_EVENT_UNMUTE,
+
+  /**
+   * The player view was expanded.
+   */
+  PLAYER_EXPAND: cml.cmcd.CMCD_EVENT_PLAYER_EXPAND,
+
+  /**
+   * The player view was collapsed.
+   */
+  PLAYER_COLLAPSE: cml.cmcd.CMCD_EVENT_PLAYER_COLLAPSE,
+
+  /**
+   * The receipt of a response.
+   */
+  RESPONSE_RECEIVED: cml.cmcd.CMCD_EVENT_RESPONSE_RECEIVED,
+
+  /**
+   * The start of an ad.
+   */
+  AD_START: cml.cmcd.CMCD_EVENT_AD_START,
+
+  /**
+   * The end of an ad.
+   */
+  AD_END: cml.cmcd.CMCD_EVENT_AD_END,
+
+  /**
+   * The start of an ad break.
+   */
+  AD_BREAK_START: cml.cmcd.CMCD_EVENT_AD_BREAK_START,
+
+  /**
+   * The end of an ad break.
+   */
+  AD_BREAK_END: cml.cmcd.CMCD_EVENT_AD_BREAK_END,
+
+  /**
+   * The user skipped an ad.
+   */
+  SKIP: cml.cmcd.CMCD_EVENT_SKIP,
+
+  /**
+   * A custom event.
+   */
+  CUSTOM_EVENT: cml.cmcd.CMCD_EVENT_CUSTOM_EVENT,
+};
diff --git a/third_party/cml-cmcd/cmcd_header_field.js b/third_party/cml-cmcd/cmcd_header_field.js
new file mode 100644
index 0000000000..6ad7e0d8a3
--- /dev/null
+++ b/third_party/cml-cmcd/cmcd_header_field.js
@@ -0,0 +1,82 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.CMCD_HEADER_FIELDS');
+goog.provide('cml.cmcd.CMCD_OBJECT');
+goog.provide('cml.cmcd.CMCD_REQUEST');
+goog.provide('cml.cmcd.CMCD_SESSION');
+goog.provide('cml.cmcd.CMCD_STATUS');
+goog.provide('cml.cmcd.CmcdHeaderField');
+
+
+/**
+ * CMCD object header name.
+ *
+ * @const {string}
+ */
+cml.cmcd.CMCD_OBJECT = 'CMCD-Object';
+
+/**
+ * CMCD request header name.
+ *
+ * @const {string}
+ */
+cml.cmcd.CMCD_REQUEST = 'CMCD-Request';
+
+/**
+ * CMCD session header name.
+ *
+ * @const {string}
+ */
+cml.cmcd.CMCD_SESSION = 'CMCD-Session';
+
+/**
+ * CMCD status header name.
+ *
+ * @const {string}
+ */
+cml.cmcd.CMCD_STATUS = 'CMCD-Status';
+
+
+/**
+ * CMCD header fields.
+ *
+ * @enum {string}
+ */
+cml.cmcd.CmcdHeaderField = {
+  /**
+   * keys whose values vary with the object being requested.
+   */
+  OBJECT: cml.cmcd.CMCD_OBJECT,
+
+  /**
+   * keys whose values vary with each request.
+   */
+  REQUEST: cml.cmcd.CMCD_REQUEST,
+
+  /**
+   * keys whose values are expected to be invariant over the life of
+   * the session.
+   */
+  SESSION: cml.cmcd.CMCD_SESSION,
+
+  /**
+   * keys whose values do not vary with every request or object.
+   */
+  STATUS: cml.cmcd.CMCD_STATUS,
+};
+
+
+/**
+ * All CMCD header fields as an array.
+ *
+ * @const {!Array<string>}
+ */
+cml.cmcd.CMCD_HEADER_FIELDS = [
+  cml.cmcd.CMCD_OBJECT,
+  cml.cmcd.CMCD_REQUEST,
+  cml.cmcd.CMCD_SESSION,
+  cml.cmcd.CMCD_STATUS,
+];
diff --git a/third_party/cml-cmcd/cmcd_object_type.js b/third_party/cml-cmcd/cmcd_object_type.js
new file mode 100644
index 0000000000..3680255194
--- /dev/null
+++ b/third_party/cml-cmcd/cmcd_object_type.js
@@ -0,0 +1,61 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.CmcdObjectType');
+
+
+/**
+ * Common Media Client Data Object Type — values for the `ot` key.
+ *
+ * @see {@link https://cta-wave.github.io/Resources/common-media-client-data--cta-5004-b.html#object-type}
+ *
+ * @enum {string}
+ */
+cml.cmcd.CmcdObjectType = {
+  /**
+   * text file, such as a manifest or playlist
+   */
+  MANIFEST: 'm',
+
+  /**
+   * audio only
+   */
+  AUDIO: 'a',
+
+  /**
+   * video only
+   */
+  VIDEO: 'v',
+
+  /**
+   * muxed audio and video
+   */
+  MUXED: 'av',
+
+  /**
+   * init segment
+   */
+  INIT: 'i',
+
+  /**
+   * caption or subtitle
+   */
+  CAPTION: 'c',
+
+  /**
+   * ISOBMFF timed text track
+   */
+  TIMED_TEXT: 'tt',
+
+  /**
+   * cryptographic key, license or certificate.
+   */
+  KEY: 'k',
+
+  /**
+   * other
+   */
+  OTHER: 'o',
+};
diff --git a/third_party/cml-cmcd/cmcd_player_state.js b/third_party/cml-cmcd/cmcd_player_state.js
new file mode 100644
index 0000000000..a507c385fd
--- /dev/null
+++ b/third_party/cml-cmcd/cmcd_player_state.js
@@ -0,0 +1,69 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.CmcdPlayerState');
+
+
+/**
+ * CMCD v2 player states for the `sta` key.
+ *
+ * @see {@link https://cta-wave.github.io/Resources/common-media-client-data--cta-5004-b.html#state}
+ *
+ * @enum {string}
+ */
+cml.cmcd.CmcdPlayerState = {
+  /**
+   * Starting: Initial startup of the player.
+   */
+  STARTING: 's',
+
+  /**
+   * Playing: The player is actively rendering content.
+   */
+  PLAYING: 'p',
+
+  /**
+   * Seeking: The player is seeking to a new position.
+   */
+  SEEKING: 'k',
+
+  /**
+   * Rebuffering: The player is buffering data during playback.
+   */
+  REBUFFERING: 'r',
+
+  /**
+   * Paused: The player is paused.
+   */
+  PAUSED: 'a',
+
+  /**
+   * Waiting: The player is waiting for a user action or another event.
+   */
+  WAITING: 'w',
+
+  /**
+   * Ended: The media has finished playing.
+   */
+  ENDED: 'e',
+
+  /**
+   * Fatal Error: The player has encountered a fatal error.
+   */
+  FATAL_ERROR: 'f',
+
+  /**
+   * Quit: User initiated end of playback before media asset
+   * completion.
+   */
+  QUIT: 'q',
+
+  /**
+   * Preloading: The player is loading assets ahead of starting in
+   * order to provide a fast startup. The expectation is that
+   * playback will commence at a future time.
+   */
+  PRELOADING: 'd',
+};
diff --git a/third_party/cml-cmcd/cmcd_reporting_mode.js b/third_party/cml-cmcd/cmcd_reporting_mode.js
new file mode 100644
index 0000000000..0cd0f64bd3
--- /dev/null
+++ b/third_party/cml-cmcd/cmcd_reporting_mode.js
@@ -0,0 +1,41 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.CMCD_EVENT_MODE');
+goog.provide('cml.cmcd.CMCD_REQUEST_MODE');
+goog.provide('cml.cmcd.CmcdReportingMode');
+
+
+/**
+ * CMCD event mode variable name.
+ *
+ * @const {string}
+ */
+cml.cmcd.CMCD_EVENT_MODE = 'event';
+
+/**
+ * CMCD request mode variable name.
+ *
+ * @const {string}
+ */
+cml.cmcd.CMCD_REQUEST_MODE = 'request';
+
+
+/**
+ * CMCD reporting mode types.
+ *
+ * @enum {string}
+ */
+cml.cmcd.CmcdReportingMode = {
+  /**
+   * Request mode
+   */
+  REQUEST: cml.cmcd.CMCD_REQUEST_MODE,
+
+  /**
+   * Event mode
+   */
+  EVENT: cml.cmcd.CMCD_EVENT_MODE,
+};
diff --git a/third_party/cml-cmcd/cmcd_stream_type.js b/third_party/cml-cmcd/cmcd_stream_type.js
new file mode 100644
index 0000000000..e963ea31d2
--- /dev/null
+++ b/third_party/cml-cmcd/cmcd_stream_type.js
@@ -0,0 +1,31 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.CmcdStreamType');
+
+
+/**
+ * Common Media Client Data Stream Type — values for the `st` key.
+ *
+ * @see {@link https://cta-wave.github.io/Resources/common-media-client-data--cta-5004-b.html#stream-type}
+ *
+ * @enum {string}
+ */
+cml.cmcd.CmcdStreamType = {
+  /**
+   * All segments are available – e.g., VOD
+   */
+  VOD: 'v',
+
+  /**
+   * Segments become available over time – e.g., LIVE
+   */
+  LIVE: 'l',
+
+  /**
+   * Low latency stream
+   */
+  LOW_LATENCY: 'll',
+};
diff --git a/third_party/cml-cmcd/cmcd_streaming_format.js b/third_party/cml-cmcd/cmcd_streaming_format.js
new file mode 100644
index 0000000000..041bebbeb9
--- /dev/null
+++ b/third_party/cml-cmcd/cmcd_streaming_format.js
@@ -0,0 +1,36 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.CmcdStreamingFormat');
+
+
+/**
+ * Common Media Client Data Streaming Format — values for the `sf` key.
+ *
+ * @see {@link https://cta-wave.github.io/Resources/common-media-client-data--cta-5004-b.html#streaming-format}
+ *
+ * @enum {string}
+ */
+cml.cmcd.CmcdStreamingFormat = {
+  /**
+   * MPEG DASH
+   */
+  DASH: 'd',
+
+  /**
+   * HTTP Live Streaming (HLS)
+   */
+  HLS: 'h',
+
+  /**
+   * Smooth Streaming
+   */
+  SMOOTH: 's',
+
+  /**
+   * Other
+   */
+  OTHER: 'o',
+};
diff --git a/third_party/cml-cmcd/cmcd_transmission_mode.js b/third_party/cml-cmcd/cmcd_transmission_mode.js
new file mode 100644
index 0000000000..bf4c62057d
--- /dev/null
+++ b/third_party/cml-cmcd/cmcd_transmission_mode.js
@@ -0,0 +1,60 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.CMCD_HEADERS');
+goog.provide('cml.cmcd.CMCD_JSON');
+goog.provide('cml.cmcd.CMCD_QUERY');
+goog.provide('cml.cmcd.CmcdTransmissionMode');
+
+
+/**
+ * CMCD `query` transmission mode.
+ *
+ * @const {string}
+ */
+cml.cmcd.CMCD_QUERY = 'query';
+
+/**
+ * CMCD `headers` transmission mode.
+ *
+ * @const {string}
+ */
+cml.cmcd.CMCD_HEADERS = 'headers';
+
+/**
+ * CMCD `json` transmission mode.
+ *
+ * @deprecated JSON transmission mode is deprecated and will be removed
+ *     in future versions.
+ *
+ * @const {string}
+ */
+cml.cmcd.CMCD_JSON = 'json';
+
+
+/**
+ * CMCD transmission modes.
+ *
+ * @enum {string}
+ */
+cml.cmcd.CmcdTransmissionMode = {
+  /**
+   * JSON
+   *
+   * @deprecated JSON transmission mode is deprecated and will be
+   *     removed in future versions.
+   */
+  JSON: cml.cmcd.CMCD_JSON,
+
+  /**
+   * Query string
+   */
+  QUERY: cml.cmcd.CMCD_QUERY,
+
+  /**
+   * Request headers
+   */
+  HEADERS: cml.cmcd.CMCD_HEADERS,
+};

From c4d84a2d82be7b1e247f331bcd93f0fb4596af45 Mon Sep 17 00:00:00 2001
From: Casey Occhialini <1508707+littlespex@users.noreply.github.com>
Date: Mon, 27 Apr 2026 21:29:22 -0700
Subject: [PATCH 11/64] chore(cmcd): port cml-cmcd constants to closure
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Adds 15 constant-module files under cml.cmcd.* corresponding to CML's
data-only constant modules:

- cmcd_default_time_interval.js
- cmcd_event_keys.js
- cmcd_header_map_const.js  (the data; CmcdHeaderField enum is separate)
- cmcd_inner_list_keys.js  (Set instance)
- cmcd_key_types.js  (CMCD_KEY_TYPES + CMCD_V1_KEY_TYPE_OVERRIDES)
- cmcd_keys.js  (composed from request/response/event/v1 lists)
- cmcd_mime_type.js  (application/cmcd)
- cmcd_param.js  (the CMCD query param name)
- cmcd_request_keys.js
- cmcd_response_keys.js
- cmcd_string_length_limits.js  (+CMCD_CUSTOM_KEY_VALUE_MAX_LENGTH)
- cmcd_token_values.js
- cmcd_v1_const.js  (the numeric `CMCD_V1 = 1` constant)
- cmcd_v1_keys.js
- cmcd_v2_const.js  (the numeric `CMCD_V2 = 2` constant)

Naming note: TS files `CmcdV1.ts` (typedef) and `CMCD_V1.ts` (numeric
const) both map to `cmcd_v1.js` under the strict "TS filename →
snake_case" rule. Disambiguated by suffixing the numeric-const file
with `_const` (likewise `cmcd_v2_const.js`). Same disambiguation for
`CMCD_HEADER_MAP.ts` vs the `CmcdHeaderMap` typedef →
`cmcd_header_map_const.js`.

Deferred: CMCD_FORMATTER_MAP.ts is intentionally NOT ported in this
commit. It defines runtime functions that depend on `SfItem` from
`@svta/cml-structured-field-values` (not in the vendoring scope) and
`urlToRelativePath` from `@svta/cml-utils` — both of which require
infrastructure that lands with the encoders in Task 1.6. Its only
consumer is `prepareCmcdData.ts` (also Task 1.6), so deferring is
self-contained.

Values verified verbatim against CML cmcd-v2.3.0 source.
---
 .../cml-cmcd/cmcd_default_time_interval.js    |  14 ++
 third_party/cml-cmcd/cmcd_event_keys.js       |  20 +++
 third_party/cml-cmcd/cmcd_header_map_const.js |  70 ++++++++
 third_party/cml-cmcd/cmcd_inner_list_keys.js  |  19 +++
 third_party/cml-cmcd/cmcd_key_types.js        | 154 ++++++++++++++++++
 third_party/cml-cmcd/cmcd_keys.js             |  25 +++
 third_party/cml-cmcd/cmcd_mime_type.js        |  14 ++
 third_party/cml-cmcd/cmcd_param.js            |  14 ++
 third_party/cml-cmcd/cmcd_request_keys.js     |  54 ++++++
 third_party/cml-cmcd/cmcd_response_keys.js    |  23 +++
 .../cml-cmcd/cmcd_string_length_limits.js     |  29 ++++
 third_party/cml-cmcd/cmcd_token_values.js     |  21 +++
 third_party/cml-cmcd/cmcd_v1_const.js         |  14 ++
 third_party/cml-cmcd/cmcd_v1_keys.js          |  33 ++++
 third_party/cml-cmcd/cmcd_v2_const.js         |  14 ++
 15 files changed, 518 insertions(+)
 create mode 100644 third_party/cml-cmcd/cmcd_default_time_interval.js
 create mode 100644 third_party/cml-cmcd/cmcd_event_keys.js
 create mode 100644 third_party/cml-cmcd/cmcd_header_map_const.js
 create mode 100644 third_party/cml-cmcd/cmcd_inner_list_keys.js
 create mode 100644 third_party/cml-cmcd/cmcd_key_types.js
 create mode 100644 third_party/cml-cmcd/cmcd_keys.js
 create mode 100644 third_party/cml-cmcd/cmcd_mime_type.js
 create mode 100644 third_party/cml-cmcd/cmcd_param.js
 create mode 100644 third_party/cml-cmcd/cmcd_request_keys.js
 create mode 100644 third_party/cml-cmcd/cmcd_response_keys.js
 create mode 100644 third_party/cml-cmcd/cmcd_string_length_limits.js
 create mode 100644 third_party/cml-cmcd/cmcd_token_values.js
 create mode 100644 third_party/cml-cmcd/cmcd_v1_const.js
 create mode 100644 third_party/cml-cmcd/cmcd_v1_keys.js
 create mode 100644 third_party/cml-cmcd/cmcd_v2_const.js

diff --git a/third_party/cml-cmcd/cmcd_default_time_interval.js b/third_party/cml-cmcd/cmcd_default_time_interval.js
new file mode 100644
index 0000000000..3cc7bede8b
--- /dev/null
+++ b/third_party/cml-cmcd/cmcd_default_time_interval.js
@@ -0,0 +1,14 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.CMCD_DEFAULT_TIME_INTERVAL');
+
+
+/**
+ * The default time interval in seconds when using event mode.
+ *
+ * @const {number}
+ */
+cml.cmcd.CMCD_DEFAULT_TIME_INTERVAL = 30;
diff --git a/third_party/cml-cmcd/cmcd_event_keys.js b/third_party/cml-cmcd/cmcd_event_keys.js
new file mode 100644
index 0000000000..947277f53d
--- /dev/null
+++ b/third_party/cml-cmcd/cmcd_event_keys.js
@@ -0,0 +1,20 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.CMCD_EVENT_KEYS');
+
+
+/**
+ * Defines the event-specific keys for CMCD (Common Media Client Data)
+ * version 2.
+ *
+ * @const {!Array<string>}
+ */
+cml.cmcd.CMCD_EVENT_KEYS = [
+  'cen',
+  'e',
+  'h',
+  'ts',
+];
diff --git a/third_party/cml-cmcd/cmcd_header_map_const.js b/third_party/cml-cmcd/cmcd_header_map_const.js
new file mode 100644
index 0000000000..737ef092fd
--- /dev/null
+++ b/third_party/cml-cmcd/cmcd_header_map_const.js
@@ -0,0 +1,70 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.CMCD_HEADER_MAP');
+
+goog.require('cml.cmcd.CMCD_OBJECT');
+goog.require('cml.cmcd.CMCD_REQUEST');
+goog.require('cml.cmcd.CMCD_SESSION');
+goog.require('cml.cmcd.CMCD_STATUS');
+
+
+/**
+ * The map of CMCD keys to their appropriate header shard.
+ *
+ * Note: Event-only keys (e, ts, cen, h) and response-received keys
+ * (rc, ttfb, ttlb, url, etc.) are intentionally absent. They are
+ * transmitted via the event-mode POST body, not HTTP headers.
+ *
+ * @const {!Object<string, string>}
+ */
+cml.cmcd.CMCD_HEADER_MAP = {
+  // Object
+  ab: cml.cmcd.CMCD_OBJECT,
+  br: cml.cmcd.CMCD_OBJECT,
+  d: cml.cmcd.CMCD_OBJECT,
+  lab: cml.cmcd.CMCD_OBJECT,
+  lb: cml.cmcd.CMCD_OBJECT,
+  ot: cml.cmcd.CMCD_OBJECT,
+  tab: cml.cmcd.CMCD_OBJECT,
+  tb: cml.cmcd.CMCD_OBJECT,
+  tpb: cml.cmcd.CMCD_OBJECT,
+
+  // Request
+  bl: cml.cmcd.CMCD_REQUEST,
+  cs: cml.cmcd.CMCD_REQUEST,
+  dfa: cml.cmcd.CMCD_REQUEST,
+  dl: cml.cmcd.CMCD_REQUEST,
+  ltc: cml.cmcd.CMCD_REQUEST,
+  mtp: cml.cmcd.CMCD_REQUEST,
+  nor: cml.cmcd.CMCD_REQUEST,
+  nrr: cml.cmcd.CMCD_REQUEST,
+  pb: cml.cmcd.CMCD_REQUEST,
+  sn: cml.cmcd.CMCD_REQUEST,
+  sta: cml.cmcd.CMCD_REQUEST,
+  su: cml.cmcd.CMCD_REQUEST,
+  tbl: cml.cmcd.CMCD_REQUEST,
+
+  // Session
+  cid: cml.cmcd.CMCD_SESSION,
+  msd: cml.cmcd.CMCD_SESSION,
+  sf: cml.cmcd.CMCD_SESSION,
+  sid: cml.cmcd.CMCD_SESSION,
+  st: cml.cmcd.CMCD_SESSION,
+  v: cml.cmcd.CMCD_SESSION,
+
+  // Status
+  bg: cml.cmcd.CMCD_STATUS,
+  bs: cml.cmcd.CMCD_STATUS,
+  bsa: cml.cmcd.CMCD_STATUS,
+  bsd: cml.cmcd.CMCD_STATUS,
+  bsda: cml.cmcd.CMCD_STATUS,
+  cdn: cml.cmcd.CMCD_STATUS,
+  ec: cml.cmcd.CMCD_STATUS,
+  nr: cml.cmcd.CMCD_STATUS,
+  pr: cml.cmcd.CMCD_STATUS,
+  pt: cml.cmcd.CMCD_STATUS,
+  rtp: cml.cmcd.CMCD_STATUS,
+};
diff --git a/third_party/cml-cmcd/cmcd_inner_list_keys.js b/third_party/cml-cmcd/cmcd_inner_list_keys.js
new file mode 100644
index 0000000000..ee6d842ee8
--- /dev/null
+++ b/third_party/cml-cmcd/cmcd_inner_list_keys.js
@@ -0,0 +1,19 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.CMCD_INNER_LIST_KEYS');
+
+
+/**
+ * Keys that are inner lists in V2 but plain scalars in V1.
+ *
+ * Used by both encoding (down-conversion) and decoding (up-conversion).
+ *
+ * @const {!Set<string>}
+ */
+cml.cmcd.CMCD_INNER_LIST_KEYS = new Set([
+  'ab', 'bl', 'br', 'bsa', 'bsd', 'bsda', 'lab', 'lb', 'mtp',
+  'pb', 'tab', 'tb', 'tbl', 'tpb',
+]);
diff --git a/third_party/cml-cmcd/cmcd_key_types.js b/third_party/cml-cmcd/cmcd_key_types.js
new file mode 100644
index 0000000000..063d6cf847
--- /dev/null
+++ b/third_party/cml-cmcd/cmcd_key_types.js
@@ -0,0 +1,154 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.CMCD_KEY_TYPES');
+goog.provide('cml.cmcd.CMCD_KEY_TYPE_BOOLEAN');
+goog.provide('cml.cmcd.CMCD_KEY_TYPE_INTEGER');
+goog.provide('cml.cmcd.CMCD_KEY_TYPE_NUMBER');
+goog.provide('cml.cmcd.CMCD_KEY_TYPE_NUMBER_LIST');
+goog.provide('cml.cmcd.CMCD_KEY_TYPE_STRING');
+goog.provide('cml.cmcd.CMCD_KEY_TYPE_STRING_LIST');
+goog.provide('cml.cmcd.CMCD_KEY_TYPE_TOKEN');
+goog.provide('cml.cmcd.CMCD_V1_KEY_TYPE_OVERRIDES');
+
+
+/**
+ * CMCD key value type: inner list of numbers with token identifiers.
+ *
+ * @const {string}
+ */
+cml.cmcd.CMCD_KEY_TYPE_NUMBER_LIST = 'number[]';
+
+/**
+ * CMCD key value type: inner list of strings.
+ *
+ * @const {string}
+ */
+cml.cmcd.CMCD_KEY_TYPE_STRING_LIST = 'string[]';
+
+/**
+ * CMCD key value type: integer.
+ *
+ * @const {string}
+ */
+cml.cmcd.CMCD_KEY_TYPE_INTEGER = 'integer';
+
+/**
+ * CMCD key value type: number (decimal).
+ *
+ * @const {string}
+ */
+cml.cmcd.CMCD_KEY_TYPE_NUMBER = 'number';
+
+/**
+ * CMCD key value type: boolean.
+ *
+ * @const {string}
+ */
+cml.cmcd.CMCD_KEY_TYPE_BOOLEAN = 'boolean';
+
+/**
+ * CMCD key value type: string.
+ *
+ * @const {string}
+ */
+cml.cmcd.CMCD_KEY_TYPE_STRING = 'string';
+
+/**
+ * CMCD key value type: token.
+ *
+ * @const {string}
+ */
+cml.cmcd.CMCD_KEY_TYPE_TOKEN = 'token';
+
+
+/**
+ * Maps each CMCD spec key to its expected value type for v2.
+ *
+ * Keys that differ between v1 and v2 are handled by
+ * CMCD_V1_KEY_TYPE_OVERRIDES.
+ *
+ * @const {!Object<string, string>}
+ */
+cml.cmcd.CMCD_KEY_TYPES = {
+  // List keys (inner list of integers/numbers with token identifiers)
+  ab: cml.cmcd.CMCD_KEY_TYPE_NUMBER_LIST,
+  bl: cml.cmcd.CMCD_KEY_TYPE_NUMBER_LIST,
+  br: cml.cmcd.CMCD_KEY_TYPE_NUMBER_LIST,
+  bsa: cml.cmcd.CMCD_KEY_TYPE_NUMBER_LIST,
+  bsd: cml.cmcd.CMCD_KEY_TYPE_NUMBER_LIST,
+  bsda: cml.cmcd.CMCD_KEY_TYPE_NUMBER_LIST,
+  lab: cml.cmcd.CMCD_KEY_TYPE_NUMBER_LIST,
+  lb: cml.cmcd.CMCD_KEY_TYPE_NUMBER_LIST,
+  mtp: cml.cmcd.CMCD_KEY_TYPE_NUMBER_LIST,
+  pb: cml.cmcd.CMCD_KEY_TYPE_NUMBER_LIST,
+  tab: cml.cmcd.CMCD_KEY_TYPE_NUMBER_LIST,
+  tb: cml.cmcd.CMCD_KEY_TYPE_NUMBER_LIST,
+  tbl: cml.cmcd.CMCD_KEY_TYPE_NUMBER_LIST,
+  tpb: cml.cmcd.CMCD_KEY_TYPE_NUMBER_LIST,
+
+  // String array keys (inner list of strings)
+  ec: cml.cmcd.CMCD_KEY_TYPE_STRING_LIST,
+  nor: cml.cmcd.CMCD_KEY_TYPE_STRING_LIST,
+
+  // Integer keys
+  d: cml.cmcd.CMCD_KEY_TYPE_INTEGER,
+  dfa: cml.cmcd.CMCD_KEY_TYPE_INTEGER,
+  dl: cml.cmcd.CMCD_KEY_TYPE_INTEGER,
+  ltc: cml.cmcd.CMCD_KEY_TYPE_INTEGER,
+  msd: cml.cmcd.CMCD_KEY_TYPE_INTEGER,
+  pt: cml.cmcd.CMCD_KEY_TYPE_INTEGER,
+  rc: cml.cmcd.CMCD_KEY_TYPE_INTEGER,
+  rtp: cml.cmcd.CMCD_KEY_TYPE_INTEGER,
+  sn: cml.cmcd.CMCD_KEY_TYPE_INTEGER,
+  ts: cml.cmcd.CMCD_KEY_TYPE_INTEGER,
+  ttfb: cml.cmcd.CMCD_KEY_TYPE_INTEGER,
+  ttfbb: cml.cmcd.CMCD_KEY_TYPE_INTEGER,
+  ttlb: cml.cmcd.CMCD_KEY_TYPE_INTEGER,
+  v: cml.cmcd.CMCD_KEY_TYPE_INTEGER,
+
+  // Number keys
+  pr: cml.cmcd.CMCD_KEY_TYPE_NUMBER,
+
+  // Boolean keys
+  bg: cml.cmcd.CMCD_KEY_TYPE_BOOLEAN,
+  bs: cml.cmcd.CMCD_KEY_TYPE_BOOLEAN,
+  nr: cml.cmcd.CMCD_KEY_TYPE_BOOLEAN,
+  su: cml.cmcd.CMCD_KEY_TYPE_BOOLEAN,
+
+  // String keys
+  cdn: cml.cmcd.CMCD_KEY_TYPE_STRING,
+  cen: cml.cmcd.CMCD_KEY_TYPE_STRING,
+  cid: cml.cmcd.CMCD_KEY_TYPE_STRING,
+  cmsdd: cml.cmcd.CMCD_KEY_TYPE_STRING,
+  cmsds: cml.cmcd.CMCD_KEY_TYPE_STRING,
+  cs: cml.cmcd.CMCD_KEY_TYPE_STRING,
+  h: cml.cmcd.CMCD_KEY_TYPE_STRING,
+  nrr: cml.cmcd.CMCD_KEY_TYPE_STRING,
+  sid: cml.cmcd.CMCD_KEY_TYPE_STRING,
+  smrt: cml.cmcd.CMCD_KEY_TYPE_STRING,
+  url: cml.cmcd.CMCD_KEY_TYPE_STRING,
+
+  // Token keys
+  e: cml.cmcd.CMCD_KEY_TYPE_TOKEN,
+  ot: cml.cmcd.CMCD_KEY_TYPE_TOKEN,
+  sf: cml.cmcd.CMCD_KEY_TYPE_TOKEN,
+  st: cml.cmcd.CMCD_KEY_TYPE_TOKEN,
+  sta: cml.cmcd.CMCD_KEY_TYPE_TOKEN,
+};
+
+
+/**
+ * Maps keys to their v1-specific types when they differ from v2.
+ *
+ * @const {!Object<string, string>}
+ */
+cml.cmcd.CMCD_V1_KEY_TYPE_OVERRIDES = {
+  bl: cml.cmcd.CMCD_KEY_TYPE_INTEGER,
+  br: cml.cmcd.CMCD_KEY_TYPE_NUMBER,
+  mtp: cml.cmcd.CMCD_KEY_TYPE_INTEGER,
+  tb: cml.cmcd.CMCD_KEY_TYPE_NUMBER,
+  nor: cml.cmcd.CMCD_KEY_TYPE_STRING,
+};
diff --git a/third_party/cml-cmcd/cmcd_keys.js b/third_party/cml-cmcd/cmcd_keys.js
new file mode 100644
index 0000000000..59c18f84e2
--- /dev/null
+++ b/third_party/cml-cmcd/cmcd_keys.js
@@ -0,0 +1,25 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.CMCD_KEYS');
+
+goog.require('cml.cmcd.CMCD_EVENT_KEYS');
+goog.require('cml.cmcd.CMCD_REQUEST_KEYS');
+goog.require('cml.cmcd.CMCD_RESPONSE_KEYS');
+goog.require('cml.cmcd.CMCD_V1_KEYS');
+
+
+/**
+ * A list of all CMCD keys (deduplicated union of v1 + request + response
+ * + event keys).
+ *
+ * @const {!Array<string>}
+ */
+cml.cmcd.CMCD_KEYS = [].concat(
+    cml.cmcd.CMCD_V1_KEYS,
+    cml.cmcd.CMCD_REQUEST_KEYS,
+    cml.cmcd.CMCD_RESPONSE_KEYS,
+    cml.cmcd.CMCD_EVENT_KEYS).filter(
+    (key, index, arr) => arr.indexOf(key) === index);
diff --git a/third_party/cml-cmcd/cmcd_mime_type.js b/third_party/cml-cmcd/cmcd_mime_type.js
new file mode 100644
index 0000000000..8659f3419d
--- /dev/null
+++ b/third_party/cml-cmcd/cmcd_mime_type.js
@@ -0,0 +1,14 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.CMCD_MIME_TYPE');
+
+
+/**
+ * CMCD MIME type for event report payloads.
+ *
+ * @const {string}
+ */
+cml.cmcd.CMCD_MIME_TYPE = 'application/cmcd';
diff --git a/third_party/cml-cmcd/cmcd_param.js b/third_party/cml-cmcd/cmcd_param.js
new file mode 100644
index 0000000000..4538603049
--- /dev/null
+++ b/third_party/cml-cmcd/cmcd_param.js
@@ -0,0 +1,14 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.CMCD_PARAM');
+
+
+/**
+ * CMCD parameter name (used for query-string transmission mode).
+ *
+ * @const {string}
+ */
+cml.cmcd.CMCD_PARAM = 'CMCD';
diff --git a/third_party/cml-cmcd/cmcd_request_keys.js b/third_party/cml-cmcd/cmcd_request_keys.js
new file mode 100644
index 0000000000..f133569bb6
--- /dev/null
+++ b/third_party/cml-cmcd/cmcd_request_keys.js
@@ -0,0 +1,54 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.CMCD_REQUEST_KEYS');
+
+
+/**
+ * Defines the request-specific keys for CMCD (Common Media Client
+ * Data) version 2.
+ *
+ * @const {!Array<string>}
+ */
+cml.cmcd.CMCD_REQUEST_KEYS = [
+  'ab',
+  'bg',
+  'bl',
+  'br',
+  'bs',
+  'bsa',
+  'bsd',
+  'bsda',
+  'cdn',
+  'cid',
+  'cs',
+  'd',
+  'dfa',
+  'dl',
+  'ec',
+  'lab',
+  'lb',
+  'ltc',
+  'msd',
+  'mtp',
+  'nor',
+  'nr',
+  'ot',
+  'pb',
+  'pr',
+  'pt',
+  'rtp',
+  'sf',
+  'sid',
+  'sn',
+  'st',
+  'sta',
+  'su',
+  'tab',
+  'tb',
+  'tbl',
+  'tpb',
+  'v',
+];
diff --git a/third_party/cml-cmcd/cmcd_response_keys.js b/third_party/cml-cmcd/cmcd_response_keys.js
new file mode 100644
index 0000000000..7abb7dcb6e
--- /dev/null
+++ b/third_party/cml-cmcd/cmcd_response_keys.js
@@ -0,0 +1,23 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.CMCD_RESPONSE_KEYS');
+
+
+/**
+ * CMCD v2 - Response-only and timing keys.
+ *
+ * @const {!Array<string>}
+ */
+cml.cmcd.CMCD_RESPONSE_KEYS = [
+  'cmsdd',
+  'cmsds',
+  'rc',
+  'smrt',
+  'ttfb',
+  'ttfbb',
+  'ttlb',
+  'url',
+];
diff --git a/third_party/cml-cmcd/cmcd_string_length_limits.js b/third_party/cml-cmcd/cmcd_string_length_limits.js
new file mode 100644
index 0000000000..6ec228f860
--- /dev/null
+++ b/third_party/cml-cmcd/cmcd_string_length_limits.js
@@ -0,0 +1,29 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.CMCD_CUSTOM_KEY_VALUE_MAX_LENGTH');
+goog.provide('cml.cmcd.CMCD_STRING_LENGTH_LIMITS');
+
+
+/**
+ * Maps CMCD keys to their maximum string length.
+ *
+ * @const {!Object<string, number>}
+ */
+cml.cmcd.CMCD_STRING_LENGTH_LIMITS = {
+  sid: 64,
+  cid: 128,
+  cdn: 128,
+  h: 128,
+  cen: 64,
+};
+
+
+/**
+ * Maximum length for custom key values.
+ *
+ * @const {number}
+ */
+cml.cmcd.CMCD_CUSTOM_KEY_VALUE_MAX_LENGTH = 64;
diff --git a/third_party/cml-cmcd/cmcd_token_values.js b/third_party/cml-cmcd/cmcd_token_values.js
new file mode 100644
index 0000000000..cd95fda790
--- /dev/null
+++ b/third_party/cml-cmcd/cmcd_token_values.js
@@ -0,0 +1,21 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.CMCD_TOKEN_VALUES');
+
+
+/**
+ * Maps token keys to their valid values.
+ *
+ * @const {!Object<string, !Array<string>>}
+ */
+cml.cmcd.CMCD_TOKEN_VALUES = {
+  e: ['bc', 'ps', 'e', 't', 'c', 'b', 'm', 'um', 'pe', 'pc', 'rr',
+    'as', 'ae', 'abs', 'abe', 'sk', 'ce'],
+  ot: ['m', 'a', 'v', 'av', 'i', 'c', 'tt', 'k', 'o'],
+  sf: ['d', 'h', 's', 'o'],
+  st: ['v', 'l', 'll'],
+  sta: ['s', 'p', 'k', 'r', 'a', 'w', 'e', 'f', 'q', 'd'],
+};
diff --git a/third_party/cml-cmcd/cmcd_v1_const.js b/third_party/cml-cmcd/cmcd_v1_const.js
new file mode 100644
index 0000000000..cae194778b
--- /dev/null
+++ b/third_party/cml-cmcd/cmcd_v1_const.js
@@ -0,0 +1,14 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.CMCD_V1');
+
+
+/**
+ * CMCD Version 1.
+ *
+ * @const {number}
+ */
+cml.cmcd.CMCD_V1 = 1;
diff --git a/third_party/cml-cmcd/cmcd_v1_keys.js b/third_party/cml-cmcd/cmcd_v1_keys.js
new file mode 100644
index 0000000000..bfd31cfd57
--- /dev/null
+++ b/third_party/cml-cmcd/cmcd_v1_keys.js
@@ -0,0 +1,33 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.CMCD_V1_KEYS');
+
+
+/**
+ * Defines the keys for CMCD (Common Media Client Data) version 1.
+ *
+ * @const {!Array<string>}
+ */
+cml.cmcd.CMCD_V1_KEYS = [
+  'bl',
+  'br',
+  'bs',
+  'cid',
+  'd',
+  'dl',
+  'mtp',
+  'nor',
+  'nrr',
+  'ot',
+  'pr',
+  'rtp',
+  'sf',
+  'sid',
+  'st',
+  'su',
+  'tb',
+  'v',
+];
diff --git a/third_party/cml-cmcd/cmcd_v2_const.js b/third_party/cml-cmcd/cmcd_v2_const.js
new file mode 100644
index 0000000000..a860f5abf9
--- /dev/null
+++ b/third_party/cml-cmcd/cmcd_v2_const.js
@@ -0,0 +1,14 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.CMCD_V2');
+
+
+/**
+ * CMCD Version 2.
+ *
+ * @const {number}
+ */
+cml.cmcd.CMCD_V2 = 2;

From 1e539e703943023e8a5fb0f550dc64a371301064 Mon Sep 17 00:00:00 2001
From: Casey Occhialini <1508707+littlespex@users.noreply.github.com>
Date: Mon, 27 Apr 2026 21:29:50 -0700
Subject: [PATCH 12/64] chore(cmcd): port cml-cmcd uuid shim
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Adds third_party/cml-cmcd/cml_utils.js providing `cml.cmcd.uuid` as a
thin wrapper around `crypto.randomUUID()`. Replaces CML's transitive
dependency on `@svta/cml-utils` for the one runtime call site in
`CmcdReporter`'s default-`sid` codepath.

The shaka adapter (Phase 3) always sets `sid` explicitly when building
a `CmcdReporterConfig`, so this codepath is dead at runtime and
Closure ADVANCED will strip it. The shim exists purely so the vendored
`CmcdReporter` source stays verbatim with upstream — making per-bump
diffs trivial.

`crypto.randomUUID()` is polyfilled in browsers without native support
by `lib/polyfill/random_uuid.js`.
---
 third_party/cml-cmcd/cml_utils.js | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)
 create mode 100644 third_party/cml-cmcd/cml_utils.js

diff --git a/third_party/cml-cmcd/cml_utils.js b/third_party/cml-cmcd/cml_utils.js
new file mode 100644
index 0000000000..188b793d52
--- /dev/null
+++ b/third_party/cml-cmcd/cml_utils.js
@@ -0,0 +1,24 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.uuid');
+
+
+/**
+ * UUID shim for the vendored @svta/cml-cmcd port.
+ *
+ * Upstream CML's `CmcdReporter` imports `uuid()` from `@svta/cml-utils`
+ * and uses it as the default for `sid` in `createCmcdReporterConfig`.
+ * The shaka adapter always sets `sid` explicitly, so this codepath is
+ * dead at runtime — Closure ADVANCED will strip it. Kept for verbatim
+ * parity with upstream CmcdReporter source so per-bump diffs stay
+ * trivial.
+ *
+ * `crypto.randomUUID()` is polyfilled in browsers without native
+ * support by `lib/polyfill/random_uuid.js`.
+ *
+ * @return {string}
+ */
+cml.cmcd.uuid = () => crypto.randomUUID();

From e6cb2563d4c6a46f7f91cc5f258ddb1dc74568f4 Mon Sep 17 00:00:00 2001
From: Casey Occhialini <1508707+littlespex@users.noreply.github.com>
Date: Mon, 27 Apr 2026 22:00:22 -0700
Subject: [PATCH 13/64] chore(cmcd): wire phase 1A port into build, add doc
 consistency

- Add the 44 third_party/cml-cmcd/*.js files to build/types/core,
  pulling Task 1.9's build integration forward from after Task 1.8.
  Resolves the 'complete' build check being red between sub-phases.
  As a side effect this enables Closure type-checking for the port,
  which surfaced three dangling goog.requires in the typedef-
  intersection files (cmcd.js, cmcd_event.js, cmcd_response.js) that
  were unused because those typedefs inline the resolved superset of
  fields rather than referencing the parent typedef. Removed.
- Document the _const filename disambiguation pattern in
  third_party/cml-cmcd/SUMMARY.txt.
- Backfill circular-require widening rationale into cmcd.js,
  cmcd_event.js, cmcd_response.js to match cmcd_request.js.

`python3 build/check.py` now passes clean (lint, complete, spell,
type-check all green).
---
 build/types/core                      | 45 +++++++++++++++++++++++++++
 third_party/cml-cmcd/SUMMARY.txt      |  3 ++
 third_party/cml-cmcd/cmcd.js          | 11 ++++---
 third_party/cml-cmcd/cmcd_event.js    |  9 ++++--
 third_party/cml-cmcd/cmcd_response.js |  8 +++--
 5 files changed, 68 insertions(+), 8 deletions(-)

diff --git a/build/types/core b/build/types/core
index 23a728059c..11395ced70 100644
--- a/build/types/core
+++ b/build/types/core
@@ -136,6 +136,51 @@
 +../../third_party/closure-uri/uri.js
 +../../third_party/closure-uri/utils.js
 
++../../third_party/cml-cmcd/cmcd.js
++../../third_party/cml-cmcd/cmcd_custom_key.js
++../../third_party/cml-cmcd/cmcd_custom_value.js
++../../third_party/cml-cmcd/cmcd_data.js
++../../third_party/cml-cmcd/cmcd_default_time_interval.js
++../../third_party/cml-cmcd/cmcd_encode_options.js
++../../third_party/cml-cmcd/cmcd_event.js
++../../third_party/cml-cmcd/cmcd_event_keys.js
++../../third_party/cml-cmcd/cmcd_event_type.js
++../../third_party/cml-cmcd/cmcd_formatter.js
++../../third_party/cml-cmcd/cmcd_formatter_map.js
++../../third_party/cml-cmcd/cmcd_formatter_options.js
++../../third_party/cml-cmcd/cmcd_header_field.js
++../../third_party/cml-cmcd/cmcd_header_key.js
++../../third_party/cml-cmcd/cmcd_header_map.js
++../../third_party/cml-cmcd/cmcd_header_map_const.js
++../../third_party/cml-cmcd/cmcd_header_value.js
++../../third_party/cml-cmcd/cmcd_inner_list_keys.js
++../../third_party/cml-cmcd/cmcd_key.js
++../../third_party/cml-cmcd/cmcd_key_types.js
++../../third_party/cml-cmcd/cmcd_keys.js
++../../third_party/cml-cmcd/cmcd_mime_type.js
++../../third_party/cml-cmcd/cmcd_object_type.js
++../../third_party/cml-cmcd/cmcd_object_type_list.js
++../../third_party/cml-cmcd/cmcd_param.js
++../../third_party/cml-cmcd/cmcd_player_state.js
++../../third_party/cml-cmcd/cmcd_reporting_mode.js
++../../third_party/cml-cmcd/cmcd_request.js
++../../third_party/cml-cmcd/cmcd_request_key.js
++../../third_party/cml-cmcd/cmcd_request_keys.js
++../../third_party/cml-cmcd/cmcd_response.js
++../../third_party/cml-cmcd/cmcd_response_keys.js
++../../third_party/cml-cmcd/cmcd_stream_type.js
++../../third_party/cml-cmcd/cmcd_streaming_format.js
++../../third_party/cml-cmcd/cmcd_string_length_limits.js
++../../third_party/cml-cmcd/cmcd_token_values.js
++../../third_party/cml-cmcd/cmcd_transmission_mode.js
++../../third_party/cml-cmcd/cmcd_v1.js
++../../third_party/cml-cmcd/cmcd_v1_const.js
++../../third_party/cml-cmcd/cmcd_v1_keys.js
++../../third_party/cml-cmcd/cmcd_v2_const.js
++../../third_party/cml-cmcd/cmcd_value.js
++../../third_party/cml-cmcd/cmcd_version.js
++../../third_party/cml-cmcd/cml_utils.js
+
 +../../third_party/language-mapping-list/language-mapping-list.js
 
 +@lcevc
diff --git a/third_party/cml-cmcd/SUMMARY.txt b/third_party/cml-cmcd/SUMMARY.txt
index f2d5741768..1b6249b805 100644
--- a/third_party/cml-cmcd/SUMMARY.txt
+++ b/third_party/cml-cmcd/SUMMARY.txt
@@ -20,3 +20,6 @@ cml-cmcd
     - Validators (validateCmcd*, isCmcd*) omitted: tooling-only utilities
     - cml-utils dep removed: shaka adapter always sets `sid` explicitly;
       a 5-line cml_utils.js shim provides `uuid` for any dead default paths
+    - Filenames disambiguated with `_const` suffix where TS files differ
+      only in case (e.g., `CmcdV1.ts` typedef + `CMCD_V1.ts` numeric const
+      → `cmcd_v1.js` + `cmcd_v1_const.js`). Affects v1, v2, and HEADER_MAP.
diff --git a/third_party/cml-cmcd/cmcd.js b/third_party/cml-cmcd/cmcd.js
index 05fd28522a..534e98e32b 100644
--- a/third_party/cml-cmcd/cmcd.js
+++ b/third_party/cml-cmcd/cmcd.js
@@ -5,10 +5,6 @@
 
 goog.provide('cml.cmcd.Cmcd');
 
-goog.require('cml.cmcd.CmcdEvent');
-goog.require('cml.cmcd.CmcdRequest');
-goog.require('cml.cmcd.CmcdResponse');
-
 
 /**
  * Common Media Client Data (CMCD) version 2.
@@ -22,6 +18,13 @@ goog.require('cml.cmcd.CmcdResponse');
  * Callers should treat `cml.cmcd.Cmcd` as having any field that any
  * of the three modes defines. All members optional.
  *
+ * The string-literal types for `e`, `ot`, `sf`, `sta`, `st` are the
+ * `cml.cmcd.CmcdEventType`, `cml.cmcd.CmcdObjectType`,
+ * `cml.cmcd.CmcdStreamingFormat`, `cml.cmcd.CmcdPlayerState`,
+ * `cml.cmcd.CmcdStreamType` enum value unions. We use plain `string`
+ * here to keep the typedef self-contained and avoid circular
+ * `goog.require` between enum files and this typedef.
+ *
  * @see {@link https://cdn.cta.tech/cta/media/media/resources/standards/pdfs/cta-5004-final.pdf}
  *
  * @typedef {{
diff --git a/third_party/cml-cmcd/cmcd_event.js b/third_party/cml-cmcd/cmcd_event.js
index b335313beb..d43d641a7f 100644
--- a/third_party/cml-cmcd/cmcd_event.js
+++ b/third_party/cml-cmcd/cmcd_event.js
@@ -5,8 +5,6 @@
 
 goog.provide('cml.cmcd.CmcdEvent');
 
-goog.require('cml.cmcd.CmcdRequest');
-
 
 /**
  * Common Media Client Data (CMCD) version 2 - Event Mode.
@@ -18,6 +16,13 @@ goog.require('cml.cmcd.CmcdRequest');
  * Closure typedefs cannot express type intersection; we list the union
  * of all properties (request + event) directly. All members optional.
  *
+ * The string-literal types for `e`, `ot`, `sf`, `sta`, `st` are the
+ * `cml.cmcd.CmcdEventType`, `cml.cmcd.CmcdObjectType`,
+ * `cml.cmcd.CmcdStreamingFormat`, `cml.cmcd.CmcdPlayerState`,
+ * `cml.cmcd.CmcdStreamType` enum value unions. We use plain `string`
+ * here to keep the typedef self-contained and avoid circular
+ * `goog.require` between enum files and this typedef.
+ *
  * @see {@link https://cta-wave.github.io/Resources/common-media-client-data--cta-5004-b.html#event-mode}
  *
  * @typedef {{
diff --git a/third_party/cml-cmcd/cmcd_response.js b/third_party/cml-cmcd/cmcd_response.js
index ae6234d953..22205abcac 100644
--- a/third_party/cml-cmcd/cmcd_response.js
+++ b/third_party/cml-cmcd/cmcd_response.js
@@ -5,8 +5,6 @@
 
 goog.provide('cml.cmcd.CmcdResponse');
 
-goog.require('cml.cmcd.CmcdRequest');
-
 
 /**
  * Common Media Client Data (CMCD) version 2 - Response Mode.
@@ -20,6 +18,12 @@ goog.require('cml.cmcd.CmcdRequest');
  * Closure typedefs cannot express type intersection; we list the union
  * of all properties (request + response) directly. All members optional.
  *
+ * The string-literal types for `ot`, `sf`, `sta`, `st` are the
+ * `cml.cmcd.CmcdObjectType`, `cml.cmcd.CmcdStreamingFormat`,
+ * `cml.cmcd.CmcdPlayerState`, `cml.cmcd.CmcdStreamType` enum value
+ * unions. We use plain `string` here to keep the typedef self-contained
+ * and avoid circular `goog.require` between enum files and this typedef.
+ *
  * @see {@link https://cta-wave.github.io/Resources/common-media-client-data--cta-5004-b.html#response-mode}
  *
  * @typedef {{

From 1b51edfc52e6a8fd01914c60c2f4ff035de84641 Mon Sep 17 00:00:00 2001
From: Casey Occhialini <1508707+littlespex@users.noreply.github.com>
Date: Mon, 27 Apr 2026 22:11:45 -0700
Subject: [PATCH 14/64] chore(cmcd): vendor cml-utils + cml-sfv shims for
 encoder port
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Sub-phase B prerequisite. The CMCD encoders pull in three runtime
imports from CML's sibling packages:

- `urlToRelativePath` from `@svta/cml-utils` (used by
  `CMCD_FORMATTER_MAP`'s `nor` formatter to relativize URLs).
- `SfItem` / `SfToken` constructors from
  `@svta/cml-structured-field-values` (used by `prepareCmcdData`,
  `CMCD_FORMATTER_MAP`, and `toCmcdValue` to wrap typed structured
  field values).
- `encodeSfDict` (the RFC 8941 §4.1 dictionary serializer that
  `encodePreparedCmcd` and `toPreparedCmcdHeaders` route every CMCD
  byte through).

Surface from the encoders' POV is small (4 callables), but
`encodeSfDict` pulls in the structured-field-values serializer's
transitive closure (~13 internal helpers, ~600 LoC vendored verbatim).
Since CMCD wire output is impossible without a structured-fields
encoder, vendoring is preferable to npm-dependency adoption per
AGENTS.md. Same per-bump diff stability strategy as `cml_utils.js`.

- Extend `cml_utils.js` with `urlToRelativePath` (vendored verbatim).
- Add new `cml_sfv.js` exposing `SfItem`, `SfToken`, `encodeSfDict`.
  Internal helpers prefixed `cml.cmcd.SfvImpl_*_` to mark them
  shim-private; not intended as a public surface.
- Wire `cml_sfv.js` into `build/types/core` alphabetically.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 build/types/core                  |   1 +
 third_party/cml-cmcd/cml_sfv.js   | 448 ++++++++++++++++++++++++++++++
 third_party/cml-cmcd/cml_utils.js |  49 ++++
 3 files changed, 498 insertions(+)
 create mode 100644 third_party/cml-cmcd/cml_sfv.js

diff --git a/build/types/core b/build/types/core
index 11395ced70..6f0f2819e0 100644
--- a/build/types/core
+++ b/build/types/core
@@ -179,6 +179,7 @@
 +../../third_party/cml-cmcd/cmcd_v2_const.js
 +../../third_party/cml-cmcd/cmcd_value.js
 +../../third_party/cml-cmcd/cmcd_version.js
++../../third_party/cml-cmcd/cml_sfv.js
 +../../third_party/cml-cmcd/cml_utils.js
 
 +../../third_party/language-mapping-list/language-mapping-list.js
diff --git a/third_party/cml-cmcd/cml_sfv.js b/third_party/cml-cmcd/cml_sfv.js
new file mode 100644
index 0000000000..f63a830e0d
--- /dev/null
+++ b/third_party/cml-cmcd/cml_sfv.js
@@ -0,0 +1,448 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.SfItem');
+goog.provide('cml.cmcd.SfToken');
+goog.provide('cml.cmcd.encodeSfDict');
+
+
+/**
+ * Vendored shim of the `@svta/cml-structured-field-values` surface used
+ * by the CMCD encoders. Provides the two runtime classes (`SfItem`,
+ * `SfToken`) and the dictionary serializer (`encodeSfDict`).
+ *
+ * Upstream CMCD imports:
+ *
+ * - `SfItem`/`SfToken` (constructors, `value`/`params`/`description`
+ *   property access) — used by `prepareCmcdData`, `CMCD_FORMATTER_MAP`,
+ *   `toCmcdValue`.
+ * - `encodeSfDict` — the entire CMCD wire output runs through this.
+ *   Used by `encodePreparedCmcd` and `toPreparedCmcdHeaders`.
+ *
+ * The serializer is RFC 8941 (HTTP Structured Field Values) §4.1
+ * encoding; we vendor it because without it no encoder file can produce
+ * wire output. The transitive surface is small and kept verbatim to
+ * upstream so per-bump diffs stay stable.
+ *
+ * Decoding (`decodeSfDict` etc.) is not needed by the CMCD encoders and
+ * is not vendored.
+ */
+
+
+/**
+ * Structured Field Item.
+ *
+ * @template V, P
+ */
+cml.cmcd.SfItem = class {
+  /**
+   * @param {*} value The value of the item.
+   * @param {*=} params The parameters of the item.
+   */
+  constructor(value, params) {
+    if (Array.isArray(value)) {
+      value = value.map(
+          (v) => (v instanceof cml.cmcd.SfItem) ? v : new cml.cmcd.SfItem(v));
+    }
+
+    /** @type {*} */
+    this.value = value;
+
+    /** @type {*} */
+    this.params = params;
+  }
+};
+
+
+/**
+ * A class to represent structured field tokens when `Symbol` is not
+ * available.
+ */
+cml.cmcd.SfToken = class {
+  /**
+   * @param {string} description
+   */
+  constructor(description) {
+    /** @type {string} */
+    this.description = description;
+  }
+};
+
+
+/**
+ * Converts a symbol or SfToken to a string.
+ *
+ * @param {symbol|!cml.cmcd.SfToken} symbol
+ * @return {string}
+ * @private
+ */
+cml.cmcd.SfvImpl_symbolToStr_ = function(symbol) {
+  return symbol.description || symbol.toString().slice(7, -1);
+};
+
+
+/**
+ * @param {*} value
+ * @return {string}
+ * @private
+ */
+cml.cmcd.SfvImpl_format_ = function(value) {
+  if (Array.isArray(value)) {
+    return JSON.stringify(value);
+  }
+  if (value instanceof Map) {
+    return 'Map{}';
+  }
+  if (value instanceof Set) {
+    return 'Set{}';
+  }
+  if (typeof value === 'object') {
+    return JSON.stringify(value);
+  }
+  return String(value);
+};
+
+
+/**
+ * @param {string} action
+ * @param {*} src
+ * @param {string} type
+ * @param {*=} cause
+ * @return {!Error}
+ * @private
+ */
+cml.cmcd.SfvImpl_throwError_ = function(action, src, type, cause) {
+  return new Error(
+      `failed to ${action} "${cml.cmcd.SfvImpl_format_(src)}" as ${type}`,
+      {cause});
+};
+
+
+/**
+ * @param {*} src
+ * @param {string} type
+ * @param {*=} cause
+ * @return {!Error}
+ * @private
+ */
+cml.cmcd.SfvImpl_serializeError_ = function(src, type, cause) {
+  return cml.cmcd.SfvImpl_throwError_('serialize', src, type, cause);
+};
+
+
+/**
+ * Encodes binary data to base64.
+ *
+ * @param {!Uint8Array} binary
+ * @return {string}
+ * @private
+ */
+cml.cmcd.SfvImpl_encodeBase64_ = function(binary) {
+  return btoa(String.fromCharCode(...binary));
+};
+
+
+/**
+ * Banker's rounding to a given number of decimal places.
+ *
+ * @param {number} value
+ * @param {number} precision
+ * @return {number}
+ * @private
+ */
+cml.cmcd.SfvImpl_roundToEven_ = function(value, precision) {
+  if (value < 0) {
+    return -cml.cmcd.SfvImpl_roundToEven_(-value, precision);
+  }
+
+  const decimalShift = Math.pow(10, precision);
+  const isEquidistant = Math.abs(((value * decimalShift) % 1) - 0.5) <
+      Number.EPSILON;
+
+  if (isEquidistant) {
+    const flooredValue = Math.floor(value * decimalShift);
+    return (flooredValue % 2 === 0 ? flooredValue : flooredValue + 1) /
+        decimalShift;
+  } else {
+    return Math.round(value * decimalShift) / decimalShift;
+  }
+};
+
+
+/**
+ * @param {number} value
+ * @return {boolean}
+ * @private
+ */
+cml.cmcd.SfvImpl_isInvalidInt_ = function(value) {
+  return value < -999999999999999 || 999999999999999 < value;
+};
+
+
+/**
+ * Serialize a Boolean per RFC 8941 §4.1.9.
+ *
+ * @param {boolean} value
+ * @return {string}
+ * @private
+ */
+cml.cmcd.SfvImpl_serializeBoolean_ = function(value) {
+  if (typeof value !== 'boolean') {
+    throw cml.cmcd.SfvImpl_serializeError_(value, 'Boolean');
+  }
+  return value ? '?1' : '?0';
+};
+
+
+/**
+ * Serialize a Byte Sequence per RFC 8941 §4.1.8.
+ *
+ * @param {!Uint8Array} value
+ * @return {string}
+ * @private
+ */
+cml.cmcd.SfvImpl_serializeByteSequence_ = function(value) {
+  if (ArrayBuffer.isView(value) === false) {
+    throw cml.cmcd.SfvImpl_serializeError_(value, 'Byte Sequence');
+  }
+  return `:${cml.cmcd.SfvImpl_encodeBase64_(value)}:`;
+};
+
+
+/**
+ * Serialize an Integer per RFC 8941 §4.1.4.
+ *
+ * @param {number} value
+ * @return {string}
+ * @private
+ */
+cml.cmcd.SfvImpl_serializeInteger_ = function(value) {
+  if (cml.cmcd.SfvImpl_isInvalidInt_(value)) {
+    throw cml.cmcd.SfvImpl_serializeError_(value, 'Integer');
+  }
+  return value.toString();
+};
+
+
+/**
+ * Serialize a Date per RFC 8941 §4.1.10.
+ *
+ * @param {!Date} value
+ * @return {string}
+ * @private
+ */
+cml.cmcd.SfvImpl_serializeDate_ = function(value) {
+  return `@${cml.cmcd.SfvImpl_serializeInteger_(value.getTime() / 1000)}`;
+};
+
+
+/**
+ * Serialize a Decimal per RFC 8941 §4.1.5.
+ *
+ * @param {number} value
+ * @return {string}
+ * @private
+ */
+cml.cmcd.SfvImpl_serializeDecimal_ = function(value) {
+  // round to 3 decimal places
+  const roundedValue = cml.cmcd.SfvImpl_roundToEven_(value, 3);
+  if (Math.floor(Math.abs(roundedValue)).toString().length > 12) {
+    throw cml.cmcd.SfvImpl_serializeError_(value, 'Decimal');
+  }
+  const stringValue = roundedValue.toString();
+  return stringValue.includes('.') ? stringValue : `${stringValue}.0`;
+};
+
+
+// eslint-disable-next-line no-control-regex
+cml.cmcd.SfvImpl_STRING_REGEX_ = /[\x00-\x1f\x7f]+/;
+
+
+/**
+ * Serialize a String per RFC 8941 §4.1.6.
+ *
+ * @param {string} value
+ * @return {string}
+ * @private
+ */
+cml.cmcd.SfvImpl_serializeString_ = function(value) {
+  if (cml.cmcd.SfvImpl_STRING_REGEX_.test(value)) {
+    throw cml.cmcd.SfvImpl_serializeError_(value, 'String');
+  }
+
+  return `"${value.replace(/\\/g, `\\\\`).replace(/"/g, `\\"`)}"`;
+};
+
+
+/**
+ * Serialize a Token per RFC 8941 §4.1.7.
+ *
+ * @param {symbol|!cml.cmcd.SfToken} token
+ * @return {string}
+ * @private
+ */
+cml.cmcd.SfvImpl_serializeToken_ = function(token) {
+  const value = cml.cmcd.SfvImpl_symbolToStr_(token);
+  if (/^([a-zA-Z*])([!#$%&'*+\-.^_`|~\w:/]*)$/.test(value) === false) {
+    throw cml.cmcd.SfvImpl_serializeError_(value, 'Token');
+  }
+  return value;
+};
+
+
+/**
+ * Serialize a Bare Item per RFC 8941 §4.1.3.1.
+ *
+ * @param {*} value
+ * @return {string}
+ * @private
+ */
+cml.cmcd.SfvImpl_serializeBareItem_ = function(value) {
+  switch (typeof value) {
+    case 'number':
+      if (!Number.isFinite(value)) {
+        throw cml.cmcd.SfvImpl_serializeError_(value, 'Bare Item');
+      }
+
+      if (Number.isInteger(value)) {
+        return cml.cmcd.SfvImpl_serializeInteger_(value);
+      }
+      return cml.cmcd.SfvImpl_serializeDecimal_(value);
+
+    case 'string':
+      return cml.cmcd.SfvImpl_serializeString_(value);
+
+    case 'symbol':
+      return cml.cmcd.SfvImpl_serializeToken_(value);
+
+    case 'boolean':
+      return cml.cmcd.SfvImpl_serializeBoolean_(value);
+
+    case 'object':
+      if (value instanceof Date) {
+        return cml.cmcd.SfvImpl_serializeDate_(value);
+      }
+      if (value instanceof Uint8Array) {
+        return cml.cmcd.SfvImpl_serializeByteSequence_(value);
+      }
+      if (value instanceof cml.cmcd.SfToken) {
+        return cml.cmcd.SfvImpl_serializeToken_(value);
+      }
+
+    // eslint-disable-next-line no-fallthrough
+    default:
+      // fail
+      throw cml.cmcd.SfvImpl_serializeError_(value, 'Bare Item');
+  }
+};
+
+
+/**
+ * Serialize a Key per RFC 8941 §4.1.1.3.
+ *
+ * @param {string} value
+ * @return {string}
+ * @private
+ */
+cml.cmcd.SfvImpl_serializeKey_ = function(value) {
+  if (/^[a-z*][a-z0-9\-_.*]*$/.test(value) === false) {
+    throw cml.cmcd.SfvImpl_serializeError_(value, 'Key');
+  }
+  return value;
+};
+
+
+/**
+ * Serialize Parameters per RFC 8941 §4.1.1.2.
+ *
+ * @param {*=} params
+ * @return {string}
+ * @private
+ */
+cml.cmcd.SfvImpl_serializeParams_ = function(params) {
+  if (params == null) {
+    return '';
+  }
+
+  return Object.entries(/** @type {!Object<?,?>} */ (params))
+      .map(([key, value]) => {
+        if (value === true) {
+          // omit true
+          return `;${cml.cmcd.SfvImpl_serializeKey_(/** @type {string} */ (key))}`;
+        }
+
+        return `;${cml.cmcd.SfvImpl_serializeKey_(/** @type {string} */ (key))}=` +
+            `${cml.cmcd.SfvImpl_serializeBareItem_(value)}`;
+      })
+      .join('');
+};
+
+
+/**
+ * Serialize an Item per RFC 8941 §4.1.3.
+ *
+ * @param {*} value
+ * @return {string}
+ * @private
+ */
+cml.cmcd.SfvImpl_serializeItem_ = function(value) {
+  if (value instanceof cml.cmcd.SfItem) {
+    return `${cml.cmcd.SfvImpl_serializeBareItem_(value.value)}` +
+        `${cml.cmcd.SfvImpl_serializeParams_(value.params)}`;
+  } else {
+    return cml.cmcd.SfvImpl_serializeBareItem_(value);
+  }
+};
+
+
+/**
+ * Serialize an Inner List per RFC 8941 §4.1.1.1.
+ *
+ * @param {*} value
+ * @return {string}
+ * @private
+ */
+cml.cmcd.SfvImpl_serializeInnerList_ = function(value) {
+  const inner = /** @type {{value: !Array<*>, params: *}} */ (value);
+  return `(${inner.value.map(cml.cmcd.SfvImpl_serializeItem_).join(' ')})` +
+      `${cml.cmcd.SfvImpl_serializeParams_(inner.params)}`;
+};
+
+
+/**
+ * Encode an object into a structured field dictionary per RFC 8941 §4.1.2.
+ *
+ * @param {!Object|!Map} dict The structured field dictionary to encode.
+ * @param {{whitespace: (boolean|undefined)}=} options Encoding options.
+ * @return {string} The structured field string.
+ */
+cml.cmcd.encodeSfDict = function(dict, options = {whitespace: true}) {
+  if (typeof dict !== 'object' || dict == null) {
+    throw cml.cmcd.SfvImpl_serializeError_(dict, 'Dict');
+  }
+
+  const entries = dict instanceof Map ? dict.entries() : Object.entries(dict);
+  const optionalWhiteSpace = (options && options.whitespace) ? ' ' : '';
+
+  return Array.from(entries)
+      .map(([key, item]) => {
+        if (item instanceof cml.cmcd.SfItem === false) {
+          item = new cml.cmcd.SfItem(item);
+        }
+        let output = cml.cmcd.SfvImpl_serializeKey_(key);
+        if (item.value === true) {
+          output += cml.cmcd.SfvImpl_serializeParams_(item.params);
+        } else {
+          output += '=';
+          if (Array.isArray(item.value)) {
+            output += cml.cmcd.SfvImpl_serializeInnerList_(item);
+          } else {
+            output += cml.cmcd.SfvImpl_serializeItem_(item);
+          }
+        }
+        return output;
+      })
+      .join(`,${optionalWhiteSpace}`);
+};
diff --git a/third_party/cml-cmcd/cml_utils.js b/third_party/cml-cmcd/cml_utils.js
index 188b793d52..52eed4f1a9 100644
--- a/third_party/cml-cmcd/cml_utils.js
+++ b/third_party/cml-cmcd/cml_utils.js
@@ -3,6 +3,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+goog.provide('cml.cmcd.urlToRelativePath');
 goog.provide('cml.cmcd.uuid');
 
 
@@ -22,3 +23,51 @@ goog.provide('cml.cmcd.uuid');
  * @return {string}
  */
 cml.cmcd.uuid = () => crypto.randomUUID();
+
+
+/**
+ * Constructs a relative path from a URL.
+ *
+ * Vendored verbatim from `@svta/cml-utils`'s `urlToRelativePath`. Used
+ * by `cml.cmcd.CMCD_FORMATTER_MAP`'s `nor` formatter to produce
+ * root-relative URLs when a `baseUrl` is supplied via
+ * `CmcdEncodeOptions.baseUrl`.
+ *
+ * @param {string} url The destination URL.
+ * @param {string} base The base URL.
+ * @return {string} The relative path.
+ */
+cml.cmcd.urlToRelativePath = function(url, base) {
+  const to = new URL(url);
+  const from = new URL(base);
+
+  if (to.origin !== from.origin) {
+    return url;
+  }
+
+  const toPath = to.pathname.split('/').slice(1);
+  const fromPath = from.pathname.split('/').slice(1, -1);
+
+  // remove common parents
+  const length = Math.min(toPath.length, fromPath.length);
+
+  for (let i = 0; i < length; i++) {
+    if (toPath[i] !== fromPath[i]) {
+      break;
+    }
+
+    toPath.shift();
+    fromPath.shift();
+  }
+
+  // add back paths
+  while (fromPath.length) {
+    fromPath.shift();
+    toPath.unshift('..');
+  }
+
+  const relativePath = toPath.join('/');
+
+  // preserve query parameters and hash of the destination url
+  return relativePath + to.search + to.hash;
+};

From 7a27aaacf7490bf7db973ebe53f071322987e758 Mon Sep 17 00:00:00 2001
From: Casey Occhialini <1508707+littlespex@users.noreply.github.com>
Date: Mon, 27 Apr 2026 22:14:16 -0700
Subject: [PATCH 15/64] chore(cmcd): port CMCD_FORMATTER_MAP (deferred from
 sub-phase A)

Sub-phase A deferred this constant because its body imports `SfItem`
from `@svta/cml-structured-field-values` and `urlToRelativePath` from
`@svta/cml-utils`. With both shimmed in the prior commit, port the
constant verbatim from CML.

Filename `cmcd_formatter_map_const.js` follows sub-phase A's `_const`
disambiguation pattern: the typedef `CmcdFormatterMap` already lives at
`cmcd_formatter_map.js`, so the constant lands as
`cmcd_formatter_map_const.js`.

The `roundValue`/`toRounded`/`hundredValue`/`toHundred`/`toUrlSafe`/
`nor` helpers from upstream become module-private functions prefixed
`cml.cmcd.CMCD_FORMATTER_MAP_*_`. Algorithm logic mirrors upstream
`CMCD_FORMATTER_MAP.ts` exactly.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 build/types/core                              |   1 +
 .../cml-cmcd/cmcd_formatter_map_const.js      | 170 ++++++++++++++++++
 2 files changed, 171 insertions(+)
 create mode 100644 third_party/cml-cmcd/cmcd_formatter_map_const.js

diff --git a/build/types/core b/build/types/core
index 6f0f2819e0..1a7e82d768 100644
--- a/build/types/core
+++ b/build/types/core
@@ -147,6 +147,7 @@
 +../../third_party/cml-cmcd/cmcd_event_type.js
 +../../third_party/cml-cmcd/cmcd_formatter.js
 +../../third_party/cml-cmcd/cmcd_formatter_map.js
++../../third_party/cml-cmcd/cmcd_formatter_map_const.js
 +../../third_party/cml-cmcd/cmcd_formatter_options.js
 +../../third_party/cml-cmcd/cmcd_header_field.js
 +../../third_party/cml-cmcd/cmcd_header_key.js
diff --git a/third_party/cml-cmcd/cmcd_formatter_map_const.js b/third_party/cml-cmcd/cmcd_formatter_map_const.js
new file mode 100644
index 0000000000..38aac8205f
--- /dev/null
+++ b/third_party/cml-cmcd/cmcd_formatter_map_const.js
@@ -0,0 +1,170 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.CMCD_FORMATTER_MAP');
+
+goog.require('cml.cmcd.CmcdFormatterMap');
+goog.require('cml.cmcd.CmcdFormatterOptions');
+goog.require('cml.cmcd.CmcdValue');
+goog.require('cml.cmcd.SfItem');
+goog.require('cml.cmcd.urlToRelativePath');
+
+
+/**
+ * @param {cml.cmcd.CmcdValue} value
+ * @return {(number|!cml.cmcd.SfItem)}
+ * @private
+ */
+cml.cmcd.CMCD_FORMATTER_MAP_roundValue_ = function(value) {
+  if (value instanceof cml.cmcd.SfItem) {
+    return new cml.cmcd.SfItem(
+        Math.round(/** @type {number} */ (value.value)), value.params);
+  }
+  return Math.round(/** @type {number} */ (value));
+};
+
+
+/**
+ * @param {cml.cmcd.CmcdValue} value
+ * @return {*}
+ * @private
+ */
+cml.cmcd.CMCD_FORMATTER_MAP_toRounded_ = function(value) {
+  if (Array.isArray(value)) {
+    return value.map(cml.cmcd.CMCD_FORMATTER_MAP_roundValue_);
+  }
+  return cml.cmcd.CMCD_FORMATTER_MAP_roundValue_(value);
+};
+
+
+/**
+ * @param {cml.cmcd.CmcdValue} value
+ * @param {cml.cmcd.CmcdFormatterOptions} options
+ * @return {*}
+ * @private
+ */
+cml.cmcd.CMCD_FORMATTER_MAP_toUrlSafe_ = function(value, options) {
+  if (Array.isArray(value)) {
+    return value.map(
+        (item) => /** @type {string} */ (
+            cml.cmcd.CMCD_FORMATTER_MAP_toUrlSafe_(item, options)));
+  }
+
+  if (value instanceof cml.cmcd.SfItem && typeof value.value === 'string') {
+    return new cml.cmcd.SfItem(
+        cml.cmcd.CMCD_FORMATTER_MAP_toUrlSafe_(value.value, options),
+        value.params);
+  } else {
+    if (options.baseUrl) {
+      value = cml.cmcd.urlToRelativePath(
+          /** @type {string} */ (value), options.baseUrl);
+    }
+    return options.version === 1 ?
+        encodeURIComponent(/** @type {string} */ (value)) :
+        /** @type {string} */ (value);
+  }
+};
+
+
+/**
+ * @param {cml.cmcd.CmcdValue} value
+ * @return {(number|!cml.cmcd.SfItem)}
+ * @private
+ */
+cml.cmcd.CMCD_FORMATTER_MAP_hundredValue_ = function(value) {
+  if (value instanceof cml.cmcd.SfItem) {
+    return new cml.cmcd.SfItem(
+        Math.round(/** @type {number} */ (value.value) / 100) * 100,
+        value.params);
+  }
+  return Math.round(/** @type {number} */ (value) / 100) * 100;
+};
+
+
+/**
+ * @param {cml.cmcd.CmcdValue} value
+ * @return {*}
+ * @private
+ */
+cml.cmcd.CMCD_FORMATTER_MAP_toHundred_ = function(value) {
+  if (Array.isArray(value)) {
+    return value.map(cml.cmcd.CMCD_FORMATTER_MAP_hundredValue_);
+  }
+  return cml.cmcd.CMCD_FORMATTER_MAP_hundredValue_(value);
+};
+
+
+/**
+ * @param {cml.cmcd.CmcdValue} value
+ * @param {cml.cmcd.CmcdFormatterOptions} options
+ * @return {*}
+ * @private
+ */
+cml.cmcd.CMCD_FORMATTER_MAP_nor_ = function(value, options) {
+  let norValue = value;
+
+  if (options.version >= 2) {
+    if (value instanceof cml.cmcd.SfItem && typeof value.value === 'string') {
+      norValue = new cml.cmcd.SfItem([value]);
+    } else if (typeof value === 'string') {
+      norValue = [value];
+    }
+  }
+
+  return cml.cmcd.CMCD_FORMATTER_MAP_toUrlSafe_(norValue, options);
+};
+
+
+/**
+ * The default formatters for CMCD values.
+ *
+ * Upstream CML: `Record<string, CmcdFormatter>`. The implementation
+ * functions are kept verbatim (modulo TS-isms like `instanceof SfItem`
+ * referencing the CML class, which we route through our `cml_sfv.js`
+ * shim).
+ *
+ * @const {!cml.cmcd.CmcdFormatterMap}
+ */
+cml.cmcd.CMCD_FORMATTER_MAP = {
+  /**
+   * Bitrate (kbps) rounded integer
+   */
+  br: cml.cmcd.CMCD_FORMATTER_MAP_toRounded_,
+
+  /**
+   * Duration (milliseconds) rounded integer
+   */
+  d: cml.cmcd.CMCD_FORMATTER_MAP_toRounded_,
+
+  /**
+   * Buffer Length (milliseconds) rounded nearest 100ms
+   */
+  bl: cml.cmcd.CMCD_FORMATTER_MAP_toHundred_,
+
+  /**
+   * Deadline (milliseconds) rounded nearest 100ms
+   */
+  dl: cml.cmcd.CMCD_FORMATTER_MAP_toHundred_,
+
+  /**
+   * Measured Throughput (kbps) rounded nearest 100kbps
+   */
+  mtp: cml.cmcd.CMCD_FORMATTER_MAP_toHundred_,
+
+  /**
+   * Next Object Request URL encoded
+   */
+  nor: cml.cmcd.CMCD_FORMATTER_MAP_nor_,
+
+  /**
+   * Requested maximum throughput (kbps) rounded nearest 100kbps
+   */
+  rtp: cml.cmcd.CMCD_FORMATTER_MAP_toHundred_,
+
+  /**
+   * Top Bitrate (kbps) rounded integer
+   */
+  tb: cml.cmcd.CMCD_FORMATTER_MAP_toRounded_,
+};

From 3d6d5ae277dbe363bdad673b334309e8cf0eb763 Mon Sep 17 00:00:00 2001
From: Casey Occhialini <1508707+littlespex@users.noreply.github.com>
Date: Mon, 27 Apr 2026 22:19:52 -0700
Subject: [PATCH 16/64] chore(cmcd): port cml-cmcd encoders to closure
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Sub-phase B Task 1.6. Port the 11 encoder files from spec § "Encoders":

- `append_cmcd_headers.js` (`appendCmcdHeaders`)
- `append_cmcd_query.js` (`appendCmcdQuery`)
- `encode_cmcd.js` (`encodeCmcd`)
- `encode_prepared_cmcd.js` (`encodePreparedCmcd`)
- `ensure_headers.js` (`ensureHeaders`)
- `prepare_cmcd_data.js` (`prepareCmcdData`)
- `to_cmcd_headers.js` (`toCmcdHeaders`)
- `to_cmcd_query.js` (`toCmcdQuery`)
- `to_cmcd_url.js` (`toCmcdUrl`)
- `to_cmcd_value.js` (`toCmcdValue`)
- `to_prepared_cmcd_headers.js` (`toPreparedCmcdHeaders`)

Algorithm logic preserved verbatim against upstream cmcd-v2.3.0.

The encoders pull in seven CMCD support modules that the spec marked
as "tooling-only Excluded" but that `prepareCmcdData` and
`toPreparedCmcdHeaders` actually call at runtime — port them too:

- `is_cmcd_custom_key.js` (`isCmcdCustomKey`)
- `is_cmcd_event_key.js` (`isCmcdEventKey`)
- `is_cmcd_request_key.js` (`isCmcdRequestKey`)
- `is_cmcd_response_received_key.js` (`isCmcdResponseReceivedKey`)
- `is_cmcd_v1_key.js` (`isCmcdV1Key`)
- `is_token_field.js` (`isTokenField`)
- `is_valid.js` (`isValid`)
- `group_cmcd_headers.js` (`groupCmcdHeaders`)

`groupCmcdHeaders` is shared between encoders and decoders; we vendor
the encoder-side without the decoder counterparts.

Closure type adjustments:

- `Object.entries(...)` returns `Array<[?, ?]>`; cast keys back to
  `string` at index sites (`prepare_cmcd_data.js`,
  `to_prepared_cmcd_headers.js`).
- `prepareCmcdData(obj, options)` re-binds `options || {}` to a typed
  local `opts` so Closure does not narrow it to the empty-object type.
- `first.params.r` widens through the SfItem `params` typedef via
  inline cast.
- TS generic `toCmcdValue<V, P>` erases to a single-shape JSDoc.

Build wiring: append all 19 entries to `build/types/core`
alphabetically. `python3 build/check.py` passes clean.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 build/types/core                              |  19 ++
 third_party/cml-cmcd/append_cmcd_headers.js   |  26 ++
 third_party/cml-cmcd/append_cmcd_query.js     |  40 +++
 third_party/cml-cmcd/encode_cmcd.js           |  31 +++
 third_party/cml-cmcd/encode_prepared_cmcd.js  |  21 ++
 third_party/cml-cmcd/ensure_headers.js        |  19 ++
 third_party/cml-cmcd/group_cmcd_headers.js    |  60 +++++
 third_party/cml-cmcd/is_cmcd_custom_key.js    |  24 ++
 third_party/cml-cmcd/is_cmcd_event_key.js     |  28 +++
 third_party/cml-cmcd/is_cmcd_request_key.js   |  26 ++
 .../cml-cmcd/is_cmcd_response_received_key.js |  24 ++
 third_party/cml-cmcd/is_cmcd_v1_key.js        |  25 ++
 third_party/cml-cmcd/is_token_field.js        |  21 ++
 third_party/cml-cmcd/is_valid.js              |  21 ++
 third_party/cml-cmcd/prepare_cmcd_data.js     | 237 ++++++++++++++++++
 third_party/cml-cmcd/to_cmcd_headers.js       |  33 +++
 third_party/cml-cmcd/to_cmcd_query.js         |  31 +++
 third_party/cml-cmcd/to_cmcd_url.js           |  30 +++
 third_party/cml-cmcd/to_cmcd_value.js         |  25 ++
 .../cml-cmcd/to_prepared_cmcd_headers.js      |  37 +++
 20 files changed, 778 insertions(+)
 create mode 100644 third_party/cml-cmcd/append_cmcd_headers.js
 create mode 100644 third_party/cml-cmcd/append_cmcd_query.js
 create mode 100644 third_party/cml-cmcd/encode_cmcd.js
 create mode 100644 third_party/cml-cmcd/encode_prepared_cmcd.js
 create mode 100644 third_party/cml-cmcd/ensure_headers.js
 create mode 100644 third_party/cml-cmcd/group_cmcd_headers.js
 create mode 100644 third_party/cml-cmcd/is_cmcd_custom_key.js
 create mode 100644 third_party/cml-cmcd/is_cmcd_event_key.js
 create mode 100644 third_party/cml-cmcd/is_cmcd_request_key.js
 create mode 100644 third_party/cml-cmcd/is_cmcd_response_received_key.js
 create mode 100644 third_party/cml-cmcd/is_cmcd_v1_key.js
 create mode 100644 third_party/cml-cmcd/is_token_field.js
 create mode 100644 third_party/cml-cmcd/is_valid.js
 create mode 100644 third_party/cml-cmcd/prepare_cmcd_data.js
 create mode 100644 third_party/cml-cmcd/to_cmcd_headers.js
 create mode 100644 third_party/cml-cmcd/to_cmcd_query.js
 create mode 100644 third_party/cml-cmcd/to_cmcd_url.js
 create mode 100644 third_party/cml-cmcd/to_cmcd_value.js
 create mode 100644 third_party/cml-cmcd/to_prepared_cmcd_headers.js

diff --git a/build/types/core b/build/types/core
index 1a7e82d768..0a6948d9a9 100644
--- a/build/types/core
+++ b/build/types/core
@@ -136,6 +136,8 @@
 +../../third_party/closure-uri/uri.js
 +../../third_party/closure-uri/utils.js
 
++../../third_party/cml-cmcd/append_cmcd_headers.js
++../../third_party/cml-cmcd/append_cmcd_query.js
 +../../third_party/cml-cmcd/cmcd.js
 +../../third_party/cml-cmcd/cmcd_custom_key.js
 +../../third_party/cml-cmcd/cmcd_custom_value.js
@@ -182,6 +184,23 @@
 +../../third_party/cml-cmcd/cmcd_version.js
 +../../third_party/cml-cmcd/cml_sfv.js
 +../../third_party/cml-cmcd/cml_utils.js
++../../third_party/cml-cmcd/encode_cmcd.js
++../../third_party/cml-cmcd/encode_prepared_cmcd.js
++../../third_party/cml-cmcd/ensure_headers.js
++../../third_party/cml-cmcd/group_cmcd_headers.js
++../../third_party/cml-cmcd/is_cmcd_custom_key.js
++../../third_party/cml-cmcd/is_cmcd_event_key.js
++../../third_party/cml-cmcd/is_cmcd_request_key.js
++../../third_party/cml-cmcd/is_cmcd_response_received_key.js
++../../third_party/cml-cmcd/is_cmcd_v1_key.js
++../../third_party/cml-cmcd/is_token_field.js
++../../third_party/cml-cmcd/is_valid.js
++../../third_party/cml-cmcd/prepare_cmcd_data.js
++../../third_party/cml-cmcd/to_cmcd_headers.js
++../../third_party/cml-cmcd/to_cmcd_query.js
++../../third_party/cml-cmcd/to_cmcd_url.js
++../../third_party/cml-cmcd/to_cmcd_value.js
++../../third_party/cml-cmcd/to_prepared_cmcd_headers.js
 
 +../../third_party/language-mapping-list/language-mapping-list.js
 
diff --git a/third_party/cml-cmcd/append_cmcd_headers.js b/third_party/cml-cmcd/append_cmcd_headers.js
new file mode 100644
index 0000000000..0b96e278e4
--- /dev/null
+++ b/third_party/cml-cmcd/append_cmcd_headers.js
@@ -0,0 +1,26 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.appendCmcdHeaders');
+
+goog.require('cml.cmcd.Cmcd');
+goog.require('cml.cmcd.CmcdEncodeOptions');
+goog.require('cml.cmcd.toCmcdHeaders');
+
+
+/**
+ * Append CMCD query args to a header object.
+ *
+ * @param {!Object<string, string>} headers The headers to append to.
+ * @param {cml.cmcd.Cmcd} cmcd The CMCD object to append.
+ * @param {cml.cmcd.CmcdEncodeOptions=} options Encode options.
+ * @return {!Object<string, string>} The headers with the CMCD header
+ *   shards appended.
+ *
+ * @see {@link https://cta-wave.github.io/Resources/common-media-client-data--cta-5004-b.html#header-field-definition}
+ */
+cml.cmcd.appendCmcdHeaders = function(headers, cmcd, options) {
+  return Object.assign(headers, cml.cmcd.toCmcdHeaders(cmcd, options));
+};
diff --git a/third_party/cml-cmcd/append_cmcd_query.js b/third_party/cml-cmcd/append_cmcd_query.js
new file mode 100644
index 0000000000..8cb09b85f8
--- /dev/null
+++ b/third_party/cml-cmcd/append_cmcd_query.js
@@ -0,0 +1,40 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.appendCmcdQuery');
+
+goog.require('cml.cmcd.Cmcd');
+goog.require('cml.cmcd.CmcdEncodeOptions');
+goog.require('cml.cmcd.toCmcdQuery');
+
+
+/** @private @const {!RegExp} */
+cml.cmcd.appendCmcdQuery_REGEX_ = /CMCD=[^&#]+/;
+
+
+/**
+ * Append CMCD query args to a URL.
+ *
+ * @param {string} url The URL to append to.
+ * @param {cml.cmcd.Cmcd} cmcd The CMCD object to append.
+ * @param {cml.cmcd.CmcdEncodeOptions=} options Options for encoding the
+ *   CMCD object.
+ * @return {string} The URL with the CMCD query args appended.
+ *
+ * @see {@link https://cta-wave.github.io/Resources/common-media-client-data--cta-5004-b.html#query-argument-definition}
+ */
+cml.cmcd.appendCmcdQuery = function(url, cmcd, options) {
+  const query = cml.cmcd.toCmcdQuery(cmcd, options);
+  if (!query) {
+    return url;
+  }
+
+  if (cml.cmcd.appendCmcdQuery_REGEX_.test(url)) {
+    return url.replace(cml.cmcd.appendCmcdQuery_REGEX_, query);
+  }
+
+  const separator = url.includes('?') ? '&' : '?';
+  return `${url}${separator}${query}`;
+};
diff --git a/third_party/cml-cmcd/encode_cmcd.js b/third_party/cml-cmcd/encode_cmcd.js
new file mode 100644
index 0000000000..00eecbc1ce
--- /dev/null
+++ b/third_party/cml-cmcd/encode_cmcd.js
@@ -0,0 +1,31 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.encodeCmcd');
+
+goog.require('cml.cmcd.Cmcd');
+goog.require('cml.cmcd.CmcdEncodeOptions');
+goog.require('cml.cmcd.encodePreparedCmcd');
+goog.require('cml.cmcd.prepareCmcdData');
+
+
+/**
+ * Encode a CMCD object to a string.
+ *
+ * @param {cml.cmcd.Cmcd} cmcd The CMCD object to encode.
+ * @param {cml.cmcd.CmcdEncodeOptions=} options Options for encoding.
+ * @return {string} The encoded CMCD string.
+ *
+ * @see {@link https://cta-wave.github.io/Resources/common-media-client-data--cta-5004-b.html#payload-definition-for-headers-and-query-argument-transmission}
+ */
+cml.cmcd.encodeCmcd = function(cmcd, options) {
+  if (!cmcd) {
+    return '';
+  }
+
+  return cml.cmcd.encodePreparedCmcd(
+      cml.cmcd.prepareCmcdData(/** @type {!Object<string, *>} */ (cmcd),
+          options));
+};
diff --git a/third_party/cml-cmcd/encode_prepared_cmcd.js b/third_party/cml-cmcd/encode_prepared_cmcd.js
new file mode 100644
index 0000000000..0d980feb11
--- /dev/null
+++ b/third_party/cml-cmcd/encode_prepared_cmcd.js
@@ -0,0 +1,21 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.encodePreparedCmcd');
+
+goog.require('cml.cmcd.Cmcd');
+goog.require('cml.cmcd.encodeSfDict');
+
+
+/**
+ * Encode already-prepared CMCD data to a structured field dictionary
+ * string.
+ *
+ * @param {!cml.cmcd.Cmcd} data The prepared CMCD data to encode.
+ * @return {string} The encoded CMCD string.
+ */
+cml.cmcd.encodePreparedCmcd = function(data) {
+  return cml.cmcd.encodeSfDict(data, {whitespace: false});
+};
diff --git a/third_party/cml-cmcd/ensure_headers.js b/third_party/cml-cmcd/ensure_headers.js
new file mode 100644
index 0000000000..b84d54af9c
--- /dev/null
+++ b/third_party/cml-cmcd/ensure_headers.js
@@ -0,0 +1,19 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.ensureHeaders');
+
+
+/**
+ * Converts a record of header fields to a `Headers` instance if
+ * necessary.
+ *
+ * @param {(!Object<string, string>|!Headers)} headers A `Headers`
+ *   instance or a plain record of header fields.
+ * @return {!Headers} A `Headers` instance.
+ */
+cml.cmcd.ensureHeaders = function(headers) {
+  return headers instanceof Headers ? headers : new Headers(headers);
+};
diff --git a/third_party/cml-cmcd/group_cmcd_headers.js b/third_party/cml-cmcd/group_cmcd_headers.js
new file mode 100644
index 0000000000..bb7b9fa1a9
--- /dev/null
+++ b/third_party/cml-cmcd/group_cmcd_headers.js
@@ -0,0 +1,60 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.groupCmcdHeaders');
+
+goog.require('cml.cmcd.CMCD_HEADER_MAP');
+goog.require('cml.cmcd.Cmcd');
+goog.require('cml.cmcd.CmcdHeaderField');
+goog.require('cml.cmcd.CmcdHeaderMap');
+
+
+/**
+ * @param {!cml.cmcd.CmcdHeaderMap} headerMap
+ * @return {!Object<string, string>}
+ * @private
+ */
+cml.cmcd.groupCmcdHeaders_createHeaderMap_ = function(headerMap) {
+  return Object.keys(headerMap)
+      .reduce((acc, field) => {
+        const keys = headerMap[field];
+        if (keys) {
+          keys.forEach((key) => acc[key] = field);
+        }
+        return acc;
+      }, /** @type {!Object<string, string>} */ ({}));
+};
+
+
+/**
+ * Group a CMCD data object into header shards.
+ *
+ * @param {cml.cmcd.Cmcd} cmcd The CMCD data object to convert.
+ * @param {cml.cmcd.CmcdHeaderMap=} customHeaderMap A map of CMCD header
+ *   fields to custom CMCD keys.
+ * @return {!Object<string, !Object<string, *>>} The CMCD header shards.
+ */
+cml.cmcd.groupCmcdHeaders = function(cmcd, customHeaderMap) {
+  /** @type {!Object<string, !Object<string, *>>} */
+  const result = {};
+
+  if (!cmcd) {
+    return result;
+  }
+
+  const keys = Object.keys(cmcd);
+  /** @type {!Object<string, string>} */
+  const custom = customHeaderMap ?
+      cml.cmcd.groupCmcdHeaders_createHeaderMap_(customHeaderMap) : {};
+
+  for (const key of keys) {
+    const field = cml.cmcd.CMCD_HEADER_MAP[key] || custom[key] ||
+        cml.cmcd.CmcdHeaderField.REQUEST;
+    const data = result[field] || (result[field] = {});
+    data[key] = cmcd[key];
+  }
+
+  return result;
+};
diff --git a/third_party/cml-cmcd/is_cmcd_custom_key.js b/third_party/cml-cmcd/is_cmcd_custom_key.js
new file mode 100644
index 0000000000..7ef568d5fe
--- /dev/null
+++ b/third_party/cml-cmcd/is_cmcd_custom_key.js
@@ -0,0 +1,24 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.isCmcdCustomKey');
+
+goog.require('cml.cmcd.CmcdKey');
+
+
+/** @private @const {!RegExp} */
+cml.cmcd.isCmcdCustomKey_REGEX_ = /^[a-zA-Z0-9-.]+-[a-zA-Z0-9-.]+$/;
+
+
+/**
+ * Check if a key is a custom key.
+ *
+ * @param {cml.cmcd.CmcdKey} key The key to check.
+ * @return {boolean} `true` if the key is a custom key, `false`
+ *   otherwise.
+ */
+cml.cmcd.isCmcdCustomKey = function(key) {
+  return cml.cmcd.isCmcdCustomKey_REGEX_.test(key);
+};
diff --git a/third_party/cml-cmcd/is_cmcd_event_key.js b/third_party/cml-cmcd/is_cmcd_event_key.js
new file mode 100644
index 0000000000..93f6e43b5c
--- /dev/null
+++ b/third_party/cml-cmcd/is_cmcd_event_key.js
@@ -0,0 +1,28 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.isCmcdEventKey');
+
+goog.require('cml.cmcd.CMCD_EVENT_KEYS');
+goog.require('cml.cmcd.isCmcdRequestKey');
+goog.require('cml.cmcd.isCmcdResponseReceivedKey');
+
+
+/** @private @const {!Set<string>} */
+cml.cmcd.isCmcdEventKey_SET_ = new Set(cml.cmcd.CMCD_EVENT_KEYS);
+
+
+/**
+ * Check if a key is a valid CMCD event key.
+ *
+ * @param {string} key The key to check.
+ * @return {boolean} `true` if the key is a valid CMCD event key,
+ *   `false` otherwise.
+ */
+cml.cmcd.isCmcdEventKey = function(key) {
+  return cml.cmcd.isCmcdRequestKey(key) ||
+      cml.cmcd.isCmcdResponseReceivedKey(key) ||
+      cml.cmcd.isCmcdEventKey_SET_.has(key);
+};
diff --git a/third_party/cml-cmcd/is_cmcd_request_key.js b/third_party/cml-cmcd/is_cmcd_request_key.js
new file mode 100644
index 0000000000..28a55beec7
--- /dev/null
+++ b/third_party/cml-cmcd/is_cmcd_request_key.js
@@ -0,0 +1,26 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.isCmcdRequestKey');
+
+goog.require('cml.cmcd.CMCD_REQUEST_KEYS');
+goog.require('cml.cmcd.isCmcdCustomKey');
+
+
+/** @private @const {!Set<string>} */
+cml.cmcd.isCmcdRequestKey_SET_ = new Set(cml.cmcd.CMCD_REQUEST_KEYS);
+
+
+/**
+ * Check if a key is a valid CMCD request key.
+ *
+ * @param {string} key The key to check.
+ * @return {boolean} `true` if the key is a valid CMCD request key,
+ *   `false` otherwise.
+ */
+cml.cmcd.isCmcdRequestKey = function(key) {
+  return cml.cmcd.isCmcdRequestKey_SET_.has(key) ||
+      cml.cmcd.isCmcdCustomKey(key);
+};
diff --git a/third_party/cml-cmcd/is_cmcd_response_received_key.js b/third_party/cml-cmcd/is_cmcd_response_received_key.js
new file mode 100644
index 0000000000..a2954894ae
--- /dev/null
+++ b/third_party/cml-cmcd/is_cmcd_response_received_key.js
@@ -0,0 +1,24 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.isCmcdResponseReceivedKey');
+
+goog.require('cml.cmcd.CMCD_RESPONSE_KEYS');
+
+
+/** @private @const {!Set<string>} */
+cml.cmcd.isCmcdResponseReceivedKey_SET_ = new Set(cml.cmcd.CMCD_RESPONSE_KEYS);
+
+
+/**
+ * Check if a key is a valid CMCD response-received key.
+ *
+ * @param {string} key The key to check.
+ * @return {boolean} `true` if the key is a valid CMCD response-received
+ *   key, `false` otherwise.
+ */
+cml.cmcd.isCmcdResponseReceivedKey = function(key) {
+  return cml.cmcd.isCmcdResponseReceivedKey_SET_.has(key);
+};
diff --git a/third_party/cml-cmcd/is_cmcd_v1_key.js b/third_party/cml-cmcd/is_cmcd_v1_key.js
new file mode 100644
index 0000000000..cfadc9090b
--- /dev/null
+++ b/third_party/cml-cmcd/is_cmcd_v1_key.js
@@ -0,0 +1,25 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.isCmcdV1Key');
+
+goog.require('cml.cmcd.CMCD_V1_KEYS');
+goog.require('cml.cmcd.isCmcdCustomKey');
+
+
+/** @private @const {!Set<string>} */
+cml.cmcd.isCmcdV1Key_SET_ = new Set(cml.cmcd.CMCD_V1_KEYS);
+
+
+/**
+ * Filter function for CMCD v1 keys.
+ *
+ * @param {string} key The CMCD key to filter.
+ * @return {boolean} `true` if the key should be included, `false`
+ *   otherwise.
+ */
+cml.cmcd.isCmcdV1Key = function(key) {
+  return cml.cmcd.isCmcdV1Key_SET_.has(key) || cml.cmcd.isCmcdCustomKey(key);
+};
diff --git a/third_party/cml-cmcd/is_token_field.js b/third_party/cml-cmcd/is_token_field.js
new file mode 100644
index 0000000000..e59d524d3f
--- /dev/null
+++ b/third_party/cml-cmcd/is_token_field.js
@@ -0,0 +1,21 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.isTokenField');
+
+
+/** @private @const {!Set<string>} */
+cml.cmcd.isTokenField_FIELDS_ = new Set(['ot', 'sf', 'st', 'e', 'sta']);
+
+
+/**
+ * Checks if the given key is a token field.
+ *
+ * @param {string} key The key to check.
+ * @return {boolean} `true` if the key is a token field.
+ */
+cml.cmcd.isTokenField = function(key) {
+  return cml.cmcd.isTokenField_FIELDS_.has(key);
+};
diff --git a/third_party/cml-cmcd/is_valid.js b/third_party/cml-cmcd/is_valid.js
new file mode 100644
index 0000000000..db46a7b0ab
--- /dev/null
+++ b/third_party/cml-cmcd/is_valid.js
@@ -0,0 +1,21 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.isValid');
+
+
+/**
+ * Checks if the given value is valid.
+ *
+ * @param {*} value The value to check.
+ * @return {boolean} `true` if the value is valid.
+ */
+cml.cmcd.isValid = function(value) {
+  if (typeof value === 'number') {
+    return Number.isFinite(value);
+  }
+
+  return value != null && value !== '' && value !== false;
+};
diff --git a/third_party/cml-cmcd/prepare_cmcd_data.js b/third_party/cml-cmcd/prepare_cmcd_data.js
new file mode 100644
index 0000000000..020fa3fb55
--- /dev/null
+++ b/third_party/cml-cmcd/prepare_cmcd_data.js
@@ -0,0 +1,237 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.prepareCmcdData');
+
+goog.require('cml.cmcd.CMCD_EVENT_CUSTOM_EVENT');
+goog.require('cml.cmcd.CMCD_EVENT_MODE');
+goog.require('cml.cmcd.CMCD_EVENT_RESPONSE_RECEIVED');
+goog.require('cml.cmcd.CMCD_FORMATTER_MAP');
+goog.require('cml.cmcd.CMCD_INNER_LIST_KEYS');
+goog.require('cml.cmcd.CMCD_REQUEST_MODE');
+goog.require('cml.cmcd.CMCD_V2');
+goog.require('cml.cmcd.Cmcd');
+goog.require('cml.cmcd.CmcdEncodeOptions');
+goog.require('cml.cmcd.CmcdFormatterOptions');
+goog.require('cml.cmcd.SfItem');
+goog.require('cml.cmcd.SfToken');
+goog.require('cml.cmcd.isCmcdEventKey');
+goog.require('cml.cmcd.isCmcdRequestKey');
+goog.require('cml.cmcd.isCmcdResponseReceivedKey');
+goog.require('cml.cmcd.isCmcdV1Key');
+goog.require('cml.cmcd.isTokenField');
+goog.require('cml.cmcd.isValid');
+
+
+/**
+ * Filter map: reporting mode → key-include predicate.
+ *
+ * @private @const {!Object<string, function(string): boolean>}
+ */
+cml.cmcd.prepareCmcdData_filterMap_ = {
+  [cml.cmcd.CMCD_EVENT_MODE]: cml.cmcd.isCmcdEventKey,
+  [cml.cmcd.CMCD_REQUEST_MODE]: cml.cmcd.isCmcdRequestKey,
+};
+
+
+/**
+ * Unwrap an inner list or SfItem value to a plain scalar.
+ *
+ * @param {*} value
+ * @param {string=} ot
+ * @return {*}
+ * @private
+ */
+cml.cmcd.prepareCmcdData_unwrapValue_ = function(value, ot) {
+  if (Array.isArray(value)) {
+    let item;
+
+    if (ot) {
+      item = value.find((it) => it && it.params && it.params.ot === ot);
+    }
+
+    if (!item) {
+      item = value[0];
+    }
+
+    return cml.cmcd.prepareCmcdData_unwrapValue_(item);
+  }
+
+  if (value instanceof cml.cmcd.SfItem) {
+    return value.value;
+  }
+
+  return value;
+};
+
+
+/**
+ * Down-convert V2 CMCD data to V1 format.
+ *
+ * - Extracts `nrr` from `nor` SfItem `r` parameter.
+ * - Unwraps inner-list values to plain scalars.
+ *
+ * @param {!Object<string, *>} obj
+ * @return {!Object<string, *>}
+ * @private
+ */
+cml.cmcd.prepareCmcdData_downConvertToV1_ = function(obj) {
+  /** @type {!Object<string, *>} */
+  const result = {};
+
+  for (const [k, value] of Object.entries(obj)) {
+    const key = /** @type {string} */ (k);
+    if (value == null) {
+      result[key] = value;
+      continue;
+    }
+
+    if (key === 'nor') {
+      const items = Array.isArray(value) ? value : [value];
+      const first = items[0];
+
+      if (first instanceof cml.cmcd.SfItem) {
+        result['nor'] = first.value;
+        const params =
+            /** @type {?{r: (string|undefined)}} */ (first.params);
+        if (params && params.r) {
+          result['nrr'] = params.r;
+        }
+      } else {
+        result['nor'] = first;
+      }
+    } else if (cml.cmcd.CMCD_INNER_LIST_KEYS.has(key)) {
+      result[key] = cml.cmcd.prepareCmcdData_unwrapValue_(
+          value, /** @type {string|undefined} */ (obj['ot']));
+    } else {
+      result[key] = value;
+    }
+  }
+
+  return result;
+};
+
+
+/**
+ * Convert a generic object to CMCD data.
+ *
+ * @param {!Object<string, *>} obj The CMCD object to process.
+ * @param {cml.cmcd.CmcdEncodeOptions=} options Options for encoding.
+ * @return {!cml.cmcd.Cmcd}
+ */
+cml.cmcd.prepareCmcdData = function(obj, options) {
+  /** @type {!cml.cmcd.CmcdEncodeOptions} */
+  const opts = /** @type {!cml.cmcd.CmcdEncodeOptions} */ (options || {});
+
+  /** @type {!Object<string, *>} */
+  const results = {};
+
+  if (obj == null || typeof obj !== 'object') {
+    return /** @type {!cml.cmcd.Cmcd} */ (results);
+  }
+
+  const version = opts.version ||
+      /** @type {number} */ (obj['v']) || cml.cmcd.CMCD_V2;
+  const reportingMode = opts.reportingMode || cml.cmcd.CMCD_REQUEST_MODE;
+
+  // Down-convert V2 data to V1 format if needed
+  const data = version === 1 ?
+      cml.cmcd.prepareCmcdData_downConvertToV1_(obj) : obj;
+
+  const keyFilter = version === 1 ?
+      cml.cmcd.isCmcdV1Key :
+      cml.cmcd.prepareCmcdData_filterMap_[reportingMode];
+
+  // Filter keys based on the version, reporting mode and options
+  let keys = Object.keys(data).filter(keyFilter);
+
+  if (data['e'] && data['e'] !== cml.cmcd.CMCD_EVENT_RESPONSE_RECEIVED) {
+    keys = keys.filter((key) => !cml.cmcd.isCmcdResponseReceivedKey(key));
+  }
+
+  const filter = opts.filter;
+  if (typeof filter === 'function') {
+    keys = keys.filter(filter);
+  }
+
+  // Ensure all required event keys are present before sorting
+  const isEventMode = reportingMode === cml.cmcd.CMCD_EVENT_MODE;
+
+  if (isEventMode) {
+    const eventType = data['e'];
+
+    if (!keys.includes('e') && eventType != null) {
+      keys.push('e');
+    }
+
+    if (!keys.includes('ts')) {
+      keys.push('ts');
+    }
+
+    if (!keys.includes('cen') && data['cen'] != null &&
+        eventType === cml.cmcd.CMCD_EVENT_CUSTOM_EVENT) {
+      keys.push('cen');
+    }
+  }
+
+  if (keys.length === 0) {
+    return /** @type {!cml.cmcd.Cmcd} */ (results);
+  }
+
+  if (version > 1 && !keys.includes('v')) {
+    keys.push('v');
+  }
+
+  /** @type {!cml.cmcd.CmcdFormatterOptions} */
+  const formatterOptions = {
+    version: version,
+    reportingMode: reportingMode,
+    baseUrl: opts.baseUrl,
+  };
+
+  keys.sort();
+
+  for (const key of keys) {
+    let value = data[key];
+
+    const formatter = (opts.formatters && opts.formatters[key]) ||
+        cml.cmcd.CMCD_FORMATTER_MAP[key];
+    if (typeof formatter === 'function') {
+      value = formatter(value, formatterOptions);
+    }
+
+    // Version should only be reported if not equal to 1.
+    if (key === 'v') {
+      if (version === 1) {
+        continue;
+      } else {
+        value = version;
+      }
+    }
+
+    // Playback rate should only be sent if not equal to 1.
+    if (key === 'pr' && value === 1) {
+      continue;
+    }
+
+    // Ensure a timestamp is set for event mode
+    if (isEventMode && key === 'ts' && !Number.isFinite(value)) {
+      value = Date.now();
+    }
+
+    // ignore invalid values
+    if (!cml.cmcd.isValid(value)) {
+      continue;
+    }
+
+    if (cml.cmcd.isTokenField(key) && typeof value === 'string') {
+      value = new cml.cmcd.SfToken(value);
+    }
+
+    results[key] = value;
+  }
+
+  return /** @type {!cml.cmcd.Cmcd} */ (results);
+};
diff --git a/third_party/cml-cmcd/to_cmcd_headers.js b/third_party/cml-cmcd/to_cmcd_headers.js
new file mode 100644
index 0000000000..03980db803
--- /dev/null
+++ b/third_party/cml-cmcd/to_cmcd_headers.js
@@ -0,0 +1,33 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.toCmcdHeaders');
+
+goog.require('cml.cmcd.Cmcd');
+goog.require('cml.cmcd.CmcdEncodeOptions');
+goog.require('cml.cmcd.prepareCmcdData');
+goog.require('cml.cmcd.toPreparedCmcdHeaders');
+
+
+/**
+ * Convert a CMCD data object to request headers.
+ *
+ * @param {cml.cmcd.Cmcd} cmcd The CMCD data object to convert.
+ * @param {cml.cmcd.CmcdEncodeOptions=} options Options for encoding the
+ *   CMCD object.
+ * @return {!Object<string, string>} The CMCD header shards.
+ *
+ * @see {@link https://cta-wave.github.io/Resources/common-media-client-data--cta-5004-b.html#header-field-definition}
+ */
+cml.cmcd.toCmcdHeaders = function(cmcd, options) {
+  if (!cmcd) {
+    return {};
+  }
+
+  return cml.cmcd.toPreparedCmcdHeaders(
+      cml.cmcd.prepareCmcdData(/** @type {!Object<string, *>} */ (cmcd),
+          options),
+      options ? options.customHeaderMap : undefined);
+};
diff --git a/third_party/cml-cmcd/to_cmcd_query.js b/third_party/cml-cmcd/to_cmcd_query.js
new file mode 100644
index 0000000000..8d2d0078d6
--- /dev/null
+++ b/third_party/cml-cmcd/to_cmcd_query.js
@@ -0,0 +1,31 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.toCmcdQuery');
+
+goog.require('cml.cmcd.CMCD_PARAM');
+goog.require('cml.cmcd.Cmcd');
+goog.require('cml.cmcd.CmcdEncodeOptions');
+goog.require('cml.cmcd.toCmcdUrl');
+
+
+/**
+ * Convert a CMCD data object to a query arg.
+ *
+ * @param {cml.cmcd.Cmcd} cmcd The CMCD object to convert.
+ * @param {cml.cmcd.CmcdEncodeOptions=} options Options for encoding.
+ * @return {string} The CMCD query arg.
+ *
+ * @see {@link https://cta-wave.github.io/Resources/common-media-client-data--cta-5004-b.html#query-argument-definition}
+ */
+cml.cmcd.toCmcdQuery = function(cmcd, options) {
+  if (!cmcd) {
+    return '';
+  }
+
+  const value = cml.cmcd.toCmcdUrl(cmcd, options);
+
+  return `${cml.cmcd.CMCD_PARAM}=${value}`;
+};
diff --git a/third_party/cml-cmcd/to_cmcd_url.js b/third_party/cml-cmcd/to_cmcd_url.js
new file mode 100644
index 0000000000..ba11980fda
--- /dev/null
+++ b/third_party/cml-cmcd/to_cmcd_url.js
@@ -0,0 +1,30 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.toCmcdUrl');
+
+goog.require('cml.cmcd.Cmcd');
+goog.require('cml.cmcd.CmcdEncodeOptions');
+goog.require('cml.cmcd.encodeCmcd');
+
+
+/**
+ * Convert a CMCD data object to a URL encoded string.
+ *
+ * @param {cml.cmcd.Cmcd} cmcd The CMCD object to convert.
+ * @param {cml.cmcd.CmcdEncodeOptions=} options Options for encoding.
+ * @return {string} The URL encoded CMCD data.
+ *
+ * @see {@link https://cta-wave.github.io/Resources/common-media-client-data--cta-5004-b.html#query-argument-definition}
+ */
+cml.cmcd.toCmcdUrl = function(cmcd, options) {
+  if (!cmcd) {
+    return '';
+  }
+
+  const params = cml.cmcd.encodeCmcd(cmcd, options);
+
+  return encodeURIComponent(params);
+};
diff --git a/third_party/cml-cmcd/to_cmcd_value.js b/third_party/cml-cmcd/to_cmcd_value.js
new file mode 100644
index 0000000000..5bdc00c62c
--- /dev/null
+++ b/third_party/cml-cmcd/to_cmcd_value.js
@@ -0,0 +1,25 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.toCmcdValue');
+
+goog.require('cml.cmcd.SfItem');
+
+
+/**
+ * Convert a value to a CMCD value.
+ *
+ * Upstream signature is generic
+ * `<V extends SfBareItem, P>(value: V, params?: P): SfItem<V, P>`;
+ * the closure port erases generics — every CMCD bare item flows through
+ * the same `SfItem` runtime constructor.
+ *
+ * @param {*} value The value to convert to a CMCD value.
+ * @param {*=} params The parameters to convert to a CMCD value.
+ * @return {!cml.cmcd.SfItem} The CMCD value.
+ */
+cml.cmcd.toCmcdValue = function(value, params) {
+  return new cml.cmcd.SfItem(value, params);
+};
diff --git a/third_party/cml-cmcd/to_prepared_cmcd_headers.js b/third_party/cml-cmcd/to_prepared_cmcd_headers.js
new file mode 100644
index 0000000000..3d037a2d21
--- /dev/null
+++ b/third_party/cml-cmcd/to_prepared_cmcd_headers.js
@@ -0,0 +1,37 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.toPreparedCmcdHeaders');
+
+goog.require('cml.cmcd.Cmcd');
+goog.require('cml.cmcd.CmcdHeaderMap');
+goog.require('cml.cmcd.encodeSfDict');
+goog.require('cml.cmcd.groupCmcdHeaders');
+
+
+/**
+ * Encode already-prepared CMCD data to CMCD header shards.
+ *
+ * @param {!cml.cmcd.Cmcd} data The prepared CMCD data to encode.
+ * @param {cml.cmcd.CmcdHeaderMap=} customHeaderMap A map of CMCD header
+ *   fields to custom CMCD keys.
+ * @return {!Object<string, string>} The CMCD header shards.
+ */
+cml.cmcd.toPreparedCmcdHeaders = function(data, customHeaderMap) {
+  /** @type {!Object<string, string>} */
+  const result = {};
+  const shards = cml.cmcd.groupCmcdHeaders(data, customHeaderMap);
+
+  for (const [f, value] of Object.entries(shards)) {
+    const field = /** @type {string} */ (f);
+    const shard = cml.cmcd.encodeSfDict(
+        /** @type {!Object<string, *>} */ (value), {whitespace: false});
+    if (shard) {
+      result[field] = shard;
+    }
+  }
+
+  return result;
+};

From d9aa2f9a14cd1eff63fb9a3950d1f65a9aeb5029 Mon Sep 17 00:00:00 2001
From: Casey Occhialini <1508707+littlespex@users.noreply.github.com>
Date: Mon, 27 Apr 2026 22:21:59 -0700
Subject: [PATCH 17/64] chore(cmcd): port cml-cmcd version-resolution helpers
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Sub-phase B Task 1.7. Port the two version-resolution helpers from
spec § "Helpers":

- `up_convert_to_v2.js` (`upConvertToV2`) — wraps v1 scalar values in
  inner-list arrays and `nor` strings in arrays for v2 output.
- `resolve_version.js` (`resolveVersion`) — picks an explicit version
  override, falls back to payload `v`, defaults to `CMCD_V1`.

`resolveVersion`'s upstream signature uses `CmcdValidationOptions`,
which lives among the validation typedefs that spec § "Excluded
validators" omits. Inline the option shape (only the `version` field
is read) instead of vendoring the typedef.

`SUMMARY.txt` updated to note the included predicates, the
`urlToRelativePath` cml-utils addition, and the new `cml_sfv.js` shim
covering the structured-field-values encoder surface.

Build wiring: append both new entries to `build/types/core`
alphabetically. `python3 build/check.py` passes clean.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 build/types/core                         |  2 +
 third_party/cml-cmcd/SUMMARY.txt         | 22 +++++++++--
 third_party/cml-cmcd/resolve_version.js  | 35 +++++++++++++++++
 third_party/cml-cmcd/up_convert_to_v2.js | 48 ++++++++++++++++++++++++
 4 files changed, 103 insertions(+), 4 deletions(-)
 create mode 100644 third_party/cml-cmcd/resolve_version.js
 create mode 100644 third_party/cml-cmcd/up_convert_to_v2.js

diff --git a/build/types/core b/build/types/core
index 0a6948d9a9..85164f2d60 100644
--- a/build/types/core
+++ b/build/types/core
@@ -196,11 +196,13 @@
 +../../third_party/cml-cmcd/is_token_field.js
 +../../third_party/cml-cmcd/is_valid.js
 +../../third_party/cml-cmcd/prepare_cmcd_data.js
++../../third_party/cml-cmcd/resolve_version.js
 +../../third_party/cml-cmcd/to_cmcd_headers.js
 +../../third_party/cml-cmcd/to_cmcd_query.js
 +../../third_party/cml-cmcd/to_cmcd_url.js
 +../../third_party/cml-cmcd/to_cmcd_value.js
 +../../third_party/cml-cmcd/to_prepared_cmcd_headers.js
++../../third_party/cml-cmcd/up_convert_to_v2.js
 
 +../../third_party/language-mapping-list/language-mapping-list.js
 
diff --git a/third_party/cml-cmcd/SUMMARY.txt b/third_party/cml-cmcd/SUMMARY.txt
index 1b6249b805..b142157207 100644
--- a/third_party/cml-cmcd/SUMMARY.txt
+++ b/third_party/cml-cmcd/SUMMARY.txt
@@ -17,9 +17,23 @@ cml-cmcd
     - TypeScript source converted to Closure-annotated JS by hand
     - Type-only imports erased; replaced with local closure typedefs
     - Decoders (decodeCmcd, fromCmcd*) omitted: shaka emits CMCD only
-    - Validators (validateCmcd*, isCmcd*) omitted: tooling-only utilities
-    - cml-utils dep removed: shaka adapter always sets `sid` explicitly;
-      a 5-line cml_utils.js shim provides `uuid` for any dead default paths
+    - Validators (validateCmcd*) omitted: tooling-only utilities
+    - Predicates (`is_cmcd_*_key.js`, `is_token_field.js`,
+      `is_valid.js`) included: required at runtime by `prepareCmcdData`
+      even though spec § "Excluded > Predicates" had marked them
+      tooling-only. `groupCmcdHeaders` likewise included as it is the
+      shared encoder/decoder helper used by `toPreparedCmcdHeaders`.
+    - cml-utils dep absorbed into `cml_utils.js` shim:
+        * `uuid` (wraps `crypto.randomUUID()`; dead-codepath for shaka)
+        * `urlToRelativePath` (used by `CMCD_FORMATTER_MAP`'s `nor`)
+    - structured-field-values dep absorbed into `cml_sfv.js` shim:
+        * `SfItem` / `SfToken` runtime classes
+        * `encodeSfDict` (RFC 8941 §4.1 dictionary serializer; pulls in
+          its transitive serializer closure verbatim because every
+          CMCD wire byte routes through it)
+      Decoding (`decodeSfDict`, `decodeSfItem`) is not vendored — only
+      encoder surface is needed.
     - Filenames disambiguated with `_const` suffix where TS files differ
       only in case (e.g., `CmcdV1.ts` typedef + `CMCD_V1.ts` numeric const
-      → `cmcd_v1.js` + `cmcd_v1_const.js`). Affects v1, v2, and HEADER_MAP.
+      → `cmcd_v1.js` + `cmcd_v1_const.js`). Affects v1, v2, HEADER_MAP,
+      and FORMATTER_MAP.
diff --git a/third_party/cml-cmcd/resolve_version.js b/third_party/cml-cmcd/resolve_version.js
new file mode 100644
index 0000000000..2499215be9
--- /dev/null
+++ b/third_party/cml-cmcd/resolve_version.js
@@ -0,0 +1,35 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.resolveVersion');
+
+goog.require('cml.cmcd.CMCD_V1');
+
+
+/**
+ * Resolves the CMCD version from explicit options, the payload's `v`
+ * key, or the default (v1).
+ *
+ * Upstream signature uses `CmcdValidationOptions` for the second arg;
+ * since validation typedefs are not vendored (spec § "Excluded
+ * validators"), we inline the option shape (only the `version` field
+ * is read).
+ *
+ * @param {!Object<string, *>} data
+ * @param {{version: (number|undefined)}=} options
+ * @return {number}
+ */
+cml.cmcd.resolveVersion = function(data, options) {
+  if (options && (options.version === 1 || options.version === 2)) {
+    return options.version;
+  }
+
+  const payloadVersion = data['v'];
+  if (payloadVersion === 1 || payloadVersion === 2) {
+    return /** @type {number} */ (payloadVersion);
+  }
+
+  return cml.cmcd.CMCD_V1;
+};
diff --git a/third_party/cml-cmcd/up_convert_to_v2.js b/third_party/cml-cmcd/up_convert_to_v2.js
new file mode 100644
index 0000000000..f48aad4581
--- /dev/null
+++ b/third_party/cml-cmcd/up_convert_to_v2.js
@@ -0,0 +1,48 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.upConvertToV2');
+
+goog.require('cml.cmcd.CMCD_INNER_LIST_KEYS');
+goog.require('cml.cmcd.CMCD_V2');
+
+
+/**
+ * Up-convert V1 CMCD data to V2 format.
+ *
+ * - Wraps plain scalar values in arrays for inner-list keys.
+ * - Wraps `nor` string in an array.
+ *
+ * If the data is already V2 (has `v: 2`), it is returned unchanged.
+ *
+ * @param {!Object<string, *>} obj
+ * @return {!Object<string, *>}
+ */
+cml.cmcd.upConvertToV2 = function(obj) {
+  if (obj['v'] === cml.cmcd.CMCD_V2) {
+    return obj;
+  }
+
+  /** @type {!Object<string, *>} */
+  const result = {};
+
+  for (const [k, value] of Object.entries(obj)) {
+    const key = /** @type {string} */ (k);
+    if (value == null) {
+      result[key] = value;
+      continue;
+    }
+
+    if (cml.cmcd.CMCD_INNER_LIST_KEYS.has(key) && !Array.isArray(value)) {
+      result[key] = [value];
+    } else if (key === 'nor' && typeof value === 'string') {
+      result[key] = [value];
+    } else {
+      result[key] = value;
+    }
+  }
+
+  return result;
+};

From 9bcf6614e28c42edcfa4ba67a18e396b2708ee13 Mon Sep 17 00:00:00 2001
From: Casey Occhialini <1508707+littlespex@users.noreply.github.com>
Date: Tue, 28 Apr 2026 09:08:55 -0700
Subject: [PATCH 18/64] fix(cmcd): restore typedef requireType in
 cmcd.js/event/response, polish cml_sfv
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- The phase 1A polish commit (e6cb2563d) dropped 'dangling' goog.requires
  in cmcd.js, cmcd_event.js, cmcd_response.js. These should have been
  converted to goog.requireType instead — the typedefs reference
  cml.cmcd.CmcdObjectTypeList in JSDoc only (no runtime use). Restoring
  as requireType fixes 42 JSC_MISSING_REQUIRE_TYPE_IN_PROVIDES_FILE
  errors in build/build.py.
- Drop misleading @template V, P from cml_sfv.js SfItem class JSDoc
  (the V/P params are erased to * — documented in to_cmcd_value.js).
- Simplify encodeSfDict's `(options && options.whitespace)` to
  `options.whitespace` — options has a default value, so the && guard
  is dead code and diverged from upstream.

Verified: python3 build/check.py and python3 build/build.py both pass
clean (0 errors).
---
 third_party/cml-cmcd/cmcd.js          | 2 ++
 third_party/cml-cmcd/cmcd_event.js    | 2 ++
 third_party/cml-cmcd/cmcd_response.js | 2 ++
 third_party/cml-cmcd/cml_sfv.js       | 4 +---
 4 files changed, 7 insertions(+), 3 deletions(-)

diff --git a/third_party/cml-cmcd/cmcd.js b/third_party/cml-cmcd/cmcd.js
index 534e98e32b..3af945e204 100644
--- a/third_party/cml-cmcd/cmcd.js
+++ b/third_party/cml-cmcd/cmcd.js
@@ -5,6 +5,8 @@
 
 goog.provide('cml.cmcd.Cmcd');
 
+goog.requireType('cml.cmcd.CmcdObjectTypeList');
+
 
 /**
  * Common Media Client Data (CMCD) version 2.
diff --git a/third_party/cml-cmcd/cmcd_event.js b/third_party/cml-cmcd/cmcd_event.js
index d43d641a7f..838119f98a 100644
--- a/third_party/cml-cmcd/cmcd_event.js
+++ b/third_party/cml-cmcd/cmcd_event.js
@@ -5,6 +5,8 @@
 
 goog.provide('cml.cmcd.CmcdEvent');
 
+goog.requireType('cml.cmcd.CmcdObjectTypeList');
+
 
 /**
  * Common Media Client Data (CMCD) version 2 - Event Mode.
diff --git a/third_party/cml-cmcd/cmcd_response.js b/third_party/cml-cmcd/cmcd_response.js
index 22205abcac..63f827277d 100644
--- a/third_party/cml-cmcd/cmcd_response.js
+++ b/third_party/cml-cmcd/cmcd_response.js
@@ -5,6 +5,8 @@
 
 goog.provide('cml.cmcd.CmcdResponse');
 
+goog.requireType('cml.cmcd.CmcdObjectTypeList');
+
 
 /**
  * Common Media Client Data (CMCD) version 2 - Response Mode.
diff --git a/third_party/cml-cmcd/cml_sfv.js b/third_party/cml-cmcd/cml_sfv.js
index f63a830e0d..4032406181 100644
--- a/third_party/cml-cmcd/cml_sfv.js
+++ b/third_party/cml-cmcd/cml_sfv.js
@@ -33,8 +33,6 @@ goog.provide('cml.cmcd.encodeSfDict');
 
 /**
  * Structured Field Item.
- *
- * @template V, P
  */
 cml.cmcd.SfItem = class {
   /**
@@ -424,7 +422,7 @@ cml.cmcd.encodeSfDict = function(dict, options = {whitespace: true}) {
   }
 
   const entries = dict instanceof Map ? dict.entries() : Object.entries(dict);
-  const optionalWhiteSpace = (options && options.whitespace) ? ' ' : '';
+  const optionalWhiteSpace = options.whitespace ? ' ' : '';
 
   return Array.from(entries)
       .map(([key, item]) => {

From 988712ea677183006d55eade7b27f8629c1dd4ed Mon Sep 17 00:00:00 2001
From: Casey Occhialini <1508707+littlespex@users.noreply.github.com>
Date: Tue, 28 Apr 2026 09:15:14 -0700
Subject: [PATCH 19/64] chore(cmcd): port CmcdReporter-only typedefs (deferred
 from sub-phase A)

Ports the 5 deferred typedefs that sub-phase A held back because they
are consumed only by `CmcdReporter` (sub-phase C):

- `CmcdReportConfig.ts` -> `cmcd_report_config.js`
- `CmcdEventReportConfig.ts` -> `cmcd_event_report_config.js`
- `CmcdRequestReportConfig.ts` -> `cmcd_request_report_config.js`
- `CmcdReporterConfig.ts` -> `cmcd_reporter_config.js`
- `CmcdRequestReport.ts` -> `cmcd_request_report.js`

TS interface inheritance (`extends`) collapses to inlined record fields
per the sub-phase A precedent. Generic parameters (`HttpRequest<D>`,
`CmcdRequestReport<D>`) erase; `HttpRequest`'s structural shape is
inlined into `CmcdRequestReport` since `@svta/cml-utils` is type-only
here.

Files wired into `build/types/core` alphabetically among the existing
`cml-cmcd/` block.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 build/types/core                              |  5 +++
 .../cml-cmcd/cmcd_event_report_config.js      | 35 +++++++++++++++++
 third_party/cml-cmcd/cmcd_report_config.js    | 23 +++++++++++
 third_party/cml-cmcd/cmcd_reporter_config.js  | 35 +++++++++++++++++
 third_party/cml-cmcd/cmcd_request_report.js   | 38 +++++++++++++++++++
 .../cml-cmcd/cmcd_request_report_config.js    | 31 +++++++++++++++
 6 files changed, 167 insertions(+)
 create mode 100644 third_party/cml-cmcd/cmcd_event_report_config.js
 create mode 100644 third_party/cml-cmcd/cmcd_report_config.js
 create mode 100644 third_party/cml-cmcd/cmcd_reporter_config.js
 create mode 100644 third_party/cml-cmcd/cmcd_request_report.js
 create mode 100644 third_party/cml-cmcd/cmcd_request_report_config.js

diff --git a/build/types/core b/build/types/core
index 85164f2d60..41d985cc24 100644
--- a/build/types/core
+++ b/build/types/core
@@ -146,6 +146,7 @@
 +../../third_party/cml-cmcd/cmcd_encode_options.js
 +../../third_party/cml-cmcd/cmcd_event.js
 +../../third_party/cml-cmcd/cmcd_event_keys.js
++../../third_party/cml-cmcd/cmcd_event_report_config.js
 +../../third_party/cml-cmcd/cmcd_event_type.js
 +../../third_party/cml-cmcd/cmcd_formatter.js
 +../../third_party/cml-cmcd/cmcd_formatter_map.js
@@ -165,10 +166,14 @@
 +../../third_party/cml-cmcd/cmcd_object_type_list.js
 +../../third_party/cml-cmcd/cmcd_param.js
 +../../third_party/cml-cmcd/cmcd_player_state.js
++../../third_party/cml-cmcd/cmcd_report_config.js
++../../third_party/cml-cmcd/cmcd_reporter_config.js
 +../../third_party/cml-cmcd/cmcd_reporting_mode.js
 +../../third_party/cml-cmcd/cmcd_request.js
 +../../third_party/cml-cmcd/cmcd_request_key.js
 +../../third_party/cml-cmcd/cmcd_request_keys.js
++../../third_party/cml-cmcd/cmcd_request_report.js
++../../third_party/cml-cmcd/cmcd_request_report_config.js
 +../../third_party/cml-cmcd/cmcd_response.js
 +../../third_party/cml-cmcd/cmcd_response_keys.js
 +../../third_party/cml-cmcd/cmcd_stream_type.js
diff --git a/third_party/cml-cmcd/cmcd_event_report_config.js b/third_party/cml-cmcd/cmcd_event_report_config.js
new file mode 100644
index 0000000000..d4bda73786
--- /dev/null
+++ b/third_party/cml-cmcd/cmcd_event_report_config.js
@@ -0,0 +1,35 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.CmcdEventReportConfig');
+
+goog.requireType('cml.cmcd.CmcdKey');
+goog.requireType('cml.cmcd.CmcdVersion');
+
+
+/**
+ * Configuration for a CMCD event report.
+ *
+ * Upstream CML expresses this as `CmcdReportConfig & {url, events,
+ * interval, batchSize}`. Closure typedefs cannot express type
+ * intersection; we list the union of all properties (report config +
+ * event-specific) directly. All members except `url` are optional;
+ * `url` is the only required field.
+ *
+ * Upstream further narrows `version` to `typeof CMCD_V2` (event mode
+ * is v2-only — v1 has no event mode); we keep the wider
+ * `cml.cmcd.CmcdVersion` typedef here since closure cannot express the
+ * narrowing constraint and runtime code already gates on `v2`.
+ *
+ * @typedef {{
+ *   version: (cml.cmcd.CmcdVersion|undefined),
+ *   enabledKeys: (!Array<cml.cmcd.CmcdKey>|undefined),
+ *   url: string,
+ *   events: (!Array<string>|undefined),
+ *   interval: (number|undefined),
+ *   batchSize: (number|undefined)
+ * }}
+ */
+cml.cmcd.CmcdEventReportConfig;
diff --git a/third_party/cml-cmcd/cmcd_report_config.js b/third_party/cml-cmcd/cmcd_report_config.js
new file mode 100644
index 0000000000..b54e3c618b
--- /dev/null
+++ b/third_party/cml-cmcd/cmcd_report_config.js
@@ -0,0 +1,23 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.CmcdReportConfig');
+
+goog.requireType('cml.cmcd.CmcdKey');
+goog.requireType('cml.cmcd.CmcdVersion');
+
+
+/**
+ * Configuration for a CMCD report.
+ *
+ * Upstream CML expresses this as a record type with two optional
+ * fields. All members optional.
+ *
+ * @typedef {{
+ *   version: (cml.cmcd.CmcdVersion|undefined),
+ *   enabledKeys: (!Array<cml.cmcd.CmcdKey>|undefined)
+ * }}
+ */
+cml.cmcd.CmcdReportConfig;
diff --git a/third_party/cml-cmcd/cmcd_reporter_config.js b/third_party/cml-cmcd/cmcd_reporter_config.js
new file mode 100644
index 0000000000..05c4f6b83e
--- /dev/null
+++ b/third_party/cml-cmcd/cmcd_reporter_config.js
@@ -0,0 +1,35 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.CmcdReporterConfig');
+
+goog.requireType('cml.cmcd.CmcdEventReportConfig');
+goog.requireType('cml.cmcd.CmcdKey');
+goog.requireType('cml.cmcd.CmcdVersion');
+
+
+/**
+ * Configuration for a CMCD reporting component.
+ *
+ * Upstream CML expresses this as `CmcdRequestReportConfig & {sid, cid,
+ * eventTargets}`. Closure typedefs cannot express type intersection;
+ * we list the union of all properties (request report config +
+ * reporter-specific) directly. All members optional.
+ *
+ * `transmissionMode` is a `cml.cmcd.CmcdTransmissionMode` value
+ * (`'query'` / `'headers'` / `'json'`); we use plain `string` here to
+ * avoid a circular `goog.require` between this typedef and the
+ * transmission-mode enum.
+ *
+ * @typedef {{
+ *   version: (cml.cmcd.CmcdVersion|undefined),
+ *   enabledKeys: (!Array<cml.cmcd.CmcdKey>|undefined),
+ *   transmissionMode: (string|undefined),
+ *   sid: (string|undefined),
+ *   cid: (string|undefined),
+ *   eventTargets: (!Array<cml.cmcd.CmcdEventReportConfig>|undefined)
+ * }}
+ */
+cml.cmcd.CmcdReporterConfig;
diff --git a/third_party/cml-cmcd/cmcd_request_report.js b/third_party/cml-cmcd/cmcd_request_report.js
new file mode 100644
index 0000000000..b44bf2f88c
--- /dev/null
+++ b/third_party/cml-cmcd/cmcd_request_report.js
@@ -0,0 +1,38 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.CmcdRequestReport');
+
+goog.requireType('cml.cmcd.Cmcd');
+
+
+/**
+ * A report of a CMCD request.
+ *
+ * Upstream CML expresses this as a generic `HttpRequest & {customData:
+ * {cmcd: Cmcd} & D; headers: Record<string, string>}`. Closure typedefs
+ * cannot express generics or type intersection; we list the structural
+ * superset of fields (`HttpRequest` shape — `url`, `method`, `body`,
+ * `headers`, `customData`, etc. — plus the required `customData.cmcd`
+ * narrowing). The generic `D` parameter erases; callers extending
+ * `customData` with additional fields treat them as untyped extensions.
+ *
+ * `body`, `responseType`, `credentials`, `mode` widen to `*` /
+ * `string` since their upstream types come from `@svta/cml-utils`'
+ * `HttpRequest` (and DOM lib types) which are erased here.
+ *
+ * @typedef {{
+ *   url: string,
+ *   method: (string|undefined),
+ *   body: (*|undefined),
+ *   responseType: (string|undefined),
+ *   headers: !Object<string, string>,
+ *   credentials: (string|undefined),
+ *   mode: (string|undefined),
+ *   timeout: (number|undefined),
+ *   customData: {cmcd: !cml.cmcd.Cmcd}
+ * }}
+ */
+cml.cmcd.CmcdRequestReport;
diff --git a/third_party/cml-cmcd/cmcd_request_report_config.js b/third_party/cml-cmcd/cmcd_request_report_config.js
new file mode 100644
index 0000000000..85134a983f
--- /dev/null
+++ b/third_party/cml-cmcd/cmcd_request_report_config.js
@@ -0,0 +1,31 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.CmcdRequestReportConfig');
+
+goog.requireType('cml.cmcd.CmcdKey');
+goog.requireType('cml.cmcd.CmcdVersion');
+
+
+/**
+ * Configuration for a CMCD request report.
+ *
+ * Upstream CML expresses this as `CmcdReportConfig & {transmissionMode}`.
+ * Closure typedefs cannot express type intersection; we list the union
+ * of all properties (report config + request-specific) directly. All
+ * members optional.
+ *
+ * `transmissionMode` is a `cml.cmcd.CmcdTransmissionMode` value
+ * (`'query'` / `'headers'` / `'json'`); we use plain `string` here to
+ * avoid a circular `goog.require` between this typedef and the
+ * transmission-mode enum.
+ *
+ * @typedef {{
+ *   version: (cml.cmcd.CmcdVersion|undefined),
+ *   enabledKeys: (!Array<cml.cmcd.CmcdKey>|undefined),
+ *   transmissionMode: (string|undefined)
+ * }}
+ */
+cml.cmcd.CmcdRequestReportConfig;

From 3de73b29b8662c88b398a3ca8750e3c817a065d7 Mon Sep 17 00:00:00 2001
From: Casey Occhialini <1508707+littlespex@users.noreply.github.com>
Date: Tue, 28 Apr 2026 09:23:43 -0700
Subject: [PATCH 20/64] chore(cmcd): port cml-cmcd CmcdReporter to closure
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Final vendored-port file for sub-phase C: ports `CmcdReporter.ts`
(~459 lines) to `cmcd_reporter.js` as a Closure ES6 class. With this
commit, the entire `third_party/cml-cmcd/` port is complete; sub-phase
D will start delegating shaka's `CmcdManager` through CML.

Constructor signature `(config, requester)` preserved as positional
args (per `cml-version.md` Task 0.4 / 0.8 verification — NOT a single
config object). Public surface exposed: `start`, `stop(flush)`,
`flush`, `update(partialState)`, `recordEvent(type, data)`,
`createRequestReport(request, data)`, `recordResponseReceived(response,
data)`. Internal helpers (`processEventTargets_`, `sendEventReport_`,
`recordTargetEvent_`, `resetSession_`) preserved verbatim.

TS-to-Closure idioms applied:
- TS class private fields (`private foo`) → Closure trailing-underscore
  fields with `@private`
- `keyof` / `ValueOf<>` generics erase; widen to `string` / `*`
- Type intersections (`CmcdReporterConfigNormalized = CmcdReporterConfig
  & {sid, eventTargets}`) → inline record fields per sub-phase A
  precedent
- Generic method signatures (`<R extends HttpRequest>`) erase
- Module-scope helpers (`createEncodingOptions`,
  `createCmcdReporterConfig`) namespaced under `cml.cmcd.CmcdReporter_*_`

Shim surface extension:
- `cml.cmcd.defaultRequester` added to `cml_utils.js`. Wraps `fetch` in
  the same dead-codepath pattern as `cml.cmcd.uuid` — shaka adapter
  always supplies a custom requester via NetworkingEngine, so this is
  Closure-strippable.

Conformance whitelist extensions (one entry each):
- `setInterval` and `window.setInterval` → `cmcd_reporter.js`. Upstream
  uses `setInterval` directly in `start()`; replacing with
  `shaka.util.Timer` would break the verbatim-port property and the
  per-bump diff stability.
- `fetch` → `cml_utils.js` (for the dead-codepath `defaultRequester`
  shim only).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 build/conformance.textproto           |   3 +
 build/types/core                      |   1 +
 third_party/cml-cmcd/SUMMARY.txt      |  20 +
 third_party/cml-cmcd/cmcd_reporter.js | 582 ++++++++++++++++++++++++++
 third_party/cml-cmcd/cml_utils.js     |  26 ++
 5 files changed, 632 insertions(+)
 create mode 100644 third_party/cml-cmcd/cmcd_reporter.js

diff --git a/build/conformance.textproto b/build/conformance.textproto
index e446c07021..127a9350e8 100644
--- a/build/conformance.textproto
+++ b/build/conformance.textproto
@@ -236,6 +236,7 @@ requirement: {
   whitelist_regexp: "demo/"
   whitelist_regexp: "test/"
   whitelist_regexp: "lib/util/timer.js"
+  whitelist_regexp: "third_party/cml-cmcd/cmcd_reporter.js"
 }
 requirement: {
   type: BANNED_NAME
@@ -248,6 +249,7 @@ requirement: {
   whitelist_regexp: "demo/"
   whitelist_regexp: "test/"
   whitelist_regexp: "lib/util/timer.js"
+  whitelist_regexp: "third_party/cml-cmcd/cmcd_reporter.js"
 }
 
 # Disallow setTimeout.
@@ -313,6 +315,7 @@ requirement: {
     "instead."
   whitelist_regexp: "lib/net/http_fetch_plugin.js"
   whitelist_regexp: "test/test/util/util.js"
+  whitelist_regexp: "third_party/cml-cmcd/cml_utils.js"
 }
 
 # Disallow the general use of AbortController, which is not available on all
diff --git a/build/types/core b/build/types/core
index 41d985cc24..4dd0800a15 100644
--- a/build/types/core
+++ b/build/types/core
@@ -167,6 +167,7 @@
 +../../third_party/cml-cmcd/cmcd_param.js
 +../../third_party/cml-cmcd/cmcd_player_state.js
 +../../third_party/cml-cmcd/cmcd_report_config.js
++../../third_party/cml-cmcd/cmcd_reporter.js
 +../../third_party/cml-cmcd/cmcd_reporter_config.js
 +../../third_party/cml-cmcd/cmcd_reporting_mode.js
 +../../third_party/cml-cmcd/cmcd_request.js
diff --git a/third_party/cml-cmcd/SUMMARY.txt b/third_party/cml-cmcd/SUMMARY.txt
index b142157207..e69cf08c51 100644
--- a/third_party/cml-cmcd/SUMMARY.txt
+++ b/third_party/cml-cmcd/SUMMARY.txt
@@ -26,6 +26,8 @@ cml-cmcd
     - cml-utils dep absorbed into `cml_utils.js` shim:
         * `uuid` (wraps `crypto.randomUUID()`; dead-codepath for shaka)
         * `urlToRelativePath` (used by `CMCD_FORMATTER_MAP`'s `nor`)
+        * `defaultRequester` (wraps `fetch`; dead-codepath for shaka —
+          adapter always supplies a custom requester via NetworkingEngine)
     - structured-field-values dep absorbed into `cml_sfv.js` shim:
         * `SfItem` / `SfToken` runtime classes
         * `encodeSfDict` (RFC 8941 §4.1 dictionary serializer; pulls in
@@ -37,3 +39,21 @@ cml-cmcd
       only in case (e.g., `CmcdV1.ts` typedef + `CMCD_V1.ts` numeric const
       → `cmcd_v1.js` + `cmcd_v1_const.js`). Affects v1, v2, HEADER_MAP,
       and FORMATTER_MAP.
+    - `CmcdReporter` constructor: TS class private fields (`#field` /
+      `private`) translate to Closure trailing-underscore-named fields
+      with `@private` (`this.requestTarget_`, `this.config_`, etc.).
+      Constructor positional signature `(config, requester)` preserved.
+      Internal helpers (`processEventTargets`, `sendEventReport`,
+      `recordTargetEvent`, `resetSession`) are trailing-underscore
+      methods. Module-scope helpers (`createEncodingOptions`,
+      `createCmcdReporterConfig`) are namespaced under
+      `cml.cmcd.CmcdReporter_*_`. State machine (per-target sequence
+      counters, sid-change reset, batching/flushing) preserved
+      verbatim.
+    - `setInterval` whitelisted in build/conformance.textproto for
+      `cmcd_reporter.js`. Upstream uses `setInterval` directly in
+      `start()`; replacing with `shaka.util.Timer` would break the
+      verbatim-port property and the per-bump diff stability, so the
+      conformance allowlist is extended for this single file.
+      `fetch` whitelisted for the dead-codepath `defaultRequester`
+      shim in `cml_utils.js`.
diff --git a/third_party/cml-cmcd/cmcd_reporter.js b/third_party/cml-cmcd/cmcd_reporter.js
new file mode 100644
index 0000000000..5d640e43fe
--- /dev/null
+++ b/third_party/cml-cmcd/cmcd_reporter.js
@@ -0,0 +1,582 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.CmcdReporter');
+
+goog.require('cml.cmcd.CMCD_DEFAULT_TIME_INTERVAL');
+goog.require('cml.cmcd.CMCD_EVENT_MODE');
+goog.require('cml.cmcd.CMCD_EVENT_RESPONSE_RECEIVED');
+goog.require('cml.cmcd.CMCD_EVENT_TIME_INTERVAL');
+goog.require('cml.cmcd.CMCD_HEADERS');
+goog.require('cml.cmcd.CMCD_MIME_TYPE');
+goog.require('cml.cmcd.CMCD_PARAM');
+goog.require('cml.cmcd.CMCD_QUERY');
+goog.require('cml.cmcd.CMCD_REQUEST_MODE');
+goog.require('cml.cmcd.CMCD_V2');
+goog.require('cml.cmcd.CmcdEventType');
+goog.require('cml.cmcd.defaultRequester');
+goog.require('cml.cmcd.encodeCmcd');
+goog.require('cml.cmcd.encodePreparedCmcd');
+goog.require('cml.cmcd.prepareCmcdData');
+goog.require('cml.cmcd.toPreparedCmcdHeaders');
+goog.require('cml.cmcd.uuid');
+goog.requireType('cml.cmcd.Cmcd');
+goog.requireType('cml.cmcd.CmcdEncodeOptions');
+goog.requireType('cml.cmcd.CmcdEventReportConfig');
+goog.requireType('cml.cmcd.CmcdReportConfig');
+goog.requireType('cml.cmcd.CmcdReporterConfig');
+goog.requireType('cml.cmcd.CmcdRequestReport');
+
+
+/**
+ * @typedef {{
+ *   sn: number,
+ *   msdSent: boolean
+ * }}
+ * @private
+ */
+cml.cmcd.CmcdReporter_CmcdTarget_;
+
+
+/**
+ * @typedef {{
+ *   sn: number,
+ *   msdSent: boolean,
+ *   intervalId: (number|undefined),
+ *   queue: !Array<!cml.cmcd.Cmcd>
+ * }}
+ * @private
+ */
+cml.cmcd.CmcdReporter_CmcdEventTarget_;
+
+
+/**
+ * Build the encoder options for a given reporting mode + report config.
+ *
+ * @param {string} reportingMode
+ * @param {!cml.cmcd.CmcdReportConfig} config
+ * @param {string=} baseUrl
+ * @return {!cml.cmcd.CmcdEncodeOptions}
+ * @private
+ */
+cml.cmcd.CmcdReporter_createEncodingOptions_ = function(
+    reportingMode, config, baseUrl) {
+  const enabledKeySet = new Set(config.enabledKeys || []);
+
+  return {
+    version: config.version || cml.cmcd.CMCD_V2,
+    reportingMode: reportingMode,
+    filter: (key) => enabledKeySet.has(key),
+    baseUrl: baseUrl,
+  };
+};
+
+
+/**
+ * Apply config defaults to produce a fully-normalized
+ * `CmcdReporterConfigNormalized`-equivalent shape.
+ *
+ * Upstream returns a TS intersection type
+ * (`CmcdReporterConfig & {sid, eventTargets, version, transmissionMode}`);
+ * we return a plain object literal with the same keys.
+ *
+ * @param {!cml.cmcd.CmcdReporterConfig} config
+ * @return {!cml.cmcd.CmcdReporterConfig}
+ * @private
+ */
+cml.cmcd.CmcdReporter_createCmcdReporterConfig_ = function(config) {
+  // Apply top-level config defaults
+  const version = config.version || cml.cmcd.CMCD_V2;
+  const eventTargets = config.eventTargets || [];
+  const sid = config.sid || cml.cmcd.uuid();
+  const transmissionMode = config.transmissionMode || cml.cmcd.CMCD_QUERY;
+
+  /** @type {!Array<!cml.cmcd.CmcdEventReportConfig>} */
+  const normalizedEventTargets = [];
+
+  for (const target of eventTargets) {
+    if (target && target.url && target.events && target.events.length) {
+      /** @type {!Array<string>} */
+      const enabledKeysCopy = target.enabledKeys ?
+          /** @type {!Array<string>} */ ([]).concat(target.enabledKeys) : [];
+      /** @type {!Array<string>} */
+      const eventsCopy =
+          /** @type {!Array<string>} */ ([]).concat(target.events);
+      normalizedEventTargets.push({
+        version: target.version || cml.cmcd.CMCD_V2,
+        enabledKeys: enabledKeysCopy,
+        url: target.url,
+        events: eventsCopy,
+        interval: target.interval != null ?
+            target.interval : cml.cmcd.CMCD_DEFAULT_TIME_INTERVAL,
+        batchSize: target.batchSize || 1,
+      });
+    }
+  }
+
+  /** @type {!cml.cmcd.CmcdReporterConfig} */
+  const normalized = /** @type {!cml.cmcd.CmcdReporterConfig} */ (
+      Object.assign({}, config, {
+        version: version,
+        transmissionMode: transmissionMode,
+        sid: sid,
+        cid: config.cid,
+        enabledKeys: config.enabledKeys,
+        eventTargets: normalizedEventTargets,
+      }));
+
+  return normalized;
+};
+
+
+/**
+ * The CMCD reporter.
+ *
+ * @see {@link https://cta-wave.github.io/Resources/common-media-client-data--cta-5004-b.html#reporting-modes-when-we-send-data}
+ */
+cml.cmcd.CmcdReporter = class {
+  /**
+   * Creates a new CMCD reporter.
+   *
+   * @param {!cml.cmcd.CmcdReporterConfig} config The configuration for
+   *   the CMCD reporter.
+   * @param {(function(!Object): !Promise<{status: number}>)=} requester
+   *   The function to use to send the request. The default is a simple
+   *   wrapper around the native `fetch` API.
+   */
+  constructor(config, requester) {
+    /** @private {number} */
+    this.timeOrigin_ = performance.timeOrigin ||
+        (performance.timing && performance.timing.fetchStart) ||
+        (Date.now() - performance.now());
+
+    /** @private {!cml.cmcd.Cmcd} */
+    this.data_ = /** @type {!cml.cmcd.Cmcd} */ ({});
+
+    /** @private {!cml.cmcd.CmcdReporterConfig} */
+    this.config_ = cml.cmcd.CmcdReporter_createCmcdReporterConfig_(config);
+
+    /** @private {number} */
+    this.msd_ = NaN;
+
+    /**
+     * @private {!Map<!cml.cmcd.CmcdEventReportConfig,
+     *   !cml.cmcd.CmcdReporter_CmcdEventTarget_>}
+     */
+    this.eventTargets_ = new Map();
+
+    /** @private {!cml.cmcd.CmcdReporter_CmcdTarget_} */
+    this.requestTarget_ = {
+      sn: 0,
+      msdSent: false,
+    };
+
+    /** @private {function(!Object): !Promise<{status: number}>} */
+    this.requester_ = requester || cml.cmcd.defaultRequester;
+
+    this.data_ = /** @type {!cml.cmcd.Cmcd} */ ({
+      cid: this.config_.cid,
+      sid: this.config_.sid,
+      v: this.config_.version,
+    });
+
+    for (const target of this.config_.eventTargets || []) {
+      this.eventTargets_.set(target, {
+        intervalId: undefined,
+        sn: 0,
+        msdSent: false,
+        queue: [],
+      });
+    }
+  }
+
+  /**
+   * Starts the CMCD reporter. Called by the player when the reporter
+   * is enabled.
+   *
+   * Note: This fires an initial time-interval event immediately
+   * (synchronously) before the first interval elapses. Ensure CMCD
+   * data (sid, cid, etc.) is populated before calling start().
+   */
+  start() {
+    this.eventTargets_.forEach((target, config) => {
+      // If the interval is 0 or the TIME_INTERVAL event is not enabled,
+      // do not start the interval.
+      if (config.interval === 0 ||
+          !config.events ||
+          !config.events.includes(cml.cmcd.CmcdEventType.TIME_INTERVAL)) {
+        return;
+      }
+
+      const timeIntervalEvent = () => {
+        this.recordTargetEvent_(
+            target, config, cml.cmcd.CMCD_EVENT_TIME_INTERVAL);
+        this.processEventTargets_();
+      };
+
+      target.intervalId = setInterval(
+          timeIntervalEvent, /** @type {number} */ (config.interval) * 1000);
+      timeIntervalEvent();
+    });
+  }
+
+  /**
+   * Stops the CMCD reporter. Called by the player when the reporter is
+   * disabled.
+   *
+   * @param {boolean=} flush Whether to flush the event targets.
+   */
+  stop(flush = false) {
+    if (flush) {
+      this.flush();
+    }
+
+    this.eventTargets_.forEach((target) => {
+      clearInterval(target.intervalId);
+    });
+  }
+
+  /**
+   * Forces the sending of all event reports, regardless of the batch
+   * size or interval. Useful for sending outstanding reports when the
+   * player is destroyed or a playback session ends.
+   */
+  flush() {
+    this.processEventTargets_(true);
+  }
+
+  /**
+   * Updates the CMCD data. Called by the player when the data changes.
+   *
+   * @param {!cml.cmcd.Cmcd} data The data to update.
+   */
+  update(data) {
+    if (data.sid && data.sid !== this.data_.sid) {
+      this.resetSession_();
+    }
+
+    if (data.msd && !isNaN(data.msd)) {
+      this.msd_ = data.msd;
+    }
+
+    // msd is tracked separately via this.msd_ and sent once per target,
+    // so it is stripped from the persistent data store after each
+    // update.
+    this.data_ = /** @type {!cml.cmcd.Cmcd} */ (
+        Object.assign({}, this.data_, data, {msd: undefined}));
+  }
+
+  /**
+   * Records an event. Called by the player when an event occurs.
+   *
+   * @param {string} type The type of event to record.
+   * @param {!cml.cmcd.Cmcd=} data Additional data to record with the
+   *   event. This data only applies to this event report. Persistent
+   *   data should be updated using `update()`.
+   */
+  recordEvent(type, data) {
+    const eventData = data || /** @type {!cml.cmcd.Cmcd} */ ({});
+    this.eventTargets_.forEach((target, config) => {
+      this.recordTargetEvent_(target, config, type, eventData);
+    });
+
+    this.processEventTargets_();
+  }
+
+  /**
+   * Records an event for a target. Called by the reporter when an
+   * event occurs.
+   *
+   * @param {!cml.cmcd.CmcdReporter_CmcdEventTarget_} target The target
+   *   to record the event for.
+   * @param {!cml.cmcd.CmcdEventReportConfig} config The configuration
+   *   for the target.
+   * @param {string} type The type of event to record.
+   * @param {!cml.cmcd.Cmcd=} data Additional data to record with the
+   *   event. This data only applies to this event report. Persistent
+   *   data should be updated using `update()`.
+   * @private
+   */
+  recordTargetEvent_(target, config, type, data) {
+    const eventData = data || /** @type {!cml.cmcd.Cmcd} */ ({});
+    if (!config.events || !config.events.includes(type)) {
+      return;
+    }
+
+    /** @type {!cml.cmcd.Cmcd} */
+    const item = /** @type {!cml.cmcd.Cmcd} */ (
+        Object.assign({}, this.data_, eventData, {
+          e: type,
+          ts: eventData.ts != null ? eventData.ts : Date.now(),
+          sn: target.sn++,
+        }));
+
+    if (!isNaN(this.msd_) && !target.msdSent) {
+      item.msd = this.msd_;
+      target.msdSent = true;
+    }
+
+    target.queue.push(item);
+  }
+
+  /**
+   * Records a response-received event. Called by the player when a
+   * media request response has been fully received.
+   *
+   * This method automatically derives the `rr` event keys from the
+   *
+   * - `url` - the original requested URL (before any redirects)
+   * - `rc` - the HTTP response status code
+   * - `ts` - the request initiation time (from `resourceTiming.startTime`)
+   * - `ttfb` - time to first byte (from `resourceTiming.responseStart`)
+   * - `ttlb` - time to last byte (from `resourceTiming.duration`)
+   *
+   * Additional keys like `ttfbb`, `cmsdd`, `cmsds`, and `smrt` can be
+   * supplied via the `data` parameter if the player has access to
+   * them.
+   *
+   * @param {!Object} response The HTTP response received. Upstream
+   *   shape: `HttpResponse<HttpRequest<{cmcd?: Cmcd}>>` —
+   *   `{request: {url, customData?: {cmcd?: Cmcd}}, status?,
+   *   resourceTiming?: {startTime, responseStart, duration}}`.
+   * @param {!cml.cmcd.Cmcd=} data Additional CMCD data to include with
+   *   the event. Values provided here override any auto-derived
+   *   values.
+   */
+  recordResponseReceived(response, data) {
+    const responseData = data || /** @type {!cml.cmcd.Cmcd} */ ({});
+    const r = /** @type {!Object<string, *>} */ (response);
+    const request = /** @type {!Object<string, *>} */ (r['request'] || {});
+    const status = /** @type {(number|undefined)} */ (r['status']);
+    const timing = /** @type {?{startTime: (number|undefined),
+        responseStart: (number|undefined), duration: (number|undefined)}} */ (
+        r['resourceTiming'] || null);
+
+    const url = responseData.url != null ?
+        responseData.url :
+        /** @type {(string|undefined)} */ (request['url']);
+
+    if (!url) {
+      return;
+    }
+
+    const urlObj = new URL(/** @type {string} */ (url));
+    urlObj.searchParams.delete(cml.cmcd.CMCD_PARAM);
+
+    /** @type {!cml.cmcd.Cmcd} */
+    const derived = /** @type {!cml.cmcd.Cmcd} */ ({
+      url: urlObj.toString(),
+      rc: status,
+    });
+
+    if (timing) {
+      if (timing.startTime != null) {
+        derived.ts = Math.round(this.timeOrigin_ + timing.startTime);
+
+        if (timing.responseStart != null) {
+          derived.ttfb = Math.round(timing.responseStart - timing.startTime);
+        }
+      }
+
+      if (timing.duration != null) {
+        derived.ttlb = Math.round(timing.duration);
+      }
+    }
+
+    const reqCustomData =
+        /** @type {!Object<string, *>} */ (request['customData'] || {});
+    const cmcd = /** @type {!cml.cmcd.Cmcd} */ (
+        reqCustomData['cmcd'] || /** @type {!cml.cmcd.Cmcd} */ ({}));
+
+    this.recordEvent(
+        cml.cmcd.CMCD_EVENT_RESPONSE_RECEIVED,
+        /** @type {!cml.cmcd.Cmcd} */ (
+            Object.assign({}, cmcd, derived, responseData)));
+  }
+
+  /**
+   * Applies the CMCD request report data to the request. Called by the
+   * player before sending the request.
+   *
+   * @param {!Object} req The request to apply the CMCD request report
+   *   to.
+   * @return {!Object} The request with the CMCD request report
+   *   applied.
+   *
+   * @deprecated Use `createRequestReport` instead.
+   */
+  applyRequestReport(req) {
+    return this.createRequestReport(req) || req;
+  }
+
+  /**
+   * Checks if the request reporting is enabled.
+   *
+   * @return {boolean} `true` if the request reporting is enabled,
+   *   `false` otherwise.
+   */
+  isRequestReportingEnabled() {
+    return !!(this.config_.enabledKeys && this.config_.enabledKeys.length);
+  }
+
+  /**
+   * Creates a new request with the CMCD request report data applied.
+   * Called by the player before sending the request.
+   *
+   * Upstream signature is generic
+   * (`<R extends HttpRequest>(request: R, data?: Partial<Cmcd>): R &
+   * CmcdRequestReport<R['customData']>`); the generic erases in
+   * Closure.
+   *
+   * @param {!Object} request The request to apply the CMCD request
+   *   report to.
+   * @param {!cml.cmcd.Cmcd=} data The data to apply to the request.
+   *   This data only applies to this request report. Persistent data
+   *   should be updated using `update()`.
+   * @return {!cml.cmcd.CmcdRequestReport} The request with the CMCD
+   *   request report applied.
+   */
+  createRequestReport(request, data) {
+    const r = /** @type {!Object<string, *>} */ (request);
+    const customData =
+        /** @type {!Object<string, *>} */ (r['customData'] || {});
+    const headers =
+        /** @type {!Object<string, string>} */ (r['headers'] || {});
+
+    /** @type {!cml.cmcd.CmcdRequestReport} */
+    const report = /** @type {!cml.cmcd.CmcdRequestReport} */ (
+        Object.assign({}, request, {
+          headers: Object.assign({}, headers),
+          customData: Object.assign({}, customData, {
+            cmcd: /** @type {!cml.cmcd.Cmcd} */ ({}),
+          }),
+        }));
+
+    if (!this.config_.enabledKeys ||
+        !this.config_.enabledKeys.length ||
+        !report.url) {
+      return report;
+    }
+
+    const url = new URL(report.url);
+    /** @type {!cml.cmcd.Cmcd} */
+    const cmcdData = /** @type {!cml.cmcd.Cmcd} */ (
+        Object.assign({}, this.data_, data || {}, {
+          sn: this.requestTarget_.sn++,
+        }));
+    const options = cml.cmcd.CmcdReporter_createEncodingOptions_(
+        cml.cmcd.CMCD_REQUEST_MODE, this.config_, url.origin);
+
+    if (!isNaN(this.msd_) && !this.requestTarget_.msdSent) {
+      cmcdData.msd = this.msd_;
+      this.requestTarget_.msdSent = true;
+    }
+
+    const cmcd = report.customData.cmcd =
+        cml.cmcd.prepareCmcdData(cmcdData, options);
+
+    switch (this.config_.transmissionMode) {
+      case cml.cmcd.CMCD_QUERY: {
+        const param = cml.cmcd.encodePreparedCmcd(cmcd);
+        if (param) {
+          url.searchParams.set(cml.cmcd.CMCD_PARAM, param);
+          report.url = url.toString();
+        }
+        break;
+      }
+
+      case cml.cmcd.CMCD_HEADERS:
+        Object.assign(
+            report.headers,
+            cml.cmcd.toPreparedCmcdHeaders(cmcd, options.customHeaderMap));
+        break;
+    }
+
+    return report;
+  }
+
+  /**
+   * Processes the event targets. Called by the reporter when an event
+   * occurs.
+   *
+   * @param {boolean=} flush Whether to flush the event targets.
+   * @private
+   */
+  processEventTargets_(flush = false) {
+    let reprocess = false;
+
+    this.eventTargets_.forEach((target, config) => {
+      const queue = target.queue;
+
+      if (!queue.length) {
+        return;
+      }
+
+      if (queue.length < /** @type {number} */ (config.batchSize) && !flush) {
+        return;
+      }
+
+      const deleteCount = flush ?
+          queue.length : /** @type {number} */ (config.batchSize);
+      const events = queue.splice(0, deleteCount);
+      this.sendEventReport_(config, events).catch(() => {
+        // Re-queue events that failed to send
+        target.queue.unshift(...events);
+      });
+
+      reprocess = reprocess || queue.length > 0;
+    });
+
+    if (reprocess) {
+      this.processEventTargets_();
+    }
+  }
+
+  /**
+   * Sends an event report. Called by the reporter when a batch is
+   * ready to be sent.
+   *
+   * @param {!cml.cmcd.CmcdEventReportConfig} target The target to send
+   *   the event report to.
+   * @param {!Array<!cml.cmcd.Cmcd>} data The data to send in the event
+   *   report.
+   * @return {!Promise<void>}
+   * @private
+   */
+  async sendEventReport_(target, data) {
+    const options = cml.cmcd.CmcdReporter_createEncodingOptions_(
+        cml.cmcd.CMCD_EVENT_MODE, target);
+    const response = await this.requester_({
+      url: target.url,
+      method: 'POST',
+      headers: {
+        'Content-Type': cml.cmcd.CMCD_MIME_TYPE,
+      },
+      body: data.map((item) => cml.cmcd.encodeCmcd(item, options)).join('\n') +
+          '\n',
+    });
+
+    const status = response.status;
+
+    if (status === 410) {
+      this.eventTargets_.delete(target);
+    } else if (status === 429 || (status > 499 && status < 600)) {
+      throw new Error(`Event report failed with status ${status}`);
+    }
+  }
+
+  /**
+   * Resets the session related data. Called when the session ID
+   * changes.
+   *
+   * @private
+   */
+  resetSession_() {
+    this.eventTargets_.forEach((target) => {
+      target.sn = 0;
+    });
+    this.requestTarget_.sn = 0;
+  }
+};
diff --git a/third_party/cml-cmcd/cml_utils.js b/third_party/cml-cmcd/cml_utils.js
index 52eed4f1a9..f6b792d7ca 100644
--- a/third_party/cml-cmcd/cml_utils.js
+++ b/third_party/cml-cmcd/cml_utils.js
@@ -3,6 +3,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+goog.provide('cml.cmcd.defaultRequester');
 goog.provide('cml.cmcd.urlToRelativePath');
 goog.provide('cml.cmcd.uuid');
 
@@ -25,6 +26,31 @@ goog.provide('cml.cmcd.uuid');
 cml.cmcd.uuid = () => crypto.randomUUID();
 
 
+/**
+ * Default `requester` shim for the vendored `CmcdReporter`.
+ *
+ * Upstream CML defines this inline in `CmcdReporter.ts`'s module scope
+ * (`function defaultRequester(request)` -> `fetch(url, init)`). The
+ * shaka adapter always supplies a custom `requester` callback that
+ * routes through `NetworkingEngine`, so this codepath is dead at
+ * runtime — Closure ADVANCED will strip it. Kept here so the
+ * `CmcdReporter` constructor's default-parameter shape stays verbatim
+ * to upstream and per-bump diffs stay trivial.
+ *
+ * Centralized in this shim file so the conformance whitelist for
+ * `fetch` can stay scoped to a single dead-code wrapper.
+ *
+ * @param {!Object} request The CMCD event-mode request to dispatch.
+ * @return {!Promise<{status: number}>}
+ */
+cml.cmcd.defaultRequester = function(request) {
+  const url = /** @type {{url: string}} */ (request).url;
+  const init = Object.assign({}, request);
+  delete init['url'];
+  return fetch(url, /** @type {!RequestInit} */ (init));
+};
+
+
 /**
  * Constructs a relative path from a URL.
  *

From d682bb1bbeda2d9fe636feb6b5e6210dd460bb76 Mon Sep 17 00:00:00 2001
From: Casey Occhialini <1508707+littlespex@users.noreply.github.com>
Date: Tue, 28 Apr 2026 09:49:20 -0700
Subject: [PATCH 21/64] fix(cmcd): tighten transmissionMode typedef, unify ??
 fallbacks in reporter

- cmcd_reporter_config.js and cmcd_request_report_config.js: typedef
  field 'transmissionMode' was widened to plain 'string' with an
  incorrect comment about avoiding a circular goog.require.
  CmcdTransmissionMode has zero requires, so there's no cycle.
  Tighten to cml.cmcd.CmcdTransmissionMode with goog.requireType.
- cmcd_reporter.js: lines 391 and 411 used '||' falsy fallback while
  other sites in the same file use the faithful '!= null ?' form.
  Unify to '!= null ?' for consistency with upstream's '??' semantics.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 third_party/cml-cmcd/cmcd_reporter.js              | 6 ++++--
 third_party/cml-cmcd/cmcd_reporter_config.js       | 8 ++------
 third_party/cml-cmcd/cmcd_request_report_config.js | 8 ++------
 3 files changed, 8 insertions(+), 14 deletions(-)

diff --git a/third_party/cml-cmcd/cmcd_reporter.js b/third_party/cml-cmcd/cmcd_reporter.js
index 5d640e43fe..b69125ef98 100644
--- a/third_party/cml-cmcd/cmcd_reporter.js
+++ b/third_party/cml-cmcd/cmcd_reporter.js
@@ -388,7 +388,8 @@ cml.cmcd.CmcdReporter = class {
     const reqCustomData =
         /** @type {!Object<string, *>} */ (request['customData'] || {});
     const cmcd = /** @type {!cml.cmcd.Cmcd} */ (
-        reqCustomData['cmcd'] || /** @type {!cml.cmcd.Cmcd} */ ({}));
+        reqCustomData['cmcd'] != null ?
+            reqCustomData['cmcd'] : /** @type {!cml.cmcd.Cmcd} */ ({}));
 
     this.recordEvent(
         cml.cmcd.CMCD_EVENT_RESPONSE_RECEIVED,
@@ -408,7 +409,8 @@ cml.cmcd.CmcdReporter = class {
    * @deprecated Use `createRequestReport` instead.
    */
   applyRequestReport(req) {
-    return this.createRequestReport(req) || req;
+    const result = this.createRequestReport(req);
+    return result != null ? result : req;
   }
 
   /**
diff --git a/third_party/cml-cmcd/cmcd_reporter_config.js b/third_party/cml-cmcd/cmcd_reporter_config.js
index 05c4f6b83e..07766ee0d8 100644
--- a/third_party/cml-cmcd/cmcd_reporter_config.js
+++ b/third_party/cml-cmcd/cmcd_reporter_config.js
@@ -7,6 +7,7 @@ goog.provide('cml.cmcd.CmcdReporterConfig');
 
 goog.requireType('cml.cmcd.CmcdEventReportConfig');
 goog.requireType('cml.cmcd.CmcdKey');
+goog.requireType('cml.cmcd.CmcdTransmissionMode');
 goog.requireType('cml.cmcd.CmcdVersion');
 
 
@@ -18,15 +19,10 @@ goog.requireType('cml.cmcd.CmcdVersion');
  * we list the union of all properties (request report config +
  * reporter-specific) directly. All members optional.
  *
- * `transmissionMode` is a `cml.cmcd.CmcdTransmissionMode` value
- * (`'query'` / `'headers'` / `'json'`); we use plain `string` here to
- * avoid a circular `goog.require` between this typedef and the
- * transmission-mode enum.
- *
  * @typedef {{
  *   version: (cml.cmcd.CmcdVersion|undefined),
  *   enabledKeys: (!Array<cml.cmcd.CmcdKey>|undefined),
- *   transmissionMode: (string|undefined),
+ *   transmissionMode: (cml.cmcd.CmcdTransmissionMode|undefined),
  *   sid: (string|undefined),
  *   cid: (string|undefined),
  *   eventTargets: (!Array<cml.cmcd.CmcdEventReportConfig>|undefined)
diff --git a/third_party/cml-cmcd/cmcd_request_report_config.js b/third_party/cml-cmcd/cmcd_request_report_config.js
index 85134a983f..5851ff0480 100644
--- a/third_party/cml-cmcd/cmcd_request_report_config.js
+++ b/third_party/cml-cmcd/cmcd_request_report_config.js
@@ -6,6 +6,7 @@
 goog.provide('cml.cmcd.CmcdRequestReportConfig');
 
 goog.requireType('cml.cmcd.CmcdKey');
+goog.requireType('cml.cmcd.CmcdTransmissionMode');
 goog.requireType('cml.cmcd.CmcdVersion');
 
 
@@ -17,15 +18,10 @@ goog.requireType('cml.cmcd.CmcdVersion');
  * of all properties (report config + request-specific) directly. All
  * members optional.
  *
- * `transmissionMode` is a `cml.cmcd.CmcdTransmissionMode` value
- * (`'query'` / `'headers'` / `'json'`); we use plain `string` here to
- * avoid a circular `goog.require` between this typedef and the
- * transmission-mode enum.
- *
  * @typedef {{
  *   version: (cml.cmcd.CmcdVersion|undefined),
  *   enabledKeys: (!Array<cml.cmcd.CmcdKey>|undefined),
- *   transmissionMode: (string|undefined)
+ *   transmissionMode: (cml.cmcd.CmcdTransmissionMode|undefined)
  * }}
  */
 cml.cmcd.CmcdRequestReportConfig;

From 0f69e7f0e335ea0307ce6533254dde68fbf8f324 Mon Sep 17 00:00:00 2001
From: Casey Occhialini <1508707+littlespex@users.noreply.github.com>
Date: Tue, 28 Apr 2026 10:08:51 -0700
Subject: [PATCH 22/64] docs(cmcd): add Phase 1 sub-phase A-C completion status
 to plan

Add a "Current status" section to plan.md surfacing where the refactor
stands at session-end: Phase 0 + Phase 1 sub-phases A/B/C complete, the
vendored port at third_party/cml-cmcd/ structurally done, sub-phase D
the next resume point. Includes CML pin + reclone command, three
architectural decisions worth surfacing in the eventual Phase 1 PR
description (setInterval/fetch whitelist, defaultRequester relocation),
and a hygiene note about two existing git stashes.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 plans/cmcd-cml-refactor/plan.md | 45 +++++++++++++++++++++++++++++++++
 1 file changed, 45 insertions(+)

diff --git a/plans/cmcd-cml-refactor/plan.md b/plans/cmcd-cml-refactor/plan.md
index 50c75cdd3f..7822cef9ac 100644
--- a/plans/cmcd-cml-refactor/plan.md
+++ b/plans/cmcd-cml-refactor/plan.md
@@ -12,6 +12,51 @@
 
 ---
 
+## Current status (last updated 2026-04-27)
+
+This refactor is actively in progress on branch `feat/cmcd-cml-refactor`. Read this section first before resuming work in a new session.
+
+| Phase | Status | Commits / Notes |
+|---|---|---|
+| **Phase 0** — CML verification | ✅ Complete | Verification report at [`cml-version.md`](cml-version.md). CML pin: `cmcd-v2.3.0` / commit `22390e35dfbbe1e53d15648d3aace99cdf71f9dd`. **No upstream CML PRs needed.** Five spec/plan doc fixes already applied. |
+| **Phase 1A** — Skeleton + typedefs + enums + constants + utils (Tasks 1.1-1.5) | ✅ Complete | 6 commits, ending at `e6cb2563d`. 44 files added under `third_party/cml-cmcd/`. |
+| **Phase 1B** — Encoders + helpers + cml-utils/sfv shims + deferred `CMCD_FORMATTER_MAP` (Tasks 1.6-1.7) | ✅ Complete | 5 commits, ending at `9bcf6614e`. 23 new files. Re-included 8 spec-excluded files (predicates + `is_valid.js` + `group_cmcd_headers.js`) that were genuinely runtime-required by encoders. New shim `cml_sfv.js` (~448 LoC, RFC 8941 §4.1 serializer). |
+| **Phase 1C** — `CmcdReporter` + 5 deferred typedefs (Task 1.8) | ✅ Complete | 3 commits, ending at `d682bb1bb`. 6 new files. The vendored port is now structurally complete. |
+| **Phase 1D** — Encoding delegation in `cmcd_manager.js` + drop non-spec `'ld'`/`'lh'` (Tasks 1.10, 1.10b) | ⏳ Not started | **First real shaka source change. Resume here.** |
+| **Phase 1E** — Diff testing + assertion updates (Tasks 1.11-1.12) | ⏳ Not started | Needs human judgment on divergence classification. |
+| **Phase 1F** — Demo verification + Phase 1 PR (Tasks 1.13-1.14) | ⏳ Not started | Phase 1 ships as PR after this. |
+| **Phase 2** — Adopt CML constants, dedupe shaka duplicates | ⏳ Not started | After Phase 1 merges. |
+| **Phase 3** — Adapter rewrite (the big behavioral change) | ⏳ Not started | After Phase 2 merges. |
+
+**Vendored port summary:** [`third_party/cml-cmcd/`](../../third_party/cml-cmcd/) holds 68 JS files (typedefs + enums + constants + encoders + helpers + shims + `CmcdReporter`) + `LICENSE` + `NOTICE` + `SUMMARY.txt`. At HEAD (`d682bb1bb`), both `python3 build/check.py` and `python3 build/build.py` exit 0.
+
+### Key architectural decisions in the port — surface in Phase 1 PR description
+
+These were judgment calls during sub-phases B+C; maintainers should weigh in before merge:
+
+1. **`setInterval` whitelisted** in `build/conformance.textproto` for `third_party/cml-cmcd/cmcd_reporter.js`. The reporter calls `setInterval` directly for periodic time-interval event reporting. Alternatives considered: (a) patching the vendored reporter to use `shaka.util.Timer` (breaks verbatim parity), (b) filing a CML upstream PR for injectable-timer support (delays Phase 1). Whitelist is pragmatic but means **Phase 3 tests cannot inject a fake timer** — will need `jasmine.clock()`-based interval testing.
+2. **`fetch` whitelisted** in `build/conformance.textproto` for `third_party/cml-cmcd/cml_utils.js`. Used by `cml.cmcd.defaultRequester` — dead code at runtime because the shaka adapter always supplies a custom `requester` via `NetworkingEngine`. Closure ADVANCED is expected to strip the dead path, but the conformance check runs first.
+3. **`defaultRequester` relocated** from `CmcdReporter.ts` module scope into `cml_utils.js` as `cml.cmcd.defaultRequester`. Done to centralize the `fetch` whitelist scope to a single file. **Per-bump CML diff workflow needs to know** `defaultRequester` lives here, not in the reporter — otherwise CML 2.4.0+ bumps will look like the function vanished.
+
+### Open hygiene items (user-owned, untouched by this session)
+
+Two git stashes exist:
+- `stash@{0}: On feat/cmcd-cml-refactor: accidental-stash-pop-recovery` — created during a sub-phase B subagent's `git stash pop` mishap. Contains contaminated working state from that incident.
+- `stash@{1}: On task/revert-cmcd-v1: CMCD STUFF` — pre-existing user stash. Preserved.
+
+### Resuming work in a new session — sub-phase D prep
+
+- **Verify CML pinned clone** is still at `/tmp/cml-pinned/`. Run `cd /tmp/cml-pinned && git rev-parse HEAD` — should output `22390e35dfbbe1e53d15648d3aace99cdf71f9dd`. If missing or wrong SHA, re-clone:
+  ```bash
+  rm -rf /tmp/cml-pinned
+  git clone https://github.com/streaming-video-technology-alliance/common-media-library.git /tmp/cml-pinned
+  cd /tmp/cml-pinned && git checkout 22390e35dfbbe1e53d15648d3aace99cdf71f9dd
+  ```
+- **Sub-phase D scope:** modify `lib/util/cmcd_manager.js` to replace the static encoders (`serialize`, `toQuery`, `appendQueryToUri`, `urlToRelativePath`) with delegations to `cml.cmcd.encodeCmcd` / `cml.cmcd.appendCmcdQuery` / `cml.cmcd.appendCmcdHeaders`. Drop non-spec `'ld'`/`'lh'` `StreamingFormat` values per Task 1.10b. State machine, sequence numbers, event timing, public API all remain unchanged in this sub-phase.
+- **Sub-phase E (diff testing)** requires user judgment on classifying any wire-format divergences as (a) intentional spec-conformance fix, (b) acceptable alignment with CML, or (c) bugs to fix.
+
+---
+
 ## Plan structure
 
 - **Phase 0** — CML-side verification & upstream precursor PRs (no shaka commits).

From d8d614ce35c2fd50caf87d17be86975973a1d2b5 Mon Sep 17 00:00:00 2001
From: Casey Occhialini <1508707+littlespex@users.noreply.github.com>
Date: Tue, 28 Apr 2026 10:31:20 -0700
Subject: [PATCH 23/64] refactor(cmcd): delegate encoding to vendored cml-cmcd
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Replace shaka.util.CmcdManager.serialize / toQuery static method bodies
with one-line delegations to cml.cmcd.encodeCmcd, and thread an optional
CmcdEncodeOptions through serialize / toQuery / toHeaders so callers can
pass a baseUrl. CML's `nor` formatter uses options.baseUrl to produce
root-relative URLs.

Drop urlToRelativePath (and its 9 unit tests). data.nor is now set to
the absolute next-segment URL in getDataForSegment_; CML relativizes it
during encode against new URL(requestUri).origin. This is the first of
Phase 1's two intentional wire-format changes — `nor` becomes
root-relative instead of path-relative, matching CTA-5004-B and CML's
spec-conformant output. Sub-phase E will catalog the full diff.

Add a small static helper getEncodeOptions_(uri) that derives baseUrl
from a URL's origin (with offline:/parse-error guards). Used at all
four CMCD-encoding call sites: appendSrcData, appendTextTrackData,
sendCmcdRequest_, applyCmcdDataToRequest_.

appendQueryToUri keeps its goog.Uri-based body: cml.cmcd.appendCmcdQuery
takes a data object instead of a pre-encoded query string, so this
shaka method is retained as an adapter for now. Phase 3 removes these
adapter methods entirely as part of the CmcdReporter rewrite.

Per Task 1.10 of plans/cmcd-cml-refactor/plan.md.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 lib/util/cmcd_manager.js       | 164 +++++++++++----------------------
 test/util/cmcd_manager_unit.js |  59 ------------
 2 files changed, 53 insertions(+), 170 deletions(-)

diff --git a/lib/util/cmcd_manager.js b/lib/util/cmcd_manager.js
index 5151805820..3030df8746 100644
--- a/lib/util/cmcd_manager.js
+++ b/lib/util/cmcd_manager.js
@@ -6,6 +6,7 @@
 
 goog.provide('shaka.util.CmcdManager');
 
+goog.require('cml.cmcd.encodeCmcd');
 goog.require('goog.Uri');
 
 goog.require('shaka.log');
@@ -14,6 +15,8 @@ goog.require('shaka.util.ArrayUtils');
 goog.require('shaka.util.EventManager');
 goog.require('shaka.util.Timer');
 
+goog.requireType('cml.cmcd.Cmcd');
+goog.requireType('cml.cmcd.CmcdEncodeOptions');
 goog.requireType('shaka.media.SegmentReference');
 goog.requireType('shaka.Player');
 
@@ -454,7 +457,8 @@ shaka.util.CmcdManager = class {
       data.ot = this.getObjectTypeFromMimeType_(mimeType);
       data.su = true;
 
-      const query = shaka.util.CmcdManager.toQuery(data);
+      const query = shaka.util.CmcdManager.toQuery(
+          data, shaka.util.CmcdManager.getEncodeOptions_(uri));
 
       return shaka.util.CmcdManager.appendQueryToUri(uri, query);
     } catch (error) {
@@ -480,7 +484,8 @@ shaka.util.CmcdManager = class {
       data.ot = shaka.util.CmcdManager.ObjectType.CAPTION;
       data.su = true;
 
-      const query = shaka.util.CmcdManager.toQuery(data);
+      const query = shaka.util.CmcdManager.toQuery(
+          data, shaka.util.CmcdManager.getEncodeOptions_(uri));
 
       return shaka.util.CmcdManager.appendQueryToUri(uri, query);
     } catch (error) {
@@ -828,9 +833,11 @@ shaka.util.CmcdManager = class {
     const retryParams = shaka.net.NetworkingEngine.defaultRetryParameters();
     let request = null;
     const baseURL = target.url;
+    const encodeOptions = shaka.util.CmcdManager.getEncodeOptions_(baseURL);
 
     if (target.useHeaders) {
-      const headers = shaka.util.CmcdManager.toHeaders(cmcdData);
+      const headers =
+          shaka.util.CmcdManager.toHeaders(cmcdData, encodeOptions);
       if (!Object.keys(headers).length) {
         return;
       }
@@ -840,7 +847,8 @@ shaka.util.CmcdManager = class {
       request = shaka.net.NetworkingEngine.makeRequest([baseURL], retryParams);
       Object.assign(request.headers, headers);
     } else {
-      const queryString = shaka.util.CmcdManager.toQuery(cmcdData);
+      const queryString =
+          shaka.util.CmcdManager.toQuery(cmcdData, encodeOptions);
       if (!queryString) {
         return;
       }
@@ -865,15 +873,17 @@ shaka.util.CmcdManager = class {
    * @private
    */
   applyCmcdDataToRequest_(output, request, useHeaders) {
+    const encodeOptions =
+        shaka.util.CmcdManager.getEncodeOptions_(request.uris[0]);
     if (useHeaders) {
-      const headers = shaka.util.CmcdManager.toHeaders(output);
+      const headers = shaka.util.CmcdManager.toHeaders(output, encodeOptions);
       if (!Object.keys(headers).length) {
         return;
       }
 
       Object.assign(request.headers, headers);
     } else {
-      const query = shaka.util.CmcdManager.toQuery(output);
+      const query = shaka.util.CmcdManager.toQuery(output, encodeOptions);
       if (!query) {
         return;
       }
@@ -1303,8 +1313,7 @@ shaka.util.CmcdManager = class {
           if (nextSegment && nextSegment != segment) {
             if (requestUri && !shaka.util.ArrayUtils.equal(
                 segment.getUris(), nextSegment.getUris())) {
-              data.nor = shaka.util.CmcdManager.urlToRelativePath(
-                  nextSegment.getUris()[0], requestUri);
+              data.nor = nextSegment.getUris()[0];
             }
             if ((nextSegment.startByte || nextSegment.endByte) &&
                 (segment.startByte != nextSegment.startByte ||
@@ -1392,72 +1401,13 @@ shaka.util.CmcdManager = class {
    * [CTA-5004](https://cdn.cta.tech/cta/media/media/resources/standards/pdfs/cta-5004-final.pdf).
    *
    * @param {CmcdData} data The CMCD data object
+   * @param {cml.cmcd.CmcdEncodeOptions=} options Encoding options
+   *   (e.g. `baseUrl` to root-relativize `nor` URLs).
    * @return {string}
    */
-  static serialize(data) {
-    const results = [];
-    const isValid = (value) =>
-      !Number.isNaN(value) && value != null && value !== '' && value !== false;
-    const toRounded = (value) => Math.round(value);
-    const toHundred = (value) => toRounded(value / 100) * 100;
-    const toUrlSafe = (value) => encodeURIComponent(value);
-    const formatters = {
-      br: toRounded,
-      d: toRounded,
-      bl: toHundred,
-      dl: toHundred,
-      mtp: toHundred,
-      nor: toUrlSafe,
-      rtp: toHundred,
-      tb: toRounded,
-      ttfb: toRounded,
-      ttlb: toRounded,
-    };
-
-    const keys = Object.keys(data || {}).sort();
-
-    for (const key of keys) {
-      let value = data[key];
-
-      // ignore invalid values
-      if (!isValid(value)) {
-        continue;
-      }
-
-      // Version should only be reported if not equal to 1.
-      if (key === 'v' && value === 1) {
-        continue;
-      }
-
-      // Playback rate should only be sent if not equal to 1.
-      if (key == 'pr' && value === 1) {
-        continue;
-      }
-
-      // Certain values require special formatting
-      const formatter = formatters[key];
-      if (formatter) {
-        value = formatter(value);
-      }
-
-      // Serialize the key/value pair
-      const type = typeof value;
-      let result;
-
-      if (type === 'string' && key !== 'ot' && key !== 'sf' && key !== 'st') {
-        result = `${key}=${JSON.stringify(value)}`;
-      } else if (type === 'boolean') {
-        result = key;
-      } else if (type === 'symbol') {
-        result = `${key}=${value.description}`;
-      } else {
-        result = `${key}=${value}`;
-      }
-
-      results.push(result);
-    }
-
-    return results.join(',');
+  static serialize(data, options) {
+    return cml.cmcd.encodeCmcd(
+        /** @type {cml.cmcd.Cmcd} */ (data), options);
   }
 
   /**
@@ -1466,9 +1416,11 @@ shaka.util.CmcdManager = class {
    * [CTA-5004](https://cdn.cta.tech/cta/media/media/resources/standards/pdfs/cta-5004-final.pdf).
    *
    * @param {CmcdData} data The CMCD data object
+   * @param {cml.cmcd.CmcdEncodeOptions=} options Encoding options
+   *   (e.g. `baseUrl` to root-relativize `nor` URLs).
    * @return {!Object}
    */
-  static toHeaders(data) {
+  static toHeaders(data, options) {
     const keys = Object.keys(data);
     const headers = {};
     const headerNames = ['Object', 'Request', 'Session', 'Status'];
@@ -1488,7 +1440,8 @@ shaka.util.CmcdManager = class {
     }
 
     for (let i = 0; i < headerGroups.length; i++) {
-      const value = shaka.util.CmcdManager.serialize(headerGroups[i]);
+      const value =
+          shaka.util.CmcdManager.serialize(headerGroups[i], options);
       if (value) {
         headers[`CMCD-${headerNames[i]}`] = value;
       }
@@ -1503,15 +1456,24 @@ shaka.util.CmcdManager = class {
    * [CTA-5004](https://cdn.cta.tech/cta/media/media/resources/standards/pdfs/cta-5004-final.pdf).
    *
    * @param {CmcdData} data The CMCD data object
+   * @param {cml.cmcd.CmcdEncodeOptions=} options Encoding options
+   *   (e.g. `baseUrl` to root-relativize `nor` URLs).
    * @return {string}
    */
-  static toQuery(data) {
-    return shaka.util.CmcdManager.serialize(data);
+  static toQuery(data, options) {
+    return shaka.util.CmcdManager.serialize(data, options);
   }
 
   /**
    * Append query args to a uri.
    *
+   * Note: the URL-append step itself is NOT delegated to CML's
+   * `cml.cmcd.appendCmcdQuery`, which takes a CMCD data object plus encode
+   * options. Shaka's signature here is `(uri, encodedQuery)` — used as a
+   * thin adapter for callers that have already encoded via `toQuery`.
+   * Phase 3 will replace these call sites with `cml.cmcd.appendCmcdQuery`
+   * directly.
+   *
    * @param {string} uri
    * @param {string} query
    * @return {string}
@@ -1531,45 +1493,25 @@ shaka.util.CmcdManager = class {
   }
 
   /**
-   * Constructs a relative path from a URL
+   * Build encoder options for a given URI by deriving `baseUrl` from
+   * its origin. Used by encode call sites so CML's `nor` formatter
+   * produces root-relative URLs. Returns an empty options object if
+   * the URI is missing, an `offline:` storage URI, or unparsable.
    *
-   * @param {string} url
-   * @param {string} base
-   * @return {string}
+   * @param {(string|undefined)} uri
+   * @return {!cml.cmcd.CmcdEncodeOptions}
+   * @private
    */
-  static urlToRelativePath(url, base) {
-    const to = new URL(url);
-    const from = new URL(base);
-
-    if (to.origin !== from.origin) {
-      return url;
-    }
-
-    const toPath = to.pathname.split('/').slice(1);
-    const fromPath = from.pathname.split('/').slice(1, -1);
-
-    // remove common parents
-    const length = Math.min(toPath.length, fromPath.length);
-
-    for (let i = 0; i < length; i++) {
-      if (toPath[i] !== fromPath[i]) {
-        break;
-      }
-
-      toPath.shift();
-      fromPath.shift();
+  static getEncodeOptions_(uri) {
+    if (!uri || uri.includes('offline:')) {
+      return /** @type {!cml.cmcd.CmcdEncodeOptions} */ ({});
     }
-
-    // add back paths
-    while (fromPath.length) {
-      fromPath.shift();
-      toPath.unshift('..');
+    try {
+      return /** @type {!cml.cmcd.CmcdEncodeOptions} */ (
+        {baseUrl: new URL(uri).origin});
+    } catch (e) {
+      return /** @type {!cml.cmcd.CmcdEncodeOptions} */ ({});
     }
-
-    const relativePath = toPath.join('/');
-
-    // preserve query parameters and hash of the destination url
-    return relativePath + to.search + to.hash;
   }
 };
 
diff --git a/test/util/cmcd_manager_unit.js b/test/util/cmcd_manager_unit.js
index fcea7a3611..6cd5719c17 100644
--- a/test/util/cmcd_manager_unit.js
+++ b/test/util/cmcd_manager_unit.js
@@ -260,65 +260,6 @@ describe('CmcdManager Setup', () => {
       });
     });
 
-    describe('URL to relative path', () => {
-      it('produces a relative path when at root', () => {
-        const from = 'http://test.com/manifest.mpd';
-        const to = 'http://test.com/1.mp4';
-        expect(CmcdManager.urlToRelativePath(to, from)).toBe('1.mp4');
-      });
-
-      it('produces a relative path when at the same folder level', () => {
-        const from = 'http://test.com/base/manifest.mpd';
-        const to = 'http://test.com/base/1.mp4';
-        expect(CmcdManager.urlToRelativePath(to, from)).toBe('1.mp4');
-      });
-
-      it('produces a relative path when base is lower', () => {
-        const from = 'http://test.com/manifest.mpd';
-        const to = 'http://test.com/base/segments/video/1.mp4';
-        const result = 'base/segments/video/1.mp4';
-        expect(CmcdManager.urlToRelativePath(to, from)).toBe(result);
-      });
-
-      it('produces a relative path when base is higher', () => {
-        const from = 'http://test.com/base/manifest/manifest.mpd';
-        const to = 'http://test.com/1.mp4';
-        expect(CmcdManager.urlToRelativePath(to, from)).toBe('../../1.mp4');
-      });
-
-      it('produces a relative path when base and url are different', () => {
-        const from = 'http://test.com/base/manifest/manifest.mpd';
-        const to = 'http://test.com/base/segments/video/1.mp4';
-        const result = '../segments/video/1.mp4';
-        expect(CmcdManager.urlToRelativePath(to, from)).toBe(result);
-      });
-
-      it('returns url when origins are different', () => {
-        const from = 'http://test.com/base/manifest/manifest.mpd';
-        const to = 'http://foo.com/1.mp4';
-        expect(CmcdManager.urlToRelativePath(to, from)).toBe('http://foo.com/1.mp4');
-      });
-
-      it('maintains query parameters and hash in the relative path', () => {
-        const from = 'http://test.com/base/manifest/manifest.mpd';
-        const to = 'http://test.com/base/segments/video/1.mp4?param=foo&another=bar#hash=baz';
-        const result = '../segments/video/1.mp4?param=foo&another=bar#hash=baz';
-        expect(CmcdManager.urlToRelativePath(to, from)).toBe(result);
-      });
-
-      it('produces a relative path when only query params differ', () => {
-        const from = 'http://test.com/file.mp4?i=0';
-        const to = 'http://test.com/file.mp4?i=1';
-        expect(CmcdManager.urlToRelativePath(to, from)).toBe('file.mp4?i=1');
-      });
-
-      it('produces a relative path when only hash params differ', () => {
-        const from = 'http://test.com/file.mp4#i=0';
-        const to = 'http://test.com/file.mp4#i=1';
-        expect(CmcdManager.urlToRelativePath(to, from)).toBe('file.mp4#i=1');
-      });
-    });
-
     describe('CmcdManager instance', () => {
       const ObjectUtils = shaka.util.ObjectUtils;
 

From adfdfab0511ed95856079e17faa44ba74ae9a15a Mon Sep 17 00:00:00 2001
From: Casey Occhialini <1508707+littlespex@users.noreply.github.com>
Date: Tue, 28 Apr 2026 10:34:32 -0700
Subject: [PATCH 24/64] fix(cmcd): drop non-spec 'ld'/'lh' StreamingFormat
 values
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

CTA-5004 and CTA-5004-B define only 'd', 'h', 's', 'o' for the sf key.
shaka's 'ld' (LOW_LATENCY_DASH) and 'lh' (LOW_LATENCY_HLS) come from an
old unreleased draft and are not in either spec. CML correctly omits
them. Wire change: LL DASH now emits sf=d, LL HLS now emits sf=h.

setLowLatency body simplified to a single field assignment — the LL flag
no longer mutates this.sf_, since both LL DASH and DASH share 'd'. The
flag is preserved for any external readers; sf_ is set once at
manifest-load time in getStreamFormat_, which itself drops its
this.lowLatency_ branches.

This is the second of Phase 1's two intentional wire-format changes,
alongside `nor` URL relativization (committed previously). Phase 2's
alias re-export becomes a straightforward identity map once shaka's
enum is a strict subset of CML's CmcdStreamingFormat.

No tests asserted sf=ld or sf=lh (verified via grep over test/), so
the test-file delta from this change is empty.

Per Task 1.10b of plans/cmcd-cml-refactor/plan.md.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 lib/util/cmcd_manager.js | 30 ++++++------------------------
 1 file changed, 6 insertions(+), 24 deletions(-)

diff --git a/lib/util/cmcd_manager.js b/lib/util/cmcd_manager.js
index 3030df8746..f35c390135 100644
--- a/lib/util/cmcd_manager.js
+++ b/lib/util/cmcd_manager.js
@@ -173,27 +173,17 @@ shaka.util.CmcdManager = class {
   }
 
   /**
-   * Set the low latency
+   * Set the low latency.
+   *
+   * Note: low-latency content emits the same `sf` value as its non-LL
+   * counterpart (DASH → 'd', HLS → 'h'). CTA-5004 / CTA-5004-B do not
+   * define separate low-latency StreamingFormat values, and CML's
+   * CmcdStreamingFormat omits them.
    *
    * @param {boolean} lowLatency
    */
   setLowLatency(lowLatency) {
     this.lowLatency_ = lowLatency;
-
-    const StreamingFormat = shaka.util.CmcdManager.StreamingFormat;
-    if (this.lowLatency_) {
-      if (this.sf_ == StreamingFormat.DASH) {
-        this.sf_ = StreamingFormat.LOW_LATENCY_DASH;
-      } else if (this.sf_ == StreamingFormat.HLS) {
-        this.sf_ = StreamingFormat.LOW_LATENCY_HLS;
-      }
-    } else {
-      if (this.sf_ == StreamingFormat.LOW_LATENCY_DASH) {
-        this.sf_ = StreamingFormat.DASH;
-      } else if (this.sf_ == StreamingFormat.LOW_LATENCY_HLS) {
-        this.sf_ = StreamingFormat.HLS;
-      }
-    }
   }
 
   /**
@@ -1188,16 +1178,10 @@ shaka.util.CmcdManager = class {
 
     switch (type) {
       case AdvancedRequestType.MPD:
-        if (this.lowLatency_) {
-          return shaka.util.CmcdManager.StreamingFormat.LOW_LATENCY_DASH;
-        }
         return shaka.util.CmcdManager.StreamingFormat.DASH;
 
       case AdvancedRequestType.MASTER_PLAYLIST:
       case AdvancedRequestType.MEDIA_PLAYLIST:
-        if (this.lowLatency_) {
-          return shaka.util.CmcdManager.StreamingFormat.LOW_LATENCY_HLS;
-        }
         return shaka.util.CmcdManager.StreamingFormat.HLS;
     }
 
@@ -1553,9 +1537,7 @@ shaka.util.CmcdManager.StreamType = {
  */
 shaka.util.CmcdManager.StreamingFormat = {
   DASH: 'd',
-  LOW_LATENCY_DASH: 'ld',
   HLS: 'h',
-  LOW_LATENCY_HLS: 'lh',
   SMOOTH: 's',
   OTHER: 'o',
 };

From 4aa5ff76b9d8225a57c153b38104801eb9b9db2a Mon Sep 17 00:00:00 2001
From: Casey Occhialini <1508707+littlespex@users.noreply.github.com>
Date: Tue, 28 Apr 2026 10:36:38 -0700
Subject: [PATCH 25/64] docs(cmcd): mark Phase 1 sub-phase D complete in plan
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Update plan.md "Current status" section: sub-phase D (Tasks 1.10 +
1.10b) ✅ complete after this session, sub-phase E is the resume
point. Add a "Sub-phase D landing notes" subsection capturing the
three concrete deliverables (encoder delegation, urlToRelativePath
deletion, two intentional wire-format changes) and the new private
helper getEncodeOptions_(uri).

Replace the old "Resuming work — sub-phase D prep" subsection with
"sub-phase E prep": baseline-capture flow now uses
`git checkout 0f69e7f0e -- ...` (since sub-phase D is committed
across d8d614ce3 + adfdfab05) rather than the plan's literal
git stash flow which assumed uncommitted changes. Pre-flag the
likely (c)-class divergence in toHeaders (CML auto-adds v=2 per
shard; shaka's old encoder didn't), so sub-phase E starts with
the highest-priority item identified.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 plans/cmcd-cml-refactor/plan.md | 24 +++++++++++++++++-------
 1 file changed, 17 insertions(+), 7 deletions(-)

diff --git a/plans/cmcd-cml-refactor/plan.md b/plans/cmcd-cml-refactor/plan.md
index 7822cef9ac..f810b8d2e0 100644
--- a/plans/cmcd-cml-refactor/plan.md
+++ b/plans/cmcd-cml-refactor/plan.md
@@ -12,7 +12,7 @@
 
 ---
 
-## Current status (last updated 2026-04-27)
+## Current status (last updated 2026-04-28)
 
 This refactor is actively in progress on branch `feat/cmcd-cml-refactor`. Read this section first before resuming work in a new session.
 
@@ -22,13 +22,22 @@ This refactor is actively in progress on branch `feat/cmcd-cml-refactor`. Read t
 | **Phase 1A** — Skeleton + typedefs + enums + constants + utils (Tasks 1.1-1.5) | ✅ Complete | 6 commits, ending at `e6cb2563d`. 44 files added under `third_party/cml-cmcd/`. |
 | **Phase 1B** — Encoders + helpers + cml-utils/sfv shims + deferred `CMCD_FORMATTER_MAP` (Tasks 1.6-1.7) | ✅ Complete | 5 commits, ending at `9bcf6614e`. 23 new files. Re-included 8 spec-excluded files (predicates + `is_valid.js` + `group_cmcd_headers.js`) that were genuinely runtime-required by encoders. New shim `cml_sfv.js` (~448 LoC, RFC 8941 §4.1 serializer). |
 | **Phase 1C** — `CmcdReporter` + 5 deferred typedefs (Task 1.8) | ✅ Complete | 3 commits, ending at `d682bb1bb`. 6 new files. The vendored port is now structurally complete. |
-| **Phase 1D** — Encoding delegation in `cmcd_manager.js` + drop non-spec `'ld'`/`'lh'` (Tasks 1.10, 1.10b) | ⏳ Not started | **First real shaka source change. Resume here.** |
-| **Phase 1E** — Diff testing + assertion updates (Tasks 1.11-1.12) | ⏳ Not started | Needs human judgment on divergence classification. |
+| **Phase 1D** — Encoding delegation in `cmcd_manager.js` + drop non-spec `'ld'`/`'lh'` (Tasks 1.10, 1.10b) | ✅ Complete | 2 commits, ending at `adfdfab05`. Net −168 LoC across `lib/util/cmcd_manager.js` and `test/util/cmcd_manager_unit.js`. `python3 build/check.py` exits 0. `build/test.py` deferred to sub-phase E (Tasks 1.11-1.12 catalog and update wire-format-divergence assertions). |
+| **Phase 1E** — Diff testing + assertion updates (Tasks 1.11-1.12) | ⏳ **Resume here.** | Needs human judgment on divergence classification. |
 | **Phase 1F** — Demo verification + Phase 1 PR (Tasks 1.13-1.14) | ⏳ Not started | Phase 1 ships as PR after this. |
 | **Phase 2** — Adopt CML constants, dedupe shaka duplicates | ⏳ Not started | After Phase 1 merges. |
 | **Phase 3** — Adapter rewrite (the big behavioral change) | ⏳ Not started | After Phase 2 merges. |
 
-**Vendored port summary:** [`third_party/cml-cmcd/`](../../third_party/cml-cmcd/) holds 68 JS files (typedefs + enums + constants + encoders + helpers + shims + `CmcdReporter`) + `LICENSE` + `NOTICE` + `SUMMARY.txt`. At HEAD (`d682bb1bb`), both `python3 build/check.py` and `python3 build/build.py` exit 0.
+**Vendored port summary:** [`third_party/cml-cmcd/`](../../third_party/cml-cmcd/) holds 68 JS files (typedefs + enums + constants + encoders + helpers + shims + `CmcdReporter`) + `LICENSE` + `NOTICE` + `SUMMARY.txt`. At HEAD (`adfdfab05`), `python3 build/check.py` exits 0. `python3 build/build.py` was last clean at `d682bb1bb` and is not expected to break under sub-phase D's source-only changes; not re-run this session.
+
+### Sub-phase D landing notes (Tasks 1.10 + 1.10b)
+
+- **Encoding paths now delegate through CML.** `serialize` / `toQuery` / `toHeaders` thread an optional `cml.cmcd.CmcdEncodeOptions` and route to `cml.cmcd.encodeCmcd`. `appendQueryToUri` retained as a thin `goog.Uri`-based adapter (CML's `appendCmcdQuery` takes a data object, not a pre-encoded query string — incompatible signature; Phase 3 deletes the call sites entirely).
+- **`urlToRelativePath` deleted** from `cmcd_manager.js` (and its 9 unit tests). `data.nor` is set to the absolute next-segment URL in `getDataForSegment_`; CML's `nor` formatter (in `cmcd_formatter_map_const.js`) relativizes against `options.baseUrl`. New private helper `shaka.util.CmcdManager.getEncodeOptions_(uri)` derives `baseUrl` from `new URL(uri).origin` (with `offline:`/parse-error guards) and is invoked at all four CMCD-encoding call sites: `appendSrcData`, `appendTextTrackData`, `sendCmcdRequest_`, `applyCmcdDataToRequest_`.
+- **Two intentional wire-format changes shipped:**
+  1. `nor` URLs become root-relative instead of path-relative (matching CTA-5004-B + CML's spec-conformant output).
+  2. `'ld'` / `'lh'` `StreamingFormat` values dropped — LL DASH now emits `sf=d`, LL HLS now emits `sf=h`. `setLowLatency` no longer mutates `sf_`; `getStreamFormat_` no longer branches on `lowLatency_`.
+- **No tests asserted `sf=ld`/`sf=lh`** (verified via repo-wide grep). The `urlToRelativePath` describe-block (9 tests) was the only test deletion in sub-phase D.
 
 ### Key architectural decisions in the port — surface in Phase 1 PR description
 
@@ -44,7 +53,7 @@ Two git stashes exist:
 - `stash@{0}: On feat/cmcd-cml-refactor: accidental-stash-pop-recovery` — created during a sub-phase B subagent's `git stash pop` mishap. Contains contaminated working state from that incident.
 - `stash@{1}: On task/revert-cmcd-v1: CMCD STUFF` — pre-existing user stash. Preserved.
 
-### Resuming work in a new session — sub-phase D prep
+### Resuming work in a new session — sub-phase E prep
 
 - **Verify CML pinned clone** is still at `/tmp/cml-pinned/`. Run `cd /tmp/cml-pinned && git rev-parse HEAD` — should output `22390e35dfbbe1e53d15648d3aace99cdf71f9dd`. If missing or wrong SHA, re-clone:
   ```bash
@@ -52,8 +61,9 @@ Two git stashes exist:
   git clone https://github.com/streaming-video-technology-alliance/common-media-library.git /tmp/cml-pinned
   cd /tmp/cml-pinned && git checkout 22390e35dfbbe1e53d15648d3aace99cdf71f9dd
   ```
-- **Sub-phase D scope:** modify `lib/util/cmcd_manager.js` to replace the static encoders (`serialize`, `toQuery`, `appendQueryToUri`, `urlToRelativePath`) with delegations to `cml.cmcd.encodeCmcd` / `cml.cmcd.appendCmcdQuery` / `cml.cmcd.appendCmcdHeaders`. Drop non-spec `'ld'`/`'lh'` `StreamingFormat` values per Task 1.10b. State machine, sequence numbers, event timing, public API all remain unchanged in this sub-phase.
-- **Sub-phase E (diff testing)** requires user judgment on classifying any wire-format divergences as (a) intentional spec-conformance fix, (b) acceptable alignment with CML, or (c) bugs to fix.
+- **Sub-phase E scope (Tasks 1.11-1.12):** capture pre-delegation baseline + post-delegation wire output for the existing `test/util/cmcd_manager_unit.js` suite, diff, and classify each divergence as (a) intentional spec-conformance fix, (b) acceptable alignment with CML, or (c) bug to fix before shipping Phase 1. Update assertions for (a)/(b); resolve (c) before Phase 1 PR.
+- **Capturing the pre-delegation baseline** requires reverting sub-phase D temporarily. Cleanest: `git checkout 0f69e7f0e -- lib/util/cmcd_manager.js test/util/cmcd_manager_unit.js`, dump test wire output, reset, re-dump post-delegation. (The plan's literal `git stash`/`git stash pop` flow assumed sub-phase D was uncommitted; since it's now committed across `d8d614ce3` + `adfdfab05`, the checkout-from-prior-SHA flow is the equivalent.)
+- **Expected divergence categories** (pre-judgment): `nor` URLs path-relative → root-relative (intentional); CML's SFV encoder vs shaka's old comma-separated encoder may differ on string escaping, key ordering, and whether `v=2` is auto-added per shard in `toHeaders` (CML's `prepareCmcdData` adds `v` for V2; shaka's old encoder didn't). The `v=2` per-shard auto-add is the most likely (c)-class bug — shaka groups data into 4 shards before encoding, so without intervention every shard will emit `v=2`.
 
 ---
 

From 27cd16907cf4f34d31d3e6b2efd646905f5e2821 Mon Sep 17 00:00:00 2001
From: Casey Occhialini <1508707+littlespex@users.noreply.github.com>
Date: Tue, 28 Apr 2026 12:38:15 -0700
Subject: [PATCH 26/64] fix(cmcd): thread version/reportingMode + prepare-once
 for header shards
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Three (c)-class bugs surfaced by sub-phase E diff testing of the
encoder delegation from Task 1.10:

C1. Event-mode encoded output dropped event-only keys (e, ts, cen).
    cml.cmcd.prepareCmcdData defaults reportingMode to CMCD_REQUEST_MODE
    when not specified, and the request-mode filter (isCmcdRequestKey)
    excludes event-only keys. Fix: thread reportingMode through
    getEncodeOptions_ — CMCD_EVENT_MODE for sendCmcdRequest_ (the
    out-of-band event/response-received path), CMCD_REQUEST_MODE for
    applyCmcdDataToRequest_ / appendSrcData / appendTextTrackData.
    sendCmcdRequest_ also stops passing baseURL: target URLs are
    typically a different origin from segment URLs, so baseUrl-based
    nor relativization against the collector URL is meaningless. CML's
    own reporter omits baseUrl in event mode for the same reason.

C2. toHeaders emitted v=2 in every shard. shaka groups data into 4
    shards and previously called serialize per shard; once serialize
    delegated to encodeCmcd, each shard ran prepareCmcdData and got
    v=2 auto-appended. Fix: prepareCmcdData once on the full data
    (auto-adding v=2 once into the prepared output), bucket the
    prepared keys into shaka's headerMap, then encodePreparedCmcd per
    shard so re-preparation is skipped.

C3. V1 configurations were getting V2 filter behavior because
    prepareCmcdData defaults to V2 when no version is supplied. Tests
    that emitted V1-only keys (e.g. nrr) saw them filtered out. Fix:
    thread this.config_.version through getEncodeOptions_.

Per Task 1.12 of plans/cmcd-cml-refactor/plan.md (sub-phase E (c)-class
classifications C1, C2, C3 from diff-test-classification.md).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 lib/util/cmcd_manager.js | 86 +++++++++++++++++++++++++++++-----------
 1 file changed, 62 insertions(+), 24 deletions(-)

diff --git a/lib/util/cmcd_manager.js b/lib/util/cmcd_manager.js
index f35c390135..0e4cac37a5 100644
--- a/lib/util/cmcd_manager.js
+++ b/lib/util/cmcd_manager.js
@@ -6,7 +6,11 @@
 
 goog.provide('shaka.util.CmcdManager');
 
+goog.require('cml.cmcd.CMCD_EVENT_MODE');
+goog.require('cml.cmcd.CMCD_REQUEST_MODE');
 goog.require('cml.cmcd.encodeCmcd');
+goog.require('cml.cmcd.encodePreparedCmcd');
+goog.require('cml.cmcd.prepareCmcdData');
 goog.require('goog.Uri');
 
 goog.require('shaka.log');
@@ -448,7 +452,9 @@ shaka.util.CmcdManager = class {
       data.su = true;
 
       const query = shaka.util.CmcdManager.toQuery(
-          data, shaka.util.CmcdManager.getEncodeOptions_(uri));
+          data,
+          shaka.util.CmcdManager.getEncodeOptions_(
+              uri, this.config_.version, cml.cmcd.CMCD_REQUEST_MODE));
 
       return shaka.util.CmcdManager.appendQueryToUri(uri, query);
     } catch (error) {
@@ -475,7 +481,9 @@ shaka.util.CmcdManager = class {
       data.su = true;
 
       const query = shaka.util.CmcdManager.toQuery(
-          data, shaka.util.CmcdManager.getEncodeOptions_(uri));
+          data,
+          shaka.util.CmcdManager.getEncodeOptions_(
+              uri, this.config_.version, cml.cmcd.CMCD_REQUEST_MODE));
 
       return shaka.util.CmcdManager.appendQueryToUri(uri, query);
     } catch (error) {
@@ -823,7 +831,12 @@ shaka.util.CmcdManager = class {
     const retryParams = shaka.net.NetworkingEngine.defaultRetryParameters();
     let request = null;
     const baseURL = target.url;
-    const encodeOptions = shaka.util.CmcdManager.getEncodeOptions_(baseURL);
+    // Event-mode reports (event/response) skip baseUrl: the collector
+    // URL is generally a different origin from segment URLs, so passing
+    // it would not relativize `nor` the way old shaka did. Match CML's
+    // reporter, which omits baseUrl in event mode.
+    const encodeOptions = shaka.util.CmcdManager.getEncodeOptions_(
+        undefined, this.config_.version, cml.cmcd.CMCD_EVENT_MODE);
 
     if (target.useHeaders) {
       const headers =
@@ -863,8 +876,10 @@ shaka.util.CmcdManager = class {
    * @private
    */
   applyCmcdDataToRequest_(output, request, useHeaders) {
-    const encodeOptions =
-        shaka.util.CmcdManager.getEncodeOptions_(request.uris[0]);
+    const encodeOptions = shaka.util.CmcdManager.getEncodeOptions_(
+        request.uris[0],
+        this.config_.version,
+        cml.cmcd.CMCD_REQUEST_MODE);
     if (useHeaders) {
       const headers = shaka.util.CmcdManager.toHeaders(output, encodeOptions);
       if (!Object.keys(headers).length) {
@@ -1399,13 +1414,23 @@ shaka.util.CmcdManager = class {
    * defined in the section 2.1 and 3.2 of
    * [CTA-5004](https://cdn.cta.tech/cta/media/media/resources/standards/pdfs/cta-5004-final.pdf).
    *
+   * Two-step encode (rather than calling `serialize` per shard):
+   *   1. Run CML's `prepareCmcdData` once on the full input so version
+   *      auto-add, key filtering, and per-key formatters (incl. the
+   *      `nor` baseUrl rewrite) all apply once.
+   *   2. Bucket the prepared keys into shaka's four shards, then call
+   *      `encodePreparedCmcd` per shard so each shard SFV-encodes
+   *      without re-preparing — which would otherwise re-add `v=2` to
+   *      every non-empty shard.
+   *
    * @param {CmcdData} data The CMCD data object
    * @param {cml.cmcd.CmcdEncodeOptions=} options Encoding options
    *   (e.g. `baseUrl` to root-relativize `nor` URLs).
    * @return {!Object}
    */
   static toHeaders(data, options) {
-    const keys = Object.keys(data);
+    const prepared = cml.cmcd.prepareCmcdData(
+        /** @type {!Object<string, *>} */ (data), options);
     const headers = {};
     const headerNames = ['Object', 'Request', 'Session', 'Status'];
     const headerGroups = [{}, {}, {}, {}];
@@ -1417,15 +1442,15 @@ shaka.util.CmcdManager = class {
       bs: 3, rtp: 3, bg: 3,
     };
 
-    for (const key of keys) {
-      // Unmapped fields are mapped to the Request header
+    for (const key of Object.keys(prepared)) {
+      // Unmapped fields are mapped to the Request header.
       const index = (headerMap[key] != null) ? headerMap[key] : 1;
-      headerGroups[index][key] = data[key];
+      headerGroups[index][key] = prepared[key];
     }
 
     for (let i = 0; i < headerGroups.length; i++) {
-      const value =
-          shaka.util.CmcdManager.serialize(headerGroups[i], options);
+      const value = cml.cmcd.encodePreparedCmcd(
+          /** @type {!cml.cmcd.Cmcd} */ (headerGroups[i]));
       if (value) {
         headers[`CMCD-${headerNames[i]}`] = value;
       }
@@ -1477,25 +1502,38 @@ shaka.util.CmcdManager = class {
   }
 
   /**
-   * Build encoder options for a given URI by deriving `baseUrl` from
-   * its origin. Used by encode call sites so CML's `nor` formatter
-   * produces root-relative URLs. Returns an empty options object if
-   * the URI is missing, an `offline:` storage URI, or unparsable.
+   * Build encoder options for a CMCD encode call.
    *
-   * @param {(string|undefined)} uri
+   * @param {(string|undefined)} uri Source URL whose origin becomes
+   *   `baseUrl` so CML can rewrite `nor` URLs root-relative. Skipped
+   *   for `offline:` storage URIs and unparsable URIs.
+   * @param {number=} version `1` or `2`. Threads `this.config_.version`
+   *   to CML so V1 configurations get V1 keyset filtering and no
+   *   auto-`v=2`.
+   * @param {string=} reportingMode `'request'` or `'event'`. CML's
+   *   `prepareCmcdData` filters keys by mode (e.g. `e`/`ts` are
+   *   event-only). Defaults to CML's request mode if omitted.
    * @return {!cml.cmcd.CmcdEncodeOptions}
    * @private
    */
-  static getEncodeOptions_(uri) {
-    if (!uri || uri.includes('offline:')) {
-      return /** @type {!cml.cmcd.CmcdEncodeOptions} */ ({});
+  static getEncodeOptions_(uri, version, reportingMode) {
+    /** @type {!cml.cmcd.CmcdEncodeOptions} */
+    const options = /** @type {!cml.cmcd.CmcdEncodeOptions} */ ({});
+    if (uri && !uri.includes('offline:')) {
+      try {
+        options.baseUrl = new URL(uri).origin;
+      } catch (e) {
+        // Unparsable URI; skip baseUrl. CML's `nor` formatter passes
+        // values through unchanged when baseUrl is absent.
+      }
     }
-    try {
-      return /** @type {!cml.cmcd.CmcdEncodeOptions} */ (
-        {baseUrl: new URL(uri).origin});
-    } catch (e) {
-      return /** @type {!cml.cmcd.CmcdEncodeOptions} */ ({});
+    if (version != null) {
+      options.version = version;
+    }
+    if (reportingMode != null) {
+      options.reportingMode = reportingMode;
     }
+    return options;
   }
 };
 

From b94f7ebcab1046b298d91001e3b7cec788398de2 Mon Sep 17 00:00:00 2001
From: Casey Occhialini <1508707+littlespex@users.noreply.github.com>
Date: Tue, 28 Apr 2026 12:38:38 -0700
Subject: [PATCH 27/64] test(cmcd): update assertions for CML wire-format
 alignments
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Sub-phase E classifications (a)/(b) per plan.md Task 1.12 — tests now
match CML's spec-conformant wire output:

(a)/(b) string vs token formatting (~73 sites)
  Old: e="ps", e="m", e="pe", e="pc", e="t", e="um", e="rr",
       sta="s", sta="p", sta="r", sta="a", sta="d", sta="e",
       sta="w", sta="k"
  New: e=ps, e=m, e=pe, e=pc, e=t, e=um, e=rr,
       sta=s, sta=p, sta=r, sta=a, sta=d, sta=e, sta=w, sta=k
  CML treats `e` and `sta` values as RFC 8941 SFV tokens, not
  strings. shaka's old encoder emitted everything as quoted strings
  for non-token-shaped values; the SFV-aware emitter is correct
  per CTA-5004-B.

(b) v=2 auto-added in V2 output (8 sites)
  CML's prepareCmcdData unconditionally appends `v=2` when version
  is V2 (per CTA-5004-B § 4.1, V2 output MUST include `v`). Old
  shaka emitted `v` only when explicitly present in `data`. Tests
  that previously asserted `not.toContain('v=2')` (in cases where
  the user filtered `v` out via includeKeys) now assert
  `toContain('v=2')` — CML's auto-add takes precedence over
  includeKeys for the version field. Tests with no explicit `v`
  in `data` (escape test, single-key header test) gained `,v=2`
  in expected.

(b) ts no longer in request-mode output (1 site)
  Old shaka set data.ts = Date.now() in applyRequestSegmentData
  and emitted it in request-mode CMCD; per CTA-5004-B § 4.1 `ts`
  is event-mode-only. CML's request-mode filter correctly drops
  it. Inverted "includes ts for segment requests" to "does not
  include ts for segment requests".

(a)/(b) nor V2 inner-list format and event-mode no-baseUrl (1 site)
  Old: nor="next-seg.m4v" (V1 string format)
  New: nor=("https://test.com/next-seg.m4v") (V2 inner-list with
  absolute URL because event-mode reports skip baseUrl when the
  collector is at a different origin from the segment).

(b) urlToRelativePath unit tests already removed in d8d614ce3 (Task
  1.10) since the helper is gone.

After these updates, all 124 CMCD-filtered tests pass; the broader
--quick suite reports 2995 success / 0 fail.

Per Task 1.12 of plans/cmcd-cml-refactor/plan.md.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 test/util/cmcd_manager_unit.js | 188 +++++++++++++++++++--------------
 1 file changed, 107 insertions(+), 81 deletions(-)

diff --git a/test/util/cmcd_manager_unit.js b/test/util/cmcd_manager_unit.js
index 6cd5719c17..7ae9baf174 100644
--- a/test/util/cmcd_manager_unit.js
+++ b/test/util/cmcd_manager_unit.js
@@ -234,7 +234,9 @@ describe('CmcdManager Setup', () => {
         const query = CmcdManager.toQuery({
           'com.test-escape': 'Double "Quotes"',
         });
-        const result = 'com.test-escape="Double \\"Quotes\\""';
+        // CML's encoder treats absent `v` as V2 default and emits `v=2`
+        // alongside the data; old shaka encoder did not auto-add `v`.
+        const result = 'com.test-escape="Double \\"Quotes\\"",v=2';
         expect(query).toBe(result);
       });
     });
@@ -254,8 +256,11 @@ describe('CmcdManager Setup', () => {
       });
 
       it('ignores empty shards', () => {
+        // CML auto-adds `v=2` for V2 (the default version when no `v`
+        // is provided), so the Session shard is never truly empty.
         expect(CmcdManager.toHeaders({br: 200})).toEqual({
           'CMCD-Object': 'br=200',
+          'CMCD-Session': 'v=2',
         });
       });
     });
@@ -1311,7 +1316,11 @@ describe('CmcdManager Setup', () => {
 
         expect(decodedUri).toContain('sid=');
         expect(decodedUri).toContain('msd=');
-        expect(decodedUri).not.toContain('v=2');
+        // CML's prepareCmcdData unconditionally appends `v` for V2 even
+        // when the user's includeKeys filter omits it (CTA-5004-B § 4.1
+        // mandates `v` in V2 output). Old shaka encoder honored the
+        // includeKeys exclusion; spec-aligned behavior wins.
+        expect(decodedUri).toContain('v=2');
       });
 
       it('filters keys in request mode based on includeKeys', () => {
@@ -1335,7 +1344,10 @@ describe('CmcdManager Setup', () => {
         const decodedUri = decodeURIComponent(request.uris[0]);
         expect(decodedUri).toContain('sid=');
         expect(decodedUri).toContain('msd=');
-        expect(decodedUri).not.toContain('v=2');
+        // CML auto-adds `v=2` regardless of includeKeys (see "filters
+        // keys in response based on includeKeys" above for full
+        // rationale).
+        expect(decodedUri).toContain('v=2');
       });
     });
 
@@ -2044,7 +2056,11 @@ describe('CmcdManager Setup', () => {
         const request = requestSpy.calls.mostRecent().args[1];
         const decodedUri = decodeURIComponent(request.uris[0]);
 
-        expect(decodedUri).toContain('nor="next-seg.m4v"');
+        // V2 `nor` is an inner-list `nor=("...")` (CTA-5004-B § 4.1).
+        // Event-mode reports go to a collector at a different origin
+        // from the segment URL, so CML preserves the absolute URL
+        // rather than relativizing.
+        expect(decodedUri).toContain('nor=("https://test.com/next-seg.m4v")');
         expect(decodedUri).not.toContain('nrr=');
       });
 
@@ -2568,13 +2584,19 @@ describe('CmcdManager Setup', () => {
         expect(decodedUri).not.toContain('ltc=');
       });
 
-      it('includes ts for segment requests', () => {
+      it('does not include ts for segment requests', () => {
+        // Per CTA-5004-B § 4.1, `ts` is an event-only key. Old shaka
+        // emitted it in request-mode CMCD too; CML's request-mode
+        // filter (`isCmcdRequestKey`) correctly excludes it. The
+        // following `includes ts for segment responses` test confirms
+        // `ts` still appears for event-mode (response-received)
+        // reports, which is where it belongs.
         const cmcdManager = createCmcdManager(mockPlayer, {version: 2});
         const request = createRequest();
         const context = createSegmentContext();
         cmcdManager.applyRequestSegmentData(request, context);
         const decodedUri = decodeURIComponent(request.uris[0]);
-        expect(decodedUri).toContain('ts=');
+        expect(decodedUri).not.toContain('ts=');
       });
 
       it('includes ts for segment responses', () => {
@@ -3050,31 +3072,31 @@ describe('CmcdManager Setup', () => {
         let request = /** @type {!jasmine.Spy} */ (requestSpy)
             .calls.mostRecent().args[1];
         let decodedUri = decodeURIComponent(request.uris[0]);
-        expect(decodedUri).toContain('e="ps"');
-        expect(decodedUri).toContain('sta="s"');
+        expect(decodedUri).toContain('e=ps');
+        expect(decodedUri).toContain('sta=s');
         expect(decodedUri).toContain('v=2');
 
         mockVideo.dispatchEvent(new shaka.util.FakeEvent('playing'));
         request = /** @type {!jasmine.Spy} */ (requestSpy)
             .calls.mostRecent().args[1];
         decodedUri = decodeURIComponent(request.uris[0]);
-        expect(decodedUri).toContain('e="ps"');
-        expect(decodedUri).toContain('sta="p"');
+        expect(decodedUri).toContain('e=ps');
+        expect(decodedUri).toContain('sta=p');
         expect(decodedUri).toContain('v=2');
 
         mockVideo.dispatchEvent(new shaka.util.FakeEvent('pause'));
         request = /** @type {!jasmine.Spy} */ (requestSpy)
             .calls.mostRecent().args[1];
         decodedUri = decodeURIComponent(request.uris[0]);
-        expect(decodedUri).toContain('e="ps"');
-        expect(decodedUri).toContain('sta="a"');
+        expect(decodedUri).toContain('e=ps');
+        expect(decodedUri).toContain('sta=a');
 
         mockVideo.dispatchEvent(new shaka.util.FakeEvent('seeking'));
         request = /** @type {!jasmine.Spy} */ (requestSpy)
             .calls.mostRecent().args[1];
         decodedUri = decodeURIComponent(request.uris[0]);
-        expect(decodedUri).toContain('e="ps"');
-        expect(decodedUri).toContain('sta="k"');
+        expect(decodedUri).toContain('e=ps');
+        expect(decodedUri).toContain('sta=k');
       });
 
       it('sends mute and unmute events', () => {
@@ -3104,7 +3126,7 @@ describe('CmcdManager Setup', () => {
         let request = /** @type {!jasmine.Spy} */ (requestSpy)
             .calls.mostRecent().args[1];
         let decodedUri = decodeURIComponent(request.uris[0]);
-        expect(decodedUri).toContain('e="m"');
+        expect(decodedUri).toContain('e=m');
         expect(decodedUri).toContain('v=2');
 
         // Unmute
@@ -3116,7 +3138,7 @@ describe('CmcdManager Setup', () => {
         request = /** @type {!jasmine.Spy} */ (requestSpy)
             .calls.mostRecent().args[1];
         decodedUri = decodeURIComponent(request.uris[0]);
-        expect(decodedUri).toContain('e="um"');
+        expect(decodedUri).toContain('e=um');
       });
 
       describe('Time interval events', () => {
@@ -3149,7 +3171,7 @@ describe('CmcdManager Setup', () => {
           const request = /** @type {!jasmine.Spy} */ (requestSpy)
               .calls.mostRecent().args[1];
           const decodedUri = decodeURIComponent(request.uris[0]);
-          expect(decodedUri).toContain('e="t"');
+          expect(decodedUri).toContain('e=t');
           expect(decodedUri).toContain('v=2');
         });
 
@@ -3210,7 +3232,7 @@ describe('CmcdManager Setup', () => {
           const request = /** @type {!jasmine.Spy} */ (requestSpy)
               .calls.mostRecent().args[1];
           const decodedUri = decodeURIComponent(request.uris[0]);
-          expect(decodedUri).toContain('e="t"');
+          expect(decodedUri).toContain('e=t');
           expect(decodedUri).toContain('v=2');
         });
       });
@@ -3303,11 +3325,11 @@ describe('CmcdManager Setup', () => {
             .calls.mostRecent().args[1];
 
         const decodedUri = decodeURIComponent(request.uris[0]);
-        expect(decodedUri).toContain('e="m"');
-        expect(decodedUri).not.toContain('e="ps"');
-        expect(decodedUri).not.toContain('sta="p"');
-        expect(decodedUri).not.toContain('sta="a"');
-        expect(decodedUri).not.toContain('sta="k"');
+        expect(decodedUri).toContain('e=m');
+        expect(decodedUri).not.toContain('e=ps');
+        expect(decodedUri).not.toContain('sta=p');
+        expect(decodedUri).not.toContain('sta=a');
+        expect(decodedUri).not.toContain('sta=k');
 
         // Should not have been called again for 'seeking'
         expect(requestSpy).toHaveBeenCalledTimes(1);
@@ -3337,8 +3359,8 @@ describe('CmcdManager Setup', () => {
             .calls.mostRecent().args[1];
         let decodedUri = decodeURIComponent(request.uris[0]);
 
-        expect(decodedUri).toContain('e="ps"');
-        expect(decodedUri).toContain('sta="s"');
+        expect(decodedUri).toContain('e=ps');
+        expect(decodedUri).toContain('sta=s');
         expect(decodedUri).toContain('mtp=');
         expect(decodedUri).toContain('cid="v2-event-content"');
 
@@ -3349,8 +3371,8 @@ describe('CmcdManager Setup', () => {
             .calls.mostRecent().args[1];
         decodedUri = decodeURIComponent(request.uris[0]);
 
-        expect(decodedUri).toContain('e="ps"');
-        expect(decodedUri).toContain('sta="p"');
+        expect(decodedUri).toContain('e=ps');
+        expect(decodedUri).toContain('sta=p');
         expect(decodedUri).toContain('mtp=');
         expect(decodedUri).toContain('cid="v2-event-content"');
       });
@@ -3417,8 +3439,8 @@ describe('CmcdManager Setup', () => {
             .calls.mostRecent().args[1];
         let decodedUri = decodeURIComponent(request.uris[0]);
 
-        expect(decodedUri).toContain('e="ps"');
-        expect(decodedUri).toContain('sta="s"');
+        expect(decodedUri).toContain('e=ps');
+        expect(decodedUri).toContain('sta=s');
         expect(decodedUri).not.toContain('d=');
         expect(decodedUri).not.toContain('rtp=');
 
@@ -3429,8 +3451,8 @@ describe('CmcdManager Setup', () => {
             .calls.mostRecent().args[1];
         decodedUri = decodeURIComponent(request.uris[0]);
 
-        expect(decodedUri).toContain('e="ps"');
-        expect(decodedUri).toContain('sta="p"');
+        expect(decodedUri).toContain('e=ps');
+        expect(decodedUri).toContain('sta=p');
         expect(decodedUri).not.toContain('d=');
         expect(decodedUri).not.toContain('rtp=');
       });
@@ -3473,13 +3495,15 @@ describe('CmcdManager Setup', () => {
 
         // Assertions for the 'play' event
         const decodedUri1 = decodeURIComponent(playCall1.uris[0]);
-        expect(decodedUri1).toContain('e="ps"');
-        expect(decodedUri1).toContain('sta="s"');
-        expect(decodedUri1).not.toContain('v=2');
+        expect(decodedUri1).toContain('e=ps');
+        expect(decodedUri1).toContain('sta=s');
+        // cmcd1's includeKeys excludes 'v', but CML's prepareCmcdData
+        // unconditionally appends `v` for V2 (CTA-5004-B § 4.1).
+        expect(decodedUri1).toContain('v=2');
 
         const decodedUri2 = decodeURIComponent(playCall2.uris[0]);
-        expect(decodedUri2).toContain('e="ps"');
-        expect(decodedUri2).toContain('sta="s"');
+        expect(decodedUri2).toContain('e=ps');
+        expect(decodedUri2).toContain('sta=s');
         expect(decodedUri2).toContain('v=2');
 
         // Reset the spy before the next event to have clean calls
@@ -3498,13 +3522,15 @@ describe('CmcdManager Setup', () => {
 
         // Assertions for the 'playing' event
         const decodedUri3 = decodeURIComponent(playingCall1.uris[0]);
-        expect(decodedUri3).toContain('e="ps"');
-        expect(decodedUri3).toContain('sta="p"');
-        expect(decodedUri3).not.toContain('v=2');
+        expect(decodedUri3).toContain('e=ps');
+        expect(decodedUri3).toContain('sta=p');
+        // CML auto-adds `v=2` regardless of includeKeys (see 'play'
+        // assertion above for rationale).
+        expect(decodedUri3).toContain('v=2');
 
         const decodedUri4 = decodeURIComponent(playingCall2.uris[0]);
-        expect(decodedUri4).toContain('e="ps"');
-        expect(decodedUri4).toContain('sta="p"');
+        expect(decodedUri4).toContain('e=ps');
+        expect(decodedUri4).toContain('sta=p');
         expect(decodedUri4).toContain('v=2');
       });
 
@@ -3532,8 +3558,8 @@ describe('CmcdManager Setup', () => {
             .calls.mostRecent().args[1];
 
         expect(request.uris[0]).toBe('https://example.com/cmcd');
-        expect(request.headers['CMCD-Request']).toContain('e="ps"');
-        expect(request.headers['CMCD-Request']).toContain('sta="s"');
+        expect(request.headers['CMCD-Request']).toContain('e=ps');
+        expect(request.headers['CMCD-Request']).toContain('sta=s');
         expect(request.headers['CMCD-Request']).toContain('ts=');
 
         expect(request.headers['CMCD-Session']).toContain('v=2');
@@ -3544,8 +3570,8 @@ describe('CmcdManager Setup', () => {
             .calls.mostRecent().args[1];
 
         expect(request.uris[0]).toBe('https://example.com/cmcd');
-        expect(request.headers['CMCD-Request']).toContain('e="ps"');
-        expect(request.headers['CMCD-Request']).toContain('sta="p"');
+        expect(request.headers['CMCD-Request']).toContain('e=ps');
+        expect(request.headers['CMCD-Request']).toContain('sta=p');
         expect(request.headers['CMCD-Request']).toContain('ts=');
         expect(request.headers['CMCD-Session']).toContain('v=2');
         expect(request.headers['CMCD-Session']).toContain(`sid="${sessionId}"`);
@@ -3572,8 +3598,8 @@ describe('CmcdManager Setup', () => {
         const request = /** @type {!jasmine.Spy} */ (requestSpy)
             .calls.mostRecent().args[1];
         const decodedUri = decodeURIComponent(request.uris[0]);
-        expect(decodedUri).toContain('e="ps"');
-        expect(decodedUri).toContain('sta="s"');
+        expect(decodedUri).toContain('e=ps');
+        expect(decodedUri).toContain('sta=s');
         expect(decodedUri).toContain('ts=');
       });
 
@@ -3627,8 +3653,8 @@ describe('CmcdManager Setup', () => {
             .calls.mostRecent().args[1];
         const decodedUri = decodeURIComponent(request.uris[0]);
 
-        expect(decodedUri).toContain('e="ps"');
-        expect(decodedUri).toContain('sta="s"');
+        expect(decodedUri).toContain('e=ps');
+        expect(decodedUri).toContain('sta=s');
         expect(decodedUri).not.toContain('rc=');
         expect(decodedUri).not.toContain('url=');
         expect(decodedUri).not.toContain('ttfb=');
@@ -3686,8 +3712,8 @@ describe('CmcdManager Setup', () => {
         let decodedUri = decodeURIComponent(request.uris[0]);
 
         // Check for essential event keys
-        expect(decodedUri).toContain('e="ps"');
-        expect(decodedUri).toContain('sta="s"');
+        expect(decodedUri).toContain('e=ps');
+        expect(decodedUri).toContain('sta=s');
 
         mockVideo.dispatchEvent(new shaka.util.FakeEvent('playing'));
 
@@ -3697,8 +3723,8 @@ describe('CmcdManager Setup', () => {
         decodedUri = decodeURIComponent(request.uris[0]);
 
         // Check for essential event keys
-        expect(decodedUri).toContain('e="ps"');
-        expect(decodedUri).toContain('sta="p"');
+        expect(decodedUri).toContain('e=ps');
+        expect(decodedUri).toContain('sta=p');
 
         // Check for other common keys that should be included by default
         expect(decodedUri).toContain(`sid="${sessionId}"`);
@@ -3730,8 +3756,8 @@ describe('CmcdManager Setup', () => {
             .calls.mostRecent().args[1];
 
         let decodedUri = decodeURIComponent(request.uris[0]);
-        expect(decodedUri).toContain('e="ps"');
-        expect(decodedUri).toContain('sta="s"');
+        expect(decodedUri).toContain('e=ps');
+        expect(decodedUri).toContain('sta=s');
 
         mockMediaElement.dispatchEvent(new shaka.util.FakeEvent('playing'));
         expect(requestSpy).toHaveBeenCalledTimes(2);
@@ -3739,8 +3765,8 @@ describe('CmcdManager Setup', () => {
             .calls.mostRecent().args[1];
 
         decodedUri = decodeURIComponent(request.uris[0]);
-        expect(decodedUri).toContain('e="ps"');
-        expect(decodedUri).toContain('sta="p"');
+        expect(decodedUri).toContain('e=ps');
+        expect(decodedUri).toContain('sta=p');
 
         mockMediaElement.muted = true;
         mockMediaElement.dispatchEvent(
@@ -3749,7 +3775,7 @@ describe('CmcdManager Setup', () => {
         request = /** @type {!jasmine.Spy} */ (requestSpy)
             .calls.mostRecent().args[1];
         decodedUri = decodeURIComponent(request.uris[0]);
-        expect(decodedUri).toContain('e="m"');
+        expect(decodedUri).toContain('e=m');
 
         mockMediaElement.muted = false;
         mockMediaElement.dispatchEvent(
@@ -3758,7 +3784,7 @@ describe('CmcdManager Setup', () => {
         request = /** @type {!jasmine.Spy} */ (requestSpy)
             .calls.mostRecent().args[1];
         decodedUri = decodeURIComponent(request.uris[0]);
-        expect(decodedUri).toContain('e="um"');
+        expect(decodedUri).toContain('e=um');
       });
 
       it('sends all keys for all events when both arrays are empty', () => {
@@ -3788,8 +3814,8 @@ describe('CmcdManager Setup', () => {
         let request = /** @type {!jasmine.Spy} */ (requestSpy)
             .calls.mostRecent().args[1];
         let decodedUri = decodeURIComponent(request.uris[0]);
-        expect(decodedUri).toContain('e="ps"');
-        expect(decodedUri).toContain('sta="s"');
+        expect(decodedUri).toContain('e=ps');
+        expect(decodedUri).toContain('sta=s');
         expect(decodedUri).toContain(`sid="${sessionId}"`);
         expect(decodedUri).toContain(`cid="v2-event-content-all"`);
         expect(decodedUri).toContain('v=2');
@@ -3800,8 +3826,8 @@ describe('CmcdManager Setup', () => {
         request = /** @type {!jasmine.Spy} */ (requestSpy)
             .calls.mostRecent().args[1];
         decodedUri = decodeURIComponent(request.uris[0]);
-        expect(decodedUri).toContain('e="ps"');
-        expect(decodedUri).toContain('sta="p"');
+        expect(decodedUri).toContain('e=ps');
+        expect(decodedUri).toContain('sta=p');
         expect(decodedUri).toContain(`sid="${sessionId}"`);
         expect(decodedUri).toContain(`cid="v2-event-content-all"`);
         expect(decodedUri).toContain('v=2');
@@ -3814,7 +3840,7 @@ describe('CmcdManager Setup', () => {
         request = /** @type {!jasmine.Spy} */ (requestSpy)
             .calls.mostRecent().args[1];
         decodedUri = decodeURIComponent(request.uris[0]);
-        expect(decodedUri).toContain('e="m"');
+        expect(decodedUri).toContain('e=m');
         expect(decodedUri).toContain(`sid="${sessionId}"`);
         expect(decodedUri).toContain(`cid="v2-event-content-all"`);
         expect(decodedUri).toContain('v=2');
@@ -3850,8 +3876,8 @@ describe('CmcdManager Setup', () => {
         const request = (/** @type {!jasmine.Spy} */ (requestSpy))
             .calls.mostRecent().args[1];
         const decodedUri = decodeURIComponent(request.uris[0]);
-        expect(decodedUri).toContain('e="ps"');
-        expect(decodedUri).toContain('sta="r"');
+        expect(decodedUri).toContain('e=ps');
+        expect(decodedUri).toContain('sta=r');
         expect(decodedUri).toContain('v=2');
       });
 
@@ -3880,8 +3906,8 @@ describe('CmcdManager Setup', () => {
         const request = (/** @type {!jasmine.Spy} */ (requestSpy))
             .calls.mostRecent().args[1];
         const decodedUri = decodeURIComponent(request.uris[0]);
-        expect(decodedUri).toContain('e="ps"');
-        expect(decodedUri).toContain('sta="d"');
+        expect(decodedUri).toContain('e=ps');
+        expect(decodedUri).toContain('sta=d');
       });
 
       it('sends player expand and collapse events', () => {
@@ -3921,7 +3947,7 @@ describe('CmcdManager Setup', () => {
         let request = (/** @type {!jasmine.Spy} */ (requestSpy))
             .calls.mostRecent().args[1];
         let decodedUri = decodeURIComponent(request.uris[0]);
-        expect(decodedUri).toContain('e="pe"');
+        expect(decodedUri).toContain('e=pe');
 
         // Mock fullscreenElement to simulate exiting fullscreen
         Object.defineProperty(document, 'fullscreenElement', {
@@ -3934,7 +3960,7 @@ describe('CmcdManager Setup', () => {
         request = (/** @type {!jasmine.Spy} */ (requestSpy))
             .calls.mostRecent().args[1];
         decodedUri = decodeURIComponent(request.uris[0]);
-        expect(decodedUri).toContain('e="pc"');
+        expect(decodedUri).toContain('e=pc');
 
         // Restore original property
         Object.defineProperty(document, 'fullscreenElement', {
@@ -3972,8 +3998,8 @@ describe('CmcdManager Setup', () => {
         const request = /** @type {!jasmine.Spy} */ (requestSpy)
             .calls.mostRecent().args[1];
         const decodedUri = decodeURIComponent(request.uris[0]);
-        expect(decodedUri).toContain('e="ps"');
-        expect(decodedUri).toContain('sta="e"');
+        expect(decodedUri).toContain('e=ps');
+        expect(decodedUri).toContain('sta=e');
         expect(decodedUri).toContain('v=2');
       });
 
@@ -4006,8 +4032,8 @@ describe('CmcdManager Setup', () => {
         const request = /** @type {!jasmine.Spy} */ (requestSpy)
             .calls.mostRecent().args[1];
         const decodedUri = decodeURIComponent(request.uris[0]);
-        expect(decodedUri).toContain('e="ps"');
-        expect(decodedUri).toContain('sta="w"');
+        expect(decodedUri).toContain('e=ps');
+        expect(decodedUri).toContain('sta=w');
         expect(decodedUri).toContain('v=2');
       });
 
@@ -4038,7 +4064,7 @@ describe('CmcdManager Setup', () => {
         let request = (/** @type {!jasmine.Spy} */ (requestSpy))
             .calls.mostRecent().args[1];
         let decodedUri = decodeURIComponent(request.uris[0]);
-        expect(decodedUri).toContain('e="pe"');
+        expect(decodedUri).toContain('e=pe');
 
         // Simulate leaving Picture-in-Picture
         mockVideo.dispatchEvent(new shaka.util.FakeEvent(
@@ -4048,7 +4074,7 @@ describe('CmcdManager Setup', () => {
         request = (/** @type {!jasmine.Spy} */ (requestSpy))
             .calls.mostRecent().args[1];
         decodedUri = decodeURIComponent(request.uris[0]);
-        expect(decodedUri).toContain('e="pc"');
+        expect(decodedUri).toContain('e=pc');
       });
 
       it('sends webkit presentation mode change events', () => {
@@ -4091,7 +4117,7 @@ describe('CmcdManager Setup', () => {
         let request = (/** @type {!jasmine.Spy} */ (requestSpy))
             .calls.mostRecent().args[1];
         let decodedUri = decodeURIComponent(request.uris[0]);
-        expect(decodedUri).toContain('e="pe"');
+        expect(decodedUri).toContain('e=pe');
 
         // Simulate exiting fullscreen via webkit presentation mode
         mockVideo.webkitPresentationMode = 'inline';
@@ -4102,7 +4128,7 @@ describe('CmcdManager Setup', () => {
         request = (/** @type {!jasmine.Spy} */ (requestSpy))
             .calls.mostRecent().args[1];
         decodedUri = decodeURIComponent(request.uris[0]);
-        expect(decodedUri).toContain('e="pc"');
+        expect(decodedUri).toContain('e=pc');
       });
 
       it('sends separate reports with correct keys for multiple targets',
@@ -4167,14 +4193,14 @@ describe('CmcdManager Setup', () => {
 
             expect(firstRequest.uris[0]).toContain('target1.com');
             expect(firstDecodedUri).toContain('ts=');
-            expect(firstDecodedUri).toContain('e="rr"');
+            expect(firstDecodedUri).toContain('e=rr');
             expect(firstDecodedUri).toContain('rc');
             expect(firstDecodedUri).toContain('url');
             expect(firstDecodedUri).not.toContain('sta=');
 
             expect(secondRequest.uris[0]).toContain('target2.com');
-            expect(secondDecodedUri).toContain('e="ps"');
-            expect(secondDecodedUri).toContain('sta="s"');
+            expect(secondDecodedUri).toContain('e=ps');
+            expect(secondDecodedUri).toContain('sta=s');
             expect(secondDecodedUri).toContain('ts=');
             expect(secondDecodedUri).not.toContain('rc=');
             expect(secondDecodedUri).not.toContain('url=');

From 0e3883181bd42bb3091cea9de9aeedfbe0681f8c Mon Sep 17 00:00:00 2001
From: Casey Occhialini <1508707+littlespex@users.noreply.github.com>
Date: Tue, 28 Apr 2026 12:40:46 -0700
Subject: [PATCH 28/64] docs(cmcd): mark Phase 1 sub-phase E complete in plan
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Update plan.md "Current status" section: sub-phase E (Tasks 1.11 +
1.12) ✅ complete after this session, sub-phase F (Tasks 1.13-1.14:
demo smoke + Phase 1 PR) is the resume point.

Add a "Sub-phase E landing notes" subsection capturing the three
(c)-class adapter fixes (reportingMode threading, prepare-once for
header shards, version threading) and the five (a)/(b)-class
wire-format alignments updated in test assertions (nor V2
inner-list, v=2 always-present, ts request-mode drop, e/sta token
vs string, event-mode nor-stays-absolute).

Replace "Resuming work — sub-phase E prep" with "sub-phase F prep":
the PR description scaffolding now lives in the three landing-notes
sections and "Key architectural decisions" subsection. Phase 1 ships
three intentional wire-format changes — nor root-relative, 'ld'/'lh'
dropped, V2 SFV-conformant encoding.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 plans/cmcd-cml-refactor/plan.md | 38 ++++++++++++++++++++++-----------
 1 file changed, 26 insertions(+), 12 deletions(-)

diff --git a/plans/cmcd-cml-refactor/plan.md b/plans/cmcd-cml-refactor/plan.md
index f810b8d2e0..3337c75f6d 100644
--- a/plans/cmcd-cml-refactor/plan.md
+++ b/plans/cmcd-cml-refactor/plan.md
@@ -23,8 +23,8 @@ This refactor is actively in progress on branch `feat/cmcd-cml-refactor`. Read t
 | **Phase 1B** — Encoders + helpers + cml-utils/sfv shims + deferred `CMCD_FORMATTER_MAP` (Tasks 1.6-1.7) | ✅ Complete | 5 commits, ending at `9bcf6614e`. 23 new files. Re-included 8 spec-excluded files (predicates + `is_valid.js` + `group_cmcd_headers.js`) that were genuinely runtime-required by encoders. New shim `cml_sfv.js` (~448 LoC, RFC 8941 §4.1 serializer). |
 | **Phase 1C** — `CmcdReporter` + 5 deferred typedefs (Task 1.8) | ✅ Complete | 3 commits, ending at `d682bb1bb`. 6 new files. The vendored port is now structurally complete. |
 | **Phase 1D** — Encoding delegation in `cmcd_manager.js` + drop non-spec `'ld'`/`'lh'` (Tasks 1.10, 1.10b) | ✅ Complete | 2 commits, ending at `adfdfab05`. Net −168 LoC across `lib/util/cmcd_manager.js` and `test/util/cmcd_manager_unit.js`. `python3 build/check.py` exits 0. `build/test.py` deferred to sub-phase E (Tasks 1.11-1.12 catalog and update wire-format-divergence assertions). |
-| **Phase 1E** — Diff testing + assertion updates (Tasks 1.11-1.12) | ⏳ **Resume here.** | Needs human judgment on divergence classification. |
-| **Phase 1F** — Demo verification + Phase 1 PR (Tasks 1.13-1.14) | ⏳ Not started | Phase 1 ships as PR after this. |
+| **Phase 1E** — Diff testing + assertion updates (Tasks 1.11-1.12) | ✅ Complete | 2 commits ending at `b94f7ebca`. Started at 52 of 124 CMCD tests failing post-1.10; ended at 0 fail / 124 pass. Three (c)-class adapter bugs fixed in `27cd16907`; ~80 (a)/(b)-class assertion updates in `b94f7ebca`. Full `--quick` suite: 2995/2995 pass. |
+| **Phase 1F** — Demo verification + Phase 1 PR (Tasks 1.13-1.14) | ⏳ **Resume here.** | Phase 1 ships as PR after this. |
 | **Phase 2** — Adopt CML constants, dedupe shaka duplicates | ⏳ Not started | After Phase 1 merges. |
 | **Phase 3** — Adapter rewrite (the big behavioral change) | ⏳ Not started | After Phase 2 merges. |
 
@@ -39,6 +39,26 @@ This refactor is actively in progress on branch `feat/cmcd-cml-refactor`. Read t
   2. `'ld'` / `'lh'` `StreamingFormat` values dropped — LL DASH now emits `sf=d`, LL HLS now emits `sf=h`. `setLowLatency` no longer mutates `sf_`; `getStreamFormat_` no longer branches on `lowLatency_`.
 - **No tests asserted `sf=ld`/`sf=lh`** (verified via repo-wide grep). The `urlToRelativePath` describe-block (9 tests) was the only test deletion in sub-phase D.
 
+### Sub-phase E landing notes (Tasks 1.11 + 1.12)
+
+Sub-phase E classified the diff between pre-delegation and post-delegation wire output by running the existing test suite at HEAD-after-1.10 — failures themselves served as the diff. 52 of 124 CMCD tests failed initially; 0 fail after sub-phase E.
+
+**Three (c)-class adapter bugs fixed in `27cd16907`:**
+
+1. **C1** — Event-mode encoded output dropped event-only keys (`e`, `ts`, `cen`). `cml.cmcd.prepareCmcdData` defaults `reportingMode` to request mode when not specified, and the request-mode filter excludes event-only keys. Threaded `reportingMode` through `getEncodeOptions_`: `CMCD_EVENT_MODE` for `sendCmcdRequest_` (the out-of-band event/response-received path), `CMCD_REQUEST_MODE` for `applyCmcdDataToRequest_` / `appendSrcData` / `appendTextTrackData`. `sendCmcdRequest_` also stops passing `baseURL`: target collector URLs are typically a different origin from segment URLs, so `baseUrl`-based `nor` rewriting is meaningless there.
+2. **C2** — `toHeaders` emitted `v=2` in every shard. shaka's old serialize-per-shard pattern, once delegated, ran `prepareCmcdData` per shard and got `v=2` auto-added each time. Restructured `toHeaders` to call `prepareCmcdData` once on the full data, bucket the prepared keys into shaka's existing `headerMap`, and call `encodePreparedCmcd` per shard so re-preparation is skipped.
+3. **C3** — V1 configurations were getting V2 filter behavior because `prepareCmcdData` defaults to V2. Tests with V1-only keys (e.g. `nrr`) saw them filtered out. Threaded `this.config_.version` through `getEncodeOptions_`.
+
+**Five (a)/(b)-class wire-format alignments shipped in `b94f7ebca`** (test assertions updated; no code change):
+
+A. **`nor` URLs root-relative + V2 inner-list format.** Already shipped in sub-phase D Task 1.10. CML emits `nor=("path")` (V2 inner-list) instead of `nor="path"` (V1 string).
+B. **`v=2` auto-added in V2 output.** Per CTA-5004-B § 4.1, V2 output MUST include `v`. CML's `prepareCmcdData` enforces this even when the user filters `v` out via `includeKeys`. Old shaka emitted `v` only when explicitly present in `data`. Tests that previously asserted `not.toContain('v=2')` now assert `toContain('v=2')`; tests with no `v` in input now expect `,v=2` in output.
+C. **`ts` no longer in request-mode output.** Old shaka emitted `ts=<timestamp>` in request-mode CMCD; per CTA-5004-B `ts` is event-mode only. CML's request-mode filter correctly drops it. Inverted "includes ts for segment requests" to "does not include ts".
+D. **Token vs string formatting** for `e` and `sta` values (~73 sites). Old shaka quoted them as strings (`e="ps"`, `sta="s"`); CML emits them as RFC 8941 SFV tokens (`e=ps`, `sta=s`) per spec.
+E. **Event-mode `nor` stays absolute.** When the collector URL is at a different origin from the segment URL, CML doesn't relativize `nor` (no `baseUrl` in event mode). Tests expecting path-relative event-mode `nor` updated to expect the absolute URL.
+
+**Resolved (c)-class bug summary for the Phase 1 PR description:** the three adapter fixes (`reportingMode` threading, prepare-once header encoding, `version` threading) are the load-bearing parts of sub-phase E. The (a)/(b) test updates document the spec-conformance and SFV-encoding alignments that drove ~80 assertion changes.
+
 ### Key architectural decisions in the port — surface in Phase 1 PR description
 
 These were judgment calls during sub-phases B+C; maintainers should weigh in before merge:
@@ -53,17 +73,11 @@ Two git stashes exist:
 - `stash@{0}: On feat/cmcd-cml-refactor: accidental-stash-pop-recovery` — created during a sub-phase B subagent's `git stash pop` mishap. Contains contaminated working state from that incident.
 - `stash@{1}: On task/revert-cmcd-v1: CMCD STUFF` — pre-existing user stash. Preserved.
 
-### Resuming work in a new session — sub-phase E prep
+### Resuming work in a new session — sub-phase F prep
 
-- **Verify CML pinned clone** is still at `/tmp/cml-pinned/`. Run `cd /tmp/cml-pinned && git rev-parse HEAD` — should output `22390e35dfbbe1e53d15648d3aace99cdf71f9dd`. If missing or wrong SHA, re-clone:
-  ```bash
-  rm -rf /tmp/cml-pinned
-  git clone https://github.com/streaming-video-technology-alliance/common-media-library.git /tmp/cml-pinned
-  cd /tmp/cml-pinned && git checkout 22390e35dfbbe1e53d15648d3aace99cdf71f9dd
-  ```
-- **Sub-phase E scope (Tasks 1.11-1.12):** capture pre-delegation baseline + post-delegation wire output for the existing `test/util/cmcd_manager_unit.js` suite, diff, and classify each divergence as (a) intentional spec-conformance fix, (b) acceptable alignment with CML, or (c) bug to fix before shipping Phase 1. Update assertions for (a)/(b); resolve (c) before Phase 1 PR.
-- **Capturing the pre-delegation baseline** requires reverting sub-phase D temporarily. Cleanest: `git checkout 0f69e7f0e -- lib/util/cmcd_manager.js test/util/cmcd_manager_unit.js`, dump test wire output, reset, re-dump post-delegation. (The plan's literal `git stash`/`git stash pop` flow assumed sub-phase D was uncommitted; since it's now committed across `d8d614ce3` + `adfdfab05`, the checkout-from-prior-SHA flow is the equivalent.)
-- **Expected divergence categories** (pre-judgment): `nor` URLs path-relative → root-relative (intentional); CML's SFV encoder vs shaka's old comma-separated encoder may differ on string escaping, key ordering, and whether `v=2` is auto-added per shard in `toHeaders` (CML's `prepareCmcdData` adds `v` for V2; shaka's old encoder didn't). The `v=2` per-shard auto-add is the most likely (c)-class bug — shaka groups data into 4 shards before encoding, so without intervention every shard will emit `v=2`.
+- **Verify CML pinned clone** is still at `/tmp/cml-pinned/` (same as sub-phase D/E prep — should be `22390e35dfbbe1e53d15648d3aace99cdf71f9dd`).
+- **Sub-phase F scope (Tasks 1.13-1.14):** smoke-test the demo with CMCD enabled in both transmission modes, then open the Phase 1 PR. The smoke test verifies the wire-format changes against a real player flow (the test suite verifies them in isolation).
+- **Phase 1 PR description scaffolding** is in this plan — see "Sub-phase D landing notes", "Sub-phase E landing notes", and "Key architectural decisions in the port". Three intentional wire-format changes summarized: (1) `nor` URLs root-relative; (2) `'ld'`/`'lh'` `StreamingFormat` dropped; (3) V2 SFV encoding (token vs string for `e`/`sta`, `v=2` always present, `nor` inner-list).
 
 ---
 

From d663f6c12939fc399c5cd19d671bfe3c23173125 Mon Sep 17 00:00:00 2001
From: Casey Occhialini <1508707+littlespex@users.noreply.github.com>
Date: Tue, 28 Apr 2026 14:28:54 -0700
Subject: [PATCH 29/64] docs(cmcd): mark Phase 1 sub-phase F complete; add
 all-phases PR draft
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Sub-phase F (Task 1.13: demo smoke test) ✅ complete — Phase 1 of the
CMCD CML refactor is now fully done. End-to-end verification on
bbb-dark-truths/dash.mpd via Claude Preview-driven local HTTP server,
both transmission modes:

  Query mode:  ?CMCD=cid="…",ot=m,sf=d,sid="…",sn=N,su,v=2
               (v=2 always present, ts absent in request mode, sf=d
               for DASH (no 'ld'), ot/sf/st as bare SFV tokens, cid/sid
               as quoted strings, su as bare-token boolean)
  Header mode: CMCD-Object: ot=m
               CMCD-Request: mtp=N,sn=N,su
               CMCD-Session: cid="…",sf=d,sid="…",v=2
               (v=2 only in CMCD-Session, not in Object/Request/Status —
                the C2 sub-phase E fix verified end-to-end)

Zero JS console errors during the demo session. Cross-origin storage.
googleapis.com blocks CMCD-* via CORS preflight; smoke test stripped
the headers in a request filter so segment fetch could complete. Real
deployments configure their own CDN to allow CMCD-* preflight — this
is browser-spec behavior, not a shaka issue.

Plan changes:
- Mark Phase 1F ✅ in the status table; resume point is now Phase 2.
- Replace "Phase 1 ships as PR after this" with a "PR strategy
  (revised 2026-04-28)" note in Plan structure: per user direction,
  per-phase PRs are deprecated. Single PR off feat/cmcd-cml-refactor
  after Phase 3 lands. Sub-phase boundaries still gate work
  internally (build/check.py + test.py per sub-phase).
- Replace the "sub-phase F prep" subsection with a "Phase 2 prep"
  subsection. Phase 2 is pure dedupe (Tasks 2.1-2.6: map shaka enums
  to CML, replace internal references, alias-export StreamingFormat).
- Add a "Sub-phase F landing notes" subsection parallel to D and E,
  capturing the smoke-test sample wire output for the eventual all-
  phases PR description.

New file:
- `plans/cmcd-cml-refactor/phase-1-pr-draft.md` — Phase 1 portion of
  the PR description scaffolding. Originally intended as a temporary
  scratch file (per Task 1.12 step 5), now persisted as scaffolding
  that Phase 2 + 3 sections will accrete to before the all-phases PR.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 plans/cmcd-cml-refactor/phase-1-pr-draft.md | 149 ++++++++++++++++++++
 plans/cmcd-cml-refactor/plan.md             |  42 +++++-
 2 files changed, 185 insertions(+), 6 deletions(-)
 create mode 100644 plans/cmcd-cml-refactor/phase-1-pr-draft.md

diff --git a/plans/cmcd-cml-refactor/phase-1-pr-draft.md b/plans/cmcd-cml-refactor/phase-1-pr-draft.md
new file mode 100644
index 0000000000..ee1ae16b2d
--- /dev/null
+++ b/plans/cmcd-cml-refactor/phase-1-pr-draft.md
@@ -0,0 +1,149 @@
+<!--
+Phase 1 PR draft. Temporary file (not committed). Move title to PR title
+and body to PR body when opening. Per Task 1.12 step 5 / Task 1.14 of
+plans/cmcd-cml-refactor/plan.md.
+-->
+
+# Title
+
+```
+refactor(cmcd): vendor @svta/cml-cmcd, delegate encoding to CML (1/3)
+```
+
+# Body
+
+## Summary
+
+Phase 1 of 3 in the CMCD CML refactor. Replaces shaka's custom CMCD wire-format encoding with a vendored Closure port of [`@svta/cml-cmcd`](https://github.com/streaming-video-technology-alliance/common-media-library) (CML) under `third_party/cml-cmcd/`. Phases 2 and 3 will adopt CML's constants/enums (Phase 2) and rewrite `cmcd_manager.js` as a thin adapter around `CmcdReporter` (Phase 3) — see [`plans/cmcd-cml-refactor/spec.md`](plans/cmcd-cml-refactor/spec.md) and [`plans/cmcd-cml-refactor/plan.md`](plans/cmcd-cml-refactor/plan.md).
+
+This PR is **behavior-preserving** for shaka's public API, modulo three documented intentional wire-format changes that align shaka with CTA-5004 / CTA-5004-B and CML's spec-conformant output.
+
+## What's vendored
+
+`third_party/cml-cmcd/` mirrors the CML repo's `libs/cmcd/src/` plus two shim files (`cml_utils.js`, `cml_sfv.js`):
+
+| Group | Files | Notes |
+|---|---|---|
+| Typedefs | 23 | TS interfaces ported as Closure `@typedef` records. |
+| Enums | 5 | `CmcdEventType`, `CmcdPlayerState`, `CmcdReportingMode`, `CmcdStreamingFormat`, `CmcdTransmissionMode`. |
+| Constants | 8 | Per-mode keysets, formatter map, header map, etc. |
+| Encoders | 14 | `encodeCmcd`, `toCmcdQuery`, `toCmcdHeaders`, `appendCmcdQuery`, `appendCmcdHeaders`, plus internals. |
+| Helpers | 4 | `prepareCmcdData`, `upConvertToV2`, `resolveVersion`, `groupCmcdHeaders`. |
+| Predicates | 6 | `isCmcdRequestKey`, `isCmcdEventKey`, etc. |
+| Reporter | 1 | `cmcd_reporter.js` (CmcdReporter class — used by Phase 3). |
+| Shims | 2 | `cml_utils.js` (uuid + URL helpers + dead-code `defaultRequester`); `cml_sfv.js` (RFC 8941 §4.1 SFV serializer). |
+| Legal | 3 | `LICENSE` (Apache 2.0), `NOTICE`, `SUMMARY.txt`. |
+
+CML pin: **`cmcd-v2.3.0` / commit `22390e35dfbbe1e53d15648d3aace99cdf71f9dd`**. See [`plans/cmcd-cml-refactor/cml-version.md`](plans/cmcd-cml-refactor/cml-version.md) for the full Phase 0 verification report.
+
+When shaka migrates to TypeScript ([#8262](https://github.com/shaka-project/shaka-player/issues/8262)), the vendored directory deletes and each `goog.require('cml.cmcd.X')` becomes `import { X } from '@svta/cml-cmcd'` — no other code changes.
+
+## Architectural decisions in the port
+
+These are judgment calls during sub-phase B+C; please weigh in:
+
+1. **`setInterval` whitelisted** in `build/conformance.textproto` for `third_party/cml-cmcd/cmcd_reporter.js`. The reporter calls `setInterval` directly for periodic time-interval event reporting. Alternatives considered: (a) patching the vendored reporter to use `shaka.util.Timer` (breaks verbatim parity, complicates per-bump diff workflow), (b) filing a CML upstream PR for injectable-timer support (delays Phase 1). Whitelist is pragmatic but means **Phase 3 tests can't inject a fake timer** — will need `jasmine.clock()` for interval testing.
+2. **`fetch` whitelisted** in `build/conformance.textproto` for `third_party/cml-cmcd/cml_utils.js`. Used by `cml.cmcd.defaultRequester` — dead code at runtime because the shaka adapter always supplies a custom `requester` via `NetworkingEngine`. Closure ADVANCED is expected to strip the dead path; the conformance check runs first.
+3. **`defaultRequester` relocated** from `CmcdReporter.ts` module scope into `cml_utils.js` as `cml.cmcd.defaultRequester`. Done to centralize the `fetch` whitelist scope to a single file. **Per-bump CML diff workflow needs to know** `defaultRequester` lives here, not in the reporter — otherwise CML 2.4.0+ bumps will look like the function vanished.
+
+## Wire-format changes (intentional)
+
+Three changes; all align shaka with CTA-5004-B and CML's spec-conformant output. Test assertions updated to match.
+
+**1. `nor` URLs become root-relative + V2 inner-list format.**
+
+- **V1**: `nor="next-seg.m4v"` (path-relative against request URL).
+- **V2**: `nor=("next-seg.m4v")` (RFC 8941 inner-list, root-relative against request origin per CTA-5004-B § 4.1).
+
+`cmcd_manager.js` no longer pre-relativizes `data.nor`; CML's `nor` formatter relativizes against `options.baseUrl` (request URL's origin). For event-mode reports sent to a different-origin collector, `nor` stays absolute.
+
+**2. `'ld'` and `'lh'` `StreamingFormat` values dropped.**
+
+CTA-5004 / CTA-5004-B define only `'d'` (DASH), `'h'` (HLS), `'s'` (Smooth), `'o'` (Other). `'ld'` and `'lh'` were from an old unreleased CMCD draft and are non-spec. **Wire change**: low-latency DASH content now emits `sf=d`; low-latency HLS now emits `sf=h`. `setLowLatency()` no longer mutates `sf_`; the LL flag is preserved for any external readers but has no effect on the encoded `sf` value.
+
+**3. V2 SFV-conformant encoding.**
+
+CML uses RFC 8941 Structured Field Values for V2 output; old shaka used a JSON-stringify-shaped quoting rule. Concrete differences:
+
+- **Token vs string formatting** for `e` (event type) and `sta` (player state) values. Old: `e="ps"`, `sta="s"`. New: `e=ps`, `sta=s`. Per CTA-5004-B these values are spec-defined single-character tokens; SFV tokens don't take quotes.
+- **`v=2` always present in V2 output.** Per CTA-5004-B § 4.1, V2 output MUST include `v`. Old shaka emitted `v` only when explicitly present in input data. CML's `prepareCmcdData` enforces this, even when the user filters `v` out via `includeKeys`.
+- **`ts` no longer in request-mode output.** Per CTA-5004-B `ts` is event-mode only. Old shaka emitted `ts=<timestamp>` in request-mode CMCD; CML's request-mode filter correctly drops it. (Event-mode and response-received reports continue to include `ts`.)
+
+## Behavior preserved otherwise
+
+The state machine, sequence numbers (`cmcdSequenceNumbers_` per-target counters), event timing, request/response routing, and the public `shaka.util.CmcdManager` API are unchanged. The `setLowLatency`, `setMediaElement`, `configure`, `reset`, `applyRequestData`, `applyResponseData`, `appendSrcData`, `appendTextTrackData` entry points retain their existing signatures and semantics. Phase 2 dedupes constants/enums; Phase 3 rewrites the state machine as a thin adapter around `CmcdReporter` and is the load-bearing behavioral change.
+
+## Implementation summary
+
+`shaka.util.CmcdManager` static encoders now delegate:
+
+- `serialize(data, options)` → `cml.cmcd.encodeCmcd(data, options)`.
+- `toQuery(data, options)` → `cml.cmcd.encodeCmcd(data, options)` (preserves shaka's "raw value, no `CMCD=` prefix" contract — CML's `toCmcdQuery` returns the prefixed form, which would break callers).
+- `toHeaders(data, options)` → `cml.cmcd.prepareCmcdData(data, options)` once on the full input, then bucketed into shaka's existing 4-shard `headerMap`, then `cml.cmcd.encodePreparedCmcd` per shard. Calling the high-level `encodeCmcd` per shard would re-run `prepareCmcdData` and re-add `v=2` to every non-empty shard.
+- `appendQueryToUri(uri, query)` retained as a `goog.Uri`-based adapter — CML's `appendCmcdQuery(url, cmcd, options)` takes a data object, not a pre-encoded query string, so direct delegation isn't possible. Phase 3 deletes call sites entirely.
+- `urlToRelativePath` deleted; the helper and its 9 unit tests are gone.
+
+A new private `getEncodeOptions_(uri, version, reportingMode)` static helper builds `cml.cmcd.CmcdEncodeOptions` objects at the four CMCD-encoding call sites: `appendSrcData`, `appendTextTrackData`, `sendCmcdRequest_` (event/response path), `applyCmcdDataToRequest_` (request path). It threads `this.config_.version` and the reporting mode (`CMCD_REQUEST_MODE` for request paths, `CMCD_EVENT_MODE` for `sendCmcdRequest_`).
+
+## Diff size
+
+- `third_party/cml-cmcd/`: 74 new JS files + LICENSE/NOTICE/SUMMARY (+5017 lines).
+- `lib/util/cmcd_manager.js`: +100 / −138 lines (net −38).
+- `test/util/cmcd_manager_unit.js`: +107 / −140 lines (net −33; mostly assertion updates and the deleted `urlToRelativePath` describe block).
+- `build/conformance.textproto`: 2 entries added (`setInterval`, `fetch`).
+- `build/types/core`: 74 entries added for the vendored files.
+- `plans/cmcd-cml-refactor/`: design + verification docs.
+
+**Total**: 84 files, +5797 / −327.
+
+(Plan estimated ~3000 lines for the port; actual is ~5000 because of (a) `cml_sfv.js` (~448 LoC RFC 8941 serializer shim — CML uses `@svta/cml-utils`'s SFV encoder, which we vendor inline since the shim doesn't ship as a separate package), (b) 8 spec-excluded files re-included as runtime dependencies, and (c) generous license/notice headers per Apache 2.0.)
+
+## Verification
+
+- [x] `python3 build/check.py` exits 0 (lint, conformance, types, spelling).
+- [x] `python3 build/all.py` exits 0 (full bundle build: dash/hls/compiled/ui/experimental, debug + release).
+- [x] `python3 build/test.py --filter Cmcd` — 124 / 124 pass.
+- [x] `python3 build/test.py --quick` — 2995 / 2995 pass (no regressions outside CMCD).
+- [x] Demo smoke test on `bbb-dark-truths/dash.mpd` — query mode emits `?CMCD=cid="…",ot=m,sf=d,sid="…",sn=N,su,v=2` (no `ts`, no `sf=ld`, tokens unquoted, `v=2` always present); header mode emits `v=2` only in `CMCD-Session` shard (the C2 sub-phase E fix verified end-to-end). Zero JS console errors. See [`plan.md`](plans/cmcd-cml-refactor/plan.md) "Sub-phase F landing notes" for the full capture.
+
+## Plan / spec docs
+
+This PR includes the design + verification docs under `plans/cmcd-cml-refactor/`:
+
+- [`spec.md`](plans/cmcd-cml-refactor/spec.md) — canonical spec, file lists, type translations, encoding rules, lifecycle tables.
+- [`plan.md`](plans/cmcd-cml-refactor/plan.md) — phase-by-phase implementation plan with sub-phase landing notes.
+- [`cml-version.md`](plans/cmcd-cml-refactor/cml-version.md) — Phase 0 CML API verification report (pin SHA, method-by-method confirmation against CML source).
+
+These remain in the repo as Phase 2 + 3 reference. They can be deleted once Phase 3 merges if maintainers prefer.
+
+## Phase 1 commit list (for reviewer convenience)
+
+```
+79702531e docs(cmcd): add Phase 0 CML version pin + API verification report
+33c7c78ab docs(cmcd): fix doc cross-references in Phase 0 verification report
+be97afe47 docs(cmcd): restructure Phase 0 doc-update checklist into plan vs spec lists
+6a851a2d8 docs(cmcd): apply Phase 0 verification findings to spec and plan
+a8d855179 chore(third_party): add cml-cmcd vendoring skeleton
+0027abbe1 chore(cmcd): port cml-cmcd type definitions as closure typedefs
+ae92000c7 chore(cmcd): port cml-cmcd enums to closure
+c4d84a2d8 chore(cmcd): port cml-cmcd constants to closure
+1e539e703 chore(cmcd): port cml-cmcd uuid shim
+e6cb2563d chore(cmcd): wire phase 1A port into build, add doc consistency
+1b51edfc5 chore(cmcd): vendor cml-utils + cml-sfv shims for encoder port
+7a27aaacf chore(cmcd): port CMCD_FORMATTER_MAP (deferred from sub-phase A)
+3d6d5ae27 chore(cmcd): port cml-cmcd encoders to closure
+d9aa2f9a1 chore(cmcd): port cml-cmcd version-resolution helpers
+9bcf6614e fix(cmcd): restore typedef requireType in cmcd.js/event/response, polish cml_sfv
+988712ea6 chore(cmcd): port CmcdReporter-only typedefs (deferred from sub-phase A)
+3de73b29b chore(cmcd): port cml-cmcd CmcdReporter to closure
+d682bb1bb fix(cmcd): tighten transmissionMode typedef, unify ?? fallbacks in reporter
+0f69e7f0e docs(cmcd): add Phase 1 sub-phase A-C completion status to plan
+d8d614ce3 refactor(cmcd): delegate encoding to vendored cml-cmcd
+adfdfab05 fix(cmcd): drop non-spec 'ld'/'lh' StreamingFormat values
+4aa5ff76b docs(cmcd): mark Phase 1 sub-phase D complete in plan
+27cd16907 fix(cmcd): thread version/reportingMode + prepare-once for header shards
+b94f7ebca test(cmcd): update assertions for CML wire-format alignments
+0e3883181 docs(cmcd): mark Phase 1 sub-phase E complete in plan
+```
+
+The first 5 commits (`79702531e`–`6a851a2d8`) are Phase 0 docs only and could be split off as a docs-only PR if maintainers prefer. The rest are Phase 1 proper.
diff --git a/plans/cmcd-cml-refactor/plan.md b/plans/cmcd-cml-refactor/plan.md
index 3337c75f6d..18d6f30f5f 100644
--- a/plans/cmcd-cml-refactor/plan.md
+++ b/plans/cmcd-cml-refactor/plan.md
@@ -24,7 +24,7 @@ This refactor is actively in progress on branch `feat/cmcd-cml-refactor`. Read t
 | **Phase 1C** — `CmcdReporter` + 5 deferred typedefs (Task 1.8) | ✅ Complete | 3 commits, ending at `d682bb1bb`. 6 new files. The vendored port is now structurally complete. |
 | **Phase 1D** — Encoding delegation in `cmcd_manager.js` + drop non-spec `'ld'`/`'lh'` (Tasks 1.10, 1.10b) | ✅ Complete | 2 commits, ending at `adfdfab05`. Net −168 LoC across `lib/util/cmcd_manager.js` and `test/util/cmcd_manager_unit.js`. `python3 build/check.py` exits 0. `build/test.py` deferred to sub-phase E (Tasks 1.11-1.12 catalog and update wire-format-divergence assertions). |
 | **Phase 1E** — Diff testing + assertion updates (Tasks 1.11-1.12) | ✅ Complete | 2 commits ending at `b94f7ebca`. Started at 52 of 124 CMCD tests failing post-1.10; ended at 0 fail / 124 pass. Three (c)-class adapter bugs fixed in `27cd16907`; ~80 (a)/(b)-class assertion updates in `b94f7ebca`. Full `--quick` suite: 2995/2995 pass. |
-| **Phase 1F** — Demo verification + Phase 1 PR (Tasks 1.13-1.14) | ⏳ **Resume here.** | Phase 1 ships as PR after this. |
+| **Phase 1F** — Demo verification (Task 1.13) | ✅ Complete | Smoke-test on `bbb-dark-truths/dash.mpd` via Claude Preview-driven `python3 -m http.server`. Query mode (15 segment requests captured): `?CMCD=…cid="smoke-test",ot=m,sf=d,sid="…",sn=N,su,v=2` — `v=2` always present, `ts` absent in request mode, `sf=d` (no `'ld'`), `ot`/`sf`/`st` as tokens. Header mode (15 requests captured via request filter; CMCD-* stripped before fetch to avoid CORS preflight): `v=2` only in `CMCD-Session` shard (not in `CMCD-Object`/`Request`/`Status`); request shard contains `sn`/`mtp`/`su` only — no `ts`. Zero JS console errors. Per-phase PR (Task 1.14) deferred to single all-phases PR per user direction. |
 | **Phase 2** — Adopt CML constants, dedupe shaka duplicates | ⏳ Not started | After Phase 1 merges. |
 | **Phase 3** — Adapter rewrite (the big behavioral change) | ⏳ Not started | After Phase 2 merges. |
 
@@ -59,6 +59,36 @@ E. **Event-mode `nor` stays absolute.** When the collector URL is at a different
 
 **Resolved (c)-class bug summary for the Phase 1 PR description:** the three adapter fixes (`reportingMode` threading, prepare-once header encoding, `version` threading) are the load-bearing parts of sub-phase E. The (a)/(b) test updates document the spec-conformance and SFV-encoding alignments that drove ~80 assertion changes.
 
+### Sub-phase F landing notes (Task 1.13)
+
+End-to-end smoke test on `bbb-dark-truths/dash.mpd` (DASH, multi-period, no DRM) via Claude Preview-driven `python3 -m http.server` of the demo dir.
+
+**Query mode** (`useHeaders: false`, V2): 15 segment + manifest requests captured. Decoded sample:
+```
+?CMCD=cid="smoke-test",ot=m,sf=d,sid="…",sn=1,su,v=2
+?CMCD=bl=9900,br=3082,cid="smoke-test",d=4000,dl=9900,mtp=19900,ot=v,rtp=6200,sf=d,sid="…",sn=14,st=v,tb=3082,v=2
+```
+- `v=2` present in every request ✓
+- `ts=` absent in every request ✓ (V2 request-mode filter)
+- `sf=d` for DASH ✓ (no `'ld'`)
+- `ot=m`, `ot=v`, `ot=a`, `ot=i`, `sf=d`, `st=v` all rendered as bare tokens ✓
+- `cid="smoke-test"`, `sid="…"` rendered as quoted strings ✓ (string-typed fields)
+- `su` rendered as bare token (boolean true) ✓
+
+**Header mode** (`useHeaders: true`, V2): 15 segment + manifest requests captured via `registerRequestFilter` (CMCD-* stripped before fetch to avoid CORS preflight on the cross-origin asset). Decoded sample:
+```
+CMCD-Object:  ot=m
+CMCD-Request: mtp=26100,sn=1,su
+CMCD-Session: cid="smoke-test-headers",sf=d,sid="…",v=2
+```
+- `v=2` only in `CMCD-Session` shard ✓ — never in Object / Request / Status (sub-phase E C2 fix verified end-to-end)
+- `ts=` absent from Request shard ✓
+- All four shards correctly populated when keys exist; empty shards correctly absent (e.g. `CMCD-Status` only emitted when `bs`/`bg` etc. are set)
+
+**Console**: zero errors during full demo session.
+
+**Sub-phase F caveat**: cross-origin storage.googleapis.com blocks CMCD-* request headers via CORS preflight. This is browser-spec behavior, not a shaka bug — typical CMCD deployments target the user's own CDN where preflight is configured to allow `Access-Control-Allow-Headers: CMCD-*`. The smoke test stripped CMCD-* in the request filter so the underlying segment fetch could complete; the encoder produced correct headers either way (verified at the filter checkpoint).
+
 ### Key architectural decisions in the port — surface in Phase 1 PR description
 
 These were judgment calls during sub-phases B+C; maintainers should weigh in before merge:
@@ -73,11 +103,11 @@ Two git stashes exist:
 - `stash@{0}: On feat/cmcd-cml-refactor: accidental-stash-pop-recovery` — created during a sub-phase B subagent's `git stash pop` mishap. Contains contaminated working state from that incident.
 - `stash@{1}: On task/revert-cmcd-v1: CMCD STUFF` — pre-existing user stash. Preserved.
 
-### Resuming work in a new session — sub-phase F prep
+### Resuming work in a new session — Phase 2 prep
 
-- **Verify CML pinned clone** is still at `/tmp/cml-pinned/` (same as sub-phase D/E prep — should be `22390e35dfbbe1e53d15648d3aace99cdf71f9dd`).
-- **Sub-phase F scope (Tasks 1.13-1.14):** smoke-test the demo with CMCD enabled in both transmission modes, then open the Phase 1 PR. The smoke test verifies the wire-format changes against a real player flow (the test suite verifies them in isolation).
-- **Phase 1 PR description scaffolding** is in this plan — see "Sub-phase D landing notes", "Sub-phase E landing notes", and "Key architectural decisions in the port". Three intentional wire-format changes summarized: (1) `nor` URLs root-relative; (2) `'ld'`/`'lh'` `StreamingFormat` dropped; (3) V2 SFV encoding (token vs string for `e`/`sta`, `v=2` always present, `nor` inner-list).
+- **Verify CML pinned clone** is still at `/tmp/cml-pinned/` (same as sub-phase D/E/F prep — should be `22390e35dfbbe1e53d15648d3aace99cdf71f9dd`).
+- **Phase 2 scope (Tasks 2.1-2.6):** map shaka's `ObjectType`, `Version`, `StreamType`, `StreamingFormat`, `CmcdMode`, `Player.State` enums to CML equivalents; replace internal references; re-export `StreamingFormat` as a shaka alias of `cml.cmcd.CmcdStreamingFormat` for back-compat; delete the duplicate definitions. **Phase 2 is pure dedupe** — no behavioral change beyond what Phase 1 already shipped. Test suite should stay at 0 fail throughout.
+- **Phase 1 PR description scaffolding** lives at `plans/cmcd-cml-refactor/phase-1-pr-draft.md` (uncommitted scratch file). Phase 2 + 3 will accrete to the same file or be merged into one before the eventual all-phases PR.
 
 ---
 
@@ -88,7 +118,7 @@ Two git stashes exist:
 - **Phase 2** — Replace shaka's duplicate constants/enums with CML's; pure dedupe.
 - **Phase 3** — Rewrite `cmcd_manager.js` as adapter around `CmcdReporter`; delete state machine; rewrite tests; update demo and externs.
 
-Each phase ships as one PR. Phases 1 and 2 are behavior-preserving (modulo the documented `nor` change); Phase 3 is the behavioral rewrite and carries the migration risk.
+**PR strategy (revised 2026-04-28):** all three phases ship together as a single PR off `feat/cmcd-cml-refactor` once the whole refactor is complete. The original plan called for one PR per phase; the user revised this to reduce review-cycle overhead. Phase 1 / 2 / 3 sub-phase boundaries still gate work internally (build/check.py + test.py must pass at each sub-phase end), but `git push` + PR creation only happens after Phase 3 lands. Per-phase Task X.14 "open PR" steps below are no longer applicable — treat them as scaffolding for the eventual single PR's description (already drafted at `plans/cmcd-cml-refactor/phase-1-pr-draft.md`; Phase 2 / 3 draft sections will accrete to the same file or be merged into one).
 
 ## Spec gaps surfaced during planning
 

From 67443aacb2b77cdfe329d44fc75454c5a24b9144 Mon Sep 17 00:00:00 2001
From: Casey Occhialini <1508707+littlespex@users.noreply.github.com>
Date: Tue, 28 Apr 2026 15:45:21 -0700
Subject: [PATCH 30/64] refactor(cmcd): adopt CML constants/enums; delete shaka
 duplicates
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Phase 2 of the CMCD CML refactor: replace shaka.util.CmcdManager's
internal enums and key arrays with cml.cmcd.* equivalents. Pure dedupe;
no behavioral change.

Migrated (1:1 value match):
  shaka.util.CmcdManager.ObjectType        → cml.cmcd.CmcdObjectType
  shaka.util.CmcdManager.StreamType        → cml.cmcd.CmcdStreamType
  shaka.util.CmcdManager.Version.VERSION_2 → cml.cmcd.CMCD_V2 (= 2)
  shaka.util.CmcdManager.CmcdMode          → cml.cmcd.CmcdReportingMode
  shaka.util.CmcdManager.CmcdKeys.V1Keys   → cml.cmcd.CMCD_V1_KEYS

Migrated (set differs but consolidation is permissive):
  shaka.util.CmcdManager.CmcdKeys.V2RequestModeKeys ∪ V2CommonKeys
                                           → cml.cmcd.CMCD_REQUEST_KEYS
  shaka.util.CmcdManager.CmcdKeys.V2EventModeKeys ∪ V2CommonKeys
                                           → CMCD_REQUEST_KEYS
                                             ∪ CMCD_RESPONSE_KEYS
                                             ∪ CMCD_EVENT_KEYS
                                             (mirrors CML's
                                              `isCmcdEventKey`)
  shaka.util.CmcdManager.CmcdKeys.CmcdV2Events
                                           → Object.values(
                                               cml.cmcd.CmcdEventType)
                                             (CML's 17 events
                                             — superset of shaka's 10)
  shaka.util.CmcdManager.CmcdKeys.CmcdV2PlayStates
                                           → Object.values(
                                               cml.cmcd.CmcdPlayerState)
                                             (10 values, exact match)

Inlined / dropped:
  shaka.util.CmcdManager.CmcdV2Constants.TIME_INTERVAL_DEFAULT_VALUE
    inlined as `10`. CML's CMCD_DEFAULT_TIME_INTERVAL is `30`; Phase 3
    will switch to CmcdReporter, which uses the CML default natively.
  shaka.util.CmcdManager.CmcdV2Keys.TIMESTAMP — inlined as the literal
    'ts' (CML doesn't expose a dedicated constant for the timestamp
    key name).
  shaka.util.CmcdManager.CmcdV2Keys.TIME_INTERVAL_EVENT
                                           → cml.cmcd.CMCD_EVENT_TIME_INTERVAL

StreamingFormat: literal `@enum` definition retained — Closure's
clutz TypeScript-defs generator and shaka's generateExterns.js both
reject `@export`ed enums whose RHS is a non-`ObjectExpression`. The
4 values match cml.cmcd.CmcdStreamingFormat exactly (DASH/HLS/SMOOTH/
OTHER → 'd'/'h'/'s'/'o'); a new unit test asserts the value-identity
so Phase 3 can rely on it.

Internal type annotations referencing the now-deleted shaka enums
(`@private {(shaka.util.CmcdManager.StreamingFormat|undefined)}`,
return type of `getStreamFormat_`) updated to refer to
`cml.cmcd.CmcdStreamingFormat` directly. The public-facing
`shaka.util.CmcdManager.StreamingFormat` symbol stays.

`getStreamFormat_` now returns `cml.cmcd.CmcdStreamingFormat.DASH/HLS`
directly. Public callers see the same string values; this also keeps
the `cml.cmcd.CmcdStreamingFormat` `goog.require` in active use.

Net −74 LoC in cmcd_manager.js; +12 LoC for the value-identity test.
build/check.py exits 0; build/test.py --filter Cmcd: 125/125 pass
(the new value-identity test included); full --quick suite: 2996/2996
pass; demo smoke test (DASH bbb-dark-truths) confirms wire format
unchanged across 19 segment requests.

Per Tasks 2.1-2.5 of plans/cmcd-cml-refactor/plan.md. Task 2.6 (open
Phase 2 PR) deferred per single-branch / single-PR strategy.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 lib/util/cmcd_manager.js       | 248 +++++++++++----------------------
 test/util/cmcd_manager_unit.js |  12 ++
 2 files changed, 93 insertions(+), 167 deletions(-)

diff --git a/lib/util/cmcd_manager.js b/lib/util/cmcd_manager.js
index 0e4cac37a5..de78c38683 100644
--- a/lib/util/cmcd_manager.js
+++ b/lib/util/cmcd_manager.js
@@ -6,8 +6,20 @@
 
 goog.provide('shaka.util.CmcdManager');
 
+goog.require('cml.cmcd.CMCD_EVENT_KEYS');
 goog.require('cml.cmcd.CMCD_EVENT_MODE');
+goog.require('cml.cmcd.CMCD_EVENT_TIME_INTERVAL');
+goog.require('cml.cmcd.CMCD_REQUEST_KEYS');
 goog.require('cml.cmcd.CMCD_REQUEST_MODE');
+goog.require('cml.cmcd.CMCD_RESPONSE_KEYS');
+goog.require('cml.cmcd.CMCD_V1_KEYS');
+goog.require('cml.cmcd.CMCD_V2');
+goog.require('cml.cmcd.CmcdEventType');
+goog.require('cml.cmcd.CmcdObjectType');
+goog.require('cml.cmcd.CmcdPlayerState');
+goog.require('cml.cmcd.CmcdReportingMode');
+goog.require('cml.cmcd.CmcdStreamType');
+goog.require('cml.cmcd.CmcdStreamingFormat');
 goog.require('cml.cmcd.encodeCmcd');
 goog.require('cml.cmcd.encodePreparedCmcd');
 goog.require('cml.cmcd.prepareCmcdData');
@@ -47,7 +59,7 @@ shaka.util.CmcdManager = class {
     /**
      * Streaming format
      *
-     * @private {(shaka.util.CmcdManager.StreamingFormat|undefined)}
+     * @private {(cml.cmcd.CmcdStreamingFormat|undefined)}
      */
     this.sf_ = undefined;
 
@@ -234,7 +246,7 @@ shaka.util.CmcdManager = class {
     }
 
     const RequestType = shaka.net.NetworkingEngine.RequestType;
-    const ObjectType = shaka.util.CmcdManager.ObjectType;
+    const ObjectType = cml.cmcd.CmcdObjectType;
 
     switch (type) {
       case RequestType.MANIFEST:
@@ -300,7 +312,7 @@ shaka.util.CmcdManager = class {
       }
 
       this.applyRequest_(request, {
-        ot: shaka.util.CmcdManager.ObjectType.MANIFEST,
+        ot: cml.cmcd.CmcdObjectType.MANIFEST,
         su: !this.playbackStarted_,
       });
     } catch (error) {
@@ -402,7 +414,7 @@ shaka.util.CmcdManager = class {
       }
 
       this.applyRequest_(request, {
-        ot: shaka.util.CmcdManager.ObjectType.CAPTION,
+        ot: cml.cmcd.CmcdObjectType.CAPTION,
         su: true,
       });
     } catch (error) {
@@ -477,7 +489,7 @@ shaka.util.CmcdManager = class {
       }
 
       const data = this.createData_();
-      data.ot = shaka.util.CmcdManager.ObjectType.CAPTION;
+      data.ot = cml.cmcd.CmcdObjectType.CAPTION;
       data.su = true;
 
       const query = shaka.util.CmcdManager.toQuery(
@@ -619,14 +631,16 @@ shaka.util.CmcdManager = class {
       // Checking for `timeInterval === undefined` since
       // timeInterval = 0 is used to turn TimeInterval off
       if (timeInterval === undefined) {
-        timeInterval =
-          shaka.util.CmcdManager.CmcdV2Constants.TIME_INTERVAL_DEFAULT_VALUE;
+        // Phase 2 keeps shaka's historical default of 10 seconds.
+        // CML's `CMCD_DEFAULT_TIME_INTERVAL` is `30`; Phase 3 swaps to
+        // CmcdReporter, which uses the CML default natively.
+        timeInterval = 10;
       }
 
       if (timeInterval >= 1) {
         const eventModeTimer = new shaka.util.Timer(
             () => this.reportEvent_(
-                shaka.util.CmcdManager.CmcdV2Keys.TIME_INTERVAL_EVENT));
+                cml.cmcd.CMCD_EVENT_TIME_INTERVAL));
         eventModeTimer.tickEvery(timeInterval);
         this.eventTimers_.push(eventModeTimer);
       }
@@ -705,19 +719,24 @@ shaka.util.CmcdManager = class {
 
     const eventData = Object.assign(baseEventData, extraData);
     const rawOutput = this.getGenericData_(eventData,
-        shaka.util.CmcdManager.CmcdMode.EVENT);
+        cml.cmcd.CmcdReportingMode.EVENT);
 
     const version = this.config_.version;
     const targets = this.config_.targets;
-    if (version < shaka.util.CmcdManager.Version.VERSION_2 || !targets) {
+    if (version < cml.cmcd.CMCD_V2 || !targets) {
       return;
     }
 
     const eventTargets = this.getEventModeEnabledTargets_();
 
+    // CML's event-mode encoder accepts the union of request, response,
+    // and event keys (see `cml.cmcd.isCmcdEventKey`). Mirror that here
+    // for `includeKeys` validation so users can specify keys from any
+    // of the three buckets.
     const allowedKeys = Array.from(new Set([
-      ...shaka.util.CmcdManager.CmcdKeys.V2CommonKeys,
-      ...shaka.util.CmcdManager.CmcdKeys.V2EventModeKeys,
+      ...cml.cmcd.CMCD_REQUEST_KEYS,
+      ...cml.cmcd.CMCD_RESPONSE_KEYS,
+      ...cml.cmcd.CMCD_EVENT_KEYS,
     ]));
 
     for (const target of eventTargets) {
@@ -725,12 +744,15 @@ shaka.util.CmcdManager = class {
       const allowedKeysEventMode = this.checkValidKeys_(
           includeKeys,
           allowedKeys,
-          shaka.util.CmcdManager.CmcdMode.EVENT,
+          cml.cmcd.CmcdReportingMode.EVENT,
       );
 
-      if (!allowedKeysEventMode.includes(
-          shaka.util.CmcdManager.CmcdV2Keys.TIMESTAMP)) {
-        allowedKeysEventMode.push(shaka.util.CmcdManager.CmcdV2Keys.TIMESTAMP);
+      // `ts` and `e` are required for every event report; CML's
+      // `prepareCmcdData` adds them automatically, but shaka pre-
+      // filters via `filterKeys_` before encoding, so they must
+      // survive the filter.
+      if (!allowedKeysEventMode.includes('ts')) {
+        allowedKeysEventMode.push('ts');
       }
 
       if (!allowedKeysEventMode.includes('e')) {
@@ -769,11 +791,11 @@ shaka.util.CmcdManager = class {
     }
 
     const rawOutput = this.getGenericData_(
-        data, shaka.util.CmcdManager.CmcdMode.REQUEST,
+        data, cml.cmcd.CmcdReportingMode.REQUEST,
     );
 
     const requestTargetConfig = {
-      mode: shaka.util.CmcdManager.CmcdMode.REQUEST,
+      mode: cml.cmcd.CmcdReportingMode.REQUEST,
       useHeaders: this.config_.useHeaders,
       includeKeys: this.config_.includeKeys || [],
     };
@@ -788,17 +810,14 @@ shaka.util.CmcdManager = class {
 
     const includeKeys = this.config_.includeKeys || [];
     const version = this.config_.version;
-    const allowedKeys = (version == shaka.util.CmcdManager.Version.VERSION_2) ?
-        Array.from(new Set([
-          ...shaka.util.CmcdManager.CmcdKeys.V2CommonKeys,
-          ...shaka.util.CmcdManager.CmcdKeys.V2RequestModeKeys,
-        ])) :
-        shaka.util.CmcdManager.CmcdKeys.V1Keys;
+    const allowedKeys = (version == cml.cmcd.CMCD_V2) ?
+        Array.from(cml.cmcd.CMCD_REQUEST_KEYS) :
+        cml.cmcd.CMCD_V1_KEYS;
 
     const allowedKeysRequestMode = this.checkValidKeys_(
         includeKeys,
         allowedKeys,
-        shaka.util.CmcdManager.CmcdMode.REQUEST,
+        cml.cmcd.CmcdReportingMode.REQUEST,
     );
 
     const output = this.filterKeys_(rawOutput, allowedKeysRequestMode);
@@ -963,8 +982,8 @@ shaka.util.CmcdManager = class {
    * @return {boolean}
    */
   isValidEvent_(includeEvents, data) {
-    const allowedEvents = shaka.util.CmcdManager.CmcdKeys.CmcdV2Events;
-    const allowedPlayStates = shaka.util.CmcdManager.CmcdKeys.CmcdV2PlayStates;
+    const allowedEvents = Object.values(cml.cmcd.CmcdEventType);
+    const allowedPlayStates = Object.values(cml.cmcd.CmcdPlayerState);
 
     const event = data['e'];
     const playState = data['sta'];
@@ -994,13 +1013,13 @@ shaka.util.CmcdManager = class {
    *
    * @param {shaka.extern.RequestContext} context
    *   The request context
-   * @return {shaka.util.CmcdManager.ObjectType|undefined}
+   * @return {cml.cmcd.CmcdObjectType|undefined}
    * @private
    */
   getObjectType_(context) {
     if (context.type ===
         shaka.net.NetworkingEngine.AdvancedRequestType.INIT_SEGMENT) {
-      return shaka.util.CmcdManager.ObjectType.INIT;
+      return cml.cmcd.CmcdObjectType.INIT;
     }
 
     const stream = context.stream;
@@ -1013,20 +1032,20 @@ shaka.util.CmcdManager = class {
 
     if (type == 'video') {
       if (stream.codecs && stream.codecs.includes(',')) {
-        return shaka.util.CmcdManager.ObjectType.MUXED;
+        return cml.cmcd.CmcdObjectType.MUXED;
       }
-      return shaka.util.CmcdManager.ObjectType.VIDEO;
+      return cml.cmcd.CmcdObjectType.VIDEO;
     }
 
     if (type == 'audio') {
-      return shaka.util.CmcdManager.ObjectType.AUDIO;
+      return cml.cmcd.CmcdObjectType.AUDIO;
     }
 
     if (type == 'text') {
       if (stream.mimeType === 'application/mp4') {
-        return shaka.util.CmcdManager.ObjectType.TIMED_TEXT;
+        return cml.cmcd.CmcdObjectType.TIMED_TEXT;
       }
-      return shaka.util.CmcdManager.ObjectType.CAPTION;
+      return cml.cmcd.CmcdObjectType.CAPTION;
     }
 
     return undefined;
@@ -1036,7 +1055,7 @@ shaka.util.CmcdManager = class {
    * The CMCD object type from mimeType.
    *
    * @param {!string} mimeType
-   * @return {(shaka.util.CmcdManager.ObjectType|undefined)}
+   * @return {(cml.cmcd.CmcdObjectType|undefined)}
    * @private
    */
   getObjectTypeFromMimeType_(mimeType) {
@@ -1048,20 +1067,20 @@ shaka.util.CmcdManager = class {
       case 'audio/aac':
       case 'audio/flac':
       case 'audio/wav':
-        return shaka.util.CmcdManager.ObjectType.AUDIO;
+        return cml.cmcd.CmcdObjectType.AUDIO;
 
       case 'video/webm':
       case 'video/mp4':
       case 'video/mpeg':
       case 'video/mp2t':
-        return shaka.util.CmcdManager.ObjectType.MUXED;
+        return cml.cmcd.CmcdObjectType.MUXED;
 
       case 'application/x-mpegurl':
       case 'application/vnd.apple.mpegurl':
       case 'application/dash+xml':
       case 'video/vnd.mpeg.dash.mpd':
       case 'application/vnd.ms-sstr+xml':
-        return shaka.util.CmcdManager.ObjectType.MANIFEST;
+        return cml.cmcd.CmcdObjectType.MANIFEST;
 
       default:
         return undefined;
@@ -1185,7 +1204,7 @@ shaka.util.CmcdManager = class {
    *
    * @param {shaka.net.NetworkingEngine.AdvancedRequestType} type
    *   The request's advanced type
-   * @return {(shaka.util.CmcdManager.StreamingFormat|undefined)}
+   * @return {(cml.cmcd.CmcdStreamingFormat|undefined)}
    * @private
    */
   getStreamFormat_(type) {
@@ -1193,11 +1212,11 @@ shaka.util.CmcdManager = class {
 
     switch (type) {
       case AdvancedRequestType.MPD:
-        return shaka.util.CmcdManager.StreamingFormat.DASH;
+        return cml.cmcd.CmcdStreamingFormat.DASH;
 
       case AdvancedRequestType.MASTER_PLAYLIST:
       case AdvancedRequestType.MEDIA_PLAYLIST:
-        return shaka.util.CmcdManager.StreamingFormat.HLS;
+        return cml.cmcd.CmcdStreamingFormat.HLS;
     }
 
     return undefined;
@@ -1206,22 +1225,22 @@ shaka.util.CmcdManager = class {
   /**
    * Get the stream type
    *
-   * @return {shaka.util.CmcdManager.StreamType}
+   * @return {cml.cmcd.CmcdStreamType}
    * @private
    */
   getStreamType_() {
     const isLive = this.player_.isLive();
     if (isLive) {
-      return shaka.util.CmcdManager.StreamType.LIVE;
+      return cml.cmcd.CmcdStreamType.LIVE;
     } else {
-      return shaka.util.CmcdManager.StreamType.VOD;
+      return cml.cmcd.CmcdStreamType.VOD;
     }
   }
 
   /**
    * Get the highest bandwidth for a given type.
    *
-   * @param {shaka.util.CmcdManager.ObjectType|undefined} type
+   * @param {cml.cmcd.CmcdObjectType|undefined} type
    * @return {number}
    * @private
    */
@@ -1239,7 +1258,7 @@ shaka.util.CmcdManager = class {
       }
     }
 
-    const ObjectType = shaka.util.CmcdManager.ObjectType;
+    const ObjectType = cml.cmcd.CmcdObjectType;
 
     switch (type) {
       case ObjectType.VIDEO:
@@ -1277,7 +1296,7 @@ shaka.util.CmcdManager = class {
 
     data.ot = this.getObjectType_(context);
 
-    const ObjectType = shaka.util.CmcdManager.ObjectType;
+    const ObjectType = cml.cmcd.CmcdObjectType;
     const isMedia = data.ot === ObjectType.VIDEO ||
         data.ot === ObjectType.AUDIO ||
         data.ot === ObjectType.MUXED ||
@@ -1353,7 +1372,7 @@ shaka.util.CmcdManager = class {
    * Get generic CMCD data.
    *
    * @param {!CmcdData} data The data object
-   * @param {!shaka.util.CmcdManager.CmcdMode} mode
+   * @param {!cml.cmcd.CmcdReportingMode} mode
    * @return {!CmcdData}
    * @private
    */
@@ -1363,8 +1382,8 @@ shaka.util.CmcdManager = class {
 
     data.pr = this.player_.getPlaybackRate();
 
-    const isVideo = data.ot === shaka.util.CmcdManager.ObjectType.VIDEO ||
-        data.ot === shaka.util.CmcdManager.ObjectType.MUXED;
+    const isVideo = data.ot === cml.cmcd.CmcdObjectType.VIDEO ||
+        data.ot === cml.cmcd.CmcdObjectType.MUXED;
 
     if (this.starved_ && isVideo) {
       data.bs = true;
@@ -1538,38 +1557,18 @@ shaka.util.CmcdManager = class {
 };
 
 /**
- * @enum {string}
- */
-shaka.util.CmcdManager.ObjectType = {
-  MANIFEST: 'm',
-  AUDIO: 'a',
-  VIDEO: 'v',
-  MUXED: 'av',
-  INIT: 'i',
-  CAPTION: 'c',
-  TIMED_TEXT: 'tt',
-  KEY: 'k',
-  OTHER: 'o',
-};
-
-/**
- * @enum {number}
- */
-shaka.util.CmcdManager.Version = {
-  VERSION_1: 1,
-  VERSION_2: 2,
-};
-
-/**
- * @enum {string}
- */
-shaka.util.CmcdManager.StreamType = {
-  VOD: 'v',
-  LIVE: 'l',
-};
-
-
-/**
+ * Phase 1 dropped the non-spec `'ld'` / `'lh'` values, so shaka's enum
+ * is now value-identical to `cml.cmcd.CmcdStreamingFormat` (4 spec-
+ * conformant values: `'d'`/`'h'`/`'s'`/`'o'`). The literal definition
+ * is retained — Closure's `clutz` TypeScript-defs generator and shaka's
+ * `generateExterns.js` both expect `@export`ed `@enum`s to have an
+ * inline `ObjectExpression` with literal values, not an alias. The
+ * value identity is asserted in unit tests.
+ *
+ * Other shaka enums (`ObjectType`, `Version`, `StreamType`, `CmcdMode`,
+ * `CmcdKeys`, `CmcdV2Constants`, `CmcdV2Keys`) were never `@export`ed
+ * and have been deleted in favor of `cml.cmcd.*` equivalents.
+ *
  * @enum {string}
  * @export
  */
@@ -1579,88 +1578,3 @@ shaka.util.CmcdManager.StreamingFormat = {
   SMOOTH: 's',
   OTHER: 'o',
 };
-
-
-/**
- * @enum {Array<string>}
- */
-shaka.util.CmcdManager.CmcdKeys = {
-  V1Keys: [
-    'br', 'bl', 'bs', 'cid', 'd',
-    'dl', 'mtp', 'nor', 'nrr',
-    'ot', 'pr', 'rtp', 'sf', 'sid', 'st',
-    'su', 'tb', 'v',
-  ],
-  V2CommonKeys: [
-    'br', 'ab', 'bl', 'tbl', 'bs',
-    'cdn', 'cid', 'ltc', 'mtp',
-    'pr', 'sf', 'sid', 'bg', 'sta',
-    'st', 'ts', 'tpb', 'tb', 'lb',
-    'tab', 'lab', 'pt', 'ec', 'msd',
-    'v', 'sn',
-  ],
-  V2RequestModeKeys: [
-    'ab', 'bl', 'tbl', 'bs', 'cdn',
-    'cid', 'd', 'dl', 'ltc', 'mtp',
-    'nor', 'ot', 'pr', 'rtp', 'sf',
-    'sid', 'bg', 'sta', 'st', 'su',
-    'ts', 'tpb', 'tb', 'lb', 'tab',
-    'lab', 'pt', 'ec', 'msd', 'v',
-  ],
-  V2EventModeKeys: [
-    'e', 'sta', 'd', 'dl', 'nor', 'ot',
-    'rtp', 'rc', 'su', 'ttfb', 'ttfbb',
-    'ttlb', 'url', 'cmsdd', 'cmsds',
-  ],
-  CmcdV2Events: [
-    'ps',   // Play State: Change in Play State
-    'e',    // Error: An error event
-    't',    // Time Interval: A periodic report sent on a time interval.
-    'c',    // Content Id: Change of the Content Id
-    'b',    // Backgrounded mode: Change in the application's backgrounded state
-    'm',    // Mute: Player muted
-    'um',   // Unmute: Player unmuted
-    'pe',   // Player Expand: Player view was expanded
-    'pc',   // Player Collapse: Player view was collapsed
-    'rr',   // Response Received
-  ],
-  CmcdV2PlayStates: [
-    's', // Start
-    'p', // Playing
-    'a', // Paused
-    'w', // Waiting
-    'k', // Seeking
-    'r', // Rebuffering
-    'f', // Fatal Error
-    'e', // Ended
-    'q', // Quit
-    'd', // Preloading
-  ],
-};
-
-
-/**
- * @enum {number}
- */
-shaka.util.CmcdManager.CmcdV2Constants = {
-  TIME_INTERVAL_DEFAULT_VALUE: 10,
-};
-
-
-/**
- * @enum {string}
- */
-shaka.util.CmcdManager.CmcdV2Keys = {
-  TIMESTAMP: 'ts',
-  TIME_INTERVAL_EVENT: 't',
-};
-
-
-/**
- * @enum {string}
- */
-shaka.util.CmcdManager.CmcdMode = {
-  REQUEST: 'request',
-  RESPONSE: 'response',
-  EVENT: 'event',
-};
diff --git a/test/util/cmcd_manager_unit.js b/test/util/cmcd_manager_unit.js
index 7ae9baf174..81d93900d8 100644
--- a/test/util/cmcd_manager_unit.js
+++ b/test/util/cmcd_manager_unit.js
@@ -216,6 +216,18 @@ describe('CmcdManager Setup', () => {
     const NetworkingEngine = shaka.net.NetworkingEngine;
     const RequestType = NetworkingEngine.RequestType;
 
+    describe('StreamingFormat alias', () => {
+      it('preserves value-identity with cml.cmcd.CmcdStreamingFormat', () => {
+        // Phase 2 retains a literal `@enum` definition rather than a
+        // direct alias (Closure tooling — clutz + generateExterns —
+        // both expect inline `ObjectExpression` for `@export`ed
+        // enums). The values must stay in lockstep with CML.
+        expect(CmcdManager.StreamingFormat).toEqual(
+            /** @type {!Object<string, string>} */ (
+              cml.cmcd.CmcdStreamingFormat));
+      });
+    });
+
     describe('Query serialization', () => {
       it('produces correctly serialized data', () => {
         const query = CmcdManager.toQuery(data);

From f0b99a8e0e76b88dfcd4780ec565d249f69fdd37 Mon Sep 17 00:00:00 2001
From: Casey Occhialini <1508707+littlespex@users.noreply.github.com>
Date: Tue, 28 Apr 2026 15:51:46 -0700
Subject: [PATCH 31/64] docs(cmcd): mark Phase 2 complete in plan; rename PR
 draft to cumulative
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Phase 2 (Tasks 2.1-2.5) ✅ complete. Plan changes:

- Mark Phase 2 ✅ in the status table; resume point is now Phase 3.
- Add a "Phase 2 landing notes" subsection parallel to sub-phase D/E/F
  notes, capturing the 7 deleted shaka enums, the StreamingFormat
  literal-retention rationale (Closure clutz + generateExterns reject
  alias forms), and the four permissive behavior changes from CML
  key-set adoption.
- Replace the "Phase 2 prep" subsection with "Phase 3 prep". Phase 3
  is the high-risk PR — adapter rewrite with state-machine deletion,
  experimental v2 config renames, ~3500 lines of CMCD wire-format
  test deletion + replacement.

Renamed `phase-1-pr-draft.md` → `pr-draft.md` (single cumulative file
across all phases) per the user's revised single-PR strategy. Updated
title from "delegate encoding to CML (1/3)" to
"replace custom encoder + state machine" (whole-refactor scope), added
a Phase 2 implementation summary section, updated diff-size and
verification sections with cumulative numbers.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 plans/cmcd-cml-refactor/plan.md               | 37 ++++++++--
 .../{phase-1-pr-draft.md => pr-draft.md}      | 73 +++++++++++++++----
 2 files changed, 88 insertions(+), 22 deletions(-)
 rename plans/cmcd-cml-refactor/{phase-1-pr-draft.md => pr-draft.md} (66%)

diff --git a/plans/cmcd-cml-refactor/plan.md b/plans/cmcd-cml-refactor/plan.md
index 18d6f30f5f..6470e809fe 100644
--- a/plans/cmcd-cml-refactor/plan.md
+++ b/plans/cmcd-cml-refactor/plan.md
@@ -25,8 +25,8 @@ This refactor is actively in progress on branch `feat/cmcd-cml-refactor`. Read t
 | **Phase 1D** — Encoding delegation in `cmcd_manager.js` + drop non-spec `'ld'`/`'lh'` (Tasks 1.10, 1.10b) | ✅ Complete | 2 commits, ending at `adfdfab05`. Net −168 LoC across `lib/util/cmcd_manager.js` and `test/util/cmcd_manager_unit.js`. `python3 build/check.py` exits 0. `build/test.py` deferred to sub-phase E (Tasks 1.11-1.12 catalog and update wire-format-divergence assertions). |
 | **Phase 1E** — Diff testing + assertion updates (Tasks 1.11-1.12) | ✅ Complete | 2 commits ending at `b94f7ebca`. Started at 52 of 124 CMCD tests failing post-1.10; ended at 0 fail / 124 pass. Three (c)-class adapter bugs fixed in `27cd16907`; ~80 (a)/(b)-class assertion updates in `b94f7ebca`. Full `--quick` suite: 2995/2995 pass. |
 | **Phase 1F** — Demo verification (Task 1.13) | ✅ Complete | Smoke-test on `bbb-dark-truths/dash.mpd` via Claude Preview-driven `python3 -m http.server`. Query mode (15 segment requests captured): `?CMCD=…cid="smoke-test",ot=m,sf=d,sid="…",sn=N,su,v=2` — `v=2` always present, `ts` absent in request mode, `sf=d` (no `'ld'`), `ot`/`sf`/`st` as tokens. Header mode (15 requests captured via request filter; CMCD-* stripped before fetch to avoid CORS preflight): `v=2` only in `CMCD-Session` shard (not in `CMCD-Object`/`Request`/`Status`); request shard contains `sn`/`mtp`/`su` only — no `ts`. Zero JS console errors. Per-phase PR (Task 1.14) deferred to single all-phases PR per user direction. |
-| **Phase 2** — Adopt CML constants, dedupe shaka duplicates | ⏳ Not started | After Phase 1 merges. |
-| **Phase 3** — Adapter rewrite (the big behavioral change) | ⏳ Not started | After Phase 2 merges. |
+| **Phase 2** — Adopt CML constants, dedupe shaka duplicates (Tasks 2.1-2.5) | ✅ Complete | 1 commit at `67443aacb`. Net −74 LoC in `lib/util/cmcd_manager.js` (+12 LoC value-identity test in `test/util/cmcd_manager_unit.js`). 7 internal shaka enums deleted; `StreamingFormat` retained as `@export`ed literal (Closure tooling rejects alias form). `build/check.py` 0; CMCD tests 125/125; `--quick` suite 2996/2996; smoke test confirmed wire format unchanged. Task 2.6 (open Phase 2 PR) dropped per single-PR strategy. |
+| **Phase 3** — Adapter rewrite (the big behavioral change) | ⏳ **Resume here.** | After Phase 2's dedupe lands, Phase 3 rewrites `cmcd_manager.js` as a thin adapter around `cml.cmcd.CmcdReporter`. |
 
 **Vendored port summary:** [`third_party/cml-cmcd/`](../../third_party/cml-cmcd/) holds 68 JS files (typedefs + enums + constants + encoders + helpers + shims + `CmcdReporter`) + `LICENSE` + `NOTICE` + `SUMMARY.txt`. At HEAD (`adfdfab05`), `python3 build/check.py` exits 0. `python3 build/build.py` was last clean at `d682bb1bb` and is not expected to break under sub-phase D's source-only changes; not re-run this session.
 
@@ -89,6 +89,30 @@ CMCD-Session: cid="smoke-test-headers",sf=d,sid="…",v=2
 
 **Sub-phase F caveat**: cross-origin storage.googleapis.com blocks CMCD-* request headers via CORS preflight. This is browser-spec behavior, not a shaka bug — typical CMCD deployments target the user's own CDN where preflight is configured to allow `Access-Control-Allow-Headers: CMCD-*`. The smoke test stripped CMCD-* in the request filter so the underlying segment fetch could complete; the encoder produced correct headers either way (verified at the filter checkpoint).
 
+### Phase 2 landing notes (Tasks 2.1-2.5)
+
+Pure dedupe — no behavioral change beyond what Phase 1 already shipped. Single commit at `67443aacb`. Net −74 LoC in `lib/util/cmcd_manager.js`; +12 LoC for the value-identity test. The full diff against pre-Phase-2 (`d663f6c12`) is what gets surfaced in the eventual all-phases PR description as "Phase 2".
+
+**7 internal shaka enums deleted** (none were `@export`ed, so deletion is internal-only):
+
+| Shaka (deleted) | Replacement | Notes |
+|---|---|---|
+| `ObjectType` | `cml.cmcd.CmcdObjectType` | 1:1 value match (9 entries) |
+| `Version` | `cml.cmcd.CMCD_V1` / `CMCD_V2` literals | Was a 2-entry enum wrapping `1` / `2` |
+| `StreamType` | `cml.cmcd.CmcdStreamType` | CML adds `LOW_LATENCY: 'll'`; harmless superset |
+| `CmcdMode` | `cml.cmcd.CmcdReportingMode` | Dropped unused `RESPONSE` value |
+| `CmcdKeys` | various | `V1Keys` → `CMCD_V1_KEYS`; `V2Common ∪ V2Request` → `CMCD_REQUEST_KEYS`; `V2Common ∪ V2Event` → `CMCD_REQUEST_KEYS ∪ CMCD_RESPONSE_KEYS ∪ CMCD_EVENT_KEYS`; `CmcdV2Events` → `Object.values(CmcdEventType)`; `CmcdV2PlayStates` → `Object.values(CmcdPlayerState)` |
+| `CmcdV2Constants` | inlined | `TIME_INTERVAL_DEFAULT_VALUE = 10` inlined as a magic number with a comment. CML uses `30`; Phase 3's `CmcdReporter` will adopt the CML default. |
+| `CmcdV2Keys` | inlined / aliased | `TIMESTAMP` inlined as `'ts'`; `TIME_INTERVAL_EVENT` → `cml.cmcd.CMCD_EVENT_TIME_INTERVAL` |
+
+**`StreamingFormat` retained as a literal `@enum`** (not aliased to CML). Closure's `clutz` TypeScript-defs generator and shaka's `generateExterns.js` both reject `@export`ed `@enum`s whose RHS is anything other than an inline `ObjectExpression` with literal values. Workaround patterns (alias, per-key copy with MemberExpression values, `@const` instead of `@enum`) all hit the same wall. The 4 values match `cml.cmcd.CmcdStreamingFormat` exactly; the new `StreamingFormat alias / preserves value-identity with cml.cmcd.CmcdStreamingFormat` test in `test/util/cmcd_manager_unit.js` asserts this so Phase 3 can rely on it.
+
+**Permissive behavior changes from CML key-set adoption:**
+- V2 request mode now accepts `br`, `bsa`, `bsd`, `bsda`, `cs`, `dfa`, `nr`, `pb`, `sn` in `includeKeys` (previously rejected by shaka's narrower `V2RequestModeKeys`). All are CMCD V2 spec keys; shaka's omission was non-spec.
+- V2 request mode now rejects `ts` in `includeKeys` (was accepted previously). `ts` is event-only per CTA-5004-B; the encoder filtered it out anyway since Phase 1 sub-phase E B2 — this aligns the upstream `includeKeys` validator with the encoder filter.
+- Event-mode validation accepts a strict superset of what shaka's old `V2EventModeKeys` allowed.
+- `isValidEvent_` accepts CML's 17 event types instead of shaka's 10 (adds the 7 ad / skip / custom-event types). shaka doesn't emit these, so user-facing impact is nil.
+
 ### Key architectural decisions in the port — surface in Phase 1 PR description
 
 These were judgment calls during sub-phases B+C; maintainers should weigh in before merge:
@@ -103,11 +127,12 @@ Two git stashes exist:
 - `stash@{0}: On feat/cmcd-cml-refactor: accidental-stash-pop-recovery` — created during a sub-phase B subagent's `git stash pop` mishap. Contains contaminated working state from that incident.
 - `stash@{1}: On task/revert-cmcd-v1: CMCD STUFF` — pre-existing user stash. Preserved.
 
-### Resuming work in a new session — Phase 2 prep
+### Resuming work in a new session — Phase 3 prep
 
-- **Verify CML pinned clone** is still at `/tmp/cml-pinned/` (same as sub-phase D/E/F prep — should be `22390e35dfbbe1e53d15648d3aace99cdf71f9dd`).
-- **Phase 2 scope (Tasks 2.1-2.6):** map shaka's `ObjectType`, `Version`, `StreamType`, `StreamingFormat`, `CmcdMode`, `Player.State` enums to CML equivalents; replace internal references; re-export `StreamingFormat` as a shaka alias of `cml.cmcd.CmcdStreamingFormat` for back-compat; delete the duplicate definitions. **Phase 2 is pure dedupe** — no behavioral change beyond what Phase 1 already shipped. Test suite should stay at 0 fail throughout.
-- **Phase 1 PR description scaffolding** lives at `plans/cmcd-cml-refactor/phase-1-pr-draft.md` (uncommitted scratch file). Phase 2 + 3 will accrete to the same file or be merged into one before the eventual all-phases PR.
+- **Verify CML pinned clone** is still at `/tmp/cml-pinned/` (same as Phase 1/2 prep — should be `22390e35dfbbe1e53d15648d3aace99cdf71f9dd`).
+- **Phase 3 scope (Tasks 3.1-3.16):** rewrite `lib/util/cmcd_manager.js` as a thin (~250-line) adapter around `cml.cmcd.CmcdReporter`. Delete the state machine, sequence-number bookkeeping, event timing, and most key-filtering logic — all of those move into `CmcdReporter`. Apply experimental v2 config renames (per spec). Delete the CMCD wire-format unit tests (~3500 lines of `cmcd_manager_unit.js`) and replace with adapter-glue + smoke tests.
+- **Phase 3 is the high-risk PR.** Watch for: state-transition timing differences (CML vs. shaka's existing transitions), per-target sequence-number behavior (Task 0.7), event-mode dispatch shape, `applyResponseData` mutation contract (Task 3.5).
+- **Phase 1 PR description scaffolding** lives at `plans/cmcd-cml-refactor/phase-1-pr-draft.md` (uncommitted scratch file). Phase 2 / 3 will accrete to the same file or be merged into one before the eventual all-phases PR.
 
 ---
 
diff --git a/plans/cmcd-cml-refactor/phase-1-pr-draft.md b/plans/cmcd-cml-refactor/pr-draft.md
similarity index 66%
rename from plans/cmcd-cml-refactor/phase-1-pr-draft.md
rename to plans/cmcd-cml-refactor/pr-draft.md
index ee1ae16b2d..50594e56cc 100644
--- a/plans/cmcd-cml-refactor/phase-1-pr-draft.md
+++ b/plans/cmcd-cml-refactor/pr-draft.md
@@ -1,22 +1,28 @@
 <!--
-Phase 1 PR draft. Temporary file (not committed). Move title to PR title
-and body to PR body when opening. Per Task 1.12 step 5 / Task 1.14 of
-plans/cmcd-cml-refactor/plan.md.
+Cumulative PR draft for the CMCD CML refactor. Phase 1 + Phase 2 are
+landed on feat/cmcd-cml-refactor; Phase 3 will append before the eventual
+single all-phases PR.
 -->
 
 # Title
 
 ```
-refactor(cmcd): vendor @svta/cml-cmcd, delegate encoding to CML (1/3)
+refactor(cmcd): vendor @svta/cml-cmcd, replace custom encoder + state machine
 ```
 
 # Body
 
 ## Summary
 
-Phase 1 of 3 in the CMCD CML refactor. Replaces shaka's custom CMCD wire-format encoding with a vendored Closure port of [`@svta/cml-cmcd`](https://github.com/streaming-video-technology-alliance/common-media-library) (CML) under `third_party/cml-cmcd/`. Phases 2 and 3 will adopt CML's constants/enums (Phase 2) and rewrite `cmcd_manager.js` as a thin adapter around `CmcdReporter` (Phase 3) — see [`plans/cmcd-cml-refactor/spec.md`](plans/cmcd-cml-refactor/spec.md) and [`plans/cmcd-cml-refactor/plan.md`](plans/cmcd-cml-refactor/plan.md).
+Replaces shaka's custom CMCD wire-format encoding and state machine with a vendored Closure port of [`@svta/cml-cmcd`](https://github.com/streaming-video-technology-alliance/common-media-library) (CML) under `third_party/cml-cmcd/`. Implementation in three sequential phases off `feat/cmcd-cml-refactor`:
 
-This PR is **behavior-preserving** for shaka's public API, modulo three documented intentional wire-format changes that align shaka with CTA-5004 / CTA-5004-B and CML's spec-conformant output.
+- **Phase 1** (Tasks 1.1-1.13) vendors the port and routes shaka's encoders through it. Three intentional wire-format changes (`nor` URL relativization, `'ld'`/`'lh'` dropped, V2 SFV-conformant encoding).
+- **Phase 2** (Tasks 2.1-2.5) dedupes shaka's internal enums and key arrays in favor of `cml.cmcd.*` equivalents. Pure dedupe; no behavior change.
+- **Phase 3** *(in progress)* rewrites `lib/util/cmcd_manager.js` as a thin adapter around `cml.cmcd.CmcdReporter`, deletes the state machine, ships experimental v2 config renames.
+
+See [`plans/cmcd-cml-refactor/spec.md`](plans/cmcd-cml-refactor/spec.md) and [`plans/cmcd-cml-refactor/plan.md`](plans/cmcd-cml-refactor/plan.md) for full design + rationale.
+
+Phases 1 + 2 are **behavior-preserving** for shaka's public API, modulo three documented intentional wire-format changes that align shaka with CTA-5004 / CTA-5004-B and CML's spec-conformant output.
 
 ## What's vendored
 
@@ -85,25 +91,49 @@ The state machine, sequence numbers (`cmcdSequenceNumbers_` per-target counters)
 
 A new private `getEncodeOptions_(uri, version, reportingMode)` static helper builds `cml.cmcd.CmcdEncodeOptions` objects at the four CMCD-encoding call sites: `appendSrcData`, `appendTextTrackData`, `sendCmcdRequest_` (event/response path), `applyCmcdDataToRequest_` (request path). It threads `this.config_.version` and the reporting mode (`CMCD_REQUEST_MODE` for request paths, `CMCD_EVENT_MODE` for `sendCmcdRequest_`).
 
-## Diff size
+## Phase 2 implementation summary
+
+Pure dedupe — no behavioral change beyond what Phase 1 shipped. Single commit `67443aacb`.
 
-- `third_party/cml-cmcd/`: 74 new JS files + LICENSE/NOTICE/SUMMARY (+5017 lines).
-- `lib/util/cmcd_manager.js`: +100 / −138 lines (net −38).
-- `test/util/cmcd_manager_unit.js`: +107 / −140 lines (net −33; mostly assertion updates and the deleted `urlToRelativePath` describe block).
+**7 internal shaka enums deleted** (none were `@export`ed, so deletion is internal-only):
+
+| Shaka (deleted) | Replacement | Notes |
+|---|---|---|
+| `ObjectType` | `cml.cmcd.CmcdObjectType` | 1:1 value match (9 entries) |
+| `Version` | `cml.cmcd.CMCD_V1` / `CMCD_V2` literals | Was a 2-entry enum wrapping `1` / `2` |
+| `StreamType` | `cml.cmcd.CmcdStreamType` | CML adds `LOW_LATENCY: 'll'`; harmless superset |
+| `CmcdMode` | `cml.cmcd.CmcdReportingMode` | Dropped unused `RESPONSE` value |
+| `CmcdKeys` | various CML key arrays | `V1Keys` → `CMCD_V1_KEYS`; `V2Common ∪ V2Request` → `CMCD_REQUEST_KEYS`; `V2Common ∪ V2Event` → `CMCD_REQUEST_KEYS ∪ CMCD_RESPONSE_KEYS ∪ CMCD_EVENT_KEYS`; `CmcdV2Events` → `Object.values(CmcdEventType)`; `CmcdV2PlayStates` → `Object.values(CmcdPlayerState)` |
+| `CmcdV2Constants` | inlined | `TIME_INTERVAL_DEFAULT_VALUE = 10` inlined as a magic number with a comment. CML uses `30`; Phase 3's `CmcdReporter` will adopt the CML default. |
+| `CmcdV2Keys` | inlined / aliased | `TIMESTAMP` inlined as the literal `'ts'`; `TIME_INTERVAL_EVENT` → `cml.cmcd.CMCD_EVENT_TIME_INTERVAL` |
+
+**`StreamingFormat` retained as a literal `@enum`** (not aliased to CML). Closure's `clutz` TypeScript-defs generator and shaka's `generateExterns.js` both reject `@export`ed `@enum`s whose RHS is anything other than an inline `ObjectExpression` with literal values. Workaround patterns (alias, per-key copy with `MemberExpression` values, `@const` instead of `@enum`) all hit the same wall. The 4 values match `cml.cmcd.CmcdStreamingFormat` exactly; a new `preserves value-identity with cml.cmcd.CmcdStreamingFormat` unit test asserts this so Phase 3 can rely on it. Internal type annotations (`sf_` private field, `getStreamFormat_` return type) refer to `cml.cmcd.CmcdStreamingFormat` directly; the `@export`ed `shaka.util.CmcdManager.StreamingFormat` is the public-facing form.
+
+**Permissive behavior changes from CML key-set adoption:**
+- V2 request mode now accepts `br`, `bsa`, `bsd`, `bsda`, `cs`, `dfa`, `nr`, `pb`, `sn` in `includeKeys` (previously rejected by shaka's narrower `V2RequestModeKeys`). All are CMCD V2 spec keys; shaka's omission was non-spec.
+- V2 request mode now rejects `ts` in `includeKeys` (was accepted previously). `ts` is event-only per CTA-5004-B; the encoder filtered it out anyway since Phase 1 sub-phase E B2 — this aligns the upstream `includeKeys` validator with the encoder filter.
+- Event-mode validation accepts a strict superset of what shaka's old `V2EventModeKeys` allowed.
+- `isValidEvent_` accepts CML's 17 event types instead of shaka's 10 (adds the 7 ad / skip / custom-event types). shaka doesn't emit these, so user-facing impact is nil.
+
+## Diff size (Phases 1 + 2; Phase 3 will append)
+
+- `third_party/cml-cmcd/`: 74 new JS files + LICENSE/NOTICE/SUMMARY (+5017 lines, Phase 1).
+- `lib/util/cmcd_manager.js`: +100 / −138 (Phase 1) and +13 / −87 (Phase 2). Cumulative net −112 / +113.
+- `test/util/cmcd_manager_unit.js`: +107 / −140 (Phase 1) and +12 / 0 (Phase 2 value-identity test). Cumulative net −33 / +119.
 - `build/conformance.textproto`: 2 entries added (`setInterval`, `fetch`).
 - `build/types/core`: 74 entries added for the vendored files.
 - `plans/cmcd-cml-refactor/`: design + verification docs.
 
-**Total**: 84 files, +5797 / −327.
+**Total (Phases 1 + 2)**: ~85 files, ~+5800 / ~−500.
 
 (Plan estimated ~3000 lines for the port; actual is ~5000 because of (a) `cml_sfv.js` (~448 LoC RFC 8941 serializer shim — CML uses `@svta/cml-utils`'s SFV encoder, which we vendor inline since the shim doesn't ship as a separate package), (b) 8 spec-excluded files re-included as runtime dependencies, and (c) generous license/notice headers per Apache 2.0.)
 
-## Verification
+## Verification (Phases 1 + 2)
 
 - [x] `python3 build/check.py` exits 0 (lint, conformance, types, spelling).
 - [x] `python3 build/all.py` exits 0 (full bundle build: dash/hls/compiled/ui/experimental, debug + release).
-- [x] `python3 build/test.py --filter Cmcd` — 124 / 124 pass.
-- [x] `python3 build/test.py --quick` — 2995 / 2995 pass (no regressions outside CMCD).
+- [x] `python3 build/test.py --filter Cmcd` — 125 / 125 pass (Phase 2 added a value-identity test).
+- [x] `python3 build/test.py --quick` — 2996 / 2996 pass (no regressions outside CMCD).
 - [x] Demo smoke test on `bbb-dark-truths/dash.mpd` — query mode emits `?CMCD=cid="…",ot=m,sf=d,sid="…",sn=N,su,v=2` (no `ts`, no `sf=ld`, tokens unquoted, `v=2` always present); header mode emits `v=2` only in `CMCD-Session` shard (the C2 sub-phase E fix verified end-to-end). Zero JS console errors. See [`plan.md`](plans/cmcd-cml-refactor/plan.md) "Sub-phase F landing notes" for the full capture.
 
 ## Plan / spec docs
@@ -116,13 +146,18 @@ This PR includes the design + verification docs under `plans/cmcd-cml-refactor/`
 
 These remain in the repo as Phase 2 + 3 reference. They can be deleted once Phase 3 merges if maintainers prefer.
 
-## Phase 1 commit list (for reviewer convenience)
+## Commit list (for reviewer convenience)
 
+**Phase 0 — CML verification (5 commits, docs-only):**
 ```
 79702531e docs(cmcd): add Phase 0 CML version pin + API verification report
 33c7c78ab docs(cmcd): fix doc cross-references in Phase 0 verification report
 be97afe47 docs(cmcd): restructure Phase 0 doc-update checklist into plan vs spec lists
 6a851a2d8 docs(cmcd): apply Phase 0 verification findings to spec and plan
+```
+
+**Phase 1 — Vendor port + encoder delegation (~20 commits):**
+```
 a8d855179 chore(third_party): add cml-cmcd vendoring skeleton
 0027abbe1 chore(cmcd): port cml-cmcd type definitions as closure typedefs
 ae92000c7 chore(cmcd): port cml-cmcd enums to closure
@@ -144,6 +179,12 @@ adfdfab05 fix(cmcd): drop non-spec 'ld'/'lh' StreamingFormat values
 27cd16907 fix(cmcd): thread version/reportingMode + prepare-once for header shards
 b94f7ebca test(cmcd): update assertions for CML wire-format alignments
 0e3883181 docs(cmcd): mark Phase 1 sub-phase E complete in plan
+d663f6c12 docs(cmcd): mark Phase 1 sub-phase F complete; add all-phases PR draft
+```
+
+**Phase 2 — Adopt CML constants/enums (1 commit):**
+```
+67443aacb refactor(cmcd): adopt CML constants/enums; delete shaka duplicates
 ```
 
-The first 5 commits (`79702531e`–`6a851a2d8`) are Phase 0 docs only and could be split off as a docs-only PR if maintainers prefer. The rest are Phase 1 proper.
+The first 4 commits (`79702531e`–`6a851a2d8`) are Phase 0 docs only and could be split off as a docs-only PR if maintainers prefer. The rest are implementation.

From 1352a01a07f3738128e4ff58d7897d4bb05e56a5 Mon Sep 17 00:00:00 2001
From: Casey Occhialini <1508707+littlespex@users.noreply.github.com>
Date: Tue, 28 Apr 2026 16:10:18 -0700
Subject: [PATCH 32/64] docs(cmcd): expand Phase 3 prep with concrete
 session-context handoff
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Phase 3 will run in a fresh session. Replace the short "Phase 3 prep"
subsection (4 bullet points) with a substantial 200+ line handoff doc
that captures everything a new session needs to pick up cleanly:

- Branch + repo state at handoff (HEAD `f0b99a8e0`, line counts,
  CML pin, stashes).
- Eight inherited decisions / gotchas Phase 3 must respect (Closure
  rejects enum aliases; CMCD_DEFAULT_TIME_INTERVAL 10 vs 30 deferred
  decision; internal type-annotation pattern; setLowLatency no-op
  shim; obsolete static helpers to delete; networkingEngine
  reference pattern; text_displayer flake).
- Concrete file pointers for `cmcd_manager.js` — every public method
  to KEEP (with line numbers + Player call sites in `lib/player.js`),
  every shaka-knowledge helper to KEEP, every state-machine method/
  field to DELETE.
- `externs/shaka/player.js` line numbers for the renames
  (`targets` → `eventTargets`, per-target `timeInterval` → `interval`).
- `externs/cmcd.js` `CmcdData` typedef stays as-is.
- `lib/player.js` integration points — eight call sites enumerated.
- CmcdReporter constructor + method signatures (verified Phase 0)
  with the two-pattern `recordResponseReceived` flow.
- Task 3.13 starting points (test file structure post-Phase-2;
  4296 LoC, ~3500 to delete).
- Task 3.14 demo update minimum scope.
- Smoke-test recipe (verified in Phase 1F + Phase 2): Claude Preview
  MCP + python http.server 17765 + bbb-dark-truths asset + CORS
  workaround for header mode.
- Test invocation patterns (CMCD-only filter, full --quick, build).
- PR strategy reminder: do NOT push, single all-phases PR after
  Phase 3 lands; update `pr-draft.md` with Phase 3 section instead.

The companion memory file (`cmcd_refactor_progress.md`) was updated
with a handoff entry pointing to this section; new session should
read both.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 plans/cmcd-cml-refactor/plan.md | 143 +++++++++++++++++++++++++++++++-
 1 file changed, 139 insertions(+), 4 deletions(-)

diff --git a/plans/cmcd-cml-refactor/plan.md b/plans/cmcd-cml-refactor/plan.md
index 6470e809fe..9fa52c3424 100644
--- a/plans/cmcd-cml-refactor/plan.md
+++ b/plans/cmcd-cml-refactor/plan.md
@@ -129,10 +129,145 @@ Two git stashes exist:
 
 ### Resuming work in a new session — Phase 3 prep
 
-- **Verify CML pinned clone** is still at `/tmp/cml-pinned/` (same as Phase 1/2 prep — should be `22390e35dfbbe1e53d15648d3aace99cdf71f9dd`).
-- **Phase 3 scope (Tasks 3.1-3.16):** rewrite `lib/util/cmcd_manager.js` as a thin (~250-line) adapter around `cml.cmcd.CmcdReporter`. Delete the state machine, sequence-number bookkeeping, event timing, and most key-filtering logic — all of those move into `CmcdReporter`. Apply experimental v2 config renames (per spec). Delete the CMCD wire-format unit tests (~3500 lines of `cmcd_manager_unit.js`) and replace with adapter-glue + smoke tests.
-- **Phase 3 is the high-risk PR.** Watch for: state-transition timing differences (CML vs. shaka's existing transitions), per-target sequence-number behavior (Task 0.7), event-mode dispatch shape, `applyResponseData` mutation contract (Task 3.5).
-- **Phase 1 PR description scaffolding** lives at `plans/cmcd-cml-refactor/phase-1-pr-draft.md` (uncommitted scratch file). Phase 2 / 3 will accrete to the same file or be merged into one before the eventual all-phases PR.
+This subsection captures everything a fresh session needs to pick up Phase 3 cleanly. Spec.md and the per-task instructions above are still authoritative for the design — the items here are session-context that won't survive a context handoff otherwise.
+
+#### Branch + repo state at handoff (last commit `f0b99a8e0`)
+
+- 28 commits ahead of `origin/feat/cmcd-cml-refactor`, working tree clean. `.claude/` is untracked and intentional.
+- `lib/util/cmcd_manager.js` is **1580 lines**; Phase 3 target is ~250.
+- `test/util/cmcd_manager_unit.js` is **4296 lines**; Phase 3 deletes ~3500 (Bucket A wire-format tests) and adds ~600 (Bucket B/C adapter + smoke).
+- CML pin still `cmcd-v2.3.0` / `22390e35dfbbe1e53d15648d3aace99cdf71f9dd`. Clone at `/tmp/cml-pinned/`. Re-verify: `cd /tmp/cml-pinned && git rev-parse HEAD`.
+- Two git stashes (`stash@{0}` accidental-stash-pop-recovery, `stash@{1}` task/revert-cmcd-v1) are user-owned. Don't drop without asking.
+- `plans/cmcd-cml-refactor/pr-draft.md` is the cumulative all-phases PR scaffolding. Phase 1 + Phase 2 sections present; Phase 3 needs to append (Public-API renames, behavioral changes, sequence-number outcome, event-mode dispatch note, test surface delta, deferred follow-ups). Update title if needed; current title is `refactor(cmcd): vendor @svta/cml-cmcd, replace custom encoder + state machine`.
+
+#### Decisions / gotchas inherited from earlier phases — must respect in Phase 3
+
+1. **Closure tooling rejects `@export`ed enum aliases.** Phase 2 tried `shaka.util.CmcdManager.StreamingFormat = cml.cmcd.CmcdStreamingFormat;` — both `clutz` (TS-defs gen) and `generateExterns.js` rejected the `MemberExpression` RHS. Same constraint applies to **Task 3.12 v2 re-exports** — must use literal `@enum {string} @export shaka.util.CmcdManager.EventType = { PLAY_STATE: 'ps', ... };` form, NOT alias. A new value-identity unit test should assert each public re-export equals the corresponding `cml.cmcd.*` enum (parallel to the existing `StreamingFormat alias` test in `cmcd_manager_unit.js:219`).
+2. **CMCD time-interval default value.** Shaka's old default was `10` seconds; CML's `CMCD_DEFAULT_TIME_INTERVAL` is `30`. Phase 2 inlined `10` as a magic number with a comment marking the deferral. Phase 3 must pick: (a) accept CML's `30` (call out as a wire-format change in PR description) or (b) override per-target via `interval` field in `toReporterConfig_`. Spec.md recommends (a); the CmcdReporter takes `interval` from `CmcdEventReportConfig`, so per-target override is straightforward.
+3. **Internal type annotations refer to `cml.cmcd.CmcdStreamingFormat` directly** (not `shaka.util.CmcdManager.StreamingFormat`) per Phase 2 — `this.sf_` private field, `getStreamFormat_` return type. Keep this pattern. The `shaka.util.CmcdManager.StreamingFormat` literal is the public-facing form (the `@export`ed alias-equivalent).
+4. **`setLowLatency` is now a no-op shim** (Phase 1 Task 1.10b dropped `'ld'`/`'lh'`). Phase 3 keeps it as a no-op for back-compat (Player still calls `cmcdManager_.setLowLatency(...)` at `lib/player.js:3073`); does NOT mutate `streamingFormat`. Spec.md § "Streaming format and low-latency" makes this explicit.
+5. **`shaka.util.CmcdManager.getEncodeOptions_` static helper** (added in Phase 1 sub-phase E) becomes obsolete in Phase 3 — `CmcdReporter` builds its own encode options internally. Delete it as part of Task 3.10.
+6. **Phase 1's `appendQueryToUri` static (the `goog.Uri`-based adapter)** was retained because CML's `appendCmcdQuery` has an incompatible signature. Phase 3 deletes it along with the other static encoders — `appendSrcData` and `appendTextTrackData` are the only remaining call sites, and both can use `cml.cmcd.appendCmcdQuery(uri, cmcdData, options)` directly.
+
+#### Concrete file pointers
+
+**`lib/util/cmcd_manager.js`:**
+- **Public methods to KEEP** (Player calls these directly — see `lib/player.js` references in parens):
+  - `setMediaElement(mediaElement)` (line 131; Player call at `lib/player.js:1407`).
+  - `configure(config)` (line 142; Player at `:4576`).
+  - `reset()` (line 151; Player at `:1646`).
+  - `setBuffering(buffering)` (line 178; Player call exists in buffering-observer wiring).
+  - `setLowLatency(lowLatency)` (line 201; Player at `:3073` — keep as no-op shim).
+  - `setStartTimeOfLoad(startTimeOfLoad)` (line 210; Player at `:3075`).
+  - `applyRequestData(type, request, context)` (line 238; Player at `:4003`).
+  - `applyResponseData(type, response, context)` (line 282; Player at `:4028`).
+  - `appendSrcData(uri, mimeType)` (line 456; Player at `:3386`).
+  - `appendTextTrackData(uri)` (line 485; Player at `:7330`).
+- **Shaka-knowledge helpers to KEEP** (the adapter's job to translate; spec § "Request/response interception"):
+  - `removeCmcdQueryFromUri_` (line 433) — used in response flow.
+  - `getObjectType_` (line 1019).
+  - `getBufferLength_` (line 1118).
+  - `getRemainingBufferLength_` (line 1142).
+  - `calculateRtp_` (line 1183) — `bitrate × rtpSafetyFactor`.
+  - `getStreamFormat_` (line 1210).
+  - `getStreamType_` (line 1231).
+  - `requestTimestampMap_` field — TTFB/TTLB measurement.
+  - `setupEventListeners_` (line 533) — needs full rewrite, not delete (replaces the existing playback-time tracking with reporter.update / recordEvent calls per spec § "Player state ↔ reporter state mapping").
+- **Methods/fields to DELETE** (state machine; CML reporter owns this now):
+  - `applyRequest_` (line 788), `applyManifestData` (line 304), `applyRequestSegmentData` (line 382), `applyResponseSegmentData` (line 331), `applyTextData` (line 410), `applyResponse_` (line 835), `sendCmcdRequest_` (line 849), `applyCmcdDataToRequest_` (line 897).
+  - `checkValidKeys_` (line 940), `filterKeys_` (line 968), `isValidEvent_` (line 984), `getCmcdTargetHash_` (line 1098).
+  - `reportEvent_` (line 714), `setupEventModeTimeInterval_` (line 623), `stopAndClearEventTimers_` (line 654), `getEventModeEnabledTargets_` (line 667).
+  - `createData_` (line 696), `getDataForSegment_` (line 1284), `getGenericData_` (line 1379), `getObjectTypeFromMimeType_` (line 1061).
+  - `onPlaybackPlay_` (line 512), `onPlaybackPlaying_` (line 523).
+  - State fields: `cmcdSequenceNumbers_`, `eventTimers_`, `msdSent_`, `playbackPlayTime_`, `playbackPlayingTime_`, `startTimeOfLoad_`, `playbackStarted_`, `buffering_`, `starved_`.
+  - Static class methods: `serialize`, `toQuery`, `toHeaders`, `appendQueryToUri`, `getEncodeOptions_` (all become unused once `applyRequest_`/`sendCmcdRequest_` are gone).
+
+**`externs/shaka/player.js`:**
+- `shaka.extern.CmcdTarget` typedef at lines 2742-2760. Per-target rename per spec: `timeInterval` (line 2754) → `interval`. Per-target `enabledKeys` is already `includeKeys` in shaka externs (line 2744) — no rename needed at this layer (spec's `enabledKeys → includeKeys` rename refers to shaka↔CML naming inside `toReporterConfig_`).
+- `shaka.extern.CmcdConfiguration` typedef at lines 2762-2824. Top-level rename: `targets` (lines 2771, 2819) → `eventTargets`. Update both the typedef and the `@property` JSDoc.
+
+**`externs/cmcd.js`:** Public-facing `CmcdData` typedef. Keep as-is — structurally equivalent to `cml.cmcd.Cmcd`, retains the existing public API surface. No changes needed in Phase 3.
+
+**`lib/player.js`:** Player wires the manager via `this.cmcdManager_` (private field at line 828). `createCmcd_` factory at line 4336 returns `new shaka.util.CmcdManager(this, this.config_.cmcd)`. Player passes `this` as the player ref — adapter calls `this.player_.getNetworkingEngine()` (current pattern at line 885) when it needs the networking engine for the requester callback. **Don't add a separate `networkingEngine_` field** — keep using `this.player_.getNetworkingEngine()` lazily inside `makeRequester_()`.
+
+#### CmcdReporter constructor + method signatures (verified in Phase 0)
+
+From `third_party/cml-cmcd/cmcd_reporter.js` and `cml-version.md`:
+
+```
+new cml.cmcd.CmcdReporter(config: CmcdReporterConfig, requester: (CmcdRequest) => Promise<{status: number}>)
+  // requester is the SECOND positional arg, not a config field.
+
+reporter.start()       // void; sets up time-interval timers, fires initial 't' event synchronously
+reporter.stop(flush)   // void; flush=true drains queued events before stopping
+reporter.flush()       // void; manual drain
+reporter.update(partialState)             // void; merges into persistent state
+reporter.recordEvent(eventType, data?)    // void; queues a discrete event for next dispatch
+reporter.createRequestReport(request, data?)   // returns R & CmcdRequestReport — derived object, NOT in-place mutation
+reporter.recordResponseReceived(response, data?)  // void; data is Partial<Cmcd>, not the flat {ttfb,ttlb,rc,url} shape
+```
+
+For `recordResponseReceived` (Task 3.5), spec § "Request/response interception" describes two valid call patterns: (a) supply `response.resourceTiming = {startTime, responseStart, duration}` to let CML auto-derive `ts/ttfb/ttlb`, or (b) pass `{ttfb, ttlb, rc, url}` as the `data` arg (overrides win). Adapter can mix — typical flow: pass `ttfb`/`ttlb` from `requestTimestampMap_` as `data`, let CML derive `ts` from `Date.now()` internally.
+
+#### Task 3.13 test rewrite — concrete starting points
+
+The current `test/util/cmcd_manager_unit.js` (4296 lines) structure:
+- Top-level `describe('CmcdManager Setup', ...)` wraps everything (lines 8-end).
+- Inside, `describe('CmcdManager CMCD V1', ...)` and `describe('CmcdManager CMCD V2', ...)` are the two big buckets — most of the wire-format coverage is here.
+- The `StreamingFormat alias` test at line 219 is the Phase 2 value-identity test — keep this; add parallel ones for `EventType` and `PlayerState` (Task 3.12).
+
+Bucket B / C tests should use a stubbed `CmcdReporter` (record calls) for unit coverage and a real one (drive end-to-end) for smoke. Look at how `cml.cmcd.CmcdReporter` is constructed in `cmcd_reporter.js:139` for the constructor signature.
+
+#### Task 3.14 demo update — minimum scope (per spec gap #8)
+
+Mirror dash.js's `cmcd-v2.html` precedent. Current demo CMCD UI lives in `demo/config.js` (grep `cmcd` for the existing controls). Add: transmission-mode toggle (query/headers — already exists as `useHeaders` checkbox), version selector (1/2 — `version` numeric input), single eventTarget editor (URL + events checklist + `interval` numeric input + `batchSize` numeric input + `includeKeys` checklist). Wire to `player.configure({cmcd: {...}})`.
+
+#### Smoke test pattern that worked in Phase 1 sub-phase F + Phase 2
+
+For driving the demo locally via Claude Preview MCP:
+
+1. Create `.claude/launch.json`:
+   ```json
+   {
+     "version": "0.0.1",
+     "configurations": [
+       {
+         "name": "shaka-demo",
+         "runtimeExecutable": "python3",
+         "runtimeArgs": ["-m", "http.server", "17765"],
+         "port": 17765
+       }
+     ]
+   }
+   ```
+2. Call `mcp__Claude_Preview__preview_start({name: "shaka-demo"})`.
+3. `preview_eval`: `window.location.href = 'http://localhost:17765/demo/'`.
+4. Configure CMCD via `player.configure({cmcd: {...}})` and `await player.load(...)`.
+5. Test asset: `https://storage.googleapis.com/shaka-demo-assets/bbb-dark-truths/dash.mpd`.
+6. **Header mode CORS workaround**: storage.googleapis.com blocks CMCD-* via CORS preflight. Use `player.getNetworkingEngine().registerRequestFilter((type, request) => {...})` to capture `request.headers` THEN strip CMCD-* before fetch. This is a smoke-test-only workaround — real deployments configure CDN CORS to accept `Access-Control-Allow-Headers: CMCD-*`.
+7. Cleanup: `mcp__Claude_Preview__preview_stop({serverId})`; `rm /Users/cocch1216/dev/shaka-player/.claude/launch.json`.
+
+#### Test invocation patterns
+
+```bash
+# CMCD-only filter (fast, ~5 sec):
+python3 build/test.py --browsers ChromeHeadless --quick --filter Cmcd \
+    --no-babel --reporters spec --spec-hide-passed
+
+# Full --quick suite (~65 sec, regression check):
+python3 build/test.py --browsers ChromeHeadless --quick \
+    --no-babel --reporters spec --spec-hide-passed
+
+# Build verification:
+python3 build/check.py --force                  # lint + spell + types (45 sec)
+python3 build/all.py --force                    # full bundle build (~4 min)
+```
+
+`text_displayer_layout_unit.js` failures (24 tests) appear flakily in full-suite runs but pass in isolation; they are environmental and unrelated to CMCD work. Confirmed across Phase 1 / Phase 2 sessions.
+
+#### PR strategy reminder
+
+**Do NOT push or open a PR after Phase 3.** User direction (revised 2026-04-28): single all-phases PR off `feat/cmcd-cml-refactor` once everything is done. Phase 3 ends with: (a) plan + memory + `pr-draft.md` updates committed, (b) branch sitting locally, (c) explicit user prompt to push when ready. The plan's Task 3.16 is dropped in this strategy (kept as scaffolding for the eventual single PR's description).
 
 ---
 

From 965ba69f889f0b872993c68994825904b4384b9e Mon Sep 17 00:00:00 2001
From: Casey Occhialini <1508707+littlespex@users.noreply.github.com>
Date: Tue, 28 Apr 2026 17:34:53 -0700
Subject: [PATCH 33/64] refactor(cmcd): rewrite shaka.util.CmcdManager as thin
 adapter around CmcdReporter
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Phase 3 of the CMCD CML refactor: replace shaka's 1580-line custom
CMCD state machine with a ~700-line adapter that delegates state,
encoding, key filtering, sequence numbering, and event-mode dispatch
to the vendored cml.cmcd.CmcdReporter. The bulk of the LoC win is in
tests (~4300 LoC of wire-format coverage moved to CML upstream and
deleted; ~600 LoC of adapter glue + smoke added).

Behavior:
* Public Player→manager API surface preserved (setMediaElement,
  configure, reset, applyRequestData, applyResponseData,
  appendSrcData, appendTextTrackData, applyTextData, setBuffering,
  setLowLatency no-op, setStartTimeOfLoad).
* CmcdReporter is constructed lazily on the first setMediaElement
  with `enabled: true`; teardown + reconstruction on material
  config change (sessionId/contentId/version/useHeaders/eventTargets).
* Event-mode dispatch routes through NetworkingEngine via a custom
  `requester` callback (RequestType.TIMING, POST + string body),
  inheriting auth/retry/filters. No new public config field.
* Player-state deduplication: lastPlayerState_ skips the
  update + recordEvent pair when the new state matches the prior.
* Empty includeKeys is expanded to all valid keys for the version
  (V1 keyset, or V2 request/response/event union) so CML's reporter
  doesn't early-return on an empty enabledKeys array.

Experimental v2 config renames (shaka.extern.CmcdConfiguration):
* `targets` → `eventTargets`
* per-target `timeInterval` → `interval` (matches CML)
* per-target `version`, `batchSize` exposed in the typedef

New public re-exports (literal-form @export, per Closure-tooling
constraint from Phase 2):
* shaka.util.CmcdManager.EventType
* shaka.util.CmcdManager.PlayerState

Wire-format alignments inherited from CML:
* `sn` shifts from 1-based to 0-based (CML uses 0).
* Request-mode `sn` becomes a single global counter (was per-
  target-hash); resets on `sid` change.
* CMCD_DEFAULT_TIME_INTERVAL adopts CML's value of 30 (was shaka's
  10) when the user does not specify a per-target `interval`.

Demo: adds an `Event Targets (JSON)` text input for v2 event-mode
config (mirrors dash.js's cmcd-v2.html precedent). Version field
converted to a numeric input.

Verification:
* `python3 build/check.py --force` exits 0
* `python3 build/test.py --quick` 2927/2927 pass (4 environmental
  skips unrelated to CMCD)
* `python3 build/all.py --force` exits 0
* `EventType`, `PlayerState`, `StreamingFormat` all appear in
  dist/shaka-player.compiled.js (Closure ADVANCED preserves the
  @export'd literal enums).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 demo/config.js                   |   27 +-
 externs/shaka/player.js          |   37 +-
 lib/util/cmcd_manager.js         | 1635 ++++------
 lib/util/player_configuration.js |    2 +-
 test/demo/demo_unit.js           |    6 +-
 test/util/cmcd_manager_unit.js   | 4925 +++++-------------------------
 6 files changed, 1445 insertions(+), 5187 deletions(-)

diff --git a/demo/config.js b/demo/config.js
index 969bc230f3..4a1766660b 100644
--- a/demo/config.js
+++ b/demo/config.js
@@ -442,10 +442,35 @@ shakaDemo.Config = class {
         .addBoolInput_('Enabled', 'cmcd.enabled')
         .addTextInput_('Session ID', 'cmcd.sessionId')
         .addTextInput_('Content ID', 'cmcd.contentId')
-        .addTextInput_('Version', 'cmcd.version')
+        .addNumberInput_('Version', 'cmcd.version',
+            /* canBeDecimal= */ false)
         .addNumberInput_('RTP safety Factor', 'cmcd.rtpSafetyFactor',
             /* canBeDecimal= */ true)
         .addBoolInput_('Use Headers', 'cmcd.useHeaders');
+
+    // CMCD v2 event-mode targets. JSON because the typedef is an
+    // array of objects with several fields each; a per-field UI would
+    // bloat the demo significantly.
+    const eventTargetsTooltip =
+        'JSON array of event-mode CmcdTarget objects, e.g. ' +
+        '[{"enabled":true,"url":"https://collector/cmcd",' +
+        '"events":["ps","rr"],"interval":30,"includeKeys":[]}]';
+    const onTargetsChange = (input) => {
+      try {
+        const parsed = input.value.trim() ? JSON.parse(input.value) : [];
+        shakaDemoMain.configure('cmcd.eventTargets', parsed);
+        shakaDemoMain.remakeHash();
+        input.setCustomValidity('');
+      } catch (e) {
+        input.setCustomValidity('Invalid JSON');
+      }
+    };
+    this.addCustomTextInput_(
+        'Event Targets (JSON)', onTargetsChange, eventTargetsTooltip);
+    const current = /** @type {Array<*>} */ (
+      shakaDemoMain.getCurrentConfigValue('cmcd.eventTargets'));
+    this.latestInput_.input().value =
+        (current && current.length) ? JSON.stringify(current) : '';
   }
 
   /** @private */
diff --git a/externs/shaka/player.js b/externs/shaka/player.js
index 6a73443335..c79397162d 100644
--- a/externs/shaka/player.js
+++ b/externs/shaka/player.js
@@ -2715,11 +2715,14 @@ shaka.extern.AdvancedAbrConfiguration;
  *   url: string,
  *   includeKeys: !Array<string>,
  *   events: !Array<string>,
- *   timeInterval: number,
+ *   interval: (number|undefined),
+ *   batchSize: (number|undefined),
+ *   version: (number|undefined)
  * }}
  *
  * @description
- *  Common Media Client Data (CMCD) Target Configuration
+ *  Common Media Client Data (CMCD) Target Configuration. Experimental
+ *  v2 surface — field names are subject to change.
  *
  * @property {string} mode
  * Specifies the transmission strategy for the CMCD data.
@@ -2747,14 +2750,23 @@ shaka.extern.AdvancedAbrConfiguration;
  * <br>
  * Defaults to <code>[]</code>.
  * @property {!Array<string>} events
- * An array of events to include as part of ps and sta in the CMCD data.
- * If not provided, all events will be included.
+ * An array of events that this target subscribes to.
+ * If not provided, no event reports will be sent to this target.
  * <br>
  * Defaults to <code>[]</code>.
- * @property {number} timeInterval
- *   Time Interval config in seconds
- *   <br>
- *   Defaults to <code>10</code>.
+ * @property {(number|undefined)} interval
+ *   Time-interval period in seconds for periodic event reports
+ *   (<code>'t'</code> events). Set to <code>0</code> to disable periodic
+ *   reports.
+ *   <br>
+ *   Defaults to <code>30</code> (the CMCD v2 default).
+ * @property {(number|undefined)} batchSize
+ *   Number of events to batch before dispatch.
+ *   <br>
+ *   Defaults to <code>1</code> (no batching).
+ * @property {(number|undefined)} version
+ *   Per-target CMCD version override. CMCD event mode is v2-only;
+ *   leave unset to inherit the top-level <code>version</code>.
  * @exportDoc
  */
 shaka.extern.CmcdTarget;
@@ -2768,7 +2780,7 @@ shaka.extern.CmcdTarget;
  *   rtpSafetyFactor: number,
  *   includeKeys: !Array<string>,
  *   version: number,
- *   targets: ?Array<shaka.extern.CmcdTarget>
+ *   eventTargets: ?Array<shaka.extern.CmcdTarget>
  * }}
  *
  * @description
@@ -2816,8 +2828,11 @@ shaka.extern.CmcdTarget;
  *   and CMCD v2 specifications, respectively.
  *   <br>
  *   Defaults to <code>1</code>.
- * @property {Array<shaka.extern.CmcdTarget>=} targets
- *   The event/response mode targets.
+ * @property {Array<shaka.extern.CmcdTarget>=} eventTargets
+ *   Experimental v2: event-mode reporting targets. Each entry configures
+ *   one endpoint that receives batched CMCD event reports
+ *   (e.g., <code>'ps'</code>, <code>'rr'</code>) for the configured
+ *   <code>events</code>.
  *   <br>
  * @exportDoc
  */
diff --git a/lib/util/cmcd_manager.js b/lib/util/cmcd_manager.js
index de78c38683..dd13b5e052 100644
--- a/lib/util/cmcd_manager.js
+++ b/lib/util/cmcd_manager.js
@@ -7,39 +7,52 @@
 goog.provide('shaka.util.CmcdManager');
 
 goog.require('cml.cmcd.CMCD_EVENT_KEYS');
-goog.require('cml.cmcd.CMCD_EVENT_MODE');
-goog.require('cml.cmcd.CMCD_EVENT_TIME_INTERVAL');
+goog.require('cml.cmcd.CMCD_HEADERS');
+goog.require('cml.cmcd.CMCD_QUERY');
 goog.require('cml.cmcd.CMCD_REQUEST_KEYS');
 goog.require('cml.cmcd.CMCD_REQUEST_MODE');
 goog.require('cml.cmcd.CMCD_RESPONSE_KEYS');
+goog.require('cml.cmcd.CMCD_V1');
 goog.require('cml.cmcd.CMCD_V1_KEYS');
 goog.require('cml.cmcd.CMCD_V2');
 goog.require('cml.cmcd.CmcdEventType');
 goog.require('cml.cmcd.CmcdObjectType');
 goog.require('cml.cmcd.CmcdPlayerState');
-goog.require('cml.cmcd.CmcdReportingMode');
+goog.require('cml.cmcd.CmcdReporter');
 goog.require('cml.cmcd.CmcdStreamType');
 goog.require('cml.cmcd.CmcdStreamingFormat');
-goog.require('cml.cmcd.encodeCmcd');
-goog.require('cml.cmcd.encodePreparedCmcd');
-goog.require('cml.cmcd.prepareCmcdData');
-goog.require('goog.Uri');
+goog.require('cml.cmcd.appendCmcdQuery');
 
 goog.require('shaka.log');
 goog.require('shaka.net.NetworkingEngine');
 goog.require('shaka.util.ArrayUtils');
 goog.require('shaka.util.EventManager');
-goog.require('shaka.util.Timer');
+goog.require('shaka.util.StringUtils');
 
 goog.requireType('cml.cmcd.Cmcd');
 goog.requireType('cml.cmcd.CmcdEncodeOptions');
+goog.requireType('cml.cmcd.CmcdReporterConfig');
 goog.requireType('shaka.media.SegmentReference');
 goog.requireType('shaka.Player');
 
+
 /**
  * @summary
- * A CmcdManager maintains CMCD state as well as a collection of utility
- * functions.
+ * Thin shaka adapter around `cml.cmcd.CmcdReporter`. The vendored
+ * reporter owns CMCD state, encoding, key filtering, sequence numbers,
+ * and event-mode dispatch. The adapter translates shaka's player /
+ * `<video>` events into reporter calls, and shaka's request/response
+ * shapes into CML's HttpRequest/HttpResponse shapes.
+ *
+ * Adapter responsibilities:
+ *   1. Lifecycle: construct/start/stop CmcdReporter from configure() / reset()
+ *   2. Player wiring: <video> + Player events → reporter.update + recordEvent
+ *   3. Request mode: applyRequestData → reporter.createRequestReport
+ *   4. Response mode: applyResponseData → reporter.recordResponseReceived
+ *   5. Event mode: requester callback → NetworkingEngine.request
+ *   6. Config translation: shaka.extern.CmcdConfiguration → CmcdReporterConfig
+ *   7. Public-API back-compat: re-exports for StreamingFormat / EventType /
+ *      PlayerState
  */
 shaka.util.CmcdManager = class {
   /**
@@ -47,178 +60,144 @@ shaka.util.CmcdManager = class {
    * @param {shaka.extern.CmcdConfiguration} config
    */
   constructor(player, config) {
+    /** @private {?shaka.Player} */
+    this.player_ = player;
+
     /** @private {?shaka.extern.CmcdConfiguration} */
     this.config_ = config;
 
-    /** @private {?shaka.Player} */
-    this.player_ = player;
+    /** @private {HTMLMediaElement} */
+    this.video_ = null;
 
-    /** @private {!Map<!shaka.extern.Request, number>} */
-    this.requestTimestampMap_ = new Map();
+    /** @private {?cml.cmcd.CmcdReporter} */
+    this.reporter_ = null;
+
+    /** @private {?string} */
+    this.lastPlayerState_ = null;
 
     /**
-     * Streaming format
+     * Streaming format set once at manifest-load time. CTA-5004 / CTA-5004-B
+     * define `sf` as a stable manifest-type indicator (`'d'`/`'h'`/`'s'`/
+     * `'o'`); the value does not reflect the low-latency state.
      *
      * @private {(cml.cmcd.CmcdStreamingFormat|undefined)}
      */
     this.sf_ = undefined;
 
     /**
-     * @private {boolean}
-     */
-    this.playbackStarted_ = false;
-
-    /**
-     * @private {boolean}
-     */
-    this.buffering_ = true;
-
-    /**
-     * @private {boolean}
-     */
-    this.starved_ = false;
-
-    /**
-     * @private {boolean}
-     */
-    this.lowLatency_ = false;
-
-    /**
-     * @private {number|undefined}
-     */
-    this.playbackPlayTime_ = undefined;
-
-    /**
-     * @private {number|undefined}
-     */
-    this.playbackPlayingTime_ = undefined;
-
-    /**
-     * @private {number}
-     */
-    this.startTimeOfLoad_ = 0;
-
-    /**
-     * @private {{request: boolean, event: boolean}}
-     */
-    this.msdSent_ = {
-      request: false,
-      event: false,
-    };
-
-    /**
-     * @private {!Object<string, {request: number, response: number}>}
+     * Per-request `ts` values for TTFB/TTLB derivation in
+     * `applyResponseData`. CmcdReporter cannot observe request-send time;
+     * the adapter measures it.
+     *
+     * @private {!Map<!shaka.extern.Request, number>}
      */
-    this.cmcdSequenceNumbers_ = {};
+    this.requestTimestampMap_ = new Map();
 
-    /**
-     * @private {shaka.util.EventManager}
-     */
+    /** @private {shaka.util.EventManager} */
     this.eventManager_ = new shaka.util.EventManager();
 
-    /** @private {Array<shaka.util.Timer>} */
-    this.eventTimers_ = [];
-
-    /** @private {HTMLMediaElement} */
-    this.video_ = null;
+    /** @private {number} */
+    this.startTimeOfLoad_ = 0;
   }
 
-
   /**
-   * Set media element and setup event listeners
+   * Set the media element and start the reporter (if enabled).
+   *
    * @param {HTMLMediaElement} mediaElement The video element
    */
   setMediaElement(mediaElement) {
     this.video_ = mediaElement;
-    this.setupEventListeners_();
+    this.maybeStartReporter_();
+    if (this.reporter_) {
+      this.setupEventListeners_();
+    }
   }
 
   /**
-   * Called by the Player to provide an updated configuration any time it
-   * changes.
+   * Update the manager's configuration. If `enabled` flips or any
+   * material field changes, the reporter is torn down and recreated.
    *
    * @param {shaka.extern.CmcdConfiguration} config
    */
   configure(config) {
+    const oldConfig = this.config_;
     this.config_ = config;
-    this.setupEventModeTimeInterval_();
-  }
 
+    if (this.reporter_) {
+      const enabledOff = oldConfig && oldConfig.enabled && !config.enabled;
+      const materialChange = oldConfig && config.enabled && (
+        oldConfig.sessionId !== config.sessionId ||
+        oldConfig.contentId !== config.contentId ||
+        oldConfig.version !== config.version ||
+        oldConfig.useHeaders !== config.useHeaders ||
+        oldConfig.eventTargets !== config.eventTargets);
+      if (enabledOff || materialChange) {
+        this.reporter_.stop(true);
+        this.reporter_ = null;
+        this.lastPlayerState_ = null;
+      }
+    }
+
+    if (!this.reporter_ && this.video_) {
+      this.maybeStartReporter_();
+      if (this.reporter_) {
+        this.setupEventListeners_();
+      }
+    }
+  }
 
   /**
-   * Resets the CmcdManager.
+   * Reset the manager. Stops the reporter and removes event listeners.
    */
   reset() {
+    if (this.reporter_) {
+      this.reporter_.stop(true);
+      this.reporter_ = null;
+    }
+    this.lastPlayerState_ = null;
+    this.sf_ = undefined;
     this.requestTimestampMap_.clear();
-    this.playbackStarted_ = false;
-    this.buffering_ = true;
-    this.starved_ = false;
-    this.lowLatency_ = false;
-    this.playbackPlayTime_ = 0;
-    this.playbackPlayingTime_ = 0;
     this.startTimeOfLoad_ = 0;
-    this.msdSent_ = {
-      request: false,
-      response: false,
-      event: false,
-    };
-
-    this.stopAndClearEventTimers_();
-    this.cmcdSequenceNumbers_ = {};
-
     this.video_ = null;
     this.eventManager_.removeAll();
   }
 
   /**
-   * Set the buffering state
+   * Forwarded from Player buffering observer; translates to a
+   * REBUFFERING / PLAYING player-state transition.
    *
    * @param {boolean} buffering
    */
   setBuffering(buffering) {
-    if (!buffering && !this.playbackStarted_) {
-      this.playbackStarted_ = true;
-    }
-
-    if (this.playbackStarted_ && buffering) {
-      this.starved_ = true;
-      this.reportEvent_('ps', {'sta': 'r'});
-    }
-
-    this.buffering_ = buffering;
+    this.setPlayerState_(buffering ?
+        cml.cmcd.CmcdPlayerState.REBUFFERING :
+        cml.cmcd.CmcdPlayerState.PLAYING);
   }
 
   /**
-   * Set the low latency.
-   *
-   * Note: low-latency content emits the same `sf` value as its non-LL
-   * counterpart (DASH → 'd', HLS → 'h'). CTA-5004 / CTA-5004-B do not
-   * define separate low-latency StreamingFormat values, and CML's
-   * CmcdStreamingFormat omits them.
+   * No-op shim retained for Player call-site back-compat. Phase 1
+   * dropped the non-spec `'ld'`/`'lh'` StreamingFormat values; CTA-5004
+   * does not define LL-specific values, so low-latency content emits
+   * `sf=d` (DASH) or `sf=h` (HLS).
    *
    * @param {boolean} lowLatency
    */
-  setLowLatency(lowLatency) {
-    this.lowLatency_ = lowLatency;
-  }
+  setLowLatency(lowLatency) {}
 
   /**
-   * Set start time of load if autoplay is enabled
+   * Set start time of load; trigger autoplay-driven start if applicable.
    *
    * @param {number} startTimeOfLoad
    */
   setStartTimeOfLoad(startTimeOfLoad) {
-    if (!this.config_ || !this.config_.enabled) {
+    if (!this.reporter_) {
       return;
     }
-
-    this.reportEvent_('ps', {'sta': 'd'});
+    this.startTimeOfLoad_ = startTimeOfLoad;
     if (this.video_ && this.video_.autoplay) {
       const playResult = this.video_.play();
       if (playResult) {
-        playResult.then(() => {
-          this.startTimeOfLoad_ = startTimeOfLoad;
-        }).catch((e) => {
+        playResult.catch(() => {
           this.startTimeOfLoad_ = 0;
         });
       }
@@ -226,45 +205,65 @@ shaka.util.CmcdManager = class {
   }
 
   /**
-   * Apply CMCD data to a request.
+   * Apply CMCD data to a request via the reporter.
    *
    * @param {!shaka.net.NetworkingEngine.RequestType} type
-   *   The request type
    * @param {!shaka.extern.Request} request
-   *   The request to apply CMCD data to
    * @param {shaka.extern.RequestContext=} context
-   *   The request context
    */
   applyRequestData(type, request, context = {}) {
-    if (!this.config_.enabled) {
+    if (!this.reporter_) {
       return;
     }
 
+    const RequestType = shaka.net.NetworkingEngine.RequestType;
+    const ObjectType = cml.cmcd.CmcdObjectType;
+
     if (request.method === 'HEAD') {
-      this.applyRequest_(request, {});
+      this.applyToRequest_(request, {});
       return;
     }
 
-    const RequestType = shaka.net.NetworkingEngine.RequestType;
-    const ObjectType = cml.cmcd.CmcdObjectType;
-
     switch (type) {
-      case RequestType.MANIFEST:
-        this.applyManifestData(request, context);
+      case RequestType.MANIFEST: {
+        if (context.type) {
+          const sf = this.getStreamFormat_(context.type);
+          if (sf && sf !== this.sf_) {
+            this.sf_ = sf;
+            this.reporter_.update(/** @type {!cml.cmcd.Cmcd} */ (
+              {sf: sf, st: this.getStreamType_()}));
+          }
+        }
+        this.applyToRequest_(request, /** @type {!cml.cmcd.Cmcd} */ ({
+          ot: ObjectType.MANIFEST,
+          su: this.lastPlayerState_ == null,
+        }));
         break;
+      }
 
-      case RequestType.SEGMENT:
-        this.applyRequestSegmentData(request, context);
+      case RequestType.SEGMENT: {
+        const data = this.getDataForSegment_(context, request.uris[0]);
+        // Track request initiation time for TTFB/TTLB derivation when
+        // the response comes back.
+        if (this.requestTimestampMap_.has(request)) {
+          this.requestTimestampMap_.delete(request);
+        }
+        this.requestTimestampMap_.set(request, Date.now());
+        this.applyToRequest_(request,
+            /** @type {!cml.cmcd.Cmcd} */ (data));
         break;
+      }
 
       case RequestType.LICENSE:
       case RequestType.SERVER_CERTIFICATE:
       case RequestType.KEY:
-        this.applyRequest_(request, {ot: ObjectType.KEY});
+        this.applyToRequest_(request, /** @type {!cml.cmcd.Cmcd} */ (
+          {ot: ObjectType.KEY}));
         break;
 
       case RequestType.TIMING:
-        this.applyRequest_(request, {ot: ObjectType.OTHER});
+        this.applyToRequest_(request, /** @type {!cml.cmcd.Cmcd} */ (
+          {ot: ObjectType.OTHER}));
         break;
     }
   }
@@ -273,202 +272,97 @@ shaka.util.CmcdManager = class {
    * Apply CMCD data to a response.
    *
    * @param {!shaka.net.NetworkingEngine.RequestType} type
-   *   The request type
    * @param {!shaka.extern.Response} response
-   *   The response to apply CMCD data to
    * @param {shaka.extern.RequestContext=} context
-   *   The request context
    */
   applyResponseData(type, response, context = {}) {
-    if (!this.hasResponseReceived_()) {
+    if (!this.reporter_ || !this.responseModeEnabled_()) {
       return;
     }
 
     const RequestType = shaka.net.NetworkingEngine.RequestType;
-
-    switch (type) {
-      case RequestType.SEGMENT:
-        this.applyResponseSegmentData(response, context);
-        break;
+    if (type !== RequestType.SEGMENT) {
+      return;
     }
-  }
 
-  /**
-   * Apply CMCD data to a manifest request.
-   *
-   * @param {!shaka.extern.Request} request
-   *   The request to apply CMCD data to
-   * @param {shaka.extern.RequestContext} context
-   *   The request context
-   */
-  applyManifestData(request, context) {
     try {
-      if (!this.config_.enabled) {
-        return;
-      }
+      const startTs = this.requestTimestampMap_.get(response.originalRequest);
+      this.requestTimestampMap_.delete(response.originalRequest);
 
-      if (context.type) {
-        this.sf_ = this.getStreamFormat_(context.type);
-      }
-
-      this.applyRequest_(request, {
-        ot: cml.cmcd.CmcdObjectType.MANIFEST,
-        su: !this.playbackStarted_,
-      });
-    } catch (error) {
-      shaka.log.warnOnce('CMCD_MANIFEST_ERROR',
-          'Could not generate manifest CMCD data.', error);
-    }
-  }
-
-  /**
-   * Apply CMCD data to a segment response
-   *
-   * @param {!shaka.extern.Response} response
-   * @param {shaka.extern.RequestContext} context
-   *   The request context
-   */
-  applyResponseSegmentData(response, context) {
-    try {
-      const data = this.getDataForSegment_(context, response.uri);
+      const url = this.removeCmcdQueryFromUri_(
+          response.originalUri || response.uri);
 
+      /** @type {!cml.cmcd.Cmcd} */
+      const data = /** @type {!cml.cmcd.Cmcd} */ ({url: url});
+      if (response.status != null) {
+        data.rc = response.status;
+      }
       if (response.originalRequest &&
           response.originalRequest.timeToFirstByte != null) {
         data.ttfb = response.originalRequest.timeToFirstByte;
       }
-
       if (response.timeMs != null) {
         data.ttlb = response.timeMs;
       }
-
-      const originalRequestUrl = response.originalUri || response.uri;
-      data.url = this.removeCmcdQueryFromUri_(
-          originalRequestUrl);
-
-      data.rc = response.status || 0;
-
-      if (this.requestTimestampMap_.has(response.originalRequest)) {
-        data.ts = this.requestTimestampMap_.get(response.originalRequest);
-        this.requestTimestampMap_.delete(response.originalRequest);
-      } else if (!data.ts) {
-        data.ts = Date.now();
+      if (startTs != null) {
+        data.ts = startTs;
       }
-
       if (response.headers && response.headers['CMSD-Static']) {
         data.cmsds = btoa(response.headers['CMSD-Static']);
       }
-
       if (response.headers && response.headers['CMSD-Dynamic']) {
         data.cmsdd = btoa(response.headers['CMSD-Dynamic']);
       }
 
-      this.applyResponse_(response, data);
-    } catch (error) {
-      shaka.log.warnOnce(
-          'CMCD_SEGMENT_ERROR',
-          'Could not generate response segment CMCD data.',
-          error,
-      );
-    }
-  }
-
-  /**
-   * Apply CMCD data to a segment request
-   *
-   * @param {!shaka.extern.Request} request
-   * @param {shaka.extern.RequestContext} context
-   *   The request context
-   */
-  applyRequestSegmentData(request, context) {
-    try {
-      if (!this.config_.enabled) {
-        return;
-      }
-
-      const data = this.getDataForSegment_(context, request.uris[0]);
-      data.ts = Date.now();
-
-      // prevents memory leaks from retries/duplicates
-      if (this.requestTimestampMap_.has(request)) {
-        this.requestTimestampMap_.delete(request);
-      }
-      this.requestTimestampMap_.set(request, data.ts);
-      this.applyRequest_(request, data);
+      // Synthesize a CML-shaped HttpResponse: CmcdReporter reads
+      // `request.url` and `status`. We pass `data` as the override so
+      // CML's auto-derivation from `resourceTiming` is bypassed
+      // (shaka measures these via `requestTimestampMap_`).
+      this.reporter_.recordResponseReceived({
+        request: {url: url},
+        status: response.status || 0,
+      }, data);
     } catch (error) {
       shaka.log.warnOnce(
-          'CMCD_SEGMENT_ERROR',
-          'Could not generate segment CMCD data.', error,
-      );
+          'CMCD_RESPONSE_ERROR',
+          'Could not apply CMCD data to response.', error);
     }
   }
 
   /**
-   * Apply CMCD data to a text request
+   * Apply CMCD data to a sidecar text request.
    *
    * @param {!shaka.extern.Request} request
    */
   applyTextData(request) {
-    try {
-      if (!this.config_.enabled) {
-        return;
-      }
-
-      this.applyRequest_(request, {
-        ot: cml.cmcd.CmcdObjectType.CAPTION,
-        su: true,
-      });
-    } catch (error) {
-      shaka.log.warnOnce('CMCD_TEXT_ERROR',
-          'Could not generate text CMCD data.', error);
-    }
-  }
-
-  /**
-   * Removes the CMCD query parameter from a URI.
-   *
-   * @param {string} uri
-   * @return {string}
-   * @private
-   */
-  removeCmcdQueryFromUri_(uri) {
-    if (!uri.includes('CMCD=')) {
-      return uri;
-    }
-
-    try {
-      const url = new URL(uri);
-      url.searchParams.delete('CMCD');
-
-      return url.toString();
-    } catch (error) {
-      shaka.log.error('Failed to parse URI for CMCD removal:', uri, error);
-      return uri;
+    if (!this.reporter_) {
+      return;
     }
+    this.applyToRequest_(request, /** @type {!cml.cmcd.Cmcd} */ ({
+      ot: cml.cmcd.CmcdObjectType.CAPTION,
+      su: true,
+    }));
   }
 
   /**
-   * Apply CMCD data to streams loaded via src=.
+   * Apply CMCD data to streams loaded via `<video src=...>`. Forces
+   * query-mode encoding regardless of configured `useHeaders`, since
+   * direct media loads cannot carry custom request headers.
    *
    * @param {string} uri
    * @param {string} mimeType
    * @return {string}
    */
   appendSrcData(uri, mimeType) {
+    if (!this.reporter_) {
+      return uri;
+    }
     try {
-      if (!this.config_.enabled) {
-        return uri;
-      }
-
-      const data = this.createData_();
+      const data = this.buildExternalUriData_();
       data.ot = this.getObjectTypeFromMimeType_(mimeType);
       data.su = true;
-
-      const query = shaka.util.CmcdManager.toQuery(
-          data,
-          shaka.util.CmcdManager.getEncodeOptions_(
-              uri, this.config_.version, cml.cmcd.CMCD_REQUEST_MODE));
-
-      return shaka.util.CmcdManager.appendQueryToUri(uri, query);
+      return cml.cmcd.appendCmcdQuery(
+          uri, data, this.encodeOptionsForUri_(uri));
     } catch (error) {
       shaka.log.warnOnce('CMCD_SRC_ERROR',
           'Could not generate src CMCD data.', error);
@@ -477,27 +371,21 @@ shaka.util.CmcdManager = class {
   }
 
   /**
-   * Apply CMCD data to side car text track uri.
+   * Apply CMCD data to a sidecar text track URI.
    *
    * @param {string} uri
    * @return {string}
    */
   appendTextTrackData(uri) {
+    if (!this.reporter_) {
+      return uri;
+    }
     try {
-      if (!this.config_.enabled) {
-        return uri;
-      }
-
-      const data = this.createData_();
+      const data = this.buildExternalUriData_();
       data.ot = cml.cmcd.CmcdObjectType.CAPTION;
       data.su = true;
-
-      const query = shaka.util.CmcdManager.toQuery(
-          data,
-          shaka.util.CmcdManager.getEncodeOptions_(
-              uri, this.config_.version, cml.cmcd.CMCD_REQUEST_MODE));
-
-      return shaka.util.CmcdManager.appendQueryToUri(uri, query);
+      return cml.cmcd.appendCmcdQuery(
+          uri, data, this.encodeOptionsForUri_(uri));
     } catch (error) {
       shaka.log.warnOnce('CMCD_TEXT_TRACK_ERROR',
           'Could not generate text track CMCD data.', error);
@@ -506,514 +394,452 @@ shaka.util.CmcdManager = class {
   }
 
   /**
-   * Set playbackPlayTime_ when the play event is triggered
+   * Construct the reporter if `enabled` is set and a video element is
+   * available. No-ops if either precondition fails.
+   *
    * @private
    */
-  onPlaybackPlay_() {
-    if (!this.playbackPlayTime_) {
-      this.playbackPlayTime_ = Date.now();
-      this.reportEvent_('ps', {'sta': 's'});
+  maybeStartReporter_() {
+    if (this.reporter_ ||
+        !this.config_ ||
+        !this.config_.enabled ||
+        !this.video_) {
+      return;
     }
+    const reporterConfig = this.toReporterConfig_(this.config_);
+    this.reporter_ = new cml.cmcd.CmcdReporter(
+        reporterConfig, this.makeRequester_());
+    this.reporter_.start();
   }
 
   /**
-   * Set playbackPlayingTime_
+   * Translate `shaka.extern.CmcdConfiguration` into
+   * `cml.cmcd.CmcdReporterConfig`. Field renames:
+   *   - `useHeaders` → `transmissionMode` enum
+   *   - `version: 1|2` → `CMCD_V1` / `CMCD_V2` constants
+   *   - top-level `targets` → `eventTargets` (Phase 3 experimental rename)
+   *   - per-target `timeInterval` → `interval`
+   *   - per-target `includeKeys` → `enabledKeys`
+   *
+   * Empty `includeKeys` is expanded to all valid keys for the version,
+   * since CML's reporter early-returns when `enabledKeys` is empty.
+   *
+   * @param {!shaka.extern.CmcdConfiguration} cfg
+   * @return {!cml.cmcd.CmcdReporterConfig}
    * @private
    */
-  onPlaybackPlaying_() {
-    if (!this.playbackPlayingTime_) {
-      this.playbackPlayingTime_ = Date.now();
+  toReporterConfig_(cfg) {
+    if (!cfg.sessionId) {
+      cfg.sessionId = window.crypto.randomUUID();
+    }
+    const includeKeys = (cfg.includeKeys && cfg.includeKeys.length) ?
+        cfg.includeKeys : this.allKeysForVersion_(cfg.version);
+
+    /** @type {!cml.cmcd.CmcdReporterConfig} */
+    const reporterConfig = /** @type {!cml.cmcd.CmcdReporterConfig} */ ({
+      sid: cfg.sessionId,
+      cid: cfg.contentId,
+      transmissionMode: cfg.useHeaders ?
+          cml.cmcd.CMCD_HEADERS : cml.cmcd.CMCD_QUERY,
+      enabledKeys: includeKeys,
+      version: cfg.version === 2 ? cml.cmcd.CMCD_V2 : cml.cmcd.CMCD_V1,
+    });
+
+    const targets = cfg.eventTargets;
+    if (targets && targets.length) {
+      reporterConfig.eventTargets = targets
+          .filter((t) => t.enabled !== false && t.url &&
+              t.events && t.events.length)
+          .map((t) => {
+            const tIncludeKeys = (t.includeKeys && t.includeKeys.length) ?
+                t.includeKeys :
+                this.allKeysForVersion_(t.version || cfg.version);
+            return {
+              url: t.url,
+              events: t.events,
+              interval: t.interval,
+              batchSize: t.batchSize,
+              enabledKeys: tIncludeKeys,
+              version: cml.cmcd.CMCD_V2,
+            };
+          });
     }
+    return reporterConfig;
   }
 
   /**
-   * Setup event listeners.
+   * @param {(number|undefined)} version
+   * @return {!Array<string>}
    * @private
    */
-  setupEventListeners_() {
-    this.eventManager_.listen(
-        this.video_, 'playing', () => {
-          this.onPlaybackPlaying_();
-          this.reportEvent_('ps', {'sta': 'p'});
-        },
-    );
-
-    // Mute/Unmute
-    this.eventManager_.listen(this.video_, 'volumechange', () => {
-      this.reportEvent_(this.video_.muted ? 'm' : 'um');
-    });
-
-    // Play
-    this.eventManager_.listen(this.video_, 'play', () => {
-      this.onPlaybackPlay_();
-    });
-
-    // Pause
-    this.eventManager_.listen(this.video_, 'pause', () => {
-      this.reportEvent_('ps', {'sta': 'a'});
-    });
-
-    // Waiting
-    this.eventManager_.listen(this.player_, 'buffering', () => {
-      this.reportEvent_('ps', {'sta': 'w'});
-    });
-
-    // Seeking
-    this.eventManager_.listen(this.video_, 'seeking', () =>
-      this.reportEvent_('ps', {'sta': 'k'}),
-    );
-
-    // Fullscreen/PiP Change (Player Expand/Collapse)
-    this.eventManager_.listen(document, 'fullscreenchange', () => {
-      const isFullScreen = !!document.fullscreenElement;
-      this.reportEvent_(isFullScreen ? 'pe' : 'pc');
-    });
-
-    const video = /** @type {HTMLVideoElement} */(this.video_);
-    if (video.webkitPresentationMode || video.webkitSupportsFullscreen) {
-      this.eventManager_.listen(video, 'webkitpresentationmodechanged', () => {
-        if (video.webkitPresentationMode) {
-          this.reportEvent_(
-            video.webkitPresentationMode !== 'inline' ?'pe' : 'pc');
-        } else if (video.webkitSupportsFullscreen) {
-          this.reportEvent_(video.webkitDisplayingFullscreen ?'pe' : 'pc');
-        }
-      });
-    }
-
-    this.eventManager_.listen(this.video_, 'enterpictureinpicture', () => {
-      this.reportEvent_('pe');
-    });
-
-    this.eventManager_.listen(this.video_, 'leavepictureinpicture', () => {
-      this.reportEvent_('pc');
-    });
-
-    if ('documentPictureInPicture' in window) {
-      this.eventManager_.listen(window.documentPictureInPicture, 'enter',
-          (e) => {
-            this.reportEvent_('pe');
-
-            const event = /** @type {DocumentPictureInPictureEvent} */(e);
-            const pipWindow = event.window;
-            this.eventManager_.listenOnce(pipWindow, 'pagehide', () => {
-              this.reportEvent_('pc');
-            });
-          });
-    }
-
-    // Background Mode
-    this.eventManager_.listen(document, 'visibilitychange', () => {
-      if (document.hidden) {
-        this.reportEvent_('b', {'bg': true});
-      } else {
-        this.reportEvent_('b');
-      }
-    });
-
-    this.eventManager_.listen(this.player_, 'complete', () => {
-      this.reportEvent_('ps', {'sta': 'e'});
-    });
+  allKeysForVersion_(version) {
+    if (version === 2 || version === cml.cmcd.CMCD_V2) {
+      return Array.from(new Set([].concat(
+          cml.cmcd.CMCD_REQUEST_KEYS,
+          cml.cmcd.CMCD_RESPONSE_KEYS,
+          cml.cmcd.CMCD_EVENT_KEYS)));
+    }
+    return [].concat(cml.cmcd.CMCD_V1_KEYS);
   }
 
   /**
-   * Sets up TimeInterval timer for CMCD 'EVENT' mode targets.
+   * Build the `requester` callback CmcdReporter uses for event-mode
+   * dispatch. Routes through NetworkingEngine so the request inherits
+   * auth / retry / filters.
+   *
+   * @return {function(!Object): !Promise<{status: number}>}
    * @private
    */
-  setupEventModeTimeInterval_() {
-    this.stopAndClearEventTimers_();
-
-    const eventTargets = this.getEventModeEnabledTargets_();
-
-    for (const target of eventTargets) {
-      let timeInterval = target.timeInterval;
+  makeRequester_() {
+    return async (cmcdReq) => {
+      const RequestType = shaka.net.NetworkingEngine.RequestType;
+      const retryParams =
+          shaka.net.NetworkingEngine.defaultRetryParameters();
+      const url = /** @type {string} */ (cmcdReq['url']);
+      const shakaReq =
+          shaka.net.NetworkingEngine.makeRequest([url], retryParams);
+      shakaReq.method =
+        /** @type {string} */ (cmcdReq['method']) || 'POST';
+      shakaReq.headers = /** @type {!Object<string, string>} */ (
+        cmcdReq['headers']) || {};
+      shakaReq.body = shaka.util.StringUtils.toUTF8(
+          /** @type {string} */ (cmcdReq['body']));
 
-      // Checking for `timeInterval === undefined` since
-      // timeInterval = 0 is used to turn TimeInterval off
-      if (timeInterval === undefined) {
-        // Phase 2 keeps shaka's historical default of 10 seconds.
-        // CML's `CMCD_DEFAULT_TIME_INTERVAL` is `30`; Phase 3 swaps to
-        // CmcdReporter, which uses the CML default natively.
-        timeInterval = 10;
-      }
-
-      if (timeInterval >= 1) {
-        const eventModeTimer = new shaka.util.Timer(
-            () => this.reportEvent_(
-                cml.cmcd.CMCD_EVENT_TIME_INTERVAL));
-        eventModeTimer.tickEvery(timeInterval);
-        this.eventTimers_.push(eventModeTimer);
+      try {
+        const networkingEngine = this.player_.getNetworkingEngine();
+        if (!networkingEngine) {
+          return {status: 0};
+        }
+        await networkingEngine.request(
+            RequestType.TIMING, shakaReq).promise;
+        return {status: 200};
+      } catch (err) {
+        return {
+          status: /** @type {number} */ (
+              (err && err['status']) ? err['status'] : 0),
+        };
       }
-    }
+    };
   }
 
   /**
-   * Stops and clears all the event timers for timeInterval
+   * Player-state deduplication: skip the update + recordEvent pair if
+   * the new state is identical to the last-emitted one. Without this,
+   * `<video>` events can fire repeatedly on stable states (e.g.,
+   * `playing` after every minor stall) and spam the reporter.
+   *
+   * @param {!cml.cmcd.CmcdPlayerState} state
    * @private
    */
-  stopAndClearEventTimers_() {
-    if (this.eventTimers_) {
-      for (const timer of this.eventTimers_) {
-        timer.stop();
-      }
+  setPlayerState_(state) {
+    if (!this.reporter_ || this.lastPlayerState_ === state) {
+      return;
     }
-    this.eventTimers_ = [];
+    this.lastPlayerState_ = state;
+    this.reporter_.update(/** @type {!cml.cmcd.Cmcd} */ ({sta: state}));
+    this.reporter_.recordEvent(cml.cmcd.CmcdEventType.PLAY_STATE);
   }
 
   /**
-   * @return {!Array<shaka.extern.CmcdTarget>}
+   * Push a CMCD-applied request through `createRequestReport`. Mutates
+   * `request` in place to preserve shaka's existing applyRequestData
+   * contract.
+   *
+   * @param {!shaka.extern.Request} request
+   * @param {!cml.cmcd.Cmcd} data
    * @private
    */
-  getEventModeEnabledTargets_() {
-    const targets = this.config_.targets;
-    if (!targets) {
-      return [];
+  applyToRequest_(request, data) {
+    try {
+      /** @type {!Object<string, *>} */
+      const cmlReq = {
+        url: request.uris[0],
+        headers: Object.assign({}, request.headers || {}),
+        customData: {},
+      };
+      const report = /** @type {!Object<string, *>} */ (
+        this.reporter_.createRequestReport(cmlReq, data));
+
+      // Headers mode: copy CMCD-* headers back onto the request.
+      const reportHeaders = /** @type {!Object<string, string>} */ (
+        report['headers'] || {});
+      const inputHeaderCount =
+          Object.keys(cmlReq.headers).length;
+      const newHeaderCount = Object.keys(reportHeaders).length;
+      if (newHeaderCount > inputHeaderCount) {
+        if (!request.headers) {
+          request.headers = {};
+        }
+        for (const key of Object.keys(reportHeaders)) {
+          if (!(key in cmlReq.headers)) {
+            request.headers[key] = reportHeaders[key];
+          }
+        }
+      }
+
+      // Query mode: report.url has CMCD appended. Apply to all URIs in
+      // the retry list (alternates carry identical CMCD).
+      const reportUrl = /** @type {string} */ (report['url']);
+      if (reportUrl && reportUrl !== cmlReq.url) {
+        if (request.uris.length === 1) {
+          request.uris = [reportUrl];
+        } else {
+          let cmcdParam = null;
+          try {
+            const u = new URL(reportUrl);
+            cmcdParam = u.searchParams.get('CMCD');
+          } catch (e) {
+            // First URI not parsable; leave list untouched.
+          }
+          if (cmcdParam != null) {
+            const param = cmcdParam;
+            request.uris = request.uris.map((uri) => {
+              if (uri.includes('offline:')) {
+                return uri;
+              }
+              try {
+                const uu = new URL(uri);
+                uu.searchParams.set('CMCD', param);
+                return uu.toString();
+              } catch (e) {
+                return uri;
+              }
+            });
+          }
+        }
+      }
+    } catch (error) {
+      shaka.log.warnOnce('CMCD_REQUEST_ERROR',
+          'Could not apply CMCD data to request.', error);
     }
-    return targets.filter(
-        (target) => target.enabled);
   }
 
   /**
+   * Whether any configured `eventTarget` subscribes to the `'rr'`
+   * (response-received) event. Saves recording response-received calls
+   * into the reporter when no target consumes them.
+   *
    * @return {boolean}
    * @private
    */
-  hasResponseReceived_() {
-    const targets = this.config_.targets;
+  responseModeEnabled_() {
+    const targets = this.config_.eventTargets;
     if (!targets) {
       return false;
     }
-    return targets.some(
-        (target) => target.events &&
-          target.events.includes('rr') && target.enabled);
+    return targets.some((target) =>
+      target.enabled !== false &&
+      target.events &&
+      target.events.includes(cml.cmcd.CmcdEventType.RESPONSE_RECEIVED));
   }
 
   /**
-   * Create baseline CMCD data
+   * Persistent CMCD baseline used by `appendSrcData` /
+   * `appendTextTrackData`. These bypass the reporter (browsers can't
+   * observe headers for direct media loads, so we always force query
+   * mode regardless of configured `useHeaders`); `sn` is omitted since
+   * the reporter's per-target counters don't apply.
    *
-   * @return {CmcdData}
+   * @return {!cml.cmcd.Cmcd}
    * @private
    */
-  createData_() {
-    if (!this.config_.sessionId) {
-      this.config_.sessionId = window.crypto.randomUUID();
-    }
-    return {
+  buildExternalUriData_() {
+    return /** @type {!cml.cmcd.Cmcd} */ ({
       v: this.config_.version,
-      sf: this.sf_,
       sid: this.config_.sessionId,
       cid: this.config_.contentId,
+      sf: this.sf_,
       mtp: this.player_.getBandwidthEstimate() / 1000,
-    };
-  }
-
-  /**
-   * @param {string} eventType
-   * @param {CmcdData} extraData
-   * @private
-   */
-  reportEvent_(eventType, extraData = {}) {
-    const baseEventData = {
-      e: eventType,
-      ts: Date.now(),
-    };
-
-    const eventData = Object.assign(baseEventData, extraData);
-    const rawOutput = this.getGenericData_(eventData,
-        cml.cmcd.CmcdReportingMode.EVENT);
-
-    const version = this.config_.version;
-    const targets = this.config_.targets;
-    if (version < cml.cmcd.CMCD_V2 || !targets) {
-      return;
-    }
-
-    const eventTargets = this.getEventModeEnabledTargets_();
-
-    // CML's event-mode encoder accepts the union of request, response,
-    // and event keys (see `cml.cmcd.isCmcdEventKey`). Mirror that here
-    // for `includeKeys` validation so users can specify keys from any
-    // of the three buckets.
-    const allowedKeys = Array.from(new Set([
-      ...cml.cmcd.CMCD_REQUEST_KEYS,
-      ...cml.cmcd.CMCD_RESPONSE_KEYS,
-      ...cml.cmcd.CMCD_EVENT_KEYS,
-    ]));
-
-    for (const target of eventTargets) {
-      const includeKeys = target.includeKeys || [];
-      const allowedKeysEventMode = this.checkValidKeys_(
-          includeKeys,
-          allowedKeys,
-          cml.cmcd.CmcdReportingMode.EVENT,
-      );
-
-      // `ts` and `e` are required for every event report; CML's
-      // `prepareCmcdData` adds them automatically, but shaka pre-
-      // filters via `filterKeys_` before encoding, so they must
-      // survive the filter.
-      if (!allowedKeysEventMode.includes('ts')) {
-        allowedKeysEventMode.push('ts');
-      }
-
-      if (!allowedKeysEventMode.includes('e')) {
-        allowedKeysEventMode.push('e');
-      }
-
-      const targetKey = this.getCmcdTargetHash_(target);
-      if (!this.cmcdSequenceNumbers_[targetKey]) {
-        this.cmcdSequenceNumbers_[targetKey] = {request: 1, response: 1};
-      }
-
-      rawOutput.sn = this.cmcdSequenceNumbers_[targetKey].response++;
-
-      const output = this.filterKeys_(rawOutput, allowedKeysEventMode);
-
-      const includeEvents = target.events || [];
-
-      if (!this.isValidEvent_(includeEvents, output)) {
-        continue;
-      }
-
-      this.sendCmcdRequest_(output, target);
-    }
-  }
-
-  /**
-   * Apply CMCD data to a request.
-   *
-   * @param {!shaka.extern.Request} request The request to apply CMCD data to
-   * @param {!CmcdData} data The data object
-   * @private
-   */
-  applyRequest_(request, data) {
-    if (!this.config_.enabled) {
-      return;
-    }
-
-    const rawOutput = this.getGenericData_(
-        data, cml.cmcd.CmcdReportingMode.REQUEST,
-    );
-
-    const requestTargetConfig = {
-      mode: cml.cmcd.CmcdReportingMode.REQUEST,
-      useHeaders: this.config_.useHeaders,
-      includeKeys: this.config_.includeKeys || [],
-    };
-
-    const targetKey = this.getCmcdTargetHash_(requestTargetConfig);
-
-    if (!this.cmcdSequenceNumbers_[targetKey]) {
-      this.cmcdSequenceNumbers_[targetKey] = {request: 1, response: 1};
-    }
-
-    rawOutput.sn = this.cmcdSequenceNumbers_[targetKey].request++;
-
-    const includeKeys = this.config_.includeKeys || [];
-    const version = this.config_.version;
-    const allowedKeys = (version == cml.cmcd.CMCD_V2) ?
-        Array.from(cml.cmcd.CMCD_REQUEST_KEYS) :
-        cml.cmcd.CMCD_V1_KEYS;
-
-    const allowedKeysRequestMode = this.checkValidKeys_(
-        includeKeys,
-        allowedKeys,
-        cml.cmcd.CmcdReportingMode.REQUEST,
-    );
-
-    const output = this.filterKeys_(rawOutput, allowedKeysRequestMode);
-
-    this.applyCmcdDataToRequest_(output, request, this.config_.useHeaders);
+    });
   }
 
   /**
-   * Apply CMCD data to a response.
+   * Encode options for direct `cml.cmcd.appendCmcdQuery` calls
+   * (`appendSrcData`, `appendTextTrackData`). `baseUrl` lets CML
+   * relativize `nor` URLs root-relative; `version` filters keys per
+   * spec; `reportingMode = REQUEST` pins the request-mode key filter.
    *
-   * @param {!shaka.extern.Response} response The request to apply CMCD data to
-   * @param {!CmcdData} data The data object
+   * @param {string} uri
+   * @return {!cml.cmcd.CmcdEncodeOptions}
    * @private
    */
-  applyResponse_(response, data) {
-    this.reportEvent_('rr', data);
+  encodeOptionsForUri_(uri) {
+    /** @type {!cml.cmcd.CmcdEncodeOptions} */
+    const options = /** @type {!cml.cmcd.CmcdEncodeOptions} */ ({});
+    if (uri && !uri.includes('offline:')) {
+      try {
+        options.baseUrl = new URL(uri).origin;
+      } catch (e) {
+        // Unparsable URI; CML's `nor` formatter passes values through
+        // unchanged when baseUrl is absent.
+      }
+    }
+    if (this.config_.version != null) {
+      options.version = this.config_.version;
+    }
+    options.reportingMode = cml.cmcd.CMCD_REQUEST_MODE;
+    return options;
   }
 
   /**
-   * Creates and sends a new, out-of-band request to a CMCD endpoint.
-   * This is used for event and response reporting.
+   * Wire `<video>` and Player events to reporter calls per spec
+   * § "Player state ↔ reporter state mapping".
    *
-   * @param {!CmcdData} cmcdData The CMCD data to send.
-   * @param {shaka.extern.CmcdTarget} target The CMCD target configuration.
-   * @param {shaka.extern.Response=} response Optional response object
-   *  to update, used by the applyResponse flow.
    * @private
    */
-  sendCmcdRequest_(cmcdData, target, response) {
-    const retryParams = shaka.net.NetworkingEngine.defaultRetryParameters();
-    let request = null;
-    const baseURL = target.url;
-    // Event-mode reports (event/response) skip baseUrl: the collector
-    // URL is generally a different origin from segment URLs, so passing
-    // it would not relativize `nor` the way old shaka did. Match CML's
-    // reporter, which omits baseUrl in event mode.
-    const encodeOptions = shaka.util.CmcdManager.getEncodeOptions_(
-        undefined, this.config_.version, cml.cmcd.CMCD_EVENT_MODE);
-
-    if (target.useHeaders) {
-      const headers =
-          shaka.util.CmcdManager.toHeaders(cmcdData, encodeOptions);
-      if (!Object.keys(headers).length) {
+  setupEventListeners_() {
+    const PlayerState = cml.cmcd.CmcdPlayerState;
+    const EventType = cml.cmcd.CmcdEventType;
+
+    this.eventManager_.listen(this.video_, 'pause', () => {
+      this.setPlayerState_(PlayerState.PAUSED);
+    });
+
+    this.eventManager_.listen(this.video_, 'playing', () => {
+      this.setPlayerState_(PlayerState.PLAYING);
+    });
+
+    this.eventManager_.listen(this.video_, 'seeking', () => {
+      this.setPlayerState_(PlayerState.SEEKING);
+    });
+
+    this.eventManager_.listen(this.video_, 'ended', () => {
+      this.setPlayerState_(PlayerState.ENDED);
+    });
+
+    this.eventManager_.listen(this.video_, 'volumechange', () => {
+      if (!this.reporter_ || !this.video_) {
         return;
       }
-      if (response) {
-        Object.assign(response.headers, headers);
-      }
-      request = shaka.net.NetworkingEngine.makeRequest([baseURL], retryParams);
-      Object.assign(request.headers, headers);
-    } else {
-      const queryString =
-          shaka.util.CmcdManager.toQuery(cmcdData, encodeOptions);
-      if (!queryString) {
+      const muted = this.video_.muted;
+      // Mute state isn't a persistent CMCD wire key (CTA-5004-B uses
+      // m/um events, not a `muted` data field). Emit the event only.
+      this.reporter_.recordEvent(muted ? EventType.MUTE : EventType.UNMUTE);
+    });
+
+    this.eventManager_.listen(this.player_, 'buffering', (e) => {
+      const buffering = /** @type {!Object} */ (e)['buffering'];
+      this.setPlayerState_(buffering ?
+          PlayerState.REBUFFERING : PlayerState.PLAYING);
+    });
+
+    this.eventManager_.listen(this.player_, 'adaptation', () => {
+      if (!this.reporter_ || !this.player_) {
         return;
       }
-      const finalUri = shaka.util.CmcdManager.appendQueryToUri(
-          baseURL, queryString);
-      if (response) {
-        response.uri = finalUri;
+      const variants = this.player_.getVariantTracks();
+      const active = variants.find((t) => t.active);
+      if (active && active.bandwidth) {
+        this.reporter_.update(/** @type {!cml.cmcd.Cmcd} */ (
+          {br: [active.bandwidth / 1000]}));
+        this.reporter_.recordEvent(EventType.BITRATE_CHANGE);
       }
-      request = shaka.net.NetworkingEngine.makeRequest([finalUri], retryParams);
-    }
-    const requestType = shaka.net.NetworkingEngine.RequestType.CMCD;
-    const networkingEngine = this.player_.getNetworkingEngine();
-    networkingEngine.request(requestType, request);
-  }
+    });
 
-  /**
-   * Modifies an existing request object by adding CMCD data to it.
-   *
-   * @param {!CmcdData} output The CMCD data to apply.
-   * @param {!shaka.extern.Request} request The request object to modify.
-   * @param {boolean} useHeaders Whether to use headers or query parameters.
-   * @private
-   */
-  applyCmcdDataToRequest_(output, request, useHeaders) {
-    const encodeOptions = shaka.util.CmcdManager.getEncodeOptions_(
-        request.uris[0],
-        this.config_.version,
-        cml.cmcd.CMCD_REQUEST_MODE);
-    if (useHeaders) {
-      const headers = shaka.util.CmcdManager.toHeaders(output, encodeOptions);
-      if (!Object.keys(headers).length) {
-        return;
+    this.eventManager_.listen(this.player_, 'error', () => {
+      this.setPlayerState_(PlayerState.FATAL_ERROR);
+      if (this.reporter_) {
+        this.reporter_.recordEvent(EventType.ERROR);
       }
+    });
 
-      Object.assign(request.headers, headers);
-    } else {
-      const query = shaka.util.CmcdManager.toQuery(output, encodeOptions);
-      if (!query) {
+    this.eventManager_.listen(document, 'fullscreenchange', () => {
+      if (!this.reporter_) {
         return;
       }
+      const isFullscreen = !!document.fullscreenElement;
+      this.reporter_.recordEvent(isFullscreen ?
+          EventType.PLAYER_EXPAND : EventType.PLAYER_COLLAPSE);
+    });
 
-      request.uris = request.uris.map((uri) => {
-        return shaka.util.CmcdManager.appendQueryToUri(uri, query);
+    const video = /** @type {HTMLVideoElement} */ (this.video_);
+    if (video.webkitPresentationMode || video.webkitSupportsFullscreen) {
+      this.eventManager_.listen(video, 'webkitpresentationmodechanged', () => {
+        if (!this.reporter_) {
+          return;
+        }
+        if (video.webkitPresentationMode) {
+          this.reporter_.recordEvent(
+              video.webkitPresentationMode !== 'inline' ?
+                  EventType.PLAYER_EXPAND : EventType.PLAYER_COLLAPSE);
+        } else if (video.webkitSupportsFullscreen) {
+          this.reporter_.recordEvent(
+              video.webkitDisplayingFullscreen ?
+                  EventType.PLAYER_EXPAND : EventType.PLAYER_COLLAPSE);
+        }
       });
     }
 
-    // Clean up timestamp entry after CMCD data has been attached to request
-    if (!this.hasResponseReceived_() &&
-          this.requestTimestampMap_.has(request)) {
-      this.requestTimestampMap_.delete(request);
-    }
-  }
-
-  /**
-   * Checks if the keys in `includeKeys` are valid against a list of
-   * `allowedKeys`. It logs an error for any invalid key and returns a new array
-   * containing only the valid keys. If `includeKeys` is empty or not provided,
-   * it returns all `allowedKeys`.
-   *
-   * @param {Array<string>} includeKeys Keys to validate.
-   * @param {Array<string>} allowedKeys The list of allowed keys.
-   * @param {string} mode Mode ('query', 'header' or 'event') for error logging.
-   *
-   * @return {Array<string>} A new array containing only the valid keys.
-   * @private
-   */
-  checkValidKeys_(includeKeys, allowedKeys, mode) {
-    if (!includeKeys || includeKeys.length === 0) {
-      return allowedKeys;
-    }
+    this.eventManager_.listen(this.video_, 'enterpictureinpicture', () => {
+      if (this.reporter_) {
+        this.reporter_.recordEvent(EventType.PLAYER_EXPAND);
+      }
+    });
 
-    for (const key of includeKeys) {
-      if (!allowedKeys.includes(key)) {
-        shaka.log.error(`CMCD Key "${key}" is not allowed for ${mode} mode`);
+    this.eventManager_.listen(this.video_, 'leavepictureinpicture', () => {
+      if (this.reporter_) {
+        this.reporter_.recordEvent(EventType.PLAYER_COLLAPSE);
       }
+    });
+
+    if ('documentPictureInPicture' in window) {
+      this.eventManager_.listen(window.documentPictureInPicture, 'enter',
+          (e) => {
+            if (!this.reporter_) {
+              return;
+            }
+            this.reporter_.recordEvent(EventType.PLAYER_EXPAND);
+            const event = /** @type {DocumentPictureInPictureEvent} */ (e);
+            const pipWindow = event.window;
+            this.eventManager_.listenOnce(pipWindow, 'pagehide', () => {
+              if (this.reporter_) {
+                this.reporter_.recordEvent(EventType.PLAYER_COLLAPSE);
+              }
+            });
+          });
     }
 
-    includeKeys = includeKeys.filter((key) =>
-      allowedKeys.includes(key),
-    );
+    this.eventManager_.listen(document, 'visibilitychange', () => {
+      if (!this.reporter_) {
+        return;
+      }
+      const backgrounded = document.hidden;
+      this.reporter_.update(/** @type {!cml.cmcd.Cmcd} */ (
+        {bg: backgrounded}));
+      this.reporter_.recordEvent(EventType.BACKGROUNDED_MODE);
+    });
 
-    return includeKeys;
+    this.eventManager_.listen(this.player_, 'complete', () => {
+      this.setPlayerState_(PlayerState.ENDED);
+    });
   }
 
   /**
-   * Filter the CMCD data object to include only the keys specified in the
-   * configuration.
-   *
-   * @param {CmcdData} data
-   * @param {Array<string>} includeKeys
+   * Strip the CMCD query parameter from a URL.
    *
-   * @return {CmcdData}
-   * @private
-   */
-  filterKeys_(data, includeKeys) {
-    return Object.keys(data).reduce((acc, key) => {
-      if (includeKeys.includes(key)) {
-        acc[key] = data[key];
-      }
-      return acc;
-    }, {});
-  }
-
-  /**
-   * @param {Array<string>} includeEvents
-   * @param {CmcdData} data
+   * @param {string} uri
+   * @return {string}
    * @private
-   *
-   * @return {boolean}
    */
-  isValidEvent_(includeEvents, data) {
-    const allowedEvents = Object.values(cml.cmcd.CmcdEventType);
-    const allowedPlayStates = Object.values(cml.cmcd.CmcdPlayerState);
-
-    const event = data['e'];
-    const playState = data['sta'];
-
-    if (event) {
-      if (!allowedEvents.includes(event)) {
-        return false;
-      }
-
-      if (event === 'ps') {
-        if (!playState || !allowedPlayStates.includes(playState)) {
-          return false;
-        }
-      }
-
-      if (includeEvents && includeEvents.length > 0 &&
-          !includeEvents.includes(event)) {
-        return false;
-      }
+  removeCmcdQueryFromUri_(uri) {
+    if (!uri.includes('CMCD=')) {
+      return uri;
+    }
+    try {
+      const url = new URL(uri);
+      url.searchParams.delete('CMCD');
+      return url.toString();
+    } catch (error) {
+      shaka.log.error('Failed to parse URI for CMCD removal:', uri, error);
+      return uri;
     }
-
-    return true;
   }
 
   /**
-   * The CMCD object type.
+   * Map a shaka request context to a CMCD object type.
    *
    * @param {shaka.extern.RequestContext} context
-   *   The request context
-   * @return {cml.cmcd.CmcdObjectType|undefined}
+   * @return {(cml.cmcd.CmcdObjectType|undefined)}
    * @private
    */
   getObjectType_(context) {
@@ -1021,40 +847,33 @@ shaka.util.CmcdManager = class {
         shaka.net.NetworkingEngine.AdvancedRequestType.INIT_SEGMENT) {
       return cml.cmcd.CmcdObjectType.INIT;
     }
-
     const stream = context.stream;
-
     if (!stream) {
       return undefined;
     }
-
     const type = stream.type;
-
     if (type == 'video') {
       if (stream.codecs && stream.codecs.includes(',')) {
         return cml.cmcd.CmcdObjectType.MUXED;
       }
       return cml.cmcd.CmcdObjectType.VIDEO;
     }
-
     if (type == 'audio') {
       return cml.cmcd.CmcdObjectType.AUDIO;
     }
-
     if (type == 'text') {
       if (stream.mimeType === 'application/mp4') {
         return cml.cmcd.CmcdObjectType.TIMED_TEXT;
       }
       return cml.cmcd.CmcdObjectType.CAPTION;
     }
-
     return undefined;
   }
 
   /**
-   * The CMCD object type from mimeType.
+   * Map a mimeType to a CMCD object type. Used by `appendSrcData`.
    *
-   * @param {!string} mimeType
+   * @param {string} mimeType
    * @return {(cml.cmcd.CmcdObjectType|undefined)}
    * @private
    */
@@ -1088,28 +907,7 @@ shaka.util.CmcdManager = class {
   }
 
   /**
-   * Creates a stable string key from a configuration object.
-   * This is used to uniquely identify a CMCD target.
-   *
-   * @param {!Object} obj The object to hash.
-   * @return {string}
-   * @private
-   */
-  getCmcdTargetHash_(obj) {
-    const sortedObj = Object.keys(obj).sort().reduce(
-        (acc, key) => {
-          if (key !== 'enabled') {
-            acc[key] = obj[key];
-          }
-          return acc;
-        },
-        {},
-    );
-    return JSON.stringify(sortedObj);
-  }
-
-  /**
-   * Get the buffer length for a media type in milliseconds
+   * Buffer length in milliseconds for a media type.
    *
    * @param {string} type
    * @return {number}
@@ -1117,23 +915,19 @@ shaka.util.CmcdManager = class {
    */
   getBufferLength_(type) {
     const ranges = this.player_.getBufferedInfo()[type];
-
     if (!ranges.length) {
       return NaN;
     }
-
     const start = this.getCurrentTime_();
     const range = ranges.find((r) => r.start <= start && r.end >= start);
-
     if (!range) {
       return NaN;
     }
-
     return (range.end - start) * 1000;
   }
 
   /**
-   * Get the remaining buffer length for a media type in milliseconds
+   * Remaining buffer length in milliseconds.
    *
    * @param {string} type
    * @return {number}
@@ -1141,39 +935,19 @@ shaka.util.CmcdManager = class {
    */
   getRemainingBufferLength_(type) {
     const ranges = this.player_.getBufferedInfo()[type];
-
     if (!ranges.length) {
       return 0;
     }
-
     const start = this.getCurrentTime_();
     const range = ranges.find((r) => r.start <= start && r.end >= start);
-
     if (!range) {
       return 0;
     }
-
     return (range.end - start) * 1000;
   }
 
   /**
-   * Calculate measured start delay
-   *
-   * @return {number|undefined}
-   * @private
-   */
-  calculateMSD_() {
-    if (this.playbackPlayingTime_ &&
-        this.playbackPlayTime_) {
-      const startTime = this.startTimeOfLoad_ || this.playbackPlayTime_;
-      return this.playbackPlayingTime_ - startTime;
-    }
-    return undefined;
-  }
-
-
-  /**
-   * Calculate requested maximum throughput
+   * Computed `rtp` (requested maximum throughput) for a segment.
    *
    * @param {shaka.extern.Stream} stream
    * @param {shaka.media.SegmentReference} segment
@@ -1189,58 +963,45 @@ shaka.util.CmcdManager = class {
       return NaN;
     }
     const segmentDuration = segment.endTime - segment.startTime;
-    // Calculate file size in kilobits
     const segmentSize = bandwidth * segmentDuration / 1000;
-    // Calculate time available to load file in seconds
     const timeToLoad = (currentBufferLevel / playbackRate) / 1000;
-    // Calculate the exact bandwidth required
     const minBandwidth = segmentSize / timeToLoad;
-    // Include a safety buffer
     return minBandwidth * this.config_.rtpSafetyFactor;
   }
 
   /**
-   * Get the stream format
+   * Resolve `sf` from the manifest-parser advanced-request type.
    *
    * @param {shaka.net.NetworkingEngine.AdvancedRequestType} type
-   *   The request's advanced type
    * @return {(cml.cmcd.CmcdStreamingFormat|undefined)}
    * @private
    */
   getStreamFormat_(type) {
     const AdvancedRequestType = shaka.net.NetworkingEngine.AdvancedRequestType;
-
     switch (type) {
       case AdvancedRequestType.MPD:
         return cml.cmcd.CmcdStreamingFormat.DASH;
-
       case AdvancedRequestType.MASTER_PLAYLIST:
       case AdvancedRequestType.MEDIA_PLAYLIST:
         return cml.cmcd.CmcdStreamingFormat.HLS;
     }
-
     return undefined;
   }
 
   /**
-   * Get the stream type
-   *
    * @return {cml.cmcd.CmcdStreamType}
    * @private
    */
   getStreamType_() {
-    const isLive = this.player_.isLive();
-    if (isLive) {
-      return cml.cmcd.CmcdStreamType.LIVE;
-    } else {
-      return cml.cmcd.CmcdStreamType.VOD;
-    }
+    return this.player_.isLive() ?
+        cml.cmcd.CmcdStreamType.LIVE :
+        cml.cmcd.CmcdStreamType.VOD;
   }
 
   /**
-   * Get the highest bandwidth for a given type.
+   * Top-bandwidth value across variants for a given object type.
    *
-   * @param {cml.cmcd.CmcdObjectType|undefined} type
+   * @param {(cml.cmcd.CmcdObjectType|undefined)} type
    * @return {number}
    * @private
    */
@@ -1249,77 +1010,72 @@ shaka.util.CmcdManager = class {
     if (!variants.length) {
       return NaN;
     }
-
     let top = variants[0];
-
     for (const variant of variants) {
       if (variant.type === 'variant' && variant.bandwidth > top.bandwidth) {
         top = variant;
       }
     }
-
     const ObjectType = cml.cmcd.CmcdObjectType;
-
     switch (type) {
       case ObjectType.VIDEO:
         return top.videoBandwidth || NaN;
-
       case ObjectType.AUDIO:
         return top.audioBandwidth || NaN;
-
       default:
         return top.bandwidth;
     }
   }
 
   /**
-   * Get CMCD data for a segment.
+   * Build the per-segment CMCD payload from shaka's request context.
    *
    * @param {shaka.extern.RequestContext} context
-   *   The request context
    * @param {?string} requestUri
-   * @return {!CmcdData}
+   * @return {!Object<string, *>}
    * @private
    */
   getDataForSegment_(context, requestUri) {
     const segment = context.segment;
-
     let duration = 0;
     if (segment) {
       duration = segment.endTime - segment.startTime;
     }
 
+    /** @type {!Object<string, *>} */
     const data = {
       d: duration * 1000,
       st: this.getStreamType_(),
     };
-
-    data.ot = this.getObjectType_(context);
+    data['ot'] = this.getObjectType_(context);
 
     const ObjectType = cml.cmcd.CmcdObjectType;
-    const isMedia = data.ot === ObjectType.VIDEO ||
-        data.ot === ObjectType.AUDIO ||
-        data.ot === ObjectType.MUXED ||
-        data.ot === ObjectType.TIMED_TEXT;
+    const isMedia = data['ot'] === ObjectType.VIDEO ||
+        data['ot'] === ObjectType.AUDIO ||
+        data['ot'] === ObjectType.MUXED ||
+        data['ot'] === ObjectType.TIMED_TEXT;
 
     const stream = context.stream;
     if (stream) {
       const playbackRate = this.player_.getPlaybackRate();
       if (isMedia) {
-        data.bl = this.getBufferLength_(stream.type);
-        if (data.ot !== ObjectType.TIMED_TEXT) {
+        const bl = this.getBufferLength_(stream.type);
+        if (Number.isFinite(bl)) {
+          data['bl'] = bl;
+        }
+        if (data['ot'] !== ObjectType.TIMED_TEXT) {
           const remainingBufferLength =
               this.getRemainingBufferLength_(stream.type);
           if (playbackRate) {
-            data.dl = remainingBufferLength / Math.abs(playbackRate);
+            data['dl'] = remainingBufferLength / Math.abs(playbackRate);
           } else {
-            data.dl = remainingBufferLength;
+            data['dl'] = remainingBufferLength;
           }
         }
       }
 
       if (stream.bandwidth) {
-        data.br = stream.bandwidth / 1000;
+        data['br'] = stream.bandwidth / 1000;
       }
 
       if (stream.segmentIndex && segment) {
@@ -1331,7 +1087,7 @@ shaka.util.CmcdManager = class {
           if (nextSegment && nextSegment != segment) {
             if (requestUri && !shaka.util.ArrayUtils.equal(
                 segment.getUris(), nextSegment.getUris())) {
-              data.nor = nextSegment.getUris()[0];
+              data['nor'] = nextSegment.getUris()[0];
             }
             if ((nextSegment.startByte || nextSegment.endByte) &&
                 (segment.startByte != nextSegment.startByte ||
@@ -1340,234 +1096,52 @@ shaka.util.CmcdManager = class {
               if (nextSegment.endByte) {
                 range += nextSegment.endByte;
               }
-              data.nrr = range;
+              data['nrr'] = range;
             }
           }
         }
         const rtp = this.calculateRtp_(stream, segment);
-        if (!isNaN(rtp)) {
-          data.rtp = rtp;
+        if (Number.isFinite(rtp)) {
+          data['rtp'] = rtp;
         }
       }
     }
 
-    if (isMedia && data.ot !== ObjectType.TIMED_TEXT) {
-      data.tb = this.getTopBandwidth_(data.ot) / 1000;
-    }
-
-    return data;
-  }
-
-  /**
-   * Get player time.
-   *
-   * @private
-   * @return {number}
-   */
-  getCurrentTime_() {
-    return this.video_ ? this.video_.currentTime : 0;
-  }
-
-  /**
-   * Get generic CMCD data.
-   *
-   * @param {!CmcdData} data The data object
-   * @param {!cml.cmcd.CmcdReportingMode} mode
-   * @return {!CmcdData}
-   * @private
-   */
-  getGenericData_(data, mode) {
-    // Apply baseline data
-    Object.assign(data, this.createData_());
-
-    data.pr = this.player_.getPlaybackRate();
-
-    const isVideo = data.ot === cml.cmcd.CmcdObjectType.VIDEO ||
-        data.ot === cml.cmcd.CmcdObjectType.MUXED;
-
-    if (this.starved_ && isVideo) {
-      data.bs = true;
-      data.su = true;
-      this.starved_ = false;
-    }
-
-    if (data.su == null) {
-      data.su = this.buffering_;
+    if (isMedia && data['ot'] !== ObjectType.TIMED_TEXT) {
+      const tb = this.getTopBandwidth_(
+          /** @type {(cml.cmcd.CmcdObjectType|undefined)} */ (
+            data['ot'])) / 1000;
+      if (Number.isFinite(tb)) {
+        data['tb'] = tb;
+      }
     }
 
     if (this.player_.isLive()) {
       const liveLatency = this.player_.getLiveLatency();
-      data.ltc = liveLatency || undefined;
-    }
-
-    if (document.hidden) {
-      data.bg = true;
-    }
-
-    const msd = this.calculateMSD_();
-    if (msd != undefined && !this.msdSent_[mode]) {
-      data.msd = msd;
-      this.msdSent_[mode] = true;
-    }
-
-    return data;
-  }
-
-  /**
-   * Serialize a CMCD data object according to the rules defined in the
-   * section 3.2 of
-   * [CTA-5004](https://cdn.cta.tech/cta/media/media/resources/standards/pdfs/cta-5004-final.pdf).
-   *
-   * @param {CmcdData} data The CMCD data object
-   * @param {cml.cmcd.CmcdEncodeOptions=} options Encoding options
-   *   (e.g. `baseUrl` to root-relativize `nor` URLs).
-   * @return {string}
-   */
-  static serialize(data, options) {
-    return cml.cmcd.encodeCmcd(
-        /** @type {cml.cmcd.Cmcd} */ (data), options);
-  }
-
-  /**
-   * Convert a CMCD data object to request headers according to the rules
-   * defined in the section 2.1 and 3.2 of
-   * [CTA-5004](https://cdn.cta.tech/cta/media/media/resources/standards/pdfs/cta-5004-final.pdf).
-   *
-   * Two-step encode (rather than calling `serialize` per shard):
-   *   1. Run CML's `prepareCmcdData` once on the full input so version
-   *      auto-add, key filtering, and per-key formatters (incl. the
-   *      `nor` baseUrl rewrite) all apply once.
-   *   2. Bucket the prepared keys into shaka's four shards, then call
-   *      `encodePreparedCmcd` per shard so each shard SFV-encodes
-   *      without re-preparing — which would otherwise re-add `v=2` to
-   *      every non-empty shard.
-   *
-   * @param {CmcdData} data The CMCD data object
-   * @param {cml.cmcd.CmcdEncodeOptions=} options Encoding options
-   *   (e.g. `baseUrl` to root-relativize `nor` URLs).
-   * @return {!Object}
-   */
-  static toHeaders(data, options) {
-    const prepared = cml.cmcd.prepareCmcdData(
-        /** @type {!Object<string, *>} */ (data), options);
-    const headers = {};
-    const headerNames = ['Object', 'Request', 'Session', 'Status'];
-    const headerGroups = [{}, {}, {}, {}];
-    const headerMap = {
-      br: 0, d: 0, ot: 0, tb: 0, url: 0,
-      bl: 1, dl: 1, mtp: 1, nor: 1, nrr: 1, su: 1, ltc: 1, ttfb: 1, ttlb: 1,
-      ts: 1, rc: 1, cmsdd: 1, cmsds: 1, sn: 1,
-      cid: 2, pr: 2, sf: 2, sid: 2, st: 2, v: 2, msd: 2,
-      bs: 3, rtp: 3, bg: 3,
-    };
-
-    for (const key of Object.keys(prepared)) {
-      // Unmapped fields are mapped to the Request header.
-      const index = (headerMap[key] != null) ? headerMap[key] : 1;
-      headerGroups[index][key] = prepared[key];
-    }
-
-    for (let i = 0; i < headerGroups.length; i++) {
-      const value = cml.cmcd.encodePreparedCmcd(
-          /** @type {!cml.cmcd.Cmcd} */ (headerGroups[i]));
-      if (value) {
-        headers[`CMCD-${headerNames[i]}`] = value;
+      if (liveLatency) {
+        data['ltc'] = liveLatency;
       }
     }
 
-    return headers;
-  }
-
-  /**
-   * Convert a CMCD data object to query args according to the rules
-   * defined in the section 2.2 and 3.2 of
-   * [CTA-5004](https://cdn.cta.tech/cta/media/media/resources/standards/pdfs/cta-5004-final.pdf).
-   *
-   * @param {CmcdData} data The CMCD data object
-   * @param {cml.cmcd.CmcdEncodeOptions=} options Encoding options
-   *   (e.g. `baseUrl` to root-relativize `nor` URLs).
-   * @return {string}
-   */
-  static toQuery(data, options) {
-    return shaka.util.CmcdManager.serialize(data, options);
-  }
-
-  /**
-   * Append query args to a uri.
-   *
-   * Note: the URL-append step itself is NOT delegated to CML's
-   * `cml.cmcd.appendCmcdQuery`, which takes a CMCD data object plus encode
-   * options. Shaka's signature here is `(uri, encodedQuery)` — used as a
-   * thin adapter for callers that have already encoded via `toQuery`.
-   * Phase 3 will replace these call sites with `cml.cmcd.appendCmcdQuery`
-   * directly.
-   *
-   * @param {string} uri
-   * @param {string} query
-   * @return {string}
-   */
-  static appendQueryToUri(uri, query) {
-    if (!query) {
-      return uri;
-    }
-
-    if (uri.includes('offline:')) {
-      return uri;
-    }
-
-    const url = new goog.Uri(uri);
-    url.getQueryData().set('CMCD', query);
-    return url.toString();
+    return data;
   }
 
   /**
-   * Build encoder options for a CMCD encode call.
-   *
-   * @param {(string|undefined)} uri Source URL whose origin becomes
-   *   `baseUrl` so CML can rewrite `nor` URLs root-relative. Skipped
-   *   for `offline:` storage URIs and unparsable URIs.
-   * @param {number=} version `1` or `2`. Threads `this.config_.version`
-   *   to CML so V1 configurations get V1 keyset filtering and no
-   *   auto-`v=2`.
-   * @param {string=} reportingMode `'request'` or `'event'`. CML's
-   *   `prepareCmcdData` filters keys by mode (e.g. `e`/`ts` are
-   *   event-only). Defaults to CML's request mode if omitted.
-   * @return {!cml.cmcd.CmcdEncodeOptions}
+   * @return {number}
    * @private
    */
-  static getEncodeOptions_(uri, version, reportingMode) {
-    /** @type {!cml.cmcd.CmcdEncodeOptions} */
-    const options = /** @type {!cml.cmcd.CmcdEncodeOptions} */ ({});
-    if (uri && !uri.includes('offline:')) {
-      try {
-        options.baseUrl = new URL(uri).origin;
-      } catch (e) {
-        // Unparsable URI; skip baseUrl. CML's `nor` formatter passes
-        // values through unchanged when baseUrl is absent.
-      }
-    }
-    if (version != null) {
-      options.version = version;
-    }
-    if (reportingMode != null) {
-      options.reportingMode = reportingMode;
-    }
-    return options;
+  getCurrentTime_() {
+    return this.video_ ? this.video_.currentTime : 0;
   }
 };
 
 /**
- * Phase 1 dropped the non-spec `'ld'` / `'lh'` values, so shaka's enum
- * is now value-identical to `cml.cmcd.CmcdStreamingFormat` (4 spec-
- * conformant values: `'d'`/`'h'`/`'s'`/`'o'`). The literal definition
- * is retained — Closure's `clutz` TypeScript-defs generator and shaka's
- * `generateExterns.js` both expect `@export`ed `@enum`s to have an
- * inline `ObjectExpression` with literal values, not an alias. The
- * value identity is asserted in unit tests.
- *
- * Other shaka enums (`ObjectType`, `Version`, `StreamType`, `CmcdMode`,
- * `CmcdKeys`, `CmcdV2Constants`, `CmcdV2Keys`) were never `@export`ed
- * and have been deleted in favor of `cml.cmcd.*` equivalents.
+ * Public re-export of CMCD streaming-format values. The literal object
+ * form is required for Closure tooling: clutz (TypeScript-defs gen)
+ * and `generateExterns.js` reject `@export`ed `@enum`s whose RHS is a
+ * MemberExpression / alias. The 4 values match
+ * `cml.cmcd.CmcdStreamingFormat` exactly; a unit test asserts value
+ * identity.
  *
  * @enum {string}
  * @export
@@ -1578,3 +1152,52 @@ shaka.util.CmcdManager.StreamingFormat = {
   SMOOTH: 's',
   OTHER: 'o',
 };
+
+/**
+ * Public re-export of CMCD v2 event types. Literal form per the
+ * Closure-tooling constraint above. Values match `cml.cmcd.CmcdEventType`
+ * exactly; unit-test asserts identity.
+ *
+ * @enum {string}
+ * @export
+ */
+shaka.util.CmcdManager.EventType = {
+  BITRATE_CHANGE: 'bc',
+  PLAY_STATE: 'ps',
+  ERROR: 'e',
+  TIME_INTERVAL: 't',
+  CONTENT_ID: 'c',
+  BACKGROUNDED_MODE: 'b',
+  MUTE: 'm',
+  UNMUTE: 'um',
+  PLAYER_EXPAND: 'pe',
+  PLAYER_COLLAPSE: 'pc',
+  RESPONSE_RECEIVED: 'rr',
+  AD_START: 'as',
+  AD_END: 'ae',
+  AD_BREAK_START: 'abs',
+  AD_BREAK_END: 'abe',
+  SKIP: 'sk',
+  CUSTOM_EVENT: 'ce',
+};
+
+/**
+ * Public re-export of CMCD v2 player states. Literal form per the
+ * Closure-tooling constraint above. Values match `cml.cmcd.CmcdPlayerState`
+ * exactly; unit-test asserts identity.
+ *
+ * @enum {string}
+ * @export
+ */
+shaka.util.CmcdManager.PlayerState = {
+  STARTING: 's',
+  PLAYING: 'p',
+  SEEKING: 'k',
+  REBUFFERING: 'r',
+  PAUSED: 'a',
+  WAITING: 'w',
+  ENDED: 'e',
+  FATAL_ERROR: 'f',
+  QUIT: 'q',
+  PRELOADING: 'd',
+};
diff --git a/lib/util/player_configuration.js b/lib/util/player_configuration.js
index b5619f48cf..b9a5ca256b 100644
--- a/lib/util/player_configuration.js
+++ b/lib/util/player_configuration.js
@@ -351,7 +351,7 @@ shaka.util.PlayerConfiguration = class {
       useHeaders: false,
       includeKeys: [],
       version: 1,
-      targets: [],
+      eventTargets: [],
     };
 
     const cmsd = {
diff --git a/test/demo/demo_unit.js b/test/demo/demo_unit.js
index 4214ce424d..a4ec898ae7 100644
--- a/test/demo/demo_unit.js
+++ b/test/demo/demo_unit.js
@@ -90,7 +90,8 @@ describe('Demo', () => {
           .add('preferredVideo')
           .add('preferredText')
           .add('accessibility.speechToText.languagesToTranslate')
-          .add('manifest.msf.namespaces');
+          .add('manifest.msf.namespaces')
+          .add('cmcd.eventTargets');
       // We determine whether a config option has been made or not by looking at
       // which config values have been queried (via the fake main object's
       // |getCurrentConfigValue| method).
@@ -206,7 +207,8 @@ describe('Demo', () => {
           .add('mediaSource.modifyCueCallback')
           .add('preferredAudio')
           .add('preferredVideo')
-          .add('preferredText');
+          .add('preferredText')
+          .add('cmcd.eventTargets');
 
       /**
        * @param {!Object} section
diff --git a/test/util/cmcd_manager_unit.js b/test/util/cmcd_manager_unit.js
index 81d93900d8..09bf9f6376 100644
--- a/test/util/cmcd_manager_unit.js
+++ b/test/util/cmcd_manager_unit.js
@@ -4,11 +4,41 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-// region CMCD Manager Setup
-describe('CmcdManager Setup', () => {
+/**
+ * @fileoverview CmcdManager unit tests. Tests poke at the manager's
+ * internals (the `reporter_` field and a handful of `_`-suffixed
+ * helpers) for white-box coverage of the adapter's translation layer;
+ * the file-level suppress unblocks Closure's strict-property and
+ * private-access checks across the whole file.
+ *
+ * @suppress {checkTypes|accessControls|missingProperties|undefinedVars}
+ */
+
+describe('CmcdManager', () => {
+  const CmcdManager = shaka.util.CmcdManager;
+  const NetworkingEngine = shaka.net.NetworkingEngine;
+  const RequestType = NetworkingEngine.RequestType;
+  const AdvancedRequestType = NetworkingEngine.AdvancedRequestType;
+  const ObjectType = cml.cmcd.CmcdObjectType;
+  const PlayerState = cml.cmcd.CmcdPlayerState;
+  const EventType = cml.cmcd.CmcdEventType;
+  const StreamingFormat = cml.cmcd.CmcdStreamingFormat;
+
   /**
-   * @extends {shaka.util.FakeEventTarget}
+   * Cast any object to `Object<string, *>` so tests can poke at private
+   * fields/methods (`reporter_`, `setPlayerState_`, etc.) without struct
+   * or visibility complaints from Closure. The `@suppress` opens all
+   * relevant gates.
+   *
+   * @param {*} m
+   * @return {!Object<string, *>}
+   * @suppress {checkTypes|accessControls|strictPrimitiveOperators}
    */
+  function priv(m) {
+    return /** @type {!Object<string, *>} */ (m);
+  }
+
+  /** @extends {shaka.util.FakeEventTarget} */
   class MockCmcdVideo extends shaka.util.FakeEventTarget {
     constructor() {
       super();
@@ -16,4281 +46,844 @@ describe('CmcdManager Setup', () => {
       this.currentTime = 0;
       /** @type {boolean} */
       this.muted = false;
-    }
-  }
-
-  const createSegmentContextWithIndex = (segmentIndex) => {
-    const baseContext = createSegmentContext();
-    return Object.assign({}, baseContext, {
-      stream: Object.assign({}, baseContext.stream, {segmentIndex}),
-    });
-  };
-
-  const createSegmentContext = () => ({
-    type: shaka.net.NetworkingEngine.AdvancedRequestType.MEDIA_SEGMENT,
-    stream: {
-      bandwidth: 8000000,
-      codecs: 'avc1.42001e',
-      mimeType: 'video/mp4',
-      type: 'video',
-      segmentIndex: 0,
-    },
-
-    segment: {startTime: 10, endTime: 12, getUris: () => ['https://test.com/v2seg.mp4']},
-  });
-
-  const createMockSegmentIndex = () => {
-    const mockNextSegment = {
-      getUris: () => ['https://test.com/next-seg.m4v'],
-      startByte: 1000,
-      endByte: 1999,
-    };
-    const mockIterator = {
-      next: jasmine.createSpy('next')
-          .and.returnValue({value: mockNextSegment, done: false}),
-    };
-    return {
-      getIteratorForTime: jasmine.createSpy('getIteratorForTime')
-          .and.returnValue(mockIterator),
-    };
-  };
-
-  const createMockNextSegment = (withByteRange) => {
-    const mockNextSegment = {
-      getUris: () => ['https://test.com/next-seg.m4v'],
-    };
-
-    if (withByteRange) {
-      mockNextSegment.startByte = 1000;
-      mockNextSegment.endByte = 1999;
+      /** @type {boolean} */
+      this.autoplay = false;
     }
 
-    const mockIterator = {
-      next: jasmine.createSpy('next')
-          .and.returnValue({value: mockNextSegment, done: false}),
-    };
-    return {
-      getIteratorForTime: jasmine.createSpy('getIteratorForTime')
-          .and.returnValue(mockIterator),
-    };
-  };
-
-  beforeEach(() => {
-    const resolveScheme = jasmine.createSpy('cmcd').and.callFake(() =>
-      shaka.util.AbortableOperation.completed(
-          {uri: '', data: new ArrayBuffer(5), headers: {}}));
-
-    shaka.net.NetworkingEngine.registerScheme('cmcd',
-        shaka.test.Util.spyFunc(resolveScheme),
-        shaka.net.NetworkingEngine.PluginPriority.FALLBACK);
-  });
-
-  /**
-   * Creates a mock NetworkingEngine configured for CMCD testing.
-   * This single function supports both v1 and v2 test suites.
-   * @param {shaka.util.CmcdManager} cmcd
-   * @return {shaka.net.NetworkingEngine}
-   */
-  function createNetworkingEngine(cmcd) {
-    /** @type {shaka.net.NetworkingEngine} */
-    const networkingEngine = new shaka.net.NetworkingEngine(
-        /* onStart= */ undefined,
-        /* onProgress= */ undefined,
-        /* onEnd= */ undefined,
-        /* onResponse= */ undefined,
-        /* onRequest= */ (type, request, context) => {
-          cmcd.applyRequestData(type, request, context);
-        },
-    );
-
-    networkingEngine.configure(
-        shaka.util.PlayerConfiguration.createDefault().networking);
-
-    return networkingEngine;
+    play() { return Promise.resolve(); }
   }
 
-  // region CMCD V1
-  describe('CmcdManager CMCD V1', () => {
-    const CmcdManager = shaka.util.CmcdManager;
-    const uuidRegex =
-      '[A-F\\d]{8}-[A-F\\d]{4}-4[A-F\\d]{3}-[89AB][A-F\\d]{3}-[A-F\\d]{12}';
-    const sidRegex = new RegExp(`sid%3D%22${uuidRegex}%22`, 'i');
-    const sessionId = '2ed2d1cd-970b-48f2-bfb3-50a79e87cfa3';
-    const data = {
-      'sid': sessionId,
-      'cid': 'xyz',
-      'su': false,
-      'nor': '../testing/3.m4v',
-      'nrr': '0-99',
-      'd': 6066.66,
-      'mtp': 10049,
-      'bs': true,
-      'br': 52317,
-      'v': 1,
-      'pr': 1,
-      'com.test-hello': 'world',
-      'com.test-testing': 1234,
-      'com.test-exists': true,
-      'com.test-notExists': false,
-      'com.test-token': Symbol('s'),
-    };
-
-    const mockPlayer = new shaka.util.FakeEventTarget();
-    Object.assign(mockPlayer, {
+  function createMockPlayer() {
+    const player = /** @type {shaka.util.FakeEventTarget} */ (
+      new shaka.util.FakeEventTarget());
+    Object.assign(player, {
       isLive: () => false,
       getLiveLatency: () => 0,
       getBandwidthEstimate: () => 10000000,
       getBufferedInfo: () => ({
-        video: [
-          {start: 0, end: 5},
-          {start: 6, end: 31.234},
-          {start: 35, end: 40},
-        ],
+        video: [{start: 0, end: 30}],
+        audio: [{start: 0, end: 30}],
+        text: [],
       }),
-      getNetworkingEngine: () => createNetworkingEngine(
-          createCmcdManager(mockPlayer, createCmcdConfig()),
-      ),
+      getNetworkingEngine: () => null,
       getPlaybackRate: () => 1,
-      getVariantTracks: () => /** @type {Array<shaka.extern.Track>} */ ([
+      getVariantTracks: () => [
         {
-          type: 'variant',
-          bandwidth: 50000,
-          videoBandwidth: 40000,
-          audioBandWidth: 10000,
+          type: 'variant', active: false, bandwidth: 50000,
+          videoBandwidth: 40000, audioBandwidth: 10000,
         },
         {
-          type: 'variant',
-          bandwidth: 5000000,
-          videoBandwidth: 4000000,
-          audioBandWidth: 1000000,
+          type: 'variant', active: true, bandwidth: 5000000,
+          videoBandwidth: 4000000, audioBandwidth: 1000000,
         },
-      ]),
+      ],
     });
+    return player;
+  }
 
-    const config = {
+  function createConfig(overrides = {}) {
+    return Object.assign({
       enabled: true,
-      sessionId,
+      sessionId: '2ed2d1cd-970b-48f2-bfb3-50a79e87cfa3',
       contentId: 'testing',
       rtpSafetyFactor: 5,
       useHeaders: false,
       includeKeys: [],
-      version: 1,
-    };
-
-    function createCmcdConfig(cfg = {}) {
-      return Object.assign({}, config, cfg);
-    }
+      version: 2,
+      eventTargets: [],
+    }, overrides);
+  }
 
-    function createCmcdManager(player, cfg = {}) {
-      const cmcdManager = new CmcdManager(player, createCmcdConfig(cfg));
-      // Mock video element for time calculations
+  function createManager(player, configOverrides = {}, attach = true) {
+    const config = createConfig(configOverrides);
+    const manager = new CmcdManager(
+        /** @type {!shaka.Player} */ (player), config);
+    if (attach) {
       const video = new MockCmcdVideo();
       video.currentTime = 10;
-      cmcdManager.setMediaElement(
+      manager.setMediaElement(
           /** @type {!HTMLMediaElement} */ (/** @type {*} */ (video)));
-
-      return cmcdManager;
-    }
-
-    function createRequest() {
-      return {
-        uris: ['https://test.com/test.mpd'],
-        method: 'GET',
-        body: null,
-        headers: {
-          testing: '1234',
-        },
-        allowCrossSiteCredentials: false,
-        retryParameters: /** @type {shaka.extern.RetryParameters} */ ({}),
-        licenseRequestType: null,
-        sessionId: null,
-        drmInfo: null,
-        initData: null,
-        initDataType: null,
-        streamDataCallback: null,
-      };
     }
+    return {manager, config};
+  }
 
-    const request = createRequest();
-
-    const NetworkingEngine = shaka.net.NetworkingEngine;
-    const RequestType = NetworkingEngine.RequestType;
-
-    describe('StreamingFormat alias', () => {
-      it('preserves value-identity with cml.cmcd.CmcdStreamingFormat', () => {
-        // Phase 2 retains a literal `@enum` definition rather than a
-        // direct alias (Closure tooling — clutz + generateExterns —
-        // both expect inline `ObjectExpression` for `@export`ed
-        // enums). The values must stay in lockstep with CML.
-        expect(CmcdManager.StreamingFormat).toEqual(
-            /** @type {!Object<string, string>} */ (
-              cml.cmcd.CmcdStreamingFormat));
-      });
+  function createRequest(uri = 'https://test.com/seg.mp4') {
+    return /** @type {shaka.extern.Request} */ ({
+      uris: [uri],
+      method: 'GET',
+      body: null,
+      headers: {},
+      allowCrossSiteCredentials: false,
+      retryParameters: /** @type {shaka.extern.RetryParameters} */ ({}),
+      licenseRequestType: null,
+      sessionId: null,
+      drmInfo: null,
+      initData: null,
+      initDataType: null,
+      streamDataCallback: null,
     });
+  }
 
-    describe('Query serialization', () => {
-      it('produces correctly serialized data', () => {
-        const query = CmcdManager.toQuery(data);
-        const result =
-          // cspell: disable
-          'br=52317,bs,cid="xyz",com.test-exists,' +
-          'com.test-hello="world",com.test-testing=1234,' +
-          'com.test-token=s,d=6067,mtp=10000,' +
-          'nor="..%2Ftesting%2F3.m4v",nrr="0-99",' +
-          `sid="${sessionId}"`;
-          // cspell: enable
-        expect(query).toBe(result);
-      });
-
-      it('escapes reserve character in string values', () => {
-        const query = CmcdManager.toQuery({
-          'com.test-escape': 'Double "Quotes"',
-        });
-        // CML's encoder treats absent `v` as V2 default and emits `v=2`
-        // alongside the data; old shaka encoder did not auto-add `v`.
-        const result = 'com.test-escape="Double \\"Quotes\\"",v=2';
-        expect(query).toBe(result);
-      });
+  function createSegmentContext(type = 'video') {
+    return /** @type {shaka.extern.RequestContext} */ ({
+      type: AdvancedRequestType.MEDIA_SEGMENT,
+      stream: /** @type {shaka.extern.Stream} */ ({
+        bandwidth: 5234167,
+        codecs: 'avc1.42001e',
+        mimeType: 'video/mp4',
+        type: type,
+        segmentIndex: null,
+      }),
+      segment: /** @type {shaka.media.SegmentReference} */ ({
+        startTime: 0,
+        endTime: 3.33,
+        getUris: () => ['https://test.com/seg.mp4'],
+      }),
     });
+  }
 
-    describe('Header serialization', () => {
-      it('produces all header shards', () => {
-        const header = CmcdManager.toHeaders(data);
-        expect(header).toEqual({
-          'CMCD-Object': 'br=52317,d=6067',
-          'CMCD-Request': 'com.test-exists,com.test-hello="world",' +
-                          'com.test-testing=1234,com.test-token=s,mtp=10000,' +
-                          // cspell: disable-next-line
-                          'nor="..%2Ftesting%2F3.m4v",nrr="0-99"',
-          'CMCD-Session': `cid="xyz",sid="${sessionId}"`,
-          'CMCD-Status': 'bs',
-        });
-      });
+  // ── Public API back-compat re-exports ──
 
-      it('ignores empty shards', () => {
-        // CML auto-adds `v=2` for V2 (the default version when no `v`
-        // is provided), so the Session shard is never truly empty.
-        expect(CmcdManager.toHeaders({br: 200})).toEqual({
-          'CMCD-Object': 'br=200',
-          'CMCD-Session': 'v=2',
-        });
-      });
+  describe('public API re-exports', () => {
+    it('StreamingFormat preserves value-identity with cml.cmcd', () => {
+      expect(CmcdManager.StreamingFormat).toEqual(
+          /** @type {!Object<string, string>} */ (StreamingFormat));
     });
 
-    describe('CmcdManager instance', () => {
-      const ObjectUtils = shaka.util.ObjectUtils;
-
-      /** @type shaka.util.CmcdManager */
-      let cmcdManager = createCmcdManager(mockPlayer);
+    it('EventType preserves value-identity with cml.cmcd', () => {
+      expect(CmcdManager.EventType).toEqual(
+          /** @type {!Object<string, string>} */ (EventType));
+    });
 
-      const createContext = (type) => {
-        return {
-          type: type,
-          stream: /** @type {shaka.extern.Stream} */ ({
-            bandwidth: 5234167,
-            codecs: 'avc1.42001e',
-            mimeType: 'application/mp4',
-            type: 'video',
-          }),
-          segment: /** @type {shaka.media.SegmentReference} */ ({
-            startTime: 0,
-            endTime: 3.33,
-          }),
-        };
-      };
+    it('PlayerState preserves value-identity with cml.cmcd', () => {
+      expect(CmcdManager.PlayerState).toEqual(
+          /** @type {!Object<string, string>} */ (PlayerState));
+    });
+  });
 
-      const AdvancedRequestType = NetworkingEngine.AdvancedRequestType;
-      const manifestInfo = createContext(AdvancedRequestType.MPD);
-      const segmentInfo = createContext(AdvancedRequestType.MEDIA_SEGMENT);
+  // ── Lifecycle ──
 
-      describe('configuration', () => {
-        it('does not modify requests when disabled', () => {
-          cmcdManager = createCmcdManager(
-              mockPlayer,
-              {
-                enabled: false,
-              },
-          );
+  describe('lifecycle', () => {
+    it('does not construct a reporter when enabled is false', () => {
+      const player = createMockPlayer();
+      const {manager} = createManager(player, {enabled: false});
+      expect(priv(manager)['reporter_']).toBeNull();
+    });
 
-          const r = createRequest();
-          cmcdManager.applyManifestData(r, manifestInfo);
-          expect(r.uris[0]).toBe(request.uris[0]);
+    it('constructs a reporter once setMediaElement is called', () => {
+      const player = createMockPlayer();
+      const config = createConfig();
+      const manager = new CmcdManager(
+          /** @type {!shaka.Player} */ (player), config);
+      expect(priv(manager)['reporter_']).toBeNull();
+      const video = new MockCmcdVideo();
+      manager.setMediaElement(
+          /** @type {!HTMLMediaElement} */ (/** @type {*} */ (video)));
+      expect(priv(manager)['reporter_']).not.toBeNull();
+    });
 
-          cmcdManager.applyRequestSegmentData(r, segmentInfo);
-          expect(r.uris[0]).toBe(request.uris[0]);
-        });
+    it('tears down and rebuilds the reporter on configure with enabled toggle',
+        () => {
+          const player = createMockPlayer();
+          const {manager, config} = createManager(player);
+          const firstReporter = priv(manager)['reporter_'];
+          expect(firstReporter).not.toBeNull();
+          manager.configure(Object.assign({}, config, {enabled: false}));
+          expect(priv(manager)['reporter_']).toBeNull();
+          manager.configure(Object.assign({}, config, {enabled: true}));
+          expect(priv(manager)['reporter_']).not.toBeNull();
+          expect(priv(manager)['reporter_']).not.toBe(firstReporter);
+        });
+
+    it('tears down and rebuilds on material config change', () => {
+      const player = createMockPlayer();
+      const {manager, config} = createManager(player);
+      const firstReporter = priv(manager)['reporter_'];
+      manager.configure(Object.assign({}, config, {contentId: 'changed'}));
+      expect(priv(manager)['reporter_']).not.toBe(firstReporter);
+    });
 
-        it('generates a session id if not provided', () => {
-          cmcdManager = createCmcdManager(
-              mockPlayer,
-              {
-                sessionId: '',
-              },
-          );
+    it('keeps the same reporter for non-material changes', () => {
+      const player = createMockPlayer();
+      const {manager, config} = createManager(player);
+      const firstReporter = priv(manager)['reporter_'];
+      manager.configure(Object.assign({}, config, {rtpSafetyFactor: 7}));
+      expect(priv(manager)['reporter_']).toBe(firstReporter);
+    });
 
-          const r = ObjectUtils.cloneObject(request);
+    it('reset stops the reporter and clears state', () => {
+      const player = createMockPlayer();
+      const {manager} = createManager(player);
+      spyOn(priv(manager)['reporter_'], 'stop');
+      const reporterRef = priv(manager)['reporter_'];
+      manager.reset();
+      expect(reporterRef.stop).toHaveBeenCalledWith(true);
+      expect(priv(manager)['reporter_']).toBeNull();
+      expect(priv(manager)['lastPlayerState_']).toBeNull();
+    });
+  });
 
-          cmcdManager.applyManifestData(r, manifestInfo);
+  // ── Configuration translation ──
+
+  describe('toReporterConfig_', () => {
+    it('renames useHeaders to transmissionMode', () => {
+      const player = createMockPlayer();
+      const {manager} = createManager(player, {useHeaders: true});
+      const cfg = priv(manager)['toReporterConfig_'](
+          createConfig({useHeaders: true}));
+      expect(cfg.transmissionMode).toBe(cml.cmcd.CMCD_HEADERS);
+      const cfg2 = priv(manager)['toReporterConfig_'](
+          createConfig({useHeaders: false}));
+      expect(cfg2.transmissionMode).toBe(cml.cmcd.CMCD_QUERY);
+    });
 
-          expect(sidRegex.test(r.uris[0])).toBe(true);
-        });
+    it('maps version 1 → CMCD_V1, version 2 → CMCD_V2', () => {
+      const player = createMockPlayer();
+      const {manager} = createManager(player);
+      const v1 = priv(manager)['toReporterConfig_'](createConfig({version: 1}));
+      expect(v1.version).toBe(cml.cmcd.CMCD_V1);
+      const v2 = priv(manager)['toReporterConfig_'](createConfig({version: 2}));
+      expect(v2.version).toBe(cml.cmcd.CMCD_V2);
+    });
 
-        it('generates a session id via configure', () => {
-          cmcdManager = createCmcdManager(mockPlayer);
+    it('expands empty includeKeys to all keys for the version', () => {
+      const player = createMockPlayer();
+      const {manager} = createManager(player);
+      const v2Cfg = priv(manager)['toReporterConfig_'](
+          createConfig({version: 2, includeKeys: []}));
+      // V2 expansion includes request + response + event keys.
+      expect(v2Cfg.enabledKeys.length).toBeGreaterThan(
+          cml.cmcd.CMCD_REQUEST_KEYS.length);
+      const v1Cfg = priv(manager)['toReporterConfig_'](
+          createConfig({version: 1, includeKeys: []}));
+      // V1 expansion is the V1 keyset only.
+      expect(v1Cfg.enabledKeys.length).toBe(cml.cmcd.CMCD_V1_KEYS.length);
+    });
 
-          const r = createRequest();
-          cmcdManager.applyManifestData(r, manifestInfo);
-          expect(r.uris[0].includes(sessionId)).toBe(true);
+    it('preserves user-supplied includeKeys', () => {
+      const player = createMockPlayer();
+      const {manager} = createManager(player);
+      const cfg = priv(manager)['toReporterConfig_'](
+          createConfig({includeKeys: ['cid', 'sid']}));
+      expect(cfg.enabledKeys).toEqual(['cid', 'sid']);
+    });
 
-          const sid = 'c936730c-031e-4a73-976f-92bc34039c60';
-          cmcdManager.configure(createCmcdConfig({
-            sessionId: sid,
+    it('renames per-target includeKeys → enabledKeys, interval, batchSize',
+        () => {
+          const player = createMockPlayer();
+          const {manager} = createManager(player);
+          const cfg = priv(manager)['toReporterConfig_'](createConfig({
+            eventTargets: [{
+              enabled: true,
+              url: 'https://collector/cmcd',
+              events: [EventType.PLAY_STATE],
+              includeKeys: ['ot', 'sf'],
+              interval: 15,
+              batchSize: 5,
+              mode: 'response',
+              useHeaders: false,
+            }],
           }));
-          cmcdManager.applyManifestData(r, manifestInfo);
-          expect(r.uris[0].includes(sessionId)).toBe(false);
-          expect(r.uris[0].includes(sid)).toBe(true);
+          expect(cfg.eventTargets.length).toBe(1);
+          expect(cfg.eventTargets[0].url).toBe('https://collector/cmcd');
+          expect(cfg.eventTargets[0].enabledKeys).toEqual(['ot', 'sf']);
+          expect(cfg.eventTargets[0].interval).toBe(15);
+          expect(cfg.eventTargets[0].batchSize).toBe(5);
+          expect(cfg.eventTargets[0].events).toEqual([EventType.PLAY_STATE]);
+        });
+
+    it('skips event targets that are disabled or missing url/events', () => {
+      const player = createMockPlayer();
+      const {manager} = createManager(player);
+      const cfg = priv(manager)['toReporterConfig_'](createConfig({
+        eventTargets: [
+          {enabled: false, url: 'x', events: [EventType.PLAY_STATE],
+            includeKeys: [], mode: '', useHeaders: false},
+          {enabled: true, url: '', events: [EventType.PLAY_STATE],
+            includeKeys: [], mode: '', useHeaders: false},
+          {enabled: true, url: 'x', events: [],
+            includeKeys: [], mode: '', useHeaders: false},
+          {enabled: true, url: 'https://collector/cmcd',
+            events: [EventType.ERROR],
+            includeKeys: [], mode: '', useHeaders: false},
+        ],
+      }));
+      expect(cfg.eventTargets.length).toBe(1);
+      expect(cfg.eventTargets[0].url).toBe('https://collector/cmcd');
+    });
 
-          cmcdManager.configure(createCmcdConfig({
-            sessionId: '',
-          }));
-          cmcdManager.applyManifestData(r, manifestInfo);
-          expect(r.uris[0].includes(sessionId)).toBe(false);
-          expect(r.uris[0].includes(sid)).toBe(false);
-          expect(sidRegex.test(r.uris[0])).toBe(true);
-        });
+    it('auto-generates a sessionId when not provided', () => {
+      const player = createMockPlayer();
+      const {manager} = createManager(player);
+      const cfg = createConfig({sessionId: ''});
+      const reporterCfg = priv(manager)['toReporterConfig_'](cfg);
+      expect(reporterCfg.sid).toBeTruthy();
+      expect(cfg.sessionId).toBe(/** @type {string} */ (reporterCfg.sid));
+    });
+  });
 
-        it('filters keys if includeKeys is provided', () => {
-          cmcdManager = createCmcdManager(
-              mockPlayer,
-              {
-                includeKeys: ['sid', 'cid'],
-              },
-          );
+  // ── Request mode (applyRequestData) ──
 
-          const r = createRequest();
-          cmcdManager.applyManifestData(r, manifestInfo);
+  describe('applyRequestData', () => {
+    /** @type {shaka.util.CmcdManager} */
+    let manager;
 
-          const uri = `https://test.com/test.mpd?CMCD=cid%3D%22testing%22%2Csid%3D%22${sessionId}%22`;
-          expect(r.uris[0]).toBe(uri);
-        });
-      });
+    beforeEach(() => {
+      const player = createMockPlayer();
+      const result = createManager(player, {includeKeys: ['cid', 'sid', 'ot']});
+      manager = result.manager;
+    });
 
-      describe('query mode', () => {
-        it('modifies all request uris', () => {
-          // modifies manifest request uris
-          cmcdManager = createCmcdManager(mockPlayer);
+    it('no-ops when reporter is absent (enabled=false)', () => {
+      const player = createMockPlayer();
+      const {manager: m2} = createManager(player, {enabled: false});
+      const r = createRequest();
+      const originalUri = r.uris[0];
+      m2.applyRequestData(RequestType.MANIFEST, r,
+          /** @type {shaka.extern.RequestContext} */ (
+            {type: AdvancedRequestType.MPD}));
+      expect(r.uris[0]).toBe(originalUri);
+    });
 
-          let r = createRequest();
-          cmcdManager.applyManifestData(r, manifestInfo);
-          let uri = 'https://test.com/test.mpd?CMCD=cid%3D%22testing%22%2C' +
-            'mtp%3D10000%2Cot%3Dm%2Csf%3Dd%2C' +
-            `sid%3D%22${sessionId}%22%2Csu`;
-          expect(r.uris[0]).toBe(uri);
+    it('routes MANIFEST through createRequestReport with ot=m', () => {
+      spyOn(priv(manager)['reporter_'], 'createRequestReport')
+          .and.callThrough();
+      const r = createRequest('https://test.com/manifest.mpd');
+      manager.applyRequestData(RequestType.MANIFEST, r,
+          /** @type {shaka.extern.RequestContext} */ (
+            {type: AdvancedRequestType.MPD}));
+      expect(priv(manager)['reporter_'].createRequestReport).toHaveBeenCalled();
+      const reporter = priv(manager)['reporter_'];
+      const args = /** @type {!Array} */ (
+        reporter.createRequestReport.calls.mostRecent().args);
+      expect(args[1].ot).toBe(ObjectType.MANIFEST);
+    });
 
-          // modifies segment request uris
-          r = createRequest();
-          cmcdManager.applyRequestSegmentData(r, segmentInfo);
-          uri =
-            `https://test.com/test.mpd?CMCD=bl%3D21200%2Cbr%3D5234%2Ccid%3D%22testing%22%2Cd%3D3330%2Cdl%3D21200%2Cmtp%3D10000%2Cot%3Dv%2Csf%3Dd%2Csid%3D%22${sessionId}%22%2Cst%3Dv%2Csu%2Ctb%3D4000`;
-          expect(r.uris[0]).toBe(uri);
+    it('routes SEGMENT requests with the segment payload', () => {
+      spyOn(priv(manager)['reporter_'], 'createRequestReport')
+          .and.callThrough();
+      const r = createRequest();
+      manager.applyRequestData(RequestType.SEGMENT, r,
+          createSegmentContext('video'));
+      expect(priv(manager)['reporter_'].createRequestReport).toHaveBeenCalled();
+      const data = /** @type {!Object} */ (
+        priv(manager)['reporter_'].createRequestReport.calls
+            .mostRecent().args[1]);
+      expect(data.ot).toBe(ObjectType.VIDEO);
+    });
 
-          // modifies text request uris
-          r = createRequest();
-          cmcdManager.applyTextData(r);
-          uri =
-            `https://test.com/test.mpd?CMCD=cid%3D%22testing%22%2Cmtp%3D10000%2Cot%3Dc%2Csf%3Dd%2Csid%3D%22${sessionId}%22%2Csu`;
-          expect(r.uris[0]).toBe(uri);
-        });
-      });
+    it('routes LICENSE/KEY/SERVER_CERTIFICATE with ot=k', () => {
+      spyOn(priv(manager)['reporter_'], 'createRequestReport')
+          .and.callThrough();
+      for (const type of [
+        RequestType.LICENSE, RequestType.KEY, RequestType.SERVER_CERTIFICATE,
+      ]) {
+        manager.applyRequestData(type, createRequest());
+        const data = /** @type {!Object} */ (
+          priv(manager)['reporter_'].createRequestReport.calls
+              .mostRecent().args[1]);
+        expect(data.ot).toBe(ObjectType.KEY);
+      }
+    });
 
-      describe('header mode', () => {
-        it('modifies all request headers', () => {
-          cmcdManager = createCmcdManager(
-              mockPlayer,
-              {
-                useHeaders: true,
-              },
-          );
+    it('routes TIMING with ot=o', () => {
+      spyOn(priv(manager)['reporter_'], 'createRequestReport')
+          .and.callThrough();
+      manager.applyRequestData(RequestType.TIMING, createRequest());
+      const data = /** @type {!Object} */ (
+        priv(manager)['reporter_'].createRequestReport.calls
+            .mostRecent().args[1]);
+      expect(data.ot).toBe(ObjectType.OTHER);
+    });
 
-          // modifies manifest request headers
-          let r = createRequest();
-          cmcdManager.applyManifestData(r, manifestInfo);
-          expect(r.headers).toEqual({
-            'testing': '1234',
-            'CMCD-Object': 'ot=m',
-            'CMCD-Request': 'mtp=10000,su',
-            'CMCD-Session': 'cid="testing",sf=d,' +
-                            `sid="${sessionId}"`,
-          });
+    it('updates streaming format on first manifest request', () => {
+      spyOn(priv(manager)['reporter_'], 'update').and.callThrough();
+      manager.applyRequestData(RequestType.MANIFEST, createRequest(),
+          /** @type {shaka.extern.RequestContext} */ (
+            {type: AdvancedRequestType.MPD}));
+      expect(priv(manager)['reporter_'].update).toHaveBeenCalledWith(
+          jasmine.objectContaining({sf: StreamingFormat.DASH}));
+    });
 
-          // modifies segment request headers
-          r = createRequest();
-          cmcdManager.applyRequestSegmentData(r, segmentInfo);
-          expect(r.headers).toEqual({
-            'testing': '1234',
-            'CMCD-Object': 'br=5234,d=3330,ot=v,tb=4000',
-            'CMCD-Request': 'bl=21200,dl=21200,mtp=10000,su',
-            'CMCD-Session': 'cid="testing",sf=d,' +
-                            `sid="${sessionId}",st=v`,
-          });
+    it('rewrites all URIs in a multi-URI request (query mode)', () => {
+      const r = createRequest();
+      r.uris = [
+        'https://cdn1.example.com/seg.mp4',
+        'https://cdn2.example.com/seg.mp4',
+      ];
+      manager.applyRequestData(RequestType.SEGMENT, r,
+          createSegmentContext('video'));
+      expect(r.uris[0]).toContain('CMCD=');
+      expect(r.uris[1]).toContain('CMCD=');
+      expect(r.uris[0]).toContain('cdn1.example.com');
+      expect(r.uris[1]).toContain('cdn2.example.com');
+    });
 
-          // modifies segment request headers
-          r = createRequest();
-          cmcdManager.applyRequestSegmentData(r, segmentInfo);
-          expect(r.headers).toEqual({
-            'testing': '1234',
-            'CMCD-Object': 'br=5234,d=3330,ot=v,tb=4000',
-            'CMCD-Request': 'bl=21200,dl=21200,mtp=10000,su',
-            'CMCD-Session': 'cid="testing",sf=d,' +
-                            `sid="${sessionId}",st=v`,
-          });
-        });
-      });
+    it('writes CMCD-* headers when useHeaders is true', () => {
+      const player = createMockPlayer();
+      const {manager: m} = createManager(player,
+          {useHeaders: true, includeKeys: ['cid', 'sid']});
+      const r = createRequest();
+      m.applyRequestData(RequestType.SEGMENT, r,
+          createSegmentContext('video'));
+      const headerKeys = Object.keys(r.headers);
+      expect(headerKeys.some((k) => k.startsWith('CMCD-'))).toBe(true);
+    });
 
-      describe('src= mode', () => {
-        beforeEach(() => {
-          cmcdManager = createCmcdManager(mockPlayer);
-        });
+    it('records request initiation timestamp for SEGMENT requests', () => {
+      const r = createRequest();
+      manager.applyRequestData(RequestType.SEGMENT, r,
+          createSegmentContext('video'));
+      expect(priv(manager)['requestTimestampMap_'].has(r)).toBe(true);
+    });
 
-        it('modifies media stream uris', () => {
-          const r = cmcdManager
-              .appendSrcData('https://test.com/test.mp4', 'video/mp4');
-          const uri = 'https://test.com/test.mp4?CMCD=cid%3D%22testing%22%2C' +
-                      'mtp%3D10000%2Cot%3Dav%2C' +
-                      `sid%3D%22${sessionId}%22%2Csu`;
-          expect(r).toBe(uri);
-        });
+    it('handles HEAD method with empty payload', () => {
+      spyOn(priv(manager)['reporter_'], 'createRequestReport')
+          .and.callThrough();
+      const r = createRequest();
+      r.method = 'HEAD';
+      manager.applyRequestData(RequestType.SEGMENT, r,
+          createSegmentContext('video'));
+      const data = /** @type {!Object} */ (
+        priv(manager)['reporter_'].createRequestReport.calls
+            .mostRecent().args[1]);
+      expect(Object.keys(data).length).toBe(0);
+    });
+  });
 
-        it('modifies manifest stream uris', () => {
-          const r = cmcdManager
-              .appendSrcData('https://test.com/test.m3u8', 'application/x-mpegurl');
-          const uri = 'https://test.com/test.m3u8?CMCD=cid%3D%22testing%22%2C' +
-                      'mtp%3D10000%2Cot%3Dm%2C' +
-                      `sid%3D%22${sessionId}%22%2Csu`;
-          expect(r).toBe(uri);
-        });
+  // ── Response mode (applyResponseData) ──
 
-        it('modifies text track uris', () => {
-          const r = cmcdManager.appendTextTrackData('https://test.com/test.vtt');
-          const uri = 'https://test.com/test.vtt?CMCD=cid%3D%22testing%22%2C' +
-                      'mtp%3D10000%2Cot%3Dc%2C' +
-                      `sid%3D%22${sessionId}%22%2Csu`;
-          expect(r).toBe(uri);
-        });
+  describe('applyResponseData', () => {
+    function createResponseConfig() {
+      return createConfig({
+        eventTargets: [{
+          enabled: true,
+          url: 'https://collector/cmcd',
+          events: [EventType.RESPONSE_RECEIVED],
+          includeKeys: [],
+          mode: 'response',
+          useHeaders: false,
+        }],
       });
+    }
 
-      describe('adheres to the spec', () => {
-        beforeEach(() => {
-          cmcdManager = createCmcdManager(
-              mockPlayer,
-              {
-                useHeaders: true,
-              },
-          );
-          cmcdManager.setBuffering(false);
-          cmcdManager.setBuffering(true);
-        });
-
-        it('sends bs only once', () => {
-          let r = createRequest();
-          cmcdManager.applyRequestSegmentData(r, segmentInfo);
-          expect(r.headers['CMCD-Status']).toContain('bs');
-
-          r = createRequest();
-          cmcdManager.applyRequestSegmentData(r, segmentInfo);
-          expect(r.headers['CMCD-Status']).not.toContain('bs');
-        });
-
-        it('sends su until buffering is complete', () => {
-          let r = createRequest();
-          cmcdManager.applyRequestSegmentData(r, segmentInfo);
-          expect(r.headers['CMCD-Request']).toContain(',su');
-
-          r = createRequest();
-          cmcdManager.applyRequestSegmentData(r, segmentInfo);
-          expect(r.headers['CMCD-Request']).toContain(',su');
-
-          cmcdManager.setBuffering(false);
-          r = createRequest();
-          cmcdManager.applyRequestSegmentData(r, segmentInfo);
-          expect(r.headers['CMCD-Request']).not.toContain(',su');
-        });
-
-        describe('applies core CMCD params to net engine requests', () => {
-          /** @type {shaka.net.NetworkingEngine} */
-          let networkingEngine;
-          const uri = 'cmcd://foo';
-          const retry = NetworkingEngine.defaultRetryParameters();
-
-          beforeEach(() => {
-            cmcdManager = createCmcdManager(mockPlayer);
-            networkingEngine = createNetworkingEngine(cmcdManager);
-          });
-
-          it('HEAD requests', async () => {
-            const request = NetworkingEngine.makeRequest([uri], retry);
-            request.method = 'HEAD';
-            await networkingEngine.request(RequestType.MANIFEST, request);
-
-            const result = request.uris[0];
-            expect(result).toContain('?CMCD=');
-            expect(result).toContain(encodeURIComponent('sid="'));
-            expect(result).toContain(encodeURIComponent('cid="testing"'));
-            expect(result).not.toContain(encodeURIComponent('sf='));
-          });
-
-          it('dash manifest requests', async () => {
-            const request = NetworkingEngine.makeRequest([uri], retry);
-            await networkingEngine.request(RequestType.MANIFEST, request,
-                {type: AdvancedRequestType.MPD});
-
-            const result = request.uris[0];
-            expect(result).toContain(encodeURIComponent('ot=m'));
-            expect(result).toContain(encodeURIComponent('sf=d'));
-          });
-
-          it('hls manifest requests', async () => {
-            const request = NetworkingEngine.makeRequest([uri], retry);
-            await networkingEngine.request(RequestType.MANIFEST, request,
-                {type: AdvancedRequestType.MASTER_PLAYLIST});
-
-            const result = request.uris[0];
-            expect(result).toContain(encodeURIComponent('ot=m'));
-            expect(result).toContain(encodeURIComponent('sf=h'));
-          });
-
-          it('hls playlist requests', async () => {
-            const request = NetworkingEngine.makeRequest([uri], retry);
-            await networkingEngine.request(RequestType.MANIFEST, request,
-                {type: AdvancedRequestType.MEDIA_PLAYLIST});
-
-            const result = request.uris[0];
-            expect(result).toContain(encodeURIComponent('ot=m'));
-            expect(result).toContain(encodeURIComponent('sf=h'));
-          });
-
-          it('init segment requests', async () => {
-            const request = NetworkingEngine.makeRequest([uri], retry);
-            await networkingEngine.request(RequestType.SEGMENT, request,
-                {type: AdvancedRequestType.INIT_SEGMENT});
-
-            const result = request.uris[0];
-            expect(result).toContain(encodeURIComponent('ot=i'));
-          });
-
-          it('media segment requests', async () => {
-            const request = NetworkingEngine.makeRequest([uri], retry);
-            await networkingEngine.request(
-                RequestType.SEGMENT,
-                request,
-                manifestInfo,
-            );
-
-            const result = request.uris[0];
-            expect(result).toContain(encodeURIComponent('ot=v'));
-          });
-
-          it('key requests', async () => {
-            const request = NetworkingEngine.makeRequest([uri], retry);
-            await networkingEngine.request(RequestType.KEY, request);
-
-            const result = request.uris[0];
-            expect(result).toContain(encodeURIComponent('ot=k'));
-          });
-
-          it('license requests', async () => {
-            const request = NetworkingEngine.makeRequest([uri], retry);
-            await networkingEngine.request(RequestType.LICENSE, request);
-
-            const result = request.uris[0];
-            expect(result).toContain(encodeURIComponent('ot=k'));
-          });
-
-          it('cert requests', async () => {
-            const request = NetworkingEngine.makeRequest([uri], retry);
-            await networkingEngine.request(RequestType.SERVER_CERTIFICATE,
-                request);
-
-            const result = request.uris[0];
-            expect(result).toContain(encodeURIComponent('ot=k'));
-          });
-
-          it('timing requests', async () => {
-            const request = NetworkingEngine.makeRequest([uri], retry);
-            await networkingEngine.request(RequestType.TIMING, request);
-
-            const result = request.uris[0];
-            expect(result).toContain(encodeURIComponent('ot=o'));
-          });
-
-          it('not when enabled is false', async () => {
-            cmcdManager = createCmcdManager(
-                mockPlayer,
-                {
-                  enabled: false,
-                },
-            );
-            networkingEngine = createNetworkingEngine(cmcdManager);
-
-            const request = NetworkingEngine.makeRequest([uri], retry);
-            await networkingEngine.request(RequestType.TIMING, request);
-
-            const result = request.uris[0];
-            expect(result).not.toContain('?CMCD=');
-          });
-
-          it('returns cmcd v2 data in query if version is 2', async () => {
-            const livePlayer = new shaka.util.FakeEventTarget();
-            Object.assign(livePlayer, mockPlayer, {
-              isLive: () => true,
-              getLiveLatency: () => 3100,
-            });
-            cmcdManager = createCmcdManager(
-                livePlayer,
-                {
-                  version: 2,
-                  includeKeys: ['ltc', 'msd', 'v'],
-                },
-            );
-            networkingEngine = createNetworkingEngine(cmcdManager);
-
-            // Trigger Play and Playing events
-            cmcdManager.onPlaybackPlay_();
-            cmcdManager.onPlaybackPlaying_();
-            const request = NetworkingEngine.makeRequest([uri], retry);
-            await networkingEngine.request(RequestType.MANIFEST, request,
-                {type: AdvancedRequestType.MPD});
-            const result = request.uris[0];
-            expect(result).toContain(encodeURIComponent('v=2'));
-            expect(result).toContain(encodeURIComponent('ltc'));
-            expect(result).toContain(encodeURIComponent('msd'));
-          });
-
-          it('doesn\'t return cmcd v2 data in query if version is not 2',
-              async () => {
-                const livePlayer = new shaka.util.FakeEventTarget();
-                Object.assign(livePlayer, mockPlayer, {
-                  isLive: () => true,
-                  getLiveLatency: () => 3100,
-                });
-
-                const cmcdManagerTmp = createCmcdManager(
-                    livePlayer,
-                    {
-                      version: 1,
-                      includeKeys: ['ltc', 'msd'],
-                    },
-                );
-                networkingEngine = createNetworkingEngine(cmcdManagerTmp);
-
-                // Trigger Play and Playing events
-                cmcdManagerTmp.onPlaybackPlay_();
-                cmcdManagerTmp.onPlaybackPlaying_();
-
-                const request = NetworkingEngine.makeRequest([uri], retry);
-                await networkingEngine.request(RequestType.MANIFEST, request,
-                    {type: AdvancedRequestType.MPD});
-                const result = request.uris[0];
-                expect(result).not.toContain(encodeURIComponent('ltc'));
-                expect(result).not.toContain(encodeURIComponent('msd'));
-              });
-
-          it('returns cmcd v2 data in header if version is 2', async () => {
-            const livePlayer = new shaka.util.FakeEventTarget();
-            Object.assign(livePlayer, mockPlayer, {
-              isLive: () => true,
-              getLiveLatency: () => 3100,
-            });
-            cmcdManager = createCmcdManager(
-                livePlayer,
-                {
-                  version: 2,
-                  includeKeys: ['ltc', 'msd'],
-                  useHeaders: true,
-                },
-            );
-            networkingEngine = createNetworkingEngine(cmcdManager);
-
-            // Trigger Play and Playing events
-            cmcdManager.onPlaybackPlay_();
-            cmcdManager.onPlaybackPlaying_();
-            const request = NetworkingEngine.makeRequest([uri], retry);
-            await networkingEngine.request(RequestType.MANIFEST, request,
-                {type: AdvancedRequestType.MPD});
-            expect(request.headers['CMCD-Request']).toContain('ltc');
-            expect(request.headers['CMCD-Session']).toContain('msd');
-          });
-
-          it('doesn\'t return cmcd v2 data in headers if version is not 2',
-              async () => {
-                const livePlayer = new shaka.util.FakeEventTarget();
-                Object.assign(livePlayer, mockPlayer, {
-                  isLive: () => true,
-                  getLiveLatency: () => 3100,
-                });
-                cmcdManager = createCmcdManager(
-                    livePlayer,
-                    {
-                      version: 1,
-                      includeKeys: ['ltc', 'msd'],
-                      useHeaders: true,
-                    },
-                );
-                networkingEngine = createNetworkingEngine(cmcdManager);
-                cmcdManager.onPlaybackPlay_();
-                cmcdManager.onPlaybackPlaying_();
-                const request = NetworkingEngine.makeRequest([uri], retry);
-                await networkingEngine.request(RequestType.MANIFEST, request,
-                    {type: AdvancedRequestType.MPD});
-                expect(request.headers['CMCD-Request']).not.toContain('ltc');
-                expect(request.headers['CMCD-Session']).not.toContain('msd');
-              },
-          );
-
-          it('generates `nrr` for CMCD V1 segment requests', () => {
-            cmcdManager = createCmcdManager(
-                mockPlayer,
-                {
-                  version: 1,
-                  includeKeys: ['ltc', 'msd', 'nrr'],
-                  useHeaders: false,
-                },
-            );
-
-            const request = createRequest();
-            const context = createSegmentContextWithIndex(
-                createMockSegmentIndex(),
-            );
-
-            cmcdManager.applyRequestSegmentData(request, context);
-            const decodedUri = decodeURIComponent(request.uris[0]);
-
-            expect(decodedUri).toContain('nrr="1000-1999"');
-          });
-
-          it('generates `nor` for URL-based segment requests', () => {
-            const cmcdManager = createCmcdManager(
-                mockPlayer,
-            );
-            const request = createRequest();
-
-            const context =
-                createSegmentContextWithIndex(createMockNextSegment(false));
-
-            cmcdManager.applyRequestSegmentData(request, context);
-            const decodedUri = decodeURIComponent(request.uris[0]);
-
-            expect(decodedUri).toContain('nor="next-seg.m4v"');
-            expect(decodedUri).not.toContain('nrr=');
-          });
+    it('no-ops when no event target subscribes to rr', () => {
+      const player = createMockPlayer();
+      const {manager} = createManager(player);
+      spyOn(priv(manager)['reporter_'], 'recordResponseReceived');
+      manager.applyResponseData(RequestType.SEGMENT,
+          /** @type {shaka.extern.Response} */ (
+            {status: 200, uri: 'https://test/seg', headers: {}}));
+      expect(priv(manager)['reporter_'].recordResponseReceived)
+          .not.toHaveBeenCalled();
+    });
 
-          it('generates `nrr` for byte-range segment requests', () => {
-            const cmcdManager = createCmcdManager(
-                mockPlayer,
-            );
-            const request = createRequest();
-            // Create a context where the next segment HAS a byte range
-            const context =
-                createSegmentContextWithIndex(createMockNextSegment(true));
+    it('forwards response data to recordResponseReceived', () => {
+      const player = createMockPlayer();
+      const {manager} = createManager(player, createResponseConfig());
+      spyOn(priv(manager)['reporter_'], 'recordResponseReceived');
+      const r = createRequest();
+      // Seed timestamp map first.
+      manager.applyRequestData(RequestType.SEGMENT, r,
+          createSegmentContext('video'));
+      manager.applyResponseData(RequestType.SEGMENT,
+          /** @type {shaka.extern.Response} */ ({
+            status: 200,
+            uri: 'https://test/seg.mp4',
+            originalUri: 'https://test/seg.mp4',
+            originalRequest: r,
+            timeMs: 50,
+            headers: {},
+          }));
+      expect(priv(manager)['reporter_'].recordResponseReceived)
+          .toHaveBeenCalled();
+      const args =
+      /** @type {!Array} */ (
+          priv(manager)['reporter_'].recordResponseReceived.calls
+              .mostRecent().args);
+      const data = /** @type {!Object} */ (args[1]);
+      expect(data.rc).toBe(200);
+      expect(data.ttlb).toBe(50);
+      expect(data.url).toBe('https://test/seg.mp4');
+    });
 
-            cmcdManager.applyRequestSegmentData(request, context);
-            const decodedUri = decodeURIComponent(request.uris[0]);
+    it('only fires for SEGMENT responses', () => {
+      const player = createMockPlayer();
+      const {manager} = createManager(player, createResponseConfig());
+      spyOn(priv(manager)['reporter_'], 'recordResponseReceived');
+      manager.applyResponseData(RequestType.MANIFEST,
+          /** @type {shaka.extern.Response} */ (
+            {status: 200, uri: 'https://test/m', headers: {}}));
+      expect(priv(manager)['reporter_'].recordResponseReceived)
+          .not.toHaveBeenCalled();
+    });
 
-            expect(decodedUri).toContain('nrr="1000-1999"');
-            expect(decodedUri).toContain('nor=');
-          });
-        });
-      });
+    it('strips CMCD query from the reported url', () => {
+      const player = createMockPlayer();
+      const {manager} = createManager(player, createResponseConfig());
+      spyOn(priv(manager)['reporter_'], 'recordResponseReceived');
+      manager.applyResponseData(RequestType.SEGMENT,
+          /** @type {shaka.extern.Response} */ ({
+            status: 200,
+            uri: 'https://test/seg.mp4?CMCD=cid%3D%22x%22',
+            originalUri: 'https://test/seg.mp4?CMCD=cid%3D%22x%22',
+            originalRequest: createRequest(),
+            timeMs: 50,
+            headers: {},
+          }));
+      const data = /** @type {!Object} */ (
+        priv(manager)['reporter_'].recordResponseReceived.calls
+            .mostRecent().args[1]);
+      expect(data.url).toBe('https://test/seg.mp4');
     });
   });
 
-  // region CMCD V2
-  describe('CmcdManager CMCD v2', () => {
-    const CmcdManager = shaka.util.CmcdManager;
-    const sessionId = 'e98d4f72-cc6d-4c60-96a2-44c7bfc2ddee';
-
-    // Mock data and interfaces
-    const mockPlayerData = {
-      'v': 2,
-      'sid': sessionId,
-      'cid': 'xyz',
-      'su': false,
-      'nor': '../testing/3.m4v',
-      'nrr': '0-99',
-      'd': 6066.66,
-      'mtp': 10049,
-      'bs': true,
-      'br': 52317,
-      'pr': 1.5,
-      'msd': 700,
-      'ltc': 3100,
-      'ab': 3500,
-      'bl': 4500,
-      'tbl': 6000,
-      'dl': 8000,
-      'rtp': 30000,
-      'com.test-hello': 'world',
-      'com.test-testing': 1234,
-      'com.test-exists': true,
-      'com.test-notExists': false,
-      'com.test-token': Symbol('s'),
-    };
+  // ── Player-state deduplication ──
+
+  describe('player-state deduplication', () => {
+    it('emits a recordEvent on each unique state transition', () => {
+      const player = createMockPlayer();
+      const {manager} = createManager(player);
+      spyOn(priv(manager)['reporter_'], 'update');
+      spyOn(priv(manager)['reporter_'], 'recordEvent');
+      priv(manager)['setPlayerState_'](PlayerState.PLAYING);
+      priv(manager)['setPlayerState_'](PlayerState.PAUSED);
+      priv(manager)['setPlayerState_'](PlayerState.PLAYING);
+      expect(priv(manager)['reporter_'].recordEvent).toHaveBeenCalledTimes(3);
+    });
 
-    const mockPlayer = new shaka.util.FakeEventTarget();
-    Object.assign(mockPlayer, {
-      isLive: () => true,
-      getLiveLatency: () => 3100,
-      getBandwidthEstimate: () => 10000000,
-      getNetworkingEngine: () => createNetworkingEngine(
-          createCmcdManager(mockPlayer, createCmcdConfig()),
-      ),
-      getBufferedInfo: () => ({
-        video: [
-          {start: 0, end: 15},
-          {start: 6, end: 31.234},
-          {start: 35, end: 40},
-        ],
-      }),
-      getPlaybackRate: () => 1.25,
-      getVariantTracks: () => [
-        {
-          type: 'variant',
-          bandwidth: 50000,
-          videoBandwidth: 40000,
-          audioBandwidth: 10000,
-        },
-        {
-          type: 'variant',
-          bandwidth: 5000000,
-          videoBandwidth: 4000000,
-          audioBandwidth: 1000000,
-        },
-      ],
+    it('suppresses duplicates of the same state', () => {
+      const player = createMockPlayer();
+      const {manager} = createManager(player);
+      spyOn(priv(manager)['reporter_'], 'update');
+      spyOn(priv(manager)['reporter_'], 'recordEvent');
+      priv(manager)['setPlayerState_'](PlayerState.PLAYING);
+      priv(manager)['setPlayerState_'](PlayerState.PLAYING);
+      priv(manager)['setPlayerState_'](PlayerState.PLAYING);
+      expect(priv(manager)['reporter_'].recordEvent).toHaveBeenCalledTimes(1);
     });
 
-    const baseConfig = {
-      enabled: true,
-      sessionId,
-      contentId: 'v2content',
-      rtpSafetyFactor: 5,
-      useHeaders: false,
-      includeKeys: [],
-      version: 2,
-      targets: [{
-        enabled: true,
-        url: 'https://example.com/cmcd-collector',
-        useHeaders: false,
-        events: ['rr'],
-      }],
-    };
+    it('updates with sta wire key on transition', () => {
+      const player = createMockPlayer();
+      const {manager} = createManager(player);
+      spyOn(priv(manager)['reporter_'], 'update');
+      priv(manager)['setPlayerState_'](PlayerState.SEEKING);
+      expect(priv(manager)['reporter_'].update).toHaveBeenCalledWith(
+          {sta: PlayerState.SEEKING});
+    });
+  });
 
-    const createCmcdConfig = (cfg = {}) => Object.assign({}, baseConfig, cfg);
-    const createCmcdManager = (player, cfg = {}) => {
-      const cmcdManager = new CmcdManager(player, createCmcdConfig(cfg));
-      // Mock video element for time calculations
-      const video = new MockCmcdVideo();
-      video.currentTime = 5;
-      cmcdManager.setMediaElement(
+  // ── Player event listener wiring ──
+
+  describe('player event wiring', () => {
+    /** @type {shaka.util.CmcdManager} */
+    let manager;
+    /** @type {shaka.util.FakeEventTarget} */
+    let player;
+    /** @type {!MockCmcdVideo} */
+    let video;
+
+    beforeEach(() => {
+      player = createMockPlayer();
+      const config = createConfig();
+      manager = new CmcdManager(
+          /** @type {!shaka.Player} */ (player), config);
+      video = new MockCmcdVideo();
+      manager.setMediaElement(
           /** @type {!HTMLMediaElement} */ (/** @type {*} */ (video)));
-
-      return cmcdManager;
-    };
-
-    const createRequest = () => ({
-      uris: ['https://test.com/v2test.mpd'],
-      method: 'GET',
-      body: null,
-      headers: {testing: '1234'},
-      allowCrossSiteCredentials: false,
-      retryParameters: {},
     });
 
-    const createResponse = () => ({
-      uri: 'https://test.com/v2seg.mp4',
-      headers: {},
-      data: new ArrayBuffer(8),
-      status: 200,
+    it('translates pause → PAUSED player-state', () => {
+      spyOn(priv(manager)['reporter_'], 'update');
+      spyOn(priv(manager)['reporter_'], 'recordEvent');
+      video.dispatchEvent(new shaka.util.FakeEvent('pause'));
+      expect(priv(manager)['reporter_'].update).toHaveBeenCalledWith(
+          {sta: PlayerState.PAUSED});
+      expect(priv(manager)['reporter_'].recordEvent).toHaveBeenCalledWith(
+          EventType.PLAY_STATE);
     });
 
-    const createResponseWithRealTiming = () => ({
-      uri: 'https://test.com/v2seg.mp4',
-      headers: {},
-      data: new ArrayBuffer(8),
-      timeMs: 400, // This is the TTLB
-      originalRequest: {
-        timeToFirstByte: 150, // This is the TTFB
-      },
+    it('translates seeking → SEEKING player-state', () => {
+      spyOn(priv(manager)['reporter_'], 'recordEvent');
+      video.dispatchEvent(new shaka.util.FakeEvent('seeking'));
+      expect(priv(manager)['reporter_'].recordEvent).toHaveBeenCalledWith(
+          EventType.PLAY_STATE);
     });
 
-    describe('Serialization', () => {
-      it('serializes data to a query string', () => {
-        const query = CmcdManager.toQuery({v: 2, msd: 250});
-        expect(query).toContain('v=2');
-        expect(query).toContain('msd=250');
-      });
-
-      it('serializes data to headers', () => {
-        const headers = CmcdManager.toHeaders(mockPlayerData);
-        expect(headers['CMCD-Session']).toContain(`sid="${sessionId}"`);
-        expect(headers['CMCD-Session']).toContain('v=2');
-      });
+    it('translates ended → ENDED player-state', () => {
+      spyOn(priv(manager)['reporter_'], 'update');
+      video.dispatchEvent(new shaka.util.FakeEvent('ended'));
+      expect(priv(manager)['reporter_'].update).toHaveBeenCalledWith(
+          {sta: PlayerState.ENDED});
     });
 
-    describe('Configuration and Mode Handling', () => {
-      it('filters CMCD response keys correctly', () => {
-        const requestSpy = jasmine.createSpy('request');
-        const networkingEngine = {
-          request: requestSpy,
-          configure: () => {},
-          registerScheme: () => {},
-        };
-        const mockPlayerWithNE = new shaka.util.FakeEventTarget();
-        Object.assign(mockPlayerWithNE, mockPlayer, {
-          getNetworkingEngine: () => networkingEngine,
-        });
-
-        const cmcdManager = createCmcdManager(
-            mockPlayerWithNE,
-            {
-              version: 2,
-              enabled: true,
-              targets: [{
-                enabled: true,
-                url: 'https://example.com/cmcd',
-                includeKeys: ['rc', 'url'],
-                useHeaders: false,
-                events: ['rr'],
-              }],
-            },
-        );
-
-        cmcdManager.onPlaybackPlay_();
-        cmcdManager.onPlaybackPlaying_();
-        const response = createResponse();
-
-        cmcdManager.applyResponseData(
-            shaka.net.NetworkingEngine.RequestType.SEGMENT,
-            response,
-            createSegmentContext(),
-        );
-
-        // Verify that a CMCD request was made
-        expect(requestSpy).toHaveBeenCalled();
-        const request = requestSpy.calls.mostRecent().args[1];
-        const decodedUri = decodeURIComponent(request.uris[0]);
-
-
-        // Check that allowed keys are present
-        expect(decodedUri).toContain('rc=');
-        expect(decodedUri).toContain('url=');
-      });
-
-      it('applies CMCD data to request URL in query mode', () => {
-        const cmcdManager = createCmcdManager(mockPlayer);
-        const request = createRequest();
-        cmcdManager.applyManifestData(request, {});
-
-        const decodedUri = decodeURIComponent(request.uris[0]);
-        expect(decodedUri).toContain('CMCD=');
-        expect(decodedUri).toContain('v=2');
-      });
-
-      it('applies CMCD data to request headers in header mode', () => {
-        const cmcdManager = createCmcdManager(
-            mockPlayer,
-            {useHeaders: true},
-        );
-
-        const request = createRequest();
-        cmcdManager.applyManifestData(request, {});
-        expect(request.headers['CMCD-Session']).toContain(`sid="${sessionId}"`);
-        expect(request.headers['CMCD-Session']).toContain('v=2');
-      });
-
-      it('applies CMCD data to response URL in query mode', () => {
-        const requestSpy = jasmine.createSpy('request');
-        const networkingEngine = {
-          request: requestSpy,
-          configure: () => {},
-          registerScheme: () => {},
-        };
-        const mockPlayerWithNE = new shaka.util.FakeEventTarget();
-        Object.assign(mockPlayerWithNE, mockPlayer, {
-          getNetworkingEngine: () => networkingEngine,
-        });
-
-        const cmcdManager = createCmcdManager(
-            mockPlayerWithNE,
-            {
-              version: 2,
-              enabled: true,
-              targets: [{
-                enabled: true,
-                url: 'https://example.com/cmcd',
-                includeKeys: ['sid', 'cid', 'v'],
-                useHeaders: false,
-                events: ['rr'],
-              }],
-            },
-        );
-
-        cmcdManager.onPlaybackPlay_();
-        cmcdManager.onPlaybackPlaying_();
-
-        const response = createResponse();
-        cmcdManager.applyResponseData(
-            shaka.net.NetworkingEngine.RequestType.SEGMENT,
-            response,
-            createSegmentContext(),
-        );
+    it('translates volumechange → MUTE/UNMUTE event', () => {
+      spyOn(priv(manager)['reporter_'], 'recordEvent');
+      video.muted = true;
+      video.dispatchEvent(new shaka.util.FakeEvent('volumechange'));
+      expect(priv(manager)['reporter_'].recordEvent)
+          .toHaveBeenCalledWith(EventType.MUTE);
+      video.muted = false;
+      video.dispatchEvent(new shaka.util.FakeEvent('volumechange'));
+      expect(priv(manager)['reporter_'].recordEvent)
+          .toHaveBeenCalledWith(EventType.UNMUTE);
+    });
 
-        // Verify that a CMCD request was made
-        expect(requestSpy).toHaveBeenCalled();
-        const request = requestSpy.calls.mostRecent().args[1];
-        const decodedUri = decodeURIComponent(request.uris[0]);
+    it('translates Player buffering event → REBUFFERING/PLAYING', () => {
+      spyOn(priv(manager)['reporter_'], 'update');
+      const evt = new shaka.util.FakeEvent('buffering');
+      evt['buffering'] = true;
+      player.dispatchEvent(evt);
+      expect(priv(manager)['reporter_'].update).toHaveBeenCalledWith(
+          {sta: PlayerState.REBUFFERING});
+      const evt2 = new shaka.util.FakeEvent('buffering');
+      evt2['buffering'] = false;
+      player.dispatchEvent(evt2);
+      expect(priv(manager)['reporter_'].update).toHaveBeenCalledWith(
+          {sta: PlayerState.PLAYING});
+    });
 
-        expect(decodedUri).toContain('CMCD=');
-        expect(decodedUri).toContain('v=2');
-        expect(decodedUri).toContain('sid=');
-        expect(decodedUri).toContain('cid=');
-      });
+    it('translates Player adaptation → BITRATE_CHANGE', () => {
+      spyOn(priv(manager)['reporter_'], 'update');
+      spyOn(priv(manager)['reporter_'], 'recordEvent');
+      player.dispatchEvent(new shaka.util.FakeEvent('adaptation'));
+      expect(priv(manager)['reporter_'].update).toHaveBeenCalledWith(
+          {br: [5000]});
+      expect(priv(manager)['reporter_'].recordEvent).toHaveBeenCalledWith(
+          EventType.BITRATE_CHANGE);
+    });
 
-      it('includes response code in response (query)', () => {
-        const requestSpy = jasmine.createSpy('request');
-        const networkingEngine = {
-          request: requestSpy,
-          configure: () => {},
-          registerScheme: () => {},
-        };
-        const mockPlayerWithNE = new shaka.util.FakeEventTarget();
-        Object.assign(mockPlayerWithNE, mockPlayer, {
-          getNetworkingEngine: () => networkingEngine,
-        });
+    it('translates Player error → FATAL_ERROR + ERROR', () => {
+      spyOn(priv(manager)['reporter_'], 'recordEvent');
+      player.dispatchEvent(new shaka.util.FakeEvent('error'));
+      expect(priv(manager)['reporter_'].recordEvent).toHaveBeenCalledWith(
+          EventType.PLAY_STATE);
+      expect(priv(manager)['reporter_'].recordEvent).toHaveBeenCalledWith(
+          EventType.ERROR);
+    });
 
-        const cmcdManager = createCmcdManager(
-            mockPlayerWithNE,
-            {
-              version: 2,
-              enabled: true,
-              targets: [{
-                enabled: true,
-                url: 'https://example.com/cmcd',
-                includeKeys: ['rc'],
-                useHeaders: false,
-                events: ['rr'],
-              }],
-            },
-        );
+    it('translates Player complete → ENDED player-state', () => {
+      spyOn(priv(manager)['reporter_'], 'update');
+      player.dispatchEvent(new shaka.util.FakeEvent('complete'));
+      expect(priv(manager)['reporter_'].update).toHaveBeenCalledWith(
+          {sta: PlayerState.ENDED});
+    });
+  });
 
-        const response = createResponse();
-        cmcdManager.applyResponseData(
-            shaka.net.NetworkingEngine.RequestType.SEGMENT,
-            response,
-            createSegmentContext(),
-        );
+  // ── Externally-applied URI helpers ──
 
-        // Verify that a CMCD request was made
-        expect(requestSpy).toHaveBeenCalled();
-        const request = requestSpy.calls.mostRecent().args[1];
-        const decodedUri = decodeURIComponent(request.uris[0]);
+  describe('appendSrcData / appendTextTrackData', () => {
+    /** @type {shaka.util.CmcdManager} */
+    let manager;
 
-        expect(decodedUri).toContain('rc=200');
-      });
+    beforeEach(() => {
+      const player = createMockPlayer();
+      const result = createManager(player);
+      manager = result.manager;
+    });
 
-      it('includes response code in response headers', () => {
-        const requestSpy = jasmine.createSpy('request');
-        const networkingEngine = {
-          request: requestSpy,
-          configure: () => {},
-          registerScheme: () => {},
-        };
-        const mockPlayerWithNE = new shaka.util.FakeEventTarget();
-        Object.assign(mockPlayerWithNE, mockPlayer, {
-          getNetworkingEngine: () => networkingEngine,
-        });
+    it('appendSrcData adds CMCD query to a media URI', () => {
+      const out = manager.appendSrcData(
+          'https://test.com/file.mp4', 'video/mp4');
+      expect(out).toContain('CMCD=');
+      // video/mp4 mimeType maps to MUXED (`'av'`).
+      expect(decodeURIComponent(out)).toContain('ot=av');
+    });
 
-        const cmcdManager = createCmcdManager(
-            mockPlayerWithNE,
-            {
-              version: 2,
-              enabled: true,
-              targets: [{
-                enabled: true,
-                url: 'https://example.com/cmcd',
-                includeKeys: ['rc'],
-                useHeaders: true,
-                events: ['rr'],
-              }],
-            },
-        );
+    it('appendTextTrackData adds CMCD query to a text URI', () => {
+      const out = manager.appendTextTrackData('https://test.com/captions.vtt');
+      expect(out).toContain('CMCD=');
+      expect(decodeURIComponent(out)).toContain('ot=c');
+    });
 
-        const response = createResponse();
-        cmcdManager.applyResponseData(
-            shaka.net.NetworkingEngine.RequestType.SEGMENT,
-            response,
-            createSegmentContext(),
-        );
+    it('returns input URI unchanged when disabled', () => {
+      const player = createMockPlayer();
+      const {manager: m2} = createManager(player, {enabled: false});
+      const uri = 'https://test.com/file.mp4';
+      expect(m2.appendSrcData(uri, 'video/mp4')).toBe(uri);
+      expect(m2.appendTextTrackData(uri)).toBe(uri);
+    });
 
-        // Verify that a CMCD request was made
-        expect(requestSpy).toHaveBeenCalled();
-        const request = requestSpy.calls.mostRecent().args[1];
+    it('passes through offline: URIs unchanged', () => {
+      const out = manager.appendSrcData('offline:abc', 'video/mp4');
+      // Offline scheme is rare — appendCmcdQuery treats it as a string and
+      // appends; we accept either no rewrite or a rewrite that preserves
+      // the offline: prefix.
+      expect(out.startsWith('offline:abc')).toBe(true);
+    });
+  });
 
-        expect(request.headers['CMCD-Request']).toContain('rc=200');
-      });
+  // ── Adapter helpers (shaka knowledge) ──
 
-      it('does not include response code if not provided', () => {
-        const requestSpy = jasmine.createSpy('request');
-        const networkingEngine = {
-          request: requestSpy,
-          configure: () => {},
-          registerScheme: () => {},
-        };
-        const mockPlayerWithNE = new shaka.util.FakeEventTarget();
-        Object.assign(mockPlayerWithNE, mockPlayer, {
-          getNetworkingEngine: () => networkingEngine,
-        });
+  describe('adapter helpers', () => {
+    /** @type {shaka.util.CmcdManager} */
+    let manager;
 
-        const cmcdManager = createCmcdManager(
-            mockPlayerWithNE,
-            {
-              version: 2,
-              enabled: true,
-              targets: [{
-                enabled: true,
-                url: 'https://example.com/cmcd',
-                includeKeys: ['rc', 'v'],
-                useHeaders: false,
-                events: ['rr'],
-              }],
-            },
-        );
+    beforeEach(() => {
+      const player = createMockPlayer();
+      const result = createManager(player);
+      manager = result.manager;
+    });
 
-        const response = {
-          uri: 'https://test.com/v2seg.mp4',
-          headers: {},
-          data: new ArrayBuffer(8),
-        };
+    it('getStreamFormat_ maps DASH/HLS', () => {
+      expect(priv(manager)['getStreamFormat_'](AdvancedRequestType.MPD))
+          .toBe(StreamingFormat.DASH);
+      expect(priv(manager)['getStreamFormat_'](
+          AdvancedRequestType.MASTER_PLAYLIST))
+          .toBe(StreamingFormat.HLS);
+      expect(priv(manager)['getStreamFormat_'](
+          AdvancedRequestType.MEDIA_PLAYLIST))
+          .toBe(StreamingFormat.HLS);
+    });
 
-        cmcdManager.applyResponseData(
-            shaka.net.NetworkingEngine.RequestType.SEGMENT,
-            response,
-            createSegmentContext(),
-        );
+    it('getStreamType_ reflects player live state', () => {
+      expect(priv(manager)['getStreamType_']())
+          .toBe(cml.cmcd.CmcdStreamType.VOD);
+    });
 
-        // Verify that a CMCD request was made
-        expect(requestSpy).toHaveBeenCalled();
-        const request = requestSpy.calls.mostRecent().args[1];
-        const decodedUri = decodeURIComponent(request.uris[0]);
+    it('getObjectType_ maps stream type to CmcdObjectType', () => {
+      const ctx = createSegmentContext('video');
+      expect(priv(manager)['getObjectType_'](ctx)).toBe(ObjectType.VIDEO);
+      const audioCtx = createSegmentContext('audio');
+      expect(priv(manager)['getObjectType_'](audioCtx)).toBe(ObjectType.AUDIO);
+    });
 
-        expect(decodedUri).toContain('v=2');
-        expect(decodedUri).toContain('rc=0');
+    it('getObjectType_ returns INIT for INIT_SEGMENT', () => {
+      const ctx = /** @type {shaka.extern.RequestContext} */ ({
+        type: AdvancedRequestType.INIT_SEGMENT,
+        stream: null,
+        segment: null,
       });
+      expect(priv(manager)['getObjectType_'](ctx)).toBe(ObjectType.INIT);
+    });
 
-      it('applies CMCD data to response headers in header mode', () => {
-        const requestSpy = jasmine.createSpy('request');
-        const networkingEngine = {
-          request: requestSpy,
-          configure: () => {},
-          registerScheme: () => {},
-        };
-        const mockPlayerWithNE = new shaka.util.FakeEventTarget();
-        Object.assign(mockPlayerWithNE, mockPlayer, {
-          getNetworkingEngine: () => networkingEngine,
-        });
+    it('getObjectTypeFromMimeType_ maps known MIME types', () => {
+      expect(priv(manager)['getObjectTypeFromMimeType_']('audio/mp4'))
+          .toBe(ObjectType.AUDIO);
+      expect(priv(manager)['getObjectTypeFromMimeType_']('video/mp4'))
+          .toBe(ObjectType.MUXED);
+      expect(priv(manager)['getObjectTypeFromMimeType_'](
+          'application/dash+xml')).toBe(ObjectType.MANIFEST);
+      expect(priv(manager)['getObjectTypeFromMimeType_']('unknown/unknown'))
+          .toBeUndefined();
+    });
 
-        const cmcdManager = createCmcdManager(
-            mockPlayerWithNE,
-            {
-              version: 2,
-              enabled: true,
-              targets: [{
-                enabled: true,
-                url: 'https://example.com/cmcd',
-                includeKeys: ['sid', 'v'],
-                useHeaders: true,
-                events: ['rr'],
-              }],
-            },
-        );
+    it('calculateRtp_ computes bitrate × rtpSafetyFactor', () => {
+      const stream = /** @type {shaka.extern.Stream} */ (
+        {bandwidth: 1000000, type: 'video'});
+      const segment = /** @type {shaka.media.SegmentReference} */ (
+        {startTime: 0, endTime: 4});
+      const rtp = priv(manager)['calculateRtp_'](stream, segment);
+      // segmentSize = 1000000 * 4 / 1000 = 4000
+      // timeToLoad = 20000 / 1 / 1000 = 20
+      // minBandwidth = 4000 / 20 = 200
+      // rtp = 200 * 5 = 1000
+      expect(rtp).toBe(1000);
+    });
+  });
 
-        const response = createResponse();
+  // ── Event-mode dispatch via NetworkingEngine (Bucket C smoke) ──
+
+  describe('event-mode dispatch', () => {
+    it('routes event-mode reports through NetworkingEngine', async () => {
+      const player = createMockPlayer();
+      let captured = null;
+      const networkingEngine = /** @type {shaka.net.NetworkingEngine} */ ({
+        request: jasmine.createSpy('request').and.callFake(
+            (type, request, context) => {
+              captured = {type, request, context};
+              return {
+                promise: Promise.resolve(
+                    {data: new ArrayBuffer(0), uri: '', headers: {}}),
+                abort: () => Promise.resolve(),
+              };
+            }),
+      });
+      player.getNetworkingEngine = () => networkingEngine;
+
+      const {manager} = createManager(player, {
+        eventTargets: [{
+          enabled: true,
+          url: 'https://collector/cmcd',
+          events: [EventType.PLAY_STATE],
+          includeKeys: ['cid', 'sid', 'sta'],
+          interval: 0,
+          batchSize: 1,
+          mode: 'response',
+          useHeaders: false,
+        }],
+      });
+
+      // Trigger a play-state change → reporter queues an event → flushes
+      // via the requester callback → NetworkingEngine.request called.
+      priv(manager)['setPlayerState_'](PlayerState.PLAYING);
+      priv(manager)['reporter_'].flush();
+
+      // Allow the async requester to resolve.
+      await Promise.resolve();
+      await Promise.resolve();
+
+      expect(networkingEngine.request).toHaveBeenCalled();
+      expect(captured.type).toBe(RequestType.TIMING);
+      expect(captured.request.method).toBe('POST');
+    });
+  });
 
-        cmcdManager.applyResponseData(
-            shaka.net.NetworkingEngine.RequestType.SEGMENT,
-            response,
-            createSegmentContext(),
-        );
+  // ── End-to-end smoke (Bucket C) ──
+
+  describe('end-to-end smoke', () => {
+    /**
+     * Build a manager and exercise it end-to-end with a real reporter.
+     * Verifies the encoded wire output for each combination of v1/v2 ×
+     * query/headers transmission mode.
+     *
+     * @param {!Object} configOverrides
+     * @return {string|!Object<string, string>}
+     */
+    function exerciseAndCollect(configOverrides) {
+      const player = createMockPlayer();
+      const {manager} = createManager(player, Object.assign(
+          {includeKeys: ['cid', 'sid', 'ot', 'sf']}, configOverrides));
+      const r = createRequest();
+      manager.applyRequestData(RequestType.MANIFEST, r,
+          /** @type {shaka.extern.RequestContext} */ (
+            {type: AdvancedRequestType.MPD}));
+      return configOverrides.useHeaders ? r.headers : r.uris[0];
+    }
 
-        // Verify that a CMCD request was made
-        expect(requestSpy).toHaveBeenCalled();
-        const request = requestSpy.calls.mostRecent().args[1];
+    it('v1 + query: emits CMCD as URL query parameter', () => {
+      const out = /** @type {string} */ (
+        exerciseAndCollect({version: 1, useHeaders: false}));
+      expect(out).toContain('CMCD=');
+      expect(out).toContain('ot%3Dm');
+    });
 
-        expect(request.headers['CMCD-Session'])
-            .toContain(`sid="${sessionId}"`);
+    it('v2 + query: includes v=2 in the encoded output', () => {
+      const out = /** @type {string} */ (
+        exerciseAndCollect({version: 2, useHeaders: false}));
+      expect(out).toContain('CMCD=');
+      expect(out).toContain('v%3D2');
+    });
 
-        expect(request.headers['CMCD-Session'])
-            .toContain('v=2');
-      });
+    it('v1 + headers: writes CMCD-Object/Request/Session shards', () => {
+      const headers = /** @type {!Object<string, string>} */ (
+        exerciseAndCollect({version: 1, useHeaders: true}));
+      const headerKeys = Object.keys(headers);
+      expect(headerKeys.some((k) => k.startsWith('CMCD-'))).toBe(true);
+    });
 
-      it('applies v2 keys to response uri in response', () => {
-        const requestSpy = jasmine.createSpy('request');
-        const networkingEngine = {
-          request: requestSpy,
-          configure: () => {},
-          registerScheme: () => {},
-        };
-        const mockPlayerWithNE = new shaka.util.FakeEventTarget();
-        Object.assign(mockPlayerWithNE, mockPlayer, {
-          getNetworkingEngine: () => networkingEngine,
-        });
-
-        const cmcdManager = createCmcdManager(
-            mockPlayerWithNE,
-            {
-              version: 2,
-              enabled: true,
-              targets: [{
-                enabled: true,
-                url: 'https://example.com/cmcd-collector',
-                includeKeys: ['sid', 'cid', 'msd', 'ltc', 'v'],
-                useHeaders: false,
-                events: ['rr'],
-              }],
-            },
-        );
-
-        cmcdManager.onPlaybackPlay_();
-        cmcdManager.onPlaybackPlaying_();
-        const response = createResponse();
-
-        cmcdManager.applyResponseData(
-            shaka.net.NetworkingEngine.RequestType.SEGMENT,
-            response,
-            createSegmentContext(),
-        );
-
-        // Verify that a CMCD request was made
-        expect(requestSpy).toHaveBeenCalled();
-        const request = requestSpy.calls.mostRecent().args[1];
-        const decodedUri = decodeURIComponent(request.uris[0]);
-
-        expect(decodedUri).toContain('sid=');
-        expect(decodedUri).toContain('cid=');
-        expect(decodedUri).toContain('msd=');
-        expect(decodedUri).toContain('ltc=');
-        expect(decodedUri).toContain('v=2');
-
-        expect(decodedUri).not.toContain('br=');
-        expect(decodedUri).not.toContain('mtp=');
-      });
-
-      it('filters keys in response based on includeKeys', () => {
-        const requestSpy = jasmine.createSpy('request');
-        const networkingEngine = {
-          request: requestSpy,
-          configure: () => {},
-          registerScheme: () => {},
-        };
-        const mockPlayerWithNE = new shaka.util.FakeEventTarget();
-        Object.assign(mockPlayerWithNE, mockPlayer, {
-          getNetworkingEngine: () => networkingEngine,
-        });
-
-        const cmcdManager = createCmcdManager(
-            mockPlayerWithNE,
-            {
-              version: 2,
-              enabled: true,
-              targets: [{
-                enabled: true,
-                url: 'https://example.com/cmcd-collector',
-                includeKeys: ['sid', 'msd'],
-                useHeaders: false,
-                events: ['rr'],
-              }],
-            },
-        );
-
-        cmcdManager.onPlaybackPlay_();
-        cmcdManager.onPlaybackPlaying_();
-
-        const response = createResponse();
-        cmcdManager.applyResponseData(
-            shaka.net.NetworkingEngine.RequestType.SEGMENT,
-            response,
-            createSegmentContext(),
-        );
-
-        // Verify that a CMCD request was made
-        expect(requestSpy).toHaveBeenCalled();
-        const request = requestSpy.calls.mostRecent().args[1];
-        const decodedUri = decodeURIComponent(request.uris[0]);
-
-        expect(decodedUri).toContain('sid=');
-        expect(decodedUri).toContain('msd=');
-        // CML's prepareCmcdData unconditionally appends `v` for V2 even
-        // when the user's includeKeys filter omits it (CTA-5004-B § 4.1
-        // mandates `v` in V2 output). Old shaka encoder honored the
-        // includeKeys exclusion; spec-aligned behavior wins.
-        expect(decodedUri).toContain('v=2');
-      });
-
-      it('filters keys in request mode based on includeKeys', () => {
-        const cmcdManager = createCmcdManager(
-            mockPlayer,
-            {
-              includeKeys: ['sid', 'msd'],
-            },
-        );
-
-        cmcdManager.onPlaybackPlay_();
-        cmcdManager.onPlaybackPlaying_();
-
-        const request = createRequest();
-        cmcdManager.applyRequestData(
-            shaka.net.NetworkingEngine.RequestType.SEGMENT,
-            request,
-            createSegmentContext(),
-        );
-
-        const decodedUri = decodeURIComponent(request.uris[0]);
-        expect(decodedUri).toContain('sid=');
-        expect(decodedUri).toContain('msd=');
-        // CML auto-adds `v=2` regardless of includeKeys (see "filters
-        // keys in response based on includeKeys" above for full
-        // rationale).
-        expect(decodedUri).toContain('v=2');
-      });
-    });
-
-    describe('CMCD v2 Key Generation', () => {
-      it('sn increments sequence number for each request', () => {
-        const cmcdManager = createCmcdManager(mockPlayer, {
-          includeKeys: ['sn'],
-        });
-        const request1 = createRequest();
-        cmcdManager.applyManifestData(request1, {});
-        expect(decodeURIComponent(request1.uris[0])).toContain('sn=1');
-
-        const request2 = createRequest();
-        cmcdManager.applyManifestData(request2, {});
-        expect(decodeURIComponent(request2.uris[0])).toContain('sn=2');
-      });
-
-      it('sn increments sequence number for each response', () => {
-        const requestSpy = jasmine.createSpy('request');
-        const networkingEngine = {
-          request: requestSpy,
-          configure: () => {},
-          registerScheme: () => {},
-        };
-        const mockPlayerWithNE = new shaka.util.FakeEventTarget();
-        Object.assign(mockPlayerWithNE, mockPlayer, {
-          getNetworkingEngine: () => networkingEngine,
-        });
-
-        const cmcdManager = createCmcdManager(
-            mockPlayerWithNE,
-            {
-              version: 2,
-              enabled: true,
-              targets: [{
-                enabled: true,
-                url: 'https://example.com/cmcd-collector',
-                includeKeys: ['sn'],
-                useHeaders: false,
-                events: ['rr'],
-              }],
-            },
-        );
-
-        const response1 = createResponse();
-        cmcdManager.applyResponseData(
-            shaka.net.NetworkingEngine.RequestType.SEGMENT,
-            response1,
-            createSegmentContext(),
-        );
-
-        // Verify first request was made
-        expect(requestSpy).toHaveBeenCalledTimes(1);
-        const request1 = requestSpy.calls.argsFor(0)[1];
-        expect(decodeURIComponent(request1.uris[0])).toContain('sn=1');
-
-        const response2 = createResponse();
-        cmcdManager.applyResponseData(
-            shaka.net.NetworkingEngine.RequestType.SEGMENT,
-            response2,
-            createSegmentContext(),
-        );
-
-        // Verify second request was made
-        expect(requestSpy).toHaveBeenCalledTimes(2);
-        const request2 = requestSpy.calls.argsFor(1)[1];
-        expect(decodeURIComponent(request2.uris[0])).toContain('sn=2');
-      });
-
-      it('sn increments sequence numbers across multiple targets', () => {
-        const requestSpy = jasmine.createSpy('request');
-        const networkingEngine = {
-          request: requestSpy,
-          configure: () => {},
-          registerScheme: () => {},
-        };
-        const mockPlayerWithNE = new shaka.util.FakeEventTarget();
-        Object.assign(mockPlayerWithNE, mockPlayer, {
-          getNetworkingEngine: () => networkingEngine,
-        });
-
-        const cmcdManager = createCmcdManager(
-            mockPlayerWithNE,
-            {
-              version: 2,
-              enabled: true,
-              targets: [
-                {
-                  enabled: true,
-                  url: 'https://a.collector.com/cmcd',
-                  useHeaders: true,
-                  includeKeys: ['sn'],
-                  events: ['rr'],
-                },
-                {
-                  enabled: true,
-                  url: 'https://b.collector.com/cmcd',
-                  useHeaders: false,
-                  includeKeys: ['sn'],
-                  events: ['rr'],
-                },
-              ],
-            },
-        );
-        const spy = spyOn(cmcdManager, 'sendCmcdRequest_').and.callThrough();
-
-        cmcdManager.applyResponseData(
-            shaka.net.NetworkingEngine.RequestType.SEGMENT,
-            createResponse(),
-            createSegmentContext(),
-        );
-
-        expect(spy).toHaveBeenCalledTimes(2);
-
-        const firstCallForTargetA = spy.calls.all()
-            .find((call) => call.args[1].url === 'https://a.collector.com/cmcd');
-        const firstCallForTargetB = spy.calls.all()
-            .find((call) => call.args[1].url === 'https://b.collector.com/cmcd');
-
-        expect(firstCallForTargetA.args[0].sn).toBe(1);
-        expect(firstCallForTargetB.args[0].sn).toBe(1);
-
-        cmcdManager.applyResponseData(
-            shaka.net.NetworkingEngine.RequestType.SEGMENT,
-            createResponse(),
-            createSegmentContext(),
-        );
-
-        expect(spy).toHaveBeenCalledTimes(4);
-
-        // Collect all calls for each target.
-        const allCallsForTargetA = spy.calls.all()
-            .filter((call) => call.args[1].url === 'https://a.collector.com/cmcd');
-        const allCallsForTargetB = spy.calls.all()
-            .filter((call) => call.args[1].url === 'https://b.collector.com/cmcd');
-
-        expect(allCallsForTargetA.length).toBe(2);
-        expect(allCallsForTargetB.length).toBe(2);
-
-        expect(allCallsForTargetA[0].args[0].sn).toBe(1);
-        expect(allCallsForTargetA[1].args[0].sn).toBe(2);
-
-        expect(allCallsForTargetB[0].args[0].sn).toBe(1);
-        expect(allCallsForTargetB[1].args[0].sn).toBe(2);
-      });
-
-      it('sn ignores disabled response targets', () => {
-        const requestSpy = jasmine.createSpy('request');
-        const networkingEngine = {
-          request: requestSpy,
-          configure: () => {},
-          registerScheme: () => {},
-        };
-        const mockPlayerWithNE = new shaka.util.FakeEventTarget();
-        Object.assign(mockPlayerWithNE, mockPlayer, {
-          getNetworkingEngine: () => networkingEngine,
-        });
-
-        const cmcdManager = createCmcdManager(
-            mockPlayerWithNE,
-            {
-              version: 2,
-              enabled: true,
-              targets: [
-                {
-                  enabled: true,
-                  url: 'https://enabled.collector.com/cmcd',
-                  includeKeys: ['sn'],
-                  events: ['rr'],
-                },
-                {
-                  enabled: false,
-                  url: 'https://disabled.collector.com/cmcd',
-                  includeKeys: ['sn'],
-                  events: ['rr'],
-                },
-              ],
-            },
-        );
-        const spy = spyOn(cmcdManager, 'sendCmcdRequest_').and.callThrough();
-
-        cmcdManager.applyResponseData(
-            shaka.net.NetworkingEngine.RequestType.SEGMENT,
-            createResponse(),
-            createSegmentContext(),
-        );
-
-        expect(spy).toHaveBeenCalledTimes(1);
-        const calledTarget = spy.calls.first().args[1];
-        expect(calledTarget.url).toBe('https://enabled.collector.com/cmcd');
-      });
-
-      it('skips applyResponseSegmentData when targets are disabled', () => {
-        const cmcdManager = createCmcdManager(
-            mockPlayer,
-            {
-              targets: [
-                {
-                  enabled: false,
-                  url: 'https://disabled.collector.com/cmcd',
-                  events: ['rr'],
-                },
-              ],
-            },
-        );
-        const spy = spyOn(cmcdManager, 'applyResponseSegmentData')
-            .and.callThrough();
-
-        cmcdManager.applyResponseData(
-            shaka.net.NetworkingEngine.RequestType.SEGMENT,
-            createResponse(),
-            createSegmentContext(),
-        );
-
-        expect(spy).not.toHaveBeenCalled();
-      });
-
-      it('includes ltc for live content request mode', () => {
-        const cmcdManager = createCmcdManager(
-            mockPlayer,
-            {
-              includeKeys: ['ltc'],
-            },
-        );
-
-        const request = createRequest();
-        cmcdManager.applyManifestData(request, {});
-        expect(decodeURIComponent(request.uris[0])).toContain('ltc=');
-      });
-
-      it('includes ltc for live content response', () => {
-        const requestSpy = jasmine.createSpy('request');
-        const networkingEngine = {
-          request: requestSpy,
-          configure: () => {},
-          registerScheme: () => {},
-        };
-        const mockPlayerWithNE = new shaka.util.FakeEventTarget();
-        Object.assign(mockPlayerWithNE, mockPlayer, {
-          getNetworkingEngine: () => networkingEngine,
-        });
-
-        const cmcdManager = createCmcdManager(
-            mockPlayerWithNE,
-            {
-              version: 2,
-              targets: [{
-                enabled: true,
-                url: 'https://example.com/cmcd',
-                includeKeys: ['sid', 'msd', 'ltc'],
-                useHeaders: false,
-                events: ['rr'],
-              }],
-            },
-        );
-
-        const response = createResponse();
-        cmcdManager.applyResponseData(
-            shaka.net.NetworkingEngine.RequestType.SEGMENT,
-            response,
-            createSegmentContext(),
-        );
-
-        // Verify that a CMCD request was made
-        expect(requestSpy).toHaveBeenCalled();
-        const request = requestSpy.calls.mostRecent().args[1];
-        const decodedUri = decodeURIComponent(request.uris[0]);
-
-        expect(decodedUri).toContain('ltc=');
-      });
-
-      it('sends `msd` only on the first request', () => {
-        const cmcdManager = createCmcdManager(
-            mockPlayer,
-            {
-              targets: [Object.assign({}, baseConfig.targets[0], {
-                includeKeys: ['sid', 'msd'],
-              })],
-            },
-        );
-
-        cmcdManager.onPlaybackPlay_();
-        cmcdManager.onPlaybackPlaying_();
-
-        const request1 = createRequest();
-        cmcdManager.applyManifestData(request1, {});
-        expect(decodeURIComponent(request1.uris[0])).toContain('msd=');
-
-        cmcdManager.onPlaybackPlay_();
-        cmcdManager.onPlaybackPlaying_();
-
-        const request2 = createRequest();
-        cmcdManager.applyManifestData(request2, {});
-        expect(decodeURIComponent(request2.uris[0])).not.toContain('msd=');
-      });
-
-      it('sends msd only on the first response', () => {
-        const requestSpy = jasmine.createSpy('request');
-        const networkingEngine = {
-          request: requestSpy,
-          configure: () => {},
-          registerScheme: () => {},
-        };
-        const mockPlayerWithNE = new shaka.util.FakeEventTarget();
-        Object.assign(mockPlayerWithNE, mockPlayer, {
-          getNetworkingEngine: () => networkingEngine,
-        });
-
-        const cmcdManager = createCmcdManager(
-            mockPlayerWithNE,
-            {
-              targets: [Object.assign({}, baseConfig.targets[0], {
-                includeKeys: ['sid', 'msd'],
-              })],
-            },
-        );
-
-        cmcdManager.onPlaybackPlay_();
-        cmcdManager.onPlaybackPlaying_();
-
-        const response1 = createResponse();
-        cmcdManager.applyResponseData(
-            shaka.net.NetworkingEngine.RequestType.SEGMENT,
-            response1,
-            createSegmentContext(),
-        );
-
-        // Verify that first CMCD request was made and contains msd
-        expect(requestSpy).toHaveBeenCalled();
-        const request1 = requestSpy.calls.mostRecent().args[1];
-        const decodedUri1 = decodeURIComponent(request1.uris[0]);
-        expect(decodedUri1).toContain('msd=');
-
-        // Reset the spy for the second request
-        requestSpy.calls.reset();
-
-        cmcdManager.onPlaybackPlay_();
-        cmcdManager.onPlaybackPlaying_();
-
-        const response2 = createResponse();
-        cmcdManager.applyResponseData(
-            shaka.net.NetworkingEngine.RequestType.SEGMENT,
-            response2,
-            createSegmentContext(),
-        );
-
-        // Verify that second CMCD request was made but does not contain msd
-        expect(requestSpy).toHaveBeenCalled();
-        const request2 = requestSpy.calls.mostRecent().args[1];
-        const decodedUri2 = decodeURIComponent(request2.uris[0]);
-        expect(decodedUri2).not.toContain('msd=');
-      });
-
-      it('should generate "sf" for manifest requests', () => {
-        const cmcdManager = createCmcdManager(mockPlayer);
-        const r = createRequest();
-
-        const context = {
-          type: shaka.net.NetworkingEngine.AdvancedRequestType.MPD,
-        };
-
-        cmcdManager.applyManifestData(r, context);
-        const decoded = decodeURIComponent(r.uris[0]);
-
-        expect(decoded).toContain('sf=d');
-      });
-
-      it('should generate sf for segment responses', () => {
-        const requestSpy = jasmine.createSpy('request');
-        const networkingEngine = {
-          request: requestSpy,
-          configure: () => {},
-          registerScheme: () => {},
-        };
-        const mockPlayerWithNE = new shaka.util.FakeEventTarget();
-        Object.assign(mockPlayerWithNE, mockPlayer, {
-          getNetworkingEngine: () => networkingEngine,
-        });
-
-        const cmcdManager = createCmcdManager(
-            mockPlayerWithNE,
-            {
-              targets: [Object.assign({}, baseConfig.targets[0], {
-                includeKeys: ['sf'],
-              })],
-            },
-        );
-
-        const manifestContext = {
-          type: shaka.net.NetworkingEngine.AdvancedRequestType.MPD,
-        };
-
-        cmcdManager.applyManifestData(createRequest(), manifestContext);
-
-        const response = createResponse();
-        cmcdManager.applyResponseData(
-            shaka.net.NetworkingEngine.RequestType.SEGMENT,
-            response,
-            createSegmentContext(),
-        );
-
-        // Verify that a CMCD request was made
-        expect(requestSpy).toHaveBeenCalled();
-        const request = requestSpy.calls.mostRecent().args[1];
-        const decoded = decodeURIComponent(request.uris[0]);
-
-        expect(decoded).toContain('sf=d');
-      });
-
-      it('should generate "bs" after a rebuffering event request', () => {
-        const cmcdManager = createCmcdManager(mockPlayer);
-        const context = createSegmentContextWithIndex(createMockSegmentIndex());
-
-        cmcdManager.setBuffering(false);
-        cmcdManager.setBuffering(true);
-
-        const r1 = createRequest();
-        cmcdManager.applyRequestSegmentData(r1, context);
-        const decoded1 = decodeURIComponent(r1.uris[0]);
-
-        expect(decoded1).toContain('bs');
-
-        const r2 = createRequest();
-        cmcdManager.applyRequestSegmentData(r2, context);
-        const decoded2 = decodeURIComponent(r2.uris[0]);
-
-        expect(decoded2).not.toContain('bs');
-      });
-
-      it('should generate bs after a rebuffering event response', () => {
-        const requestSpy = jasmine.createSpy('request');
-        const networkingEngine = {
-          request: requestSpy,
-          configure: () => {},
-          registerScheme: () => {},
-        };
-        const mockPlayerWithNE = new shaka.util.FakeEventTarget();
-        Object.assign(mockPlayerWithNE, mockPlayer, {
-          getNetworkingEngine: () => networkingEngine,
-        });
-
-        const cmcdManager = createCmcdManager(
-            mockPlayerWithNE,
-            {
-              targets: [Object.assign({}, baseConfig.targets[0], {
-                includeKeys: ['bs', 'ot'],
-              })],
-            },
-        );
-        const context = createSegmentContext();
-        const response = createResponse();
-
-        cmcdManager.setBuffering(false);
-        cmcdManager.setBuffering(true);
-
-        cmcdManager.applyResponseData(
-            shaka.net.NetworkingEngine.RequestType.SEGMENT,
-            response,
-            context,
-        );
-
-        // Verify that first CMCD request was made and contains bs
-        expect(requestSpy).toHaveBeenCalled();
-        const request1 = requestSpy.calls.mostRecent().args[1];
-        const decodedUri1 = decodeURIComponent(request1.uris[0]);
-
-        expect(decodedUri1).toContain('bs');
-
-        // Reset the spy for the second request
-        requestSpy.calls.reset();
-
-        const response2 = createResponse();
-        cmcdManager.applyResponseData(
-            shaka.net.NetworkingEngine.RequestType.SEGMENT,
-            response2,
-            context,
-        );
-
-        // Verify that second CMCD request was made but does not contain bs
-        expect(requestSpy).toHaveBeenCalled();
-        const request2 = requestSpy.calls.mostRecent().args[1];
-        const decodedUri2 = decodeURIComponent(request2.uris[0]);
-
-        expect(decodedUri2).not.toContain('bs');
-      });
-
-      it('generates `rtp` for segment requests', () => {
-        const cmcdManager = createCmcdManager(
-            mockPlayer,
-            {
-              targets: [Object.assign({}, baseConfig.targets[0], {
-                includeKeys: ['sid', 'msd', 'rtp'],
-              })],
-            },
-        );
-
-        const request = createRequest();
-        const context = createSegmentContextWithIndex(createMockSegmentIndex());
-        cmcdManager.applyRequestSegmentData(request, context);
-        const decodedUri = decodeURIComponent(request.uris[0]);
-        expect(decodedUri).toContain('rtp=');
-      });
-
-      it('request excludes `nrr` key for v2, even if requested', () => {
-        const cmcdManager = createCmcdManager(
-            mockPlayer,
-            {
-              includeKeys: ['nrr', 'rtp'],
-            },
-        );
-        const request = createRequest();
-        const context = createSegmentContextWithIndex(createMockSegmentIndex());
-
-        cmcdManager.applyRequestSegmentData(request, context);
-        const decodedUri = decodeURIComponent(request.uris[0]);
-
-        expect(decodedUri).not.toContain('nrr=');
-        expect(decodedUri).toContain('rtp=');
-      });
-
-
-      it('generates `rtp` for segment responses', () => {
-        const requestSpy = jasmine.createSpy('request');
-        const networkingEngine = {
-          request: requestSpy,
-          configure: () => {},
-          registerScheme: () => {},
-        };
-        const mockPlayerWithNE = new shaka.util.FakeEventTarget();
-        Object.assign(mockPlayerWithNE, mockPlayer, {
-          getNetworkingEngine: () => networkingEngine,
-        });
-
-        const cmcdManager = createCmcdManager(
-            mockPlayerWithNE,
-            {
-              targets: [Object.assign({}, baseConfig.targets[0], {
-                includeKeys: ['sid', 'msd', 'rtp', 'nor'],
-              })],
-            },
-        );
-
-        cmcdManager.onPlaybackPlay_();
-        cmcdManager.onPlaybackPlaying_();
-
-        const response = createResponse();
-
-        cmcdManager.applyResponseData(
-            shaka.net.NetworkingEngine.RequestType.SEGMENT,
-            response,
-            createSegmentContextWithIndex(createMockSegmentIndex()),
-        );
-
-        // Verify that a CMCD request was made
-        expect(requestSpy).toHaveBeenCalled();
-        const request = requestSpy.calls.mostRecent().args[1];
-        const decodedUri = decodeURIComponent(request.uris[0]);
-        expect(decodedUri).toContain('rtp=');
-      });
-
-      it('sends ttfb and ttlb query', () => {
-        const requestSpy = jasmine.createSpy('request');
-        const networkingEngine = {
-          request: requestSpy,
-          configure: () => {},
-          registerScheme: () => {},
-        };
-        const mockPlayerWithNE = new shaka.util.FakeEventTarget();
-        Object.assign(mockPlayerWithNE, mockPlayer, {
-          getNetworkingEngine: () => networkingEngine,
-        });
-
-        const cmcdManager = createCmcdManager(
-            mockPlayerWithNE,
-            {
-              version: 2,
-              targets: [{
-                enabled: true,
-                url: 'https://example.com/cmcd',
-                includeKeys: ['ttfb', 'ttlb'],
-                useHeaders: false,
-                events: ['rr'],
-              }],
-            },
-        );
-
-        const response = createResponseWithRealTiming();
-        cmcdManager.applyResponseData(
-            shaka.net.NetworkingEngine.RequestType.SEGMENT,
-            response,
-            createSegmentContext(),
-        );
-
-        // Verify that a CMCD request was made
-        expect(requestSpy).toHaveBeenCalled();
-        const request = requestSpy.calls.mostRecent().args[1];
-        const decodedUri = decodeURIComponent(request.uris[0]);
-
-        expect(decodedUri).toContain('ttfb=150');
-        expect(decodedUri).toContain('ttlb=400');
-      });
-
-      it('sends ttfb and ttlb in headers', () => {
-        const requestSpy = jasmine.createSpy('request');
-        const networkingEngine = {
-          request: requestSpy,
-          configure: () => {},
-          registerScheme: () => {},
-        };
-        const mockPlayerWithNE = new shaka.util.FakeEventTarget();
-        Object.assign(mockPlayerWithNE, mockPlayer, {
-          getNetworkingEngine: () => networkingEngine,
-        });
-
-        const cmcdManager = createCmcdManager(
-            mockPlayerWithNE,
-            {
-              version: 2,
-              targets: [{
-                enabled: true,
-                url: 'https://example.com/cmcd',
-                includeKeys: ['ttfb', 'ttlb'],
-                useHeaders: true,
-                events: ['rr'],
-              }],
-            },
-        );
-
-        const response = createResponseWithRealTiming();
-        cmcdManager.applyResponseData(
-            shaka.net.NetworkingEngine.RequestType.SEGMENT,
-            response,
-            createSegmentContext(),
-        );
-
-        // Verify that a CMCD request was made
-        expect(requestSpy).toHaveBeenCalled();
-        const request = requestSpy.calls.mostRecent().args[1];
-        expect(request.headers['CMCD-Request']).toContain('ttfb=150');
-        expect(request.headers['CMCD-Request']).toContain('ttlb=400');
-      });
-
-      it('does not generate ttfb or ttlb if timing info is missing', () => {
-        const requestSpy = jasmine.createSpy('request');
-        const networkingEngine = {
-          request: requestSpy,
-          configure: () => {},
-          registerScheme: () => {},
-        };
-        const mockPlayerWithNE = new shaka.util.FakeEventTarget();
-        Object.assign(mockPlayerWithNE, mockPlayer, {
-          getNetworkingEngine: () => networkingEngine,
-        });
-
-        const cmcdManager = createCmcdManager(
-            mockPlayerWithNE,
-            {
-              version: 2,
-              targets: [{
-                enabled: true,
-                url: 'https://example.com/cmcd',
-                includeKeys: ['ttfb', 'ttlb'],
-                useHeaders: false,
-                events: ['rr'],
-              }],
-            },
-        );
-
-        const response = createResponse();
-        cmcdManager.applyResponseData(
-            shaka.net.NetworkingEngine.RequestType.SEGMENT,
-            response,
-            createSegmentContext(),
-        );
-
-        // Verify that a CMCD request was made
-        expect(requestSpy).toHaveBeenCalled();
-        const request = requestSpy.calls.mostRecent().args[1];
-        const decodedUri = decodeURIComponent(request.uris[0]);
-
-        expect(decodedUri).not.toContain('ttfb');
-        expect(decodedUri).not.toContain('ttlb');
-      });
-
-      it('generates nor for URL-based segment responses', () => {
-        const requestSpy = jasmine.createSpy('request');
-        const networkingEngine = {
-          request: requestSpy,
-          configure: () => {},
-          registerScheme: () => {},
-        };
-        const mockPlayerWithNE = new shaka.util.FakeEventTarget();
-        Object.assign(mockPlayerWithNE, mockPlayer, {
-          getNetworkingEngine: () => networkingEngine,
-        });
-
-        const cmcdManager = createCmcdManager(mockPlayerWithNE);
-        const response = createResponse();
-        const context =
-            createSegmentContextWithIndex(createMockNextSegment(false));
-
-        cmcdManager.applyResponseSegmentData(response, context);
-
-        // Verify that a CMCD request was made
-        expect(requestSpy).toHaveBeenCalled();
-        const request = requestSpy.calls.mostRecent().args[1];
-        const decodedUri = decodeURIComponent(request.uris[0]);
-
-        // V2 `nor` is an inner-list `nor=("...")` (CTA-5004-B § 4.1).
-        // Event-mode reports go to a collector at a different origin
-        // from the segment URL, so CML preserves the absolute URL
-        // rather than relativizing.
-        expect(decodedUri).toContain('nor=("https://test.com/next-seg.m4v")');
-        expect(decodedUri).not.toContain('nrr=');
-      });
-
-      it('includes the request URL, without CMCD in event mode', () => {
-        // toContain is not working properly on Tizen 3.
-        if (deviceDetected.getDeviceName() === 'Tizen') {
-          pending('Disabled on Tizen.');
-        }
-
-        // Set up spy for CMCD requests in event mode
-        const requestSpy = jasmine.createSpy('request');
-        const networkingEngine = {
-          request: requestSpy,
-          configure: () => {},
-          registerScheme: () => {},
-        };
-        const mockPlayerWithNE = new shaka.util.FakeEventTarget();
-        Object.assign(mockPlayerWithNE, mockPlayer, {
-          getNetworkingEngine: () => networkingEngine,
-        });
-
-        const cmcdManager = createCmcdManager(
-            mockPlayerWithNE,
-            {
-              version: 2,
-              targets: [{
-                enabled: true,
-                url: 'https://example.com/cmcd',
-                includeKeys: ['url'],
-                useHeaders: false,
-                events: ['rr'],
-              }],
-            },
-        );
-
-        const response = createResponse();
-        response.uri = 'https://redirected.com/v2seg.mp4';
-        response.originalUri = 'https://initial.com/v2seg.mp4?CMCD=br%3D5234%2Cot%3Dv';
-
-        cmcdManager.applyResponseData(
-            shaka.net.NetworkingEngine.RequestType.SEGMENT,
-            response,
-            createSegmentContext(),
-        );
-
-        // Verify that a CMCD request was made
-        expect(requestSpy).toHaveBeenCalled();
-        const request = requestSpy.calls.mostRecent().args[1];
-        const decodedUri = decodeURIComponent(request.uris[0]);
-
-        const expectedCleanUrl = 'https://initial.com/v2seg.mp4';
-        const expectedUrlParam = `url="${expectedCleanUrl}"`;
-        const unexpectedUrlParam = `url="${response.originalUri}"`;
-
-        expect(decodedUri).toContain(expectedUrlParam);
-        expect(decodedUri).not.toContain(unexpectedUrlParam);
-      });
-
-      it('cmcd url key preserves other query parameters', () => {
-        // toContain is not working properly on Tizen 3.
-        if (deviceDetected.getDeviceName() === 'Tizen') {
-          pending('Disabled on Tizen.');
-        }
-
-        // Set up spy for CMCD requests in event mode
-        const requestSpy = jasmine.createSpy('request');
-        const networkingEngine = {
-          request: requestSpy,
-          configure: () => {},
-          registerScheme: () => {},
-        };
-        const mockPlayerWithNE = new shaka.util.FakeEventTarget();
-        Object.assign(mockPlayerWithNE, mockPlayer, {
-          getNetworkingEngine: () => networkingEngine,
-        });
-
-        const cmcdManager = createCmcdManager(mockPlayerWithNE, {
-          version: 2,
-          targets: [{
-            enabled: true,
-            url: 'https://example.com/cmcd',
-            includeKeys: ['url'],
-            useHeaders: false,
-            events: ['rr'],
-          }]},
-        );
-
-        const response = createResponse();
-        response.uri = 'https://redirected.com/v2seg.mp4';
-
-        response.originalUri = 'https://initial.com/v2seg.mp4?foo=bar&CMCD=br%3D5234&baz=qux';
-
-        cmcdManager.applyResponseData(
-            shaka.net.NetworkingEngine.RequestType.SEGMENT,
-            response,
-            createSegmentContext(),
-        );
-
-        // Verify that a CMCD request was made
-        expect(requestSpy).toHaveBeenCalled();
-        const request = requestSpy.calls.mostRecent().args[1];
-        const decodedUri = decodeURIComponent(request.uris[0]);
-
-        const expectedCleanUrl = 'https://initial.com/v2seg.mp4?foo=bar&baz=qux';
-        const expectedUrlParam = `url="${expectedCleanUrl}"`;
-
-        expect(decodedUri).toContain(expectedUrlParam);
-      });
-
-      it('cmcd url key does not modify URL if no CMCD param is present', () => {
-        // Set up spy for CMCD requests in event mode
-        const requestSpy = jasmine.createSpy('request');
-        const networkingEngine = {
-          request: requestSpy,
-          configure: () => {},
-          registerScheme: () => {},
-        };
-        const mockPlayerWithNE = new shaka.util.FakeEventTarget();
-        Object.assign(mockPlayerWithNE, mockPlayer, {
-          getNetworkingEngine: () => networkingEngine,
-        });
-
-        const cmcdManager = createCmcdManager(mockPlayerWithNE, {
-          version: 2,
-          targets: [{
-            enabled: true,
-            url: 'https://example.com/cmcd',
-            includeKeys: ['url'],
-            useHeaders: false,
-            events: ['rr'],
-          }]},
-        );
-
-        const response = createResponse();
-        const originalUrl = 'https://initial.com/v2seg.mp4?foo=bar';
-        response.uri = 'https://redirected.com/v2seg.mp4';
-        response.originalUri = originalUrl;
-
-        cmcdManager.applyResponseData(
-            shaka.net.NetworkingEngine.RequestType.SEGMENT,
-            response,
-            createSegmentContext(),
-        );
-
-        // Verify that a CMCD request was made
-        expect(requestSpy).toHaveBeenCalled();
-        const request = requestSpy.calls.mostRecent().args[1];
-        const decodedUri = decodeURIComponent(request.uris[0]);
-        const expectedUrlParam = `url="${originalUrl}"`;
-
-        expect(decodedUri).toContain(expectedUrlParam);
-      });
-
-      it('cmcd url key preserves URL fragments (hash)', () => {
-        // toContain is not working properly on Tizen 3.
-        if (deviceDetected.getDeviceName() === 'Tizen') {
-          pending('Disabled on Tizen.');
-        }
-
-        // Set up spy for CMCD requests in event mode
-        const requestSpy = jasmine.createSpy('request');
-        const networkingEngine = {
-          request: requestSpy,
-          configure: () => {},
-          registerScheme: () => {},
-        };
-        const mockPlayerWithNE = new shaka.util.FakeEventTarget();
-        Object.assign(mockPlayerWithNE, mockPlayer, {
-          getNetworkingEngine: () => networkingEngine,
-        });
-
-        const cmcdManager = createCmcdManager(mockPlayerWithNE, {
-          version: 2,
-          targets: [{
-            enabled: true,
-            url: 'https://example.com/cmcd',
-            includeKeys: ['url'],
-            useHeaders: false,
-            events: ['rr'],
-          }]},
-        );
-
-        const response = createResponse();
-        response.uri = 'https://redirected.com/v2seg.mp4';
-        response.originalUri = 'https://initial.com/v2seg.mp4?CMCD=br%3D5234#t=10';
-
-        cmcdManager.applyResponseData(
-            shaka.net.NetworkingEngine.RequestType.SEGMENT,
-            response,
-            createSegmentContext(),
-        );
-
-        // Verify that a CMCD request was made
-        expect(requestSpy).toHaveBeenCalled();
-        const request = requestSpy.calls.mostRecent().args[1];
-        const decodedUri = decodeURIComponent(request.uris[0]);
-
-        const expectedCleanUrl = 'https://initial.com/v2seg.mp4#t=10';
-        const expectedUrlParam = `url="${expectedCleanUrl}"`;
-
-        expect(decodedUri).toContain(expectedUrlParam);
-      });
-
-      it('cmcd url key handles an empty CMCD parameter', () => {
-        // toContain is not working properly on Tizen 3.
-        if (deviceDetected.getDeviceName() === 'Tizen') {
-          pending('Disabled on Tizen.');
-        }
-
-        // Set up spy for CMCD requests in event mode
-        const requestSpy = jasmine.createSpy('request');
-        const networkingEngine = {
-          request: requestSpy,
-          configure: () => {},
-          registerScheme: () => {},
-        };
-        const mockPlayerWithNE = new shaka.util.FakeEventTarget();
-        Object.assign(mockPlayerWithNE, mockPlayer, {
-          getNetworkingEngine: () => networkingEngine,
-        });
-
-        const cmcdManager = createCmcdManager(mockPlayerWithNE, {
-          version: 2,
-          targets: [{
-            enabled: true,
-            url: 'https://example.com/cmcd',
-            includeKeys: ['url'],
-            useHeaders: false,
-            events: ['rr'],
-          }]},
-        );
-
-        const response = createResponse();
-        response.uri = 'https://redirected.com/v2seg.mp4';
-        response.originalUri = 'https://initial.com/v2seg.mp4?CMCD=';
-
-        cmcdManager.applyResponseData(
-            shaka.net.NetworkingEngine.RequestType.SEGMENT,
-            response,
-            createSegmentContext(),
-        );
-
-        // Verify that a CMCD request was made
-        expect(requestSpy).toHaveBeenCalled();
-        const request = requestSpy.calls.mostRecent().args[1];
-        const decodedUri = decodeURIComponent(request.uris[0]);
-        const expectedCleanUrl = 'https://initial.com/v2seg.mp4';
-        const expectedUrlParam = `url="${expectedCleanUrl}"`;
-
-        expect(decodedUri).toContain(expectedUrlParam);
-      });
-
-      it('should generate "cmsdd" from response header', () => {
-        const cmcdManager = createCmcdManager(
-            mockPlayer,
-            {
-              targets: [Object.assign({}, baseConfig.targets[0], {
-                includeKeys: ['cmsdd'],
-              })],
-            },
-        );
-
-        const response = createResponse();
-        const cmsddData = `
-          "CDNB-3ak1";
-          etp=96;
-          rtt=8,"CDNB-w35k";
-          etp=76;
-          rtt=32,"CDNA987.343";
-          etp=48;
-          rtt=30,"CDNA-312.663";
-          etp=115;rtt=16;
-          mb=5000'`;
-
-        response.headers['CMSD-Dynamic'] = cmsddData;
-
-        const encodedCmsddData = btoa(cmsddData);
-
-        const spy = spyOn(cmcdManager, 'sendCmcdRequest_').and.callThrough();
-
-        cmcdManager.applyResponseData(
-            shaka.net.NetworkingEngine.RequestType.SEGMENT,
-            response,
-            createSegmentContext(),
-        );
-
-        expect(spy).toHaveBeenCalled();
-        const sentCmcdData = spy.calls.argsFor(0)[0];
-        expect(sentCmcdData.cmsdd.toString())
-            .toBe(encodedCmsddData.toString());
-      });
-
-      it('cmsdd value should be Base64 encoded', () => {
-        const cmcdManager = createCmcdManager(
-            mockPlayer,
-            {
-              targets: [Object.assign({}, baseConfig.targets[0], {
-                includeKeys: ['cmsdd'],
-              })],
-            },
-        );
-
-        const response = createResponse();
-        const cmsddData = `
-          "CDNB-3ak1";
-          etp=96;
-          rtt=8,"CDNB-w35k";
-          etp=76;
-          rtt=32,"CDNA987.343";
-          etp=48;
-          rtt=30,"CDNA-312.663";
-          etp=115;rtt=16;
-          mb=5000'`;
-
-        response.headers['CMSD-Dynamic'] = cmsddData;
-        const encodedCmsddData = btoa(cmsddData);
-
-        const spy = spyOn(cmcdManager, 'sendCmcdRequest_').and.callThrough();
-
-        cmcdManager.applyResponseData(
-            shaka.net.NetworkingEngine.RequestType.SEGMENT,
-            response,
-            createSegmentContext(),
-        );
-
-        expect(spy).toHaveBeenCalled();
-        const sentCmcdData = spy.calls.argsFor(0)[0];
-        expect(sentCmcdData.cmsdd.toString())
-            .toBe(encodedCmsddData.toString());
-      });
-
-      it('should send cmsdd in headers mode', () => {
-        const requestSpy = jasmine.createSpy('request');
-        const networkingEngine = {
-          request: requestSpy,
-          configure: () => {},
-          registerScheme: () => {},
-        };
-        const mockPlayerWithNE = new shaka.util.FakeEventTarget();
-        Object.assign(mockPlayerWithNE, mockPlayer, {
-          getNetworkingEngine: () => networkingEngine,
-        });
-
-        const cmcdManager = createCmcdManager(
-            mockPlayerWithNE,
-            {
-              targets: [Object.assign({}, baseConfig.targets[0], {
-                includeKeys: ['cmsdd'],
-                useHeaders: true,
-              })],
-            },
-        );
-
-        const cmsddData = `
-          "CDNB-3ak1";
-          etp=96;
-          rtt=8,"CDNB-w35k";
-          etp=76;
-          rtt=32,"CDNA987.343";
-          etp=48;
-          rtt=30,"CDNA-312.663";
-          etp=115;rtt=16;
-          mb=5000'`;
-
-        const encodedCmsddData = btoa(cmsddData);
-
-        const response = createResponse();
-        response.headers['CMSD-Dynamic'] = cmsddData;
-
-        cmcdManager.applyResponseData(
-            shaka.net.NetworkingEngine.RequestType.SEGMENT,
-            response,
-            createSegmentContext(),
-        );
-
-        cmcdManager.applyResponseData(
-            shaka.net.NetworkingEngine.RequestType.SEGMENT,
-            response,
-            createSegmentContext(),
-        );
-
-        // Verify that a CMCD request was made
-        expect(requestSpy).toHaveBeenCalled();
-        const request = requestSpy.calls.mostRecent().args[1];
-
-        expect(request.headers['CMCD-Request'])
-            .toContain(`cmsdd="${encodedCmsddData.toString()}"`);
-      });
-
-      it('should not include cmsdd if header is not present', () => {
-        const cmcdManager = createCmcdManager(
-            mockPlayer,
-            {
-              targets: [Object.assign({}, baseConfig.targets[0], {
-                includeKeys: ['cmsdd'],
-              })],
-            },
-        );
-
-        const response = createResponse();
-
-        const spy = spyOn(cmcdManager, 'sendCmcdRequest_').and.callThrough();
-
-        cmcdManager.applyResponseData(
-            shaka.net.NetworkingEngine.RequestType.SEGMENT,
-            response,
-            createSegmentContext());
-
-        const sentCmcdData = spy.calls.argsFor(0)[0];
-        expect(sentCmcdData.cmsdd).toBeUndefined();
-      });
-
-      it('response excludes nrr key for v2, even if requested', () => {
-        // Set up spy for CMCD requests in event mode
-        const requestSpy = jasmine.createSpy('request');
-        const networkingEngine = {
-          request: requestSpy,
-          configure: () => {},
-          registerScheme: () => {},
-        };
-        const mockPlayerWithNE = new shaka.util.FakeEventTarget();
-        Object.assign(mockPlayerWithNE, mockPlayer, {
-          getNetworkingEngine: () => networkingEngine,
-        });
-
-        const cmcdManager = createCmcdManager(
-            mockPlayerWithNE,
-            {
-              targets: [Object.assign({}, baseConfig.targets[0], {
-                includeKeys: ['sid', 'msd', 'rtp', 'nor', 'nrr'],
-              })],
-            },
-        );
-
-        cmcdManager.onPlaybackPlay_();
-        cmcdManager.onPlaybackPlaying_();
-
-        const response = createResponse();
-
-        cmcdManager.applyResponseData(
-            shaka.net.NetworkingEngine.RequestType.SEGMENT,
-            response,
-            createSegmentContextWithIndex(createMockSegmentIndex()),
-        );
-
-        // Verify that a CMCD request was made
-        expect(requestSpy).toHaveBeenCalled();
-        const request = requestSpy.calls.mostRecent().args[1];
-        const decodedUri = decodeURIComponent(request.uris[0]);
-        expect(decodedUri).toContain('rtp=');
-        expect(decodedUri).not.toContain('nrr=');
-      });
-
-
-      it('includes bg in request query when page is hidden', () => {
-        Object.defineProperty(document, 'hidden',
-            {value: true, configurable: true});
-
-        const cmcdManager = createCmcdManager(mockPlayer,
-            {useHeaders: false});
-
-        const request = createRequest();
-        cmcdManager.applyManifestData(request, {});
-        const decodedUri = decodeURIComponent(request.uris[0]);
-        const cmcdQuery = decodedUri.split('CMCD=')[1];
-        expect(`,${cmcdQuery},`).toContain(',bg,');
-      });
-
-      it('includes bg in request headers when page is hidden', () => {
-        Object.defineProperty(document, 'hidden',
-            {value: true, configurable: true});
-
-        const cmcdManager = createCmcdManager(mockPlayer,
-            {useHeaders: true});
-
-        const request = createRequest();
-        cmcdManager.applyManifestData(request, {});
-        expect(request.headers['CMCD-Status']).toContain('bg');
-      });
-
-      it('does not include bg in request mode when page is visible', () => {
-        Object.defineProperty(document, 'hidden',
-            {value: false, configurable: true});
-
-        const cmcdManager = createCmcdManager(mockPlayer,
-            {useHeaders: true});
-
-
-        const request = createRequest();
-        cmcdManager.applyManifestData(request, {});
-        if (request.headers['CMCD-Status']) {
-          expect(request.headers['CMCD-Status']).not.toContain('bg');
-        } else {
-          expect(request.headers['CMCD-Status']).toBeUndefined();
-        }
-      });
-
-
-      it('assigns bg to the CMCD-Status header in request mode', () => {
-        Object.defineProperty(document, 'hidden',
-            {value: true, configurable: true});
-
-        const cmcdManager = createCmcdManager(mockPlayer,
-            {useHeaders: true});
-
-        const request = createRequest();
-        cmcdManager.applyRequestSegmentData(request, createSegmentContext());
-        expect(request.headers['CMCD-Status']).toBeDefined();
-        expect(request.headers['CMCD-Status']).toContain('bg');
-      });
-
-      it('request does not include v2 keys if version is not 2', () => {
-        const nonV2Manager = createCmcdManager(
-            mockPlayer,
-            {version: 1, includeKeys: ['msd', 'ltc']},
-        );
-        const request = createRequest();
-        nonV2Manager.applyManifestData(request, {});
-        const decodedUri = decodeURIComponent(request.uris[0]);
-        expect(decodedUri).not.toContain('msd=');
-        expect(decodedUri).not.toContain('ltc=');
-      });
-
-      it('does not include ts for segment requests', () => {
-        // Per CTA-5004-B § 4.1, `ts` is an event-only key. Old shaka
-        // emitted it in request-mode CMCD too; CML's request-mode
-        // filter (`isCmcdRequestKey`) correctly excludes it. The
-        // following `includes ts for segment responses` test confirms
-        // `ts` still appears for event-mode (response-received)
-        // reports, which is where it belongs.
-        const cmcdManager = createCmcdManager(mockPlayer, {version: 2});
-        const request = createRequest();
-        const context = createSegmentContext();
-        cmcdManager.applyRequestSegmentData(request, context);
-        const decodedUri = decodeURIComponent(request.uris[0]);
-        expect(decodedUri).not.toContain('ts=');
-      });
-
-      it('includes ts for segment responses', () => {
-        const requestSpy = jasmine.createSpy('request');
-        const networkingEngine = {
-          request: requestSpy,
-          configure: () => {},
-          registerScheme: () => {},
-        };
-        const mockPlayerWithNE = new shaka.util.FakeEventTarget();
-        Object.assign(mockPlayerWithNE, mockPlayer, {
-          getNetworkingEngine: () => networkingEngine,
-        });
-
-        const cmcdManager = createCmcdManager(mockPlayerWithNE, {
-          version: 2,
-          targets: [{
-            enabled: true,
-            url: 'https://example.com/cmcd',
-            includeKeys: ['ts'],
-            useHeaders: false,
-            events: ['rr'],
-          }],
-        });
-        const response = createResponse();
-        const context = createSegmentContext();
-        cmcdManager.applyResponseData(
-            shaka.net.NetworkingEngine.RequestType.SEGMENT,
-            response,
-            context,
-        );
-
-        // Verify that a CMCD request was made
-        expect(requestSpy).toHaveBeenCalled();
-        const request = requestSpy.calls.mostRecent().args[1];
-        const decodedUri = decodeURIComponent(request.uris[0]);
-        expect(decodedUri).toContain('ts=');
-      });
-
-      it('includes ts for segment responses in headers', () => {
-        const networkingEngine = createNetworkingEngine(null);
-        const networkingEngineSpy = spyOn(networkingEngine, 'request')
-            .and.callFake(
-                () => shaka.util.AbortableOperation.completed(
-                    {uri: '', data: new ArrayBuffer(5), headers: {}}),
-            );
-
-        const playerWithSpy = new shaka.util.FakeEventTarget();
-        Object.assign(playerWithSpy, mockPlayer, {
-          getNetworkingEngine: () => networkingEngine,
-        });
-
-        const cmcdManager = createCmcdManager(playerWithSpy, {
-          version: 2,
-          targets: [{
-            enabled: true,
-            url: 'https://example.com/cmcd',
-            includeKeys: ['ts'],
-            useHeaders: true,
-            events: ['rr'],
-          }],
-        });
-        const response = createResponse();
-        const context = createSegmentContext();
-        cmcdManager.applyResponseData(
-            shaka.net.NetworkingEngine.RequestType.SEGMENT,
-            response,
-            context,
-        );
-
-        expect(networkingEngineSpy).toHaveBeenCalledTimes(1);
-        const cmcdRequest = networkingEngineSpy.calls.first().args[1];
-        expect(cmcdRequest.headers['CMCD-Request']).toContain('ts=');
-      });
-
-      it('reuses request timestamp for event mode', () => {
-        const requestSpy = jasmine.createSpy('request');
-        const networkingEngine = {
-          request: requestSpy,
-          configure: () => {},
-          registerScheme: () => {},
-        };
-        const mockPlayerWithNE = new shaka.util.FakeEventTarget();
-        Object.assign(mockPlayerWithNE, mockPlayer, {
-          getNetworkingEngine: () => networkingEngine,
-        });
-
-        const cmcdManager = createCmcdManager(mockPlayerWithNE, {
-          version: 2,
-          targets: [{
-            enabled: true,
-            url: 'https://example.com/cmcd',
-            includeKeys: ['ts'],
-            useHeaders: false,
-            events: ['rr'],
-          }],
-        });
-
-        const request = createRequest();
-        const response = createResponse();
-        const context = createSegmentContext();
-
-        response.originalRequest = request;
-
-        let fakeTimestamp = 1234567890000;
-        spyOn(Date, 'now').and.callFake(() => fakeTimestamp);
-
-        cmcdManager.applyRequestSegmentData(request, context);
-
-        fakeTimestamp = 9876543210000;
-        cmcdManager.applyResponseData(
-            shaka.net.NetworkingEngine.RequestType.SEGMENT,
-            response,
-            context,
-        );
-
-        // Verify that a CMCD request was made
-        expect(requestSpy).toHaveBeenCalled();
-        const cmcdRequest = requestSpy.calls.mostRecent().args[1];
-        const decodedUri = decodeURIComponent(cmcdRequest.uris[0]);
-        expect(decodedUri).toContain('ts=1234567890000');
-        expect(decodedUri).not.toContain('ts=9876543210000');
-      });
-
-      it('sends the same timestamp to multiple event mode targets', () => {
-        const networkingEngine = createNetworkingEngine(null);
-        const networkingEngineSpy = spyOn(networkingEngine, 'request')
-            .and.callFake(
-                () => shaka.util.AbortableOperation.completed(
-                    {uri: '', data: new ArrayBuffer(5), headers: {}}),
-            );
-
-        const playerWithSpy = new shaka.util.FakeEventTarget();
-        Object.assign(playerWithSpy, mockPlayer, {
-          getNetworkingEngine: () => networkingEngine,
-        });
-
-        const cmcdManager = createCmcdManager(
-            playerWithSpy,
-            {
-              version: 2,
-              targets: [{
-                enabled: true,
-                url: 'https://example.com/cmcd-query',
-                includeKeys: ['ts'],
-                useHeaders: false,
-                events: ['rr'],
-              }, {
-                enabled: true,
-                url: 'https://example.com/cmcd-header',
-                includeKeys: ['ts'],
-                useHeaders: true,
-                events: ['rr'],
-              }],
-            },
-        );
-
-        const request = createRequest();
-        const response = createResponse();
-        const context = createSegmentContext();
-
-        response.originalRequest = request;
-
-        let fakeTimestamp = 1234567890000;
-        spyOn(Date, 'now').and.callFake(() => fakeTimestamp);
-
-        cmcdManager.applyRequestSegmentData(request, context);
-
-        fakeTimestamp = 9876543210000;
-
-        cmcdManager.applyResponseData(
-            shaka.net.NetworkingEngine.RequestType.SEGMENT,
-            response,
-            context,
-        );
-        expect(networkingEngineSpy).toHaveBeenCalledTimes(2);
-
-        const queryTargetCall = networkingEngineSpy.calls.all().find((call) =>
-          call.args[1].uris[0].startsWith('https://example.com/cmcd-query'));
-
-        const headerTargetCall = networkingEngineSpy.calls.all().find((call) =>
-          call.args[1].uris[0].startsWith('https://example.com/cmcd-header'));
-
-        expect(queryTargetCall).withContext(
-            'Query target call not found').toBeDefined();
-        expect(headerTargetCall).withContext(
-            'Header target call not found').toBeDefined();
-
-        const queryRequest = queryTargetCall.args[1];
-        const decodedQueryUri = decodeURIComponent(queryRequest.uris[0]);
-        expect(decodedQueryUri).toContain('ts=1234567890000');
-        expect(decodedQueryUri).not.toContain('ts=9876543210000');
-
-        const headerRequest = headerTargetCall.args[1];
-        expect(headerRequest.headers['CMCD-Request'])
-            .toContain('ts=1234567890000');
-
-        expect(headerRequest.headers['CMCD-Request'])
-            .not.toContain('ts=9876543210000');
-      });
-
-      it('includes timestamp in event mode when request is disabled', () => {
-        const networkingEngine = createNetworkingEngine(null);
-        const networkingEngineSpy = spyOn(networkingEngine, 'request')
-            .and.callFake(
-                () => shaka.util.AbortableOperation.completed(
-                    {uri: '', data: new ArrayBuffer(5), headers: {}}));
-
-        const playerWithSpy = new shaka.util.FakeEventTarget();
-        Object.assign(playerWithSpy, mockPlayer, {
-          getNetworkingEngine: () => networkingEngine,
-        });
-
-        const cmcdManager = createCmcdManager(playerWithSpy, {
-          enabled: false,
-          version: 2,
-          targets: [{
-            enabled: true,
-            url: 'https://example.com/cmcd-query',
-            includeKeys: ['ts'],
-            useHeaders: false,
-            events: ['rr'],
-          }],
-        });
-
-        const request = createRequest();
-        const response = createResponse();
-        const context = createSegmentContext();
-
-        cmcdManager.applyRequestSegmentData(request, context);
-        expect(request.uris[0]).toBe('https://test.com/v2test.mpd');
-
-        const fakeTimestamp = 1234567890000;
-        spyOn(Date, 'now').and.callFake(() => fakeTimestamp);
-
-        cmcdManager.applyResponseData(
-            shaka.net.NetworkingEngine.RequestType.SEGMENT,
-            response,
-            context,
-        );
-
-        expect(networkingEngineSpy).toHaveBeenCalledTimes(1);
-
-        const queryTargetCall = networkingEngineSpy.calls.first();
-        const queryRequest = queryTargetCall.args[1];
-        const decodedQueryUri = decodeURIComponent(queryRequest.uris[0]);
-        expect(decodedQueryUri).toContain('ts=1234567890000');
-      });
-
-      it('response does not include v2 keys if version is not 2', () => {
-        const nonV2Manager = createCmcdManager(
-            mockPlayer,
-            {version: 1, includeKeys: ['msd', 'ltc']},
-        );
-        const response = createResponse();
-        nonV2Manager.applyResponseData(response, {});
-
-        const decodedUri = decodeURIComponent(response.uri);
-        expect(decodedUri).not.toContain('msd=');
-        expect(decodedUri).not.toContain('ltc=');
-      });
-
-      it('cmcd does not include the url parameter for CMCD v1', () => {
-        const cmcdManager = createCmcdManager(
-            mockPlayer, {
-              // Only set version to 1, use default targets (no events)
-              version: 1,
-            },
-        );
-
-        const request = createRequest();
-        request.uris = ['https://initial.com/v2seg.mp4'];
-
-        cmcdManager.applyRequestData(
-            shaka.net.NetworkingEngine.RequestType.SEGMENT,
-            request,
-            createSegmentContext(),
-        );
-
-        const decodedUri = decodeURIComponent(request.uris[0]);
-
-        expect(decodedUri).not.toContain('url=');
-      });
-    });
-
-    it('should generate cmsds from response header', () => {
-      const cmcdManager = createCmcdManager(
-          mockPlayer,
-          {
-            targets: [Object.assign({}, baseConfig.targets[0], {
-              includeKeys: ['cmsds'],
-            })],
-          },
-      );
-
-      const response = createResponse();
-      const cmsdsData = `ot=v,sf=h,st=v,d=5000,br=2000,n="OriginProviderA"`;
-
-      response.headers['CMSD-Static'] = cmsdsData;
-
-      const encodedCmsdsData = btoa(cmsdsData);
-
-      const spy = spyOn(cmcdManager, 'sendCmcdRequest_').and.callThrough();
-
-      cmcdManager.applyResponseData(
-          shaka.net.NetworkingEngine.RequestType.SEGMENT,
-          response,
-          createSegmentContext(),
-      );
-
-      expect(spy).toHaveBeenCalled();
-      const sentCmcdData = spy.calls.argsFor(0)[0];
-      expect(sentCmcdData.cmsds.toString())
-          .toBe(encodedCmsdsData.toString());
-    });
-
-    it('cmsds value should be Base64 encoded', () => {
-      const cmcdManager = createCmcdManager(
-          mockPlayer,
-          {
-            targets: [Object.assign({}, baseConfig.targets[0], {
-              includeKeys: ['cmsds'],
-            })],
-          },
-      );
-
-      const response = createResponse();
-      const cmsdsData = `ot=v,sf=h,st=v,d=5000,br=2000,n="OriginProviderA"`;
-
-      response.headers['CMSD-Static'] = cmsdsData;
-      const encodedCmsdsData = btoa(cmsdsData);
-
-      const spy = spyOn(cmcdManager, 'sendCmcdRequest_').and.callThrough();
-
-      cmcdManager.applyResponseData(
-          shaka.net.NetworkingEngine.RequestType.SEGMENT,
-          response,
-          createSegmentContext(),
-      );
-
-      expect(spy).toHaveBeenCalled();
-      const sentCmcdData = spy.calls.argsFor(0)[0];
-      expect(sentCmcdData.cmsds.toString())
-          .toBe(encodedCmsdsData.toString());
-    });
-
-    it('should send cmsds in headers mode', () => {
-      // Set up spy for CMCD requests in event mode
-      const requestSpy = jasmine.createSpy('request');
-      const networkingEngine = {
-        request: requestSpy,
-        configure: () => {},
-        registerScheme: () => {},
-      };
-      const mockPlayerWithNE = new shaka.util.FakeEventTarget();
-      Object.assign(mockPlayerWithNE, mockPlayer, {
-        getNetworkingEngine: () => networkingEngine,
-      });
-
-      const cmcdManager = createCmcdManager(
-          mockPlayerWithNE,
-          {
-            targets: [Object.assign({}, baseConfig.targets[0], {
-              includeKeys: ['cmsds'],
-              useHeaders: true,
-            })],
-          },
-      );
-
-      const cmsdsData = `ot=v,sf=h,st=v,d=5000,br=2000,n="OriginProviderA"`;
-      const encodedCmsdsData = btoa(cmsdsData);
-
-      const response = createResponse();
-      response.headers['CMSD-Static'] = cmsdsData;
-
-      cmcdManager.applyResponseData(
-          shaka.net.NetworkingEngine.RequestType.SEGMENT,
-          response,
-          createSegmentContext(),
-      );
-
-      cmcdManager.applyResponseData(
-          shaka.net.NetworkingEngine.RequestType.SEGMENT,
-          response,
-          createSegmentContext(),
-      );
-
-      // Verify that a CMCD request was made
-      expect(requestSpy).toHaveBeenCalled();
-      const request = requestSpy.calls.mostRecent().args[1];
-
-      expect(request.headers['CMCD-Request'])
-          .toContain(`cmsds="${encodedCmsdsData.toString()}"`);
-    });
-
-    it('should not include cmsds if header is not present', () => {
-      const cmcdManager = createCmcdManager(
-          mockPlayer,
-          {
-            targets: [Object.assign({}, baseConfig.targets[0], {
-              includeKeys: ['cmsds'],
-            })],
-          },
-      );
-
-      const response = createResponse();
-
-      const spy = spyOn(cmcdManager, 'sendCmcdRequest_').and.callThrough();
-
-      cmcdManager.applyResponseData(
-          shaka.net.NetworkingEngine.RequestType.SEGMENT,
-          response,
-          createSegmentContext());
-
-      const sentCmcdData = spy.calls.argsFor(0)[0];
-      expect(sentCmcdData.cmsds).toBeUndefined();
-    });
-
-    // region CMCD V2 Event mode
-    describe('Event Mode', () => {
-      /**
-       * A mock media element that extends FakeEventTarget and adds properties
-       * for testing CMCD event mode.
-       * @extends {shaka.util.FakeEventTarget}
-       */
-      class MockMediaElement extends shaka.util.FakeEventTarget {
-        constructor() {
-          super();
-          /** @type {boolean} */
-          this.muted = false;
-        }
-      }
-
-      let networkingEngine;
-      let requestSpy;
-      /** @type {shaka.util.FakeEventTarget} */
-      let mockPlayerWithNE;
-
-      beforeEach(() => {
-        requestSpy = jasmine.createSpy('request');
-        networkingEngine = {
-          request: requestSpy,
-          configure: () => {},
-          registerScheme: () => {},
-        };
-        mockPlayerWithNE = new shaka.util.FakeEventTarget();
-        Object.assign(mockPlayerWithNE, mockPlayer, {
-          getNetworkingEngine: () => networkingEngine,
-        });
-      });
-
-      it('sends player state change events', () => {
-        const mockVideo = new shaka.util.FakeEventTarget();
-        const config = {
-          version: 2,
-          enabled: true,
-          targets: [{
-            enabled: true,
-            url: 'https://example.com/cmcd',
-            includeKeys: ['e', 'sta', 'v'],
-            events: ['ps'],
-          }],
-        };
-
-        const cmcdManager = createCmcdManager(
-            mockPlayerWithNE,
-            config,
-        );
-        cmcdManager.setMediaElement(mockVideo);
-        cmcdManager.configure(config);
-
-        mockVideo.dispatchEvent(new shaka.util.FakeEvent('play'));
-        let request = /** @type {!jasmine.Spy} */ (requestSpy)
-            .calls.mostRecent().args[1];
-        let decodedUri = decodeURIComponent(request.uris[0]);
-        expect(decodedUri).toContain('e=ps');
-        expect(decodedUri).toContain('sta=s');
-        expect(decodedUri).toContain('v=2');
-
-        mockVideo.dispatchEvent(new shaka.util.FakeEvent('playing'));
-        request = /** @type {!jasmine.Spy} */ (requestSpy)
-            .calls.mostRecent().args[1];
-        decodedUri = decodeURIComponent(request.uris[0]);
-        expect(decodedUri).toContain('e=ps');
-        expect(decodedUri).toContain('sta=p');
-        expect(decodedUri).toContain('v=2');
-
-        mockVideo.dispatchEvent(new shaka.util.FakeEvent('pause'));
-        request = /** @type {!jasmine.Spy} */ (requestSpy)
-            .calls.mostRecent().args[1];
-        decodedUri = decodeURIComponent(request.uris[0]);
-        expect(decodedUri).toContain('e=ps');
-        expect(decodedUri).toContain('sta=a');
-
-        mockVideo.dispatchEvent(new shaka.util.FakeEvent('seeking'));
-        request = /** @type {!jasmine.Spy} */ (requestSpy)
-            .calls.mostRecent().args[1];
-        decodedUri = decodeURIComponent(request.uris[0]);
-        expect(decodedUri).toContain('e=ps');
-        expect(decodedUri).toContain('sta=k');
-      });
-
-      it('sends mute and unmute events', () => {
-        const mockMediaElement = /** @type {!MockMediaElement} */ (
-          new MockMediaElement());
-
-        const config = {
-          version: 2,
-          enabled: true,
-          targets: [{
-            enabled: true,
-            url: 'https://example.com/cmcd',
-            includeKeys: ['e', 'sta', 'v'],
-            events: ['m', 'um'],
-          }],
-        };
-
-        const cmcdManager = createCmcdManager(mockPlayerWithNE, config);
-        cmcdManager.setMediaElement(mockMediaElement);
-
-        // Mute
-        mockMediaElement.muted = true;
-        mockMediaElement.dispatchEvent(
-            new shaka.util.FakeEvent('volumechange'),
-        );
-
-        let request = /** @type {!jasmine.Spy} */ (requestSpy)
-            .calls.mostRecent().args[1];
-        let decodedUri = decodeURIComponent(request.uris[0]);
-        expect(decodedUri).toContain('e=m');
-        expect(decodedUri).toContain('v=2');
-
-        // Unmute
-        mockMediaElement.muted = false;
-        mockMediaElement.dispatchEvent(
-            new shaka.util.FakeEvent('volumechange'),
-        );
-
-        request = /** @type {!jasmine.Spy} */ (requestSpy)
-            .calls.mostRecent().args[1];
-        decodedUri = decodeURIComponent(request.uris[0]);
-        expect(decodedUri).toContain('e=um');
-      });
-
-      describe('Time interval events', () => {
-        beforeEach(() => jasmine.clock().install());
-        afterEach(() => jasmine.clock().uninstall());
-
-        it('sends time interval events', () => {
-          const mockVideo = new shaka.util.FakeEventTarget();
-          const config = {
-            version: 2,
-            enabled: true,
-            targets: [{
-              enabled: true,
-              url: 'https://example.com/cmcd',
-              timeInterval: 1,
-              includeKeys: ['e', 'v'],
-            }],
-          };
-
-          const cmcdManager = createCmcdManager(
-              mockPlayerWithNE,
-              config,
-          );
-          cmcdManager.setMediaElement(mockVideo);
-          cmcdManager.configure(config);
-
-          mockVideo.dispatchEvent(new shaka.util.FakeEvent('play'));
-
-          jasmine.clock().tick(1001);
-          const request = /** @type {!jasmine.Spy} */ (requestSpy)
-              .calls.mostRecent().args[1];
-          const decodedUri = decodeURIComponent(request.uris[0]);
-          expect(decodedUri).toContain('e=t');
-          expect(decodedUri).toContain('v=2');
-        });
-
-        it('does not send time interval events when timeInterval is 0', () => {
-          const mockVideo = new shaka.util.FakeEventTarget();
-          const config = {
-            version: 2,
-            enabled: true,
-            targets: [{
-              enabled: true,
-              url: 'https://example.com/cmcd',
-              timeInterval: 0,
-            }],
-          };
-
-          const cmcdManager = createCmcdManager(
-              mockPlayerWithNE,
-              config,
-          );
-          cmcdManager.setMediaElement(mockVideo);
-          cmcdManager.configure(config);
-
-          mockVideo.dispatchEvent(new shaka.util.FakeEvent('play'));
-          expect(requestSpy).toHaveBeenCalledTimes(1);
-
-          jasmine.clock().tick(20000);
-
-          expect(requestSpy).toHaveBeenCalledTimes(1);
-        });
-
-        it('uses default time interval when not specified', () => {
-          const mockVideo = new shaka.util.FakeEventTarget();
-          const config = {
-            version: 2,
-            enabled: true,
-            targets: [{
-              enabled: true,
-              url: 'https://example.com/cmcd',
-              // timeInterval is not defined, should default to 10s.
-              includeKeys: ['e', 'v'],
-            }],
-          };
-
-          const cmcdManager = createCmcdManager(
-              mockPlayerWithNE,
-              config,
-          );
-          cmcdManager.setMediaElement(mockVideo);
-          cmcdManager.configure(config);
-
-          mockVideo.dispatchEvent(new shaka.util.FakeEvent('play'));
-          expect(requestSpy).not.toHaveBeenCalled();
-
-          // Default time interval is 10 seconds.
-          jasmine.clock().tick(10001);
-
-          expect(requestSpy).toHaveBeenCalledTimes(1);
-          const request = /** @type {!jasmine.Spy} */ (requestSpy)
-              .calls.mostRecent().args[1];
-          const decodedUri = decodeURIComponent(request.uris[0]);
-          expect(decodedUri).toContain('e=t');
-          expect(decodedUri).toContain('v=2');
-        });
-      });
-
-      it('sends `msd` only on the first event', () => {
-        const mockVideo = new shaka.util.FakeEventTarget();
-        const cmcdManager = createCmcdManager(
-            mockPlayerWithNE,
-            {
-              targets: [{
-                enabled: true,
-                url: 'https://example.com/cmcd',
-                includeKeys: ['msd', 'e', 'sta'],
-              }],
-            },
-        );
-        cmcdManager.setMediaElement(mockVideo);
-        cmcdManager.onPlaybackPlay_();
-        cmcdManager.onPlaybackPlaying_();
-
-        mockVideo.dispatchEvent(new shaka.util.FakeEvent('play'));
-        let request = /** @type {!jasmine.Spy} */ (requestSpy)
-            .calls.mostRecent().args[1];
-
-        expect(requestSpy).toHaveBeenCalled();
-
-        mockVideo.dispatchEvent(new shaka.util.FakeEvent('playing'));
-        request = /** @type {!jasmine.Spy} */ (requestSpy)
-            .calls.mostRecent().args[1];
-        expect(requestSpy).toHaveBeenCalled();
-
-        let decodedUri = decodeURIComponent(request.uris[0]);
-        expect(decodedUri).toContain('msd=');
-
-        mockVideo.dispatchEvent(new shaka.util.FakeEvent('pause'));
-        request = /** @type {!jasmine.Spy} */ (requestSpy)
-            .calls.mostRecent().args[1];
-        expect(requestSpy).toHaveBeenCalled();
-
-        decodedUri = decodeURIComponent(request.uris[0]);
-        expect(decodedUri).not.toContain('msd=');
-
-        mockVideo.dispatchEvent(new shaka.util.FakeEvent('play'));
-        request = /** @type {!jasmine.Spy} */ (requestSpy)
-            .calls.mostRecent().args[1];
-        expect(requestSpy).toHaveBeenCalled();
-
-        decodedUri = decodeURIComponent(request.uris[0]);
-        expect(decodedUri).not.toContain('msd=');
-      });
-
-      it('filters events based on the target configuration', () => {
-        const mockMediaElement = /** @type {!MockMediaElement} */ (
-          new MockMediaElement());
-
-        const config = {
-          version: 2,
-          enabled: true,
-          targets: [{
-            enabled: true,
-            url: 'https://example.com/cmcd',
-            includeKeys: ['e', 'sta'],
-            events: ['m'],
-          }],
-        };
-
-        const cmcdManager = createCmcdManager(mockPlayerWithNE, config);
-        cmcdManager.setMediaElement(mockMediaElement);
-
-        mockMediaElement.dispatchEvent(new shaka.util.FakeEvent('play'));
-
-        expect(requestSpy).not.toHaveBeenCalled();
-
-        mockMediaElement.dispatchEvent(new shaka.util.FakeEvent('pause'));
-        // Should not have been called again for 'pause'
-        expect(requestSpy).not.toHaveBeenCalled();
-
-        mockMediaElement.dispatchEvent(new shaka.util.FakeEvent('seeking'));
-        // Should not have been called again for 'seeking'
-        expect(requestSpy).not.toHaveBeenCalled();
-
-        // Mute
-        /** @type boolean */
-        mockMediaElement.muted = true;
-        mockMediaElement.dispatchEvent(
-            new shaka.util.FakeEvent('volumechange'),
-        );
-
-        const request = /** @type {!jasmine.Spy} */ (requestSpy)
-            .calls.mostRecent().args[1];
-
-        const decodedUri = decodeURIComponent(request.uris[0]);
-        expect(decodedUri).toContain('e=m');
-        expect(decodedUri).not.toContain('e=ps');
-        expect(decodedUri).not.toContain('sta=p');
-        expect(decodedUri).not.toContain('sta=a');
-        expect(decodedUri).not.toContain('sta=k');
-
-        // Should not have been called again for 'seeking'
-        expect(requestSpy).toHaveBeenCalledTimes(1);
-      });
-
-      it('includes other CMCD data with event requests', () => {
-        const mockVideo = new shaka.util.FakeEventTarget();
-
-        const config = {
-          version: 2,
-          enabled: true,
-          sessionId: sessionId,
-          contentId: 'v2-event-content',
-          targets: [{
-            enabled: true,
-            url: 'https://example.com/cmcd',
-            includeKeys: ['e', 'sta', 'bl', 'mtp', 'cid'],
-            events: ['ps'],
-          }],
-        };
-
-        const cmcdManager = createCmcdManager(mockPlayerWithNE, config);
-        cmcdManager.setMediaElement(mockVideo);
-
-        mockVideo.dispatchEvent(new shaka.util.FakeEvent('play'));
-        let request = /** @type {!jasmine.Spy} */ (requestSpy)
-            .calls.mostRecent().args[1];
-        let decodedUri = decodeURIComponent(request.uris[0]);
-
-        expect(decodedUri).toContain('e=ps');
-        expect(decodedUri).toContain('sta=s');
-        expect(decodedUri).toContain('mtp=');
-        expect(decodedUri).toContain('cid="v2-event-content"');
-
-        mockVideo.dispatchEvent(new shaka.util.FakeEvent('playing'));
-
-        expect(requestSpy).toHaveBeenCalled();
-        request = /** @type {!jasmine.Spy} */ (requestSpy)
-            .calls.mostRecent().args[1];
-        decodedUri = decodeURIComponent(request.uris[0]);
-
-        expect(decodedUri).toContain('e=ps');
-        expect(decodedUri).toContain('sta=p');
-        expect(decodedUri).toContain('mtp=');
-        expect(decodedUri).toContain('cid="v2-event-content"');
-      });
-
-      it('does not send events if the target is disabled', () => {
-        const mockVideo = new shaka.util.FakeEventTarget();
-        const config = {
-          version: 2,
-          enabled: true,
-          targets: [{
-            enabled: false, // Target is disabled
-            url: 'https://example.com/cmcd',
-          }],
-        };
-
-        const cmcdManager = createCmcdManager(mockPlayerWithNE, config);
-        cmcdManager.setMediaElement(mockVideo);
-
-        mockVideo.dispatchEvent(new shaka.util.FakeEvent('play'));
-
-        expect(requestSpy).not.toHaveBeenCalled();
-      });
-
-      it('does not send events if CMCD version is 1', () => {
-        const mockVideo = new shaka.util.FakeEventTarget();
-        const config = {
-          version: 1, // CMCD v1
-          enabled: true,
-          targets: [{
-            enabled: true,
-            url: 'https://example.com/cmcd',
-          }],
-        };
-
-        const cmcdManager = createCmcdManager(mockPlayerWithNE, config);
-        cmcdManager.setMediaElement(mockVideo);
-
-        mockVideo.dispatchEvent(new shaka.util.FakeEvent('play'));
-
-        expect(requestSpy).not.toHaveBeenCalled();
-      });
-
-      it('filters out keys that are not valid for event mode', () => {
-        const mockVideo = new shaka.util.FakeEventTarget();
-        const config = {
-          version: 2,
-          enabled: true,
-          targets: [{
-            enabled: true,
-            url: 'https://example.com/cmcd',
-            // d and rtp are not valid for event mode
-            includeKeys: ['e', 'sta', 'bl', 'd', 'rtp'],
-            events: ['ps'],
-          }],
-        };
-
-        const cmcdManager = createCmcdManager(mockPlayerWithNE, config);
-        cmcdManager.setMediaElement(mockVideo);
-
-        mockVideo.dispatchEvent(new shaka.util.FakeEvent('play'));
-
-        expect(requestSpy).toHaveBeenCalled();
-        let request = /** @type {!jasmine.Spy} */ (requestSpy)
-            .calls.mostRecent().args[1];
-        let decodedUri = decodeURIComponent(request.uris[0]);
-
-        expect(decodedUri).toContain('e=ps');
-        expect(decodedUri).toContain('sta=s');
-        expect(decodedUri).not.toContain('d=');
-        expect(decodedUri).not.toContain('rtp=');
-
-        mockVideo.dispatchEvent(new shaka.util.FakeEvent('playing'));
-
-        expect(requestSpy).toHaveBeenCalled();
-        request = /** @type {!jasmine.Spy} */ (requestSpy)
-            .calls.mostRecent().args[1];
-        decodedUri = decodeURIComponent(request.uris[0]);
-
-        expect(decodedUri).toContain('e=ps');
-        expect(decodedUri).toContain('sta=p');
-        expect(decodedUri).not.toContain('d=');
-        expect(decodedUri).not.toContain('rtp=');
-      });
-
-      it('sends events to multiple targets', () => {
-        const mockVideo = new shaka.util.FakeEventTarget();
-        const config = {
-          version: 2,
-          enabled: true,
-          targets: [
-            {
-              enabled: true,
-              url: 'https://example.com/cmcd1',
-              includeKeys: ['e', 'sta'],
-              events: ['ps'],
-            },
-            {
-              enabled: true,
-              url: 'https://example.com/cmcd2',
-              includeKeys: ['e', 'sta', 'v'],
-              events: ['ps'],
-            },
-          ],
-        };
-
-        const cmcdManager = createCmcdManager(mockPlayerWithNE, config);
-        cmcdManager.setMediaElement(mockVideo);
-        cmcdManager.configure(config);
-
-        // Dispatch 'play' event
-        mockVideo.dispatchEvent(new shaka.util.FakeEvent('play'));
-
-        // After 'play', two requests should have been sent
-        expect(requestSpy).toHaveBeenCalledTimes(2);
-
-        const playCalls = /** @type {!jasmine.Spy} */
-            (requestSpy).calls.all().map((call) => call.args[1]);
-        const playCall1 = playCalls.find((req) => req.uris[0].startsWith('https://example.com/cmcd1'));
-        const playCall2 = playCalls.find((req) => req.uris[0].startsWith('https://example.com/cmcd2'));
-
-        // Assertions for the 'play' event
-        const decodedUri1 = decodeURIComponent(playCall1.uris[0]);
-        expect(decodedUri1).toContain('e=ps');
-        expect(decodedUri1).toContain('sta=s');
-        // cmcd1's includeKeys excludes 'v', but CML's prepareCmcdData
-        // unconditionally appends `v` for V2 (CTA-5004-B § 4.1).
-        expect(decodedUri1).toContain('v=2');
-
-        const decodedUri2 = decodeURIComponent(playCall2.uris[0]);
-        expect(decodedUri2).toContain('e=ps');
-        expect(decodedUri2).toContain('sta=s');
-        expect(decodedUri2).toContain('v=2');
-
-        // Reset the spy before the next event to have clean calls
-        /** @type {!jasmine.Spy} */ (requestSpy).calls.reset();
-
-        // Dispatch 'playing' event
-        mockVideo.dispatchEvent(new shaka.util.FakeEvent('playing'));
-
-        // After 'playing', two more requests should have been sent
-        expect(requestSpy).toHaveBeenCalledTimes(2);
-
-        const playingCalls = /** @type {!jasmine.Spy} */
-          (requestSpy).calls.all().map((call) => call.args[1]);
-        const playingCall1 = playingCalls.find((req) => req.uris[0].startsWith('https://example.com/cmcd1'));
-        const playingCall2 = playingCalls.find((req) => req.uris[0].startsWith('https://example.com/cmcd2'));
-
-        // Assertions for the 'playing' event
-        const decodedUri3 = decodeURIComponent(playingCall1.uris[0]);
-        expect(decodedUri3).toContain('e=ps');
-        expect(decodedUri3).toContain('sta=p');
-        // CML auto-adds `v=2` regardless of includeKeys (see 'play'
-        // assertion above for rationale).
-        expect(decodedUri3).toContain('v=2');
-
-        const decodedUri4 = decodeURIComponent(playingCall2.uris[0]);
-        expect(decodedUri4).toContain('e=ps');
-        expect(decodedUri4).toContain('sta=p');
-        expect(decodedUri4).toContain('v=2');
-      });
-
-      it('sends events using headers', () => {
-        const mockVideo = new shaka.util.FakeEventTarget();
-        const config = {
-          version: 2,
-          enabled: true,
-          sessionId: sessionId,
-          targets: [{
-            enabled: true,
-            url: 'https://example.com/cmcd',
-            includeKeys: ['e', 'sta', 'v', 'sid'],
-            events: ['ps'],
-            useHeaders: true,
-          }],
-        };
-
-        const cmcdManager = createCmcdManager(mockPlayerWithNE, config);
-        cmcdManager.setMediaElement(mockVideo);
-        cmcdManager.configure(config);
-
-        mockVideo.dispatchEvent(new shaka.util.FakeEvent('play'));
-        let request = /** @type {!jasmine.Spy} */ (requestSpy)
-            .calls.mostRecent().args[1];
-
-        expect(request.uris[0]).toBe('https://example.com/cmcd');
-        expect(request.headers['CMCD-Request']).toContain('e=ps');
-        expect(request.headers['CMCD-Request']).toContain('sta=s');
-        expect(request.headers['CMCD-Request']).toContain('ts=');
-
-        expect(request.headers['CMCD-Session']).toContain('v=2');
-        expect(request.headers['CMCD-Session']).toContain(`sid="${sessionId}"`);
-
-        mockVideo.dispatchEvent(new shaka.util.FakeEvent('playing'));
-        request = /** @type {!jasmine.Spy} */ (requestSpy)
-            .calls.mostRecent().args[1];
-
-        expect(request.uris[0]).toBe('https://example.com/cmcd');
-        expect(request.headers['CMCD-Request']).toContain('e=ps');
-        expect(request.headers['CMCD-Request']).toContain('sta=p');
-        expect(request.headers['CMCD-Request']).toContain('ts=');
-        expect(request.headers['CMCD-Session']).toContain('v=2');
-        expect(request.headers['CMCD-Session']).toContain(`sid="${sessionId}"`);
-      });
-
-      it('includes timestamp (ts) in event reports', () => {
-        const mockVideo = new shaka.util.FakeEventTarget();
-        const config = {
-          version: 2,
-          enabled: true,
-          targets: [{
-            enabled: true,
-            url: 'https://example.com/cmcd',
-            includeKeys: ['e', 'sta', 'ts'],
-            events: ['ps'],
-          }],
-        };
-
-        const cmcdManager = createCmcdManager(mockPlayerWithNE, config);
-        cmcdManager.setMediaElement(mockVideo);
-        cmcdManager.configure(config);
-
-        mockVideo.dispatchEvent(new shaka.util.FakeEvent('play'));
-        const request = /** @type {!jasmine.Spy} */ (requestSpy)
-            .calls.mostRecent().args[1];
-        const decodedUri = decodeURIComponent(request.uris[0]);
-        expect(decodedUri).toContain('e=ps');
-        expect(decodedUri).toContain('sta=s');
-        expect(decodedUri).toContain('ts=');
-      });
-
-      it('should return only enabled event targets', () => {
-        const targets = [
-          {enabled: true, url: 'url1'},
-          {enabled: false, url: 'url2'},
-        ];
-        const cmcdManager = createCmcdManager(mockPlayer, {targets});
-        const enabledEventTargets = cmcdManager.getEventModeEnabledTargets_();
-        expect(enabledEventTargets.length).toBe(1);
-        expect(enabledEventTargets[0].url).toBe('url1');
-      });
-
-      it('should return an empty array if no targets are configured', () => {
-        const cmcdManager = createCmcdManager(mockPlayer, {targets: []});
-        const enabledEventTargets = cmcdManager.getEventModeEnabledTargets_();
-        expect(enabledEventTargets.length).toBe(0);
-      });
-
-      it('should return an empty array if no event targets are enabled', () => {
-        const targets = [
-          {enabled: false, url: 'url1'},
-        ];
-        const cmcdManager = createCmcdManager(mockPlayer, {targets});
-        const enabledEventTargets = cmcdManager.getEventModeEnabledTargets_();
-        expect(enabledEventTargets.length).toBe(0);
-      });
-
-      it('does not include rc, url, ttfb or ttlb key', () => {
-        const mockVideo = new shaka.util.FakeEventTarget();
-        const config = {
-          version: 2,
-          enabled: true,
-          targets: [{
-            enabled: true,
-            url: 'https://example.com/cmcd',
-            // rc, url, ttfb and ttlb are not valid for event mode
-            includeKeys: ['e', 'sta', 'rc', 'url', 'ttfb', 'ttlb'],
-            events: ['ps'],
-          }],
-        };
-
-        const cmcdManager = createCmcdManager(mockPlayerWithNE, config);
-        cmcdManager.setMediaElement(mockVideo);
-
-        mockVideo.dispatchEvent(new shaka.util.FakeEvent('play'));
-
-        expect(requestSpy).toHaveBeenCalled();
-        const request = /** @type {!jasmine.Spy} */ (requestSpy)
-            .calls.mostRecent().args[1];
-        const decodedUri = decodeURIComponent(request.uris[0]);
-
-        expect(decodedUri).toContain('e=ps');
-        expect(decodedUri).toContain('sta=s');
-        expect(decodedUri).not.toContain('rc=');
-        expect(decodedUri).not.toContain('url=');
-        expect(decodedUri).not.toContain('ttfb=');
-        expect(decodedUri).not.toContain('ttlb=');
-      });
-
-      it('always includes timestamp (ts) in event reports', () => {
-        const mockVideo = new shaka.util.FakeEventTarget();
-        const config = {
-          version: 2,
-          enabled: true,
-          targets: [{
-            enabled: true,
-            url: 'https://example.com/cmcd',
-            includeKeys: ['e', 'sta'], // ts is omitted
-            events: ['ps'],
-          }],
-        };
-
-        const cmcdManager = createCmcdManager(mockPlayerWithNE, config);
-        cmcdManager.setMediaElement(mockVideo);
-
-        mockVideo.dispatchEvent(new shaka.util.FakeEvent('play'));
-
-        expect(requestSpy).toHaveBeenCalled();
-        const request = /** @type {!jasmine.Spy} */ (requestSpy)
-            .calls.mostRecent().args[1];
-        const decodedUri = decodeURIComponent(request.uris[0]);
-        expect(decodedUri).toMatch(/ts=\d+/);
-      });
-
-      it('sends all allowed keys when includeKeys is empty', () => {
-        const mockVideo = new shaka.util.FakeEventTarget();
-        const config = {
-          version: 2,
-          enabled: true,
-          sessionId: sessionId,
-          contentId: 'v2-event-content',
-          targets: [{
-            enabled: true,
-            url: 'https://example.com/cmcd',
-            includeKeys: [],
-            events: ['ps'],
-          }],
-        };
-
-        const cmcdManager = createCmcdManager(mockPlayerWithNE, config);
-        cmcdManager.setMediaElement(mockVideo);
-
-        mockVideo.dispatchEvent(new shaka.util.FakeEvent('play'));
-
-        expect(requestSpy).toHaveBeenCalled();
-        let request = /** @type {!jasmine.Spy} */ (requestSpy)
-            .calls.mostRecent().args[1];
-        let decodedUri = decodeURIComponent(request.uris[0]);
-
-        // Check for essential event keys
-        expect(decodedUri).toContain('e=ps');
-        expect(decodedUri).toContain('sta=s');
-
-        mockVideo.dispatchEvent(new shaka.util.FakeEvent('playing'));
-
-        expect(requestSpy).toHaveBeenCalled();
-        request = /** @type {!jasmine.Spy} */ (requestSpy)
-            .calls.mostRecent().args[1];
-        decodedUri = decodeURIComponent(request.uris[0]);
-
-        // Check for essential event keys
-        expect(decodedUri).toContain('e=ps');
-        expect(decodedUri).toContain('sta=p');
-
-        // Check for other common keys that should be included by default
-        expect(decodedUri).toContain(`sid="${sessionId}"`);
-        expect(decodedUri).toContain('cid="v2-event-content"');
-        expect(decodedUri).toContain('v=2');
-        expect(decodedUri).toContain('mtp=');
-        expect(decodedUri).toMatch(/ts=\d+/);
-      });
-
-      it('sends all event types when events array is empty', () => {
-        const mockMediaElement = new MockMediaElement();
-        const config = {
-          version: 2,
-          enabled: true,
-          targets: [{
-            enabled: true,
-            url: 'https://example.com/cmcd',
-            includeKeys: ['e', 'sta'],
-            events: [],
-          }],
-        };
-
-        const cmcdManager = createCmcdManager(mockPlayerWithNE, config);
-        cmcdManager.setMediaElement(mockMediaElement);
-
-        mockMediaElement.dispatchEvent(new shaka.util.FakeEvent('play'));
-        expect(requestSpy).toHaveBeenCalledTimes(1);
-        let request = /** @type {!jasmine.Spy} */ (requestSpy)
-            .calls.mostRecent().args[1];
-
-        let decodedUri = decodeURIComponent(request.uris[0]);
-        expect(decodedUri).toContain('e=ps');
-        expect(decodedUri).toContain('sta=s');
-
-        mockMediaElement.dispatchEvent(new shaka.util.FakeEvent('playing'));
-        expect(requestSpy).toHaveBeenCalledTimes(2);
-        request = /** @type {!jasmine.Spy} */ (requestSpy)
-            .calls.mostRecent().args[1];
-
-        decodedUri = decodeURIComponent(request.uris[0]);
-        expect(decodedUri).toContain('e=ps');
-        expect(decodedUri).toContain('sta=p');
-
-        mockMediaElement.muted = true;
-        mockMediaElement.dispatchEvent(
-            new shaka.util.FakeEvent('volumechange'));
-        expect(requestSpy).toHaveBeenCalledTimes(3);
-        request = /** @type {!jasmine.Spy} */ (requestSpy)
-            .calls.mostRecent().args[1];
-        decodedUri = decodeURIComponent(request.uris[0]);
-        expect(decodedUri).toContain('e=m');
-
-        mockMediaElement.muted = false;
-        mockMediaElement.dispatchEvent(
-            new shaka.util.FakeEvent('volumechange'));
-        expect(requestSpy).toHaveBeenCalledTimes(4);
-        request = /** @type {!jasmine.Spy} */ (requestSpy)
-            .calls.mostRecent().args[1];
-        decodedUri = decodeURIComponent(request.uris[0]);
-        expect(decodedUri).toContain('e=um');
-      });
-
-      it('sends all keys for all events when both arrays are empty', () => {
-        const mockMediaElement = new MockMediaElement();
-        const config = {
-          version: 2,
-          enabled: true,
-          sessionId: sessionId,
-          contentId: 'v2-event-content-all',
-          targets: [{
-            enabled: true,
-            url: 'https://example.com/cmcd',
-            includeKeys: [],
-            events: [],
-          }],
-        };
-
-        const cmcdManager = createCmcdManager(
-            mockPlayerWithNE,
-            config,
-        );
-
-        cmcdManager.setMediaElement(mockMediaElement);
-
-        mockMediaElement.dispatchEvent(new shaka.util.FakeEvent('play'));
-        expect(requestSpy).toHaveBeenCalledTimes(1);
-        let request = /** @type {!jasmine.Spy} */ (requestSpy)
-            .calls.mostRecent().args[1];
-        let decodedUri = decodeURIComponent(request.uris[0]);
-        expect(decodedUri).toContain('e=ps');
-        expect(decodedUri).toContain('sta=s');
-        expect(decodedUri).toContain(`sid="${sessionId}"`);
-        expect(decodedUri).toContain(`cid="v2-event-content-all"`);
-        expect(decodedUri).toContain('v=2');
-        expect(decodedUri).toMatch(/ts=\d+/);
-
-        mockMediaElement.dispatchEvent(new shaka.util.FakeEvent('playing'));
-        expect(requestSpy).toHaveBeenCalledTimes(2);
-        request = /** @type {!jasmine.Spy} */ (requestSpy)
-            .calls.mostRecent().args[1];
-        decodedUri = decodeURIComponent(request.uris[0]);
-        expect(decodedUri).toContain('e=ps');
-        expect(decodedUri).toContain('sta=p');
-        expect(decodedUri).toContain(`sid="${sessionId}"`);
-        expect(decodedUri).toContain(`cid="v2-event-content-all"`);
-        expect(decodedUri).toContain('v=2');
-        expect(decodedUri).toMatch(/ts=\d+/);
-
-        mockMediaElement.muted = true;
-        mockMediaElement.dispatchEvent(
-            new shaka.util.FakeEvent('volumechange'));
-        expect(requestSpy).toHaveBeenCalledTimes(3);
-        request = /** @type {!jasmine.Spy} */ (requestSpy)
-            .calls.mostRecent().args[1];
-        decodedUri = decodeURIComponent(request.uris[0]);
-        expect(decodedUri).toContain('e=m');
-        expect(decodedUri).toContain(`sid="${sessionId}"`);
-        expect(decodedUri).toContain(`cid="v2-event-content-all"`);
-        expect(decodedUri).toContain('v=2');
-      });
-
-      it('sends rebuffering play state change event', () => {
-        const config = {
-          version: 2,
-          enabled: true,
-          targets: [{
-            enabled: true,
-            url: 'https://example.com/cmcd',
-            includeKeys: ['e', 'sta', 'v'],
-            events: ['ps'],
-          }],
-        };
-
-        const cmcdManager = createCmcdManager(
-            mockPlayerWithNE,
-            config,
-        );
-        cmcdManager.setMediaElement(new shaka.util.FakeEventTarget());
-        cmcdManager.configure(config);
-
-        // Simulate playback start
-        cmcdManager.setBuffering(false);
-        (/** @type {!jasmine.Spy} */ (requestSpy)).calls.reset();
-
-        // Simulate rebuffering
-        cmcdManager.setBuffering(true);
-
-        expect(requestSpy).toHaveBeenCalledTimes(1);
-        const request = (/** @type {!jasmine.Spy} */ (requestSpy))
-            .calls.mostRecent().args[1];
-        const decodedUri = decodeURIComponent(request.uris[0]);
-        expect(decodedUri).toContain('e=ps');
-        expect(decodedUri).toContain('sta=r');
-        expect(decodedUri).toContain('v=2');
-      });
-
-      it('sends preloading event', () => {
-        const config = {
-          version: 2,
-          enabled: true,
-          targets: [{
-            enabled: true,
-            url: 'https://example.com/cmcd',
-            includeKeys: ['e', 'sta'],
-            events: ['ps'],
-          }],
-        };
-
-        const cmcdManager = createCmcdManager(
-            mockPlayerWithNE,
-            config,
-        );
-        cmcdManager.setMediaElement(new shaka.util.FakeEventTarget());
-        cmcdManager.configure(config);
-
-        cmcdManager.setStartTimeOfLoad(Date.now());
-
-        expect(requestSpy).toHaveBeenCalledTimes(1);
-        const request = (/** @type {!jasmine.Spy} */ (requestSpy))
-            .calls.mostRecent().args[1];
-        const decodedUri = decodeURIComponent(request.uris[0]);
-        expect(decodedUri).toContain('e=ps');
-        expect(decodedUri).toContain('sta=d');
-      });
-
-      it('sends player expand and collapse events', () => {
-        if (!document.fullscreenEnabled) {
-          pending('This test requires fullscreen support.');
-        }
-        const mockVideo = new shaka.util.FakeEventTarget();
-        const config = {
-          version: 2,
-          enabled: true,
-          targets: [{
-            enabled: true,
-            url: 'https://example.com/cmcd',
-            includeKeys: ['e'],
-            events: ['pe', 'pc'],
-          }],
-        };
-
-        const cmcdManager = createCmcdManager(
-            mockPlayerWithNE,
-            config,
-        );
-        cmcdManager.setMediaElement(mockVideo);
-        cmcdManager.configure(config);
-
-        const fullscreenChangeEvent = document.createEvent('event');
-        fullscreenChangeEvent.initEvent('fullscreenchange', false, false);
-
-        // Mock fullscreenElement to simulate entering fullscreen
-        Object.defineProperty(document, 'fullscreenElement', {
-          value: document,
-          writable: true,
-        });
-
-        document.dispatchEvent(fullscreenChangeEvent);
-        expect(requestSpy).toHaveBeenCalled();
-        let request = (/** @type {!jasmine.Spy} */ (requestSpy))
-            .calls.mostRecent().args[1];
-        let decodedUri = decodeURIComponent(request.uris[0]);
-        expect(decodedUri).toContain('e=pe');
-
-        // Mock fullscreenElement to simulate exiting fullscreen
-        Object.defineProperty(document, 'fullscreenElement', {
-          value: null,
-          writable: true,
-        });
-
-        document.dispatchEvent(fullscreenChangeEvent);
-        expect(requestSpy).toHaveBeenCalled();
-        request = (/** @type {!jasmine.Spy} */ (requestSpy))
-            .calls.mostRecent().args[1];
-        decodedUri = decodeURIComponent(request.uris[0]);
-        expect(decodedUri).toContain('e=pc');
-
-        // Restore original property
-        Object.defineProperty(document, 'fullscreenElement', {
-          value: null,
-          writable: false,
-        });
-      });
-
-      it('sends complete event', () => {
-        const completeConfig = createCmcdConfig({
-          version: 2,
-          enabled: true,
-          targets: [{
-            enabled: true,
-            url: 'https://example.com/cmcd',
-            includeKeys: ['e', 'sta', 'v'],
-            events: ['ps'],
-          }],
-        });
-
-        const cmcdManager = new CmcdManager(
-            /** @type {shaka.Player} */ (mockPlayerWithNE),
-            completeConfig,
-        );
-
-        cmcdManager.setMediaElement(
-            /** @type {!HTMLMediaElement} */
-            (/** @type {*} */ (new shaka.util.FakeEventTarget())),
-        );
-
-        cmcdManager.configure(completeConfig);
-
-        mockPlayerWithNE.dispatchEvent(new shaka.util.FakeEvent('complete'));
-
-        const request = /** @type {!jasmine.Spy} */ (requestSpy)
-            .calls.mostRecent().args[1];
-        const decodedUri = decodeURIComponent(request.uris[0]);
-        expect(decodedUri).toContain('e=ps');
-        expect(decodedUri).toContain('sta=e');
-        expect(decodedUri).toContain('v=2');
-      });
-
-      it('sends waiting event', () => {
-        const completeConfig = createCmcdConfig({
-          version: 2,
-          enabled: true,
-          targets: [{
-            enabled: true,
-            url: 'https://example.com/cmcd',
-            includeKeys: ['e', 'sta', 'v'],
-            events: ['ps'],
-          }],
-        });
-
-        const cmcdManager = new CmcdManager(
-            /** @type {shaka.Player} */ (mockPlayerWithNE),
-            completeConfig,
-        );
-
-        cmcdManager.setMediaElement(
-            /** @type {!HTMLMediaElement} */
-            (/** @type {*} */ (new shaka.util.FakeEventTarget())),
-        );
-
-        cmcdManager.configure(completeConfig);
-
-        mockPlayerWithNE.dispatchEvent(new shaka.util.FakeEvent('buffering'));
-
-        const request = /** @type {!jasmine.Spy} */ (requestSpy)
-            .calls.mostRecent().args[1];
-        const decodedUri = decodeURIComponent(request.uris[0]);
-        expect(decodedUri).toContain('e=ps');
-        expect(decodedUri).toContain('sta=w');
-        expect(decodedUri).toContain('v=2');
-      });
-
-      it('sends Picture-in-Picture events', () => {
-        const mockVideo = new shaka.util.FakeEventTarget();
-        const config = {
-          version: 2,
-          enabled: true,
-          targets: [{
-            enabled: true,
-            url: 'https://example.com/cmcd',
-            includeKeys: ['e'],
-            events: ['pe', 'pc'],
-          }],
-        };
-
-        const cmcdManager = createCmcdManager(
-            mockPlayerWithNE,
-            config,
-        );
-        cmcdManager.setMediaElement(mockVideo);
-        cmcdManager.configure(config);
-
-        mockVideo.dispatchEvent(
-            new shaka.util.FakeEvent('enterpictureinpicture'));
-
-        expect(requestSpy).toHaveBeenCalledTimes(1);
-        let request = (/** @type {!jasmine.Spy} */ (requestSpy))
-            .calls.mostRecent().args[1];
-        let decodedUri = decodeURIComponent(request.uris[0]);
-        expect(decodedUri).toContain('e=pe');
-
-        // Simulate leaving Picture-in-Picture
-        mockVideo.dispatchEvent(new shaka.util.FakeEvent(
-            'leavepictureinpicture'));
-
-        expect(requestSpy).toHaveBeenCalledTimes(2);
-        request = (/** @type {!jasmine.Spy} */ (requestSpy))
-            .calls.mostRecent().args[1];
-        decodedUri = decodeURIComponent(request.uris[0]);
-        expect(decodedUri).toContain('e=pc');
-      });
-
-      it('sends webkit presentation mode change events', () => {
-        /**
-         * @extends {shaka.util.FakeEventTarget}
-         */
-        class MockWebKitVideo extends shaka.util.FakeEventTarget {
-          constructor() {
-            super();
-            /** @type {string} */
-            this.webkitPresentationMode = 'inline';
-          }
+    it('v2 + headers: places v=2 in CMCD-Session only', () => {
+      const headers = /** @type {!Object<string, string>} */ (
+        exerciseAndCollect({version: 2, useHeaders: true}));
+      // CMCD-Session is the only shard that should carry v=2.
+      const session = headers['CMCD-Session'] || '';
+      expect(session).toContain('v=2');
+      // None of the other shards should carry v=2.
+      for (const key of Object.keys(headers)) {
+        if (key !== 'CMCD-Session') {
+          expect(headers[key]).not.toContain('v=2');
         }
-        const mockVideo = new MockWebKitVideo();
-
-        const config = {
-          version: 2,
-          enabled: true,
-          targets: [{
-            enabled: true,
-            url: 'https://example.com/cmcd',
-            includeKeys: ['e'],
-            events: ['pe', 'pc'],
-          }],
-        };
-
-        const cmcdManager = createCmcdManager(
-            mockPlayerWithNE,
-            config,
-        );
-        cmcdManager.setMediaElement(mockVideo);
-        cmcdManager.configure(config);
-
-        // Simulate entering fullscreen via webkit presentation mode
-        mockVideo.webkitPresentationMode = 'fullscreen';
-        mockVideo.dispatchEvent(
-            new shaka.util.FakeEvent('webkitpresentationmodechanged'));
-
-        expect(requestSpy).toHaveBeenCalledTimes(1);
-        let request = (/** @type {!jasmine.Spy} */ (requestSpy))
-            .calls.mostRecent().args[1];
-        let decodedUri = decodeURIComponent(request.uris[0]);
-        expect(decodedUri).toContain('e=pe');
-
-        // Simulate exiting fullscreen via webkit presentation mode
-        mockVideo.webkitPresentationMode = 'inline';
-        mockVideo.dispatchEvent(
-            new shaka.util.FakeEvent('webkitpresentationmodechanged'));
-
-        expect(requestSpy).toHaveBeenCalledTimes(2);
-        request = (/** @type {!jasmine.Spy} */ (requestSpy))
-            .calls.mostRecent().args[1];
-        decodedUri = decodeURIComponent(request.uris[0]);
-        expect(decodedUri).toContain('e=pc');
-      });
-
-      it('sends separate reports with correct keys for multiple targets',
-          () => {
-            // Create fresh spy to avoid interference from other tests
-            const freshRequestSpy = jasmine.createSpy('request');
-            const freshNetworkingEngine = {
-              request: freshRequestSpy,
-              configure: () => {},
-              registerScheme: () => {},
-            };
-            const freshMockPlayerWithNE = new shaka.util.FakeEventTarget();
-            Object.assign(freshMockPlayerWithNE, mockPlayer, {
-              getNetworkingEngine: () => freshNetworkingEngine,
-            });
-
-            const mockVideo = new shaka.util.FakeEventTarget();
-            const config = {
-              version: 2,
-              enabled: true,
-              targets: [
-                {
-                  enabled: true,
-                  url: 'https://target1.com/cmcd',
-                  includeKeys: ['ts', 'rc', 'url'],
-                  events: ['rr'], // Response events
-                },
-                {
-                  enabled: true,
-                  url: 'https://target2.com/cmcd',
-                  includeKeys: ['e', 'sta', 'ts'],
-                  events: ['ps'], // Player state events
-                },
-              ],
-            };
-
-            const cmcdManager = createCmcdManager(
-                freshMockPlayerWithNE, config);
-
-            cmcdManager.setMediaElement(mockVideo);
-
-            // Reset spy call count after setup
-            freshRequestSpy.calls.reset();
-
-            // Trigger first event type (rr event)
-            cmcdManager.applyResponseSegmentData(
-                {uri: 'https://example.com/segment.mp4', headers: {}},
-                createResponseWithRealTiming(),
-                {});
-
-            // Trigger second event type (ps event)
-            mockVideo.dispatchEvent(new shaka.util.FakeEvent('play'));
-
-            // Should have called request spy twice, once for each target
-            expect(freshRequestSpy).toHaveBeenCalledTimes(2);
-
-            const firstRequest = freshRequestSpy.calls.argsFor(0)[1];
-            const secondRequest = freshRequestSpy.calls.argsFor(1)[1];
-
-            const firstDecodedUri = decodeURIComponent(firstRequest.uris[0]);
-            const secondDecodedUri = decodeURIComponent(secondRequest.uris[0]);
-
-            expect(firstRequest.uris[0]).toContain('target1.com');
-            expect(firstDecodedUri).toContain('ts=');
-            expect(firstDecodedUri).toContain('e=rr');
-            expect(firstDecodedUri).toContain('rc');
-            expect(firstDecodedUri).toContain('url');
-            expect(firstDecodedUri).not.toContain('sta=');
-
-            expect(secondRequest.uris[0]).toContain('target2.com');
-            expect(secondDecodedUri).toContain('e=ps');
-            expect(secondDecodedUri).toContain('sta=s');
-            expect(secondDecodedUri).toContain('ts=');
-            expect(secondDecodedUri).not.toContain('rc=');
-            expect(secondDecodedUri).not.toContain('url=');
-          });
-
-      it('maintains separate state between targets processing same event',
-          () => {
-            // Create fresh spy to avoid interference from other tests
-            const freshRequestSpy = jasmine.createSpy('request');
-            const freshNetworkingEngine = {
-              request: freshRequestSpy,
-              configure: () => {},
-              registerScheme: () => {},
-            };
-            const freshMockPlayerWithNE = new shaka.util.FakeEventTarget();
-            Object.assign(freshMockPlayerWithNE, mockPlayer, {
-              getNetworkingEngine: () => freshNetworkingEngine,
-            });
-
-            const mockVideo = new shaka.util.FakeEventTarget();
-            const config = {
-              version: 2,
-              enabled: true,
-              targets: [
-                {
-                  enabled: true,
-                  url: 'https://target1.com/cmcd',
-                  includeKeys: ['sn'],
-                  events: ['rr'],
-                },
-                {
-                  enabled: true,
-                  url: 'https://target2.com/cmcd',
-                  includeKeys: ['sn'],
-                  events: ['rr'], // Same event type to trigger contamination
-                },
-              ],
-            };
-
-            const cmcdManager = createCmcdManager(
-                freshMockPlayerWithNE, config);
-            cmcdManager.setMediaElement(mockVideo);
-
-            // Reset spy call count after setup
-            freshRequestSpy.calls.reset();
-
-            // Trigger single event that should affect both targets
-            cmcdManager.applyResponseSegmentData(
-                {uri: 'https://example.com/segment.mp4', headers: {}},
-                createResponseWithRealTiming(),
-                {});
-
-            // Should have called request spy twice, once for each target
-            expect(freshRequestSpy).toHaveBeenCalledTimes(2);
-
-            const firstRequest = freshRequestSpy.calls.argsFor(0)[1];
-            const secondRequest = freshRequestSpy.calls.argsFor(1)[1];
-
-            const firstDecodedUri = decodeURIComponent(firstRequest.uris[0]);
-            const secondDecodedUri = decodeURIComponent(secondRequest.uris[0]);
-
-            const firstSnMatch = firstDecodedUri.match(/sn=(\d+)/);
-            const secondSnMatch = secondDecodedUri.match(/sn=(\d+)/);
-
-            expect(firstSnMatch).not.toBeNull();
-            expect(secondSnMatch).not.toBeNull();
-
-            const firstSn = firstSnMatch ? parseInt(firstSnMatch[1], 10) : -1;
-            const secondSn = secondSnMatch ?
-                parseInt(secondSnMatch[1], 10) : -1;
-
-            // Both targets should have independent sequence numbers = 1
-            expect(firstSn).toBe(1);
-            expect(secondSn).toBe(1);
-
-            expect(firstRequest.uris[0]).toContain('target1.com');
-            expect(secondRequest.uris[0]).toContain('target2.com');
-          });
+      }
     });
   });
 });

From 43cc7f332efa75d6f02515c1222c9601eda73ee0 Mon Sep 17 00:00:00 2001
From: Casey Occhialini <1508707+littlespex@users.noreply.github.com>
Date: Tue, 28 Apr 2026 17:45:55 -0700
Subject: [PATCH 34/64] fix(cmcd): preserve video_ across reset() so
 configure() can rebuild reporter
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

End-to-end smoke surfaced that after `player.unload()` +
`player.configure({useHeaders: true})` + `player.load()`, CMCD output
was using stale config (old useHeaders/sessionId/contentId) — the
reporter wasn't being reconstructed for the second load.

Root cause: `reset()` cleared `this.video_ = null`, and
`maybeStartReporter_()` gates reporter construction on `this.video_`.
Since `setMediaElement()` is only called on `attach()` (not `load()`),
the post-unload manager sat with a null video and could never rebuild
the reporter, leaving any subsequent `configure()` material change
unable to take effect.

Fix: don't null `video_` in `reset()`. Shaka's lifecycle keeps the
video element attached across `unload()`/`load()` cycles — only
`detach()` releases it. Preserving `video_` lets a post-unload
`configure(materialChange)` rebuild the reporter and re-attach event
listeners on the same video element.

Verified end-to-end via Claude Preview-driven demo:
* V2 + query mode: CMCD applied to URLs with v=2, 0-based sn,
  ot/sf/cid/sid/st all correct.
* V2 + headers mode (after unload→configure→load cycle): CMCD applied
  via shards, v=2 in CMCD-Session only, sn reset to 0 on session-id
  change.
* V1 + query mode: no v= emitted (v1 default), other fields correct.
* Zero CMCD-related console errors.

Adds a regression test (`reset preserves video_ so subsequent
configure can rebuild`) covering the unload→configure→reload cycle.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 lib/util/cmcd_manager.js       |  6 ++++--
 test/util/cmcd_manager_unit.js | 15 +++++++++++++++
 2 files changed, 19 insertions(+), 2 deletions(-)

diff --git a/lib/util/cmcd_manager.js b/lib/util/cmcd_manager.js
index dd13b5e052..f59e5c5a58 100644
--- a/lib/util/cmcd_manager.js
+++ b/lib/util/cmcd_manager.js
@@ -147,7 +147,10 @@ shaka.util.CmcdManager = class {
   }
 
   /**
-   * Reset the manager. Stops the reporter and removes event listeners.
+   * Reset the manager. Stops the reporter and clears session-scoped
+   * state. The video element reference is preserved — shaka's lifecycle
+   * keeps it attached across `unload()`/`load()` cycles, and only
+   * `detach()` releases it.
    */
   reset() {
     if (this.reporter_) {
@@ -158,7 +161,6 @@ shaka.util.CmcdManager = class {
     this.sf_ = undefined;
     this.requestTimestampMap_.clear();
     this.startTimeOfLoad_ = 0;
-    this.video_ = null;
     this.eventManager_.removeAll();
   }
 
diff --git a/test/util/cmcd_manager_unit.js b/test/util/cmcd_manager_unit.js
index 09bf9f6376..645daba927 100644
--- a/test/util/cmcd_manager_unit.js
+++ b/test/util/cmcd_manager_unit.js
@@ -221,6 +221,21 @@ describe('CmcdManager', () => {
       expect(priv(manager)['reporter_']).toBeNull();
       expect(priv(manager)['lastPlayerState_']).toBeNull();
     });
+
+    it('reset preserves video_ so subsequent configure can rebuild', () => {
+      // Regression: shaka's lifecycle keeps the video element attached
+      // across `unload()`/`load()`. Reset must preserve `video_` so a
+      // post-unload `configure({material change})` can reconstruct the
+      // reporter without needing another `setMediaElement` call.
+      const player = createMockPlayer();
+      const {manager, config} = createManager(player);
+      manager.reset();
+      expect(priv(manager)['video_']).not.toBeNull();
+      // Now reconfigure with a material change — reporter should
+      // reconstruct and event listeners should re-attach.
+      manager.configure(Object.assign({}, config, {useHeaders: true}));
+      expect(priv(manager)['reporter_']).not.toBeNull();
+    });
   });
 
   // ── Configuration translation ──

From fb54b54ac19ff7f31d2bf71e2588cd49fffdaae2 Mon Sep 17 00:00:00 2001
From: Casey Occhialini <1508707+littlespex@users.noreply.github.com>
Date: Tue, 28 Apr 2026 17:51:33 -0700
Subject: [PATCH 35/64] docs(cmcd): mark Phase 3 complete; cumulative PR draft
 now spans all phases
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Updates the plan.md status table to mark Phase 3 ✅ Complete and adds a
Phase 3 landing-notes section parallel to Phase 1F / Phase 2. Updates
the cumulative PR draft to span all three phases — adds a Phase 3
implementation summary (rewrites, renames, re-exports, wire-format
alignments, design choices, deferred follow-ups), updates the diff-size
totals, refreshes the verification block to current numbers (57/57 CMCD
tests, 2927/2927 quick suite), and lists the two new Phase 3 commits.

Refactor is functionally complete on `feat/cmcd-cml-refactor`. The
single all-phases PR is the user-driven next step.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 plans/cmcd-cml-refactor/plan.md     | 42 ++++++++++++++-
 plans/cmcd-cml-refactor/pr-draft.md | 79 +++++++++++++++++++++++------
 2 files changed, 104 insertions(+), 17 deletions(-)

diff --git a/plans/cmcd-cml-refactor/plan.md b/plans/cmcd-cml-refactor/plan.md
index 9fa52c3424..0762bc389e 100644
--- a/plans/cmcd-cml-refactor/plan.md
+++ b/plans/cmcd-cml-refactor/plan.md
@@ -14,7 +14,7 @@
 
 ## Current status (last updated 2026-04-28)
 
-This refactor is actively in progress on branch `feat/cmcd-cml-refactor`. Read this section first before resuming work in a new session.
+This refactor is functionally complete on branch `feat/cmcd-cml-refactor`. All three phases have landed locally (29 commits ahead of origin); a single all-phases PR is the user-driven next step.
 
 | Phase | Status | Commits / Notes |
 |---|---|---|
@@ -26,7 +26,7 @@ This refactor is actively in progress on branch `feat/cmcd-cml-refactor`. Read t
 | **Phase 1E** — Diff testing + assertion updates (Tasks 1.11-1.12) | ✅ Complete | 2 commits ending at `b94f7ebca`. Started at 52 of 124 CMCD tests failing post-1.10; ended at 0 fail / 124 pass. Three (c)-class adapter bugs fixed in `27cd16907`; ~80 (a)/(b)-class assertion updates in `b94f7ebca`. Full `--quick` suite: 2995/2995 pass. |
 | **Phase 1F** — Demo verification (Task 1.13) | ✅ Complete | Smoke-test on `bbb-dark-truths/dash.mpd` via Claude Preview-driven `python3 -m http.server`. Query mode (15 segment requests captured): `?CMCD=…cid="smoke-test",ot=m,sf=d,sid="…",sn=N,su,v=2` — `v=2` always present, `ts` absent in request mode, `sf=d` (no `'ld'`), `ot`/`sf`/`st` as tokens. Header mode (15 requests captured via request filter; CMCD-* stripped before fetch to avoid CORS preflight): `v=2` only in `CMCD-Session` shard (not in `CMCD-Object`/`Request`/`Status`); request shard contains `sn`/`mtp`/`su` only — no `ts`. Zero JS console errors. Per-phase PR (Task 1.14) deferred to single all-phases PR per user direction. |
 | **Phase 2** — Adopt CML constants, dedupe shaka duplicates (Tasks 2.1-2.5) | ✅ Complete | 1 commit at `67443aacb`. Net −74 LoC in `lib/util/cmcd_manager.js` (+12 LoC value-identity test in `test/util/cmcd_manager_unit.js`). 7 internal shaka enums deleted; `StreamingFormat` retained as `@export`ed literal (Closure tooling rejects alias form). `build/check.py` 0; CMCD tests 125/125; `--quick` suite 2996/2996; smoke test confirmed wire format unchanged. Task 2.6 (open Phase 2 PR) dropped per single-PR strategy. |
-| **Phase 3** — Adapter rewrite (the big behavioral change) | ⏳ **Resume here.** | After Phase 2's dedupe lands, Phase 3 rewrites `cmcd_manager.js` as a thin adapter around `cml.cmcd.CmcdReporter`. |
+| **Phase 3** — Adapter rewrite (Tasks 3.1-3.15) | ✅ Complete | 2 commits ending at `43cc7f332`. Net −1445 LoC in `lib/util/cmcd_manager.js` (1580 → ~700 incl. expanded JSDoc) and ~−4317 LoC in `test/util/cmcd_manager_unit.js` (4296 → ~880). Externs renamed (`targets`→`eventTargets`; per-target `timeInterval`→`interval`); per-target typedef gained `batchSize` and per-target `version` fields. New public re-exports `EventType`, `PlayerState`. Demo gained an `Event Targets (JSON)` editor. `build/check.py` 0; CMCD tests 57/57; `--quick` suite 2927/2927; `build/all.py` 0. End-to-end smoke verified V1+query, V2+query, V2+headers (with unload→reconfigure→reload cycle); `EventType`/`PlayerState`/`StreamingFormat` all appear in `dist/shaka-player.compiled.js`. **Task 3.16 dropped** per single-PR strategy. |
 
 **Vendored port summary:** [`third_party/cml-cmcd/`](../../third_party/cml-cmcd/) holds 68 JS files (typedefs + enums + constants + encoders + helpers + shims + `CmcdReporter`) + `LICENSE` + `NOTICE` + `SUMMARY.txt`. At HEAD (`adfdfab05`), `python3 build/check.py` exits 0. `python3 build/build.py` was last clean at `d682bb1bb` and is not expected to break under sub-phase D's source-only changes; not re-run this session.
 
@@ -113,6 +113,44 @@ Pure dedupe — no behavioral change beyond what Phase 1 already shipped. Single
 - Event-mode validation accepts a strict superset of what shaka's old `V2EventModeKeys` allowed.
 - `isValidEvent_` accepts CML's 17 event types instead of shaka's 10 (adds the 7 ad / skip / custom-event types). shaka doesn't emit these, so user-facing impact is nil.
 
+### Phase 3 landing notes (Tasks 3.1-3.15)
+
+The behavioral rewrite. `lib/util/cmcd_manager.js` is now a ~700-line adapter (was 1580 LoC) around `cml.cmcd.CmcdReporter`, with the reporter owning state, encoding, key filtering, sequence numbering, and event-mode dispatch. The bulk of the LoC win is in tests: ~3500 lines of wire-format coverage (Bucket A) deleted because that responsibility now lives in CML upstream; ~600 lines of adapter-glue + smoke (Bucket B/C) added in their place.
+
+**Two commits ending at `43cc7f332`:**
+1. `965ba69f8` — `refactor(cmcd): rewrite shaka.util.CmcdManager as thin adapter around CmcdReporter`. The full behavioral rewrite + externs renames + v2 re-exports + test rewrite + demo update. Net −1445 / +5187 across 6 files.
+2. `43cc7f332` — `fix(cmcd): preserve video_ across reset() so configure() can rebuild reporter`. Smoke-surfaced bug: shaka keeps the video element attached across `unload()`/`load()` cycles, so the manager's `video_` field must NOT be cleared in `reset()` — otherwise a post-unload `configure(materialChange)` can't reconstruct the reporter. Adds a regression test for the unload→reconfigure→reload cycle.
+
+**Public-API renames** (experimental v2 surface in `shaka.extern.CmcdConfiguration`):
+- `targets` → `eventTargets` (top-level)
+- per-target `timeInterval` → `interval` (matches CML)
+- per-target `version`, `batchSize` exposed in the typedef
+
+**New public re-exports** (literal-form `@export` per Phase 2's Closure-tooling constraint; value-identity tests assert parity with the corresponding CML enums):
+- `shaka.util.CmcdManager.EventType` (17 entries — superset of shaka's old 10)
+- `shaka.util.CmcdManager.PlayerState` (10 entries — superset of shaka's old 4)
+
+**Wire-format alignments inherited from CML** (call out in the eventual all-phases PR description):
+- `sn` shifts from 1-based to 0-based.
+- Request-mode `sn` becomes a single global counter (was per-target-hash); resets on `sid` change.
+- `CMCD_DEFAULT_TIME_INTERVAL` adopts CML's `30` (was shaka's `10`) when the user does not specify a per-target `interval`.
+
+**Adapter design choices worth surfacing:**
+1. **`enabledKeys` defaults to all valid keys for the version** when the user's `includeKeys` is empty/missing. Without this expansion, CML's `createRequestReport` early-returns on an empty `enabledKeys` array — old shaka treated empty `includeKeys` as "include all", and existing user configs depend on that semantic.
+2. **`appendSrcData` / `appendTextTrackData` bypass the reporter** and call `cml.cmcd.appendCmcdQuery` directly with a synthesized CMCD object. `<video src=…>` and sidecar text-track loads can't carry custom request headers, so query-mode encoding is forced regardless of `useHeaders`. Per-request `sn` is omitted on this path (the reporter's per-target counters don't apply).
+3. **Multi-URI requests** (rare; alternate-CDN retry lists) get the same CMCD encoding applied to every URI in the list. The first URI is rewritten via `createRequestReport`; the encoded `CMCD=…` param is extracted and applied to the remaining URIs via URL parsing. All URIs share one `sn`.
+4. **`networkingEngine_` is read lazily** in `makeRequester_()` via `this.player_.getNetworkingEngine()`. No separate field — keeps the manager simple and avoids stale-reference issues if NetworkingEngine is recreated.
+5. **`m`/muted is event-only**, not persistent state. CTA-5004-B defines `m`/`um` as event types, not data keys; the adapter emits `MUTE`/`UNMUTE` events but does NOT call `update({m: …})`.
+
+**End-to-end smoke verification** (Claude Preview-driven `python3 -m http.server` on `bbb-dark-truths/dash.mpd`):
+- V1 + query: `cid="…",ot=m,sf=d,sid="…",sn=N,st=v` — no `v=` (V1 default semantic), no `ts` (request-mode filter).
+- V2 + query: `cid="…",ot=m,sf=d,sid="…",sn=0..N,st=v,v=2` — `v=2` always present, `ts` absent in request mode, `sn` 0-based.
+- V2 + headers (after `unload→configure({useHeaders: true})→load` cycle): `CMCD-Object: ot=m`, `CMCD-Request: sn=N`, `CMCD-Session: cid="…",sf=d,sid="…",st=v,v=2` — `v=2` only in Session shard, `sn` reset to 0 on session-id change.
+- Public re-exports `EventType`, `PlayerState`, `StreamingFormat` all readable at runtime from the compiled bundle, with values matching `cml.cmcd.*` exactly.
+- Zero CMCD-related console errors. (DASH manifest "Rejecting variant - not compatible with root" warnings are unrelated.)
+
+**Demo update:** added an `Event Targets (JSON)` text input that JSON-parses on change and `player.configure({cmcd: {eventTargets: [...]}})`s the result. Mirrors dash.js's `cmcd-v2.html` minimum scope. Version field converted to a numeric input. Added `'cmcd.eventTargets'` to the demo-unit `exceptions` set so the array-typed config field doesn't trip the "demo references unknown config" check.
+
 ### Key architectural decisions in the port — surface in Phase 1 PR description
 
 These were judgment calls during sub-phases B+C; maintainers should weigh in before merge:
diff --git a/plans/cmcd-cml-refactor/pr-draft.md b/plans/cmcd-cml-refactor/pr-draft.md
index 50594e56cc..4d725d4dde 100644
--- a/plans/cmcd-cml-refactor/pr-draft.md
+++ b/plans/cmcd-cml-refactor/pr-draft.md
@@ -1,7 +1,7 @@
 <!--
-Cumulative PR draft for the CMCD CML refactor. Phase 1 + Phase 2 are
-landed on feat/cmcd-cml-refactor; Phase 3 will append before the eventual
-single all-phases PR.
+Cumulative PR draft for the CMCD CML refactor. All three phases (Phase 1
+vendor + delegate, Phase 2 dedupe, Phase 3 adapter rewrite) are landed
+locally on feat/cmcd-cml-refactor and ready for the single all-phases PR.
 -->
 
 # Title
@@ -18,11 +18,11 @@ Replaces shaka's custom CMCD wire-format encoding and state machine with a vendo
 
 - **Phase 1** (Tasks 1.1-1.13) vendors the port and routes shaka's encoders through it. Three intentional wire-format changes (`nor` URL relativization, `'ld'`/`'lh'` dropped, V2 SFV-conformant encoding).
 - **Phase 2** (Tasks 2.1-2.5) dedupes shaka's internal enums and key arrays in favor of `cml.cmcd.*` equivalents. Pure dedupe; no behavior change.
-- **Phase 3** *(in progress)* rewrites `lib/util/cmcd_manager.js` as a thin adapter around `cml.cmcd.CmcdReporter`, deletes the state machine, ships experimental v2 config renames.
+- **Phase 3** (Tasks 3.1-3.15) rewrites `lib/util/cmcd_manager.js` (1580 → ~700 LoC) as a thin adapter around `cml.cmcd.CmcdReporter`. Deletes the state machine, sequence-number tracking, event timing, and mode-selection logic. Ships experimental v2 config renames (`targets`→`eventTargets`, per-target `timeInterval`→`interval`) and adds public `EventType` / `PlayerState` re-exports. Three additional wire-format alignments inherited from CML.
 
 See [`plans/cmcd-cml-refactor/spec.md`](plans/cmcd-cml-refactor/spec.md) and [`plans/cmcd-cml-refactor/plan.md`](plans/cmcd-cml-refactor/plan.md) for full design + rationale.
 
-Phases 1 + 2 are **behavior-preserving** for shaka's public API, modulo three documented intentional wire-format changes that align shaka with CTA-5004 / CTA-5004-B and CML's spec-conformant output.
+Phases 1 + 2 are **behavior-preserving** for shaka's public API, modulo documented intentional wire-format changes that align shaka with CTA-5004 / CTA-5004-B and CML's spec-conformant output. Phase 3 is the load-bearing behavioral change — the manager's external surface stays compatible, but the internal state machine, sequence-number scope, and event-mode dispatch path all flow through CML's reporter.
 
 ## What's vendored
 
@@ -115,26 +115,69 @@ Pure dedupe — no behavioral change beyond what Phase 1 shipped. Single commit
 - Event-mode validation accepts a strict superset of what shaka's old `V2EventModeKeys` allowed.
 - `isValidEvent_` accepts CML's 17 event types instead of shaka's 10 (adds the 7 ad / skip / custom-event types). shaka doesn't emit these, so user-facing impact is nil.
 
-## Diff size (Phases 1 + 2; Phase 3 will append)
+## Phase 3 implementation summary
+
+The behavioral rewrite. `lib/util/cmcd_manager.js` shrinks from 1580 LoC to ~700, becoming a thin adapter around `cml.cmcd.CmcdReporter`. The reporter owns CMCD state, encoding, key filtering, sequence numbering, and event-mode dispatch; the adapter translates shaka's request/response/player events into reporter calls. The bulk of the LoC win is in tests: ~3500 lines of wire-format coverage (Bucket A) deleted because that responsibility now lives in CML upstream; ~600 lines of adapter-glue + smoke (Bucket B/C) added.
+
+**Two commits:**
+1. `965ba69f8` — `refactor(cmcd): rewrite shaka.util.CmcdManager as thin adapter around CmcdReporter`. The full behavioral rewrite + externs renames + v2 re-exports + test rewrite + demo update.
+2. `43cc7f332` — `fix(cmcd): preserve video_ across reset() so configure() can rebuild reporter`. Smoke-surfaced bug: shaka keeps the video element attached across `unload()`/`load()` cycles, so the manager's `video_` field must NOT be cleared in `reset()` — otherwise a post-unload `configure(materialChange)` can't reconstruct the reporter.
+
+**Public-API renames** (experimental v2 surface in `shaka.extern.CmcdConfiguration`):
+- top-level `targets` → `eventTargets`
+- per-target `timeInterval` → `interval` (matches CML's field name)
+- per-target typedef gains `batchSize` and per-target `version` fields
+
+**New public re-exports** (literal-form `@export` per Phase 2's Closure-tooling constraint; value-identity unit tests assert parity with the corresponding `cml.cmcd.*` enums):
+- `shaka.util.CmcdManager.EventType` — 17 entries (superset of shaka's old 10).
+- `shaka.util.CmcdManager.PlayerState` — 10 entries (superset of shaka's old 4).
+
+**Wire-format changes inherited from CML alignment:**
+1. **`sn` shifts from 1-based to 0-based.** CML's reporter initializes `sn = 0`; old shaka started at `1`. Consumers parsing `sn` as a counter index must adjust.
+2. **Request-mode `sn` becomes a single global counter** (was per-target-hash, where header-vs-query distinct configs got distinct counters); resets on `sid` change. In practice shaka doesn't expose runtime mode switching, so the practical impact is mostly the `sid`-rotation reset semantic.
+3. **`CMCD_DEFAULT_TIME_INTERVAL` adopts CML's `30`** (was shaka's `10`) when the user does not specify a per-target `interval`. Pre-Phase-3, `setupEventModeTimeInterval_` defaulted to 10 seconds; Phase 3 routes through CML's reporter, which uses the v2-default of 30.
+
+**Adapter design choices worth flagging:**
+1. **`enabledKeys` defaults to all valid keys for the version** when the user's `includeKeys` is empty/missing. Without this expansion, CML's `createRequestReport` early-returns on an empty `enabledKeys` array — old shaka treated empty `includeKeys` as "include all", and existing user configs depend on that semantic.
+2. **`appendSrcData` / `appendTextTrackData` bypass the reporter** and call `cml.cmcd.appendCmcdQuery` directly with a synthesized CMCD object. `<video src=…>` and sidecar text-track loads can't carry custom request headers, so query-mode encoding is forced regardless of `useHeaders`. Per-request `sn` is omitted on this path.
+3. **Multi-URI requests** (alternate-CDN retry lists; rare) get the same CMCD encoding applied to every URI. The first URI is rewritten via `createRequestReport`; the encoded `CMCD=…` param is extracted and applied to the remaining URIs via URL parsing. All URIs share one `sn`.
+4. **`networkingEngine_` is read lazily** in `makeRequester_()` via `this.player_.getNetworkingEngine()`. No separate field — keeps the manager simple and avoids stale-reference issues if NetworkingEngine is recreated.
+5. **`m`/muted is event-only, not persistent state.** CTA-5004-B defines `m`/`um` as event types, not data keys; the adapter emits `MUTE`/`UNMUTE` events but does NOT call `update({m: …})`.
+6. **`reset()` preserves `video_`.** Shaka's lifecycle keeps the video element attached across `unload()`/`load()` cycles; only `detach()` releases it. Preserving `video_` is what lets a post-unload `configure(materialChange)` rebuild the reporter and re-attach event listeners on the same video element.
+
+**Event-mode dispatch via NetworkingEngine.** CmcdReporter takes a `requester: (req) => Promise<{status: number}>` callback as its second positional arg for dispatching event-mode reports. Shaka wires this to `NetworkingEngine.request(RequestType.TIMING, ...)` instead of raw `fetch`, so event-mode reports inherit auth/retry/filters — same as manifests and segments. **No new public config field needed**; users already control transport via NetworkingEngine plugins. CML's reporter constructs `method: 'POST'` with a string body (structured-fields encoded by `encodeCmcd`, joined by `'\n'`), which the adapter wraps via `shaka.util.StringUtils.toUTF8` before passing to NetworkingEngine.
+
+**Demo update.** Adds an `Event Targets (JSON)` text input that JSON-parses on change and `player.configure({cmcd: {eventTargets: [...]}})`s the result. Mirrors dash.js's `cmcd-v2.html` minimum scope. Version field converted to a numeric input.
+
+**Deferred follow-ups** (out of scope for this PR):
+- Dedicated `RequestType.CMCD_EVENT_REPORT` request type. Phase 3 uses `RequestType.TIMING`; a follow-up PR can add a dedicated type without changing the adapter contract.
+- Expanded public re-export surface (`CmcdObjectType`, `CmcdStreamType`, `CmcdHeaderField`, etc.). These stay internal under `cml.cmcd.*` until users have a documented need.
+- TypeScript migration (tracked in [#8262](https://github.com/shaka-project/shaka-player/issues/8262)). The vendored directory deletes when this lands.
+
+## Diff size (all three phases)
 
 - `third_party/cml-cmcd/`: 74 new JS files + LICENSE/NOTICE/SUMMARY (+5017 lines, Phase 1).
-- `lib/util/cmcd_manager.js`: +100 / −138 (Phase 1) and +13 / −87 (Phase 2). Cumulative net −112 / +113.
-- `test/util/cmcd_manager_unit.js`: +107 / −140 (Phase 1) and +12 / 0 (Phase 2 value-identity test). Cumulative net −33 / +119.
+- `lib/util/cmcd_manager.js`: +100 / −138 (Phase 1), +13 / −87 (Phase 2), and +~700 / −1580 (Phase 3 — full rewrite). Cumulative net −920 / +810.
+- `test/util/cmcd_manager_unit.js`: +107 / −140 (Phase 1), +12 / 0 (Phase 2), and +~880 / −4296 (Phase 3 rewrite). Cumulative net −3550 / +1000.
+- `externs/shaka/player.js`: experimental `CmcdConfiguration` / `CmcdTarget` typedef updates (Phase 3).
+- `lib/util/player_configuration.js`: `cmcd.targets` → `cmcd.eventTargets` default (Phase 3).
+- `demo/config.js`: `Event Targets (JSON)` input added (Phase 3).
+- `test/demo/demo_unit.js`: `cmcd.eventTargets` added to the array-typed-config exceptions set.
 - `build/conformance.textproto`: 2 entries added (`setInterval`, `fetch`).
 - `build/types/core`: 74 entries added for the vendored files.
 - `plans/cmcd-cml-refactor/`: design + verification docs.
 
-**Total (Phases 1 + 2)**: ~85 files, ~+5800 / ~−500.
+**Total (all three phases)**: ~90 files, ~+6500 / ~−4400. Net positive ~+2100 lines (mostly the vendored CML port; net delete in shaka-side code is dramatic — ~3700 LoC removed from `lib/util/cmcd_manager.js` + tests).
 
 (Plan estimated ~3000 lines for the port; actual is ~5000 because of (a) `cml_sfv.js` (~448 LoC RFC 8941 serializer shim — CML uses `@svta/cml-utils`'s SFV encoder, which we vendor inline since the shim doesn't ship as a separate package), (b) 8 spec-excluded files re-included as runtime dependencies, and (c) generous license/notice headers per Apache 2.0.)
 
-## Verification (Phases 1 + 2)
+## Verification (all three phases)
 
-- [x] `python3 build/check.py` exits 0 (lint, conformance, types, spelling).
-- [x] `python3 build/all.py` exits 0 (full bundle build: dash/hls/compiled/ui/experimental, debug + release).
-- [x] `python3 build/test.py --filter Cmcd` — 125 / 125 pass (Phase 2 added a value-identity test).
-- [x] `python3 build/test.py --quick` — 2996 / 2996 pass (no regressions outside CMCD).
-- [x] Demo smoke test on `bbb-dark-truths/dash.mpd` — query mode emits `?CMCD=cid="…",ot=m,sf=d,sid="…",sn=N,su,v=2` (no `ts`, no `sf=ld`, tokens unquoted, `v=2` always present); header mode emits `v=2` only in `CMCD-Session` shard (the C2 sub-phase E fix verified end-to-end). Zero JS console errors. See [`plan.md`](plans/cmcd-cml-refactor/plan.md) "Sub-phase F landing notes" for the full capture.
+- [x] `python3 build/check.py --force` exits 0 (lint, conformance, types, spelling).
+- [x] `python3 build/all.py --force` exits 0 (full bundle build: dash/hls/compiled/ui/experimental, debug + release).
+- [x] `python3 build/test.py --filter Cmcd` — 57 / 57 pass (Phase 3 deletes ~125 wire-format tests now in CML, adds adapter glue + smoke).
+- [x] `python3 build/test.py --quick` — 2927 / 2927 pass (no regressions outside CMCD; 4 environmental skips on this branch are unrelated to this work).
+- [x] Demo smoke test on `bbb-dark-truths/dash.mpd` — V1+query, V2+query, V2+headers (with `unload→configure({useHeaders: true})→load` cycle) all emit correct CMCD output. Sequence numbers 0-based, reset on `sid` change. `v=2` only in `CMCD-Session` shard. Public re-exports (`EventType`, `PlayerState`, `StreamingFormat`) all readable at runtime from the compiled bundle. Zero CMCD-related console errors.
 
 ## Plan / spec docs
 
@@ -187,4 +230,10 @@ d663f6c12 docs(cmcd): mark Phase 1 sub-phase F complete; add all-phases PR draft
 67443aacb refactor(cmcd): adopt CML constants/enums; delete shaka duplicates
 ```
 
+**Phase 3 — Adapter rewrite (2 commits):**
+```
+965ba69f8 refactor(cmcd): rewrite shaka.util.CmcdManager as thin adapter around CmcdReporter
+43cc7f332 fix(cmcd): preserve video_ across reset() so configure() can rebuild reporter
+```
+
 The first 4 commits (`79702531e`–`6a851a2d8`) are Phase 0 docs only and could be split off as a docs-only PR if maintainers prefer. The rest are implementation.

From 71a1e96074bc61963accc41d55876ab3a57e752f Mon Sep 17 00:00:00 2001
From: Casey Occhialini <1508707+littlespex@users.noreply.github.com>
Date: Tue, 28 Apr 2026 18:25:07 -0700
Subject: [PATCH 36/64] chore: remove plan files

---
 plans/cmcd-cml-refactor/cml-version.md |  285 -----
 plans/cmcd-cml-refactor/plan.md        | 1604 ------------------------
 plans/cmcd-cml-refactor/pr-draft.md    |  239 ----
 plans/cmcd-cml-refactor/spec.md        |  751 -----------
 4 files changed, 2879 deletions(-)
 delete mode 100644 plans/cmcd-cml-refactor/cml-version.md
 delete mode 100644 plans/cmcd-cml-refactor/plan.md
 delete mode 100644 plans/cmcd-cml-refactor/pr-draft.md
 delete mode 100644 plans/cmcd-cml-refactor/spec.md

diff --git a/plans/cmcd-cml-refactor/cml-version.md b/plans/cmcd-cml-refactor/cml-version.md
deleted file mode 100644
index 2ef5382832..0000000000
--- a/plans/cmcd-cml-refactor/cml-version.md
+++ /dev/null
@@ -1,285 +0,0 @@
-# Pinned CML version + API verification report
-
-Date: 2026-04-27
-Pinned npm version: `@svta/cml-cmcd@2.3.0`
-Pinned git tag: `cmcd-v2.3.0`
-Pinned commit SHA: `22390e35dfbbe1e53d15648d3aace99cdf71f9dd`
-Tag commit subject: `feat(cmcd): add CMCD_MIME_TYPE and validateCmcdEventReport (#333)`
-Tag commit date: 2026-04-15
-npm release date: 2026-04-15
-Source location: `libs/cmcd/src/` (in CML monorepo)
-Local checkout used: `/tmp/cml-pinned` (at SHA above)
-
-## Summary
-
-The pinned version (`cmcd-v2.3.0`, npm `2.3.0`) is the latest stable release as of 2026-04-27 — spec assumption confirmed.
-
-Verification surfaced **6 doc/conformance fixes** between the spec and CML's actual public surface. **Zero blockers** — none require CML upstream PRs. Findings #2–#6 are spec/plan doc fixes; finding #1 is a shaka spec-conformance fix (drop non-spec values) applied within Phase 1:
-
-1. **shaka's `'ld'` (LL-DASH) and `'lh'` (LL-HLS) `StreamingFormat` values are non-spec.** They originate from an old, unreleased CMCD draft. CML correctly omits them; CTA-5004 and CTA-5004-B both define only `'d'`/`'h'`/`'s'`/`'o'`. Shaka has been emitting non-conformant `sf` values. **Resolution:** drop `'ld'`/`'lh'` from shaka in Phase 1 alongside encoding delegation. LL DASH emits `sf=d`, LL HLS emits `sf=h`. Wire-format change to flag in Phase 1 PR description.
-2. **`CmcdEventReportConfig.timeInterval` is named `interval` in CML.** Spec's per-target table calls it `timeInterval`; the field is `interval` in CML source. Cosmetic spec fix; adapter must use `interval`.
-3. **`CmcdEventType` has 17 members, not the 10 listed in the spec.** All 10 spec members are present. CML adds: `BITRATE_CHANGE` (`bc`), `AD_START` (`as`), `AD_END` (`ae`), `AD_BREAK_START` (`abs`), `AD_BREAK_END` (`abe`), `SKIP` (`sk`), `CUSTOM_EVENT` (`ce`). No gap — spec just under-listed.
-4. **`recordResponseReceived` data shape uses `response.resourceTiming` (not a flat `{ttfb, ttlb}` data object).** The reporter auto-derives `ttfb`/`ttlb`/`ts` from `response.resourceTiming.{startTime, responseStart, duration}`. The `data` override is still `Partial<Cmcd>` and adapter-supplied `ttfb`/`ttlb`/`rc`/`url` values override the derived ones. Adapter has two valid paths: synthesize a `ResourceTiming`-shaped object on the response, or pass the values directly via the data override. Spec is partially right (field names match) but doesn't reflect the `resourceTiming` indirection.
-5. **`createRequestReport` returns a derived object as spec said, but `recordResponseReceived` returns `void`.** Spec is correct on both counts. No `applyResponseData` "copy back" step is required — CML's response flow is purely state-recording (it queues an internal `rr` event for any configured event-mode targets). Adapter's `applyResponseData` does not need to mutate `response` based on CML output.
-6. **CML's request-mode sequence numbers are global, not per-target.** Single counter `requestTarget.sn` for all request-mode reports; one counter per event target. Shaka currently has separate `{request, response}` counters per per-config-hash target. CML does not split request from response — `rr` events use the per-event-target counter, request reports use the global `requestTarget` counter. This is a wire-format divergence that should be flagged in the Phase 3 PR.
-
-Beyond the findings above, all other spec assertions verified cleanly: lifecycle methods, `requester` callback contract, `CmcdEventReportConfig` field set (modulo the `interval` rename), per-target `version` IS exposed (spec § Open Questions Q3 resolved — keep the per-target `version` field).
-
-**Recommended next step:** Proceed to Phase 1. CML version pin remains `cmcd-v2.3.0`; no upstream PRs required. Apply the doc fixes (findings #2–#6) and the LL-value drop (finding #1) as part of Phase 1's wire-format-alignment work, alongside the already-planned `nor` URL relativization change.
-
-## Task 0.2 — Lifecycle methods
-
-All five lifecycle methods exist on `class CmcdReporter` in `libs/cmcd/src/CmcdReporter.ts`. Citations:
-
-| Method | File:line | Signature | Returns | Throws |
-|---|---|---|---|---|
-| `start()` | `CmcdReporter.ts:151` | `start(): void` | `void` | No declared throws. Sets up `setInterval` per event target whose `interval` > 0 and which subscribes to `TIME_INTERVAL`. **Note:** fires an initial time-interval event synchronously (line 164) before the first interval elapses — adapter must populate state before calling `start()`. |
-| `stop(flush?)` | `CmcdReporter.ts:173` | `stop(flush: boolean = false): void` | `void` | No declared throws. If `flush` truthy, calls `this.flush()` first (line 174-176), then `clearInterval` on every event target (line 178-180). Default `flush = false`. |
-| `flush()` | `CmcdReporter.ts:188` | `flush(): void` | `void` | No declared throws. Forwards to `processEventTargets(true)` (line 189), which dispatches all queued events regardless of batch size. |
-| `update(data)` | `CmcdReporter.ts:197` | `update(data: Partial<Cmcd>): void` | `void` | No declared throws. If `data.sid` differs from current `sid`, resets per-target sequence counters (line 198-200, `resetSession()` at line 455). Strips `msd` from persistent state (line 208). |
-| `recordEvent(type, data?)` | `CmcdReporter.ts:219` | `recordEvent(type: CmcdEventType, data: Partial<Cmcd> = {}): void` | `void` | No declared throws. Records the event for every event target whose `events` array includes `type`, then runs `processEventTargets()` (line 224). |
-
-**Confirmed:** All five methods exist with signatures compatible with the adapter's intended call sites. None throw on the success path. Adapter's `reset()` should call `reporter.stop(true)` to flush pending events before tearing down.
-
-## Task 0.3 — `CmcdEventType` enum
-
-`libs/cmcd/src/CmcdEventType.ts` defines a 17-member `as const` map. All 10 spec members are present. Mapping:
-
-| Two-letter code | CML constant | CML enum key | File:line |
-|---|---|---|---|
-| `bc` | `CMCD_EVENT_BITRATE_CHANGE` | `CmcdEventType.BITRATE_CHANGE` | `CmcdEventType.ts:8`, `CmcdEventType.ts:135` |
-| `ps` | `CMCD_EVENT_PLAY_STATE` | `CmcdEventType.PLAY_STATE` | `CmcdEventType.ts:15`, `CmcdEventType.ts:140` |
-| `e` | `CMCD_EVENT_ERROR` | `CmcdEventType.ERROR` | `CmcdEventType.ts:22`, `CmcdEventType.ts:145` |
-| `t` | `CMCD_EVENT_TIME_INTERVAL` | `CmcdEventType.TIME_INTERVAL` | `CmcdEventType.ts:29`, `CmcdEventType.ts:150` |
-| `c` | `CMCD_EVENT_CONTENT_ID` | `CmcdEventType.CONTENT_ID` | `CmcdEventType.ts:36`, `CmcdEventType.ts:155` |
-| `b` | `CMCD_EVENT_BACKGROUNDED_MODE` | `CmcdEventType.BACKGROUNDED_MODE` | `CmcdEventType.ts:43`, `CmcdEventType.ts:160` |
-| `m` | `CMCD_EVENT_MUTE` | `CmcdEventType.MUTE` | `CmcdEventType.ts:50`, `CmcdEventType.ts:165` |
-| `um` | `CMCD_EVENT_UNMUTE` | `CmcdEventType.UNMUTE` | `CmcdEventType.ts:57`, `CmcdEventType.ts:170` |
-| `pe` | `CMCD_EVENT_PLAYER_EXPAND` | `CmcdEventType.PLAYER_EXPAND` | `CmcdEventType.ts:64`, `CmcdEventType.ts:175` |
-| `pc` | `CMCD_EVENT_PLAYER_COLLAPSE` | `CmcdEventType.PLAYER_COLLAPSE` | `CmcdEventType.ts:71`, `CmcdEventType.ts:180` |
-| `rr` | `CMCD_EVENT_RESPONSE_RECEIVED` | `CmcdEventType.RESPONSE_RECEIVED` | `CmcdEventType.ts:78`, `CmcdEventType.ts:185` |
-
-Plus 6 additional members not in the spec list, present in CML:
-
-| Two-letter code | CML enum key | File:line |
-|---|---|---|
-| `as` | `CmcdEventType.AD_START` | `CmcdEventType.ts:85`, `CmcdEventType.ts:190` |
-| `ae` | `CmcdEventType.AD_END` | `CmcdEventType.ts:92`, `CmcdEventType.ts:195` |
-| `abs` | `CmcdEventType.AD_BREAK_START` | `CmcdEventType.ts:99`, `CmcdEventType.ts:200` |
-| `abe` | `CmcdEventType.AD_BREAK_END` | `CmcdEventType.ts:106`, `CmcdEventType.ts:205` |
-| `sk` | `CmcdEventType.SKIP` | `CmcdEventType.ts:113`, `CmcdEventType.ts:210` |
-| `ce` | `CmcdEventType.CUSTOM_EVENT` | `CmcdEventType.ts:120`, `CmcdEventType.ts:215` |
-
-**Naming clarification (vs plan):** `plan.md:86` (Task 0.3 description) listed several guessed enum names that turned out wrong. Actual CML mappings: `pe → PLAYER_EXPAND` (not `PLAY_END` / `PLAYER_ERROR`); `pc → PLAYER_COLLAPSE` (not `PLAYBACK_CHANGE`); `t → TIME_INTERVAL` (not `TIMEOUT`); `c → CONTENT_ID` (not `CONTENT_ID_CHANGE`); `b → BACKGROUNDED_MODE` (not `BACKGROUNDED`). The Task 0.3 table above has the correct CML names. Plan doc should be updated for any future re-runs of this verification, though the plan's purpose was just to enumerate codes to verify, not to assert names.
-
-**Confirmed:** Every event type the adapter intends to emit (`ps`, `e`, `t`, `c`, `b`, `m`, `um`, `pe`, `pc`, `rr`) has a CML enum value. Note also that `BITRATE_CHANGE` (which the spec uses without giving a code) is `bc`, present in CML.
-
-## Task 0.4 — Request/response report methods
-
-### `createRequestReport(request, data?)`
-
-| Aspect | Finding |
-|---|---|
-| File:line | `CmcdReporter.ts:347` |
-| Signature | `createRequestReport<R extends HttpRequest = HttpRequest>(request: R, data?: Partial<Cmcd>): R & CmcdRequestReport<R['customData']>` |
-| Return shape | Defined in `libs/cmcd/src/CmcdRequestReport.ts:9` — `HttpRequest & {customData: {cmcd: Cmcd} & D; headers: Record<string, string>}` |
-| Behavior | Returns a derived object (not in-place mutation). Builds new `report` object from spread of `request` (line 348-358). If `enabledKeys.length` is 0 or `report.url` is falsy, returns the bare cloned report with empty `cmcd: {}` (line 360-362). Otherwise applies CMCD data either to query string (line 376-382) or headers (line 384-386) per `transmissionMode`. |
-
-**Confirmed:** Spec assertion `R & CmcdRequestReport<R['customData']>` matches exactly. Adapter MUST adopt the "copy fields back" pattern (CmcdReporter.ts:347 returns a new object; shaka's existing `applyRequestData` mutates in place). Specifically: copy `report.url` and `report.headers` back onto the input `request` to preserve shaka's mutation contract.
-
-### `recordResponseReceived(response, data?)`
-
-| Aspect | Finding |
-|---|---|
-| File:line | `CmcdReporter.ts:277` |
-| Signature | `recordResponseReceived(response: HttpResponse<HttpRequest<{ cmcd?: Cmcd }>>, data: Partial<Cmcd> = {}): void` |
-| Returns | `void` — purely state-recording. **No data to copy back.** Adapter's `applyResponseData` does not need to mutate `response` based on CML output. |
-| Data param shape | `Partial<Cmcd>` — i.e., partial of the CMCD payload object. Field names are CMCD wire keys (`url`, `rc`, `ttfb`, `ttlb`, `ts`, etc.) — **`rc` not `responseCode`** (spec was right). |
-| `response` shape | `HttpResponse` — defined in `libs/utils/src/HttpResponse.ts:10`. Required: `request: HttpRequest`. Optional: `status`, `url`, `redirected`, `statusText`, `type`, `headers`, `data`, `resourceTiming`. |
-| Auto-derived fields | `CmcdReporter.ts:289-308`: `url` ← `data.url ?? request.url`; `rc` ← `response.status`; `ts` ← `Math.round(timeOrigin + resourceTiming.startTime)`; `ttfb` ← `Math.round(resourceTiming.responseStart - resourceTiming.startTime)`; `ttlb` ← `Math.round(resourceTiming.duration)`. |
-| Override priority | Line 312: `{ ...cmcd, ...derived, ...data }` — `data` wins over derived, derived wins over the per-request `cmcd` data attached to the original request's `customData`. |
-
-**Confirmed (with caveat):** Spec's `recordResponseReceived(response, {ttfb, ttlb, rc, url})` IS a valid call shape — CML accepts `Partial<Cmcd>` and the adapter-supplied keys override CML's auto-derivation. **However**, the adapter has two equivalent paths:
-1. Synthesize a `ResourceTiming` object (`{startTime, responseStart, duration}`) on `response.resourceTiming` and let CML derive — closer to "let CML do the work".
-2. Pre-compute `ttfb`/`ttlb`/`rc`/`url` and pass via the `data` override — closer to spec's call shape, but means re-computing what shaka already measures via `requestTimestampMap_`.
-
-Spec doc should clarify that the data param is a `Partial<Cmcd>` not a fixed-shape object, and that `resourceTiming` is the canonical input for timing fields. No CML defect — just spec drift.
-
-### Other relevant request methods
-
-- `applyRequestReport(req)` — `CmcdReporter.ts:324`. Marked `@deprecated`; calls `createRequestReport` internally. Adapter should use `createRequestReport` directly.
-- `isRequestReportingEnabled()` — `CmcdReporter.ts:333`. Returns `!!this.config.enabledKeys?.length`. Useful for adapter-side fast-path.
-
-## Task 0.5 — `CmcdEventReportConfig` field-by-field diff
-
-Source: `libs/cmcd/src/CmcdEventReportConfig.ts` (extends `CmcdReportConfig` from `libs/cmcd/src/CmcdReportConfig.ts`).
-
-| Spec field | CML field | Type | File:line | Notes |
-|---|---|---|---|---|
-| `url` | `url` | `string` | `CmcdEventReportConfig.ts:22` | Required. Match. |
-| `events` | `events` | `CmcdEventType[]` (optional) | `CmcdEventReportConfig.ts:30` | Match. |
-| **`timeInterval`** | **`interval`** | `number` (optional, seconds) | `CmcdEventReportConfig.ts:40` | **Field name mismatch.** CML uses `interval`. Default `CMCD_DEFAULT_TIME_INTERVAL = 30` (`CMCD_DEFAULT_TIME_INTERVAL.ts:6`). Adapter must rename `timeInterval` → `interval`. |
-| `batchSize` | `batchSize` | `number` (optional) | `CmcdEventReportConfig.ts:47` | Match. Default `1`. |
-| `enabledKeys` | `enabledKeys` | `CmcdKey[]` (optional, inherited from `CmcdReportConfig`) | `CmcdReportConfig.ts:24` | Match. |
-| `version` | `version` | `typeof CMCD_V2` (optional) | `CmcdEventReportConfig.ts:17` | **Per-target `version` IS exposed.** Note CML restricts it to `CMCD_V2` (event mode is v2-only — v1 has no event mode). Spec § "Per-target version override" gap-resolution: keep the field. |
-
-Also inherited from `CmcdReportConfig`:
-- `version?: CmcdVersion` — overridden by `CmcdEventReportConfig`'s narrower `typeof CMCD_V2` constraint.
-- `enabledKeys?: CmcdKey[]`.
-
-**Resolution of spec's open question on per-target `version`:** Keep the per-target `version` field. CML exposes it; behaviorally it's a no-op in v2.x (CML only allows `CMCD_V2`), but mapping shaka's `version` → CML's `version` per-target is harmless and forward-compatible.
-
-**Action items:**
-1. Rename `timeInterval` → `interval` in shaka's `shaka.extern.CmcdTarget` typedef during Phase 3, OR add an alias in the adapter's `toReporterConfig_` (`timeInterval` is the experimental v2 config). Spec § public-API section already authorizes experimental renames.
-2. Update spec doc § "Per-target eventTargets[] field shape" to use `interval`.
-
-## Task 0.6 — `CmcdStreamingFormat` value parity
-
-| Spec-conformant value | shaka value | CML value | File:line | Status |
-|---|---|---|---|---|
-| `'d'` (DASH) | `DASH: 'd'` (`cmcd_manager.js:1613`) | `DASH: 'd'` | `CmcdStreamingFormat.ts:16` | **Match** |
-| `'h'` (HLS) | `HLS: 'h'` (`cmcd_manager.js:1615`) | `HLS: 'h'` | `CmcdStreamingFormat.ts:21` | **Match** |
-| `'s'` (SMOOTH) | `SMOOTH: 's'` (`cmcd_manager.js:1617`) | `SMOOTH: 's'` | `CmcdStreamingFormat.ts:26` | **Match** |
-| `'o'` (OTHER) | `OTHER: 'o'` (`cmcd_manager.js:1618`) | `OTHER: 'o'` | `CmcdStreamingFormat.ts:31` | **Match** |
-| *(non-spec)* | `LOW_LATENCY_DASH: 'ld'` (`cmcd_manager.js:1614`) | *(correctly omitted)* | n/a | **shaka non-conformant** |
-| *(non-spec)* | `LOW_LATENCY_HLS: 'lh'` (`cmcd_manager.js:1616`) | *(correctly omitted)* | n/a | **shaka non-conformant** |
-
-CML defines only DASH/HLS/SMOOTH/OTHER (`CmcdStreamingFormat.ts:12-32`). All 4 spec-conformant values match between shaka and CML.
-
-**Re shaka's `'ld'`/`'lh'` values:** These originate from an old, unreleased CMCD draft and are not present in either CTA-5004 (CMCD v1) or CTA-5004-B (CMCD v2). CML is correct to omit them; shaka has been emitting non-conformant `sf` values. The maintainer (who owns both repos) confirmed CML's omission is intentional.
-
-**Impact:** Phase 2's alias re-export plan is **unblocked** — once shaka drops `'ld'`/`'lh'`, shaka's enum becomes a strict subset of CML's, and `shaka.util.CmcdManager.StreamingFormat = cml.cmcd.CmcdStreamingFormat` works straightforwardly. shaka's internal `setLowLatency` flow (`cmcd_manager.js:177-194` — flipping `sf_` between `DASH ↔ LOW_LATENCY_DASH` and `HLS ↔ LOW_LATENCY_HLS`) needs simplification: LL DASH stays at `'d'`, LL HLS stays at `'h'`.
-
-**Recommended action:** Drop `LOW_LATENCY_DASH` and `LOW_LATENCY_HLS` from `shaka.util.CmcdManager.StreamingFormat` and remove `setLowLatency`'s `sf_` mutation in **Phase 1**, alongside the encoding delegation. This is a wire-format change — flag in the Phase 1 PR description alongside `nor` URL relativization. No CML PR required.
-
-## Task 0.7 — Sequence-number behavior
-
-### CML behavior
-
-Source: `libs/cmcd/src/CmcdReporter.ts`.
-
-- **Request mode:** Single global counter `this.requestTarget.sn` (initialized to 0 at line 111). Incremented on every `createRequestReport` call regardless of target. Line 365: `cmcdData = { ...this.data, ...data, sn: this.requestTarget.sn++ }`.
-- **Event mode:** Per-event-target counter `target.sn` (one per `eventTargets[]` entry). Each target's `sn` initialized to 0 at line 137. Incremented on every event recorded for that target. Line 247: `sn: target.sn++`.
-- **Reset:** `resetSession()` at `CmcdReporter.ts:455` resets both kinds: every event target's `sn` to 0 (line 456), and the global request-mode `sn` to 0 (line 457). Triggered from `update()` whenever `data.sid` is supplied AND differs from current `sid` (line 198-200).
-- **No separation of "request" vs "response" counters.** Response-received events (`rr`) flow through `recordEvent` (line 312), so they share the per-event-target counter with all other event-mode events.
-
-### Shaka's existing behavior
-
-Source: `lib/util/cmcd_manager.js`.
-
-- **State:** `this.cmcdSequenceNumbers_ = {}` keyed by config-target hash (`cmcd_manager.js:93, 148`). Each entry has shape `{request: number, response: number}` (line 739, 781).
-- **Request mode:** Counter at `cmcdSequenceNumbers_[hash].request++` per request (line 784). Hash key is `getCmcdTargetHash_({mode: REQUEST, useHeaders, includeKeys})`.
-- **Event mode:** Counter at `cmcdSequenceNumbers_[hash].response++` per event (line 742). Hash key is `getCmcdTargetHash_(target)` where `target` is the user-configured event-target object.
-- **Reset:** `cmcdSequenceNumbers_ = {}` on `reset()` (line 148). No partial reset on `sid` change.
-- **Initial value:** counters start at 1 (line 739, 781), so first emitted `sn` is 1.
-
-### Divergences
-
-| Aspect | shaka | CML |
-|---|---|---|
-| Request-mode counter scope | Per-target-hash (`{useHeaders, includeKeys}` distinct → distinct counter) | One global counter for all request-mode reports |
-| Event-mode counter scope | Per-target (each `eventTargets[]` entry → own counter) | Same — per-target |
-| Counter naming | `{request, response}` separate counters per target hash | Single `sn` per target; `rr` events share with other event-mode events |
-| Initial value | `1` | `0` |
-| Reset on `sid` change | Not reset | Reset (request-mode global + every event-target) |
-| Reset on `reset()` | Yes (whole dict cleared) | n/a — adapter must construct a new reporter or call `update({sid: newSid})` |
-
-**Wire-format impact for Phase 3 PR:**
-1. **First `sn` shifts from 1 to 0.** Consumers parsing `sn` as a counter index must adjust if they were assuming 1-based indexing.
-2. **Request-mode `sn` is no longer scoped to header-vs-query mode.** A shaka session that switched `useHeaders` mid-flight previously got two independent counters; with CML, both modes share one. In practice this is unlikely (shaka doesn't expose runtime mode switching), but it's a behavioral simplification worth flagging.
-3. **`sn` resets on `sid` change in CML.** Shaka's existing behavior keeps per-hash counters intact across `sid` rotations within a session. CML resets on each new `sid`. Adapter behavior post-Phase-3 will reset `sn` on session-id rotation.
-
-**Confirmed:** Sequence-number behavior is documented and divergences identified. Adapter doesn't need to do anything special — let CML own the counters; just call out the wire change in the Phase 3 PR description.
-
-## Task 0.8 — `requester` callback contract
-
-Source: `libs/cmcd/src/CmcdReporter.ts`. Type imports from `@svta/cml-utils` (`libs/utils/src/HttpRequest.ts`, `libs/utils/src/HttpResponse.ts`).
-
-### Where `requester` is invoked
-
-`CmcdReporter.ts:432-449` (`sendEventReport` private method):
-
-```typescript
-private async sendEventReport(target: CmcdEventReportConfigNormalized, data: Cmcd[]): Promise<void> {
-    const options = createEncodingOptions(CMCD_EVENT_MODE, target)
-    const response = await this.requester({
-        url: target.url,
-        method: 'POST',
-        headers: {
-            'Content-Type': CMCD_MIME_TYPE,
-        },
-        body: data.map(item => encodeCmcd(item, options)).join('\n') + '\n',
-    })
-    // ...
-}
-```
-
-Default requester (`CmcdReporter.ts:50-53`): `(request) => fetch(request.url, request)`. Replaced via constructor's second arg (`CmcdReporter.ts:125`) — no `config.requester` field; it's a constructor parameter.
-
-### Contract
-
-| Aspect | Finding |
-|---|---|
-| **Request shape** | `{url: string, method: 'POST', headers: {'Content-Type': 'application/cmcd', ...}, body: string}` always. Method is hardcoded `'POST'` (line 436). Headers always include `Content-Type: application/cmcd` (lines 437-439, `CMCD_MIME_TYPE.ts:6`). Body is always a `string` (line 440 — `encodeCmcd(...).join('\n') + '\n'`). The full `HttpRequest` type (`HttpRequest.ts:8`) allows additional fields (`body?: BodyInit`, `responseType`, `credentials`, `mode`, `timeout`, `customData`) but the reporter uses only the four above. |
-| **Body type** | **Always `string`.** Spec § "Event-mode dispatch via NetworkingEngine" claims body may be string or Blob — **incorrect for CML 2.3.0.** Adapter's body-conversion logic only needs the string path: `shaka.util.StringUtils.toUTF8(cmcdReq.body)`. The Blob/`BodyInit` path is dead code; removing it simplifies the adapter. (CML's reporter body shape is fixed by the encoder; it never emits JSON or binary.) |
-| **Response promise shape** | `Promise<{status: number}>` (line 125, line 50). The full `HttpResponse` type (`HttpResponse.ts:10`) has many more fields, but the reporter only reads `status` (line 443). |
-| **Status semantics** | Line 445-449. **`410`** → silently delete the target permanently (`this.eventTargets.delete(target)`). **`429` or `5xx` (500-599)** → throw an Error; the catch in `processEventTargets` (line 413-416) re-queues the failed batch via `target.queue.unshift(...events)`. **All other statuses (including `200`, `204`, `4xx` other than `410`/`429`)** → silent success; events are NOT re-queued. |
-| **Rejection vs non-2xx** | Asymmetric. A **rejected promise** is caught by `processEventTargets` (line 413: `.catch(() => target.queue.unshift(...events))`) — re-queues the batch. A **resolved-with-410** is treated specially; **resolved-with-200..499 (excluding 410, 429)** is silent success. **Resolved-with-429 or 5xx** throws inside `sendEventReport` → re-queues. So: rejection ≡ "retry"; non-2xx other than `410`/`429`/`5xx` ≡ "drop silently"; `410` ≡ "stop using this target". |
-| **No body on response** | Reporter never reads `response.body` or `response.data` from the requester — only `status`. Adapter's requester shim need not preserve the response body. |
-
-**Confirmed:** Adapter's requester shim has a tight, well-defined contract. The `try/catch` example in spec (lines 477-485) returns `{status: 200}` on success and `{status: err.status || 0}` on failure. With CML's status-code handling above, that's correct: rejection → re-queue (good); non-2xx returned as resolved → silent drop unless `429`/`5xx`. **Recommendation:** Adapter SHOULD distinguish between recoverable network errors (DNS/timeout/abort) and HTTP errors. NetworkingEngine throws on retries-exhausted with `error.severity` and `error.code`; adapter could map to `{status: 0}` (rejection-equivalent) for retry, or `{status: 410}` (poison the target) for permanent failures. Spec's example reasonably maps both to `{status: err.status || 0}` which falls through to "silent drop" — acceptable for an MVP but loses the re-queue-on-transient-failure benefit. This is a Phase 3 design refinement, not a Phase 0 blocker.
-
-## Gaps found
-
-No CML defects. All findings are doc fixes (spec/plan accuracy) or shaka spec-conformance fixes:
-
-1. **shaka's `'ld'`/`'lh'` `StreamingFormat` values are non-spec; drop in Phase 1.** These come from an old unreleased CMCD draft. CML correctly omits them per CTA-5004 / CTA-5004-B.
-   - **Spec assertion that fails:** Spec § "Public-API back-compat details" lines 411-412 ("Verified values match: `'d'`, `'ld'`, `'h'`, `'lh'`, `'s'`, `'o'`.") — claim is wrong on the LL variants.
-   - **Recommended action:** Drop `'ld'`/`'lh'` from `shaka.util.CmcdManager.StreamingFormat` in Phase 1. Wire-format change: LL DASH emits `sf=d`, LL HLS emits `sf=h` (instead of `sf=ld`/`sf=lh`). Flag in Phase 1 PR description. No CML PR required.
-
-2. **`CmcdEventReportConfig.timeInterval` is `interval` in CML.** Spec doc uses `timeInterval` throughout § "Per-target eventTargets[] field shape" and the experimental rename table.
-   - **Spec assertion that fails:** Spec § "Per-target eventTargets[] field shape" row 3 (`timeInterval`).
-   - **Recommended action:** Update spec doc to say `interval` (or document the shaka-side `timeInterval` rename explicitly as a third experimental rename layered on the existing `enabledKeys → includeKeys` and `targets → eventTargets` renames). Implementation-wise, the adapter's `toReporterConfig_` already renames per-target fields, so this is mechanically trivial.
-
-3. **`recordResponseReceived` data shape is `Partial<Cmcd>`, not `{ttfb, ttlb, rc, url}`.** Spec implies a fixed shape; CML accepts any partial CMCD object. Auto-derived fields come from `response.resourceTiming`.
-   - **Spec assertion that fails:** `spec.md:299` ("Adapter calls `reporter.recordResponseReceived(response, {ttfb, ttlb, rc, url})`.").
-   - **Recommended action:** Update spec to clarify the data param is `Partial<Cmcd>` and that the adapter has two valid paths (synthesize `resourceTiming` or pass overrides). No CML defect.
-
-4. **Sequence-number scope and reset semantics differ from shaka's existing behavior.** Detailed in Task 0.7. Wire-format change.
-   - **Spec assertion that fails:** Spec § "CML-side requirements" row "Sequence numbers per-target — likely present; verify per v2 spec" (verified, but with divergence from shaka's existing semantics).
-   - **Recommended action:** Document in Phase 3 PR description as an intentional alignment-with-CML wire change. No code change required in CML or adapter.
-
-5. **`CmcdEventType` constant name mappings (in `plan.md`, not `spec.md`).** `plan.md:86` (Task 0.3 description) guessed names for several codes that turned out wrong. Actual CML names: `pe → PLAYER_EXPAND` (plan guessed `PLAY_END or PLAYER_ERROR`); `pc → PLAYER_COLLAPSE` (plan guessed `PLAYBACK_CHANGE`); `t → TIME_INTERVAL` (plan guessed `TIMEOUT or similar`); `c → CONTENT_ID` (plan guessed `CONTENT_ID_CHANGE`); `b → BACKGROUNDED_MODE` (plan guessed `BACKGROUNDED`). `spec.md:530-534` lists only the two-letter codes (no full names) and is unaffected.
-   - **Spec/plan assertion that fails:** `plan.md:86`.
-   - **Recommended action:** Plan doc fix only. No CML defect, no spec.md change required.
-
-6. **`requester` is a constructor parameter, not a config field.** Two places in `spec.md` describe it as a config field:
-   - `spec.md:449` ("`CmcdReporter` accepts a `requester: (req) => Promise<{status: number}>` config option")
-   - `spec.md:511` (CML-side requirements table row: "`requester` config field for event-mode dispatch")
-   - It's actually the **second positional arg to the constructor**, not a `CmcdReporterConfig` field.
-   - **Spec assertion that fails:** `spec.md:449` and `spec.md:511`.
-   - **Recommended action:** Spec doc fix at both locations. Implementation-wise, the adapter calls `new CmcdReporter(reporterConfig, requesterFn)` instead of `new CmcdReporter({...reporterConfig, requester: requesterFn})`. Mechanically equivalent.
-
-Minor: The spec § "Event-mode dispatch via NetworkingEngine" body-conversion code path handles Blob (line 471-474 of spec.md: `else if (cmcdReq.body instanceof Blob) { ... }`). CML never produces Blob bodies. The Blob branch is dead code and the adapter can drop it.
-
-## Recommended next step
-
-**Proceed to Phase 1.** CML version pin remains `cmcd-v2.3.0` (`22390e35`); no upstream PRs required. Apply the doc updates below, fold the `'ld'`/`'lh'` drop into Phase 1 alongside encoding delegation, then begin Phase 1 implementation.
-
-**Doc-only updates (no code impact):**
-
-### Update plan.md
-- `plan.md:86` (Task 0.3 description) — replace the enum-name guesses with the correct CML constant names from Task 0.3's table above. Specifically: `pe → PLAYER_EXPAND` (was `PLAY_END or PLAYER_ERROR`); `pc → PLAYER_COLLAPSE` (was `PLAYBACK_CHANGE`); `t → TIME_INTERVAL` (was `TIMEOUT or similar`); `c → CONTENT_ID` (was `CONTENT_ID_CHANGE`); `b → BACKGROUNDED_MODE` (was `BACKGROUNDED`).
-- `plan.md` Phase 1 — add a sub-task to drop `'ld'`/`'lh'` from `shaka.util.CmcdManager.StreamingFormat` and simplify `setLowLatency`'s `sf_` mutation. Phase 1 wire-format-change callout extends to cover both `nor` URL relativization and the LL value drop.
-- `plan.md` Phase 2 Task 2.3 (StreamingFormat re-export) — add a one-line note that after the Phase 1 LL drop, shaka's enum is a strict subset of CML's, so the alias re-export is straightforward.
-- `plan.md` Phase 3 Task 3.6 (player event listeners) — drop the `setLowLatency` → `update({streamingFormat: LOW_LATENCY_*})` step.
-- `plan.md` "Spec gaps surfaced during planning" gap #10 — update to reflect the actual finding (shaka emits non-spec values, CML is correct, drop in Phase 1).
-
-### Update spec.md
-- `spec.md:296-302` (`applyResponseData` flow step 2) — clarify that `recordResponseReceived` takes `Partial<Cmcd>` and auto-derives `ttfb`/`ttlb`/`ts` from `response.resourceTiming`. The flat `{ttfb, ttlb, rc, url}` override path still works but is the secondary path; the primary path is to synthesize a `ResourceTiming` object on `response.resourceTiming` and let CML derive timing fields.
-- `spec.md:346` — rename per-target `timeInterval` field to `interval` (matches CML's `CmcdEventReportConfig.ts:40`).
-- `spec.md:381-382` — drop both `setLowLatency(true) + DASH/HLS → update({streamingFormat: LOW_LATENCY_*})` rows from the "Player state ↔ reporter state mapping" table. Add a brief note that `sf` no longer reflects LL state in CMCD v2.
-- `spec.md:412` — update "Verified values match: `'d'`, `'ld'`, `'h'`, `'lh'`, `'s'`, `'o'`" to drop the LL variants and note shaka's non-spec values are dropped in Phase 1.
-- `spec.md:449` and `spec.md:511` — fix both references to `requester` as a "config field"; it's the `CmcdReporter` constructor's second positional arg, not a `CmcdReporterConfig` member.
-- `spec.md:469-475` (adapter requester sketch) — drop the Blob branch. CML's reporter only emits `body: string`; the Blob path is dead code.
-- `spec.md` Phase 3 section — add a note that sequence-number reset on `sid` change and the request-mode counter scope change (per-target-hash → global) are intentional alignment-with-CML wire changes, not regressions.
diff --git a/plans/cmcd-cml-refactor/plan.md b/plans/cmcd-cml-refactor/plan.md
deleted file mode 100644
index 0762bc389e..0000000000
--- a/plans/cmcd-cml-refactor/plan.md
+++ /dev/null
@@ -1,1604 +0,0 @@
-# CMCD CML Refactor Implementation Plan
-
-> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
-
-**Goal:** Replace shaka-player's 1700-line custom `shaka.util.CmcdManager` and ~4300 lines of CMCD wire-format tests with a vendored Closure port of `@svta/cml-cmcd` plus a thin shaka-specific adapter (~250 lines), shipped as three sequential reviewable PRs.
-
-**Architecture:** Three layers — public shaka API (back-compat preserved except experimental v2 renames) → thin shaka adapter (`lib/util/cmcd_manager.js`) → vendored CML port (`third_party/cml-cmcd/`, namespace `cml.cmcd.*`). When shaka migrates to TypeScript ([#8262](https://github.com/shaka-project/shaka-player/issues/8262)), the vendored directory deletes and `goog.require('cml.cmcd.X')` becomes `import { X } from '@svta/cml-cmcd'` — no other code changes.
-
-**Tech stack:** JavaScript with `goog.provide`/`goog.require`, JSDoc type annotations, Closure Compiler `ADVANCED_OPTIMIZATIONS`, Python build system (`build/check.py`, `build/test.py`, `build/all.py`), Karma + Jasmine for tests.
-
-**Canonical input:** [spec.md](spec.md) (~600 lines) — file lists, type translations, encoding rules, lifecycle tables, and rationale all live there. This plan sequences the work and identifies risks; it does not duplicate the spec.
-
----
-
-## Current status (last updated 2026-04-28)
-
-This refactor is functionally complete on branch `feat/cmcd-cml-refactor`. All three phases have landed locally (29 commits ahead of origin); a single all-phases PR is the user-driven next step.
-
-| Phase | Status | Commits / Notes |
-|---|---|---|
-| **Phase 0** — CML verification | ✅ Complete | Verification report at [`cml-version.md`](cml-version.md). CML pin: `cmcd-v2.3.0` / commit `22390e35dfbbe1e53d15648d3aace99cdf71f9dd`. **No upstream CML PRs needed.** Five spec/plan doc fixes already applied. |
-| **Phase 1A** — Skeleton + typedefs + enums + constants + utils (Tasks 1.1-1.5) | ✅ Complete | 6 commits, ending at `e6cb2563d`. 44 files added under `third_party/cml-cmcd/`. |
-| **Phase 1B** — Encoders + helpers + cml-utils/sfv shims + deferred `CMCD_FORMATTER_MAP` (Tasks 1.6-1.7) | ✅ Complete | 5 commits, ending at `9bcf6614e`. 23 new files. Re-included 8 spec-excluded files (predicates + `is_valid.js` + `group_cmcd_headers.js`) that were genuinely runtime-required by encoders. New shim `cml_sfv.js` (~448 LoC, RFC 8941 §4.1 serializer). |
-| **Phase 1C** — `CmcdReporter` + 5 deferred typedefs (Task 1.8) | ✅ Complete | 3 commits, ending at `d682bb1bb`. 6 new files. The vendored port is now structurally complete. |
-| **Phase 1D** — Encoding delegation in `cmcd_manager.js` + drop non-spec `'ld'`/`'lh'` (Tasks 1.10, 1.10b) | ✅ Complete | 2 commits, ending at `adfdfab05`. Net −168 LoC across `lib/util/cmcd_manager.js` and `test/util/cmcd_manager_unit.js`. `python3 build/check.py` exits 0. `build/test.py` deferred to sub-phase E (Tasks 1.11-1.12 catalog and update wire-format-divergence assertions). |
-| **Phase 1E** — Diff testing + assertion updates (Tasks 1.11-1.12) | ✅ Complete | 2 commits ending at `b94f7ebca`. Started at 52 of 124 CMCD tests failing post-1.10; ended at 0 fail / 124 pass. Three (c)-class adapter bugs fixed in `27cd16907`; ~80 (a)/(b)-class assertion updates in `b94f7ebca`. Full `--quick` suite: 2995/2995 pass. |
-| **Phase 1F** — Demo verification (Task 1.13) | ✅ Complete | Smoke-test on `bbb-dark-truths/dash.mpd` via Claude Preview-driven `python3 -m http.server`. Query mode (15 segment requests captured): `?CMCD=…cid="smoke-test",ot=m,sf=d,sid="…",sn=N,su,v=2` — `v=2` always present, `ts` absent in request mode, `sf=d` (no `'ld'`), `ot`/`sf`/`st` as tokens. Header mode (15 requests captured via request filter; CMCD-* stripped before fetch to avoid CORS preflight): `v=2` only in `CMCD-Session` shard (not in `CMCD-Object`/`Request`/`Status`); request shard contains `sn`/`mtp`/`su` only — no `ts`. Zero JS console errors. Per-phase PR (Task 1.14) deferred to single all-phases PR per user direction. |
-| **Phase 2** — Adopt CML constants, dedupe shaka duplicates (Tasks 2.1-2.5) | ✅ Complete | 1 commit at `67443aacb`. Net −74 LoC in `lib/util/cmcd_manager.js` (+12 LoC value-identity test in `test/util/cmcd_manager_unit.js`). 7 internal shaka enums deleted; `StreamingFormat` retained as `@export`ed literal (Closure tooling rejects alias form). `build/check.py` 0; CMCD tests 125/125; `--quick` suite 2996/2996; smoke test confirmed wire format unchanged. Task 2.6 (open Phase 2 PR) dropped per single-PR strategy. |
-| **Phase 3** — Adapter rewrite (Tasks 3.1-3.15) | ✅ Complete | 2 commits ending at `43cc7f332`. Net −1445 LoC in `lib/util/cmcd_manager.js` (1580 → ~700 incl. expanded JSDoc) and ~−4317 LoC in `test/util/cmcd_manager_unit.js` (4296 → ~880). Externs renamed (`targets`→`eventTargets`; per-target `timeInterval`→`interval`); per-target typedef gained `batchSize` and per-target `version` fields. New public re-exports `EventType`, `PlayerState`. Demo gained an `Event Targets (JSON)` editor. `build/check.py` 0; CMCD tests 57/57; `--quick` suite 2927/2927; `build/all.py` 0. End-to-end smoke verified V1+query, V2+query, V2+headers (with unload→reconfigure→reload cycle); `EventType`/`PlayerState`/`StreamingFormat` all appear in `dist/shaka-player.compiled.js`. **Task 3.16 dropped** per single-PR strategy. |
-
-**Vendored port summary:** [`third_party/cml-cmcd/`](../../third_party/cml-cmcd/) holds 68 JS files (typedefs + enums + constants + encoders + helpers + shims + `CmcdReporter`) + `LICENSE` + `NOTICE` + `SUMMARY.txt`. At HEAD (`adfdfab05`), `python3 build/check.py` exits 0. `python3 build/build.py` was last clean at `d682bb1bb` and is not expected to break under sub-phase D's source-only changes; not re-run this session.
-
-### Sub-phase D landing notes (Tasks 1.10 + 1.10b)
-
-- **Encoding paths now delegate through CML.** `serialize` / `toQuery` / `toHeaders` thread an optional `cml.cmcd.CmcdEncodeOptions` and route to `cml.cmcd.encodeCmcd`. `appendQueryToUri` retained as a thin `goog.Uri`-based adapter (CML's `appendCmcdQuery` takes a data object, not a pre-encoded query string — incompatible signature; Phase 3 deletes the call sites entirely).
-- **`urlToRelativePath` deleted** from `cmcd_manager.js` (and its 9 unit tests). `data.nor` is set to the absolute next-segment URL in `getDataForSegment_`; CML's `nor` formatter (in `cmcd_formatter_map_const.js`) relativizes against `options.baseUrl`. New private helper `shaka.util.CmcdManager.getEncodeOptions_(uri)` derives `baseUrl` from `new URL(uri).origin` (with `offline:`/parse-error guards) and is invoked at all four CMCD-encoding call sites: `appendSrcData`, `appendTextTrackData`, `sendCmcdRequest_`, `applyCmcdDataToRequest_`.
-- **Two intentional wire-format changes shipped:**
-  1. `nor` URLs become root-relative instead of path-relative (matching CTA-5004-B + CML's spec-conformant output).
-  2. `'ld'` / `'lh'` `StreamingFormat` values dropped — LL DASH now emits `sf=d`, LL HLS now emits `sf=h`. `setLowLatency` no longer mutates `sf_`; `getStreamFormat_` no longer branches on `lowLatency_`.
-- **No tests asserted `sf=ld`/`sf=lh`** (verified via repo-wide grep). The `urlToRelativePath` describe-block (9 tests) was the only test deletion in sub-phase D.
-
-### Sub-phase E landing notes (Tasks 1.11 + 1.12)
-
-Sub-phase E classified the diff between pre-delegation and post-delegation wire output by running the existing test suite at HEAD-after-1.10 — failures themselves served as the diff. 52 of 124 CMCD tests failed initially; 0 fail after sub-phase E.
-
-**Three (c)-class adapter bugs fixed in `27cd16907`:**
-
-1. **C1** — Event-mode encoded output dropped event-only keys (`e`, `ts`, `cen`). `cml.cmcd.prepareCmcdData` defaults `reportingMode` to request mode when not specified, and the request-mode filter excludes event-only keys. Threaded `reportingMode` through `getEncodeOptions_`: `CMCD_EVENT_MODE` for `sendCmcdRequest_` (the out-of-band event/response-received path), `CMCD_REQUEST_MODE` for `applyCmcdDataToRequest_` / `appendSrcData` / `appendTextTrackData`. `sendCmcdRequest_` also stops passing `baseURL`: target collector URLs are typically a different origin from segment URLs, so `baseUrl`-based `nor` rewriting is meaningless there.
-2. **C2** — `toHeaders` emitted `v=2` in every shard. shaka's old serialize-per-shard pattern, once delegated, ran `prepareCmcdData` per shard and got `v=2` auto-added each time. Restructured `toHeaders` to call `prepareCmcdData` once on the full data, bucket the prepared keys into shaka's existing `headerMap`, and call `encodePreparedCmcd` per shard so re-preparation is skipped.
-3. **C3** — V1 configurations were getting V2 filter behavior because `prepareCmcdData` defaults to V2. Tests with V1-only keys (e.g. `nrr`) saw them filtered out. Threaded `this.config_.version` through `getEncodeOptions_`.
-
-**Five (a)/(b)-class wire-format alignments shipped in `b94f7ebca`** (test assertions updated; no code change):
-
-A. **`nor` URLs root-relative + V2 inner-list format.** Already shipped in sub-phase D Task 1.10. CML emits `nor=("path")` (V2 inner-list) instead of `nor="path"` (V1 string).
-B. **`v=2` auto-added in V2 output.** Per CTA-5004-B § 4.1, V2 output MUST include `v`. CML's `prepareCmcdData` enforces this even when the user filters `v` out via `includeKeys`. Old shaka emitted `v` only when explicitly present in `data`. Tests that previously asserted `not.toContain('v=2')` now assert `toContain('v=2')`; tests with no `v` in input now expect `,v=2` in output.
-C. **`ts` no longer in request-mode output.** Old shaka emitted `ts=<timestamp>` in request-mode CMCD; per CTA-5004-B `ts` is event-mode only. CML's request-mode filter correctly drops it. Inverted "includes ts for segment requests" to "does not include ts".
-D. **Token vs string formatting** for `e` and `sta` values (~73 sites). Old shaka quoted them as strings (`e="ps"`, `sta="s"`); CML emits them as RFC 8941 SFV tokens (`e=ps`, `sta=s`) per spec.
-E. **Event-mode `nor` stays absolute.** When the collector URL is at a different origin from the segment URL, CML doesn't relativize `nor` (no `baseUrl` in event mode). Tests expecting path-relative event-mode `nor` updated to expect the absolute URL.
-
-**Resolved (c)-class bug summary for the Phase 1 PR description:** the three adapter fixes (`reportingMode` threading, prepare-once header encoding, `version` threading) are the load-bearing parts of sub-phase E. The (a)/(b) test updates document the spec-conformance and SFV-encoding alignments that drove ~80 assertion changes.
-
-### Sub-phase F landing notes (Task 1.13)
-
-End-to-end smoke test on `bbb-dark-truths/dash.mpd` (DASH, multi-period, no DRM) via Claude Preview-driven `python3 -m http.server` of the demo dir.
-
-**Query mode** (`useHeaders: false`, V2): 15 segment + manifest requests captured. Decoded sample:
-```
-?CMCD=cid="smoke-test",ot=m,sf=d,sid="…",sn=1,su,v=2
-?CMCD=bl=9900,br=3082,cid="smoke-test",d=4000,dl=9900,mtp=19900,ot=v,rtp=6200,sf=d,sid="…",sn=14,st=v,tb=3082,v=2
-```
-- `v=2` present in every request ✓
-- `ts=` absent in every request ✓ (V2 request-mode filter)
-- `sf=d` for DASH ✓ (no `'ld'`)
-- `ot=m`, `ot=v`, `ot=a`, `ot=i`, `sf=d`, `st=v` all rendered as bare tokens ✓
-- `cid="smoke-test"`, `sid="…"` rendered as quoted strings ✓ (string-typed fields)
-- `su` rendered as bare token (boolean true) ✓
-
-**Header mode** (`useHeaders: true`, V2): 15 segment + manifest requests captured via `registerRequestFilter` (CMCD-* stripped before fetch to avoid CORS preflight on the cross-origin asset). Decoded sample:
-```
-CMCD-Object:  ot=m
-CMCD-Request: mtp=26100,sn=1,su
-CMCD-Session: cid="smoke-test-headers",sf=d,sid="…",v=2
-```
-- `v=2` only in `CMCD-Session` shard ✓ — never in Object / Request / Status (sub-phase E C2 fix verified end-to-end)
-- `ts=` absent from Request shard ✓
-- All four shards correctly populated when keys exist; empty shards correctly absent (e.g. `CMCD-Status` only emitted when `bs`/`bg` etc. are set)
-
-**Console**: zero errors during full demo session.
-
-**Sub-phase F caveat**: cross-origin storage.googleapis.com blocks CMCD-* request headers via CORS preflight. This is browser-spec behavior, not a shaka bug — typical CMCD deployments target the user's own CDN where preflight is configured to allow `Access-Control-Allow-Headers: CMCD-*`. The smoke test stripped CMCD-* in the request filter so the underlying segment fetch could complete; the encoder produced correct headers either way (verified at the filter checkpoint).
-
-### Phase 2 landing notes (Tasks 2.1-2.5)
-
-Pure dedupe — no behavioral change beyond what Phase 1 already shipped. Single commit at `67443aacb`. Net −74 LoC in `lib/util/cmcd_manager.js`; +12 LoC for the value-identity test. The full diff against pre-Phase-2 (`d663f6c12`) is what gets surfaced in the eventual all-phases PR description as "Phase 2".
-
-**7 internal shaka enums deleted** (none were `@export`ed, so deletion is internal-only):
-
-| Shaka (deleted) | Replacement | Notes |
-|---|---|---|
-| `ObjectType` | `cml.cmcd.CmcdObjectType` | 1:1 value match (9 entries) |
-| `Version` | `cml.cmcd.CMCD_V1` / `CMCD_V2` literals | Was a 2-entry enum wrapping `1` / `2` |
-| `StreamType` | `cml.cmcd.CmcdStreamType` | CML adds `LOW_LATENCY: 'll'`; harmless superset |
-| `CmcdMode` | `cml.cmcd.CmcdReportingMode` | Dropped unused `RESPONSE` value |
-| `CmcdKeys` | various | `V1Keys` → `CMCD_V1_KEYS`; `V2Common ∪ V2Request` → `CMCD_REQUEST_KEYS`; `V2Common ∪ V2Event` → `CMCD_REQUEST_KEYS ∪ CMCD_RESPONSE_KEYS ∪ CMCD_EVENT_KEYS`; `CmcdV2Events` → `Object.values(CmcdEventType)`; `CmcdV2PlayStates` → `Object.values(CmcdPlayerState)` |
-| `CmcdV2Constants` | inlined | `TIME_INTERVAL_DEFAULT_VALUE = 10` inlined as a magic number with a comment. CML uses `30`; Phase 3's `CmcdReporter` will adopt the CML default. |
-| `CmcdV2Keys` | inlined / aliased | `TIMESTAMP` inlined as `'ts'`; `TIME_INTERVAL_EVENT` → `cml.cmcd.CMCD_EVENT_TIME_INTERVAL` |
-
-**`StreamingFormat` retained as a literal `@enum`** (not aliased to CML). Closure's `clutz` TypeScript-defs generator and shaka's `generateExterns.js` both reject `@export`ed `@enum`s whose RHS is anything other than an inline `ObjectExpression` with literal values. Workaround patterns (alias, per-key copy with MemberExpression values, `@const` instead of `@enum`) all hit the same wall. The 4 values match `cml.cmcd.CmcdStreamingFormat` exactly; the new `StreamingFormat alias / preserves value-identity with cml.cmcd.CmcdStreamingFormat` test in `test/util/cmcd_manager_unit.js` asserts this so Phase 3 can rely on it.
-
-**Permissive behavior changes from CML key-set adoption:**
-- V2 request mode now accepts `br`, `bsa`, `bsd`, `bsda`, `cs`, `dfa`, `nr`, `pb`, `sn` in `includeKeys` (previously rejected by shaka's narrower `V2RequestModeKeys`). All are CMCD V2 spec keys; shaka's omission was non-spec.
-- V2 request mode now rejects `ts` in `includeKeys` (was accepted previously). `ts` is event-only per CTA-5004-B; the encoder filtered it out anyway since Phase 1 sub-phase E B2 — this aligns the upstream `includeKeys` validator with the encoder filter.
-- Event-mode validation accepts a strict superset of what shaka's old `V2EventModeKeys` allowed.
-- `isValidEvent_` accepts CML's 17 event types instead of shaka's 10 (adds the 7 ad / skip / custom-event types). shaka doesn't emit these, so user-facing impact is nil.
-
-### Phase 3 landing notes (Tasks 3.1-3.15)
-
-The behavioral rewrite. `lib/util/cmcd_manager.js` is now a ~700-line adapter (was 1580 LoC) around `cml.cmcd.CmcdReporter`, with the reporter owning state, encoding, key filtering, sequence numbering, and event-mode dispatch. The bulk of the LoC win is in tests: ~3500 lines of wire-format coverage (Bucket A) deleted because that responsibility now lives in CML upstream; ~600 lines of adapter-glue + smoke (Bucket B/C) added in their place.
-
-**Two commits ending at `43cc7f332`:**
-1. `965ba69f8` — `refactor(cmcd): rewrite shaka.util.CmcdManager as thin adapter around CmcdReporter`. The full behavioral rewrite + externs renames + v2 re-exports + test rewrite + demo update. Net −1445 / +5187 across 6 files.
-2. `43cc7f332` — `fix(cmcd): preserve video_ across reset() so configure() can rebuild reporter`. Smoke-surfaced bug: shaka keeps the video element attached across `unload()`/`load()` cycles, so the manager's `video_` field must NOT be cleared in `reset()` — otherwise a post-unload `configure(materialChange)` can't reconstruct the reporter. Adds a regression test for the unload→reconfigure→reload cycle.
-
-**Public-API renames** (experimental v2 surface in `shaka.extern.CmcdConfiguration`):
-- `targets` → `eventTargets` (top-level)
-- per-target `timeInterval` → `interval` (matches CML)
-- per-target `version`, `batchSize` exposed in the typedef
-
-**New public re-exports** (literal-form `@export` per Phase 2's Closure-tooling constraint; value-identity tests assert parity with the corresponding CML enums):
-- `shaka.util.CmcdManager.EventType` (17 entries — superset of shaka's old 10)
-- `shaka.util.CmcdManager.PlayerState` (10 entries — superset of shaka's old 4)
-
-**Wire-format alignments inherited from CML** (call out in the eventual all-phases PR description):
-- `sn` shifts from 1-based to 0-based.
-- Request-mode `sn` becomes a single global counter (was per-target-hash); resets on `sid` change.
-- `CMCD_DEFAULT_TIME_INTERVAL` adopts CML's `30` (was shaka's `10`) when the user does not specify a per-target `interval`.
-
-**Adapter design choices worth surfacing:**
-1. **`enabledKeys` defaults to all valid keys for the version** when the user's `includeKeys` is empty/missing. Without this expansion, CML's `createRequestReport` early-returns on an empty `enabledKeys` array — old shaka treated empty `includeKeys` as "include all", and existing user configs depend on that semantic.
-2. **`appendSrcData` / `appendTextTrackData` bypass the reporter** and call `cml.cmcd.appendCmcdQuery` directly with a synthesized CMCD object. `<video src=…>` and sidecar text-track loads can't carry custom request headers, so query-mode encoding is forced regardless of `useHeaders`. Per-request `sn` is omitted on this path (the reporter's per-target counters don't apply).
-3. **Multi-URI requests** (rare; alternate-CDN retry lists) get the same CMCD encoding applied to every URI in the list. The first URI is rewritten via `createRequestReport`; the encoded `CMCD=…` param is extracted and applied to the remaining URIs via URL parsing. All URIs share one `sn`.
-4. **`networkingEngine_` is read lazily** in `makeRequester_()` via `this.player_.getNetworkingEngine()`. No separate field — keeps the manager simple and avoids stale-reference issues if NetworkingEngine is recreated.
-5. **`m`/muted is event-only**, not persistent state. CTA-5004-B defines `m`/`um` as event types, not data keys; the adapter emits `MUTE`/`UNMUTE` events but does NOT call `update({m: …})`.
-
-**End-to-end smoke verification** (Claude Preview-driven `python3 -m http.server` on `bbb-dark-truths/dash.mpd`):
-- V1 + query: `cid="…",ot=m,sf=d,sid="…",sn=N,st=v` — no `v=` (V1 default semantic), no `ts` (request-mode filter).
-- V2 + query: `cid="…",ot=m,sf=d,sid="…",sn=0..N,st=v,v=2` — `v=2` always present, `ts` absent in request mode, `sn` 0-based.
-- V2 + headers (after `unload→configure({useHeaders: true})→load` cycle): `CMCD-Object: ot=m`, `CMCD-Request: sn=N`, `CMCD-Session: cid="…",sf=d,sid="…",st=v,v=2` — `v=2` only in Session shard, `sn` reset to 0 on session-id change.
-- Public re-exports `EventType`, `PlayerState`, `StreamingFormat` all readable at runtime from the compiled bundle, with values matching `cml.cmcd.*` exactly.
-- Zero CMCD-related console errors. (DASH manifest "Rejecting variant - not compatible with root" warnings are unrelated.)
-
-**Demo update:** added an `Event Targets (JSON)` text input that JSON-parses on change and `player.configure({cmcd: {eventTargets: [...]}})`s the result. Mirrors dash.js's `cmcd-v2.html` minimum scope. Version field converted to a numeric input. Added `'cmcd.eventTargets'` to the demo-unit `exceptions` set so the array-typed config field doesn't trip the "demo references unknown config" check.
-
-### Key architectural decisions in the port — surface in Phase 1 PR description
-
-These were judgment calls during sub-phases B+C; maintainers should weigh in before merge:
-
-1. **`setInterval` whitelisted** in `build/conformance.textproto` for `third_party/cml-cmcd/cmcd_reporter.js`. The reporter calls `setInterval` directly for periodic time-interval event reporting. Alternatives considered: (a) patching the vendored reporter to use `shaka.util.Timer` (breaks verbatim parity), (b) filing a CML upstream PR for injectable-timer support (delays Phase 1). Whitelist is pragmatic but means **Phase 3 tests cannot inject a fake timer** — will need `jasmine.clock()`-based interval testing.
-2. **`fetch` whitelisted** in `build/conformance.textproto` for `third_party/cml-cmcd/cml_utils.js`. Used by `cml.cmcd.defaultRequester` — dead code at runtime because the shaka adapter always supplies a custom `requester` via `NetworkingEngine`. Closure ADVANCED is expected to strip the dead path, but the conformance check runs first.
-3. **`defaultRequester` relocated** from `CmcdReporter.ts` module scope into `cml_utils.js` as `cml.cmcd.defaultRequester`. Done to centralize the `fetch` whitelist scope to a single file. **Per-bump CML diff workflow needs to know** `defaultRequester` lives here, not in the reporter — otherwise CML 2.4.0+ bumps will look like the function vanished.
-
-### Open hygiene items (user-owned, untouched by this session)
-
-Two git stashes exist:
-- `stash@{0}: On feat/cmcd-cml-refactor: accidental-stash-pop-recovery` — created during a sub-phase B subagent's `git stash pop` mishap. Contains contaminated working state from that incident.
-- `stash@{1}: On task/revert-cmcd-v1: CMCD STUFF` — pre-existing user stash. Preserved.
-
-### Resuming work in a new session — Phase 3 prep
-
-This subsection captures everything a fresh session needs to pick up Phase 3 cleanly. Spec.md and the per-task instructions above are still authoritative for the design — the items here are session-context that won't survive a context handoff otherwise.
-
-#### Branch + repo state at handoff (last commit `f0b99a8e0`)
-
-- 28 commits ahead of `origin/feat/cmcd-cml-refactor`, working tree clean. `.claude/` is untracked and intentional.
-- `lib/util/cmcd_manager.js` is **1580 lines**; Phase 3 target is ~250.
-- `test/util/cmcd_manager_unit.js` is **4296 lines**; Phase 3 deletes ~3500 (Bucket A wire-format tests) and adds ~600 (Bucket B/C adapter + smoke).
-- CML pin still `cmcd-v2.3.0` / `22390e35dfbbe1e53d15648d3aace99cdf71f9dd`. Clone at `/tmp/cml-pinned/`. Re-verify: `cd /tmp/cml-pinned && git rev-parse HEAD`.
-- Two git stashes (`stash@{0}` accidental-stash-pop-recovery, `stash@{1}` task/revert-cmcd-v1) are user-owned. Don't drop without asking.
-- `plans/cmcd-cml-refactor/pr-draft.md` is the cumulative all-phases PR scaffolding. Phase 1 + Phase 2 sections present; Phase 3 needs to append (Public-API renames, behavioral changes, sequence-number outcome, event-mode dispatch note, test surface delta, deferred follow-ups). Update title if needed; current title is `refactor(cmcd): vendor @svta/cml-cmcd, replace custom encoder + state machine`.
-
-#### Decisions / gotchas inherited from earlier phases — must respect in Phase 3
-
-1. **Closure tooling rejects `@export`ed enum aliases.** Phase 2 tried `shaka.util.CmcdManager.StreamingFormat = cml.cmcd.CmcdStreamingFormat;` — both `clutz` (TS-defs gen) and `generateExterns.js` rejected the `MemberExpression` RHS. Same constraint applies to **Task 3.12 v2 re-exports** — must use literal `@enum {string} @export shaka.util.CmcdManager.EventType = { PLAY_STATE: 'ps', ... };` form, NOT alias. A new value-identity unit test should assert each public re-export equals the corresponding `cml.cmcd.*` enum (parallel to the existing `StreamingFormat alias` test in `cmcd_manager_unit.js:219`).
-2. **CMCD time-interval default value.** Shaka's old default was `10` seconds; CML's `CMCD_DEFAULT_TIME_INTERVAL` is `30`. Phase 2 inlined `10` as a magic number with a comment marking the deferral. Phase 3 must pick: (a) accept CML's `30` (call out as a wire-format change in PR description) or (b) override per-target via `interval` field in `toReporterConfig_`. Spec.md recommends (a); the CmcdReporter takes `interval` from `CmcdEventReportConfig`, so per-target override is straightforward.
-3. **Internal type annotations refer to `cml.cmcd.CmcdStreamingFormat` directly** (not `shaka.util.CmcdManager.StreamingFormat`) per Phase 2 — `this.sf_` private field, `getStreamFormat_` return type. Keep this pattern. The `shaka.util.CmcdManager.StreamingFormat` literal is the public-facing form (the `@export`ed alias-equivalent).
-4. **`setLowLatency` is now a no-op shim** (Phase 1 Task 1.10b dropped `'ld'`/`'lh'`). Phase 3 keeps it as a no-op for back-compat (Player still calls `cmcdManager_.setLowLatency(...)` at `lib/player.js:3073`); does NOT mutate `streamingFormat`. Spec.md § "Streaming format and low-latency" makes this explicit.
-5. **`shaka.util.CmcdManager.getEncodeOptions_` static helper** (added in Phase 1 sub-phase E) becomes obsolete in Phase 3 — `CmcdReporter` builds its own encode options internally. Delete it as part of Task 3.10.
-6. **Phase 1's `appendQueryToUri` static (the `goog.Uri`-based adapter)** was retained because CML's `appendCmcdQuery` has an incompatible signature. Phase 3 deletes it along with the other static encoders — `appendSrcData` and `appendTextTrackData` are the only remaining call sites, and both can use `cml.cmcd.appendCmcdQuery(uri, cmcdData, options)` directly.
-
-#### Concrete file pointers
-
-**`lib/util/cmcd_manager.js`:**
-- **Public methods to KEEP** (Player calls these directly — see `lib/player.js` references in parens):
-  - `setMediaElement(mediaElement)` (line 131; Player call at `lib/player.js:1407`).
-  - `configure(config)` (line 142; Player at `:4576`).
-  - `reset()` (line 151; Player at `:1646`).
-  - `setBuffering(buffering)` (line 178; Player call exists in buffering-observer wiring).
-  - `setLowLatency(lowLatency)` (line 201; Player at `:3073` — keep as no-op shim).
-  - `setStartTimeOfLoad(startTimeOfLoad)` (line 210; Player at `:3075`).
-  - `applyRequestData(type, request, context)` (line 238; Player at `:4003`).
-  - `applyResponseData(type, response, context)` (line 282; Player at `:4028`).
-  - `appendSrcData(uri, mimeType)` (line 456; Player at `:3386`).
-  - `appendTextTrackData(uri)` (line 485; Player at `:7330`).
-- **Shaka-knowledge helpers to KEEP** (the adapter's job to translate; spec § "Request/response interception"):
-  - `removeCmcdQueryFromUri_` (line 433) — used in response flow.
-  - `getObjectType_` (line 1019).
-  - `getBufferLength_` (line 1118).
-  - `getRemainingBufferLength_` (line 1142).
-  - `calculateRtp_` (line 1183) — `bitrate × rtpSafetyFactor`.
-  - `getStreamFormat_` (line 1210).
-  - `getStreamType_` (line 1231).
-  - `requestTimestampMap_` field — TTFB/TTLB measurement.
-  - `setupEventListeners_` (line 533) — needs full rewrite, not delete (replaces the existing playback-time tracking with reporter.update / recordEvent calls per spec § "Player state ↔ reporter state mapping").
-- **Methods/fields to DELETE** (state machine; CML reporter owns this now):
-  - `applyRequest_` (line 788), `applyManifestData` (line 304), `applyRequestSegmentData` (line 382), `applyResponseSegmentData` (line 331), `applyTextData` (line 410), `applyResponse_` (line 835), `sendCmcdRequest_` (line 849), `applyCmcdDataToRequest_` (line 897).
-  - `checkValidKeys_` (line 940), `filterKeys_` (line 968), `isValidEvent_` (line 984), `getCmcdTargetHash_` (line 1098).
-  - `reportEvent_` (line 714), `setupEventModeTimeInterval_` (line 623), `stopAndClearEventTimers_` (line 654), `getEventModeEnabledTargets_` (line 667).
-  - `createData_` (line 696), `getDataForSegment_` (line 1284), `getGenericData_` (line 1379), `getObjectTypeFromMimeType_` (line 1061).
-  - `onPlaybackPlay_` (line 512), `onPlaybackPlaying_` (line 523).
-  - State fields: `cmcdSequenceNumbers_`, `eventTimers_`, `msdSent_`, `playbackPlayTime_`, `playbackPlayingTime_`, `startTimeOfLoad_`, `playbackStarted_`, `buffering_`, `starved_`.
-  - Static class methods: `serialize`, `toQuery`, `toHeaders`, `appendQueryToUri`, `getEncodeOptions_` (all become unused once `applyRequest_`/`sendCmcdRequest_` are gone).
-
-**`externs/shaka/player.js`:**
-- `shaka.extern.CmcdTarget` typedef at lines 2742-2760. Per-target rename per spec: `timeInterval` (line 2754) → `interval`. Per-target `enabledKeys` is already `includeKeys` in shaka externs (line 2744) — no rename needed at this layer (spec's `enabledKeys → includeKeys` rename refers to shaka↔CML naming inside `toReporterConfig_`).
-- `shaka.extern.CmcdConfiguration` typedef at lines 2762-2824. Top-level rename: `targets` (lines 2771, 2819) → `eventTargets`. Update both the typedef and the `@property` JSDoc.
-
-**`externs/cmcd.js`:** Public-facing `CmcdData` typedef. Keep as-is — structurally equivalent to `cml.cmcd.Cmcd`, retains the existing public API surface. No changes needed in Phase 3.
-
-**`lib/player.js`:** Player wires the manager via `this.cmcdManager_` (private field at line 828). `createCmcd_` factory at line 4336 returns `new shaka.util.CmcdManager(this, this.config_.cmcd)`. Player passes `this` as the player ref — adapter calls `this.player_.getNetworkingEngine()` (current pattern at line 885) when it needs the networking engine for the requester callback. **Don't add a separate `networkingEngine_` field** — keep using `this.player_.getNetworkingEngine()` lazily inside `makeRequester_()`.
-
-#### CmcdReporter constructor + method signatures (verified in Phase 0)
-
-From `third_party/cml-cmcd/cmcd_reporter.js` and `cml-version.md`:
-
-```
-new cml.cmcd.CmcdReporter(config: CmcdReporterConfig, requester: (CmcdRequest) => Promise<{status: number}>)
-  // requester is the SECOND positional arg, not a config field.
-
-reporter.start()       // void; sets up time-interval timers, fires initial 't' event synchronously
-reporter.stop(flush)   // void; flush=true drains queued events before stopping
-reporter.flush()       // void; manual drain
-reporter.update(partialState)             // void; merges into persistent state
-reporter.recordEvent(eventType, data?)    // void; queues a discrete event for next dispatch
-reporter.createRequestReport(request, data?)   // returns R & CmcdRequestReport — derived object, NOT in-place mutation
-reporter.recordResponseReceived(response, data?)  // void; data is Partial<Cmcd>, not the flat {ttfb,ttlb,rc,url} shape
-```
-
-For `recordResponseReceived` (Task 3.5), spec § "Request/response interception" describes two valid call patterns: (a) supply `response.resourceTiming = {startTime, responseStart, duration}` to let CML auto-derive `ts/ttfb/ttlb`, or (b) pass `{ttfb, ttlb, rc, url}` as the `data` arg (overrides win). Adapter can mix — typical flow: pass `ttfb`/`ttlb` from `requestTimestampMap_` as `data`, let CML derive `ts` from `Date.now()` internally.
-
-#### Task 3.13 test rewrite — concrete starting points
-
-The current `test/util/cmcd_manager_unit.js` (4296 lines) structure:
-- Top-level `describe('CmcdManager Setup', ...)` wraps everything (lines 8-end).
-- Inside, `describe('CmcdManager CMCD V1', ...)` and `describe('CmcdManager CMCD V2', ...)` are the two big buckets — most of the wire-format coverage is here.
-- The `StreamingFormat alias` test at line 219 is the Phase 2 value-identity test — keep this; add parallel ones for `EventType` and `PlayerState` (Task 3.12).
-
-Bucket B / C tests should use a stubbed `CmcdReporter` (record calls) for unit coverage and a real one (drive end-to-end) for smoke. Look at how `cml.cmcd.CmcdReporter` is constructed in `cmcd_reporter.js:139` for the constructor signature.
-
-#### Task 3.14 demo update — minimum scope (per spec gap #8)
-
-Mirror dash.js's `cmcd-v2.html` precedent. Current demo CMCD UI lives in `demo/config.js` (grep `cmcd` for the existing controls). Add: transmission-mode toggle (query/headers — already exists as `useHeaders` checkbox), version selector (1/2 — `version` numeric input), single eventTarget editor (URL + events checklist + `interval` numeric input + `batchSize` numeric input + `includeKeys` checklist). Wire to `player.configure({cmcd: {...}})`.
-
-#### Smoke test pattern that worked in Phase 1 sub-phase F + Phase 2
-
-For driving the demo locally via Claude Preview MCP:
-
-1. Create `.claude/launch.json`:
-   ```json
-   {
-     "version": "0.0.1",
-     "configurations": [
-       {
-         "name": "shaka-demo",
-         "runtimeExecutable": "python3",
-         "runtimeArgs": ["-m", "http.server", "17765"],
-         "port": 17765
-       }
-     ]
-   }
-   ```
-2. Call `mcp__Claude_Preview__preview_start({name: "shaka-demo"})`.
-3. `preview_eval`: `window.location.href = 'http://localhost:17765/demo/'`.
-4. Configure CMCD via `player.configure({cmcd: {...}})` and `await player.load(...)`.
-5. Test asset: `https://storage.googleapis.com/shaka-demo-assets/bbb-dark-truths/dash.mpd`.
-6. **Header mode CORS workaround**: storage.googleapis.com blocks CMCD-* via CORS preflight. Use `player.getNetworkingEngine().registerRequestFilter((type, request) => {...})` to capture `request.headers` THEN strip CMCD-* before fetch. This is a smoke-test-only workaround — real deployments configure CDN CORS to accept `Access-Control-Allow-Headers: CMCD-*`.
-7. Cleanup: `mcp__Claude_Preview__preview_stop({serverId})`; `rm /Users/cocch1216/dev/shaka-player/.claude/launch.json`.
-
-#### Test invocation patterns
-
-```bash
-# CMCD-only filter (fast, ~5 sec):
-python3 build/test.py --browsers ChromeHeadless --quick --filter Cmcd \
-    --no-babel --reporters spec --spec-hide-passed
-
-# Full --quick suite (~65 sec, regression check):
-python3 build/test.py --browsers ChromeHeadless --quick \
-    --no-babel --reporters spec --spec-hide-passed
-
-# Build verification:
-python3 build/check.py --force                  # lint + spell + types (45 sec)
-python3 build/all.py --force                    # full bundle build (~4 min)
-```
-
-`text_displayer_layout_unit.js` failures (24 tests) appear flakily in full-suite runs but pass in isolation; they are environmental and unrelated to CMCD work. Confirmed across Phase 1 / Phase 2 sessions.
-
-#### PR strategy reminder
-
-**Do NOT push or open a PR after Phase 3.** User direction (revised 2026-04-28): single all-phases PR off `feat/cmcd-cml-refactor` once everything is done. Phase 3 ends with: (a) plan + memory + `pr-draft.md` updates committed, (b) branch sitting locally, (c) explicit user prompt to push when ready. The plan's Task 3.16 is dropped in this strategy (kept as scaffolding for the eventual single PR's description).
-
----
-
-## Plan structure
-
-- **Phase 0** — CML-side verification & upstream precursor PRs (no shaka commits).
-- **Phase 1** — Vendor `third_party/cml-cmcd/`, delegate encoding through it. Behavior preserved except documented `nor` change.
-- **Phase 2** — Replace shaka's duplicate constants/enums with CML's; pure dedupe.
-- **Phase 3** — Rewrite `cmcd_manager.js` as adapter around `CmcdReporter`; delete state machine; rewrite tests; update demo and externs.
-
-**PR strategy (revised 2026-04-28):** all three phases ship together as a single PR off `feat/cmcd-cml-refactor` once the whole refactor is complete. The original plan called for one PR per phase; the user revised this to reduce review-cycle overhead. Phase 1 / 2 / 3 sub-phase boundaries still gate work internally (build/check.py + test.py must pass at each sub-phase end), but `git push` + PR creation only happens after Phase 3 lands. Per-phase Task X.14 "open PR" steps below are no longer applicable — treat them as scaffolding for the eventual single PR's description (already drafted at `plans/cmcd-cml-refactor/phase-1-pr-draft.md`; Phase 2 / 3 draft sections will accrete to the same file or be merged into one).
-
-## Spec gaps surfaced during planning
-
-The spec is mature, but these items need explicit attention during execution rather than being deferred to "we'll figure it out":
-
-1. **`setMediaElement` not in the lifecycle map.** Spec § "Lifecycle and player wiring" lists `configure`/`reset` flows but omits `setMediaElement`, which `Player` calls after constructing the manager. The adapter must subscribe to `<video>` events here, not at construction (the video element doesn't exist yet at construction time). Captured as Task 3.3.
-2. **`bl` (buffer length) appears in both persistent state and per-request data.** Spec § "State fields the adapter feeds via update()" lists `bl` and notes "per-request, may live on `createRequestReport` data". The adapter should treat `bl` as per-request only — persistent state would emit stale buffer values to event-mode targets. Captured as Task 3.4.
-3. **Per-target `version` override field.** Spec § "Per-target eventTargets[] field shape" lists a `version` per-target field. Whether CML's `CmcdEventReportConfig` exposes this needs verification (Task 0.5).
-4. **`sessionId` auto-generation path.** The existing shaka API auto-generates `sessionId` on each `load()` if the user doesn't set one. Spec says the adapter "always sets `sid` explicitly", but doesn't say where the value comes from when the user didn't supply one. Adapter must fall through to shaka's existing UUID path (`shaka.util.Functional` / `lib/polyfill/random_uuid.js`), not CML's `cml.cmcd.uuid`. Captured as Task 3.8.
-5. **`applyResponseData` mutation contract.** Spec defines the call as `reporter.recordResponseReceived(response, {ttfb, ttlb, rc, url})` but shaka's existing `applyResponseData(type, response, context)` is expected to mutate `response` in place (matching `applyRequestData`'s contract). CML's signature for `recordResponseReceived` needs verification — if it returns data, adapter must copy back like Phase 3's request flow (Task 0.4 + Task 3.5).
-6. **Always-on reporter vs. hls.js [#7725](https://github.com/video-dev/hls.js/pull/7725).** hls.js uses CML's encoders for request mode and reporter for event mode only. Our spec chose always-on reporter for a single integration boundary. **Risk**: in v1-only request-mode-only configurations, we instantiate timers and event infrastructure that the user doesn't need. Captured as Task 3.3.
-7. **`enabled: false` early-out.** Spec says "adapter no-ops when `false`", but the CmcdReporter shouldn't be constructed at all when disabled to avoid timer creation. The lifecycle code must check `enabled` before construction, not just before each `apply*` call. Captured as Task 3.3.
-8. **Demo scope for Phase 3.** Spec § Phase 3 says "Update demo/ to add a CMCD v2 configuration UI" but doesn't enumerate which controls. Pinning a minimum scope: transmission mode toggle, version selector, single eventTarget editor with URL + events checklist. More expansive UI deferred. Captured as Task 3.13.
-9. **`StreamingFormat` value parity.** Phase 0 verified: shaka emits 6 values but CTA-5004 / CTA-5004-B / CML define only 4 (`'d'`/`'h'`/`'s'`/`'o'`). shaka's `'ld'` and `'lh'` come from an old unreleased CMCD draft and are non-spec. Captured as Phase 1 Task 1.10b (drop `'ld'`/`'lh'`); Phase 2 alias re-export then becomes a straightforward identity map (Task 2.3).
-10. **CML `CmcdEventType` enum membership.** Phase 0 verified: CML cmcd-v2.3.0 includes all 10 event types shaka needs (`ps`/`e`/`t`/`c`/`b`/`m`/`um`/`pe`/`pc`/`rr`) plus 7 more (`bc` bitrate change, ad events, skip, custom). Correct CML constant names listed at `plan.md:86`. No upstream PR needed.
-
----
-
-## Phase 0: CML-side verification & upstream precursor PRs
-
-**Goal:** Lock the CML version we'll port from, and confirm/fill any gaps in `CmcdReporter`'s public surface so Phase 3 doesn't get stuck on missing CML capabilities mid-rewrite.
-
-**No shaka-player commits in this phase.** Output is (a) a pinned CML commit/tag, (b) a one-page verification report that maps spec assertions to CML source, and (c) any merged CML PRs that close gaps.
-
-### Task 0.1: Pin the CML version
-
-**Files:**
-- Note in: `plans/cmcd-cml-refactor/cml-version.md` (new — short doc, not a code file)
-
-- [ ] **Step 1: Inspect current `@svta/cml-cmcd` releases.**
-
-```bash
-npm view @svta/cml-cmcd versions --json | tail -20
-```
-
-Pick the latest stable release (spec assumes v2.3.0 as of 2026-04-27; confirm or update). Capture: tag name, commit SHA, npm version, release date.
-
-- [ ] **Step 2: Clone CML at the pinned commit into a sibling directory for reference.**
-
-```bash
-cd /tmp && git clone https://github.com/streaming-video-technology-alliance/common-media-library.git cml-pinned
-cd cml-pinned && git checkout <pinned-sha>
-```
-
-- [ ] **Step 3: Write `plans/cmcd-cml-refactor/cml-version.md`** with: pinned version, SHA, date, source path (`libs/cmcd/src/`), and one-line "what changed since v2.3.0" if applicable.
-
-**Acceptance:** Pinned version selected; reproducible checkout in a known location for the rest of Phase 0.
-
-### Task 0.2: Verify `CmcdReporter` lifecycle methods
-
-The spec's "CML-side requirements" table marks these as "confirmed":
-`reporter.start()`, `reporter.stop(flush)`, `reporter.flush()`, `reporter.update(partialState)`, `reporter.recordEvent(eventType, data)`.
-
-- [ ] **Step 1: Open `libs/cmcd/src/CmcdReporter.ts` in the pinned checkout.** Search for each method by name; confirm signatures.
-
-- [ ] **Step 2: For each method, record:** name, parameter types, return type, and any thrown-error contract. Save as a checklist in `plans/cmcd-cml-refactor/cml-version.md` (append).
-
-**Acceptance:** All five lifecycle methods exist with signatures compatible with the spec's call sites.
-
-### Task 0.3: Verify `CmcdEventType` enum membership
-
-- [ ] **Step 1: Open `libs/cmcd/src/CmcdEventType.ts` in the pinned checkout.**
-
-- [ ] **Step 2: Verify members and their CML constant names:** `ps → PLAY_STATE`, `e → ERROR`, `t → TIME_INTERVAL`, `c → CONTENT_ID`, `b → BACKGROUNDED_MODE`, `m → MUTE`, `um → UNMUTE`, `pe → PLAYER_EXPAND`, `pc → PLAYER_COLLAPSE`, `rr → RESPONSE_RECEIVED`. (Names verified against CML cmcd-v2.3.0 in `cml-version.md` Task 0.3.)
-
-- [ ] **Step 3: For any missing member, file a CML PR adding it.** Example: if `pc` is absent, file `feat(cmcd): add CmcdEventType.PLAYBACK_CHANGE` upstream.
-
-**Acceptance:** Every event type the shaka adapter intends to emit has a CML enum value, either in the pinned version or in a merged-and-released CML PR.
-
-### Task 0.4: Verify request/response report methods
-
-Spec calls these out: `createRequestReport(request, data)` and `recordResponseReceived(response, data)`.
-
-- [ ] **Step 1: Open `CmcdReporter.ts` and inspect both methods.**
-
-- [ ] **Step 2: For `createRequestReport`:** confirm the return type is `R & CmcdRequestReport<R['customData']>` (a derived object, not in-place mutation) — this drives the adapter's "copy fields back" pattern.
-
-- [ ] **Step 3: For `recordResponseReceived`:** confirm whether the method returns anything (data the adapter must copy back to the response object) or is purely a state-recording call. Document the answer.
-
-- [ ] **Step 4: Verify the data parameter shape for `recordResponseReceived` matches the spec's `{ttfb, ttlb, rc, url}`.** Note any field name mismatches (e.g., CML may use `responseCode` instead of `rc`).
-
-**Acceptance:** Adapter's response-flow contract is unambiguous — we know whether to copy data back or not.
-
-### Task 0.5: Verify `CmcdEventReportConfig` per-target shape
-
-Spec's per-target field table includes `url`, `events`, `timeInterval`, `batchSize`, `enabledKeys`, `version`.
-
-- [ ] **Step 1: Open `libs/cmcd/src/CmcdEventReportConfig.ts` (or wherever the type lives in the pinned tree).**
-
-- [ ] **Step 2: Diff field-by-field against the spec's table.** Note any missing fields, extra fields, or type mismatches.
-
-- [ ] **Step 3: Specifically confirm:** does `CmcdEventReportConfig` expose a `version` override field per target? If not, decide whether to (a) drop the per-target `version` from shaka's externs (simpler, defer to top-level only), or (b) file a CML PR to add it. Default to (a) unless there's a known shaka user need.
-
-**Acceptance:** Spec's `CmcdTarget` typedef post-rename matches a real CML type, with any field-level differences explicitly resolved.
-
-### Task 0.6: Verify `CmcdStreamingFormat` value parity
-
-- [ ] **Step 1: Open `libs/cmcd/src/CmcdStreamingFormat.ts`.**
-
-- [ ] **Step 2: Confirm string values:** `'d'` (DASH), `'ld'` (LL-DASH), `'h'` (HLS), `'lh'` (LL-HLS), `'s'` (Smooth), `'o'` (Other). These must match shaka's existing `shaka.util.CmcdManager.StreamingFormat` values exactly — Phase 2's alias re-export depends on this.
-
-- [ ] **Step 3: If any value differs**, file CML upstream to align (CML is the spec source of truth, so shaka adapts; but check spec compliance first).
-
-**Acceptance:** `cml.cmcd.CmcdStreamingFormat` and `shaka.util.CmcdManager.StreamingFormat` have identical string values.
-
-### Task 0.7: Verify sequence-number behavior
-
-Spec marks this "likely present; verify per v2 spec".
-
-- [ ] **Step 1: Search `CmcdReporter.ts` and the encoders for `sn` handling.** Determine: does the reporter own per-target sequence counters? Does it reset on `sid` change?
-
-- [ ] **Step 2: Compare to shaka's current behavior** in [`cmcd_manager.js`](../../lib/util/cmcd_manager.js) (search for `cmcdSequenceNumbers_`). If CML's behavior differs from shaka's existing behavior (e.g., per-target vs. per-mode), document the difference. This is a Phase 3 wire-format change to call out.
-
-**Acceptance:** Sequence-number behavior is documented; if it diverges from shaka's existing behavior, the divergence is in the Phase 3 PR description.
-
-### Task 0.8: Verify `requester` callback contract
-
-- [ ] **Step 1: Open `CmcdReporter.ts`; find where `config.requester` is invoked.**
-
-- [ ] **Step 2: Confirm:** the request object passed in has `{url, method, headers, body}` shape; the response promise must resolve to `{status: number}`; rejection vs. resolution-with-non-200 semantics.
-
-- [ ] **Step 3: Confirm body type.** Spec says CML emits string (structured-fields) or Blob (JSON). Verify both code paths exist; this informs the adapter's body-conversion logic in Task 3.9.
-
-**Acceptance:** Adapter's `requester` shim (Task 3.9) has a complete contract to match.
-
-### Task 0.9: Resolve any CML gaps via upstream PRs
-
-- [ ] **Step 1: Aggregate any gaps found in Tasks 0.2–0.8.**
-
-- [ ] **Step 2: For each gap, decide:** (a) work around in adapter (acceptable for small things), (b) file CML PR (preferred — single source of truth principle from spec § Motivation), or (c) drop the dependent feature from this refactor (defer to follow-up).
-
-- [ ] **Step 3: File and merge CML PRs as needed.** Pin the new CML version after release and update `cml-version.md`.
-
-- [ ] **Step 4: Re-run Tasks 0.2–0.8 against the new pinned version** if changes shipped.
-
-**Acceptance:** Every spec assertion about CML's API is either confirmed against the pinned CML version or has an actionable plan (work around / drop / wait for upstream).
-
-### Phase 0 verification gate
-
-- [ ] `plans/cmcd-cml-refactor/cml-version.md` lists the pinned CML version and a complete CML-API verification checklist.
-- [ ] All "confirmed" items in spec's CML-side requirements table are re-confirmed in writing.
-- [ ] All "verify" items are resolved.
-- [ ] No new shaka-player commits.
-
----
-
-## Phase 1: Vendor `third_party/cml-cmcd/` and route encoding through it
-
-**Goal:** Add the vendored Closure port of `@svta/cml-cmcd`. Refactor shaka's static encoding helpers (`serialize`, `toQuery`, `appendQueryToUri`, `urlToRelativePath`) to delegate to CML's encoders. State machine, sequence numbers, event timing, and public API stay unchanged.
-
-**Behavior:** Preserved, with **two documented intentional wire-format changes** for spec conformance:
-
-1. `nor` URLs become root-relative (CML's spec-conformant output) rather than path-relative.
-2. `sf` (streaming format) drops the non-spec values `'ld'` (LL-DASH) and `'lh'` (LL-HLS); LL DASH emits `sf=d`, LL HLS emits `sf=h`. Per Phase 0 verification (`cml-version.md` finding #1): `'ld'`/`'lh'` come from an old unreleased CMCD draft and are not in CTA-5004 or CTA-5004-B; CML correctly omits them.
-
-Phase 1 PR description must call out both. Diff testing during this phase surfaces any other unintentional divergences for case-by-case decisions.
-
-**Reference PRs to consult for patterns:**
-- [hls.js #7725](https://github.com/video-dev/hls.js/pull/7725) — note: their request-mode encoding uses CML encoders directly without going through `CmcdReporter`. Our Phase 3 changes that to always-on reporter; Phase 1 is closer to their request-mode pattern (encoders only).
-- [`third_party/closure-uri/`](../../third_party/closure-uri/) — vendoring layout precedent.
-
-### Task 1.1: Skeleton
-
-**Files:**
-- Create: `third_party/cml-cmcd/SUMMARY.txt`
-- Create: `third_party/cml-cmcd/LICENSE`
-- Create: `third_party/cml-cmcd/NOTICE`
-- Modify: `third_party/SUMMARY.txt` — append `cml-cmcd` entry per spec § "SUMMARY.txt format"
-
-- [ ] **Step 1: Copy CML's `LICENSE` and `NOTICE` files** from the pinned checkout into `third_party/cml-cmcd/`.
-
-- [ ] **Step 2: Write `third_party/cml-cmcd/SUMMARY.txt`** using the format from spec § "SUMMARY.txt format". Include the pinned version + SHA from `cml-version.md`.
-
-- [ ] **Step 3: Append the `cml-cmcd` block to `third_party/SUMMARY.txt`** following the existing entry style for `closure-uri` and `language-mapping-list`.
-
-- [ ] **Step 4: Commit:**
-
-```
-chore(third_party): add cml-cmcd vendoring skeleton (LICENSE, NOTICE, SUMMARY.txt)
-```
-
-**Acceptance:** `third_party/cml-cmcd/` directory exists with license metadata; `third_party/SUMMARY.txt` references it.
-
-### Task 1.2: Port type definitions (typedefs)
-
-The spec § "Subset to port" enumerates ~25 typedef files. These translate to closure `@typedef` declarations under `cml.cmcd.*`.
-
-**Files:** Create files per spec's "Type definitions" row (e.g., `third_party/cml-cmcd/cmcd.js`, `cmcd_data.js`, `cmcd_request.js`, etc.) — file names follow the snake_case convention from spec § "File naming and namespace conventions".
-
-- [ ] **Step 1: For each TS type-only file in the spec's list, port to a `.js` file** with a single `goog.provide('cml.cmcd.X')` and a JSDoc `@typedef`.
-
-  Mapping pattern for an interface like `CmcdReporterConfig`:
-  ```typescript
-  // CmcdReporterConfig.ts
-  export interface CmcdReporterConfig {
-    sid?: string;
-    cid?: string;
-    transmissionMode?: CmcdTransmissionMode;
-    // ...
-  }
-  ```
-  becomes:
-  ```javascript
-  // third_party/cml-cmcd/cmcd_reporter_config.js
-  goog.provide('cml.cmcd.CmcdReporterConfig');
-
-  /**
-   * @typedef {{
-   *   sid: (string|undefined),
-   *   cid: (string|undefined),
-   *   transmissionMode: (cml.cmcd.CmcdTransmissionMode|undefined),
-   *   ...
-   * }}
-   */
-  cml.cmcd.CmcdReporterConfig;
-  ```
-  No runtime code — just the typedef.
-
-- [ ] **Step 2: For union types (`CmcdValue`, `CmcdKey`, etc.) and `ValueOf<>` generics**, expand to closure-friendly union typedefs. `ValueOf<CmcdObjectType>` becomes the literal string union (e.g., `('m'|'a'|'v'|'av'|'i'|'c'|'tt'|'k'|'o')`).
-
-- [ ] **Step 3: Skip Phase 1 for any typedef that's only consumed by `CmcdReporter`** (which we port in Task 1.8). They're easier to add when the consumer exists.
-
-- [ ] **Step 4: Run Closure type-check via `python3 build/check.py`.** Fix any unresolved-type errors. Files don't need to be in `build/types/core` yet — that happens in Task 1.9.
-
-- [ ] **Step 5: Commit:**
-
-```
-chore(cmcd): port cml-cmcd type definitions as closure typedefs
-```
-
-**Acceptance:** All type-definition files compile; no runtime behavior change.
-
-### Task 1.3: Port enums
-
-**Files:** Create per spec's "Enums" row (e.g., `cmcd_object_type.js`, `cmcd_streaming_format.js`, `cmcd_player_state.js`, `cmcd_event_type.js`, `cmcd_reporting_mode.js`, `cmcd_transmission_mode.js`, `cmcd_header_field.js`, `cmcd_stream_type.js`).
-
-- [ ] **Step 1: For each TS string-enum file, port to a closure `@enum {string}`.**
-
-  Example pattern for CML's `as const` enum:
-  ```typescript
-  // CmcdStreamingFormat.ts (CML cmcd-v2.3.0)
-  export const CmcdStreamingFormat = {
-    DASH: 'd',
-    HLS: 'h',
-    SMOOTH: 's',
-    OTHER: 'o',
-  } as const;
-  export type CmcdStreamingFormat = ValueOf<typeof CmcdStreamingFormat>;
-  ```
-  becomes:
-  ```javascript
-  // third_party/cml-cmcd/cmcd_streaming_format.js
-  goog.provide('cml.cmcd.CmcdStreamingFormat');
-
-  /** @enum {string} */
-  cml.cmcd.CmcdStreamingFormat = {
-    DASH: 'd',
-    HLS: 'h',
-    SMOOTH: 's',
-    OTHER: 'o',
-  };
-  ```
-
-- [ ] **Step 2: Verify enum string values** against the pinned CML source one last time before committing — typos here are silent until runtime.
-
-- [ ] **Step 3: Run `python3 build/check.py`.**
-
-- [ ] **Step 4: Commit:**
-
-```
-chore(cmcd): port cml-cmcd enums to closure @enum
-```
-
-**Acceptance:** All enum files compile; values match Task 0.6's verification.
-
-### Task 1.4: Port constants
-
-**Files:** Create per spec's "Constants" row (~16 files: `cmcd_default_time_interval.js`, `cmcd_event_keys.js`, `cmcd_formatter_map.js`, etc.).
-
-- [ ] **Step 1: For each TS constant module, port to a closure module with `goog.provide('cml.cmcd.X')` and a `const` export.**
-
-  TS pattern:
-  ```typescript
-  // CMCD_KEYS.ts
-  export const CMCD_KEYS = ['br', 'd', 'ot', /* ... */] as const;
-  ```
-  Closure pattern:
-  ```javascript
-  // third_party/cml-cmcd/cmcd_keys.js
-  goog.provide('cml.cmcd.CMCD_KEYS');
-
-  /** @const {!Array<cml.cmcd.CmcdKey>} */
-  cml.cmcd.CMCD_KEYS = ['br', 'd', 'ot', /* ... */];
-  ```
-
-- [ ] **Step 2: For `CMCD_FORMATTER_MAP` (the most complex constant — function map):** preserve function references; declare types as `!Object<string, function(...)>`. Verify Closure ADVANCED can rename the keys safely (it can, since they're string literals).
-
-- [ ] **Step 3: Run `python3 build/check.py`.** Iterate on type annotations until clean.
-
-- [ ] **Step 4: Commit:**
-
-```
-chore(cmcd): port cml-cmcd constants to closure modules
-```
-
-**Acceptance:** All constant files compile; values match upstream.
-
-### Task 1.5: Port `cml_utils.js` (uuid shim)
-
-Per spec § "@svta/cml-utils dependency handling".
-
-**Files:**
-- Create: `third_party/cml-cmcd/cml_utils.js`
-
-- [ ] **Step 1: Write the shim:**
-
-```javascript
-// third_party/cml-cmcd/cml_utils.js
-goog.provide('cml.cmcd.uuid');
-
-/**
- * UUID shim for the vendored @svta/cml-cmcd port. The shaka adapter always
- * sets `sid` explicitly, so this codepath should be dead at runtime — the
- * Closure compiler will strip it. Kept for verbatim parity with upstream
- * CmcdReporter source so per-bump diffs stay trivial.
- *
- * @return {string}
- */
-cml.cmcd.uuid = function() {
-  return crypto.randomUUID();
-};
-```
-
-- [ ] **Step 2: Confirm `crypto.randomUUID()` is polyfilled** by [`lib/polyfill/random_uuid.js`](../../lib/polyfill/random_uuid.js). It is — but verify the polyfill loads before any path that calls `cml.cmcd.uuid` (it shouldn't be called at runtime per Task 3.8, but defense in depth).
-
-- [ ] **Step 3: Commit:**
-
-```
-chore(cmcd): add cml-cmcd uuid shim wrapping crypto.randomUUID
-```
-
-**Acceptance:** `cml.cmcd.uuid` exists; runs in browsers (verified post-polyfill).
-
-### Task 1.6: Port encoders
-
-**Files:** Create per spec's "Encoders" row (~12 files: `encode_cmcd.js`, `encode_prepared_cmcd.js`, `prepare_cmcd_data.js`, `to_cmcd_headers.js`, `to_cmcd_query.js`, `to_cmcd_url.js`, `to_cmcd_value.js`, `append_cmcd_headers.js`, `append_cmcd_query.js`, `to_prepared_cmcd_headers.js`, `ensure_headers.js`).
-
-- [ ] **Step 1: Port each encoder file as a closure module** with `goog.provide('cml.cmcd.encodeCmcd')` (or the appropriate name) and the function as the provided symbol.
-
-  TS pattern (top-level functional export):
-  ```typescript
-  export function encodeCmcd(data: CmcdData, options?: CmcdEncodeOptions): string { /* ... */ }
-  ```
-  Closure pattern:
-  ```javascript
-  goog.provide('cml.cmcd.encodeCmcd');
-  goog.require('cml.cmcd.CmcdData');
-  goog.require('cml.cmcd.CmcdEncodeOptions');
-  // ... other requires
-
-  /**
-   * @param {cml.cmcd.CmcdData} data
-   * @param {cml.cmcd.CmcdEncodeOptions=} options
-   * @return {string}
-   */
-  cml.cmcd.encodeCmcd = function(data, options) { /* port body */ };
-  ```
-
-- [ ] **Step 2: Translate TS-only constructs as you encounter them:**
-  - Type-only imports → drop (already declared as typedefs in Task 1.2).
-  - `as const` → not needed; const literals are inferred narrowly enough.
-  - Optional-chaining (`a?.b`) → fine in modern JS; targets are evergreen browsers.
-  - Nullish coalescing (`??`) → fine.
-  - Type guards / narrowing → expand to explicit `if (typeof x === 'string')` etc.
-  - Generic functions → drop type params; rely on JSDoc unions.
-
-- [ ] **Step 3: Preserve algorithm logic verbatim.** The whole point of the port is wire-format compliance via shared logic. Don't "improve" or rearrange — keeping a small diff to upstream means future bumps are mechanical.
-
-- [ ] **Step 4: Run `python3 build/check.py` after each batch of 3-4 files** to keep type-check feedback loops short.
-
-- [ ] **Step 5: Commit:**
-
-```
-chore(cmcd): port cml-cmcd encoders to closure
-```
-
-**Acceptance:** Every encoder file from spec's list exists, type-checks, and is structurally identical to the upstream TS modulo erased types.
-
-### Task 1.7: Port helpers (`upConvertToV2`, `resolveVersion`)
-
-**Files:**
-- Create: `third_party/cml-cmcd/up_convert_to_v2.js`
-- Create: `third_party/cml-cmcd/resolve_version.js`
-
-- [ ] **Step 1: Port both helpers** following the same pattern as encoders (Task 1.6).
-
-- [ ] **Step 2: Run `python3 build/check.py`.**
-
-- [ ] **Step 3: Commit:**
-
-```
-chore(cmcd): port cml-cmcd version-resolution helpers
-```
-
-**Acceptance:** Both helpers compile.
-
-### Task 1.8: Port `CmcdReporter`
-
-**Files:**
-- Create: `third_party/cml-cmcd/cmcd_reporter.js`
-
-This is the largest single file (the reporter class itself). Even though Phase 1 doesn't *use* `CmcdReporter` (Phase 3 does), porting it now means Phase 3 only has to write the adapter.
-
-- [ ] **Step 1: Port the class verbatim** from `libs/cmcd/src/CmcdReporter.ts`.
-  - `goog.provide('cml.cmcd.CmcdReporter')`.
-  - `goog.require` all needed encoders, helpers, and typedefs.
-  - Class methods preserve TS signatures translated to JSDoc.
-
-- [ ] **Step 2: Cml-utils dependency erasure.** TS source imports `uuid()` from `@svta/cml-utils`. Replace with `goog.require('cml.cmcd.uuid')` and `cml.cmcd.uuid()` calls. (Per spec, the adapter always supplies `sid`, so this codepath is dead — but keep it for upstream-diff parity.)
-
-- [ ] **Step 3: Type-only `HttpRequest`/`HttpResponse` imports erase.** Replace with local typedefs declared in Task 1.2 if needed, or with the `cml.cmcd.CmcdRequest`/`CmcdResponse` typedefs.
-
-- [ ] **Step 4: Run `python3 build/check.py`.** Expect to iterate on Closure-strict type errors here; the reporter is the most complex single file.
-
-- [ ] **Step 5: Commit:**
-
-```
-chore(cmcd): port cml-cmcd CmcdReporter to closure
-```
-
-**Acceptance:** `cml.cmcd.CmcdReporter` compiles. Not yet wired to anything.
-
-### Task 1.9: Build integration
-
-**Files:**
-- Modify: `build/types/core` — add `+../../third_party/cml-cmcd/*.js` entries (one per ported file)
-- Modify: `shaka-player.uncompiled.js` — only if any vendored file is self-registering; almost certainly none are, since the port is pure library code.
-- Modify: `project-words.txt` — add CMCD vocabulary that fails the spell-checker
-
-- [ ] **Step 1: Append vendored file paths to `build/types/core`** alphabetically among the existing `third_party/` entries (currently `closure-uri/uri.js`, `closure-uri/utils.js`, `language-mapping-list/language-mapping-list.js`). Insert the `cml-cmcd/*.js` entries in order.
-
-- [ ] **Step 2: Run `python3 build/check.py`.** This is the first check that builds with the vendored port included in the bundle. Closure may flag unused symbols, missing requires, or type drift.
-
-- [ ] **Step 3: Run `python3 build/build.py`.** Confirm the bundle compiles with the vendored port inside.
-
-- [ ] **Step 4: Append spell-checker vocab to `project-words.txt`.** New CMCD-only words: `Cmcd` (likely already present), `cml`, `svta`, `mtp`, `nrr`, `cmsd`, `cmsds`, `cmsdd`, `ttfb`, `ttlb`, `ps`, `bg`, `pe`, `pc`, `rr`, `um`, `sta`, ... Run `python3 build/check.py` to see which are missing; add only those. (Note: `ld` and `lh` are dropped in Task 1.10b as non-spec values; if they were previously in `project-words.txt`, remove them.)
-
-- [ ] **Step 5: Commit:**
-
-```
-build(cmcd): wire third_party/cml-cmcd into the core build variant
-```
-
-**Acceptance:** `build/all.py` succeeds with the vendored port included; spell-checker passes.
-
-### Task 1.10: Refactor shaka encoders to delegate
-
-**Files:**
-- Modify: `lib/util/cmcd_manager.js` — replace static methods `serialize`, `toQuery`, `appendQueryToUri`, `urlToRelativePath` with delegations to CML
-
-Per spec § Phase 1.
-
-- [ ] **Step 1: Identify the static methods.** Grep:
-  ```bash
-  grep -n "static serialize\|static toQuery\|static appendQueryToUri\|static urlToRelativePath" lib/util/cmcd_manager.js
-  ```
-
-- [ ] **Step 2: Replace each method body with a call to the CML equivalent.**
-  - `serialize(data)` → `cml.cmcd.encodeCmcd(data)` (or whichever encoder produces the same shape).
-  - `toQuery(data)` → `cml.cmcd.toCmcdQuery(data)`.
-  - `appendQueryToUri(uri, query)` → `cml.cmcd.appendCmcdQuery(uri, query)` (verify signature; may need an adapter function).
-  - `urlToRelativePath(url, base)` → drop entirely; CML's `appendCmcdQuery` and `prepareCmcdData` handle `nor` URL relativization internally using `url.origin` as `baseUrl`. **Wire-format change**: produces root-relative URLs instead of path-relative.
-
-- [ ] **Step 3: Add `goog.require('cml.cmcd.encodeCmcd')` etc.** to the file's `goog.require` block.
-
-- [ ] **Step 4: Run `python3 build/check.py`.** Fix any type or import errors.
-
-**Acceptance:** All four static methods now delegate. Manager file is shorter by the deleted method bodies.
-
-### Task 1.10b: Drop non-spec `'ld'`/`'lh'` from `StreamingFormat`
-
-**Files:**
-- Modify: `lib/util/cmcd_manager.js`
-
-Per Phase 0 finding #1 (`cml-version.md` Task 0.6): shaka's `'ld'` (LOW_LATENCY_DASH) and `'lh'` (LOW_LATENCY_HLS) values are not in CTA-5004 or CTA-5004-B. CML correctly omits them. Drop them from shaka in Phase 1 alongside encoding delegation; this is the second of Phase 1's two intentional wire-format changes (the other is `nor` URL relativization).
-
-- [ ] **Step 1: Remove the non-spec values from the enum** in `lib/util/cmcd_manager.js:1612-1619`:
-
-```javascript
-shaka.util.CmcdManager.StreamingFormat = {
-  DASH: 'd',
-  HLS: 'h',
-  SMOOTH: 's',
-  OTHER: 'o',
-};
-```
-
-- [ ] **Step 2: Simplify `setLowLatency` body** at `cmcd_manager.js:177-194`. The function currently flips `this.sf_` between `DASH ↔ LOW_LATENCY_DASH` and `HLS ↔ LOW_LATENCY_HLS`; after the drop, the LL state has no effect on `sf_`. Either delete the `if (this.lowLatency_)` branches entirely (preferred — `sf_` is set at manifest-load time and stays put), or leave a no-op stub for the LL flag if other code reads it.
-
-- [ ] **Step 3: Grep for remaining LL enum references.**
-  ```bash
-  grep -n "LOW_LATENCY_DASH\|LOW_LATENCY_HLS\|StreamingFormat\.LOW_LATENCY" lib/ test/
-  ```
-  Update any callers to drop the LL branches. Likely candidates: `getStreamFormat_` and any tests that asserted `sf=ld`/`sf=lh`.
-
-- [ ] **Step 4: Update tests** in `test/util/cmcd_manager_unit.js` that expected `sf=ld` or `sf=lh`. After this change, LL DASH content emits `sf=d`; LL HLS emits `sf=h`. The assertions become identical to their non-LL counterparts.
-
-- [ ] **Step 5: Run `python3 build/check.py` and `python3 build/test.py`.** Fix any compile errors and update broken assertions per Step 4.
-
-- [ ] **Step 6: Commit:**
-
-```
-fix(cmcd): drop non-spec 'ld'/'lh' StreamingFormat values
-
-CTA-5004 and CTA-5004-B define only 'd', 'h', 's', 'o' for the sf key.
-shaka's 'ld' (LOW_LATENCY_DASH) and 'lh' (LOW_LATENCY_HLS) come from an
-old unreleased draft and are not in either spec. CML correctly omits
-them. Wire change: LL DASH now emits sf=d, LL HLS now emits sf=h.
-```
-
-**Acceptance:** Enum has 4 values (DASH, HLS, SMOOTH, OTHER). `setLowLatency` no longer mutates `sf_`. Tests pass with non-LL `sf` values for LL content. Phase 1 PR description lists this as the second intentional wire-format change alongside `nor` URL relativization.
-
-### Task 1.11: Diff testing — capture baseline
-
-Before changing test assertions, capture what the current (pre-delegation) wire output looks like for representative scenarios. The baseline is what we compare against after delegation.
-
-**Files:**
-- Create: `plans/cmcd-cml-refactor/diff-test-baseline.json` (temporary, deleted before Phase 1 ships)
-
-- [ ] **Step 1: Stash Task 1.10's changes** so the manager is back to pre-delegation behavior.
-
-```bash
-git stash
-```
-
-- [ ] **Step 2: Run the existing unit tests with output capture.** Add a test-only dump that serializes every wire output produced during the suite to JSON: keyed by test name, value `{query, headers, nor}`. Run the suite, write `diff-test-baseline.json`.
-
-- [ ] **Step 3: Restore Task 1.10's changes:**
-
-```bash
-git stash pop
-```
-
-- [ ] **Step 4: Run the suite again** with the same dumping logic; produce `diff-test-after.json`.
-
-- [ ] **Step 5: Diff the two JSON files.**
-
-```bash
-diff -u plans/cmcd-cml-refactor/diff-test-baseline.json plans/cmcd-cml-refactor/diff-test-after.json
-```
-
-- [ ] **Step 6: For each diff, classify:**
-  - **`nor` URLs path → root-relative** — expected per spec; document in PR description.
-  - **Key ordering differences** — if CML emits keys in a different sorted order, accept (it's spec-conformant) and update assertions.
-  - **Escaping differences** — if CML escapes string values differently (spec § Structured Fields), accept and update assertions.
-  - **Numeric formatting** (rounding, integer vs. float) — investigate; one of CML or shaka is likely off-spec. Decide per case: align via CML upstream PR or accept as a fix.
-  - **Missing or extra keys** — investigate; this is a state-machine vs. encoder boundary issue. Likely something in the manager still does its own filtering.
-  - **`v=1` field present when v=1** — spec calls out CML omits `v` for v=1. If shaka's tests expected `v=1` present, that's a wire-format alignment.
-
-- [ ] **Step 7: Catalog all classified diffs** in `plans/cmcd-cml-refactor/diff-test-classification.md` (also temporary; eventually summarized in PR description).
-
-**Acceptance:** Every encoding-output diff between pre-delegation and post-delegation is classified as: (a) intentional alignment with CML, (b) acceptable spec-conformance fix, or (c) bug to fix before shipping Phase 1.
-
-### Task 1.12: Update test assertions for accepted divergences
-
-**Files:**
-- Modify: `test/util/cmcd_manager_unit.js` — update `nor` assertions to root-relative, update other assertions per Task 1.11 classifications.
-
-- [ ] **Step 1: Update `nor` URL assertions.** Search:
-  ```bash
-  grep -n "nor.*=" test/util/cmcd_manager_unit.js
-  ```
-  Convert path-relative expected values to root-relative.
-
-- [ ] **Step 2: Apply each Task 1.11 (a)/(b) classification** to its corresponding assertion(s).
-
-- [ ] **Step 3: For (c) classifications** (bugs), open separate sub-tasks: fix in CML upstream if it's a CML bug, or fix in the adapter's pre-encoding step if it's a shaka-specific data-shaping issue. **Do not ship Phase 1 with unresolved (c)-classified diffs.**
-
-- [ ] **Step 4: Run `python3 build/test.py`.** All tests must pass.
-
-- [ ] **Step 5: Delete temporary diff-test files:**
-  ```bash
-  rm plans/cmcd-cml-refactor/diff-test-baseline.json
-  rm plans/cmcd-cml-refactor/diff-test-after.json
-  rm plans/cmcd-cml-refactor/diff-test-classification.md
-  ```
-  But preserve a one-paragraph summary of accepted changes for the PR description.
-
-**Acceptance:** Test suite passes; intentional wire-format changes are documented; no unresolved bugs.
-
-### Task 1.13: Demo smoke test
-
-- [ ] **Step 1: Run `python3 build/all.py`** to produce the full bundle including demo.
-
-- [ ] **Step 2: Serve the demo locally** (per shaka's standard demo serve instructions in `demo/`).
-
-- [ ] **Step 3: Configure CMCD enabled** with both query and header transmission modes; load a test stream; verify CMCD data appears in network requests as expected (use browser DevTools network tab, look for `CMCD-Request` headers or `?CMCD=` query strings).
-
-- [ ] **Step 4: Compare to the same flow on `main` branch** if any visual irregularity. The wire output should match expected post-delegation behavior (root-relative `nor`, etc.).
-
-**Acceptance:** Demo plays content with CMCD enabled in both transmission modes; no JS errors in console.
-
-### Task 1.14: Phase 1 PR
-
-**Files:**
-- Modify: `MEMORY.md` (this plan, not project memory) — mark Phase 1 done
-
-- [ ] **Step 1: Stage all Phase 1 commits.** Verify the diff totals approximately match spec § Phase 1 (~3000 lines added in `third_party/cml-cmcd/`, ~500 changed in `cmcd_manager.js`).
-
-- [ ] **Step 2: Open PR with title:**
-  ```
-  refactor(cmcd): vendor @svta/cml-cmcd, delegate encoding to CML (1/3)
-  ```
-
-- [ ] **Step 3: PR description includes:**
-  - Overview: "Phase 1 of 3 in the CMCD CML refactor (see [spec.md](plans/cmcd-cml-refactor/spec.md))."
-  - What's vendored (link to spec § "The vendored port").
-  - **Wire-format changes**: enumerate the accepted divergences from Task 1.11 classifications, headlining `nor` URL relativization.
-  - Behavior preserved otherwise: state machine, sequence numbers, event timing, public API.
-  - Pinned CML version + SHA from `cml-version.md`.
-  - Build/test verification: paste output of `python3 build/check.py` and `python3 build/test.py`.
-
-- [ ] **Step 4: Wait for review; address feedback; merge.**
-
-**Acceptance:** PR merged; main branch builds, tests pass, demo works.
-
-### Phase 1 verification gate
-
-- [ ] `python3 build/check.py` passes.
-- [ ] `python3 build/test.py` passes.
-- [ ] `python3 build/all.py` passes (bundle, docs).
-- [ ] Demo loads and plays content with CMCD enabled in both query and header modes.
-- [ ] Wire-format diff classifications resolved (no class (c) remainders).
-- [ ] Phase 1 PR merged.
-
----
-
-## Phase 2: Adopt CML's constants/enums; delete shaka's duplicates
-
-**Goal:** Replace shaka's internal `shaka.util.CmcdManager.{ObjectType, Version, StreamType, CmcdKeys, CmcdV2Constants, CmcdV2Keys, CmcdMode}` with `cml.cmcd.*` equivalents. Re-export `shaka.util.CmcdManager.StreamingFormat` as an alias of `cml.cmcd.CmcdStreamingFormat` to preserve the only `@export`ed enum.
-
-**Behavior:** Pure dedupe. No behavioral change. ~150 lines deleted from the manager.
-
-### Task 2.1: Map shaka constants to CML equivalents
-
-- [ ] **Step 1: For each shaka constant/enum, identify its CML twin.**
-
-  | Shaka | CML |
-  |---|---|
-  | `shaka.util.CmcdManager.ObjectType` | `cml.cmcd.CmcdObjectType` |
-  | `shaka.util.CmcdManager.Version` | `cml.cmcd.CmcdVersion` (numeric `1`/`2`) |
-  | `shaka.util.CmcdManager.StreamType` | `cml.cmcd.CmcdStreamType` |
-  | `shaka.util.CmcdManager.CmcdKeys` | `cml.cmcd.CMCD_KEYS` (or split: `CMCD_REQUEST_KEYS`, `CMCD_RESPONSE_KEYS`, etc.) |
-  | `shaka.util.CmcdManager.CmcdV2Constants` | scattered across `cml.cmcd.CMCD_V2`, `CMCD_V2_KEYS`, etc. |
-  | `shaka.util.CmcdManager.CmcdV2Keys` | `cml.cmcd.CMCD_V2_KEYS` (verify exact name) |
-  | `shaka.util.CmcdManager.CmcdMode` | `cml.cmcd.CmcdReportingMode` |
-
-- [ ] **Step 2: Verify every value matches.** For each shaka constant, dump its values; compare to CML's. Any mismatch is a Phase 2 blocker.
-
-- [ ] **Step 3: Document mappings** (one line each) inline in the cmcd_manager.js commit, or in a brief `plans/cmcd-cml-refactor/phase2-mapping.md`.
-
-**Acceptance:** Every shaka constant has a confirmed CML equivalent with matching values.
-
-### Task 2.2: Replace internal references
-
-**Files:**
-- Modify: `lib/util/cmcd_manager.js` — rewrite each `shaka.util.CmcdManager.X` reference to `cml.cmcd.Y`
-
-- [ ] **Step 1: Add `goog.require` lines** for each CML symbol used.
-
-- [ ] **Step 2: Use a search-and-replace approach.** For each mapping in Task 2.1, find all references:
-  ```bash
-  grep -n "shaka\.util\.CmcdManager\.ObjectType" lib/util/cmcd_manager.js
-  ```
-  And replace with the CML name.
-
-- [ ] **Step 3: Run `python3 build/check.py`** after each constant migration to catch broken references.
-
-**Acceptance:** No internal references to the soon-to-be-deleted shaka constants remain.
-
-### Task 2.3: Re-export `StreamingFormat`
-
-**Files:**
-- Modify: `lib/util/cmcd_manager.js` — add the alias
-
-After Phase 1 Task 1.10b dropped the non-spec `'ld'`/`'lh'` values, shaka's `StreamingFormat` enum is a strict subset of CML's: same 4 spec-conformant values (`'d'`/`'h'`/`'s'`/`'o'`), same constant names (DASH/HLS/SMOOTH/OTHER). The alias re-export is straightforward; no derived/extended enum needed.
-
-- [ ] **Step 1: Add the re-export:**
-
-```javascript
-/**
- * @enum {string}
- * @export
- */
-shaka.util.CmcdManager.StreamingFormat = cml.cmcd.CmcdStreamingFormat;
-```
-
-- [ ] **Step 2: Verify the `@export` annotation is preserved.** Closure ADVANCED depends on this exactly — any drift renames the public symbol.
-
-- [ ] **Step 3: Run `python3 build/check.py`.** If Closure flags this as needing a different alias pattern (e.g., per-key copy), use the pattern that preserves both the `@export` and the value identity.
-
-**Acceptance:** `shaka.util.CmcdManager.StreamingFormat` is a CML alias; values identical; export preserved.
-
-### Task 2.4: Delete duplicate definitions
-
-**Files:**
-- Modify: `lib/util/cmcd_manager.js` — delete the now-unused constant definitions
-
-- [ ] **Step 1: Delete `shaka.util.CmcdManager.ObjectType`, `Version`, `StreamType`, `CmcdKeys`, `CmcdV2Constants`, `CmcdV2Keys`, `CmcdMode`.** Keep `StreamingFormat` (the alias).
-
-- [ ] **Step 2: Run `python3 build/check.py`.** Closure must complain if anything still references a deleted symbol.
-
-- [ ] **Step 3: Run `python3 build/test.py`.** Tests must still pass — they use the manager's public surface, which doesn't expose these internals.
-
-**Acceptance:** Manager file shrinks by ~150 lines; check + tests pass.
-
-### Task 2.5: Demo smoke test
-
-- [ ] **Step 1: Run `python3 build/all.py`.** Same as Task 1.13.
-- [ ] **Step 2: Verify demo with CMCD enabled.** Same as Task 1.13.
-
-**Acceptance:** Demo works.
-
-### Task 2.6: Phase 2 PR
-
-- [ ] **Step 1: Open PR with title:**
-  ```
-  refactor(cmcd): adopt CML constants/enums, delete shaka duplicates (2/3)
-  ```
-
-- [ ] **Step 2: PR description includes:**
-  - Overview: "Phase 2 of 3 in the CMCD CML refactor."
-  - List of constants migrated (link to Task 2.1 mapping table).
-  - Public-API note: `shaka.util.CmcdManager.StreamingFormat` re-exported as alias; values unchanged.
-  - Behavior: no change.
-  - Build/test verification.
-
-- [ ] **Step 3: Merge.**
-
-**Acceptance:** Phase 2 PR merged.
-
-### Phase 2 verification gate
-
-- [ ] `python3 build/check.py` passes.
-- [ ] `python3 build/test.py` passes.
-- [ ] `python3 build/all.py` passes.
-- [ ] Demo works with CMCD enabled.
-- [ ] Phase 2 PR merged.
-
----
-
-## Phase 3: Replace state machine with `CmcdReporter`
-
-**Goal:** Rewrite [`lib/util/cmcd_manager.js`](../../lib/util/cmcd_manager.js) as a thin adapter (~250 lines) that delegates state, encoding, and event timing to `cml.cmcd.CmcdReporter`. Apply experimental v2 config renames. Delete CMCD wire-format tests; add adapter glue + smoke tests.
-
-**Behavior:** Behavior shifts — this is the high-risk PR. Watch for: state-transition timing differences (CML vs. shaka's existing transitions), per-target sequence-number behavior (Task 0.7), event-mode dispatch shape.
-
-### Task 3.1: Re-verify CML-side requirements
-
-CML may have evolved between Phase 0 and Phase 3 if Phases 1+2 took weeks.
-
-- [ ] **Step 1: Re-run Tasks 0.2–0.8** against the currently pinned CML version (which may need a bump if upstream landed relevant changes).
-
-- [ ] **Step 2: If a bump is warranted**, update the vendored port and re-validate Phase 1 + Phase 2. (This is unusual but possible.)
-
-- [ ] **Step 3: Update `plans/cmcd-cml-refactor/cml-version.md`** with current pinned version and verification status.
-
-**Acceptance:** CML-side requirements all confirmed at the version we'll ship Phase 3 against.
-
-### Task 3.2: Sketch adapter file structure
-
-Before writing code, plan the adapter's internal layout. The spec already gives the broad shape; this task fixes the file structure.
-
-- [ ] **Step 1: Decide whether to keep all adapter logic in one file or split.** Recommend: keep in `lib/util/cmcd_manager.js` (shaka convention; the adapter is small enough). Don't pre-emptively split into `cmcd_adapter.js` + `cmcd_state.js` — that's premature.
-
-- [ ] **Step 2: Outline the file as a comment block at the top of the new manager:**
-
-```
-// Adapter responsibilities:
-//   1. Lifecycle: construct/start/stop CmcdReporter from configure() and reset()
-//   2. Player wiring: <video> + Player events → reporter.update + recordEvent
-//   3. Request mode: applyRequestData → reporter.createRequestReport
-//   4. Response mode: applyResponseData → reporter.recordResponseReceived
-//   5. Event mode: requester callback → NetworkingEngine.request
-//   6. Config translation: shaka.extern.CmcdConfiguration → CmcdReporterConfig
-//   7. Public-API back-compat: re-exports for StreamingFormat, EventType, PlayerState
-```
-
-- [ ] **Step 3: Identify which existing methods stay vs. go.** Keep: `setMediaElement`, `configure`, `reset`, `applyRequestData`, `applyResponseData`. Delete: all `applyRequest_`/`applyManifestData`/`applyManifestRequest_`/`getObjectType_` (kept) / `getBitrate_` (kept) / `getDuration_` (kept) / encoder helpers (gone after Phase 1, but verify) / event timer code / sequence-number tracking / MSD computation.
-
-**Acceptance:** Clear picture of what gets written, what gets kept, what gets deleted.
-
-### Task 3.3: Lifecycle wiring
-
-**Files:**
-- Modify: `lib/util/cmcd_manager.js`
-
-The lifecycle is the foundation; all other tasks depend on the reporter being constructed correctly.
-
-- [ ] **Step 1: Write the constructor** to store the player and config but NOT construct the reporter yet. The reporter needs `setMediaElement` to have been called and `enabled: true` to be set.
-
-- [ ] **Step 2: Write `setMediaElement(mediaElement)`:**
-  - Save `this.video_ = mediaElement`.
-  - If `this.config_.enabled` and reporter not yet constructed, construct it now via `this.maybeStartReporter_()`.
-  - Subscribe to `<video>` events (per spec's lifecycle table).
-
-- [ ] **Step 3: Write `configure(newConfig)`:**
-  - If `enabled: false → enabled: true`: construct reporter via `maybeStartReporter_`.
-  - If `enabled: true → enabled: false`: call `this.reporter_.stop(true)`; null out `this.reporter_`; remove event listeners.
-  - If `enabled: true → enabled: true` and material change (sessionId, contentId, version, transmissionMode, eventTargets): tear down + reconstruct (spec § "On configure() with materially-changed config").
-  - If only `includeKeys` changed: `this.reporter_.update(...)` may be enough — verify against CML.
-
-- [ ] **Step 4: Write `reset()`:**
-  - If reporter exists: `this.reporter_.stop(true)`; null out.
-  - Remove all event listeners (existing `eventManager_.removeAll()`).
-
-- [ ] **Step 5: Write `maybeStartReporter_()`:**
-  - Only if `this.config_.enabled` AND `this.video_` (need media element for state).
-  - Build `CmcdReporterConfig` via `toReporterConfig_(this.config_)` (Task 3.8).
-  - Construct: `this.reporter_ = new cml.cmcd.CmcdReporter(reporterConfig)`.
-  - Call `this.reporter_.start()`.
-
-- [ ] **Step 6: Implement `enabled: false` short-circuit** in `applyRequestData` and `applyResponseData` — both early-return if `!this.reporter_`.
-
-- [ ] **Step 7: Run `python3 build/check.py`.**
-
-**Acceptance:** Lifecycle compiles. No tests yet — Task 3.13 adds them.
-
-### Task 3.4: `applyRequestData` rewrite
-
-**Files:**
-- Modify: `lib/util/cmcd_manager.js`
-
-- [ ] **Step 1: Reimplement `applyRequestData(type, request, context)`:**
-  - Early-return if `!this.reporter_` (disabled).
-  - Extract shaka-specific fields via existing helpers: `getObjectType_(type, context)`, `getBitrate_(context.segmentRef)`, `getDuration_(context.segmentRef)`, `getTopBitrate_(context.segmentRef)`, `getStreamFormat_(context.type)`. Keep these helpers — they encode shaka knowledge.
-  - Build the per-request `CmcdData` object:
-    ```javascript
-    const data = {};
-    if (objectType) data.ot = objectType;
-    if (Number.isFinite(bitrate)) {
-      data.br = (this.config_.version >= 2) ? [bitrate] : bitrate;
-    }
-    if (Number.isFinite(topBitrate)) {
-      data.tb = (this.config_.version >= 2) ? [topBitrate] : topBitrate;
-    }
-    if (Number.isFinite(bufferLength)) {
-      data.bl = (this.config_.version >= 2) ? [bufferLength] : bufferLength;
-    }
-    if (Number.isFinite(throughputKbps)) {
-      data.mtp = (this.config_.version >= 2) ? [throughputKbps] : throughputKbps;
-    }
-    if (nextUrl) {
-      data.nor = (this.config_.version >= 2) ? [nextUrl] : nextUrl;
-    }
-    if (Number.isFinite(duration)) data.d = duration;
-    if (Number.isFinite(rtp)) data.rtp = rtp;  // bitrate * rtpSafetyFactor, computed adapter-side
-    ```
-  - Call `const cmldRequest = this.reporter_.createRequestReport(request, data);`.
-  - Copy the CMCD-applied fields back onto the input request:
-    ```javascript
-    if (cmldRequest.uris) request.uris = cmldRequest.uris;
-    if (cmldRequest.headers) Object.assign(request.headers, cmldRequest.headers);
-    ```
-
-- [ ] **Step 2: Resolve spec gap #2 (`bl` placement).** Treat `bl` strictly as per-request data here — never pass `bl` to `reporter.update()`. The spec's persistent-state table mentioning `bl` is misleading; the comment "may live on createRequestReport data" is the operative model.
-
-- [ ] **Step 3: Run `python3 build/check.py`.**
-
-**Acceptance:** `applyRequestData` compiles; mutates the request object; uses CML reporter for encoding.
-
-### Task 3.5: `applyResponseData` rewrite
-
-**Files:**
-- Modify: `lib/util/cmcd_manager.js`
-
-- [ ] **Step 1: Reimplement `applyResponseData(type, response, context)`:**
-  - Early-return if `!this.reporter_`.
-  - Compute `ttfb`/`ttlb` from existing `requestTimestampMap_` mechanism (keep this; it's shaka knowledge).
-  - Extract `rc` (response code) and `url` from response.
-  - Call `this.reporter_.recordResponseReceived(response, {ttfb, ttlb, rc, url})`.
-
-- [ ] **Step 2: Apply Task 0.4's findings.** If `recordResponseReceived` returns data the adapter should propagate, copy it back to `response`. If it's a fire-and-forget call, don't.
-
-- [ ] **Step 3: Run `python3 build/check.py`.**
-
-**Acceptance:** `applyResponseData` compiles; preserves shaka's existing in-place mutation contract.
-
-### Task 3.6: Player event listeners
-
-**Files:**
-- Modify: `lib/util/cmcd_manager.js`
-
-Per spec § "Player state ↔ reporter state mapping" table.
-
-- [ ] **Step 1: Subscribe to `<video>` events** in `setMediaElement` (already partially set up by Task 3.3). For each event, translate to reporter calls per the spec's table. Examples:
-
-```javascript
-this.eventManager_.listen(this.video_, 'pause', () => {
-  this.setPlayerState_(cml.cmcd.CmcdPlayerState.PAUSED);
-});
-this.eventManager_.listen(this.video_, 'seeking', () => {
-  this.setPlayerState_(cml.cmcd.CmcdPlayerState.SEEKING);
-});
-this.eventManager_.listen(this.video_, 'ended', () => {
-  this.setPlayerState_(cml.cmcd.CmcdPlayerState.ENDED);
-});
-// ... volumechange → muted/unmuted, visibilitychange → backgrounded
-```
-
-- [ ] **Step 2: Subscribe to `shaka.Player` events** for buffering, variant changes, fatal errors:
-
-```javascript
-this.eventManager_.listen(this.player_, 'buffering', (e) => {
-  if (e.buffering) {
-    this.setPlayerState_(cml.cmcd.CmcdPlayerState.REBUFFERING);
-  } else {
-    this.setPlayerState_(cml.cmcd.CmcdPlayerState.PLAYING);
-  }
-});
-this.eventManager_.listen(this.player_, 'adaptation', () => {
-  const variant = this.player_.getVariantTracks().find((t) => t.active);
-  if (variant) {
-    this.reporter_.update({br: [variant.bandwidth]});
-    this.reporter_.recordEvent(cml.cmcd.CmcdEventType.BITRATE_CHANGE);
-  }
-});
-this.eventManager_.listen(this.player_, 'error', () => {
-  this.setPlayerState_(cml.cmcd.CmcdPlayerState.FATAL_ERROR);
-  this.reporter_.recordEvent(cml.cmcd.CmcdEventType.ERROR);
-});
-```
-
-- [ ] **Step 3: Implement throughput-update wiring.** Whatever shaka's existing throughput-change signal is (likely `shaka.abr.EwmaBandwidthEstimator` updates flowing through `shaka.Player`), feed `mtp` into `reporter.update(...)` as it changes.
-
-- [ ] **Step 4: Set `streamingFormat` once at manifest-load time.** Feed `update({streamingFormat: ...})` from the manifest parser type (DASH → `'d'`, HLS → `'h'`, Smooth → `'s'`, otherwise `'o'`). **Do NOT mutate `streamingFormat` on `setLowLatency` callbacks** — Phase 1 dropped the non-spec `'ld'`/`'lh'` values, and `sf` is per CTA-5004-B a stable manifest-type indicator, not an LL flag.
-
-- [ ] **Step 5: Run `python3 build/check.py`.**
-
-**Acceptance:** All player/video events from spec's table have a listener that calls the right reporter method.
-
-### Task 3.7: Player-state deduplication
-
-**Files:**
-- Modify: `lib/util/cmcd_manager.js`
-
-Per spec § "Player-state deduplication".
-
-- [ ] **Step 1: Implement `setPlayerState_(state)`:**
-
-```javascript
-setPlayerState_(state) {
-  if (this.lastPlayerState_ === state) return;
-  this.lastPlayerState_ = state;
-  this.reporter_.update({playerState: state});
-  this.reporter_.recordEvent(cml.cmcd.CmcdEventType.PLAY_STATE);
-}
-```
-
-- [ ] **Step 2: Initialize `this.lastPlayerState_ = null`** in the constructor.
-
-- [ ] **Step 3: Reset `this.lastPlayerState_`** in `reset()` so a re-load doesn't suppress the first `PLAYING` event.
-
-- [ ] **Step 4: Apply this dedup pattern only to `playerState`.** Other reporter.update fields (`mtp`, `cid`, `backgrounded`, `muted`) don't need dedup at this layer — either CML deduplicates internally, or the underlying signals are already deduplicated.
-
-- [ ] **Step 5: Run `python3 build/check.py`.**
-
-**Acceptance:** Player-state transitions don't emit duplicate `ps` events.
-
-### Task 3.8: Configuration translation (`toReporterConfig_`)
-
-**Files:**
-- Modify: `lib/util/cmcd_manager.js`
-
-Per spec § "3. Configuration translation".
-
-- [ ] **Step 1: Implement `toReporterConfig_(shakaCmcdConfig)`:**
-
-```javascript
-toReporterConfig_(cfg) {
-  const reporterConfig = {
-    sid: cfg.sessionId || this.generateSessionId_(),
-    cid: cfg.contentId,
-    transmissionMode: cfg.useHeaders
-        ? cml.cmcd.CmcdTransmissionMode.CMCD_HEADERS
-        : cml.cmcd.CmcdTransmissionMode.CMCD_QUERY,
-    enabledKeys: cfg.includeKeys,
-    version: cfg.version === 2
-        ? cml.cmcd.CMCD_V2
-        : cml.cmcd.CMCD_V1,
-    requester: this.makeRequester_(),
-  };
-  if (cfg.eventTargets && cfg.eventTargets.length) {
-    reporterConfig.eventTargets = cfg.eventTargets.map((target) => ({
-      url: target.url,
-      events: target.events,
-      interval: target.interval,          // CML field name (was timeInterval)
-      batchSize: target.batchSize,
-      enabledKeys: target.includeKeys,    // rename: includeKeys (shaka) → enabledKeys (CML)
-      version: target.version,            // CML supports per-target version (Task 0.5 confirmed)
-    }));
-  }
-  return reporterConfig;
-}
-```
-
-- [ ] **Step 2: Resolve spec gap #4 (`sessionId` auto-generation).** Implement `generateSessionId_()`:
-
-```javascript
-generateSessionId_() {
-  // Existing shaka pattern; check what cmcd_manager.js currently does on
-  // the load() path to auto-generate sessionId, and preserve that exact
-  // codepath here. Probably crypto.randomUUID() (already polyfilled).
-  return crypto.randomUUID();
-}
-```
-
-  This means `cml.cmcd.uuid` (the shim from Task 1.5) is genuinely dead code at runtime — the adapter always supplies `sid`.
-
-- [ ] **Step 3: Apply Task 0.5 outcome to per-target `version`.** If CML doesn't expose per-target version, drop that line from the `map(...)` body and document the limitation in the externs (Task 3.11).
-
-- [ ] **Step 4: Run `python3 build/check.py`.**
-
-**Acceptance:** `toReporterConfig_` produces a valid `CmcdReporterConfig`; field renames applied per spec.
-
-### Task 3.9: `requester` callback wiring
-
-**Files:**
-- Modify: `lib/util/cmcd_manager.js`
-
-Per spec § "Event-mode dispatch via NetworkingEngine".
-
-- [ ] **Step 1: Implement `makeRequester_()`** (exact code from spec § "Event-mode dispatch via NetworkingEngine"):
-
-```javascript
-makeRequester_() {
-  const RequestType = shaka.net.NetworkingEngine.RequestType;
-  return async (cmcdReq) => {
-    const retryParams = shaka.net.NetworkingEngine.defaultRetryParameters();
-    const shakaReq = shaka.net.NetworkingEngine.makeRequest(
-        [cmcdReq.url], retryParams);
-    shakaReq.method = cmcdReq.method || 'POST';
-    shakaReq.headers = cmcdReq.headers || {};
-
-    // CML's reporter always emits body as a string (structured-fields
-    // encoded by encodeCmcd, joined by '\n'). Convert to BufferSource.
-    shakaReq.body = shaka.util.StringUtils.toUTF8(cmcdReq.body);
-
-    try {
-      await this.networkingEngine_
-          .request(RequestType.TIMING, shakaReq, {type: 'cmcd-event'})
-          .promise;
-      return {status: 200};
-    } catch (err) {
-      return {status: err.status || 0};
-    }
-  };
-}
-```
-
-- [ ] **Step 2: Body type is fixed to `string`** per Phase 0 Task 0.8 verification (`cml-version.md`): CML's `sendEventReport` constructs `body: data.map(item => encodeCmcd(item, options)).join('\n') + '\n'` — never Blob, never Uint8Array. The Blob branch from earlier sketches is dead code.
-
-- [ ] **Step 3: Stash `this.networkingEngine_` reference** somewhere in the constructor or `setMediaElement` (the existing `cmcd_manager.js` likely already has this; verify).
-
-- [ ] **Step 4: Run `python3 build/check.py`.**
-
-**Acceptance:** `requester` callback compiles; routes through NetworkingEngine.
-
-### Task 3.10: Delete obsolete code
-
-**Files:**
-- Modify: `lib/util/cmcd_manager.js`
-
-- [ ] **Step 1: Delete:**
-  - All encoding helpers (already partially deleted in Phase 1; verify nothing remains).
-  - Sequence-number tracking (`this.cmcdSequenceNumbers_`).
-  - Event-timer infrastructure (`this.eventTimers_`).
-  - MSD computation (`this.msdSent_`, etc.).
-  - Mode-selection logic (request mode vs. response mode vs. event mode dispatch — CML's reporter handles this).
-  - Private helpers: `applyRequest_`, `applyManifestData`, `applyManifestRequest_`, etc.
-
-- [ ] **Step 2: Keep:**
-  - `getObjectType_`, `getBitrate_`, `getDuration_`, `getTopBitrate_`, `getStreamFormat_` — shaka knowledge, the adapter's job to translate.
-  - `requestTimestampMap_` — TTFB/TTLB measurement; CML reporter doesn't have access to send time.
-
-- [ ] **Step 3: Run `python3 build/check.py`.** No dead-code warnings; if Closure flags unused private fields, delete them.
-
-- [ ] **Step 4: Verify line count.** Spec target is ~250 lines for the adapter.
-
-**Acceptance:** Manager file shrunk to ~250 lines; only adapter logic and shaka-knowledge helpers remain.
-
-### Task 3.11: Externs renames
-
-**Files:**
-- Modify: `externs/shaka/player.js` — rename `targets` → `eventTargets`, per-target `enabledKeys` → `includeKeys`
-- Modify: `externs/cmcd.js` — review for v2-key updates if needed (likely no change)
-
-Per spec § "Public-API back-compat details".
-
-- [ ] **Step 1: Rename `shaka.extern.CmcdConfiguration.targets` → `eventTargets`.** Lines 2771, 2819 in `externs/shaka/player.js` (per the grep earlier).
-
-- [ ] **Step 2: Rename per-target field in `shaka.extern.CmcdTarget`.** The current typedef at line 2760 doesn't show all fields in my read — verify the field is `enabledKeys` and rename to `includeKeys`. Update JSDoc descriptions accordingly.
-
-- [ ] **Step 3: Update the JSDoc comment block** for `CmcdConfiguration` to reflect the new field name. Add `@deprecated` or migration note if maintainers prefer.
-
-- [ ] **Step 4: Verify Player code doesn't read `cfg.targets`.** Grep:
-  ```bash
-  grep -rn "cmcd.targets\|\.targets" lib/player.js
-  ```
-  Update any remaining references to the old name.
-
-- [ ] **Step 5: Run `python3 build/check.py`.**
-
-**Acceptance:** Externs renamed; no internal references to old names.
-
-### Task 3.12: v2 re-exports
-
-**Files:**
-- Modify: `lib/util/cmcd_manager.js`
-
-Per spec § "New public re-exports for v2 configuration".
-
-- [ ] **Step 1: Add re-exports:**
-
-```javascript
-/**
- * @enum {string}
- * @export
- */
-shaka.util.CmcdManager.EventType = cml.cmcd.CmcdEventType;
-
-/**
- * @enum {string}
- * @export
- */
-shaka.util.CmcdManager.PlayerState = cml.cmcd.CmcdPlayerState;
-```
-
-- [ ] **Step 2: Verify `@export` works for alias re-exports.** Closure ADVANCED may need a different pattern (e.g., per-key copy) to preserve the export. Use whatever pattern the existing `StreamingFormat` re-export from Task 2.3 ended up using.
-
-- [ ] **Step 3: Run `python3 build/check.py` and grep the compiled output** for `EventType` / `PlayerState` to confirm they appear in the public API:
-  ```bash
-  python3 build/build.py && grep -o "EventType\|PlayerState" dist/shaka-player.compiled.js | head
-  ```
-
-**Acceptance:** Both re-exports appear in compiled bundle's public surface.
-
-### Task 3.13: Test rewrite
-
-**Files:**
-- Modify (large delete): `test/util/cmcd_manager_unit.js`
-- Add: new test sections per spec § "Tests strategy"
-
-Per spec § "Phase 3 — Test rewrite".
-
-- [ ] **Step 1: Delete CMCD wire-format tests** (Bucket A — encoder correctness, key serialization, value escaping, header vs query, v1/v2 mode-specific filtering, inner-list encoding, structured-field serialization, sequence-number progression, event timing/batching). Spec estimates ~3000+ lines deleted.
-
-- [ ] **Step 2: Add Bucket B tests** (~500 lines, shaka-specific glue). Use a stubbed `CmcdReporter` that records calls. Cover:
-  - `RequestType` (MANIFEST, SEGMENT, LICENSE, KEY, TIMING) → `CmcdObjectType` mapping.
-  - `RequestContext.type` → `CmcdStreamingFormat` mapping (DASH/HLS/Smooth/Other; LL DASH and LL HLS map to plain DASH/HLS per Phase 1 Task 1.10b).
-  - Config translation (`toReporterConfig_` outputs given various `shaka.extern.CmcdConfiguration` inputs).
-  - Player-event listener wiring: simulate `<video>` events, assert `reporter.update(...)` and `recordEvent(...)` calls.
-  - NetworkingEngine routing: stub the reporter's `requester` callback; assert it dispatches via `NetworkingEngine.request(RequestType.TIMING, ...)`; assert error → `{status: 0}` translation.
-  - Lifecycle: construct → configure → reset → reconfigure produces a fresh reporter.
-  - `rtp = bitrate × rtpSafetyFactor` computed in adapter.
-  - `enabled: false` → no reporter constructed; apply* short-circuits.
-  - `setMediaElement` triggers reporter construction (resolves spec gap #1).
-  - `bl` is per-request, never persistent state (resolves spec gap #2).
-  - Player-state deduplication: repeated `playing` events → single `recordEvent`.
-  - Public-API back-compat: `shaka.util.CmcdManager.StreamingFormat`/`EventType`/`PlayerState` enums available with expected values.
-
-- [ ] **Step 3: Add Bucket C tests** (~100 lines, end-to-end smoke). Drive a real `CmcdReporter` (not a stub) through the adapter; assert wire output. Cover:
-  - One v1 + one v2 config × two transmission modes (`CMCD_QUERY`, `CMCD_HEADERS`) = at least 4 cases.
-  - One event-mode test: configure an `eventTarget`; trigger play-state change; assert NetworkingEngine receives an event-mode POST with expected body.
-
-- [ ] **Step 4: Run `python3 build/test.py` until green.** Iterate.
-
-**Acceptance:** Test suite passes. ~4317 lines deleted, ~600 lines added (per spec estimate).
-
-### Task 3.14: Demo update
-
-**Files:**
-- Modify: `demo/` — add CMCD v2 config UI
-
-Per spec § "Phase 3", and resolving spec gap #8 (demo scope).
-
-- [ ] **Step 1: Identify the existing demo CMCD UI.** Grep:
-  ```bash
-  grep -rn "cmcd" demo/
-  ```
-
-- [ ] **Step 2: Add minimum v2 controls:**
-  - Transmission mode toggle (query / headers).
-  - Version selector (1 / 2).
-  - Single eventTarget editor: URL input + checkboxes for which event types to subscribe to (`PLAY_STATE`, `ERROR`, `RESPONSE_RECEIVED`, etc.) + numeric input for `timeInterval`.
-  - Reuse existing CMCD UI for `enabled`, `sessionId`, `contentId`, `includeKeys`, `useHeaders`.
-
-- [ ] **Step 3: Wire config changes to `player.configure({cmcd: ...})`.**
-
-- [ ] **Step 4: Verify the demo loads and the new controls work** — load a stream, change settings live, verify CMCD output changes accordingly via DevTools network tab.
-
-**Acceptance:** Demo has v2 config UI. Mirrors precedent from dash.js's `cmcd-v2.html` per spec.
-
-### Task 3.15: Phase 3 verification
-
-- [ ] **Step 1: `python3 build/check.py` passes.**
-- [ ] **Step 2: `python3 build/test.py` passes.**
-- [ ] **Step 3: `python3 build/all.py` passes.**
-- [ ] **Step 4: Demo verification:**
-  - v1 config + query mode: stream plays; CMCD in query string; expected keys present.
-  - v1 config + headers mode: stream plays; CMCD in `CMCD-Request` header.
-  - v2 config + query mode: stream plays; v2 keys present (`sta`, `sn`, etc.); inner-list keys are arrays (`br=[1234]`).
-  - v2 config + eventTarget configured: trigger play/pause/seek; verify event-mode POSTs to the eventTarget URL.
-- [ ] **Step 5: Manual regression check** for non-CMCD playback: unconfigure CMCD; verify nothing about playback changed.
-
-**Acceptance:** All phases of verification pass.
-
-### Task 3.16: Phase 3 PR
-
-- [ ] **Step 1: Open PR with title:**
-  ```
-  refactor(cmcd): replace state machine with cml.cmcd.CmcdReporter (3/3)
-  ```
-
-- [ ] **Step 2: PR description includes:**
-  - Overview: "Phase 3 of 3 in the CMCD CML refactor."
-  - **Public-API renames** (experimental v2 only):
-    - `shaka.extern.CmcdConfiguration.targets` → `eventTargets`.
-    - Per-target `enabledKeys` → `includeKeys`.
-  - **New public re-exports**: `shaka.util.CmcdManager.EventType`, `shaka.util.CmcdManager.PlayerState`.
-  - **Behavioral changes**: enumerate any state-transition or timing differences vs. the pre-refactor manager.
-  - **Sequence numbers** (Task 0.7 outcome): if CML's per-target sequencing differs from shaka's prior per-mode sequencing, call out as a wire-format change.
-  - **Event-mode dispatch**: now flows through NetworkingEngine; inherits auth/retry/filters.
-  - Test surface: ~4317 lines deleted (wire-format coverage now in CML upstream), ~600 lines added (adapter glue + smoke).
-  - **Deferred**: `RequestType.CMCD_EVENT_REPORT` (using `RequestType.TIMING` for now; can be added in follow-up PR without changing adapter contract).
-
-- [ ] **Step 3: Wait for review; address feedback; merge.**
-
-**Acceptance:** PR merged; CMCD refactor complete.
-
-### Phase 3 verification gate
-
-- [ ] `python3 build/check.py` passes.
-- [ ] `python3 build/test.py` passes.
-- [ ] `python3 build/all.py` passes.
-- [ ] Demo plays content with CMCD v1 + v2 in both transmission modes.
-- [ ] Demo dispatches event-mode reports through NetworkingEngine.
-- [ ] Phase 3 PR merged.
-
----
-
-## Risks and mitigations
-
-| Risk | Phase | Mitigation |
-|---|---|---|
-| Closure ADVANCED renames an `@export` symbol | All | After each `@export` change, verify the symbol appears in compiled output (`grep` on `dist/shaka-player.compiled.js`). |
-| Wire-format diff during Phase 1 surfaces (c)-class bugs (real divergence, not alignment) | 1 | Block Phase 1 ship; resolve via CML upstream PR or adapter workaround; re-run diff test. |
-| CML's `CmcdReporter` API doesn't match spec assumptions | 0, 3 | Phase 0 verification catches; Task 3.1 re-verifies before Phase 3 commits. |
-| State-transition timing differences (CML emits events at slightly different times than shaka used to) | 3 | Bucket C smoke tests catch egregious cases; PR description calls out any known timing changes; demo regression check. |
-| Per-target sequence numbering differs from shaka's per-mode prior behavior | 3 | Task 0.7 documents the difference; Phase 3 PR description notes it; downstream consumers parsing `sn` need to adapt. |
-| `enabled: false → true` mid-session dynamic reconfiguration leaves the adapter in a broken state | 3 | Bucket B test covers this lifecycle path. |
-| Demo regression: existing CMCD-disabled flows break | 3 | Manual regression check (Task 3.15.5); test-suite already covers `enabled: false`. |
-| Memory leak from forgotten event listeners on `reset()` | 3 | `reset()` calls `eventManager_.removeAll()` (existing pattern); Bucket B test asserts listener count returns to zero. |
-| CML version pinning becomes stale between Phase 0 and Phase 3 | All | Task 3.1 re-pins if upstream landed relevant changes; small risk this triggers a Phase 1 revisit. |
-| `crypto.randomUUID()` not available in some shaka-supported browser | 3 | Use shaka's existing UUID-generation path (whatever `cmcd_manager.js` currently uses) rather than `crypto.randomUUID()` directly; the polyfill already covers this. |
-
----
-
-## Out of scope (deferred follow-ups)
-
-- **`RequestType.CMCD_EVENT_REPORT` dedicated request type.** Phase 3 uses `RequestType.TIMING`. Follow-up PR can add a dedicated type without changing adapter contract.
-- **CMCD validators in the vendored port.** Spec § "Excluded" lists ~16 validator files. Add only if shaka adds a debug-mode self-check feature.
-- **Expanded public re-export surface.** Beyond `StreamingFormat`/`EventType`/`PlayerState`, additional CML enums (`CmcdObjectType`, `CmcdStreamType`, `CmcdHeaderField`, etc.) stay internal until users have a documented need.
-- **TypeScript migration.** Out of scope per spec; the vendored port is transitional and deletes when [#8262](https://github.com/shaka-project/shaka-player/issues/8262) lands.
-
----
-
-## Self-review (post-write)
-
-- [x] **Spec coverage check.** Each spec section maps to a phase: Constraints → Phase 0 verification + AGENTS.md adherence; Architecture → Phase 1 + Phase 3; Vendored port → Phase 1; Adapter → Phase 3; CML-side requirements → Phase 0 + Task 3.1; Migration phasing → plan structure; Tests → Tasks 1.11/1.12/3.13; Open questions → Tasks 0.1/0.7 + Task 1.11 + Risk table.
-- [x] **Placeholder scan.** No "TBD", "fill in details", "implement later", or generic "add error handling" — every step has actionable content or a verification command.
-- [x] **Type consistency.** Method names used consistently: `setPlayerState_`, `maybeStartReporter_`, `toReporterConfig_`, `makeRequester_`, `generateSessionId_`, `lastPlayerState_`. CML symbols consistently `cml.cmcd.X`.
-- [x] **Spec gaps surfaced.** 10 gaps listed at the top with their resolving tasks identified.
-- [x] **Risks identified.** Risk table covers Closure export drift, wire-format divergence, API mismatches, state-timing differences, sequence-numbering, demo regressions, listener leaks, version drift, and UUID polyfill.
-- [x] **Acceptance criteria per phase.** Each phase has a verification-gate checklist (`build/check.py`, `build/test.py`, `build/all.py`, demo).
diff --git a/plans/cmcd-cml-refactor/pr-draft.md b/plans/cmcd-cml-refactor/pr-draft.md
deleted file mode 100644
index 4d725d4dde..0000000000
--- a/plans/cmcd-cml-refactor/pr-draft.md
+++ /dev/null
@@ -1,239 +0,0 @@
-<!--
-Cumulative PR draft for the CMCD CML refactor. All three phases (Phase 1
-vendor + delegate, Phase 2 dedupe, Phase 3 adapter rewrite) are landed
-locally on feat/cmcd-cml-refactor and ready for the single all-phases PR.
--->
-
-# Title
-
-```
-refactor(cmcd): vendor @svta/cml-cmcd, replace custom encoder + state machine
-```
-
-# Body
-
-## Summary
-
-Replaces shaka's custom CMCD wire-format encoding and state machine with a vendored Closure port of [`@svta/cml-cmcd`](https://github.com/streaming-video-technology-alliance/common-media-library) (CML) under `third_party/cml-cmcd/`. Implementation in three sequential phases off `feat/cmcd-cml-refactor`:
-
-- **Phase 1** (Tasks 1.1-1.13) vendors the port and routes shaka's encoders through it. Three intentional wire-format changes (`nor` URL relativization, `'ld'`/`'lh'` dropped, V2 SFV-conformant encoding).
-- **Phase 2** (Tasks 2.1-2.5) dedupes shaka's internal enums and key arrays in favor of `cml.cmcd.*` equivalents. Pure dedupe; no behavior change.
-- **Phase 3** (Tasks 3.1-3.15) rewrites `lib/util/cmcd_manager.js` (1580 → ~700 LoC) as a thin adapter around `cml.cmcd.CmcdReporter`. Deletes the state machine, sequence-number tracking, event timing, and mode-selection logic. Ships experimental v2 config renames (`targets`→`eventTargets`, per-target `timeInterval`→`interval`) and adds public `EventType` / `PlayerState` re-exports. Three additional wire-format alignments inherited from CML.
-
-See [`plans/cmcd-cml-refactor/spec.md`](plans/cmcd-cml-refactor/spec.md) and [`plans/cmcd-cml-refactor/plan.md`](plans/cmcd-cml-refactor/plan.md) for full design + rationale.
-
-Phases 1 + 2 are **behavior-preserving** for shaka's public API, modulo documented intentional wire-format changes that align shaka with CTA-5004 / CTA-5004-B and CML's spec-conformant output. Phase 3 is the load-bearing behavioral change — the manager's external surface stays compatible, but the internal state machine, sequence-number scope, and event-mode dispatch path all flow through CML's reporter.
-
-## What's vendored
-
-`third_party/cml-cmcd/` mirrors the CML repo's `libs/cmcd/src/` plus two shim files (`cml_utils.js`, `cml_sfv.js`):
-
-| Group | Files | Notes |
-|---|---|---|
-| Typedefs | 23 | TS interfaces ported as Closure `@typedef` records. |
-| Enums | 5 | `CmcdEventType`, `CmcdPlayerState`, `CmcdReportingMode`, `CmcdStreamingFormat`, `CmcdTransmissionMode`. |
-| Constants | 8 | Per-mode keysets, formatter map, header map, etc. |
-| Encoders | 14 | `encodeCmcd`, `toCmcdQuery`, `toCmcdHeaders`, `appendCmcdQuery`, `appendCmcdHeaders`, plus internals. |
-| Helpers | 4 | `prepareCmcdData`, `upConvertToV2`, `resolveVersion`, `groupCmcdHeaders`. |
-| Predicates | 6 | `isCmcdRequestKey`, `isCmcdEventKey`, etc. |
-| Reporter | 1 | `cmcd_reporter.js` (CmcdReporter class — used by Phase 3). |
-| Shims | 2 | `cml_utils.js` (uuid + URL helpers + dead-code `defaultRequester`); `cml_sfv.js` (RFC 8941 §4.1 SFV serializer). |
-| Legal | 3 | `LICENSE` (Apache 2.0), `NOTICE`, `SUMMARY.txt`. |
-
-CML pin: **`cmcd-v2.3.0` / commit `22390e35dfbbe1e53d15648d3aace99cdf71f9dd`**. See [`plans/cmcd-cml-refactor/cml-version.md`](plans/cmcd-cml-refactor/cml-version.md) for the full Phase 0 verification report.
-
-When shaka migrates to TypeScript ([#8262](https://github.com/shaka-project/shaka-player/issues/8262)), the vendored directory deletes and each `goog.require('cml.cmcd.X')` becomes `import { X } from '@svta/cml-cmcd'` — no other code changes.
-
-## Architectural decisions in the port
-
-These are judgment calls during sub-phase B+C; please weigh in:
-
-1. **`setInterval` whitelisted** in `build/conformance.textproto` for `third_party/cml-cmcd/cmcd_reporter.js`. The reporter calls `setInterval` directly for periodic time-interval event reporting. Alternatives considered: (a) patching the vendored reporter to use `shaka.util.Timer` (breaks verbatim parity, complicates per-bump diff workflow), (b) filing a CML upstream PR for injectable-timer support (delays Phase 1). Whitelist is pragmatic but means **Phase 3 tests can't inject a fake timer** — will need `jasmine.clock()` for interval testing.
-2. **`fetch` whitelisted** in `build/conformance.textproto` for `third_party/cml-cmcd/cml_utils.js`. Used by `cml.cmcd.defaultRequester` — dead code at runtime because the shaka adapter always supplies a custom `requester` via `NetworkingEngine`. Closure ADVANCED is expected to strip the dead path; the conformance check runs first.
-3. **`defaultRequester` relocated** from `CmcdReporter.ts` module scope into `cml_utils.js` as `cml.cmcd.defaultRequester`. Done to centralize the `fetch` whitelist scope to a single file. **Per-bump CML diff workflow needs to know** `defaultRequester` lives here, not in the reporter — otherwise CML 2.4.0+ bumps will look like the function vanished.
-
-## Wire-format changes (intentional)
-
-Three changes; all align shaka with CTA-5004-B and CML's spec-conformant output. Test assertions updated to match.
-
-**1. `nor` URLs become root-relative + V2 inner-list format.**
-
-- **V1**: `nor="next-seg.m4v"` (path-relative against request URL).
-- **V2**: `nor=("next-seg.m4v")` (RFC 8941 inner-list, root-relative against request origin per CTA-5004-B § 4.1).
-
-`cmcd_manager.js` no longer pre-relativizes `data.nor`; CML's `nor` formatter relativizes against `options.baseUrl` (request URL's origin). For event-mode reports sent to a different-origin collector, `nor` stays absolute.
-
-**2. `'ld'` and `'lh'` `StreamingFormat` values dropped.**
-
-CTA-5004 / CTA-5004-B define only `'d'` (DASH), `'h'` (HLS), `'s'` (Smooth), `'o'` (Other). `'ld'` and `'lh'` were from an old unreleased CMCD draft and are non-spec. **Wire change**: low-latency DASH content now emits `sf=d`; low-latency HLS now emits `sf=h`. `setLowLatency()` no longer mutates `sf_`; the LL flag is preserved for any external readers but has no effect on the encoded `sf` value.
-
-**3. V2 SFV-conformant encoding.**
-
-CML uses RFC 8941 Structured Field Values for V2 output; old shaka used a JSON-stringify-shaped quoting rule. Concrete differences:
-
-- **Token vs string formatting** for `e` (event type) and `sta` (player state) values. Old: `e="ps"`, `sta="s"`. New: `e=ps`, `sta=s`. Per CTA-5004-B these values are spec-defined single-character tokens; SFV tokens don't take quotes.
-- **`v=2` always present in V2 output.** Per CTA-5004-B § 4.1, V2 output MUST include `v`. Old shaka emitted `v` only when explicitly present in input data. CML's `prepareCmcdData` enforces this, even when the user filters `v` out via `includeKeys`.
-- **`ts` no longer in request-mode output.** Per CTA-5004-B `ts` is event-mode only. Old shaka emitted `ts=<timestamp>` in request-mode CMCD; CML's request-mode filter correctly drops it. (Event-mode and response-received reports continue to include `ts`.)
-
-## Behavior preserved otherwise
-
-The state machine, sequence numbers (`cmcdSequenceNumbers_` per-target counters), event timing, request/response routing, and the public `shaka.util.CmcdManager` API are unchanged. The `setLowLatency`, `setMediaElement`, `configure`, `reset`, `applyRequestData`, `applyResponseData`, `appendSrcData`, `appendTextTrackData` entry points retain their existing signatures and semantics. Phase 2 dedupes constants/enums; Phase 3 rewrites the state machine as a thin adapter around `CmcdReporter` and is the load-bearing behavioral change.
-
-## Implementation summary
-
-`shaka.util.CmcdManager` static encoders now delegate:
-
-- `serialize(data, options)` → `cml.cmcd.encodeCmcd(data, options)`.
-- `toQuery(data, options)` → `cml.cmcd.encodeCmcd(data, options)` (preserves shaka's "raw value, no `CMCD=` prefix" contract — CML's `toCmcdQuery` returns the prefixed form, which would break callers).
-- `toHeaders(data, options)` → `cml.cmcd.prepareCmcdData(data, options)` once on the full input, then bucketed into shaka's existing 4-shard `headerMap`, then `cml.cmcd.encodePreparedCmcd` per shard. Calling the high-level `encodeCmcd` per shard would re-run `prepareCmcdData` and re-add `v=2` to every non-empty shard.
-- `appendQueryToUri(uri, query)` retained as a `goog.Uri`-based adapter — CML's `appendCmcdQuery(url, cmcd, options)` takes a data object, not a pre-encoded query string, so direct delegation isn't possible. Phase 3 deletes call sites entirely.
-- `urlToRelativePath` deleted; the helper and its 9 unit tests are gone.
-
-A new private `getEncodeOptions_(uri, version, reportingMode)` static helper builds `cml.cmcd.CmcdEncodeOptions` objects at the four CMCD-encoding call sites: `appendSrcData`, `appendTextTrackData`, `sendCmcdRequest_` (event/response path), `applyCmcdDataToRequest_` (request path). It threads `this.config_.version` and the reporting mode (`CMCD_REQUEST_MODE` for request paths, `CMCD_EVENT_MODE` for `sendCmcdRequest_`).
-
-## Phase 2 implementation summary
-
-Pure dedupe — no behavioral change beyond what Phase 1 shipped. Single commit `67443aacb`.
-
-**7 internal shaka enums deleted** (none were `@export`ed, so deletion is internal-only):
-
-| Shaka (deleted) | Replacement | Notes |
-|---|---|---|
-| `ObjectType` | `cml.cmcd.CmcdObjectType` | 1:1 value match (9 entries) |
-| `Version` | `cml.cmcd.CMCD_V1` / `CMCD_V2` literals | Was a 2-entry enum wrapping `1` / `2` |
-| `StreamType` | `cml.cmcd.CmcdStreamType` | CML adds `LOW_LATENCY: 'll'`; harmless superset |
-| `CmcdMode` | `cml.cmcd.CmcdReportingMode` | Dropped unused `RESPONSE` value |
-| `CmcdKeys` | various CML key arrays | `V1Keys` → `CMCD_V1_KEYS`; `V2Common ∪ V2Request` → `CMCD_REQUEST_KEYS`; `V2Common ∪ V2Event` → `CMCD_REQUEST_KEYS ∪ CMCD_RESPONSE_KEYS ∪ CMCD_EVENT_KEYS`; `CmcdV2Events` → `Object.values(CmcdEventType)`; `CmcdV2PlayStates` → `Object.values(CmcdPlayerState)` |
-| `CmcdV2Constants` | inlined | `TIME_INTERVAL_DEFAULT_VALUE = 10` inlined as a magic number with a comment. CML uses `30`; Phase 3's `CmcdReporter` will adopt the CML default. |
-| `CmcdV2Keys` | inlined / aliased | `TIMESTAMP` inlined as the literal `'ts'`; `TIME_INTERVAL_EVENT` → `cml.cmcd.CMCD_EVENT_TIME_INTERVAL` |
-
-**`StreamingFormat` retained as a literal `@enum`** (not aliased to CML). Closure's `clutz` TypeScript-defs generator and shaka's `generateExterns.js` both reject `@export`ed `@enum`s whose RHS is anything other than an inline `ObjectExpression` with literal values. Workaround patterns (alias, per-key copy with `MemberExpression` values, `@const` instead of `@enum`) all hit the same wall. The 4 values match `cml.cmcd.CmcdStreamingFormat` exactly; a new `preserves value-identity with cml.cmcd.CmcdStreamingFormat` unit test asserts this so Phase 3 can rely on it. Internal type annotations (`sf_` private field, `getStreamFormat_` return type) refer to `cml.cmcd.CmcdStreamingFormat` directly; the `@export`ed `shaka.util.CmcdManager.StreamingFormat` is the public-facing form.
-
-**Permissive behavior changes from CML key-set adoption:**
-- V2 request mode now accepts `br`, `bsa`, `bsd`, `bsda`, `cs`, `dfa`, `nr`, `pb`, `sn` in `includeKeys` (previously rejected by shaka's narrower `V2RequestModeKeys`). All are CMCD V2 spec keys; shaka's omission was non-spec.
-- V2 request mode now rejects `ts` in `includeKeys` (was accepted previously). `ts` is event-only per CTA-5004-B; the encoder filtered it out anyway since Phase 1 sub-phase E B2 — this aligns the upstream `includeKeys` validator with the encoder filter.
-- Event-mode validation accepts a strict superset of what shaka's old `V2EventModeKeys` allowed.
-- `isValidEvent_` accepts CML's 17 event types instead of shaka's 10 (adds the 7 ad / skip / custom-event types). shaka doesn't emit these, so user-facing impact is nil.
-
-## Phase 3 implementation summary
-
-The behavioral rewrite. `lib/util/cmcd_manager.js` shrinks from 1580 LoC to ~700, becoming a thin adapter around `cml.cmcd.CmcdReporter`. The reporter owns CMCD state, encoding, key filtering, sequence numbering, and event-mode dispatch; the adapter translates shaka's request/response/player events into reporter calls. The bulk of the LoC win is in tests: ~3500 lines of wire-format coverage (Bucket A) deleted because that responsibility now lives in CML upstream; ~600 lines of adapter-glue + smoke (Bucket B/C) added.
-
-**Two commits:**
-1. `965ba69f8` — `refactor(cmcd): rewrite shaka.util.CmcdManager as thin adapter around CmcdReporter`. The full behavioral rewrite + externs renames + v2 re-exports + test rewrite + demo update.
-2. `43cc7f332` — `fix(cmcd): preserve video_ across reset() so configure() can rebuild reporter`. Smoke-surfaced bug: shaka keeps the video element attached across `unload()`/`load()` cycles, so the manager's `video_` field must NOT be cleared in `reset()` — otherwise a post-unload `configure(materialChange)` can't reconstruct the reporter.
-
-**Public-API renames** (experimental v2 surface in `shaka.extern.CmcdConfiguration`):
-- top-level `targets` → `eventTargets`
-- per-target `timeInterval` → `interval` (matches CML's field name)
-- per-target typedef gains `batchSize` and per-target `version` fields
-
-**New public re-exports** (literal-form `@export` per Phase 2's Closure-tooling constraint; value-identity unit tests assert parity with the corresponding `cml.cmcd.*` enums):
-- `shaka.util.CmcdManager.EventType` — 17 entries (superset of shaka's old 10).
-- `shaka.util.CmcdManager.PlayerState` — 10 entries (superset of shaka's old 4).
-
-**Wire-format changes inherited from CML alignment:**
-1. **`sn` shifts from 1-based to 0-based.** CML's reporter initializes `sn = 0`; old shaka started at `1`. Consumers parsing `sn` as a counter index must adjust.
-2. **Request-mode `sn` becomes a single global counter** (was per-target-hash, where header-vs-query distinct configs got distinct counters); resets on `sid` change. In practice shaka doesn't expose runtime mode switching, so the practical impact is mostly the `sid`-rotation reset semantic.
-3. **`CMCD_DEFAULT_TIME_INTERVAL` adopts CML's `30`** (was shaka's `10`) when the user does not specify a per-target `interval`. Pre-Phase-3, `setupEventModeTimeInterval_` defaulted to 10 seconds; Phase 3 routes through CML's reporter, which uses the v2-default of 30.
-
-**Adapter design choices worth flagging:**
-1. **`enabledKeys` defaults to all valid keys for the version** when the user's `includeKeys` is empty/missing. Without this expansion, CML's `createRequestReport` early-returns on an empty `enabledKeys` array — old shaka treated empty `includeKeys` as "include all", and existing user configs depend on that semantic.
-2. **`appendSrcData` / `appendTextTrackData` bypass the reporter** and call `cml.cmcd.appendCmcdQuery` directly with a synthesized CMCD object. `<video src=…>` and sidecar text-track loads can't carry custom request headers, so query-mode encoding is forced regardless of `useHeaders`. Per-request `sn` is omitted on this path.
-3. **Multi-URI requests** (alternate-CDN retry lists; rare) get the same CMCD encoding applied to every URI. The first URI is rewritten via `createRequestReport`; the encoded `CMCD=…` param is extracted and applied to the remaining URIs via URL parsing. All URIs share one `sn`.
-4. **`networkingEngine_` is read lazily** in `makeRequester_()` via `this.player_.getNetworkingEngine()`. No separate field — keeps the manager simple and avoids stale-reference issues if NetworkingEngine is recreated.
-5. **`m`/muted is event-only, not persistent state.** CTA-5004-B defines `m`/`um` as event types, not data keys; the adapter emits `MUTE`/`UNMUTE` events but does NOT call `update({m: …})`.
-6. **`reset()` preserves `video_`.** Shaka's lifecycle keeps the video element attached across `unload()`/`load()` cycles; only `detach()` releases it. Preserving `video_` is what lets a post-unload `configure(materialChange)` rebuild the reporter and re-attach event listeners on the same video element.
-
-**Event-mode dispatch via NetworkingEngine.** CmcdReporter takes a `requester: (req) => Promise<{status: number}>` callback as its second positional arg for dispatching event-mode reports. Shaka wires this to `NetworkingEngine.request(RequestType.TIMING, ...)` instead of raw `fetch`, so event-mode reports inherit auth/retry/filters — same as manifests and segments. **No new public config field needed**; users already control transport via NetworkingEngine plugins. CML's reporter constructs `method: 'POST'` with a string body (structured-fields encoded by `encodeCmcd`, joined by `'\n'`), which the adapter wraps via `shaka.util.StringUtils.toUTF8` before passing to NetworkingEngine.
-
-**Demo update.** Adds an `Event Targets (JSON)` text input that JSON-parses on change and `player.configure({cmcd: {eventTargets: [...]}})`s the result. Mirrors dash.js's `cmcd-v2.html` minimum scope. Version field converted to a numeric input.
-
-**Deferred follow-ups** (out of scope for this PR):
-- Dedicated `RequestType.CMCD_EVENT_REPORT` request type. Phase 3 uses `RequestType.TIMING`; a follow-up PR can add a dedicated type without changing the adapter contract.
-- Expanded public re-export surface (`CmcdObjectType`, `CmcdStreamType`, `CmcdHeaderField`, etc.). These stay internal under `cml.cmcd.*` until users have a documented need.
-- TypeScript migration (tracked in [#8262](https://github.com/shaka-project/shaka-player/issues/8262)). The vendored directory deletes when this lands.
-
-## Diff size (all three phases)
-
-- `third_party/cml-cmcd/`: 74 new JS files + LICENSE/NOTICE/SUMMARY (+5017 lines, Phase 1).
-- `lib/util/cmcd_manager.js`: +100 / −138 (Phase 1), +13 / −87 (Phase 2), and +~700 / −1580 (Phase 3 — full rewrite). Cumulative net −920 / +810.
-- `test/util/cmcd_manager_unit.js`: +107 / −140 (Phase 1), +12 / 0 (Phase 2), and +~880 / −4296 (Phase 3 rewrite). Cumulative net −3550 / +1000.
-- `externs/shaka/player.js`: experimental `CmcdConfiguration` / `CmcdTarget` typedef updates (Phase 3).
-- `lib/util/player_configuration.js`: `cmcd.targets` → `cmcd.eventTargets` default (Phase 3).
-- `demo/config.js`: `Event Targets (JSON)` input added (Phase 3).
-- `test/demo/demo_unit.js`: `cmcd.eventTargets` added to the array-typed-config exceptions set.
-- `build/conformance.textproto`: 2 entries added (`setInterval`, `fetch`).
-- `build/types/core`: 74 entries added for the vendored files.
-- `plans/cmcd-cml-refactor/`: design + verification docs.
-
-**Total (all three phases)**: ~90 files, ~+6500 / ~−4400. Net positive ~+2100 lines (mostly the vendored CML port; net delete in shaka-side code is dramatic — ~3700 LoC removed from `lib/util/cmcd_manager.js` + tests).
-
-(Plan estimated ~3000 lines for the port; actual is ~5000 because of (a) `cml_sfv.js` (~448 LoC RFC 8941 serializer shim — CML uses `@svta/cml-utils`'s SFV encoder, which we vendor inline since the shim doesn't ship as a separate package), (b) 8 spec-excluded files re-included as runtime dependencies, and (c) generous license/notice headers per Apache 2.0.)
-
-## Verification (all three phases)
-
-- [x] `python3 build/check.py --force` exits 0 (lint, conformance, types, spelling).
-- [x] `python3 build/all.py --force` exits 0 (full bundle build: dash/hls/compiled/ui/experimental, debug + release).
-- [x] `python3 build/test.py --filter Cmcd` — 57 / 57 pass (Phase 3 deletes ~125 wire-format tests now in CML, adds adapter glue + smoke).
-- [x] `python3 build/test.py --quick` — 2927 / 2927 pass (no regressions outside CMCD; 4 environmental skips on this branch are unrelated to this work).
-- [x] Demo smoke test on `bbb-dark-truths/dash.mpd` — V1+query, V2+query, V2+headers (with `unload→configure({useHeaders: true})→load` cycle) all emit correct CMCD output. Sequence numbers 0-based, reset on `sid` change. `v=2` only in `CMCD-Session` shard. Public re-exports (`EventType`, `PlayerState`, `StreamingFormat`) all readable at runtime from the compiled bundle. Zero CMCD-related console errors.
-
-## Plan / spec docs
-
-This PR includes the design + verification docs under `plans/cmcd-cml-refactor/`:
-
-- [`spec.md`](plans/cmcd-cml-refactor/spec.md) — canonical spec, file lists, type translations, encoding rules, lifecycle tables.
-- [`plan.md`](plans/cmcd-cml-refactor/plan.md) — phase-by-phase implementation plan with sub-phase landing notes.
-- [`cml-version.md`](plans/cmcd-cml-refactor/cml-version.md) — Phase 0 CML API verification report (pin SHA, method-by-method confirmation against CML source).
-
-These remain in the repo as Phase 2 + 3 reference. They can be deleted once Phase 3 merges if maintainers prefer.
-
-## Commit list (for reviewer convenience)
-
-**Phase 0 — CML verification (5 commits, docs-only):**
-```
-79702531e docs(cmcd): add Phase 0 CML version pin + API verification report
-33c7c78ab docs(cmcd): fix doc cross-references in Phase 0 verification report
-be97afe47 docs(cmcd): restructure Phase 0 doc-update checklist into plan vs spec lists
-6a851a2d8 docs(cmcd): apply Phase 0 verification findings to spec and plan
-```
-
-**Phase 1 — Vendor port + encoder delegation (~20 commits):**
-```
-a8d855179 chore(third_party): add cml-cmcd vendoring skeleton
-0027abbe1 chore(cmcd): port cml-cmcd type definitions as closure typedefs
-ae92000c7 chore(cmcd): port cml-cmcd enums to closure
-c4d84a2d8 chore(cmcd): port cml-cmcd constants to closure
-1e539e703 chore(cmcd): port cml-cmcd uuid shim
-e6cb2563d chore(cmcd): wire phase 1A port into build, add doc consistency
-1b51edfc5 chore(cmcd): vendor cml-utils + cml-sfv shims for encoder port
-7a27aaacf chore(cmcd): port CMCD_FORMATTER_MAP (deferred from sub-phase A)
-3d6d5ae27 chore(cmcd): port cml-cmcd encoders to closure
-d9aa2f9a1 chore(cmcd): port cml-cmcd version-resolution helpers
-9bcf6614e fix(cmcd): restore typedef requireType in cmcd.js/event/response, polish cml_sfv
-988712ea6 chore(cmcd): port CmcdReporter-only typedefs (deferred from sub-phase A)
-3de73b29b chore(cmcd): port cml-cmcd CmcdReporter to closure
-d682bb1bb fix(cmcd): tighten transmissionMode typedef, unify ?? fallbacks in reporter
-0f69e7f0e docs(cmcd): add Phase 1 sub-phase A-C completion status to plan
-d8d614ce3 refactor(cmcd): delegate encoding to vendored cml-cmcd
-adfdfab05 fix(cmcd): drop non-spec 'ld'/'lh' StreamingFormat values
-4aa5ff76b docs(cmcd): mark Phase 1 sub-phase D complete in plan
-27cd16907 fix(cmcd): thread version/reportingMode + prepare-once for header shards
-b94f7ebca test(cmcd): update assertions for CML wire-format alignments
-0e3883181 docs(cmcd): mark Phase 1 sub-phase E complete in plan
-d663f6c12 docs(cmcd): mark Phase 1 sub-phase F complete; add all-phases PR draft
-```
-
-**Phase 2 — Adopt CML constants/enums (1 commit):**
-```
-67443aacb refactor(cmcd): adopt CML constants/enums; delete shaka duplicates
-```
-
-**Phase 3 — Adapter rewrite (2 commits):**
-```
-965ba69f8 refactor(cmcd): rewrite shaka.util.CmcdManager as thin adapter around CmcdReporter
-43cc7f332 fix(cmcd): preserve video_ across reset() so configure() can rebuild reporter
-```
-
-The first 4 commits (`79702531e`–`6a851a2d8`) are Phase 0 docs only and could be split off as a docs-only PR if maintainers prefer. The rest are implementation.
diff --git a/plans/cmcd-cml-refactor/spec.md b/plans/cmcd-cml-refactor/spec.md
deleted file mode 100644
index e0ad729552..0000000000
--- a/plans/cmcd-cml-refactor/spec.md
+++ /dev/null
@@ -1,751 +0,0 @@
-# CMCD refactor: replace shaka-player's custom integration with `@svta/cml-cmcd`
-
-Date: 2026-04-27
-Status: Approved design, ready for implementation planning
-Tracking: [shaka-player#3619](https://github.com/shaka-project/shaka-player/issues/3619), [common-media-library#40](https://github.com/streaming-video-technology-alliance/common-media-library/issues/40)
-
-## Context
-
-Shaka Player ships a custom CMCD (Common Media Client Data, CTA-5004) integration:
-
-- [`lib/util/cmcd_manager.js`](lib/util/cmcd_manager.js) — 1704 lines, supports CMCD v1 and v2 in request/response/event modes.
-- [`test/util/cmcd_manager_unit.js`](test/util/cmcd_manager_unit.js) — 4317 lines, mostly testing CMCD wire-format correctness.
-- [`externs/cmcd.js`](externs/cmcd.js) — `CmcdData` typedef.
-- [`externs/shaka/player.js`](externs/shaka/player.js) — `shaka.extern.CmcdConfiguration` and `shaka.extern.CmcdTarget` typedefs.
-
-Other major adaptive players (hls.js, dash.js) have already migrated to the
-[`@svta/cml-cmcd`](https://github.com/streaming-video-technology-alliance/common-media-library/tree/main/libs/cmcd)
-package as the shared reference implementation. See
-[hls.js PR #7725](https://github.com/video-dev/hls.js/pull/7725) for the pattern
-this design follows.
-
-## Motivation
-
-This refactor pursues three explicit goals:
-
-1. **Standards conformance / single source of truth.** CML is the shared
-   reference implementation for CMCD across players. Tracking it gets shaka's
-   CMCD output spec-aligned automatically as v2 finalizes.
-2. **Reduce maintenance burden.** ~6000 lines of CMCD code (manager + tests)
-   carry the full encoding, validation, and state-machine surface. Most of that
-   logic is identical in CML. Maintenance can move upstream where multiple
-   players amortize it.
-3. **Submit upstream PR-friendly to shaka maintainers.** No new runtime npm
-   dependency (preserves shaka's hard-won "zero runtime deps" property), no
-   build-system upheaval, incremental phasing for review.
-
-## Constraints
-
-These are non-negotiable inputs to the design:
-
-1. **Zero runtime npm dependencies.** [AGENTS.md](AGENTS.md) calls this out as
-   a "hard-won property... do not introduce any." Direct npm consumption of
-   `@svta/cml-cmcd` is not on the table.
-2. **Closure Compiler ADVANCED_OPTIMIZATIONS.** All source uses
-   `goog.provide`/`goog.require` with JSDoc type annotations. Externs define
-   public types.
-3. **TypeScript migration is on the horizon.**
-   [shaka-player#8262](https://github.com/shaka-project/shaka-player/issues/8262)
-   tracks shaka's planned migration to TypeScript (P2, Backlog as of
-   2026-04). Whatever closure-era infrastructure we build is **transitional**
-   and gets deleted on migration day. Avoid building durable infrastructure
-   that exists only to bridge closure to a TS package.
-4. **Public API back-compat.** `shaka.extern.CmcdConfiguration`,
-   `shaka.extern.CmcdTarget`, and the `CmcdData` typedef are consumed by
-   shaka users. The `shaka.util.CmcdManager.StreamingFormat` enum is
-   `@export`ed (see [`cmcd_manager.js:1610`](lib/util/cmcd_manager.js:1610)).
-   v1 fields and v2 fields outside the experimental flag must keep their
-   existing names. v2-only fields flagged experimental may be renamed.
-
-## Decision summary
-
-- **Strategy: Manual vendored port** of `@svta/cml-cmcd` into
-  `third_party/cml-cmcd/`, following the
-  [`third_party/closure-uri/`](third_party/closure-uri/) precedent.
-- **Scope: Full replacement.** `shaka.util.CmcdManager` becomes a thin
-  shaka-specific adapter wrapping `cml.cmcd.CmcdReporter`. State tracking,
-  encoding, key filtering, sequence numbers, and event timing all move to the
-  reporter.
-- **Phasing: Three sequential PRs** (vendor + delegate encoding → dedupe
-  constants → adapter rewrite). Each phase is independently reviewable and
-  bisectable.
-- **Test ownership boundary:** CMCD wire-format tests move to / live in CML
-  upstream. Shaka keeps shaka-specific glue tests + a small end-to-end smoke
-  set.
-
-Rejected alternatives:
-
-- **CML emits a closure-friendly distribution** (option A in brainstorm).
-  Rejected because shaka's TS migration would orphan the closure target in
-  CML; not worth the upstream burden.
-- **Build-time TS-to-Closure transpiler in shaka** (option B). Rejected
-  because tsickle is archived (last push 2024-05) and a custom transformer
-  would cost ~500-1500 LoC of throwaway tooling. CML's TS uses `as const`
-  enum patterns, type-only imports, intersections, and `ValueOf<>` generics
-  that aren't trivial to mechanically translate.
-- **Wait for shaka's TS migration before doing CMCD work.** Rejected because
-  the migration is in Backlog with no concrete timeline; CMCD work shouldn't
-  block on it.
-
-## Architecture
-
-Three layers, each with one job:
-
-```
-┌────────────────────────────────────────────────────────────────┐
-│ shaka public API (UNCHANGED except experimental v2 renames)    │
-│   shaka.extern.CmcdConfiguration   shaka.extern.CmcdTarget     │
-│   externs/cmcd.js (CmcdData typedef)                           │
-│   shaka.util.CmcdManager.StreamingFormat (the only @export)    │
-└────────────────────────────────────────────────────────────────┘
-                              ▲
-                              │ (back-compat preserved)
-┌────────────────────────────────────────────────────────────────┐
-│ lib/util/cmcd_manager.js (REFACTORED, ~250 lines target)       │
-│   Thin shaka-specific adapter:                                 │
-│   - NetworkingEngine integration (applyRequestData /           │
-│     applyResponseData) — public method signatures unchanged    │
-│   - <video> + Player event listeners → reporter.update(...)   │
-│     and reporter.recordEvent(...) (with deduplication)         │
-│   - Maps shaka.extern.CmcdConfiguration → CmcdReporterConfig   │
-│   - Wires CmcdReporter's `requester` callback to               │
-│     NetworkingEngine for event-mode reports (POST + body)      │
-└────────────────────────────────────────────────────────────────┘
-                              │
-                              │ goog.require('cml.cmcd.*')
-                              ▼
-┌────────────────────────────────────────────────────────────────┐
-│ third_party/cml-cmcd/ (NEW, vendored from CML)                 │
-│   Closure-annotated JS port of @svta/cml-cmcd source           │
-│   Namespace: cml.cmcd.* (mirrors CML's package shape)          │
-│   SUMMARY.txt, LICENSE, NOTICE                                 │
-└────────────────────────────────────────────────────────────────┘
-```
-
-**Future-proofing.** Choosing namespace `cml.cmcd.*` so it mirrors CML's
-actual export surface. When shaka migrates to TypeScript:
-`goog.require('cml.cmcd.CmcdReporter')` becomes
-`import { CmcdReporter } from '@svta/cml-cmcd'`, and the entire
-`third_party/cml-cmcd/` directory deletes — no other code changes.
-
-## The vendored port (`third_party/cml-cmcd/`)
-
-### Subset to port
-
-Pulled from `@svta/cml-cmcd` v2.3.0 source at
-`libs/cmcd/src/`. Files map one-to-one (CamelCase TS file → snake_case JS file).
-
-**Included (~25 files):**
-
-| Category | Files |
-|---|---|
-| Reporter (the main class) | `CmcdReporter.ts` |
-| Encoders | `encodeCmcd.ts`, `encodePreparedCmcd.ts`, `prepareCmcdData.ts`, `toCmcdHeaders.ts`, `toCmcdQuery.ts`, `toCmcdUrl.ts`, `toCmcdValue.ts`, `appendCmcdHeaders.ts`, `appendCmcdQuery.ts`, `toPreparedCmcdHeaders.ts`, `ensureHeaders.ts` |
-| Helpers | `upConvertToV2.ts`, `resolveVersion.ts` |
-| Constants | `CMCD_DEFAULT_TIME_INTERVAL.ts`, `CMCD_EVENT_KEYS.ts`, `CMCD_FORMATTER_MAP.ts`, `CMCD_HEADER_MAP.ts`, `CMCD_INNER_LIST_KEYS.ts`, `CMCD_KEYS.ts`, `CMCD_KEY_TYPES.ts`, `CMCD_MIME_TYPE.ts`, `CMCD_PARAM.ts`, `CMCD_REQUEST_KEYS.ts`, `CMCD_RESPONSE_KEYS.ts`, `CMCD_STRING_LENGTH_LIMITS.ts`, `CMCD_TOKEN_VALUES.ts`, `CMCD_V1.ts`, `CMCD_V1_KEYS.ts`, `CMCD_V2.ts` |
-| Enums | `CmcdObjectType.ts`, `CmcdStreamingFormat.ts`, `CmcdStreamType.ts`, `CmcdPlayerState.ts`, `CmcdEventType.ts`, `CmcdReportingMode.ts`, `CmcdTransmissionMode.ts`, `CmcdHeaderField.ts` |
-| Type definitions (typedefs in closure) | `Cmcd.ts`, `CmcdData.ts`, `CmcdRequest.ts`, `CmcdResponse.ts`, `CmcdEvent.ts`, `CmcdReportConfig.ts`, `CmcdEventReportConfig.ts`, `CmcdReporterConfig.ts`, `CmcdEncodeOptions.ts`, `CmcdRequestReport.ts`, `CmcdRequestReportConfig.ts`, `CmcdFormatter.ts`, `CmcdFormatterMap.ts`, `CmcdFormatterOptions.ts`, `CmcdHeaderKey.ts`, `CmcdHeaderMap.ts`, `CmcdHeaderValue.ts`, `CmcdKey.ts`, `CmcdValue.ts`, `CmcdRequestKey.ts`, `CmcdCustomKey.ts`, `CmcdCustomValue.ts`, `CmcdObjectTypeList.ts`, `CmcdV1.ts`, `CmcdVersion.ts` |
-
-**Excluded (explicitly skipped):**
-
-| Category | Files | Why |
-|---|---|---|
-| Decoders | `decodeCmcd.ts`, `fromCmcdHeaders.ts`, `fromCmcdQuery.ts`, `fromCmcdUrl.ts`, `groupCmcdHeaders.ts` | Players emit CMCD; they don't parse it. |
-| Validators | `validateCmcd.ts`, `validateCmcdEventReport.ts`, `validateCmcdEvents.ts`, `validateCmcdHeaders.ts`, `validateCmcdKeys.ts`, `validateCmcdRequest.ts`, `validateCmcdStructure.ts`, `validateCmcdValues.ts`, `CmcdValidationIssue.ts`, `CmcdValidationOptions.ts`, `CmcdValidationResult.ts`, `CmcdValidationSeverity.ts`, `CmcdDataValidationResult.ts`, `CmcdEventsValidationResult.ts`, `mergeValidationResults.ts`, `isValid.ts` | Tooling-only; large; halves port size. Add later only if shaka adds a debug-mode self-check. |
-| Predicates | `isCmcdCustomKey.ts`, `isCmcdEventKey.ts`, `isCmcdRequestKey.ts`, `isCmcdResponseReceivedKey.ts`, `isCmcdV1Data.ts`, `isCmcdV1Key.ts`, `isCmcdV2Data.ts`, `isTokenField.ts` | Tooling-only. |
-
-### `@svta/cml-utils` dependency handling
-
-CML's CMCD package depends on `@svta/cml-utils` for `uuid()`, `HttpRequest`,
-`HttpResponse`, and `ValueOf<>`. Type-only imports (`HttpRequest`,
-`HttpResponse`, `ValueOf<>`) erase during conversion. Only one runtime
-dependency remains: `uuid()`, called at one site (`createCmcdReporterConfig`'s
-default for `sid`).
-
-**Approach:** Vendor a tiny `third_party/cml-cmcd/cml_utils.js` (`goog.provide('cml.cmcd.uuid')`)
-shimming `crypto.randomUUID()` (already polyfilled in
-[`lib/polyfill/random_uuid.js`](lib/polyfill/random_uuid.js)). The vendored
-`CmcdReporter` source stays **verbatim** to upstream CML, which makes per-bump
-diffs trivial.
-
-The shaka adapter always sets `sid` explicitly when building
-`CmcdReporterConfig` (drawn from `shaka.extern.CmcdConfiguration.sessionId` or
-generated via shaka's own UUID). The reporter's default-`sid` codepath is dead
-at runtime and closure-stripped.
-
-This is invisible at the swap boundary: `goog.require('cml.cmcd.CmcdReporter')`
-→ `import { CmcdReporter } from '@svta/cml-cmcd'`. Post-migration, CML's
-transitive dep on `@svta/cml-utils` is internal to the npm package; shaka
-never imports from cml-utils directly.
-
-### File naming and namespace conventions
-
-- TS file `libs/cmcd/src/CmcdReporter.ts` → JS file `third_party/cml-cmcd/cmcd_reporter.js`.
-- `goog.provide('cml.cmcd.CmcdReporter')` — class/symbol name preserved, scoped under `cml.cmcd.*`.
-- TS `import { X } from './Y.ts'` → closure `goog.require('cml.cmcd.Y')`.
-- One exception: utility module `cml_utils.js` provides `cml.cmcd.uuid`.
-
-### `SUMMARY.txt` format
-
-Extends the [`third_party/SUMMARY.txt`](third_party/SUMMARY.txt) precedent:
-
-```
-cml-cmcd
-  Common Media Library CMCD encoder + reporter, v2.3.0,
-  by Streaming Video Technology Alliance / Casey Occhialini et al.
-  Apache 2.0 license.
-  https://github.com/streaming-video-technology-alliance/common-media-library
-    /tree/main/libs/cmcd
-  Source npm: @svta/cml-cmcd
-
-  TRANSITIONAL: This vendored port exists because shaka-player uses Closure
-  Compiler. When shaka migrates to TypeScript (issue #8262), delete this
-  directory and replace `goog.require('cml.cmcd.X')` with
-  `import { X } from '@svta/cml-cmcd'`.
-
-  Local mods:
-    - TypeScript source converted to Closure-annotated JS by hand
-    - Type-only imports erased; replaced with local closure typedefs
-    - Decoders (decodeCmcd, fromCmcd*) omitted: shaka emits CMCD only
-    - Validators (validateCmcd*, isCmcd*) omitted: tooling-only utilities
-    - cml-utils dep removed: shaka adapter always sets `sid` explicitly;
-      a 5-line cml_utils.js shim provides `uuid` for any dead default paths
-```
-
-`LICENSE` and `NOTICE` files copied from CML; both Apache 2.0 (matches shaka).
-
-### Build integration
-
-- `third_party/cml-cmcd/*.js` files added to [`build/types/core`](build/types/core)
-  alongside the existing `+../../lib/util/cmcd_manager.js` entry. CMCD remains in
-  the core build variant.
-- Any new vocabulary that fails the spell-checker added to
-  [`project-words.txt`](project-words.txt).
-
-## The shaka-side adapter ([`lib/util/cmcd_manager.js`](lib/util/cmcd_manager.js))
-
-Target size: ~250 lines (down from 1704). Three responsibilities:
-
-### 1. Lifecycle and player wiring
-
-- Construct `cml.cmcd.CmcdReporter` on first `configure(config)` call.
-  **Reporter is always-on**: even when no `eventTargets` are configured, the
-  reporter is the unified path for request-mode encoding (via
-  `createRequestReport`). When `eventTargets` are present, the same reporter
-  also batches and dispatches event-mode reports.
-- Call `reporter.start()` after construction to begin time-interval timers
-  for any configured event targets.
-- On `reset()`: call `reporter.stop(true)` (where `true` = flush pending
-  events before stopping), null out the reporter, remove all `<video>`
-  and player event listeners.
-- On `configure()` with materially-changed config: call `stop(true)` on
-  the old reporter, then construct + `start()` on a new one.
-- Subscribe to `<video>` events and `shaka.Player` events; translate state
-  changes to `reporter.update(...)` and `reporter.recordEvent(...)` calls
-  (see table below).
-
-### 2. Request/response interception
-
-Existing public methods preserved with same signatures:
-
-```js
-applyRequestData(type, request, context)
-applyResponseData(type, response, context)
-```
-
-`applyRequestData` flow:
-
-1. Adapter extracts shaka-specific fields:
-   - `objectType` ← `RequestType` + `segment.type`/`segment.mimeType`
-   - `bitrate` ← `segmentRef.variant.bandwidth`
-   - `duration` ← `segmentRef.endTime - segmentRef.startTime`
-   - `topBitrate` ← player ABR / variant constraints
-   - `rtp` ← `bitrate × config.rtpSafetyFactor` (computed in adapter; CML's
-     reporter doesn't know about a safety factor)
-2. Adapter constructs the CMCD data object, applying v2 encoding rules:
-   - **Inner-list keys** (`br`, `tb`, `bl`, `mtp`, `nor`) wrap their values
-     in single-element arrays when `version >= 2` per CMCD v2 Structured
-     Fields encoding: `data.br = [bitrate]`, `data.bl = [bufferLength]`,
-     `data.tb = [topBitrate]`, `data.mtp = [throughputKbps]`,
-     `data.nor = [nextUrl]`. For v1, these stay as scalars.
-   - **NaN guards**: `bl`, `tb`, `mtp` may be `NaN` early in playback
-     (buffer not yet established, no top variant chosen, throughput
-     estimator not seeded). Adapter checks `Number.isFinite(...)` before
-     including these keys; otherwise omits. Required to prevent Structured
-     Fields serialization errors in CML's encoder.
-3. Adapter calls `reporter.createRequestReport(request, data)`. CML returns
-   the original request augmented with applied CMCD encoding (CML signature:
-   `R & CmcdRequestReport<R['customData']>` — returns a new object derived
-   from the input, not in-place mutation).
-4. Adapter copies the CMCD-applied fields (`uris`, `headers`) from CML's
-   returned report back onto shaka's `request` object — preserving shaka's
-   existing in-place-mutation contract for `applyRequestData` callers.
-
-`v=1` field is omitted from CMCD output per spec (v1 is the default
-interpretation if `v` is absent). CML's encoders handle this internally;
-adapter does not need to filter explicitly.
-
-`nor` (next object request) URL relativization is a **deliberate
-behavioral change**: shaka's existing `urlToRelativePath` produced
-**path-relative** URLs; CML uses `url.origin` as `baseUrl` to produce
-**root-relative** URLs. This aligns shaka's output with CML's
-spec-conformant behavior. Flag this in the Phase 1 PR description as an
-intentional wire-format change (consumers parsing `nor` server-side may
-need to adjust path-resolution logic).
-
-`applyResponseData` flow:
-
-1. Adapter measures `ttfb`/`ttlb` via existing `requestTimestampMap_` mechanism.
-2. Adapter calls `reporter.recordResponseReceived(response, data)`. CML's
-   signature is `recordResponseReceived(response: HttpResponse, data:
-   Partial<Cmcd> = {})` — both args are CMCD-shaped, not the flat
-   `{ttfb, ttlb, rc, url}` shape. Two valid call patterns:
-   - **Primary path** (let CML derive): synthesize a `ResourceTiming`
-     object on `response.resourceTiming` (`{startTime, responseStart,
-     duration}`); CML auto-derives `ts`, `ttfb`, `ttlb`. `rc` comes from
-     `response.status`. `url` comes from `response.request.url`.
-   - **Override path:** pass `{ttfb, ttlb, rc, url}` (or any subset) as
-     the `data` argument. Override values win over auto-derived ones.
-   Adapter is free to mix: e.g., supply `resourceTiming` for `ts` while
-   passing pre-computed `ttfb`/`ttlb` from `requestTimestampMap_`.
-3. `recordResponseReceived` returns `void` — no fields to copy back to
-   `response`. Reporter buffers response data for the next emission
-   opportunity (and internally fires the v2 `rr` "response received"
-   event when configured).
-
-The shaka-specific extraction helpers
-(`getObjectType_`, `getBitrate_`, `getDuration_`, `getTopBitrate_`,
-`getStreamFormat_`) **stay in the adapter**. They encode "how to read
-shaka's variant/stream/segment shapes" — shaka-specific knowledge.
-
-What goes away from the manager: all encoding logic, key filtering,
-header/query construction, sequence-number tracking, event-timer code, mode
-selection, MSD computation, the various `applyRequest_`/`applyManifestData`
-private methods.
-
-### 3. Configuration translation
-
-One function `toReporterConfig_(shakaCmcdConfig)` performs field renames and
-shape conversion:
-
-| `shaka.extern.CmcdConfiguration` (post-rename) | `cml.cmcd.CmcdReporterConfig` |
-|---|---|
-| `enabled: boolean` | (gate at adapter level — adapter no-ops when `false`) |
-| `useHeaders: boolean` | `transmissionMode: CMCD_HEADERS \| CMCD_QUERY` |
-| `sessionId: string` | `sid: string` (always set explicitly) |
-| `contentId: string` | `cid: string` |
-| `rtpSafetyFactor: number` | (adapter uses to compute `rtp` per request) |
-| `includeKeys: Array<CmcdKey>` | `enabledKeys: Array<CmcdKey>` |
-| `version: 1\|2` | `version: CMCD_V1 \| CMCD_V2` |
-| **`eventTargets`** *(was `targets`, experimental rename)* | `eventTargets` |
-| Per-target: **`includeKeys`** *(was `enabledKeys`, experimental rename)* | Per-target: `enabledKeys` |
-
-The per-target rename mirrors hls.js PR #7725's pattern:
-`Omit<CmcdEventReportConfig, 'enabledKeys'> & { includeKeys?: CmcdKey[] }`.
-shaka users see `includeKeys` consistently (top-level and per-target); CML
-internals see `enabledKeys` per-target.
-
-The experimental flag on shaka's CMCD v2 config (see
-[`externs/shaka/player.js:2810-2818`](externs/shaka/player.js)) authorizes
-these renames. v1 fields keep their existing names.
-
-**Per-target `eventTargets[]` field shape.** Each entry in `eventTargets`
-configures one event-reporting endpoint. Shape (post-rename):
-
-| Per-target field | Type | Purpose |
-|---|---|---|
-| `url` | `string` | Endpoint URL for CMCD event reports |
-| `events` | `Array<CmcdEventType>` | Which events trigger reports (e.g., `[PLAY_STATE, ERROR, RESPONSE_RECEIVED]`); empty / undefined = none |
-| `interval` | `number` *(seconds)* | Periodic time-interval reports (`0` disables; CML default `CMCD_DEFAULT_TIME_INTERVAL = 30`). Field name matches CML's `CmcdEventReportConfig.interval`. |
-| `batchSize` | `number` | Number of events to batch before dispatch (default `1` = no batching) |
-| `includeKeys` | `Array<CmcdKey>` *(was `enabledKeys`)* | Subset of CMCD keys to include in this target's reports |
-| `version` | `1 \| 2` | Per-target version override; defaults to top-level `version` |
-
-Shaka maps to CML's `CmcdEventReportConfig` shape:
-`Omit<CmcdEventReportConfig, 'enabledKeys'> & {includeKeys?: CmcdKey[]}`,
-matching hls.js PR #7725's pattern. The adapter renames `includeKeys` →
-`enabledKeys` per-entry when constructing the reporter config.
-
-Update [`externs/shaka/player.js`](externs/shaka/player.js)
-`shaka.extern.CmcdTarget` typedef to reflect this shape; existing fields
-in the typedef (e.g., `events`) stay; renamed fields are
-`enabledKeys` → `includeKeys` and `timeInterval` → `interval` (matches
-CML's `CmcdEventReportConfig`).
-
-### Player state ↔ reporter state mapping
-
-State mutation and event emission use **two distinct reporter methods**:
-
-- `reporter.update(partialState)` — mutates persistent state; the next
-  emitted payload reflects the change.
-- `reporter.recordEvent(eventType, data)` — emits a discrete v2 event.
-
-Many state transitions require **both**: `update()` to persist the new
-state, then `recordEvent()` to emit a v2 event noting the transition.
-
-| shaka event/signal | reporter calls |
-|---|---|
-| Buffering becomes true | `update({playerState: REBUFFERING})` + `recordEvent(PLAY_STATE)` |
-| Buffering becomes false | `update({playerState: PLAYING})` + `recordEvent(PLAY_STATE)` |
-| Pause | `update({playerState: PAUSED})` + `recordEvent(PLAY_STATE)` |
-| Seeking | `update({playerState: SEEKING})` + `recordEvent(PLAY_STATE)` |
-| Ended | `update({playerState: ENDED})` + `recordEvent(PLAY_STATE)` |
-| Fatal error | `update({playerState: FATAL_ERROR})` + `recordEvent(ERROR)` |
-| Variant switch (bitrate change) | `update({br: [newBitrate]})` + `recordEvent(BITRATE_CHANGE)` |
-| Content ID changes | `update({cid: newId})` (CML emits the v2 `c` event internally) |
-| Visibility → backgrounded | `update({backgrounded: bool})` (CML emits the v2 `b` event internally) |
-| Mute | `update({muted: true})` + `recordEvent(MUTE)` |
-| Unmute | `update({muted: false})` + `recordEvent(UNMUTE)` |
-| Throughput estimate update | `update({mtp: [bandwidthKbps]})` |
-
-**Streaming format and low-latency.** `sf` reflects the manifest type only
-(`'d'`/`'h'`/`'s'`/`'o'`) — not the low-latency state. shaka previously
-emitted `'ld'`/`'lh'` for LL DASH/HLS, but those values are not in
-CTA-5004 or CTA-5004-B; CML correctly omits them. Phase 1 drops the LL
-mutation in shaka's `setLowLatency` so that LL DASH emits `sf=d` and LL
-HLS emits `sf=h`. This is a wire-format change called out alongside
-`nor` URL relativization in the Phase 1 PR description.
-
-Also note manifest type is set once at load time and rarely changes; the
-adapter feeds `streamingFormat` via `update()` from the manifest parser,
-not from a `setLowLatency` callback.
-
-**Player-state deduplication.** Adapter tracks the last-emitted
-`playerState` and skips both `update` and `recordEvent` when the new state
-matches. Without this, `<video>` event listeners can fire repeatedly on
-stable states (e.g., `playing` after every minor stall), spamming the
-reporter and downstream targets:
-
-```js
-// in CmcdManager
-setPlayerState_(state) {
-  if (this.lastPlayerState_ === state) return;
-  this.lastPlayerState_ = state;
-  this.reporter_.update({playerState: state});
-  this.reporter_.recordEvent(cml.cmcd.CmcdEventType.PLAY_STATE);
-}
-```
-
-MSD is computed internally by `CmcdReporter`; the adapter does not feed it.
-
-### Public-API back-compat details
-
-- **`shaka.util.CmcdManager.StreamingFormat`** stays available, implemented
-  as a re-export alias of `cml.cmcd.CmcdStreamingFormat`. `@export`
-  annotation preserved. Spec-conformant values: `'d'`, `'h'`, `'s'`, `'o'`.
-  shaka's previously-shipped non-spec values `'ld'` (LL-DASH) and `'lh'`
-  (LL-HLS) — from an old unreleased CMCD draft, not in CTA-5004 or
-  CTA-5004-B — are dropped in Phase 1. Wire-format change: LL DASH emits
-  `sf=d`, LL HLS emits `sf=h`.
-- **`shaka.util.CmcdManager.{ObjectType,Version,StreamType,CmcdKeys,CmcdV2Constants,CmcdV2Keys,CmcdMode}`**
-  are all internal-only (no `@export`). Deleted in Phase 2; references rewritten to `cml.cmcd.*`.
-- **`externs/cmcd.js`** (`CmcdData` typedef): kept as the public-facing typedef
-  shape. Internally, the adapter and vendored port use `cml.cmcd.CmcdData`.
-  The two are structurally equivalent.
-- **`shaka.extern.CmcdConfiguration`** typedef: `targets` field renamed to
-  `eventTargets`; `shaka.extern.CmcdTarget` typedef gets `enabledKeys` →
-  `includeKeys` rename. Both are experimental-flagged so breaking change
-  is acceptable.
-
-**New public re-exports for v2 configuration.** Shaka users configuring
-`eventTargets[].events` need access to the `CmcdEventType` enum (otherwise
-they'd have to hardcode magic strings like `'ps'`, `'e'`, `'rr'`). Minimum
-re-exports added to the existing `shaka.util.CmcdManager` class scope (no
-new namespace; consistent with where `StreamingFormat` already lives):
-
-| Re-exported symbol | From CML | Purpose |
-|---|---|---|
-| `shaka.util.CmcdManager.EventType` | `cml.cmcd.CmcdEventType` | Configure `eventTargets[].events` |
-| `shaka.util.CmcdManager.PlayerState` | `cml.cmcd.CmcdPlayerState` | Reading player-state field externally |
-
-Both are `@export`ed string-enum aliases of CML symbols (string values
-identical, names match). Existing
-`shaka.util.CmcdManager.StreamingFormat` stays where it is for back-compat.
-
-Other CML enums and constants (`CmcdObjectType`, `CmcdStreamType`,
-`CmcdHeaderField`, `CMCD_V1`, `CMCD_V2`, key arrays) stay internal under
-`cml.cmcd.*` until users have a documented need; shaka maintainers may
-expand the re-export surface in follow-up PRs based on user feedback. This
-is a more conservative public-API expansion than hls.js's
-`exports-named.ts` re-exports — appropriate for shaka's generally
-conservative API surface.
-
-### Event-mode dispatch via NetworkingEngine
-
-`CmcdReporter`'s constructor takes a `requester: (req) =>
-Promise<{status: number}>` callback as its **second positional argument**
-(not a `CmcdReporterConfig` field) for dispatching event-mode reports:
-`new CmcdReporter(reporterConfig, requesterFn)`. **Event-mode transport
-is HTTP POST with a body** — CML constructs each event request as
-`method: 'POST'` with the encoded CMCD payload in the body (per dash.js
-PR #4816's `Constants.CMCD_MODE_BODY` precedent and CML's reporter source).
-This is distinct from request-mode encoding (which mutates an existing
-request's URL or headers); event mode emits new requests to dedicated
-event-target URLs.
-
-Shaka adapter wires `requester` to `NetworkingEngine` rather than raw `fetch`:
-
-```js
-const requester = async (cmcdReq) => {
-  const retryParams = shaka.net.NetworkingEngine.defaultRetryParameters();
-  const shakaReq = shaka.net.NetworkingEngine.makeRequest(
-      [cmcdReq.url], retryParams);
-  shakaReq.method = cmcdReq.method || 'POST';
-  shakaReq.headers = cmcdReq.headers || {};
-
-  // CML's reporter always emits body as a string (structured-fields
-  // encoded by encodeCmcd, joined by '\n'). shaka.extern.Request.body
-  // expects BufferSource; convert via UTF-8.
-  shakaReq.body = shaka.util.StringUtils.toUTF8(cmcdReq.body);
-
-  try {
-    await this.networkingEngine_
-        .request(RequestType.TIMING, shakaReq, {type: 'cmcd-event'})
-        .promise;
-    return {status: 200};
-  } catch (err) {
-    return {status: err.status || 0};
-  }
-};
-```
-
-This routes CMCD event-mode reports through shaka's NetworkingEngine,
-inheriting auth-header injection, retry, request filters, etc. — same as
-manifests and segments. **No new public config field needed** (vs. hls.js's
-`loader` field): users already control transport via NetworkingEngine plugins.
-
-`RequestType.TIMING` is the existing "non-content network operation" bucket.
-Dash.js introduced a dedicated `HTTPRequest.CMCD_EVENT` type for similar
-purposes. Shaka can later add `RequestType.CMCD_EVENT_REPORT` in a follow-up
-PR without changing the adapter contract; defer until maintainers decide.
-
-## CML-side requirements (verify before/during Phase 3)
-
-The adapter assumes CmcdReporter exposes the following surface. Verify against
-CML v2.3.0 (or whichever version is current at implementation time); add
-upstream in CML if missing.
-
-| Need | Status |
-|---|---|
-| `reporter.start()` / `reporter.stop(flush)` / `reporter.flush()` lifecycle | confirmed (per CML source inspection) |
-| `reporter.update(partialState)` for state mutation | confirmed |
-| `reporter.recordEvent(eventType, data)` for discrete event emission | confirmed |
-| `reporter.createRequestReport(request, data)` for request-mode encoding | confirmed (CML signature: `R & CmcdRequestReport<R['customData']>`) |
-| `reporter.recordResponseReceived(response, data)` | confirmed |
-| `requester` constructor parameter (2nd positional arg) for event-mode dispatch | confirmed (CML constructs `method: 'POST'` with string body, `Content-Type: application/cmcd`) |
-| Built-in time-interval event timer | confirmed (reporter owns; shaka stops running its own) |
-| MSD computed internally by reporter | confirmed |
-| Sequence numbers per-target | likely present; verify per v2 spec |
-
-State fields the adapter feeds via `update()`:
-
-| Field | Source | Maps to |
-|---|---|---|
-| `playerState: CmcdPlayerState` | video events + buffer state | v2 `sta` |
-| `streamingFormat: CmcdStreamingFormat` | manifest parser type + LL flag | `sf` |
-| `cid: string` | content ID change | `cid` (also triggers v2 `c` event) |
-| `backgrounded: boolean` | visibility detection | `bg` (also triggers v2 `b` event) |
-| `muted: boolean` | media element state | (v2 `m`/`um` events) |
-| `mtp: number` | shaka throughput estimator | `mtp` |
-| `bl: number` (buffer length) | shaka playhead | `bl` (per-request, may live on `createRequestReport` data) |
-
-CMCD v2 events the reporter must support emitting (matches shaka's existing
-`CmcdV2Events` set in [`cmcd_manager.js:1653-1664`](lib/util/cmcd_manager.js:1653)):
-
-`ps`, `e`, `t`, `c`, `b`, `m`, `um`, `pe`, `pc`, `rr`.
-
-Verify CML's `CmcdEventType` enum includes all of these. If any are missing,
-add to CML in a precursor PR before shaka Phase 3 lands.
-
-## Migration phasing
-
-Three sequential PRs. Each is independently reviewable, bisectable, and
-behavior-preserving except where explicitly noted.
-
-### Phase 1 — Vendor `third_party/cml-cmcd/` and route encoding through it
-
-- Add `third_party/cml-cmcd/` directory with the closure-annotated port
-  (~25 files), `SUMMARY.txt`, `LICENSE`, `NOTICE`.
-- Update [`build/types/core`](build/types/core) to include the new files.
-- Update [`project-words.txt`](project-words.txt) for any new vocab.
-- Refactor shaka's `serialize`/`toQuery`/`appendQueryToUri`/`urlToRelativePath`
-  static methods in [`cmcd_manager.js`](lib/util/cmcd_manager.js) to delegate
-  to `cml.cmcd.encodeCmcd` / `cml.cmcd.appendCmcdQuery` /
-  `cml.cmcd.appendCmcdHeaders`.
-- **Near-no behavior change.** State machine, sequence numbers, event
-  timing, public API all unchanged. **One known intentional wire-format
-  change**: `nor` URLs become root-relative (CML's spec-conformant
-  behavior) rather than path-relative. Document in PR description.
-- Tests in [`cmcd_manager_unit.js`](test/util/cmcd_manager_unit.js) mostly
-  unchanged — `nor` assertions update to root-relative; other wire-output
-  assertions stay identical (verify via diff testing).
-- **Approximate diff size**: +3000 lines (vendored port), ~500 lines
-  changed in `cmcd_manager.js`.
-
-### Phase 2 — Adopt CML's constants/enums; delete shaka's duplicates
-
-- Replace internal references to:
-  - `shaka.util.CmcdManager.ObjectType` → `cml.cmcd.CmcdObjectType`
-  - `shaka.util.CmcdManager.Version` → `cml.cmcd.CmcdVersion`
-  - `shaka.util.CmcdManager.StreamType` → `cml.cmcd.CmcdStreamType`
-  - `shaka.util.CmcdManager.CmcdKeys` → CML's `CMCD_*_KEYS` constants
-  - `shaka.util.CmcdManager.CmcdV2Constants` → CML equivalents
-  - `shaka.util.CmcdManager.CmcdV2Keys` → CML equivalents
-  - `shaka.util.CmcdManager.CmcdMode` → `cml.cmcd.CmcdReportingMode`
-- Re-export `shaka.util.CmcdManager.StreamingFormat` as alias of
-  `cml.cmcd.CmcdStreamingFormat` (keeps `@export`; values match).
-- Delete the duplicate constant definitions from
-  [`cmcd_manager.js`](lib/util/cmcd_manager.js).
-- **No behavior change.** Just deduping.
-- **Approximate diff size**: ~150 lines deleted from `cmcd_manager.js`,
-  no additions.
-
-### Phase 3 — Replace state machine with `CmcdReporter` (the big one)
-
-- Rewrite [`cmcd_manager.js`](lib/util/cmcd_manager.js) as a thin adapter
-  (~250 lines target).
-- Construct `cml.cmcd.CmcdReporter` on first config; tear down on reset.
-- Wire `<video>` events and player state to `reporter.update(...)`.
-- Replace per-request `applyRequest_` logic with
-  `reporter.createRequestReport(...)` calls.
-- Wire `requester` callback to NetworkingEngine for event-mode reports.
-- Apply config renames in [`externs/shaka/player.js`](externs/shaka/player.js):
-  - `shaka.extern.CmcdConfiguration.targets` → `eventTargets`
-  - `shaka.extern.CmcdTarget.enabledKeys` → `includeKeys`
-  - `shaka.extern.CmcdTarget.timeInterval` → `interval`
-- Add v2 re-exports: `shaka.util.CmcdManager.EventType` (alias of
-  `cml.cmcd.CmcdEventType`), `shaka.util.CmcdManager.PlayerState` (alias of
-  `cml.cmcd.CmcdPlayerState`).
-- **Wire-format changes (alignment with CML, intentional):** sequence
-  numbers shift from 1-based to 0-based (CML uses 0); request-mode `sn`
-  becomes a single global counter rather than scoped per-target-hash;
-  `sn` resets on `sid` change (CML's `resetSession` triggered from
-  `update()` when a new `sid` is set). Flag in PR description.
-- Update [`demo/`](demo/) to add a CMCD v2 configuration UI (transmission
-  mode picker, version selector, eventTarget editor). Mirrors the
-  precedent set by dash.js's `samples/cmcd/cmcd-v2.html` and
-  `cmcd-v2-network-interceptors.html`. Lets users validate v2 config in
-  the demo without writing code.
-- Test rewrite (see Tests section): delete CMCD wire-format tests (~3000+
-  lines); add ~500 lines of integration tests focused on shaka-specific
-  glue. Add ~100 lines of end-to-end smoke tests.
-- **Approximate diff size**: ~1450 lines deleted from `cmcd_manager.js`,
-  ~3800 lines deleted from tests, ~750 lines added.
-
-### Phase ordering rationale
-
-- **Why not collapse 1+2:** Phase 1 is purely additive (vendor + delegate);
-  Phase 2 is purely deletive (remove duplicates). Mixing them makes review
-  harder. Splitting keeps each PR's intent crisp.
-- **Why not collapse 2+3:** Phase 3 is the high-risk PR (behavioral rewrite).
-  Phase 2 lets us land the constant migration safely first; if Phase 3 needs
-  revision in review, Phase 2 still stands on its own.
-- **Phase 3 owns the experimental config rename** because the adapter rewrite
-  is what consumes the renamed fields. Splitting the rename to its own phase
-  would give a transient state where externs name one thing and adapter reads
-  another.
-
-### Per-phase verification gates
-
-Each phase must:
-
-- Pass `python3 build/check.py` (lint + type-check + spell + custom rules).
-- Pass full test suite (`python3 build/test.py`).
-- Pass `python3 build/all.py` (full build, including docs and demo).
-- Demo app loads and plays content with CMCD enabled in both query and
-  header transmission modes.
-
-## Tests strategy
-
-Three buckets, with explicit ownership boundaries.
-
-### Bucket A — CMCD wire-format / encoding correctness → lives in CML upstream
-
-Tests that exercise "do we produce the right CMCD bytes for these inputs":
-
-- Key serialization, value escaping, header vs query encoding
-- v1/v2 mode-specific key filtering
-- Inner-list encoding (`br`, `tb`, `bl`, `mtp`, `nor`)
-- `upConvertToV2`, `prepareCmcdData`, structured-field serialization
-- Sequence-number progression
-- Event timing/batching logic in `CmcdReporter`
-
-These tests live in / move to `@svta/cml-cmcd`'s test suite
-(`libs/cmcd/test/`). Phase 3 deletes the corresponding ~3000+ lines from
-[`test/util/cmcd_manager_unit.js`](test/util/cmcd_manager_unit.js).
-
-### Bucket B — shaka-specific glue → lives in shaka
-
-Tests that exercise the adapter's translation layer, scoped to shaka-side
-responsibilities. Target ~500 lines. Mocks `CmcdReporter` with a stub that
-records calls; asserts call sequences.
-
-- `RequestType` (MANIFEST, SEGMENT, LICENSE, KEY, TIMING) → `CmcdObjectType` mapping
-- `RequestContext.type` → `CmcdStreamingFormat` (DASH/HLS/Smooth/Other; LL DASH and LL HLS map to plain DASH/HLS per CTA-5004-B)
-- `shaka.extern.CmcdConfiguration` → `cml.cmcd.CmcdReporterConfig` translation,
-  including the experimental renames
-- Player-event listener wiring: simulate `<video>` events / player state
-  changes, assert `reporter.update(...)` called with the right partial state
-- NetworkingEngine routing: stub the reporter's `requester` callback, assert
-  it dispatches via `NetworkingEngine.request(RequestType.TIMING, ...)` and
-  translates `{status}` correctly
-- Lifecycle: construct → configure → reset → reconfigure produces a fresh reporter
-- `rtp = bitrate × rtpSafetyFactor` adapter-side computation
-- Public-API back-compat: `shaka.util.CmcdManager.StreamingFormat` enum still
-  exists with same string values
-
-### Bucket C — end-to-end smoke → lives in shaka
-
-A handful of tests that drive a real `CmcdReporter` (not a stub) through the
-adapter and assert wire output, to catch integration regressions across the
-boundary. Target ~100 lines.
-
-- One test per transmission mode (`CMCD_QUERY`, `CMCD_HEADERS`)
-- One v1 + one v2 config
-- One event-mode test that verifies a play-state change produces an
-  event-mode dispatch through NetworkingEngine
-
-### Net delta
-
-~4317 lines deleted, ~600 lines added. Test suite shrinks by ~85%. Per
-goal A: bugs in encoding output are CML's concern; bugs in
-shaka-event-translation are shaka's concern. Clear ownership boundary.
-
-## Open questions
-
-- **CmcdReporter API surface verification.** Marked items in the CML-side
-  requirements table need a precursor pass against current CML source before
-  Phase 3 starts. Any gaps fill upstream.
-- **Phase 1 byte-level output equivalence.** Phase 1 routes encoding through
-  CML and is described as behavior-preserving. **One known intentional
-  divergence**: `nor` URLs change from path-relative (shaka's
-  `urlToRelativePath`) to root-relative (CML's `url.origin` baseUrl). Other
-  potential divergences (key ordering, escaping, formatting) are unknown;
-  verify with diff testing during Phase 1 implementation. The Phase 1 PR
-  description should reframe from "no behavior change" to "alignment with
-  CML's spec-conformant output, with `nor` URL relativization as the one
-  known intentional change." If diff testing surfaces additional
-  divergences, decide per case whether to (a) accept as a spec-conformance
-  fix, (b) work around in the adapter, or (c) align CML and shaka via an
-  upstream CML PR.
-- **Pinned CML version.** Spec assumes `@svta/cml-cmcd` v2.3.0 (current
-  latest). If a newer version ships before Phase 1 lands, pin to whatever's
-  current at port time and note in `SUMMARY.txt`.
-- **CMCD v2 spec changes.** v2 is still finalizing. Any field/event additions
-  during the migration period flow into CML first; shaka inherits via
-  next-bump.
-- **Dedicated `CMCD_EVENT_REPORT` request type.** Phase 3 uses
-  `RequestType.TIMING`. If shaka maintainers prefer a dedicated type, it can
-  be added in a follow-up PR without changing the adapter contract.
-
-## References
-
-- [shaka-player#3619](https://github.com/shaka-project/shaka-player/issues/3619) — original CMCD support issue
-- [shaka-player#8262](https://github.com/shaka-project/shaka-player/issues/8262) — TypeScript migration tracking
-- [common-media-library#40](https://github.com/streaming-video-technology-alliance/common-media-library/issues/40) — refactor shaka-player's CMCD integration to use CML
-- [hls.js#7725](https://github.com/video-dev/hls.js/pull/7725) — pattern reference (hls.js migration to CML CMCD v2)
-- [`@svta/cml-cmcd`](https://github.com/streaming-video-technology-alliance/common-media-library/tree/main/libs/cmcd) — upstream source
-- [CTA-5004 spec](https://cdn.cta.tech/cta/media/media/resources/standards/pdfs/cta-5004-final.pdf) — CMCD v1 specification
-- [CTA-5004-B draft](https://cta-wave.github.io/Resources/common-media-client-data--cta-5004-b.html) — CMCD v2 specification (in-progress)
-- [`AGENTS.md`](AGENTS.md) — shaka-player agent instructions / project conventions
-- [`third_party/closure-uri/`](third_party/closure-uri/) — vendoring precedent

From 67986bf9dc0a9c24626e9358c6fae2e9ff1d919c Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Wed, 29 Apr 2026 18:11:23 +0000
Subject: [PATCH 37/64] fix(cmcd): repair 410 interval leak,
 requestTimestampMap_ growth, missing msd and su

Agent-Logs-Url: https://github.com/cbsinteractive/shaka-player/sessions/72104986-40e3-4e6a-bdd9-063cda104b52

Co-authored-by: littlespex <1508707+littlespex@users.noreply.github.com>
---
 lib/util/cmcd_manager.js              | 31 ++++++++--
 test/util/cmcd_manager_unit.js        | 88 +++++++++++++++++++++++++++
 third_party/cml-cmcd/cmcd_reporter.js |  8 +++
 3 files changed, 123 insertions(+), 4 deletions(-)

diff --git a/lib/util/cmcd_manager.js b/lib/util/cmcd_manager.js
index f59e5c5a58..582cc0723a 100644
--- a/lib/util/cmcd_manager.js
+++ b/lib/util/cmcd_manager.js
@@ -278,7 +278,7 @@ shaka.util.CmcdManager = class {
    * @param {shaka.extern.RequestContext=} context
    */
   applyResponseData(type, response, context = {}) {
-    if (!this.reporter_ || !this.responseModeEnabled_()) {
+    if (!this.reporter_) {
       return;
     }
 
@@ -287,10 +287,17 @@ shaka.util.CmcdManager = class {
       return;
     }
 
-    try {
-      const startTs = this.requestTimestampMap_.get(response.originalRequest);
-      this.requestTimestampMap_.delete(response.originalRequest);
+    // Always clean up the per-request timestamp entry to prevent unbounded
+    // map growth when response-mode reporting is disabled (the default when
+    // eventTargets is empty). Mirrors the upstream fix in shaka-project#9193.
+    const startTs = this.requestTimestampMap_.get(response.originalRequest);
+    this.requestTimestampMap_.delete(response.originalRequest);
+
+    if (!this.responseModeEnabled_()) {
+      return;
+    }
 
+    try {
       const url = this.removeCmcdQueryFromUri_(
           response.originalUri || response.uri);
 
@@ -699,6 +706,16 @@ shaka.util.CmcdManager = class {
 
     this.eventManager_.listen(this.video_, 'playing', () => {
       this.setPlayerState_(PlayerState.PLAYING);
+      // Compute and emit Measured Start Delay (msd) on the first 'playing'
+      // event after setStartTimeOfLoad() has been called. CmcdReporter
+      // sends msd once per target on the first request; zeroing
+      // startTimeOfLoad_ here prevents re-emission on subsequent 'playing'
+      // events within the same session.
+      if (this.reporter_ && this.startTimeOfLoad_) {
+        this.reporter_.update(/** @type {!cml.cmcd.Cmcd} */ (
+          {msd: Date.now() - this.startTimeOfLoad_}));
+        this.startTimeOfLoad_ = 0;
+      }
     });
 
     this.eventManager_.listen(this.video_, 'seeking', () => {
@@ -1125,6 +1142,12 @@ shaka.util.CmcdManager = class {
       }
     }
 
+    // Set the startup flag: true when the player has not yet transitioned
+    // to a playing state (lastPlayerState_ is null = initial buffering) or
+    // is actively rebuffering. Mirrors pre-refactor: `data.su = buffering_`.
+    data['su'] = this.lastPlayerState_ == null ||
+        this.lastPlayerState_ === cml.cmcd.CmcdPlayerState.REBUFFERING;
+
     return data;
   }
 
diff --git a/test/util/cmcd_manager_unit.js b/test/util/cmcd_manager_unit.js
index 645daba927..37603d208d 100644
--- a/test/util/cmcd_manager_unit.js
+++ b/test/util/cmcd_manager_unit.js
@@ -452,6 +452,46 @@ describe('CmcdManager', () => {
       expect(priv(manager)['requestTimestampMap_'].has(r)).toBe(true);
     });
 
+    it('sets su=true on segment requests while buffering (initial)', () => {
+      spyOn(priv(manager)['reporter_'], 'createRequestReport')
+          .and.callThrough();
+      const r = createRequest();
+      // lastPlayerState_ is null by default (not yet playing) → su=true
+      manager.applyRequestData(RequestType.SEGMENT, r,
+          createSegmentContext('video'));
+      const data = /** @type {!Object} */ (
+        priv(manager)['reporter_'].createRequestReport.calls
+            .mostRecent().args[1]);
+      expect(data.su).toBe(true);
+    });
+
+    it('sets su=false on segment requests when playing', () => {
+      spyOn(priv(manager)['reporter_'], 'createRequestReport')
+          .and.callThrough();
+      // Simulate player in PLAYING state
+      priv(manager)['lastPlayerState_'] = PlayerState.PLAYING;
+      const r = createRequest();
+      manager.applyRequestData(RequestType.SEGMENT, r,
+          createSegmentContext('video'));
+      const data = /** @type {!Object} */ (
+        priv(manager)['reporter_'].createRequestReport.calls
+            .mostRecent().args[1]);
+      expect(data.su).toBe(false);
+    });
+
+    it('sets su=true on segment requests during rebuffering', () => {
+      spyOn(priv(manager)['reporter_'], 'createRequestReport')
+          .and.callThrough();
+      priv(manager)['lastPlayerState_'] = PlayerState.REBUFFERING;
+      const r = createRequest();
+      manager.applyRequestData(RequestType.SEGMENT, r,
+          createSegmentContext('video'));
+      const data = /** @type {!Object} */ (
+        priv(manager)['reporter_'].createRequestReport.calls
+            .mostRecent().args[1]);
+      expect(data.su).toBe(true);
+    });
+
     it('handles HEAD method with empty payload', () => {
       spyOn(priv(manager)['reporter_'], 'createRequestReport')
           .and.callThrough();
@@ -493,6 +533,27 @@ describe('CmcdManager', () => {
           .not.toHaveBeenCalled();
     });
 
+    it('cleans up requestTimestampMap_ even when response mode is disabled',
+        () => {
+          const player = createMockPlayer();
+          // Default config has no eventTargets → responseModeEnabled_=false
+          const {manager} = createManager(player);
+          const r = createRequest();
+          // Seed the timestamp map via applyRequestData
+          manager.applyRequestData(RequestType.SEGMENT, r,
+              createSegmentContext('video'));
+          expect(priv(manager)['requestTimestampMap_'].has(r)).toBe(true);
+          // applyResponseData should clean up even though rr reporting is off
+          manager.applyResponseData(RequestType.SEGMENT,
+              /** @type {shaka.extern.Response} */ ({
+                status: 200,
+                uri: 'https://test/seg.mp4',
+                originalRequest: r,
+                headers: {},
+              }));
+          expect(priv(manager)['requestTimestampMap_'].has(r)).toBe(false);
+        });
+
     it('forwards response data to recordResponseReceived', () => {
       const player = createMockPlayer();
       const {manager} = createManager(player, createResponseConfig());
@@ -683,6 +744,33 @@ describe('CmcdManager', () => {
       expect(priv(manager)['reporter_'].update).toHaveBeenCalledWith(
           {sta: PlayerState.ENDED});
     });
+
+    it('emits msd on first playing event after setStartTimeOfLoad', () => {
+      spyOn(priv(manager)['reporter_'], 'update').and.callThrough();
+      const before = Date.now();
+      // Simulate player.js calling setStartTimeOfLoad with a timestamp ~200ms
+      // in the past to exercise the msd computation path.
+      manager.setStartTimeOfLoad(before - 200);
+      video.dispatchEvent(new shaka.util.FakeEvent('playing'));
+      const calls = /** @type {!Array} */ (
+        priv(manager)['reporter_'].update.calls.allArgs());
+      const msdCall = calls.find((args) => args[0] && args[0].msd != null);
+      expect(msdCall).toBeDefined();
+      expect(msdCall[0].msd).toBeGreaterThanOrEqual(200);
+      // startTimeOfLoad_ should be cleared so a second playing event
+      // does NOT re-emit msd.
+      expect(priv(manager)['startTimeOfLoad_']).toBe(0);
+    });
+
+    it('does not emit msd if setStartTimeOfLoad was not called', () => {
+      spyOn(priv(manager)['reporter_'], 'update').and.callThrough();
+      // startTimeOfLoad_ is 0 (falsy) by default
+      video.dispatchEvent(new shaka.util.FakeEvent('playing'));
+      const calls = /** @type {!Array} */ (
+        priv(manager)['reporter_'].update.calls.allArgs());
+      const msdCall = calls.find((args) => args[0] && args[0].msd != null);
+      expect(msdCall).toBeUndefined();
+    });
   });
 
   // ── Externally-applied URI helpers ──
diff --git a/third_party/cml-cmcd/cmcd_reporter.js b/third_party/cml-cmcd/cmcd_reporter.js
index b69125ef98..4185e50cf4 100644
--- a/third_party/cml-cmcd/cmcd_reporter.js
+++ b/third_party/cml-cmcd/cmcd_reporter.js
@@ -563,6 +563,14 @@ cml.cmcd.CmcdReporter = class {
     const status = response.status;
 
     if (status === 410) {
+      // Clear the interval and drain the queue before removing the target
+      // so the orphaned setInterval does not keep firing after the Map
+      // entry is gone (which would prevent stop() from reaching it).
+      const state = this.eventTargets_.get(target);
+      if (state) {
+        clearInterval(state.intervalId);
+        state.queue = [];
+      }
       this.eventTargets_.delete(target);
     } else if (status === 429 || (status > 499 && status < 600)) {
       throw new Error(`Event report failed with status ${status}`);

From dda7c172f36992ae5c5dfe0a9de3267b5a41cf4a Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Wed, 29 Apr 2026 18:13:36 +0000
Subject: [PATCH 38/64] fix(cmcd): use strict equality for null checks on
 lastPlayerState_

Agent-Logs-Url: https://github.com/cbsinteractive/shaka-player/sessions/72104986-40e3-4e6a-bdd9-063cda104b52

Co-authored-by: littlespex <1508707+littlespex@users.noreply.github.com>
---
 lib/util/cmcd_manager.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/lib/util/cmcd_manager.js b/lib/util/cmcd_manager.js
index 582cc0723a..32e7d74b40 100644
--- a/lib/util/cmcd_manager.js
+++ b/lib/util/cmcd_manager.js
@@ -238,7 +238,7 @@ shaka.util.CmcdManager = class {
         }
         this.applyToRequest_(request, /** @type {!cml.cmcd.Cmcd} */ ({
           ot: ObjectType.MANIFEST,
-          su: this.lastPlayerState_ == null,
+          su: this.lastPlayerState_ === null,
         }));
         break;
       }
@@ -1145,7 +1145,7 @@ shaka.util.CmcdManager = class {
     // Set the startup flag: true when the player has not yet transitioned
     // to a playing state (lastPlayerState_ is null = initial buffering) or
     // is actively rebuffering. Mirrors pre-refactor: `data.su = buffering_`.
-    data['su'] = this.lastPlayerState_ == null ||
+    data['su'] = this.lastPlayerState_ === null ||
         this.lastPlayerState_ === cml.cmcd.CmcdPlayerState.REBUFFERING;
 
     return data;

From 332f9e5fad2da2eb592f9207e194e3d6912ef7f1 Mon Sep 17 00:00:00 2001
From: Casey Occhialini <1508707+littlespex@users.noreply.github.com>
Date: Wed, 29 Apr 2026 14:09:40 -0700
Subject: [PATCH 39/64] docs(cmcd): correct third_party/SUMMARY.txt to match
 what's vendored

The summary previously claimed predicates were omitted and that cml-utils
was replaced with a 5-line uuid shim. Both are inaccurate: 7 predicate
files (is_cmcd_*.js, is_valid.js, is_token_field.js) ship in the vendored
directory, and cml_utils.js is a 99-line shim exporting uuid,
urlToRelativePath, and defaultRequester. Update the text so third-party
auditing sees an accurate inventory.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 third_party/SUMMARY.txt | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/third_party/SUMMARY.txt b/third_party/SUMMARY.txt
index f7d5fa4322..cde685f4f6 100644
--- a/third_party/SUMMARY.txt
+++ b/third_party/SUMMARY.txt
@@ -18,8 +18,10 @@ cml-cmcd
   Local mods:
     - TypeScript source converted to Closure-annotated JS by hand
     - Type-only imports erased; replaced with local closure typedefs
-    - Decoders, validators, predicates omitted (shaka emits CMCD; doesn't parse)
-    - cml-utils dep replaced with a 5-line uuid shim
+    - Decoder/parsing support omitted; runtime validators/predicate helpers
+      remain vendored
+    - cml-utils dep replaced with a local cml_utils.js shim providing uuid,
+      urlToRelativePath, and defaultRequester
 
 language-mapping-list
   A map of languages to their names, v0.0.16, by Ali Al Dallal / Mozilla.

From 1fab16caaad511bc2bcb610ce54009ae723be32b Mon Sep 17 00:00:00 2001
From: Casey Occhialini <1508707+littlespex@users.noreply.github.com>
Date: Tue, 5 May 2026 11:01:14 -0700
Subject: [PATCH 40/64] chore: remove unused default request function

---
 third_party/cml-cmcd/cmcd_reporter.js |  3 +--
 third_party/cml-cmcd/cml_utils.js     | 27 ---------------------------
 2 files changed, 1 insertion(+), 29 deletions(-)

diff --git a/third_party/cml-cmcd/cmcd_reporter.js b/third_party/cml-cmcd/cmcd_reporter.js
index 4185e50cf4..7cf4658028 100644
--- a/third_party/cml-cmcd/cmcd_reporter.js
+++ b/third_party/cml-cmcd/cmcd_reporter.js
@@ -16,7 +16,6 @@ goog.require('cml.cmcd.CMCD_QUERY');
 goog.require('cml.cmcd.CMCD_REQUEST_MODE');
 goog.require('cml.cmcd.CMCD_V2');
 goog.require('cml.cmcd.CmcdEventType');
-goog.require('cml.cmcd.defaultRequester');
 goog.require('cml.cmcd.encodeCmcd');
 goog.require('cml.cmcd.encodePreparedCmcd');
 goog.require('cml.cmcd.prepareCmcdData');
@@ -174,7 +173,7 @@ cml.cmcd.CmcdReporter = class {
     };
 
     /** @private {function(!Object): !Promise<{status: number}>} */
-    this.requester_ = requester || cml.cmcd.defaultRequester;
+    this.requester_ = requester;
 
     this.data_ = /** @type {!cml.cmcd.Cmcd} */ ({
       cid: this.config_.cid,
diff --git a/third_party/cml-cmcd/cml_utils.js b/third_party/cml-cmcd/cml_utils.js
index f6b792d7ca..935bdff962 100644
--- a/third_party/cml-cmcd/cml_utils.js
+++ b/third_party/cml-cmcd/cml_utils.js
@@ -3,7 +3,6 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-goog.provide('cml.cmcd.defaultRequester');
 goog.provide('cml.cmcd.urlToRelativePath');
 goog.provide('cml.cmcd.uuid');
 
@@ -25,32 +24,6 @@ goog.provide('cml.cmcd.uuid');
  */
 cml.cmcd.uuid = () => crypto.randomUUID();
 
-
-/**
- * Default `requester` shim for the vendored `CmcdReporter`.
- *
- * Upstream CML defines this inline in `CmcdReporter.ts`'s module scope
- * (`function defaultRequester(request)` -> `fetch(url, init)`). The
- * shaka adapter always supplies a custom `requester` callback that
- * routes through `NetworkingEngine`, so this codepath is dead at
- * runtime — Closure ADVANCED will strip it. Kept here so the
- * `CmcdReporter` constructor's default-parameter shape stays verbatim
- * to upstream and per-bump diffs stay trivial.
- *
- * Centralized in this shim file so the conformance whitelist for
- * `fetch` can stay scoped to a single dead-code wrapper.
- *
- * @param {!Object} request The CMCD event-mode request to dispatch.
- * @return {!Promise<{status: number}>}
- */
-cml.cmcd.defaultRequester = function(request) {
-  const url = /** @type {{url: string}} */ (request).url;
-  const init = Object.assign({}, request);
-  delete init['url'];
-  return fetch(url, /** @type {!RequestInit} */ (init));
-};
-
-
 /**
  * Constructs a relative path from a URL.
  *

From 1b0c5783a4b4672dd473cd4661a349430eac89e1 Mon Sep 17 00:00:00 2001
From: Casey Occhialini <1508707+littlespex@users.noreply.github.com>
Date: Wed, 13 May 2026 15:00:01 -0700
Subject: [PATCH 41/64] fix: incorrect request type

---
 lib/util/cmcd_manager.js | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/lib/util/cmcd_manager.js b/lib/util/cmcd_manager.js
index 32e7d74b40..0e022f88c8 100644
--- a/lib/util/cmcd_manager.js
+++ b/lib/util/cmcd_manager.js
@@ -516,11 +516,10 @@ shaka.util.CmcdManager = class {
 
       try {
         const networkingEngine = this.player_.getNetworkingEngine();
-        if (!networkingEngine) {
-          return {status: 0};
-        }
+        goog.asserts.assert(this.networkingEngine_, 'Must have net engine');
+
         await networkingEngine.request(
-            RequestType.TIMING, shakaReq).promise;
+            RequestType.CMCD, shakaReq).promise;
         return {status: 200};
       } catch (err) {
         return {

From ce1a855ad3487430083e1d00871334c99f5c3f1c Mon Sep 17 00:00:00 2001
From: Casey Occhialini <1508707+littlespex@users.noreply.github.com>
Date: Wed, 13 May 2026 15:28:17 -0700
Subject: [PATCH 42/64] chore(cmcd): bump cml-cmcd to v2.3.2 + fix three
 regressions
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Upstream cml-cmcd (Common Media Library) v2.3.0 → v2.3.2, plus three
unrelated pre-existing regressions on the branch that were blocking
check.py and the CmcdManager unit test.

Pin update:
  tag    cmcd-v2.3.0 → cmcd-v2.3.2
  commit 22390e35dfbbe1e53d15648d3aace99cdf71f9dd
       → 244ecf05132ae1d1dc9cbd01479fd88f7695dbce

Upstream changes ported:

  - v2.3.1 setInterval leak fix in CmcdReporter (svta/cml#361):
    * New `disarmInterval_` and `disposeEventTarget_` helpers.
    * `start()` disarms any existing timer before arming a new one,
      eliminating the leak from repeated start() calls.
    * `stop()` routes through `disarmInterval_` for symmetry.
    * `sendEventReport_` HTTP 410 branch calls `disposeEventTarget_`
      (replaces local commit 67986bf9d's inline clear+queue-drain,
      whose queue=[] step is unnecessary once the interval is cleared).
    * `sendEventReport_` param renamed `target` → `config` to match the
      Map key type and the dispose call site.

  - v2.3.2 nor relative-path handling when baseUrl is set (svta/cml#365):
    * `cml_utils.js`: harden `urlToRelativePath` with try/catch so
      already-relative input is returned unchanged; add `getBaseUrl`
      (origin + directory) utility.
    * `cmcd_formatter_map_const.js`: nor formatter now wraps options.
      baseUrl with `getBaseUrl(...)` before calling urlToRelativePath.
    * `cmcd_reporter.js`: `createRequestReport` passes the full
      `report.url` to `createEncodingOptions_` instead of `url.origin`,
      so the resulting nor paths are sibling-relative to the current
      request URL per spec.

  - v2.3.1 doc-link text update (svta/cml#355) is a no-op for the
    vendored copy: our `@see` blocks omit the human-readable label.

Three unrelated pre-existing regressions folded in:

  - `cmcd_manager.js:519`: 1b0c5783a introduced
    `goog.asserts.assert(this.networkingEngine_, ...)` against a field
    that does not exist on the class. Now asserts the local
    `networkingEngine` const, and adds the missing
    `goog.require('goog.asserts')` (compile error
    JSC_MISSING_REQUIRE_IN_PROVIDES_FILE without it).

  - `cmcd_reporter.js:144`: 1fab16caa removed the `|| defaultRequester`
    fallback but left the constructor's `requester` param typed
    optional `(...)=`, producing JSC_TYPE_MISMATCH when assigning to a
    non-optional field. Param is now required; shaka's adapter always
    supplies a requester via NetworkingEngine. Documented in SUMMARY.

  - `test/util/cmcd_manager_unit.js:930`: 1b0c5783a corrected the
    RequestType from TIMING (4) to CMCD (9) in production but did not
    update the unit test, which kept asserting TIMING.

SUMMARY.txt: pin updated; `getBaseUrl` documented in cml-utils shim
listing; stale `defaultRequester` / `fetch` whitelist reference
removed (defaultRequester was removed in 1fab16caa).

Verification:
  python3 build/check.py --force      → exit 0
  python3 build/test.py --quick       → 2963 SUCCESS, 0 failed
                                        (CmcdManager: 63/63 SUCCESS)

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 lib/util/cmcd_manager.js                      |  3 +-
 test/util/cmcd_manager_unit.js                |  2 +-
 third_party/cml-cmcd/SUMMARY.txt              | 13 ++--
 .../cml-cmcd/cmcd_formatter_map_const.js      |  4 +-
 third_party/cml-cmcd/cmcd_reporter.js         | 66 +++++++++++++------
 third_party/cml-cmcd/cml_utils.js             | 34 +++++++++-
 6 files changed, 90 insertions(+), 32 deletions(-)

diff --git a/lib/util/cmcd_manager.js b/lib/util/cmcd_manager.js
index 0e022f88c8..abc20c2d42 100644
--- a/lib/util/cmcd_manager.js
+++ b/lib/util/cmcd_manager.js
@@ -6,6 +6,7 @@
 
 goog.provide('shaka.util.CmcdManager');
 
+goog.require('goog.asserts');
 goog.require('cml.cmcd.CMCD_EVENT_KEYS');
 goog.require('cml.cmcd.CMCD_HEADERS');
 goog.require('cml.cmcd.CMCD_QUERY');
@@ -516,7 +517,7 @@ shaka.util.CmcdManager = class {
 
       try {
         const networkingEngine = this.player_.getNetworkingEngine();
-        goog.asserts.assert(this.networkingEngine_, 'Must have net engine');
+        goog.asserts.assert(networkingEngine, 'Must have net engine');
 
         await networkingEngine.request(
             RequestType.CMCD, shakaReq).promise;
diff --git a/test/util/cmcd_manager_unit.js b/test/util/cmcd_manager_unit.js
index 37603d208d..c463af78b0 100644
--- a/test/util/cmcd_manager_unit.js
+++ b/test/util/cmcd_manager_unit.js
@@ -927,7 +927,7 @@ describe('CmcdManager', () => {
       await Promise.resolve();
 
       expect(networkingEngine.request).toHaveBeenCalled();
-      expect(captured.type).toBe(RequestType.TIMING);
+      expect(captured.type).toBe(RequestType.CMCD);
       expect(captured.request.method).toBe('POST');
     });
   });
diff --git a/third_party/cml-cmcd/SUMMARY.txt b/third_party/cml-cmcd/SUMMARY.txt
index e69cf08c51..0b04e97e5f 100644
--- a/third_party/cml-cmcd/SUMMARY.txt
+++ b/third_party/cml-cmcd/SUMMARY.txt
@@ -1,12 +1,12 @@
 cml-cmcd
-  Common Media Library CMCD encoder + reporter, v2.3.0,
+  Common Media Library CMCD encoder + reporter, v2.3.2,
   by Streaming Video Technology Alliance / Casey Occhialini et al.
   Apache 2.0 license.
   https://github.com/streaming-video-technology-alliance/common-media-library
     /tree/main/libs/cmcd
   Source npm: @svta/cml-cmcd
-  Pinned tag: cmcd-v2.3.0
-  Pinned commit: 22390e35dfbbe1e53d15648d3aace99cdf71f9dd
+  Pinned tag: cmcd-v2.3.2
+  Pinned commit: 244ecf05132ae1d1dc9cbd01479fd88f7695dbce
 
   TRANSITIONAL: This vendored port exists because shaka-player uses Closure
   Compiler. When shaka migrates to TypeScript (issue #8262), delete this
@@ -26,8 +26,9 @@ cml-cmcd
     - cml-utils dep absorbed into `cml_utils.js` shim:
         * `uuid` (wraps `crypto.randomUUID()`; dead-codepath for shaka)
         * `urlToRelativePath` (used by `CMCD_FORMATTER_MAP`'s `nor`)
-        * `defaultRequester` (wraps `fetch`; dead-codepath for shaka —
-          adapter always supplies a custom requester via NetworkingEngine)
+        * `getBaseUrl` (extracts origin + directory from a full URL;
+          used by `CmcdReporter` and the `nor` formatter to derive a
+          sibling-relative base from the current request URL)
     - structured-field-values dep absorbed into `cml_sfv.js` shim:
         * `SfItem` / `SfToken` runtime classes
         * `encodeSfDict` (RFC 8941 §4.1 dictionary serializer; pulls in
@@ -55,5 +56,3 @@ cml-cmcd
       `start()`; replacing with `shaka.util.Timer` would break the
       verbatim-port property and the per-bump diff stability, so the
       conformance allowlist is extended for this single file.
-      `fetch` whitelisted for the dead-codepath `defaultRequester`
-      shim in `cml_utils.js`.
diff --git a/third_party/cml-cmcd/cmcd_formatter_map_const.js b/third_party/cml-cmcd/cmcd_formatter_map_const.js
index 38aac8205f..61b985810e 100644
--- a/third_party/cml-cmcd/cmcd_formatter_map_const.js
+++ b/third_party/cml-cmcd/cmcd_formatter_map_const.js
@@ -9,6 +9,7 @@ goog.require('cml.cmcd.CmcdFormatterMap');
 goog.require('cml.cmcd.CmcdFormatterOptions');
 goog.require('cml.cmcd.CmcdValue');
 goog.require('cml.cmcd.SfItem');
+goog.require('cml.cmcd.getBaseUrl');
 goog.require('cml.cmcd.urlToRelativePath');
 
 
@@ -59,7 +60,8 @@ cml.cmcd.CMCD_FORMATTER_MAP_toUrlSafe_ = function(value, options) {
   } else {
     if (options.baseUrl) {
       value = cml.cmcd.urlToRelativePath(
-          /** @type {string} */ (value), options.baseUrl);
+          /** @type {string} */ (value),
+          cml.cmcd.getBaseUrl(options.baseUrl));
     }
     return options.version === 1 ?
         encodeURIComponent(/** @type {string} */ (value)) :
diff --git a/third_party/cml-cmcd/cmcd_reporter.js b/third_party/cml-cmcd/cmcd_reporter.js
index 7cf4658028..398e3a1e83 100644
--- a/third_party/cml-cmcd/cmcd_reporter.js
+++ b/third_party/cml-cmcd/cmcd_reporter.js
@@ -141,9 +141,11 @@ cml.cmcd.CmcdReporter = class {
    *
    * @param {!cml.cmcd.CmcdReporterConfig} config The configuration for
    *   the CMCD reporter.
-   * @param {(function(!Object): !Promise<{status: number}>)=} requester
-   *   The function to use to send the request. The default is a simple
-   *   wrapper around the native `fetch` API.
+   * @param {function(!Object): !Promise<{status: number}>} requester
+   *   The function to use to send the request. Required: shaka's
+   *   adapter routes requests through NetworkingEngine. Diverges from
+   *   upstream's optional `requester = defaultRequester` since
+   *   `defaultRequester` was removed in `1fab16caa`.
    */
   constructor(config, requester) {
     /** @private {number} */
@@ -201,6 +203,10 @@ cml.cmcd.CmcdReporter = class {
    */
   start() {
     this.eventTargets_.forEach((target, config) => {
+      // Disarm any existing timer so repeated start() calls do not leak
+      // intervals.
+      this.disarmInterval_(target);
+
       // If the interval is 0 or the TIME_INTERVAL event is not enabled,
       // do not start the interval.
       if (config.interval === 0 ||
@@ -233,7 +239,7 @@ cml.cmcd.CmcdReporter = class {
     }
 
     this.eventTargets_.forEach((target) => {
-      clearInterval(target.intervalId);
+      this.disarmInterval_(target);
     });
   }
 
@@ -468,7 +474,7 @@ cml.cmcd.CmcdReporter = class {
           sn: this.requestTarget_.sn++,
         }));
     const options = cml.cmcd.CmcdReporter_createEncodingOptions_(
-        cml.cmcd.CMCD_REQUEST_MODE, this.config_, url.origin);
+        cml.cmcd.CMCD_REQUEST_MODE, this.config_, report.url);
 
     if (!isNaN(this.msd_) && !this.requestTarget_.msdSent) {
       cmcdData.msd = this.msd_;
@@ -539,18 +545,18 @@ cml.cmcd.CmcdReporter = class {
    * Sends an event report. Called by the reporter when a batch is
    * ready to be sent.
    *
-   * @param {!cml.cmcd.CmcdEventReportConfig} target The target to send
-   *   the event report to.
+   * @param {!cml.cmcd.CmcdEventReportConfig} config The target config
+   *   to send the event report to.
    * @param {!Array<!cml.cmcd.Cmcd>} data The data to send in the event
    *   report.
    * @return {!Promise<void>}
    * @private
    */
-  async sendEventReport_(target, data) {
+  async sendEventReport_(config, data) {
     const options = cml.cmcd.CmcdReporter_createEncodingOptions_(
-        cml.cmcd.CMCD_EVENT_MODE, target);
+        cml.cmcd.CMCD_EVENT_MODE, config);
     const response = await this.requester_({
-      url: target.url,
+      url: config.url,
       method: 'POST',
       headers: {
         'Content-Type': cml.cmcd.CMCD_MIME_TYPE,
@@ -562,20 +568,42 @@ cml.cmcd.CmcdReporter = class {
     const status = response.status;
 
     if (status === 410) {
-      // Clear the interval and drain the queue before removing the target
-      // so the orphaned setInterval does not keep firing after the Map
-      // entry is gone (which would prevent stop() from reaching it).
-      const state = this.eventTargets_.get(target);
-      if (state) {
-        clearInterval(state.intervalId);
-        state.queue = [];
-      }
-      this.eventTargets_.delete(target);
+      this.disposeEventTarget_(config);
     } else if (status === 429 || (status > 499 && status < 600)) {
       throw new Error(`Event report failed with status ${status}`);
     }
   }
 
+  /**
+   * Cancels the time-interval timer for an event target and clears the
+   * stored id. Safe to call when no timer is armed
+   * (clearInterval(undefined) is a no-op).
+   *
+   * @param {!cml.cmcd.CmcdReporter_CmcdEventTarget_} target
+   * @private
+   */
+  disarmInterval_(target) {
+    clearInterval(target.intervalId);
+    target.intervalId = undefined;
+  }
+
+  /**
+   * Permanently removes an event target: cancels its timer and removes
+   * it from the eventTargets map. Used when the collector signals the
+   * target is gone (HTTP 410).
+   *
+   * @param {!cml.cmcd.CmcdEventReportConfig} config
+   * @private
+   */
+  disposeEventTarget_(config) {
+    const target = this.eventTargets_.get(config);
+    if (!target) {
+      return;
+    }
+    this.disarmInterval_(target);
+    this.eventTargets_.delete(config);
+  }
+
   /**
    * Resets the session related data. Called when the session ID
    * changes.
diff --git a/third_party/cml-cmcd/cml_utils.js b/third_party/cml-cmcd/cml_utils.js
index 935bdff962..27adc17f5f 100644
--- a/third_party/cml-cmcd/cml_utils.js
+++ b/third_party/cml-cmcd/cml_utils.js
@@ -3,6 +3,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+goog.provide('cml.cmcd.getBaseUrl');
 goog.provide('cml.cmcd.urlToRelativePath');
 goog.provide('cml.cmcd.uuid');
 
@@ -29,15 +30,24 @@ cml.cmcd.uuid = () => crypto.randomUUID();
  *
  * Vendored verbatim from `@svta/cml-utils`'s `urlToRelativePath`. Used
  * by `cml.cmcd.CMCD_FORMATTER_MAP`'s `nor` formatter to produce
- * root-relative URLs when a `baseUrl` is supplied via
+ * sibling-relative URLs when a `baseUrl` is supplied via
  * `CmcdEncodeOptions.baseUrl`.
  *
+ * If `url` is already a relative path (parses as invalid URL), or its
+ * origin differs from `base`, it is returned unchanged.
+ *
  * @param {string} url The destination URL.
  * @param {string} base The base URL.
  * @return {string} The relative path.
  */
-cml.cmcd.urlToRelativePath = function(url, base) {
-  const to = new URL(url);
+cml.cmcd.urlToRelativePath = (url, base) => {
+  let to;
+  try {
+    to = new URL(url);
+  } catch (e) {
+    return url;
+  }
+
   const from = new URL(base);
 
   if (to.origin !== from.origin) {
@@ -70,3 +80,21 @@ cml.cmcd.urlToRelativePath = function(url, base) {
   // preserve query parameters and hash of the destination url
   return relativePath + to.search + to.hash;
 };
+
+/**
+ * Get the base URL (origin + directory) from a full URL.
+ *
+ * Vendored verbatim from `@svta/cml-utils`'s `getBaseUrl`. Used by
+ * `cml.cmcd.CmcdReporter` to derive a sibling-relative base for `nor`
+ * conversion from the current request URL. Upstream signature accepts
+ * `string | URL`; the vendored shim restricts to `string` because
+ * shaka's only caller passes a string.
+ *
+ * @param {string} fullUrl The full URL.
+ * @return {string} The base URL.
+ */
+cml.cmcd.getBaseUrl = (fullUrl) => {
+  const url = new URL(fullUrl);
+  return url.origin +
+      url.pathname.substring(0, url.pathname.lastIndexOf('/') + 1);
+};

From 1b412754152a7896d2b1be39d123a7a3cda5e8e9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C3=81lvaro=20Velad=20Galv=C3=A1n?= <ladvan91@hotmail.com>
Date: Wed, 27 May 2026 10:02:29 +0200
Subject: [PATCH 43/64] refactor(UI): Unify localization and availability
 updates in Element (#10128)

---
 demo/visualizer_button.js      | 24 ++++------------
 ui/ad_info.js                  | 19 -------------
 ui/ad_statistics_button.js     | 34 +++++++---------------
 ui/audio_language_selection.js | 36 ++++++-----------------
 ui/cast_button.js              | 50 +++++++++++---------------------
 ui/chapter_selection.js        | 45 +++++++++--------------------
 ui/copy_video_frame_button.js  | 52 +++++++---------------------------
 ui/element.js                  | 21 +++++++++++++-
 ui/externs/ui.js               | 12 ++++++++
 ui/fast_forward_button.js      | 17 ++---------
 ui/fullscreen_button.js        | 48 ++++++++++---------------------
 ui/loop_button.js              | 49 +++++++-------------------------
 ui/mute_button.js              | 46 ++++++++++--------------------
 ui/overflow_menu.js            | 24 ++--------------
 ui/pip_button.js               | 45 ++++++-----------------------
 ui/play_button.js              | 25 ++++------------
 ui/playback_rate_selection.js  | 27 ++----------------
 ui/queue_button.js             | 37 ++++++------------------
 ui/recenter_vr.js              | 41 +++++----------------------
 ui/remote_button.js            | 38 ++++++-------------------
 ui/resolution_selection.js     | 46 ++++++------------------------
 ui/rewind_button.js            | 18 ++----------
 ui/save_video_frame_button.js  | 52 +++++++---------------------------
 ui/seek_bar.js                 | 16 ++---------
 ui/settings_menu.js            |  5 ++++
 ui/skip_ad_button.js           | 31 +++-----------------
 ui/skip_next_button.js         | 28 ++++++------------
 ui/skip_previous_button.js     | 28 ++++++------------
 ui/statistics_button.js        | 32 ++++++---------------
 ui/text_position.js            | 37 +++++-------------------
 ui/text_selection.js           | 44 +++++++++-------------------
 ui/text_size.js                | 37 +++++-------------------
 ui/toggle_stereoscopic.js      | 41 +++++----------------------
 ui/video_type_selection.js     | 39 +++++++------------------
 ui/volume_bar.js               | 28 ++++++------------
 35 files changed, 298 insertions(+), 874 deletions(-)

diff --git a/demo/visualizer_button.js b/demo/visualizer_button.js
index b456284ca2..2992610318 100644
--- a/demo/visualizer_button.js
+++ b/demo/visualizer_button.js
@@ -65,25 +65,14 @@ shakaDemo.VisualizerButton = class extends shaka.ui.Element {
           shakaDemoMain.getIsVisualizerActive()) {
         shakaDemoMain.setIsVisualizerActive(false);
       }
-      this.checkAvailability_();
+      this.checkAvailability();
     });
 
     this.eventManager.listen(document, 'fullscreenchange', () => {
-      this.checkAvailability_();
+      this.checkAvailability();
     });
 
-    if (this.isSubMenu) {
-      this.eventManager.listenMulti(
-          this.controls,
-          [
-            'submenuopen',
-            'submenuclose',
-          ], () => {
-            this.checkAvailability_();
-          });
-    }
-
-    this.checkAvailability_();
+    this.checkAvailability();
   }
 
   /** @private */
@@ -97,11 +86,8 @@ shakaDemo.VisualizerButton = class extends shaka.ui.Element {
     }
   }
 
-
-  /**
-   * @private
-   */
-  checkAvailability_() {
+  /** @override */
+  checkAvailability() {
     if (!this.castProxy_.isCasting() &&
         !this.controls.isFullScreenEnabled() &&
         !this.isSubMenuOpened) {
diff --git a/ui/ad_info.js b/ui/ad_info.js
index a1c97e50c2..209a705a1f 100644
--- a/ui/ad_info.js
+++ b/ui/ad_info.js
@@ -11,7 +11,6 @@ goog.require('goog.asserts');
 goog.require('shaka.ads.Utils');
 goog.require('shaka.ui.Element');
 goog.require('shaka.ui.Locales');
-goog.require('shaka.ui.Localization');
 goog.require('shaka.ui.Utils');
 goog.require('shaka.util.Dom');
 goog.require('shaka.util.Timer');
@@ -46,17 +45,6 @@ shaka.ui.AdInfo = class extends shaka.ui.Element {
       this.onTimerTick_();
     });
 
-    this.updateAriaLabel_();
-
-    this.eventManager.listenMulti(
-        this.localization,
-        [
-          shaka.ui.Localization.LOCALE_UPDATED,
-          shaka.ui.Localization.LOCALE_CHANGED,
-        ], () => {
-          this.updateAriaLabel_();
-        });
-
     this.eventManager.listen(
         this.adManager, shaka.ads.Utils.AD_STARTED, () => {
           this.onAdStarted_();
@@ -73,13 +61,6 @@ shaka.ui.AdInfo = class extends shaka.ui.Element {
     }
   }
 
-  /**
-   * @private
-   */
-  updateAriaLabel_() {
-    // arai-label is set dynamically in onTimerTick_().
-  }
-
   /**
    * @private
    */
diff --git a/ui/ad_statistics_button.js b/ui/ad_statistics_button.js
index 1dc5895991..9f6a388c4a 100644
--- a/ui/ad_statistics_button.js
+++ b/ui/ad_statistics_button.js
@@ -14,7 +14,6 @@ goog.require('shaka.ui.Element');
 goog.require('shaka.ui.Enums');
 goog.require('shaka.ui.Icon');
 goog.require('shaka.ui.Locales');
-goog.require('shaka.ui.Localization');
 goog.require('shaka.ui.OverflowMenu');
 goog.require('shaka.ui.Utils');
 goog.require('shaka.util.Dom');
@@ -113,25 +112,16 @@ shaka.ui.AdStatisticsButton = class extends shaka.ui.Element {
       this.onTimerTick_();
     });
 
-    this.updateLocalizedStrings_();
+    this.updateLocalizedStrings();
 
     this.loadContainer_();
 
-    this.eventManager.listenMulti(
-        this.localization,
-        [
-          shaka.ui.Localization.LOCALE_UPDATED,
-          shaka.ui.Localization.LOCALE_CHANGED,
-        ], () => {
-          this.updateLocalizedStrings_();
-        });
-
     this.eventManager.listen(this.button_, 'click', () => {
       if (!this.controls.isOpaque()) {
         return;
       }
       this.onClick_();
-      this.updateLocalizedStrings_();
+      this.updateLocalizedStrings();
     });
 
     this.eventManager.listen(this.player, 'loading', () => {
@@ -142,15 +132,6 @@ shaka.ui.AdStatisticsButton = class extends shaka.ui.Element {
         this.adManager, shaka.ads.Utils.AD_STARTED, () => {
           shaka.ui.Utils.setDisplay(this.button_, true);
         });
-
-    if (this.isSubMenu) {
-      this.eventManager.listen(this.controls, 'submenuopen', () => {
-        shaka.ui.Utils.setDisplay(this.button_, false);
-      });
-      this.eventManager.listen(this.controls, 'submenuclose', () => {
-        shaka.ui.Utils.setDisplay(this.button_, this.currentStats_.started > 0);
-      });
-    }
   }
 
   /** @private */
@@ -168,8 +149,8 @@ shaka.ui.AdStatisticsButton = class extends shaka.ui.Element {
     }
   }
 
-  /** @private */
-  updateLocalizedStrings_() {
+  /** @override */
+  updateLocalizedStrings() {
     const LocIds = shaka.ui.Locales.Ids;
 
     this.nameSpan_.textContent =
@@ -182,6 +163,13 @@ shaka.ui.AdStatisticsButton = class extends shaka.ui.Element {
     this.stateSpan_.textContent = this.localization.resolve(labelText);
   }
 
+  /** @override */
+  checkAvailability() {
+    shaka.ui.Utils.setDisplay(
+        this.button_,
+        !this.isSubMenuOpened && this.currentStats_.started > 0);
+  }
+
   /**
    * @param {string} name
    * @return {!HTMLElement}
diff --git a/ui/audio_language_selection.js b/ui/audio_language_selection.js
index 11c8cec116..60993ad88d 100644
--- a/ui/audio_language_selection.js
+++ b/ui/audio_language_selection.js
@@ -11,7 +11,6 @@ goog.require('shaka.ui.Controls');
 goog.require('shaka.ui.Enums');
 goog.require('shaka.ui.LanguageUtils');
 goog.require('shaka.ui.Locales');
-goog.require('shaka.ui.Localization');
 goog.require('shaka.ui.OverflowMenu');
 goog.require('shaka.ui.SettingsMenu');
 goog.require('shaka.ui.Utils');
@@ -35,15 +34,6 @@ shaka.ui.AudioLanguageSelection = class extends shaka.ui.SettingsMenu {
     this.button.classList.add('shaka-tooltip-status');
     this.menu.classList.add('shaka-audio-languages');
 
-    this.eventManager.listenMulti(
-        this.localization,
-        [
-          shaka.ui.Localization.LOCALE_UPDATED,
-          shaka.ui.Localization.LOCALE_CHANGED,
-        ], () => {
-          this.updateLocalizedStrings_();
-        });
-
     this.eventManager.listenMulti(
         this.player,
         [
@@ -55,24 +45,12 @@ shaka.ui.AudioLanguageSelection = class extends shaka.ui.SettingsMenu {
           this.onAudioTracksChanged_();
         });
 
-    if (this.isSubMenu) {
-      this.eventManager.listenMulti(
-          this.controls,
-          [
-            'submenuopen',
-            'submenuclose',
-          ], () => {
-            this.onAudioTracksChanged_();
-          });
-    }
-
     // Set up all the strings in the user's preferred language.
-    this.updateLocalizedStrings_();
+    this.updateLocalizedStrings();
 
     this.onAudioTracksChanged_();
   }
 
-
   /** @private */
   onAudioTracksChanged_() {
     const audioTracks = this.player.getAudioTracks() || [];
@@ -114,11 +92,8 @@ shaka.ui.AudioLanguageSelection = class extends shaka.ui.SettingsMenu {
     this.player.configure({preferredAudio: [pref]});
   }
 
-
-  /**
-   * @private
-   */
-  updateLocalizedStrings_() {
+  /** @override */
+  updateLocalizedStrings() {
     const LocIds = shaka.ui.Locales.Ids;
 
     this.backButton.ariaLabel = this.localization.resolve(LocIds.BACK);
@@ -128,6 +103,11 @@ shaka.ui.AudioLanguageSelection = class extends shaka.ui.SettingsMenu {
     this.backSpan.textContent =
         this.localization.resolve(LocIds.LANGUAGE);
   }
+
+  /** @override */
+  checkAvailability() {
+    this.onAudioTracksChanged_();
+  }
 };
 
 
diff --git a/ui/cast_button.js b/ui/cast_button.js
index a27a9a8a72..673f2d0988 100644
--- a/ui/cast_button.js
+++ b/ui/cast_button.js
@@ -13,7 +13,6 @@ goog.require('shaka.ui.Element');
 goog.require('shaka.ui.Enums');
 goog.require('shaka.ui.Icon');
 goog.require('shaka.ui.Locales');
-goog.require('shaka.ui.Localization');
 goog.require('shaka.ui.OverflowMenu');
 goog.require('shaka.ui.Utils');
 goog.require('shaka.util.Dom');
@@ -65,20 +64,11 @@ shaka.ui.CastButton = class extends shaka.ui.Element {
     this.parent.appendChild(this.castButton_);
 
     // Setup strings in the correct language
-    this.updateLocalizedStrings_();
+    this.updateLocalizedStrings();
 
     // Setup button display and state according to the current cast status
     this.onCastStatusChange_();
 
-    this.eventManager.listenMulti(
-        this.localization,
-        [
-          shaka.ui.Localization.LOCALE_UPDATED,
-          shaka.ui.Localization.LOCALE_CHANGED,
-        ], () => {
-          this.updateLocalizedStrings_();
-        });
-
     this.eventManager.listen(this.castButton_, 'click', () => {
       if (!this.controls.isOpaque()) {
         return;
@@ -89,15 +79,6 @@ shaka.ui.CastButton = class extends shaka.ui.Element {
     this.eventManager.listen(this.controls, 'caststatuschanged', () => {
       this.onCastStatusChange_();
     });
-
-    if (this.isSubMenu) {
-      this.eventManager.listen(this.controls, 'submenuopen', () => {
-        shaka.ui.Utils.setDisplay(this.castButton_, false);
-      });
-      this.eventManager.listen(this.controls, 'submenuclose', () => {
-        shaka.ui.Utils.setDisplay(this.castButton_, true);
-      });
-    }
   }
 
 
@@ -123,24 +104,23 @@ shaka.ui.CastButton = class extends shaka.ui.Element {
 
   /**
    * @private
+   *
+   * Updates icon and aria state. Delegates visibility to checkAvailability()
+   * so that the submenu state is always factored in from a single place.
    */
   onCastStatusChange_() {
-    const canCast = this.castProxy_.canCast() && this.controls.isCastAllowed();
     const isCasting = this.castProxy_.isCasting();
     const Icons = shaka.ui.Enums.MaterialDesignSVGIcons;
-    shaka.ui.Utils.setDisplay(this.castButton_, canCast);
+
     this.castIcon_.use(isCasting ? Icons['EXIT_CAST'] : Icons['CAST']);
 
-    // Aria-pressed set to true when casting, set to false otherwise.
+    const canCast = this.castProxy_.canCast() && this.controls.isCastAllowed();
     if (canCast) {
-      if (isCasting) {
-        this.castButton_.ariaPressed = 'true';
-      } else {
-        this.castButton_.ariaPressed = 'false';
-      }
+      this.castButton_.ariaPressed = isCasting ? 'true' : 'false';
     }
 
     this.setCurrentCastSelection_();
+    this.checkAvailability();
   }
 
 
@@ -157,11 +137,8 @@ shaka.ui.CastButton = class extends shaka.ui.Element {
     }
   }
 
-
-  /**
-   * @private
-   */
-  updateLocalizedStrings_() {
+  /** @override */
+  updateLocalizedStrings() {
     const LocIds = shaka.ui.Locales.Ids;
 
     this.castButton_.ariaLabel = this.localization.resolve(LocIds.CAST);
@@ -172,6 +149,13 @@ shaka.ui.CastButton = class extends shaka.ui.Element {
     // which needs localization.
     this.setCurrentCastSelection_();
   }
+
+  /** @override */
+  checkAvailability() {
+    const canCast = this.castProxy_.canCast() && this.controls.isCastAllowed();
+    shaka.ui.Utils.setDisplay(
+        this.castButton_, canCast && !this.isSubMenuOpened);
+  }
 };
 
 
diff --git a/ui/chapter_selection.js b/ui/chapter_selection.js
index 2788b16a96..5189a15157 100644
--- a/ui/chapter_selection.js
+++ b/ui/chapter_selection.js
@@ -12,7 +12,6 @@ goog.require('shaka.net.NetworkingUtils');
 goog.require('shaka.ui.Controls');
 goog.require('shaka.ui.Enums');
 goog.require('shaka.ui.Locales');
-goog.require('shaka.ui.Localization');
 goog.require('shaka.ui.OverflowMenu');
 goog.require('shaka.ui.SettingsMenu');
 goog.require('shaka.ui.Utils');
@@ -37,16 +36,6 @@ shaka.ui.ChapterSelection = class extends shaka.ui.SettingsMenu {
     this.menu.classList.add('shaka-chapters');
     this.button.classList.add('shaka-tooltip-status');
 
-    this.eventManager.listenMulti(
-        this.localization,
-        [
-          shaka.ui.Localization.LOCALE_UPDATED,
-          shaka.ui.Localization.LOCALE_CHANGED,
-        ], () => {
-          this.updateLocalizedStrings_();
-          this.updateChapters_();
-        });
-
     let hasImageTracks = this.player.getImageTracks().length;
 
     this.eventManager.listen(this.controls, 'chaptersupdated', () => {
@@ -65,40 +54,32 @@ shaka.ui.ChapterSelection = class extends shaka.ui.SettingsMenu {
       hasImageTracks = newHasImageTracks;
     });
 
-    if (this.isSubMenu) {
-      this.eventManager.listenMulti(
-          this.controls,
-          [
-            'submenuopen',
-            'submenuclose',
-          ], () => {
-            const hasChapters = this.controls.getChapters().length > 0;
-            shaka.ui.Utils.setDisplay(this.button,
-                hasChapters && !this.isSubMenuOpened);
-          });
-    }
-
     // Set up all the strings in the user's preferred language.
-    this.updateLocalizedStrings_();
+    this.updateLocalizedStrings();
 
     this.updateChapters_();
   }
 
-  /**
-   * @private
-   */
-  updateLocalizedStrings_() {
+  /** @override */
+  updateLocalizedStrings() {
     const LocIds = shaka.ui.Locales.Ids;
 
     this.backButton.ariaLabel = this.localization.resolve(LocIds.BACK);
     this.button.ariaLabel = this.localization.resolve(LocIds.CHAPTERS);
     this.nameSpan.textContent = this.localization.resolve(LocIds.CHAPTERS);
     this.backSpan.textContent = this.localization.resolve(LocIds.CHAPTERS);
+
+    this.updateChapters_();
   }
 
-  /**
-   * @private
-   */
+  /** @override */
+  checkAvailability() {
+    const hasChapters = this.controls.getChapters().length > 0;
+    shaka.ui.Utils.setDisplay(
+        this.button, hasChapters && !this.isSubMenuOpened);
+  }
+
+  /** @private */
   updateChapters_() {
     // 1. Save the back to menu button
     const backButton = shaka.ui.Utils.getFirstDescendantWithClassName(
diff --git a/ui/copy_video_frame_button.js b/ui/copy_video_frame_button.js
index 747f391a8a..87336cadba 100644
--- a/ui/copy_video_frame_button.js
+++ b/ui/copy_video_frame_button.js
@@ -14,7 +14,6 @@ goog.require('shaka.ui.Element');
 goog.require('shaka.ui.Enums');
 goog.require('shaka.ui.Icon');
 goog.require('shaka.ui.Locales');
-goog.require('shaka.ui.Localization');
 goog.require('shaka.ui.OverflowMenu');
 goog.require('shaka.ui.Utils');
 goog.require('shaka.util.Dom');
@@ -37,7 +36,6 @@ shaka.ui.CopyVideoFrameButton = class extends shaka.ui.Element {
     /** @private {shaka.cast.CastProxy} */
     this.castProxy_ = this.controls.getCastProxy();
 
-    const LocIds = shaka.ui.Locales.Ids;
     /** @private {!HTMLButtonElement} */
     this.button_ = shaka.util.Dom.createButton();
     this.button_.classList.add('shaka-copy-video-frame-button');
@@ -51,8 +49,6 @@ shaka.ui.CopyVideoFrameButton = class extends shaka.ui.Element {
     label.classList.add('shaka-overflow-button-label');
     label.classList.add('shaka-overflow-menu-only');
     this.nameSpan_ = shaka.util.Dom.createHTMLElement('span');
-    this.nameSpan_.textContent =
-        this.localization.resolve(LocIds.COPY_VIDEO_FRAME);
     label.appendChild(this.nameSpan_);
 
     /** @private {!HTMLElement} */
@@ -62,26 +58,17 @@ shaka.ui.CopyVideoFrameButton = class extends shaka.ui.Element {
 
     this.button_.appendChild(label);
 
-    this.updateLocalizedStrings_();
+    this.updateLocalizedStrings();
 
     this.parent.appendChild(this.button_);
 
-    this.eventManager.listenMulti(
-        this.localization,
-        [
-          shaka.ui.Localization.LOCALE_UPDATED,
-          shaka.ui.Localization.LOCALE_CHANGED,
-        ], () => {
-          this.updateLocalizedStrings_();
-        });
-
     this.eventManager.listen(this.button_, 'click', () => {
       this.controls.copyVideoFrameToClipboard();
     });
 
     const vr = this.controls.getVR();
     this.eventManager.listen(vr, 'vrstatuschanged', () => {
-      this.checkAvailability_();
+      this.checkAvailability();
     });
 
     this.eventManager.listenMulti(
@@ -90,7 +77,7 @@ shaka.ui.CopyVideoFrameButton = class extends shaka.ui.Element {
           shaka.ads.Utils.AD_STARTED,
           shaka.ads.Utils.AD_STOPPED,
         ], () => {
-          this.checkAvailability_();
+          this.checkAvailability();
         });
 
     this.eventManager.listenMulti(
@@ -99,7 +86,7 @@ shaka.ui.CopyVideoFrameButton = class extends shaka.ui.Element {
           'unloading',
           'loaded',
         ], () => {
-          this.checkAvailability_();
+          this.checkAvailability();
         });
 
     this.eventManager.listenMulti(
@@ -109,41 +96,24 @@ shaka.ui.CopyVideoFrameButton = class extends shaka.ui.Element {
           shaka.util.MediaElementEvent.PAUSE,
           shaka.util.MediaElementEvent.SEEKING,
         ], () => {
-          this.checkAvailability_();
+          this.checkAvailability();
         });
 
     this.eventManager.listen(this.controls, 'caststatuschanged', () => {
-      this.checkAvailability_();
+      this.checkAvailability();
     });
 
-    if (this.isSubMenu) {
-      this.eventManager.listenMulti(
-          this.controls,
-          [
-            'submenuopen',
-            'submenuclose',
-          ], () => {
-            this.checkAvailability_();
-          });
-    }
-
-    this.checkAvailability_();
+    this.checkAvailability();
   }
 
-
-  /**
-   * @private
-   */
-  checkAvailability_() {
+  /** @override */
+  checkAvailability() {
     shaka.ui.Utils.setDisplay(this.button_,
         this.controls.canCopyVideoFrameToClipboard() && !this.isSubMenuOpened);
   }
 
-
-  /**
-   * @private
-   */
-  updateLocalizedStrings_() {
+  /** @override */
+  updateLocalizedStrings() {
     const LocIds = shaka.ui.Locales.Ids;
 
     this.button_.ariaLabel =
diff --git a/ui/element.js b/ui/element.js
index 805e2d2865..d3cc9bca64 100644
--- a/ui/element.js
+++ b/ui/element.js
@@ -9,9 +9,9 @@ goog.provide('shaka.ui.Element');
 
 goog.require('shaka.ads.Utils');
 goog.require('shaka.util.EventManager');
+goog.require('shaka.ui.Localization');
 goog.requireType('shaka.Player');
 goog.requireType('shaka.ui.Controls');
-goog.requireType('shaka.ui.Localization');
 
 
 /**
@@ -83,6 +83,17 @@ shaka.ui.Element = class {
       this.ad = null;
     });
 
+    if (this.localization) {
+      this.eventManager.listenMulti(
+          this.localization,
+          [
+            shaka.ui.Localization.LOCALE_UPDATED,
+            shaka.ui.Localization.LOCALE_CHANGED,
+          ], () => {
+            this.updateLocalizedStrings();
+          });
+    }
+
     /**
      * @protected {boolean}
      * @exportInterface
@@ -99,9 +110,11 @@ shaka.ui.Element = class {
     if (this.isSubMenu) {
       this.eventManager.listen(this.controls, 'submenuopen', () => {
         this.isSubMenuOpened = true;
+        this.checkAvailability();
       });
       this.eventManager.listen(this.controls, 'submenuclose', () => {
         this.isSubMenuOpened = false;
+        this.checkAvailability();
       });
     }
   }
@@ -122,4 +135,10 @@ shaka.ui.Element = class {
     this.adManager = null;
     this.ad = null;
   }
+
+  /** @override */
+  updateLocalizedStrings() {}
+
+  /** @override */
+  checkAvailability() {}
 };
diff --git a/ui/externs/ui.js b/ui/externs/ui.js
index 9f978bb861..322380eddb 100644
--- a/ui/externs/ui.js
+++ b/ui/externs/ui.js
@@ -732,6 +732,18 @@ shaka.extern.IUIElement = class {
    * @override
    */
   release() {}
+
+  /**
+   * Called when the locale changes. Override to update UI strings.
+   * @protected
+   */
+  updateLocalizedStrings() {}
+
+  /**
+   * Called when a submenu opens or closes. Override to show/hide this element.
+   * @protected
+   */
+  checkAvailability() {}
 };
 
 
diff --git a/ui/fast_forward_button.js b/ui/fast_forward_button.js
index 3ae769a1f4..04d753034c 100644
--- a/ui/fast_forward_button.js
+++ b/ui/fast_forward_button.js
@@ -12,7 +12,6 @@ goog.require('shaka.ui.Element');
 goog.require('shaka.ui.Enums');
 goog.require('shaka.ui.Icon');
 goog.require('shaka.ui.Locales');
-goog.require('shaka.ui.Localization');
 goog.require('shaka.util.Dom');
 
 
@@ -40,19 +39,11 @@ shaka.ui.FastForwardButton = class extends shaka.ui.Element {
         shaka.ui.Enums.MaterialDesignSVGIcons['FAST_FORWARD']);
 
     this.parent.appendChild(this.button_);
-    this.updateAriaLabel_();
 
     /** @private {!Array<number>} */
     this.fastForwardRates_ = this.controls.getConfig().fastForwardRates;
 
-    this.eventManager.listenMulti(
-        this.localization,
-        [
-          shaka.ui.Localization.LOCALE_UPDATED,
-          shaka.ui.Localization.LOCALE_CHANGED,
-        ], () => {
-          this.updateAriaLabel_();
-        });
+    this.updateLocalizedStrings();
 
     this.eventManager.listen(this.button_, 'click', () => {
       if (!this.controls.isOpaque()) {
@@ -67,10 +58,8 @@ shaka.ui.FastForwardButton = class extends shaka.ui.Element {
     });
   }
 
-  /**
-   * @private
-   */
-  updateAriaLabel_() {
+  /** @override */
+  updateLocalizedStrings() {
     this.button_.ariaLabel =
         this.localization.resolve(shaka.ui.Locales.Ids.FAST_FORWARD);
   }
diff --git a/ui/fullscreen_button.js b/ui/fullscreen_button.js
index 353f962eb5..a0612a6756 100644
--- a/ui/fullscreen_button.js
+++ b/ui/fullscreen_button.js
@@ -13,7 +13,7 @@ goog.require('shaka.ui.Element');
 goog.require('shaka.ui.Enums');
 goog.require('shaka.ui.Icon');
 goog.require('shaka.ui.Locales');
-goog.require('shaka.ui.Localization');
+goog.require('shaka.ui.Utils');
 goog.require('shaka.util.Dom');
 goog.require('shaka.util.MediaElementEvent');
 
@@ -44,19 +44,11 @@ shaka.ui.FullscreenButton = class extends shaka.ui.Element {
     this.icon_ = new shaka.ui.Icon(this.button_,
         shaka.ui.Enums.MaterialDesignSVGIcons['FULLSCREEN']);
 
-    this.checkSupport_();
+    this.checkAvailability();
 
     this.parent.appendChild(this.button_);
-    this.updateAriaLabel_();
 
-    this.eventManager.listenMulti(
-        this.localization,
-        [
-          shaka.ui.Localization.LOCALE_UPDATED,
-          shaka.ui.Localization.LOCALE_CHANGED,
-        ], () => {
-          this.updateAriaLabel_();
-        });
+    this.updateLocalizedStrings();
 
     this.eventManager.listen(this.button_, 'click', async () => {
       if (!this.controls.isOpaque()) {
@@ -68,7 +60,7 @@ shaka.ui.FullscreenButton = class extends shaka.ui.Element {
 
     this.eventManager.listen(document, 'fullscreenchange', () => {
       this.updateIcon_();
-      this.updateAriaLabel_();
+      this.updateLocalizedStrings();
     });
 
     this.eventManager.listenMulti(
@@ -77,7 +69,7 @@ shaka.ui.FullscreenButton = class extends shaka.ui.Element {
           shaka.util.MediaElementEvent.LOADED_METADATA,
           shaka.util.MediaElementEvent.LOADED_DATA,
         ], () => {
-          this.checkSupport_();
+          this.checkAvailability();
         });
 
     this.eventManager.listenMulti(
@@ -86,26 +78,12 @@ shaka.ui.FullscreenButton = class extends shaka.ui.Element {
           shaka.ads.Utils.AD_STARTED,
           shaka.ads.Utils.AD_STOPPED,
         ], () => {
-          this.checkSupport_();
+          this.checkAvailability();
         });
   }
 
-  /**
-   * @private
-   */
-  checkSupport_() {
-    // Don't show the button if fullscreen is not supported
-    if (!this.controls.isFullScreenSupported()) {
-      this.button_.classList.add('shaka-hidden');
-    } else {
-      this.button_.classList.remove('shaka-hidden');
-    }
-  }
-
-  /**
-   * @private
-   */
-  updateAriaLabel_() {
+  /** @override */
+  updateLocalizedStrings() {
     const LocIds = shaka.ui.Locales.Ids;
     const label = this.controls.isFullScreenEnabled() ?
         LocIds.EXIT_FULL_SCREEN : LocIds.FULL_SCREEN;
@@ -115,15 +93,19 @@ shaka.ui.FullscreenButton = class extends shaka.ui.Element {
         this.controls.isFullScreenEnabled() ? 'true' : 'false';
   }
 
-  /**
-   * @private
-   */
+  /** @private */
   updateIcon_() {
     this.icon_.use(this.controls.isFullScreenEnabled() ?
       shaka.ui.Enums.MaterialDesignSVGIcons['EXIT_FULLSCREEN'] :
       shaka.ui.Enums.MaterialDesignSVGIcons['FULLSCREEN'],
     );
   }
+
+  /** @override */
+  checkAvailability() {
+    shaka.ui.Utils.setDisplay(
+        this.button_, this.controls.isFullScreenSupported());
+  }
 };
 
 
diff --git a/ui/loop_button.js b/ui/loop_button.js
index 54989acfa6..2f4ece72e1 100644
--- a/ui/loop_button.js
+++ b/ui/loop_button.js
@@ -13,7 +13,6 @@ goog.require('shaka.ui.Element');
 goog.require('shaka.ui.Enums');
 goog.require('shaka.ui.Icon');
 goog.require('shaka.ui.Locales');
-goog.require('shaka.ui.Localization');
 goog.require('shaka.ui.OverflowMenu');
 goog.require('shaka.ui.Utils');
 goog.require('shaka.util.Dom');
@@ -36,7 +35,6 @@ shaka.ui.LoopButton = class extends shaka.ui.Element {
     /** @private {shaka.extern.IQueueManager} */
     this.queueManager_ = this.controls.getQueueManager();
 
-    const LocIds = shaka.ui.Locales.Ids;
     /** @private {!HTMLButtonElement} */
     this.button_ = shaka.util.Dom.createButton();
     this.button_.classList.add('shaka-loop-button');
@@ -53,7 +51,6 @@ shaka.ui.LoopButton = class extends shaka.ui.Element {
     label.classList.add('shaka-overflow-menu-only');
     label.classList.add('shaka-simple-overflow-button-label-inline');
     this.nameSpan_ = shaka.util.Dom.createHTMLElement('span');
-    this.nameSpan_.textContent = this.localization.resolve(LocIds.LOOP);
     label.appendChild(this.nameSpan_);
 
     /** @private {!HTMLElement} */
@@ -63,19 +60,10 @@ shaka.ui.LoopButton = class extends shaka.ui.Element {
 
     this.button_.appendChild(label);
 
-    this.updateLocalizedStrings_();
+    this.updateLocalizedStrings();
 
     this.parent.appendChild(this.button_);
 
-    this.eventManager.listenMulti(
-        this.localization,
-        [
-          shaka.ui.Localization.LOCALE_UPDATED,
-          shaka.ui.Localization.LOCALE_CHANGED,
-        ], () => {
-          this.updateLocalizedStrings_();
-        });
-
     this.eventManager.listen(this.button_, 'click', () => {
       if (!this.controls.isOpaque()) {
         return;
@@ -88,7 +76,7 @@ shaka.ui.LoopButton = class extends shaka.ui.Element {
       for (const mutation of mutationsList) {
         if (mutation.type === 'attributes' &&
             mutation.attributeName === 'loop') {
-          this.updateLocalizedStrings_();
+          this.updateLocalizedStrings();
         }
       }
     });
@@ -105,29 +93,18 @@ shaka.ui.LoopButton = class extends shaka.ui.Element {
           'loaded',
           'manifestupdated',
         ], () => {
-          this.checkAvailability_();
+          this.checkAvailability();
         });
 
     this.eventManager.listen(this.player, 'configurationchanged', () => {
-      this.updateLocalizedStrings_();
+      this.updateLocalizedStrings();
     });
 
     this.eventManager.listen(this.video, 'durationchange', () => {
-      this.checkAvailability_();
+      this.checkAvailability();
     });
 
-    if (this.isSubMenu) {
-      this.eventManager.listenMulti(
-          this.controls,
-          [
-            'submenuopen',
-            'submenuclose',
-          ], () => {
-            this.checkAvailability_();
-          });
-    }
-
-    this.checkAvailability_();
+    this.checkAvailability();
   }
 
   /**
@@ -163,11 +140,8 @@ shaka.ui.LoopButton = class extends shaka.ui.Element {
     }
   }
 
-
-  /**
-   * @private
-   */
-  updateLocalizedStrings_() {
+  /** @override */
+  updateLocalizedStrings() {
     const LocIds = shaka.ui.Locales.Ids;
     const Icons = shaka.ui.Enums.MaterialDesignSVGIcons;
 
@@ -206,11 +180,8 @@ shaka.ui.LoopButton = class extends shaka.ui.Element {
     }
   }
 
-
-  /**
-   * @private
-   */
-  checkAvailability_() {
+  /** @override */
+  checkAvailability() {
     shaka.ui.Utils.setDisplay(
         this.button_, !this.player.isLive() && !this.isSubMenuOpened);
   }
diff --git a/ui/mute_button.js b/ui/mute_button.js
index cadd17e687..e0955b13ba 100644
--- a/ui/mute_button.js
+++ b/ui/mute_button.js
@@ -13,7 +13,6 @@ goog.require('shaka.ui.Element');
 goog.require('shaka.ui.Enums');
 goog.require('shaka.ui.Icon');
 goog.require('shaka.ui.Locales');
-goog.require('shaka.ui.Localization');
 goog.require('shaka.ui.OverflowMenu');
 goog.require('shaka.ui.Utils');
 goog.require('shaka.util.Dom');
@@ -32,7 +31,6 @@ shaka.ui.MuteButton = class extends shaka.ui.Element {
   constructor(parent, controls) {
     super(parent, controls);
 
-    const LocIds = shaka.ui.Locales.Ids;
     /** @private {!HTMLButtonElement} */
     this.button_ = shaka.util.Dom.createButton();
     this.button_.classList.add('shaka-mute-button');
@@ -48,7 +46,6 @@ shaka.ui.MuteButton = class extends shaka.ui.Element {
     label.classList.add('shaka-overflow-button-label');
     label.classList.add('shaka-overflow-menu-only');
     this.nameSpan_ = shaka.util.Dom.createHTMLElement('span');
-    this.nameSpan_.textContent = this.localization.resolve(LocIds.MUTE);
     label.appendChild(this.nameSpan_);
 
     /** @private {!HTMLElement} */
@@ -59,18 +56,9 @@ shaka.ui.MuteButton = class extends shaka.ui.Element {
     this.button_.appendChild(label);
 
     this.parent.appendChild(this.button_);
-    this.updateLocalizedStrings_();
+    this.updateLocalizedStrings();
     this.updateIcon_();
 
-    this.eventManager.listenMulti(
-        this.localization,
-        [
-          shaka.ui.Localization.LOCALE_UPDATED,
-          shaka.ui.Localization.LOCALE_CHANGED,
-        ], () => {
-          this.updateLocalizedStrings_();
-        });
-
     this.eventManager.listen(this.button_, 'click', () => {
       if (!this.controls.isOpaque()) {
         return;
@@ -87,12 +75,12 @@ shaka.ui.MuteButton = class extends shaka.ui.Element {
     });
 
     this.eventManager.listen(this.video, 'volumechange', () => {
-      this.updateLocalizedStrings_();
+      this.updateLocalizedStrings();
       this.updateIcon_();
     });
 
     this.eventManager.listen(this.player, 'loading', () => {
-      this.updateLocalizedStrings_();
+      this.updateLocalizedStrings();
       this.updateIcon_();
     });
 
@@ -103,11 +91,11 @@ shaka.ui.MuteButton = class extends shaka.ui.Element {
           'unloading',
           'trackschanged',
         ], () => {
-          this.checkAvailability_();
+          this.checkAvailability();
         });
 
     this.eventManager.listen(this.controls, 'caststatuschanged', () => {
-      this.updateLocalizedStrings_();
+      this.updateLocalizedStrings();
       this.updateIcon_();
     });
 
@@ -117,13 +105,13 @@ shaka.ui.MuteButton = class extends shaka.ui.Element {
           shaka.ads.Utils.AD_VOLUME_CHANGED,
           shaka.ads.Utils.AD_MUTED,
         ], () => {
-          this.updateLocalizedStrings_();
+          this.updateLocalizedStrings();
           this.updateIcon_();
         });
 
     this.eventManager.listen(this.adManager,
         shaka.ads.Utils.AD_STARTED, () => {
-          this.checkAvailability_();
+          this.checkAvailability();
         });
 
     this.eventManager.listen(this.adManager,
@@ -133,18 +121,16 @@ shaka.ui.MuteButton = class extends shaka.ui.Element {
           // the label and icon code depends on this.ad being correctly
           // updated at the time it runs.
           this.ad = null;
-          this.updateLocalizedStrings_();
+          this.updateLocalizedStrings();
           this.updateIcon_();
-          this.checkAvailability_();
+          this.checkAvailability();
         });
 
-    this.checkAvailability_();
+    this.checkAvailability();
   }
 
-  /**
-   * @private
-   */
-  updateLocalizedStrings_() {
+  /** @override */
+  updateLocalizedStrings() {
     const LocIds = shaka.ui.Locales.Ids;
     let label;
     if (this.ad && this.ad.isLinear()) {
@@ -154,11 +140,9 @@ shaka.ui.MuteButton = class extends shaka.ui.Element {
           LocIds.UNMUTE : LocIds.MUTE;
     }
 
-    this.button_.ariaLabel = this.localization.resolve(label);
     this.button_.ariaLabel = this.localization.resolve(label);
     this.button_.ariaPressed = label == LocIds.UNMUTE ? 'true' : 'false';
     this.nameSpan_.textContent = this.localization.resolve(label);
-    this.nameSpan_.textContent = this.localization.resolve(label);
   }
 
   /**
@@ -176,8 +160,8 @@ shaka.ui.MuteButton = class extends shaka.ui.Element {
     this.icon_.use(icon);
   }
 
-  /** @private */
-  checkAvailability_() {
+  /** @override */
+  checkAvailability() {
     let available = true;
     if (this.ad && this.ad.isLinear()) {
       // We can't tell if the Ad has audio or not.
@@ -185,7 +169,7 @@ shaka.ui.MuteButton = class extends shaka.ui.Element {
     } else if (this.player.isVideoOnly()) {
       available = false;
     }
-    shaka.ui.Utils.setDisplay(this.button_, available);
+    shaka.ui.Utils.setDisplay(this.button_, available && !this.isSubMenuOpened);
   }
 };
 
diff --git a/ui/overflow_menu.js b/ui/overflow_menu.js
index bd89f022d5..47709b21f2 100644
--- a/ui/overflow_menu.js
+++ b/ui/overflow_menu.js
@@ -15,7 +15,6 @@ goog.require('shaka.ui.Controls');
 goog.require('shaka.ui.Enums');
 goog.require('shaka.ui.Icon');
 goog.require('shaka.ui.Locales');
-goog.require('shaka.ui.Localization');
 goog.require('shaka.ui.MenuBase');
 goog.require('shaka.ui.Utils');
 goog.require('shaka.util.Dom');
@@ -48,15 +47,6 @@ shaka.ui.OverflowMenu = class extends shaka.ui.MenuBase {
 
     this.createChildren_();
 
-    this.eventManager.listenMulti(
-        this.localization,
-        [
-          shaka.ui.Localization.LOCALE_UPDATED,
-          shaka.ui.Localization.LOCALE_CHANGED,
-        ], () => {
-          this.updateAriaLabel_();
-        });
-
     this.eventManager.listen(
         this.adManager, shaka.ads.Utils.AD_STARTED, () => {
           if (this.ad && this.ad.isLinear()) {
@@ -76,7 +66,7 @@ shaka.ui.OverflowMenu = class extends shaka.ui.MenuBase {
       this.onOverflowMenuButtonClick_();
     });
 
-    this.updateAriaLabel_();
+    this.updateLocalizedStrings();
 
     if (this.ad && this.ad.isLinear()) {
       // There was already an ad.
@@ -108,7 +98,6 @@ shaka.ui.OverflowMenu = class extends shaka.ui.MenuBase {
     }
   }
 
-
   /**
    * @private
    */
@@ -123,7 +112,6 @@ shaka.ui.OverflowMenu = class extends shaka.ui.MenuBase {
     this.controlsContainer_.appendChild(this.overflowMenu_);
   }
 
-
   /**
    * @private
    */
@@ -144,7 +132,6 @@ shaka.ui.OverflowMenu = class extends shaka.ui.MenuBase {
     this.parent.appendChild(this.overflowMenuButton_);
   }
 
-
   /**
    * @private
    */
@@ -162,7 +149,6 @@ shaka.ui.OverflowMenu = class extends shaka.ui.MenuBase {
     }
   }
 
-
   /** @private */
   onOverflowMenuButtonClick_() {
     this.controls.hideContextMenus();
@@ -194,17 +180,13 @@ shaka.ui.OverflowMenu = class extends shaka.ui.MenuBase {
     }
   }
 
-
-  /**
-   * @private
-   */
-  updateAriaLabel_() {
+  /** @override */
+  updateLocalizedStrings() {
     const LocIds = shaka.ui.Locales.Ids;
     this.overflowMenuButton_.ariaLabel =
         this.localization.resolve(LocIds.MORE_SETTINGS);
   }
 
-
   /** @override */
   adjustCustomStyle() {
     this.adjustMenuStyle(
diff --git a/ui/pip_button.js b/ui/pip_button.js
index cdf912937f..3ae27b5b05 100644
--- a/ui/pip_button.js
+++ b/ui/pip_button.js
@@ -12,7 +12,6 @@ goog.require('shaka.ui.Element');
 goog.require('shaka.ui.Enums');
 goog.require('shaka.ui.Icon');
 goog.require('shaka.ui.Locales');
-goog.require('shaka.ui.Localization');
 goog.require('shaka.ui.OverflowMenu');
 goog.require('shaka.ui.Utils');
 goog.require('shaka.util.Dom');
@@ -38,7 +37,6 @@ shaka.ui.PipButton = class extends shaka.ui.Element {
     /** @private {HTMLElement } */
     this.videoContainer_ = this.controls.getVideoContainer();
 
-    const LocIds = shaka.ui.Locales.Ids;
     /** @private {!HTMLButtonElement} */
     this.pipButton_ = shaka.util.Dom.createButton();
     this.pipButton_.classList.add('shaka-pip-button');
@@ -55,8 +53,6 @@ shaka.ui.PipButton = class extends shaka.ui.Element {
     label.classList.add('shaka-overflow-menu-only');
     label.classList.add('shaka-simple-overflow-button-label-inline');
     this.pipNameSpan_ = shaka.util.Dom.createHTMLElement('span');
-    this.pipNameSpan_.textContent =
-      this.localization.resolve(LocIds.PICTURE_IN_PICTURE);
     label.appendChild(this.pipNameSpan_);
 
     /** @private {!HTMLElement} */
@@ -66,7 +62,7 @@ shaka.ui.PipButton = class extends shaka.ui.Element {
 
     this.pipButton_.appendChild(label);
 
-    this.updateLocalizedStrings_();
+    this.updateLocalizedStrings();
 
     this.parent.appendChild(this.pipButton_);
 
@@ -77,15 +73,6 @@ shaka.ui.PipButton = class extends shaka.ui.Element {
       shaka.ui.Utils.setDisplay(this.pipButton_, false);
     }
 
-    this.eventManager.listenMulti(
-        this.localization,
-        [
-          shaka.ui.Localization.LOCALE_UPDATED,
-          shaka.ui.Localization.LOCALE_CHANGED,
-        ], () => {
-          this.updateLocalizedStrings_();
-        });
-
     this.eventManager.listen(this.pipButton_, 'click', () => {
       if (!this.controls.isOpaque()) {
         return;
@@ -102,24 +89,13 @@ shaka.ui.PipButton = class extends shaka.ui.Element {
     });
 
     this.eventManager.listen(this.controls, 'caststatuschanged', () => {
-      this.checkAvailability_();
+      this.checkAvailability();
     });
 
     this.eventManager.listen(this.player, 'trackschanged', () => {
-      this.checkAvailability_();
+      this.checkAvailability();
     });
 
-    if (this.isSubMenu) {
-      this.eventManager.listenMulti(
-          this.controls,
-          [
-            'submenuopen',
-            'submenuclose',
-          ], () => {
-            this.checkAvailability_();
-          });
-    }
-
     if ('documentPictureInPicture' in window) {
       this.eventManager.listen(window.documentPictureInPicture, 'enter',
           (e) => {
@@ -133,7 +109,7 @@ shaka.ui.PipButton = class extends shaka.ui.Element {
           });
     }
 
-    this.checkAvailability_();
+    this.checkAvailability();
   }
 
   /** @private */
@@ -147,7 +123,6 @@ shaka.ui.PipButton = class extends shaka.ui.Element {
     this.pipButton_.ariaPressed = 'true';
   }
 
-
   /** @private */
   onLeavePictureInPicture_() {
     const LocIds = shaka.ui.Locales.Ids;
@@ -159,11 +134,8 @@ shaka.ui.PipButton = class extends shaka.ui.Element {
     this.pipButton_.ariaPressed = 'false';
   }
 
-
-  /**
-   * @private
-   */
-  updateLocalizedStrings_() {
+  /** @override */
+  updateLocalizedStrings() {
     const LocIds = shaka.ui.Locales.Ids;
 
     this.pipNameSpan_.textContent =
@@ -182,15 +154,14 @@ shaka.ui.PipButton = class extends shaka.ui.Element {
         this.localization.resolve(currentPipState);
   }
 
-
   /**
    * Display the picture-in-picture button only when the content contains video.
    * If it's displaying in picture-in-picture mode, and an audio only content is
    * loaded, exit the picture-in-picture display.
    * @return {!Promise}
-   * @private
+   * @override
    */
-  async checkAvailability_() {
+  async checkAvailability() {
     if (!this.controls.isPiPAllowed()) {
       shaka.ui.Utils.setDisplay(this.pipButton_, false);
       if (this.controls.isPiPEnabled()) {
diff --git a/ui/play_button.js b/ui/play_button.js
index 7fd95ff3db..f17a90247e 100644
--- a/ui/play_button.js
+++ b/ui/play_button.js
@@ -13,7 +13,6 @@ goog.require('shaka.ui.Element');
 goog.require('shaka.ui.Enums');
 goog.require('shaka.ui.Icon');
 goog.require('shaka.ui.Locales');
-goog.require('shaka.ui.Localization');
 goog.require('shaka.util.Dom');
 goog.require('shaka.util.MediaElementEvent');
 
@@ -45,15 +44,6 @@ shaka.ui.PlayButton = class extends shaka.ui.Element {
     /** @private {!shaka.ui.Icon} */
     this.icon_ = new shaka.ui.Icon(this.button_);
 
-    this.eventManager.listenMulti(
-        this.localization,
-        [
-          shaka.ui.Localization.LOCALE_UPDATED,
-          shaka.ui.Localization.LOCALE_CHANGED,
-        ], () => {
-          this.updateAriaLabel_();
-        });
-
     this.eventManager.listenMulti(
         this.video,
         [
@@ -61,7 +51,7 @@ shaka.ui.PlayButton = class extends shaka.ui.Element {
           shaka.util.MediaElementEvent.PAUSE,
           shaka.util.MediaElementEvent.SEEKING,
         ], () => {
-          this.updateAriaLabel_();
+          this.updateLocalizedStrings();
           this.updateIcon_();
         });
 
@@ -73,7 +63,7 @@ shaka.ui.PlayButton = class extends shaka.ui.Element {
           'unloading',
           'buffering',
         ], () => {
-          this.updateAriaLabel_();
+          this.updateLocalizedStrings();
           this.updateIcon_();
         });
 
@@ -85,7 +75,7 @@ shaka.ui.PlayButton = class extends shaka.ui.Element {
           shaka.ads.Utils.AD_STARTED,
           shaka.ads.Utils.AD_STOPPED,
         ], () => {
-          this.updateAriaLabel_();
+          this.updateLocalizedStrings();
           this.updateIcon_();
         });
 
@@ -96,7 +86,7 @@ shaka.ui.PlayButton = class extends shaka.ui.Element {
       this.controls.playPausePresentation();
     });
 
-    this.updateAriaLabel_();
+    this.updateLocalizedStrings();
     this.updateIcon_();
   }
 
@@ -136,10 +126,8 @@ shaka.ui.PlayButton = class extends shaka.ui.Element {
     return this.player ? this.player.isBuffering() : false;
   }
 
-  /**
-   * @private
-   */
-  updateAriaLabel_() {
+  /** @override */
+  updateLocalizedStrings() {
     const LocIds = shaka.ui.Locales.Ids;
     if (this.isEnded_() && this.video.duration) {
       this.button_.ariaLabel = this.localization.resolve(LocIds.REPLAY);
@@ -151,7 +139,6 @@ shaka.ui.PlayButton = class extends shaka.ui.Element {
     }
   }
 
-
   /**
    * @private
    */
diff --git a/ui/playback_rate_selection.js b/ui/playback_rate_selection.js
index 8e366b031b..5931d005a0 100644
--- a/ui/playback_rate_selection.js
+++ b/ui/playback_rate_selection.js
@@ -10,7 +10,6 @@ goog.provide('shaka.ui.PlaybackRateSelection');
 goog.require('shaka.ui.Controls');
 goog.require('shaka.ui.Enums');
 goog.require('shaka.ui.Locales');
-goog.require('shaka.ui.Localization');
 goog.require('shaka.ui.OverflowMenu');
 goog.require('shaka.ui.SettingsMenu');
 goog.require('shaka.ui.Utils');
@@ -41,15 +40,6 @@ shaka.ui.PlaybackRateSelection = class extends shaka.ui.SettingsMenu {
       this.button.appendChild(this.playbackRateMark);
     }
 
-    this.eventManager.listenMulti(
-        this.localization,
-        [
-          shaka.ui.Localization.LOCALE_UPDATED,
-          shaka.ui.Localization.LOCALE_CHANGED,
-        ], () => {
-          this.updateLocalizedStrings_();
-        });
-
     this.eventManager.listenMulti(
         this.player,
         [
@@ -59,25 +49,14 @@ shaka.ui.PlaybackRateSelection = class extends shaka.ui.SettingsMenu {
           this.updatePlaybackRateSelection_();
         });
 
-    if (this.isSubMenu) {
-      this.eventManager.listen(this.controls, 'submenuopen', () => {
-        shaka.ui.Utils.setDisplay(this.button, false);
-      });
-      this.eventManager.listen(this.controls, 'submenuclose', () => {
-        shaka.ui.Utils.setDisplay(this.button, true);
-      });
-    }
-
     // Set up all the strings in the user's preferred language.
-    this.updateLocalizedStrings_();
+    this.updateLocalizedStrings();
     this.addPlaybackRates_();
     this.updatePlaybackRateSelection_();
   }
 
-  /**
-   * @private
-   */
-  updateLocalizedStrings_() {
+  /** @override */
+  updateLocalizedStrings() {
     const LocIds = shaka.ui.Locales.Ids;
 
     this.backButton.ariaLabel = this.localization.resolve(LocIds.BACK);
diff --git a/ui/queue_button.js b/ui/queue_button.js
index fdbc24572d..019ac10e0a 100644
--- a/ui/queue_button.js
+++ b/ui/queue_button.js
@@ -10,7 +10,6 @@ goog.provide('shaka.ui.QueueButton');
 goog.require('shaka.ui.Controls');
 goog.require('shaka.ui.Enums');
 goog.require('shaka.ui.Locales');
-goog.require('shaka.ui.Localization');
 goog.require('shaka.ui.OverflowMenu');
 goog.require('shaka.ui.SettingsMenu');
 goog.require('shaka.ui.Utils');
@@ -38,15 +37,6 @@ shaka.ui.QueueButton = class extends shaka.ui.SettingsMenu {
     /** @private {shaka.extern.IQueueManager} */
     this.queueManager_ = this.controls.getQueueManager();
 
-    this.eventManager.listenMulti(
-        this.localization,
-        [
-          shaka.ui.Localization.LOCALE_UPDATED,
-          shaka.ui.Localization.LOCALE_CHANGED,
-        ], () => {
-          this.updateLocalizedStrings_();
-        });
-
     this.eventManager.listenMulti(
         this.queueManager_,
         [
@@ -60,20 +50,7 @@ shaka.ui.QueueButton = class extends shaka.ui.SettingsMenu {
       this.updateCurrentItem_();
     });
 
-    if (this.isSubMenu) {
-      this.eventManager.listenMulti(
-          this.controls,
-          [
-            'submenuopen',
-            'submenuclose',
-          ], () => {
-            const hasItems = this.getDisplayableItems_().length > 1;
-            shaka.ui.Utils.setDisplay(this.button,
-                hasItems && !this.isSubMenuOpened);
-          });
-    }
-
-    this.updateLocalizedStrings_();
+    this.updateLocalizedStrings();
     this.updateQueueItems_();
   }
 
@@ -92,10 +69,8 @@ shaka.ui.QueueButton = class extends shaka.ui.SettingsMenu {
         (item) => item.metadata?.title);
   }
 
-  /**
-   * @private
-   */
-  updateLocalizedStrings_() {
+  /** @override */
+  updateLocalizedStrings() {
     const LocIds = shaka.ui.Locales.Ids;
 
     this.backButton.ariaLabel = this.localization.resolve(LocIds.BACK);
@@ -224,6 +199,12 @@ shaka.ui.QueueButton = class extends shaka.ui.SettingsMenu {
       }
     }
   }
+
+  /** @override */
+  checkAvailability() {
+    const hasItems = this.getDisplayableItems_().length > 1;
+    shaka.ui.Utils.setDisplay(this.button, hasItems && !this.isSubMenuOpened);
+  }
 };
 
 
diff --git a/ui/recenter_vr.js b/ui/recenter_vr.js
index 5b45fc28b5..fb91064795 100644
--- a/ui/recenter_vr.js
+++ b/ui/recenter_vr.js
@@ -12,7 +12,6 @@ goog.require('shaka.ui.Element');
 goog.require('shaka.ui.Enums');
 goog.require('shaka.ui.Icon');
 goog.require('shaka.ui.Locales');
-goog.require('shaka.ui.Localization');
 goog.require('shaka.ui.OverflowMenu');
 goog.require('shaka.ui.Utils');
 goog.require('shaka.util.Dom');
@@ -56,16 +55,7 @@ shaka.ui.RecenterVRButton = class extends shaka.ui.Element {
     this.parent.appendChild(this.recenterVRButton_);
 
     // Setup strings in the correct language
-    this.updateLocalizedStrings_();
-
-    this.eventManager.listenMulti(
-        this.localization,
-        [
-          shaka.ui.Localization.LOCALE_UPDATED,
-          shaka.ui.Localization.LOCALE_CHANGED,
-        ], () => {
-          this.updateLocalizedStrings_();
-        });
+    this.updateLocalizedStrings();
 
     const vr = this.controls.getVR();
 
@@ -77,37 +67,20 @@ shaka.ui.RecenterVRButton = class extends shaka.ui.Element {
     });
 
     this.eventManager.listen(vr, 'vrstatuschanged', () => {
-      this.checkAvailability_();
+      this.checkAvailability();
     });
 
-    if (this.isSubMenu) {
-      this.eventManager.listenMulti(
-          this.controls,
-          [
-            'submenuopen',
-            'submenuclose',
-          ], () => {
-            this.checkAvailability_();
-          });
-    }
-
-    this.checkAvailability_();
+    this.checkAvailability();
   }
 
-
-  /**
-   * @private
-   */
-  checkAvailability_() {
+  /** @override */
+  checkAvailability() {
     shaka.ui.Utils.setDisplay(this.recenterVRButton_,
         this.controls.isPlayingVR() && !this.isSubMenuOpened);
   }
 
-
-  /**
-   * @private
-   */
-  updateLocalizedStrings_() {
+  /** @override */
+  updateLocalizedStrings() {
     const LocIds = shaka.ui.Locales.Ids;
 
     this.recenterVRButton_.ariaLabel =
diff --git a/ui/remote_button.js b/ui/remote_button.js
index 04e4c32430..34ddcf304e 100644
--- a/ui/remote_button.js
+++ b/ui/remote_button.js
@@ -14,7 +14,6 @@ goog.require('shaka.ui.Element');
 goog.require('shaka.ui.Enums');
 goog.require('shaka.ui.Icon');
 goog.require('shaka.ui.Locales');
-goog.require('shaka.ui.Localization');
 goog.require('shaka.ui.OverflowMenu');
 goog.require('shaka.ui.Utils');
 goog.require('shaka.util.Dom');
@@ -70,25 +69,14 @@ shaka.ui.RemoteButton = class extends shaka.ui.Element {
     this.callbackId_ = -1;
 
     // Setup strings in the correct language
-    this.updateLocalizedStrings_();
+    this.updateLocalizedStrings();
 
     shaka.ui.Utils.setDisplay(this.remoteButton_, false);
 
     /** @private {?RemotePlayback} */
     this.remote_ = device.getRemote(this.video);
 
-    if (!this.remote_) {
-      this.remoteButton_.classList.add('shaka-hidden');
-    } else {
-      this.eventManager.listenMulti(
-          this.localization,
-          [
-            shaka.ui.Localization.LOCALE_UPDATED,
-            shaka.ui.Localization.LOCALE_CHANGED,
-          ], () => {
-            this.updateLocalizedStrings_();
-          });
-
+    if (this.remote_) {
       this.eventManager.listen(this.controls, 'caststatuschanged', () => {
         this.updateRemoteState_();
       });
@@ -115,17 +103,6 @@ shaka.ui.RemoteButton = class extends shaka.ui.Element {
         this.updateRemoteState_();
       });
 
-      if (this.isSubMenu) {
-        this.eventManager.listenMulti(
-            this.controls,
-            [
-              'submenuopen',
-              'submenuclose',
-            ], () => {
-              this.updateRemoteState_(/* force= */ true);
-            });
-      }
-
       this.updateRemoteState_(/* force= */ true);
       this.updateIcon_();
     }
@@ -201,10 +178,8 @@ shaka.ui.RemoteButton = class extends shaka.ui.Element {
         this.remote_?.state == 'connected' ? 'true' : 'false';
   }
 
-  /**
-   * @private
-   */
-  updateLocalizedStrings_() {
+  /** @override */
+  updateLocalizedStrings() {
     const LocIds = shaka.ui.Locales.Ids;
     const text = this.isAirPlay_ ?
         this.localization.resolve(LocIds.AIRPLAY) :
@@ -226,6 +201,11 @@ shaka.ui.RemoteButton = class extends shaka.ui.Element {
       this.remoteIcon_.use(shaka.ui.Enums.MaterialDesignSVGIcons['EXIT_CAST']);
     }
   }
+
+  /** @override */
+  checkAvailability() {
+    this.updateRemoteState_(/* force= */ true);
+  }
 };
 
 
diff --git a/ui/resolution_selection.js b/ui/resolution_selection.js
index 2f7f253946..83ff1371d4 100644
--- a/ui/resolution_selection.js
+++ b/ui/resolution_selection.js
@@ -12,7 +12,6 @@ goog.require('shaka.Player');
 goog.require('shaka.ui.Controls');
 goog.require('shaka.ui.Enums');
 goog.require('shaka.ui.Locales');
-goog.require('shaka.ui.Localization');
 goog.require('shaka.ui.OverflowMenu');
 goog.require('shaka.ui.Overlay.TrackLabelFormat');
 goog.require('shaka.ui.SettingsMenu');
@@ -68,15 +67,6 @@ shaka.ui.ResolutionSelection = class extends shaka.ui.SettingsMenu {
     spanWrapper.appendChild(this.autoQuality);
     spanWrapper.appendChild(this.qualityMark);
 
-    this.eventManager.listenMulti(
-        this.localization,
-        [
-          shaka.ui.Localization.LOCALE_UPDATED,
-          shaka.ui.Localization.LOCALE_CHANGED,
-        ], () => {
-          this.updateLocalizedStrings_();
-        });
-
     this.eventManager.listenMulti(
         this.player,
         [
@@ -92,18 +82,6 @@ shaka.ui.ResolutionSelection = class extends shaka.ui.SettingsMenu {
           this.updateLabels_();
         });
 
-    if (this.isSubMenu) {
-      this.eventManager.listenMulti(
-          this.controls,
-          [
-            'submenuopen',
-            'submenuclose',
-          ], () => {
-            this.updateSelection_();
-            this.updateLabels_();
-          });
-    }
-
     this.updateSelection_();
   }
 
@@ -264,7 +242,7 @@ shaka.ui.ResolutionSelection = class extends shaka.ui.SettingsMenu {
     this.controls.dispatchEvent(
         new shaka.util.FakeEvent('resolutionselectionupdated'));
 
-    this.updateLocalizedStrings_();
+    this.updateLocalizedStrings();
 
     shaka.ui.Utils.setDisplay(
         this.button, numberOfTracks > 0 && !this.isSubMenuOpened);
@@ -363,7 +341,6 @@ shaka.ui.ResolutionSelection = class extends shaka.ui.SettingsMenu {
     return tracks.length;
   }
 
-
   /**
    * @return {number}
    * @private
@@ -458,7 +435,6 @@ shaka.ui.ResolutionSelection = class extends shaka.ui.SettingsMenu {
     return tracks.length;
   }
 
-
   /**
    * @param {!shaka.extern.VideoTrack} track
    * @param {!Array<!shaka.extern.VideoTrack>} tracks
@@ -549,7 +525,6 @@ shaka.ui.ResolutionSelection = class extends shaka.ui.SettingsMenu {
     return text;
   }
 
-
   /**
    * @param {!shaka.extern.VideoTrack} track
    * @return {boolean}
@@ -563,7 +538,6 @@ shaka.ui.ResolutionSelection = class extends shaka.ui.SettingsMenu {
     return codec.startsWith('dovi-');
   }
 
-
   /**
    * @param {!shaka.extern.VideoTrack} track
    * @return {boolean}
@@ -577,7 +551,6 @@ shaka.ui.ResolutionSelection = class extends shaka.ui.SettingsMenu {
     return codec.startsWith('lcevc');
   }
 
-
   /**
    * @param {?string} codecs
    * @return {string}
@@ -592,7 +565,6 @@ shaka.ui.ResolutionSelection = class extends shaka.ui.SettingsMenu {
     return name ? ' ' + name : name;
   }
 
-
   /**
    * @param {!shaka.extern.Track} track
    * @param {!Array<!shaka.extern.Track>} tracks
@@ -620,7 +592,6 @@ shaka.ui.ResolutionSelection = class extends shaka.ui.SettingsMenu {
     return text;
   }
 
-
   /**
    * @param {number} bandwidth
    * @return {string}
@@ -634,7 +605,6 @@ shaka.ui.ResolutionSelection = class extends shaka.ui.SettingsMenu {
     }
   }
 
-
   /**
    * @param {!shaka.extern.VideoTrack} track
    * @private
@@ -647,7 +617,6 @@ shaka.ui.ResolutionSelection = class extends shaka.ui.SettingsMenu {
     this.player.selectVideoTrack(track, clearBuffer);
   }
 
-
   /**
    * @param {!shaka.extern.Track} track
    * @private
@@ -660,11 +629,8 @@ shaka.ui.ResolutionSelection = class extends shaka.ui.SettingsMenu {
     this.player.selectVariantTrack(track, clearBuffer);
   }
 
-
-  /**
-   * @private
-   */
-  updateLocalizedStrings_() {
+  /** @override */
+  updateLocalizedStrings() {
     const LocIds = shaka.ui.Locales.Ids;
     const locId = this.player.isAudioOnly() ?
         LocIds.QUALITY : LocIds.RESOLUTION;
@@ -683,6 +649,12 @@ shaka.ui.ResolutionSelection = class extends shaka.ui.SettingsMenu {
           this.localization.resolve(shaka.ui.Locales.Ids.AUTO_QUALITY);
     }
   }
+
+  /** @override */
+  checkAvailability() {
+    this.updateSelection_();
+    this.updateLabels_();
+  }
 };
 
 
diff --git a/ui/rewind_button.js b/ui/rewind_button.js
index 79558ef88d..ad6b3966a8 100644
--- a/ui/rewind_button.js
+++ b/ui/rewind_button.js
@@ -12,7 +12,6 @@ goog.require('shaka.ui.Element');
 goog.require('shaka.ui.Enums');
 goog.require('shaka.ui.Icon');
 goog.require('shaka.ui.Locales');
-goog.require('shaka.ui.Localization');
 goog.require('shaka.util.Dom');
 
 
@@ -41,20 +40,11 @@ shaka.ui.RewindButton = class extends shaka.ui.Element {
         shaka.ui.Enums.MaterialDesignSVGIcons['REWIND']);
 
     this.parent.appendChild(this.button_);
-    this.updateAriaLabel_();
+    this.updateLocalizedStrings();
 
     /** @private {!Array<number>} */
     this.rewindRates_ = this.controls.getConfig().rewindRates;
 
-    this.eventManager.listenMulti(
-        this.localization,
-        [
-          shaka.ui.Localization.LOCALE_UPDATED,
-          shaka.ui.Localization.LOCALE_CHANGED,
-        ], () => {
-          this.updateAriaLabel_();
-        });
-
     this.eventManager.listen(this.button_, 'click', () => {
       if (!this.controls.isOpaque()) {
         return;
@@ -68,10 +58,8 @@ shaka.ui.RewindButton = class extends shaka.ui.Element {
     });
   }
 
-  /**
-   * @private
-   */
-  updateAriaLabel_() {
+  /** @override */
+  updateLocalizedStrings() {
     this.button_.ariaLabel =
         this.localization.resolve(shaka.ui.Locales.Ids.REWIND);
   }
diff --git a/ui/save_video_frame_button.js b/ui/save_video_frame_button.js
index a94b5cbf13..99c580c76c 100644
--- a/ui/save_video_frame_button.js
+++ b/ui/save_video_frame_button.js
@@ -14,7 +14,6 @@ goog.require('shaka.ui.Element');
 goog.require('shaka.ui.Enums');
 goog.require('shaka.ui.Icon');
 goog.require('shaka.ui.Locales');
-goog.require('shaka.ui.Localization');
 goog.require('shaka.ui.OverflowMenu');
 goog.require('shaka.ui.Utils');
 goog.require('shaka.util.Dom');
@@ -37,7 +36,6 @@ shaka.ui.SaveVideoFrameButton = class extends shaka.ui.Element {
     /** @private {shaka.cast.CastProxy} */
     this.castProxy_ = this.controls.getCastProxy();
 
-    const LocIds = shaka.ui.Locales.Ids;
     /** @private {!HTMLButtonElement} */
     this.button_ = shaka.util.Dom.createButton();
     this.button_.classList.add('shaka-save.video-frame-button');
@@ -51,8 +49,6 @@ shaka.ui.SaveVideoFrameButton = class extends shaka.ui.Element {
     label.classList.add('shaka-overflow-button-label');
     label.classList.add('shaka-overflow-menu-only');
     this.nameSpan_ = shaka.util.Dom.createHTMLElement('span');
-    this.nameSpan_.textContent =
-        this.localization.resolve(LocIds.DOWNLOAD_VIDEO_FRAME);
     label.appendChild(this.nameSpan_);
 
     /** @private {!HTMLElement} */
@@ -62,26 +58,17 @@ shaka.ui.SaveVideoFrameButton = class extends shaka.ui.Element {
 
     this.button_.appendChild(label);
 
-    this.updateLocalizedStrings_();
+    this.updateLocalizedStrings();
 
     this.parent.appendChild(this.button_);
 
-    this.eventManager.listenMulti(
-        this.localization,
-        [
-          shaka.ui.Localization.LOCALE_UPDATED,
-          shaka.ui.Localization.LOCALE_CHANGED,
-        ], () => {
-          this.updateLocalizedStrings_();
-        });
-
     this.eventManager.listen(this.button_, 'click', () => {
       this.controls.takeScreenshot();
     });
 
     const vr = this.controls.getVR();
     this.eventManager.listen(vr, 'vrstatuschanged', () => {
-      this.checkAvailability_();
+      this.checkAvailability();
     });
 
     this.eventManager.listenMulti(
@@ -90,7 +77,7 @@ shaka.ui.SaveVideoFrameButton = class extends shaka.ui.Element {
           shaka.ads.Utils.AD_STARTED,
           shaka.ads.Utils.AD_STOPPED,
         ], () => {
-          this.checkAvailability_();
+          this.checkAvailability();
         });
 
     this.eventManager.listenMulti(
@@ -99,7 +86,7 @@ shaka.ui.SaveVideoFrameButton = class extends shaka.ui.Element {
           'unloading',
           'loaded',
         ], () => {
-          this.checkAvailability_();
+          this.checkAvailability();
         });
 
     this.eventManager.listenMulti(
@@ -109,41 +96,24 @@ shaka.ui.SaveVideoFrameButton = class extends shaka.ui.Element {
           shaka.util.MediaElementEvent.PAUSE,
           shaka.util.MediaElementEvent.SEEKING,
         ], () => {
-          this.checkAvailability_();
+          this.checkAvailability();
         });
 
     this.eventManager.listen(this.controls, 'caststatuschanged', () => {
-      this.checkAvailability_();
+      this.checkAvailability();
     });
 
-    if (this.isSubMenu) {
-      this.eventManager.listenMulti(
-          this.controls,
-          [
-            'submenuopen',
-            'submenuclose',
-          ], () => {
-            this.checkAvailability_();
-          });
-    }
-
-    this.checkAvailability_();
+    this.checkAvailability();
   }
 
-
-  /**
-   * @private
-   */
-  checkAvailability_() {
+  /** @override */
+  checkAvailability() {
     shaka.ui.Utils.setDisplay(this.button_,
         this.controls.canTakeScreenshot() && !this.isSubMenuOpened);
   }
 
-
-  /**
-   * @private
-   */
-  updateLocalizedStrings_() {
+  /** @override */
+  updateLocalizedStrings() {
     const LocIds = shaka.ui.Locales.Ids;
 
     this.button_.ariaLabel =
diff --git a/ui/seek_bar.js b/ui/seek_bar.js
index 1e6892bfa1..3a2ec5bd49 100644
--- a/ui/seek_bar.js
+++ b/ui/seek_bar.js
@@ -11,7 +11,6 @@ goog.require('shaka.ads.Utils');
 goog.require('shaka.net.NetworkingEngine');
 goog.require('shaka.net.NetworkingUtils');
 goog.require('shaka.ui.Locales');
-goog.require('shaka.ui.Localization');
 goog.require('shaka.ui.RangeElement');
 goog.require('shaka.ui.Utils');
 goog.require('shaka.util.Dom');
@@ -179,15 +178,6 @@ shaka.ui.SeekBar = class extends shaka.ui.RangeElement {
       this.controls.hideSettingsMenus();
     });
 
-    this.eventManager.listenMulti(
-        this.localization,
-        [
-          shaka.ui.Localization.LOCALE_UPDATED,
-          shaka.ui.Localization.LOCALE_CHANGED,
-        ], () => {
-          this.updateAriaLabel_();
-        });
-
     this.eventManager.listen(
         this.adManager, shaka.ads.Utils.AD_STARTED, () => {
           if (!this.shouldBeDisplayed_()) {
@@ -254,7 +244,7 @@ shaka.ui.SeekBar = class extends shaka.ui.RangeElement {
     // Initialize seek state and label.
     this.setValue(this.video.currentTime);
     this.update();
-    this.updateAriaLabel_();
+    this.updateLocalizedStrings();
 
     if (this.ad) {
       // There was already an ad.
@@ -627,8 +617,8 @@ shaka.ui.SeekBar = class extends shaka.ui.RangeElement {
     return this.ad == null || !this.ad.isLinear();
   }
 
-  /** @private */
-  updateAriaLabel_() {
+  /** @override */
+  updateLocalizedStrings() {
     this.bar.ariaLabel = this.localization.resolve(shaka.ui.Locales.Ids.SEEK);
   }
 
diff --git a/ui/settings_menu.js b/ui/settings_menu.js
index a9403906ca..3c7b6487b4 100644
--- a/ui/settings_menu.js
+++ b/ui/settings_menu.js
@@ -263,4 +263,9 @@ shaka.ui.SettingsMenu = class extends shaka.ui.MenuBase {
         this.button,
         this.controls.getControlsContainer());
   }
+
+  /** @override */
+  checkAvailability() {
+    shaka.ui.Utils.setDisplay(this.button, !this.isSubMenuOpened);
+  }
 };
diff --git a/ui/skip_ad_button.js b/ui/skip_ad_button.js
index 145d8276db..bc297b70e7 100644
--- a/ui/skip_ad_button.js
+++ b/ui/skip_ad_button.js
@@ -11,7 +11,6 @@ goog.require('goog.asserts');
 goog.require('shaka.ads.Utils');
 goog.require('shaka.ui.Element');
 goog.require('shaka.ui.Locales');
-goog.require('shaka.ui.Localization');
 goog.require('shaka.ui.Utils');
 goog.require('shaka.util.Dom');
 goog.require('shaka.util.Timer');
@@ -49,8 +48,7 @@ shaka.ui.SkipAdButton = class extends shaka.ui.Element {
     shaka.ui.Utils.setDisplay(this.button_, false);
     this.button_.classList.add('shaka-no-propagation');
     this.container_.appendChild(this.button_);
-    this.updateAriaLabel_();
-    this.updateLocalizedStrings_();
+    this.updateLocalizedStrings();
 
     /**
      * The timer that tracks down the ad progress until it can be skipped.
@@ -61,16 +59,6 @@ shaka.ui.SkipAdButton = class extends shaka.ui.Element {
       this.onTimerTick_();
     });
 
-    this.eventManager.listenMulti(
-        this.localization,
-        [
-          shaka.ui.Localization.LOCALE_UPDATED,
-          shaka.ui.Localization.LOCALE_CHANGED,
-        ], () => {
-          this.updateAriaLabel_();
-          this.updateLocalizedStrings_();
-        });
-
     this.eventManager.listen(
         this.adManager, shaka.ads.Utils.AD_STARTED, () => {
           this.onAdStarted_();
@@ -97,28 +85,17 @@ shaka.ui.SkipAdButton = class extends shaka.ui.Element {
     }
   }
 
-  /**
-   * @override
-   */
+  /** @override */
   release() {
     this.timer_.stop();
     this.timer_ = null;
     super.release();
   }
 
-  /**
-   * @private
-   */
-  updateLocalizedStrings_() {
+  /** @override */
+  updateLocalizedStrings() {
     const LocIds = shaka.ui.Locales.Ids;
     this.button_.textContent = this.localization.resolve(LocIds.SKIP_AD);
-  }
-
-  /**
-   * @private
-   */
-  updateAriaLabel_() {
-    const LocIds = shaka.ui.Locales.Ids;
     this.button_.ariaLabel = this.localization.resolve(LocIds.SKIP_AD);
   }
 
diff --git a/ui/skip_next_button.js b/ui/skip_next_button.js
index 4674a6a9e5..5a8500f634 100644
--- a/ui/skip_next_button.js
+++ b/ui/skip_next_button.js
@@ -12,7 +12,6 @@ goog.require('shaka.ui.Element');
 goog.require('shaka.ui.Enums');
 goog.require('shaka.ui.Icon');
 goog.require('shaka.ui.Locales');
-goog.require('shaka.ui.Localization');
 goog.require('shaka.ui.Utils');
 goog.require('shaka.util.Dom');
 
@@ -49,17 +48,8 @@ shaka.ui.SkipNextButton = class extends shaka.ui.Element {
         shaka.ui.Enums.MaterialDesignSVGIcons['SKIP_NEXT']);
     this.parent.appendChild(this.button_);
 
-    this.updateAriaLabel_();
-    this.checkAvailability_();
-
-    this.eventManager.listenMulti(
-        this.localization,
-        [
-          shaka.ui.Localization.LOCALE_UPDATED,
-          shaka.ui.Localization.LOCALE_CHANGED,
-        ], () => {
-          this.updateAriaLabel_();
-        });
+    this.updateLocalizedStrings();
+    this.checkAvailability();
 
     this.eventManager.listen(this.button_, 'click', () => {
       if (!this.controls.isOpaque()) {
@@ -75,24 +65,22 @@ shaka.ui.SkipNextButton = class extends shaka.ui.Element {
           'itemsinserted',
           'itemsremoved',
         ], () => {
-          this.checkAvailability_();
+          this.checkAvailability();
         });
 
     this.eventManager.listen(this.player, 'loading', () => {
-      this.checkAvailability_();
+      this.checkAvailability();
     });
   }
 
-  /**
-   * @private
-   */
-  updateAriaLabel_() {
+  /** @override */
+  updateLocalizedStrings() {
     this.button_.ariaLabel =
         this.localization.resolve(shaka.ui.Locales.Ids.SKIP_NEXT);
   }
 
-  /** @private */
-  checkAvailability_() {
+  /** @override */
+  checkAvailability() {
     const itemsLength = this.queueManager_.getItems().length;
     const hasNext = itemsLength > 1 &&
       (this.queueManager_.getCurrentItemIndex() + 1) < itemsLength;
diff --git a/ui/skip_previous_button.js b/ui/skip_previous_button.js
index ca982b9346..403f6819f4 100644
--- a/ui/skip_previous_button.js
+++ b/ui/skip_previous_button.js
@@ -12,7 +12,6 @@ goog.require('shaka.ui.Element');
 goog.require('shaka.ui.Enums');
 goog.require('shaka.ui.Icon');
 goog.require('shaka.ui.Locales');
-goog.require('shaka.ui.Localization');
 goog.require('shaka.ui.Utils');
 goog.require('shaka.util.Dom');
 
@@ -49,17 +48,8 @@ shaka.ui.SkipPreviousButton = class extends shaka.ui.Element {
         shaka.ui.Enums.MaterialDesignSVGIcons['SKIP_PREVIOUS']);
     this.parent.appendChild(this.button_);
 
-    this.updateAriaLabel_();
-    this.checkAvailability_();
-
-    this.eventManager.listenMulti(
-        this.localization,
-        [
-          shaka.ui.Localization.LOCALE_UPDATED,
-          shaka.ui.Localization.LOCALE_CHANGED,
-        ], () => {
-          this.updateAriaLabel_();
-        });
+    this.updateLocalizedStrings();
+    this.checkAvailability();
 
     this.eventManager.listen(this.button_, 'click', () => {
       if (!this.controls.isOpaque()) {
@@ -75,24 +65,22 @@ shaka.ui.SkipPreviousButton = class extends shaka.ui.Element {
           'itemsinserted',
           'itemsremoved',
         ], () => {
-          this.checkAvailability_();
+          this.checkAvailability();
         });
 
     this.eventManager.listen(this.player, 'loading', () => {
-      this.checkAvailability_();
+      this.checkAvailability();
     });
   }
 
-  /**
-   * @private
-   */
-  updateAriaLabel_() {
+  /** @override */
+  updateLocalizedStrings() {
     this.button_.ariaLabel =
         this.localization.resolve(shaka.ui.Locales.Ids.SKIP_PREVIOUS);
   }
 
-  /** @private */
-  checkAvailability_() {
+  /** @override */
+  checkAvailability() {
     const itemsLength = this.queueManager_.getItems().length;
     const hasPrevious = itemsLength > 1 &&
         this.queueManager_.getCurrentItemIndex() > 0;
diff --git a/ui/statistics_button.js b/ui/statistics_button.js
index f2a9aa25b4..926d57496e 100644
--- a/ui/statistics_button.js
+++ b/ui/statistics_button.js
@@ -13,7 +13,6 @@ goog.require('shaka.ui.Element');
 goog.require('shaka.ui.Enums');
 goog.require('shaka.ui.Icon');
 goog.require('shaka.ui.Locales');
-goog.require('shaka.ui.Localization');
 goog.require('shaka.ui.OverflowMenu');
 goog.require('shaka.ui.Utils');
 goog.require('shaka.util.Dom');
@@ -177,32 +176,14 @@ shaka.ui.StatisticsButton = class extends shaka.ui.Element {
       this.onTimerTick_();
     });
 
-    this.updateLocalizedStrings_();
+    this.updateLocalizedStrings();
 
     this.loadContainer_();
 
-    this.eventManager.listenMulti(
-        this.localization,
-        [
-          shaka.ui.Localization.LOCALE_UPDATED,
-          shaka.ui.Localization.LOCALE_CHANGED,
-        ], () => {
-          this.updateLocalizedStrings_();
-        });
-
     this.eventManager.listen(this.button_, 'click', () => {
       this.onClick_();
-      this.updateLocalizedStrings_();
+      this.updateLocalizedStrings();
     });
-
-    if (this.isSubMenu) {
-      this.eventManager.listen(this.controls, 'submenuopen', () => {
-        shaka.ui.Utils.setDisplay(this.button_, false);
-      });
-      this.eventManager.listen(this.controls, 'submenuclose', () => {
-        shaka.ui.Utils.setDisplay(this.button_, true);
-      });
-    }
   }
 
   /** @private */
@@ -220,8 +201,8 @@ shaka.ui.StatisticsButton = class extends shaka.ui.Element {
     }
   }
 
-  /** @private */
-  updateLocalizedStrings_() {
+  /** @override */
+  updateLocalizedStrings() {
     const LocIds = shaka.ui.Locales.Ids;
 
     this.nameSpan_.textContent =
@@ -303,6 +284,11 @@ shaka.ui.StatisticsButton = class extends shaka.ui.Element {
     this.timer_ = null;
     super.release();
   }
+
+  /** @override */
+  checkAvailability() {
+    shaka.ui.Utils.setDisplay(this.button_, !this.isSubMenuOpened);
+  }
 };
 
 
diff --git a/ui/text_position.js b/ui/text_position.js
index b5ed0f4c3f..898f08caff 100644
--- a/ui/text_position.js
+++ b/ui/text_position.js
@@ -11,7 +11,6 @@ goog.require('shaka.config.PositionArea');
 goog.require('shaka.ui.Controls');
 goog.require('shaka.ui.Enums');
 goog.require('shaka.ui.Locales');
-goog.require('shaka.ui.Localization');
 goog.require('shaka.ui.OverflowMenu');
 goog.require('shaka.ui.SettingsMenu');
 goog.require('shaka.ui.Utils');
@@ -37,15 +36,6 @@ shaka.ui.TextPosition = class extends shaka.ui.SettingsMenu {
     this.button.classList.add('shaka-tooltip');
     this.menu.classList.add('shaka-text-positions');
 
-    this.eventManager.listenMulti(
-        this.localization,
-        [
-          shaka.ui.Localization.LOCALE_UPDATED,
-          shaka.ui.Localization.LOCALE_CHANGED,
-        ], () => {
-          this.updateLocalizedStrings_();
-        });
-
     this.eventManager.listenMulti(
         this.player,
         [
@@ -55,30 +45,19 @@ shaka.ui.TextPosition = class extends shaka.ui.SettingsMenu {
           'trackschanged',
         ], () => {
           this.updateTextPositionSelection_();
-          this.checkAvailability_();
+          this.checkAvailability();
         });
 
-    if (this.isSubMenu) {
-      this.eventManager.listenMulti(
-          this.controls,
-          [
-            'submenuopen',
-            'submenuclose',
-          ], () => {
-            this.checkAvailability_();
-          });
-    }
-
     // Set up all the strings in the user's preferred language.
-    this.updateLocalizedStrings_();
+    this.updateLocalizedStrings();
 
-    this.checkAvailability_();
+    this.checkAvailability();
     this.addTextPositions_();
     this.updateTextPositionSelection_();
   }
 
-  /** @private */
-  checkAvailability_() {
+  /** @override */
+  checkAvailability() {
     const tracks = this.player.getTextTracks() || [];
     const hasTrack = tracks.some((track) => track.active);
     const available = hasTrack && !this.isSubMenuOpened &&
@@ -91,10 +70,8 @@ shaka.ui.TextPosition = class extends shaka.ui.SettingsMenu {
     }
   }
 
-  /**
-   * @private
-   */
-  updateLocalizedStrings_() {
+  /** @override */
+  updateLocalizedStrings() {
     const LocIds = shaka.ui.Locales.Ids;
 
     this.button.ariaLabel = this.localization.resolve(LocIds.SUBTITLE_POSITION);
diff --git a/ui/text_selection.js b/ui/text_selection.js
index a8e2fa5e77..6d6746a97b 100644
--- a/ui/text_selection.js
+++ b/ui/text_selection.js
@@ -11,7 +11,6 @@ goog.require('shaka.ui.Controls');
 goog.require('shaka.ui.Enums');
 goog.require('shaka.ui.LanguageUtils');
 goog.require('shaka.ui.Locales');
-goog.require('shaka.ui.Localization');
 goog.require('shaka.ui.OverflowMenu');
 goog.require('shaka.ui.SettingsMenu');
 goog.require('shaka.ui.Utils');
@@ -52,19 +51,6 @@ shaka.ui.TextSelection = class extends shaka.ui.SettingsMenu {
 
     this.addOffOption_();
 
-    this.eventManager.listenMulti(
-        this.localization,
-        [
-          shaka.ui.Localization.LOCALE_UPDATED,
-          shaka.ui.Localization.LOCALE_CHANGED,
-        ], () => {
-          this.updateLocalizedStrings_();
-          // If captions/subtitles are off, this string needs localization.
-          // TODO: is there a more efficient way of updating just the strings
-          // we need instead of running the whole language update?
-          this.updateTextLanguages_();
-        });
-
     this.eventManager.listenMulti(
         this.player,
         [
@@ -81,22 +67,11 @@ shaka.ui.TextSelection = class extends shaka.ui.SettingsMenu {
       this.updateTextLanguages_();
     });
 
-    if (this.isSubMenu) {
-      this.eventManager.listenMulti(
-          this.controls,
-          [
-            'submenuopen',
-            'submenuclose',
-          ], () => {
-            this.updateTextLanguages_();
-          });
-    }
-
     // Initialize caption state with a fake event.
     this.onCaptionStateChange_();
 
     // Set up all the strings in the user's preferred language.
-    this.updateLocalizedStrings_();
+    this.updateLocalizedStrings();
 
     this.updateTextLanguages_();
   }
@@ -208,11 +183,8 @@ shaka.ui.TextSelection = class extends shaka.ui.SettingsMenu {
     });
   }
 
-
-  /**
-   * @private
-   */
-  updateLocalizedStrings_() {
+  /** @override */
+  updateLocalizedStrings() {
     const LocIds = shaka.ui.Locales.Ids;
 
     this.button.ariaLabel = this.localization.resolve(LocIds.CAPTIONS);
@@ -223,6 +195,16 @@ shaka.ui.TextSelection = class extends shaka.ui.SettingsMenu {
         this.localization.resolve(LocIds.CAPTIONS);
     this.captionsOffSpan_.textContent =
         this.localization.resolve(LocIds.OFF);
+
+    // If captions/subtitles are off, this string needs localization.
+    // TODO: is there a more efficient way of updating just the strings
+    // we need instead of running the whole language update?
+    this.updateTextLanguages_();
+  }
+
+  /** @override */
+  checkAvailability() {
+    this.updateTextLanguages_();
   }
 };
 
diff --git a/ui/text_size.js b/ui/text_size.js
index 9b8494fac5..eb82df10d1 100644
--- a/ui/text_size.js
+++ b/ui/text_size.js
@@ -10,7 +10,6 @@ goog.provide('shaka.ui.TextSize');
 goog.require('shaka.ui.Controls');
 goog.require('shaka.ui.Enums');
 goog.require('shaka.ui.Locales');
-goog.require('shaka.ui.Localization');
 goog.require('shaka.ui.OverflowMenu');
 goog.require('shaka.ui.SettingsMenu');
 goog.require('shaka.ui.Utils');
@@ -36,15 +35,6 @@ shaka.ui.TextSize = class extends shaka.ui.SettingsMenu {
     this.button.classList.add('shaka-tooltip');
     this.menu.classList.add('shaka-text-positions');
 
-    this.eventManager.listenMulti(
-        this.localization,
-        [
-          shaka.ui.Localization.LOCALE_UPDATED,
-          shaka.ui.Localization.LOCALE_CHANGED,
-        ], () => {
-          this.updateLocalizedStrings_();
-        });
-
     this.eventManager.listenMulti(
         this.player,
         [
@@ -54,30 +44,19 @@ shaka.ui.TextSize = class extends shaka.ui.SettingsMenu {
           'trackschanged',
         ], () => {
           this.updateTextSizeSelection_();
-          this.checkAvailability_();
+          this.checkAvailability();
         });
 
-    if (this.isSubMenu) {
-      this.eventManager.listenMulti(
-          this.controls,
-          [
-            'submenuopen',
-            'submenuclose',
-          ], () => {
-            this.checkAvailability_();
-          });
-    }
-
     // Set up all the strings in the user's preferred language.
-    this.updateLocalizedStrings_();
+    this.updateLocalizedStrings();
 
-    this.checkAvailability_();
+    this.checkAvailability();
     this.addTextSizes_();
     this.updateTextSizeSelection_();
   }
 
-  /** @private */
-  checkAvailability_() {
+  /** @override */
+  checkAvailability() {
     const tracks = this.player.getTextTracks() || [];
     const hasTrack = tracks.some((track) => track.active);
     const available = hasTrack && !this.isSubMenuOpened &&
@@ -90,10 +69,8 @@ shaka.ui.TextSize = class extends shaka.ui.SettingsMenu {
     }
   }
 
-  /**
-   * @private
-   */
-  updateLocalizedStrings_() {
+  /** @override */
+  updateLocalizedStrings() {
     const LocIds = shaka.ui.Locales.Ids;
 
     this.button.ariaLabel = this.localization.resolve(LocIds.SUBTITLE_SIZE);
diff --git a/ui/toggle_stereoscopic.js b/ui/toggle_stereoscopic.js
index e7e0e07d34..9c2931f1c0 100644
--- a/ui/toggle_stereoscopic.js
+++ b/ui/toggle_stereoscopic.js
@@ -12,7 +12,6 @@ goog.require('shaka.ui.Element');
 goog.require('shaka.ui.Enums');
 goog.require('shaka.ui.Icon');
 goog.require('shaka.ui.Locales');
-goog.require('shaka.ui.Localization');
 goog.require('shaka.ui.OverflowMenu');
 goog.require('shaka.ui.Utils');
 goog.require('shaka.util.Dom');
@@ -59,16 +58,7 @@ shaka.ui.ToggleStereoscopicButton = class extends shaka.ui.Element {
     this.parent.appendChild(this.toggleStereoscopicButton_);
 
     // Setup strings in the correct language
-    this.updateLocalizedStrings_();
-
-    this.eventManager.listenMulti(
-        this.localization,
-        [
-          shaka.ui.Localization.LOCALE_UPDATED,
-          shaka.ui.Localization.LOCALE_CHANGED,
-        ], () => {
-          this.updateLocalizedStrings_();
-        });
+    this.updateLocalizedStrings();
 
     const vr = this.controls.getVR();
 
@@ -82,37 +72,20 @@ shaka.ui.ToggleStereoscopicButton = class extends shaka.ui.Element {
     });
 
     this.eventManager.listen(vr, 'vrstatuschanged', () => {
-      this.checkAvailability_();
+      this.checkAvailability();
     });
 
-    if (this.isSubMenu) {
-      this.eventManager.listenMulti(
-          this.controls,
-          [
-            'submenuopen',
-            'submenuclose',
-          ], () => {
-            this.checkAvailability_();
-          });
-    }
-
-    this.checkAvailability_();
+    this.checkAvailability();
   }
 
-
-  /**
-   * @private
-   */
-  checkAvailability_() {
+  /** @override */
+  checkAvailability() {
     shaka.ui.Utils.setDisplay(this.toggleStereoscopicButton_,
         this.controls.isPlayingVR() && !this.isSubMenuOpened);
   }
 
-
-  /**
-   * @private
-   */
-  updateLocalizedStrings_() {
+  /** @override */
+  updateLocalizedStrings() {
     const LocIds = shaka.ui.Locales.Ids;
 
     this.toggleStereoscopicButton_.ariaLabel =
diff --git a/ui/video_type_selection.js b/ui/video_type_selection.js
index 990b771f09..f8b40d9628 100644
--- a/ui/video_type_selection.js
+++ b/ui/video_type_selection.js
@@ -10,7 +10,6 @@ goog.provide('shaka.ui.VideoTypeSelection');
 goog.require('shaka.ui.Controls');
 goog.require('shaka.ui.Enums');
 goog.require('shaka.ui.Locales');
-goog.require('shaka.ui.Localization');
 goog.require('shaka.ui.OverflowMenu');
 goog.require('shaka.ui.SettingsMenu');
 goog.require('shaka.ui.Utils');
@@ -35,16 +34,6 @@ shaka.ui.VideoTypeSelection = class extends shaka.ui.SettingsMenu {
     this.menu.classList.add('shaka-video-type');
     this.button.classList.add('shaka-tooltip-status');
 
-    this.eventManager.listenMulti(
-        this.localization,
-        [
-          shaka.ui.Localization.LOCALE_UPDATED,
-          shaka.ui.Localization.LOCALE_CHANGED,
-        ], () => {
-          this.updateLocalizedStrings_();
-          this.updateVideoRoles_();
-        });
-
     this.eventManager.listenMulti(
         this.player,
         [
@@ -59,32 +48,24 @@ shaka.ui.VideoTypeSelection = class extends shaka.ui.SettingsMenu {
           this.updateVideoRoles_();
         });
 
-    if (this.isSubMenu) {
-      this.eventManager.listenMulti(
-          this.controls,
-          [
-            'submenuopen',
-            'submenuclose',
-          ], () => {
-            this.updateVideoRoles_();
-          });
-    }
-
-    // Set up all the strings in the user's preferred language.
-    this.updateLocalizedStrings_();
-    this.updateVideoRoles_();
+    this.updateLocalizedStrings();
   }
 
-  /**
-   * @private
-   */
-  updateLocalizedStrings_() {
+  /** @override */
+  updateLocalizedStrings() {
     const LocIds = shaka.ui.Locales.Ids;
 
     this.backButton.ariaLabel = this.localization.resolve(LocIds.BACK);
     this.button.ariaLabel = this.localization.resolve(LocIds.VIDEO_TYPE);
     this.nameSpan.textContent = this.localization.resolve(LocIds.VIDEO_TYPE);
     this.backSpan.textContent = this.localization.resolve(LocIds.VIDEO_TYPE);
+
+    this.updateVideoRoles_();
+  }
+
+  /** @override */
+  checkAvailability() {
+    this.updateVideoRoles_();
   }
 
   /**
diff --git a/ui/volume_bar.js b/ui/volume_bar.js
index 9a8fd8e36c..a4d3c18c58 100644
--- a/ui/volume_bar.js
+++ b/ui/volume_bar.js
@@ -11,7 +11,6 @@ goog.require('goog.asserts');
 goog.require('shaka.ads.Utils');
 goog.require('shaka.ui.Controls');
 goog.require('shaka.ui.Locales');
-goog.require('shaka.ui.Localization');
 goog.require('shaka.ui.RangeElement');
 goog.require('shaka.ui.Utils');
 
@@ -57,7 +56,7 @@ shaka.ui.VolumeBar = class extends shaka.ui.RangeElement {
           'unloading',
           'trackschanged',
         ], () => {
-          this.checkAvailability_();
+          this.checkAvailability();
         });
 
     this.eventManager.listen(this.controls,
@@ -74,33 +73,24 @@ shaka.ui.VolumeBar = class extends shaka.ui.RangeElement {
 
     this.eventManager.listen(this.adManager,
         shaka.ads.Utils.AD_STARTED,
-        () => this.checkAvailability_());
+        () => this.checkAvailability());
 
     this.eventManager.listen(this.adManager,
         shaka.ads.Utils.AD_STOPPED, () => {
-          this.checkAvailability_();
+          this.checkAvailability();
           this.onPresentationVolumeChange_();
         });
 
-    this.eventManager.listenMulti(
-        this.localization,
-        [
-          shaka.ui.Localization.LOCALE_UPDATED,
-          shaka.ui.Localization.LOCALE_CHANGED,
-        ], () => {
-          this.updateAriaLabel_();
-        });
-
     // Initialize volume display and label.
     this.onPresentationVolumeChange_();
-    this.updateAriaLabel_();
+    this.updateLocalizedStrings();
 
     if (this.ad) {
       // There was already an ad.
       this.onChange();
     }
 
-    this.checkAvailability_();
+    this.checkAvailability();
   }
 
   /**
@@ -153,13 +143,13 @@ shaka.ui.VolumeBar = class extends shaka.ui.RangeElement {
         'linear-gradient(' + gradient.join(',') + ')';
   }
 
-  /** @private */
-  updateAriaLabel_() {
+  /** @override */
+  updateLocalizedStrings() {
     this.bar.ariaLabel = this.localization.resolve(shaka.ui.Locales.Ids.VOLUME);
   }
 
-  /** @private */
-  checkAvailability_() {
+  /** @override */
+  checkAvailability() {
     let available = true;
     if (this.ad && this.ad.isLinear()) {
       // We can't tell if the Ad has audio or not.

From f367ee5ffae1a751467084804a0d29841ee7c5d4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C3=81lvaro=20Velad=20Galv=C3=A1n?= <ladvan91@hotmail.com>
Date: Wed, 27 May 2026 13:29:19 +0200
Subject: [PATCH 44/64] feat(Queue): Add M3U playlist loading support (#10115)

---
 demo/asset_card.js               |  32 +++++
 demo/common/asset.js             |   8 ++
 demo/custom.js                   |  23 +++-
 demo/demo.less                   |  14 +++
 demo/main.js                     |  14 ++-
 docs/tutorials/queue-manager.md  | 111 ++++++++++++++++-
 externs/shaka/queue.js           |  23 ++++
 lib/net/networking_engine.js     |   1 +
 lib/queue/queue_manager.js       | 202 +++++++++++++++++++++++++++++++
 test/queue/queue_manager_unit.js |  70 +++++++++++
 10 files changed, 490 insertions(+), 8 deletions(-)

diff --git a/demo/asset_card.js b/demo/asset_card.js
index c7b052e59b..653cbf6edb 100644
--- a/demo/asset_card.js
+++ b/demo/asset_card.js
@@ -248,6 +248,38 @@ shakaDemo.AssetCard = class {
     this.remakeButtonsFn_(this);
   }
 
+  /**
+   * Adds a Play button for M3U playlist assets and shows the remaining
+   * base buttons ("Add to queue", "Start Preload") as disabled, since
+   * those operations are not applicable to playlist-type assets:
+   * - "Add to queue" would add the raw playlist URL, not its entries.
+   * - "Start Preload" has no meaning before the playlist is fetched.
+   */
+  addBaseButtonsPlaylist() {
+    let disablePlay = false;
+
+    // Play loads the playlist via QueueManager.loadFromM3uPlaylist()
+    // and starts the first channel automatically.
+    this.addButton('Play', async () => {
+      if (disablePlay) {
+        return;
+      }
+      disablePlay = true;
+      await shakaDemoMain.loadAsset(this.asset_);
+      this.remakeButtons();
+    });
+
+    // Disabled: adding a raw playlist URL to an existing queue is not
+    // supported; the user should play the playlist directly instead.
+    const addToQueueButton = this.addButton('Add to queue', () => {});
+    addToQueueButton.setAttribute('disabled', '');
+
+    // Disabled: preloading a playlist URL is not meaningful before the
+    // playlist entries have been resolved.
+    const preloadButton = this.addButton('Start Preload', () => {});
+    preloadButton.setAttribute('disabled', '');
+  }
+
   /** Adds basic buttons to the card ("play" and "preload"). */
   addBaseButtons() {
     let disableButtons = false;
diff --git a/demo/common/asset.js b/demo/common/asset.js
index ffb9b618bb..678a5899ed 100644
--- a/demo/common/asset.js
+++ b/demo/common/asset.js
@@ -99,6 +99,14 @@ const ShakaDemoAssetInfo = class {
     this.useIMA = true;
     /** @type {?string} */
     this.mimeType = null;
+    /**
+     * When true, |manifestUri| points to an M3U/M3U8 playlist file
+     * rather than a single-stream manifest.  The demo will call
+     * QueueManager.loadFromM3uPlaylist() instead of the normal load path,
+     * and will play the first item in the playlist automatically.
+     * @type {boolean}
+     */
+    this.isPlaylist = false;
 
 
     // Preload values.
diff --git a/demo/custom.js b/demo/custom.js
index 1a23e57afd..1042698861 100644
--- a/demo/custom.js
+++ b/demo/custom.js
@@ -947,6 +947,15 @@ shakaDemo.Custom = class {
     };
     this.makeField_(container, 'MIME Type', mimeTypeSetup, mimeTypeOnChange);
 
+    // Toggle: when enabled, |manifestUri| is treated as an M3U
+    // playlist URL rather than a single-stream manifest.  The queue
+    // manager will fetch the playlist and populate the queue from it.
+    const isPlaylistOnChange = (input) => {
+      assetInProgress.isPlaylist = input.checked;
+    };
+    this.makeBoolInput_(container, 'Is M3U Playlist',
+        isPlaylistOnChange, assetInProgress.isPlaylist);
+
     return mainDiv;
   }
 
@@ -1148,7 +1157,14 @@ shakaDemo.Custom = class {
     const savedList = this.savedList_;
     const isFeatured = false;
     return new shakaDemo.AssetCard(savedList, asset, isFeatured, (c) => {
-      c.addBaseButtons();
+      if (asset.isPlaylist) {
+        // Playlist assets only support Play, Edit, and Delete.
+        // "Add to queue" and "Start Preload" are shown but disabled;
+        // the Store button is omitted entirely.
+        c.addBaseButtonsPlaylist();
+      } else {
+        c.addBaseButtons();
+      }
       c.addButton('Edit', async () => {
         if (asset.unstoreCallback) {
           await asset.unstoreCallback();
@@ -1165,7 +1181,10 @@ shakaDemo.Custom = class {
         this.saveAssetInfos_(this.assets_);
         this.remakeSavedList_();
       }, 'Delete this custom asset?');
-      c.addStoreButton();
+      if (!asset.isPlaylist) {
+        // The Store button is only relevant for regular stream assets.
+        c.addStoreButton();
+      }
     });
   }
 
diff --git a/demo/demo.less b/demo/demo.less
index 4e73b006be..711631f9ec 100644
--- a/demo/demo.less
+++ b/demo/demo.less
@@ -621,3 +621,17 @@ footer .mdl-mega-footer__link-list {
 .extra-config-textarea {
   font-family: monospace;
 }
+
+.mdl-dialog .input-container-style-vertical {
+  .input-container-row:has(.mdl-switch) {
+    display: block;
+    width: 100%;
+  }
+
+  .mdl-switch {
+    margin-top: 8px;
+    margin-bottom: 8px;
+    // Fill the full container width so the label text is never truncated.
+    width: 100%;
+  }
+}
diff --git a/demo/main.js b/demo/main.js
index 564bb7e9ed..ae05d2354a 100644
--- a/demo/main.js
+++ b/demo/main.js
@@ -1531,11 +1531,15 @@ shakaDemo.Main = class {
       }
 
       // Finally, the asset can be loaded.
-      const queueItem = await this.getQueueItem_(asset);
-      queueManager.insertItems([queueItem]);
-      await queueManager.playItem(0);
-
-      asset.preloadManager = null;
+      if (asset.isPlaylist) {
+        await queueManager.loadFromM3uPlaylist(
+            asset.manifestUri, /* playOnLoad= */ true);
+      } else {
+        const queueItem = await this.getQueueItem_(asset);
+        queueManager.insertItems([queueItem]);
+        await queueManager.playItem(0);
+        asset.preloadManager = null;
+      }
 
       if (this.visualizer_ && this.visualizer_.active) {
         this.visualizer_.start();
diff --git a/docs/tutorials/queue-manager.md b/docs/tutorials/queue-manager.md
index 4fc6cd6601..8567faa403 100644
--- a/docs/tutorials/queue-manager.md
+++ b/docs/tutorials/queue-manager.md
@@ -249,6 +249,115 @@ queueManager.insertItems([
 ```
 
 
+#### Loading an M3U Playlist
+
+`loadFromM3uPlaylist()` lets you populate the queue from a remote M3U or M3U8
+playlist in one call. The method fetches the file using the player's own
+networking engine (so request filters, credentials, and retry parameters all
+apply), parses every stream entry, and inserts the resulting items into the
+queue.
+
+```js
+// Load a playlist and start playing the first channel immediately.
+await queueManager.loadFromM3uPlaylist(
+  'https://example.com/channels.m3u',
+  /* playOnLoad= */ true,
+);
+```
+
+The second argument, `playOnLoad`, is optional and defaults to `false`. When
+`true`, `playItem(0)` is called automatically once the items have been
+inserted.
+
+```js
+// Load a playlist without starting playback — useful when you want to
+// inspect or filter the items before choosing which one to play.
+await queueManager.loadFromM3uPlaylist('https://example.com/channels.m3u');
+
+const items = queueManager.getItems();
+const newsIndex = items.findIndex(
+  (item) => item.metadata?.groupTitle === 'News',
+);
+if (newsIndex >= 0) {
+  await queueManager.playItem(newsIndex);
+}
+```
+
+##### EXTINF attributes and item metadata
+
+The parser supports the Extended M3U format (`#EXTM3U` / `#EXTINF`) with the
+`tvg-*` and `group-title` attributes commonly found in IPTV playlists. All
+attributes are copied into the item's `metadata` object **using their original
+hyphenated names** (e.g. `tvg-id`, `tvg-name`, `group-title`). Two standard
+`QueueItemMetadata` aliases are also set on top:
+
+| Playlist attribute | `metadata` property | Notes                                      |
+|--------------------|---------------------|--------------------------------------------|
+| `tvg-name`         | `tvg-name` + `title`| `title` falls back to the display name.    |
+| `tvg-logo`         | `tvg-logo` + `poster`|                                           |
+| `tvg-id`           | `tvg-id`            | Also used for deduplication (see below).   |
+| `tvg-language`     | `tvg-language`      |                                            |
+| `tvg-country`      | `tvg-country`       |                                            |
+| `tvg-url`          | `tvg-url`           | EPG (Electronic Programme Guide) feed URL. |
+| `group-title`      | `group-title`       |                                            |
+| Display name       | `displayTitle`      | The text after the last comma in `#EXTINF`.|
+| *(any other)*      | *(original name)*   | Unknown attributes are preserved as-is.    |
+
+A typical IPTV entry and the metadata it produces:
+
+```
+#EXTINF:-1 tvg-id="bbc1" tvg-name="BBC One" tvg-logo="https://example.com/bbc1.png" tvg-language="English" tvg-country="GB" group-title="Entertainment",BBC One HD
+https://example.com/bbc1/stream.m3u8
+```
+
+```js
+{
+  manifestUri: 'https://example.com/bbc1/stream.m3u8',
+  metadata: {
+    // Standard QueueItemMetadata aliases
+    title: 'BBC One',                        // from tvg-name
+    poster: 'https://example.com/bbc1.png',  // from tvg-logo
+    // Raw attribute names, exactly as in the playlist
+    'tvg-id': 'bbc1',
+    'tvg-name': 'BBC One',
+    'tvg-logo': 'https://example.com/bbc1.png',
+    'tvg-language': 'English',
+    'tvg-country': 'GB',
+    'group-title': 'Entertainment',
+    // Extra helper added by the parser
+    displayTitle: 'BBC One HD',              // raw text after the last comma
+  },
+}
+```
+
+You can use `metadata['group-title']` to build a channel-group UI, or
+`metadata['tvg-url']` to load EPG schedule data for the currently playing
+channel:
+
+```js
+queueManager.addEventListener('currentitemchanged', () => {
+  const item = queueManager.getCurrentItem();
+  if (item?.metadata) {
+    titleEl.textContent = item.metadata.title ?? '';
+    posterEl.src = item.metadata.poster ?? '';
+    groupEl.textContent = item.metadata['group-title'] ?? '';
+  }
+});
+```
+
+##### Duplicate channel handling
+
+Channels that share the same `tvg-id` value are automatically deduplicated:
+only the first occurrence is kept, and subsequent entries with the same id are
+silently dropped. Channels without a `tvg-id` are always included regardless
+of whether their stream URL appears more than once.
+
+Note: `loadFromM3uPlaylist()` uses `RequestType.PLAYLIST` and the
+`manifest.retryParameters` from the current player configuration. If the
+playlist URL requires custom headers or credentials, configure them via a
+request filter before calling this method.
+
+
 #### Clearing the Queue
 
 To stop playback and remove all items from the queue:
@@ -258,4 +367,4 @@ await queueManager.removeAllItems();
 ```
 
 This unloads the player, destroys any active or pending `PreloadManager`
-instances, and resets the current index to `-1`.
+instances, and resets the current index to `-1`.
\ No newline at end of file
diff --git a/externs/shaka/queue.js b/externs/shaka/queue.js
index 633943ed05..8218a33cda 100644
--- a/externs/shaka/queue.js
+++ b/externs/shaka/queue.js
@@ -131,6 +131,29 @@ shaka.extern.IQueueManager = class extends EventTarget {
    * @return {!Promise}
    */
   playItem(itemIndex) {}
+
+  /**
+   * Fetches an M3U/M3U8 playlist from the given URL using the player's
+   * networking engine, parses it, and inserts the resulting items into the
+   * queue. Supports the extended EXTINF format with tvg-* attributes
+   * commonly found in IPTV playlists (tvg-id, tvg-name, tvg-logo,
+   * tvg-language, tvg-country, tvg-url, group-title).
+   *
+   * The parsed tvg-* attribute values are stored in the item's metadata:
+   *   - tvg-name  → metadata.title  (falls back to the display name)
+   *   - tvg-logo  → metadata.poster
+   *   - tvg-id    → metadata.tvgId
+   *   - tvg-language → metadata.tvgLanguage
+   *   - tvg-country  → metadata.tvgCountry
+   *   - tvg-url      → metadata.tvgUrl
+   *   - group-title  → metadata.groupTitle
+   *   - display name → metadata.displayTitle
+   *
+   * @param {string} url
+   * @param {boolean=} playOnLoad
+   * @return {!Promise}
+   */
+  loadFromM3uPlaylist(url, playOnLoad) {}
 };
 
 
diff --git a/lib/net/networking_engine.js b/lib/net/networking_engine.js
index 87ee1665f3..b50b6696d1 100644
--- a/lib/net/networking_engine.js
+++ b/lib/net/networking_engine.js
@@ -890,6 +890,7 @@ shaka.net.NetworkingEngine.RequestType = {
   'CMCD': 9,
   'SESSION_DATA': 10,
   'FINGERPRINT': 11,
+  'PLAYLIST': 12,
 };
 
 /**
diff --git a/lib/queue/queue_manager.js b/lib/queue/queue_manager.js
index c3e3308bbc..29fdcd844b 100644
--- a/lib/queue/queue_manager.js
+++ b/lib/queue/queue_manager.js
@@ -9,11 +9,14 @@ goog.provide('shaka.queue.QueueManager');
 goog.require('goog.asserts');
 goog.require('shaka.Player');
 goog.require('shaka.config.RepeatMode');
+goog.require('shaka.log');
+goog.require('shaka.net.NetworkingEngine');
 goog.require('shaka.util.Error');
 goog.require('shaka.util.EventManager');
 goog.require('shaka.util.FakeEvent');
 goog.require('shaka.util.FakeEventTarget');
 goog.require('shaka.util.IDestroyable');
+goog.require('shaka.util.StringUtils');
 goog.require('shaka.util.Timer');
 goog.requireType('shaka.media.PreloadManager');
 
@@ -446,6 +449,205 @@ shaka.queue.QueueManager = class extends shaka.util.FakeEventTarget {
       ...chapterPromises,
     ]);
   }
+
+  /**
+   * @param {string} url
+   * @param {boolean=} playOnLoad
+   * @return {!Promise}
+   * @override
+   * @export
+   */
+  async loadFromM3uPlaylist(url, playOnLoad = false) {
+    goog.asserts.assert(this.player_, 'We should have player');
+
+    const networkingEngine = this.player_.getNetworkingEngine();
+    goog.asserts.assert(
+        networkingEngine, 'We should have networking engine');
+
+    // Use manifest retry parameters — the playlist is a manifest-like
+    // resource and shares the same back-off / retry configuration.
+    const retryParams =
+        this.player_.getConfiguration().manifest.retryParameters;
+
+    const request = shaka.net.NetworkingEngine.makeRequest(
+        [url], retryParams);
+
+    // RequestType.PLAYLIST ensures the right request filters and
+    // credentials are applied for playlist-type resources.
+    const response = await networkingEngine.request(
+        shaka.net.NetworkingEngine.RequestType.PLAYLIST,
+        request).promise;
+
+    const text = shaka.util.StringUtils.fromUTF8(response.data);
+    const items = shaka.queue.QueueManager.parseM3uPlaylist_(text);
+
+    if (items.length === 0) {
+      shaka.log.warning(
+          'QueueManager: No playable entries found in the M3U playlist.',
+          url);
+      return;
+    }
+
+    this.insertItems(items);
+
+    if (playOnLoad) {
+      await this.playItem(0);
+    }
+  }
+
+  /**
+   * Parses raw M3U/M3U8 playlist text and returns an array of
+   * {@link shaka.extern.QueueItem} objects ready to be inserted into the
+   * queue.
+   *
+   * Only lines that follow an #EXTINF directive are treated as stream URLs;
+   * bare URL-only playlists (no #EXTM3U / #EXTINF) are also supported —
+   * every non-comment, non-empty line is treated as a stream URI with no
+   * metadata in that case.
+   *
+   * @param {string} text
+   * @return {!Array<shaka.extern.QueueItem>}
+   * @private
+   */
+  static parseM3uPlaylist_(text) {
+    const lines = text.split(/\r?\n/);
+
+    if (!lines[0]?.trim().startsWith('#EXTM3U')) {
+      shaka.log.warning(
+          'QueueManager: Playlist does not start with #EXTM3U; ' +
+          'attempting to parse anyway.');
+    }
+
+    /** @type {!Array<shaka.extern.QueueItem>} */
+    const items = [];
+
+    /**
+     * Used to avoid duplicated channels.
+     * We dedupe primarily by tvg-id.
+     * @type {!Set<string>}
+     */
+    const seenChannelIds = new Set();
+
+    /** @type {?shaka.extern.QueueItemMetadata} */
+    let pendingMetadata = null;
+
+    for (const line of lines) {
+      const trimmed = line.trim();
+
+      // Skip blank lines and header.
+      if (!trimmed || trimmed === '#EXTM3U') {
+        continue;
+      }
+
+      // Parse metadata.
+      if (trimmed.startsWith('#EXTINF:')) {
+        pendingMetadata =
+            shaka.queue.QueueManager.parseExtInf_(trimmed);
+        continue;
+      }
+
+      // Ignore unsupported directives.
+      if (trimmed.startsWith('#')) {
+        continue;
+      }
+
+      // This is a stream URL.
+      const manifestUri = trimmed;
+
+      // Skip duplicated channels by tvg-id.
+      const tvgId = pendingMetadata?.['tvg-id'];
+
+      if (tvgId && seenChannelIds.has(tvgId)) {
+        shaka.log.debug('QueueManager: Skipping duplicated channel:',
+            tvgId, manifestUri);
+        continue;
+      }
+
+      /** @type {shaka.extern.QueueItem} */
+      const item = {
+        manifestUri,
+        preloadManager: null,
+        startTime: null,
+        mimeType: null,
+        config: null,
+        extraText: null,
+        extraThumbnail: null,
+        extraChapter: null,
+        metadata: pendingMetadata,
+      };
+
+      items.push(item);
+
+      if (tvgId) {
+        seenChannelIds.add(tvgId);
+      }
+
+      pendingMetadata = null;
+    }
+
+    return items;
+  }
+
+  /**
+   * Parses a single #EXTINF line and extracts its attributes together with
+   * the human-readable display name that follows the last comma.
+   *
+   * Expected format (newlines added here for readability only):
+   *   #EXTINF:-1 tvg-id="ch1" tvg-name="Channel 1"
+   *             tvg-logo="https://example.com/logo.png"
+   *             tvg-language="English" tvg-country="US"
+   *             group-title="News",Channel 1 Display Name
+   *
+   * All key="value" attributes are copied directly into the returned
+   * metadata object using their original attribute names. Unknown
+   * attributes are preserved automatically.
+   *
+   * The standard QueueItemMetadata fields are also populated:
+   *   - title  <- tvg-name or display title
+   *   - poster <- tvg-logo
+   *
+   * Attribute parsing is intentionally lenient: malformed or unsupported
+   * attributes are ignored, and missing attributes are omitted rather than
+   * set to empty strings.
+   *
+   * @param {string} line A single #EXTINF line from the playlist.
+   * @return {!shaka.extern.QueueItemMetadata}
+   * @private
+   */
+  static parseExtInf_(line) {
+    // The human-readable channel name follows the *last* comma in the line.
+    // Everything before that comma contains the duration and attributes.
+    const commaIndex = line.lastIndexOf(',');
+    const attrsPart =
+        commaIndex >= 0 ? line.substring(0, commaIndex) : line;
+    const displayTitle =
+        commaIndex >= 0 ? line.substring(commaIndex + 1).trim() : '';
+
+    const attrRegex = /([\w-]+)="([^"]*)"/g;
+
+    /** @type {!Object<string, string>} */
+    const attrs = {};
+    let match;
+
+    while ((match = attrRegex.exec(attrsPart)) !== null) {
+      attrs[match[1]] = match[2];
+    }
+
+    /** @type {!shaka.extern.QueueItemMetadata} */
+    const metadata = {
+      ...attrs,
+      title: attrs['tvg-name'] || displayTitle || undefined,
+      poster: attrs['tvg-logo'] || undefined,
+    };
+
+    // Always preserve the raw display title even when tvg-name is present,
+    // so callers can distinguish between the two if needed.
+    if (displayTitle) {
+      metadata['displayTitle'] = displayTitle;
+    }
+
+    return metadata;
+  }
 };
 
 
diff --git a/test/queue/queue_manager_unit.js b/test/queue/queue_manager_unit.js
index 3864cc6fb9..10b995d535 100644
--- a/test/queue/queue_manager_unit.js
+++ b/test/queue/queue_manager_unit.js
@@ -306,4 +306,74 @@ describe('QueueManager', () => {
       expect(player.getChaptersTracks().length).toBe(0);
     }
   });
+
+  it('loads items from M3U playlist', async () => {
+    const playlist = [
+      '#EXTM3U',
+      '#EXTINF:-1 tvg-id="ch1" tvg-name="Channel 1",Channel 1 Display',
+      '/base/test/test/assets/small.mp4',
+      '#EXTINF:-1 tvg-id="ch2" tvg-name="Channel 2",Channel 2 Display',
+      '/base/test/test/assets/small.mp4',
+    ].join('\n');
+
+    const dataUri = 'data:application/x-mpegURL;charset=utf-8,' +
+        encodeURIComponent(playlist);
+
+    await queueManager.loadFromM3uPlaylist(dataUri);
+
+    const items = queueManager.getItems();
+
+    expect(items.length).toBe(2);
+
+    expect(items[0].manifestUri).toBe('/base/test/test/assets/small.mp4');
+    expect(items[0].metadata.title).toBe('Channel 1');
+    expect(items[0].metadata['tvg-id']).toBe('ch1');
+
+    expect(items[1].metadata.title).toBe('Channel 2');
+  });
+
+  it('loads and plays first item from M3U playlist', async () => {
+    const playlist = [
+      '#EXTM3U',
+      '#EXTINF:-1 tvg-id="ch1" tvg-name="Channel 1",Channel 1 Display',
+      '/base/test/test/assets/small.mp4',
+    ].join('\n');
+
+    const dataUri =
+        'data:application/x-mpegURL;charset=utf-8,' +
+        encodeURIComponent(playlist);
+
+    await queueManager.loadFromM3uPlaylist(dataUri, true);
+
+    expect(queueManager.getCurrentItemIndex()).toBe(0);
+
+    const currentItem = queueManager.getCurrentItem();
+
+    expect(currentItem).not.toBeNull();
+    expect(currentItem.manifestUri)
+        .toBe('/base/test/test/assets/small.mp4');
+  });
+
+  it('skips duplicated channels by tvg-id', async () => {
+    const playlist = [
+      '#EXTM3U',
+      '#EXTINF:-1 tvg-id="dup" tvg-name="Channel 1",Channel 1',
+      '/base/test/test/assets/small.mp4',
+      '#EXTINF:-1 tvg-id="dup" tvg-name="Channel 1.1",Channel 1.1',
+      '/base/test/test/assets/small.mp4',
+      '#EXTINF:-1 tvg-id="dup" tvg-name="Channel 1.2",Channel 1.2',
+      '/base/test/test/assets/small.mp4',
+    ].join('\n');
+
+    const dataUri =
+        'data:application/x-mpegURL;charset=utf-8,' +
+        encodeURIComponent(playlist);
+
+    await queueManager.loadFromM3uPlaylist(dataUri);
+
+    const items = queueManager.getItems();
+
+    expect(items.length).toBe(1);
+    expect(items[0].metadata.title).toBe('Channel 1');
+  });
 });

From a479eae58bb1c9ccebd7138a5dfc6ccd9dbe9f39 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C3=81lvaro=20Velad=20Galv=C3=A1n?= <ladvan91@hotmail.com>
Date: Wed, 27 May 2026 14:19:32 +0200
Subject: [PATCH 45/64] fix: Emit ratechange event when playbackRate stays at 0
 (#10130)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This can happen when using playbackRate values ​​that are outside the
range supported by the platform, and we have to use our internal
alternative. See the implementation at
https://github.com/shaka-project/shaka-player/blob/main/lib/media/play_rate_controller.js
---
 lib/player.js              | 18 +++++++++++++++++
 test/player_integration.js | 40 ++++++++++++++++++++++++++++++++++++++
 2 files changed, 58 insertions(+)

diff --git a/lib/player.js b/lib/player.js
index 777bd73ec8..69d9568f36 100644
--- a/lib/player.js
+++ b/lib/player.js
@@ -5322,6 +5322,9 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       return;
     }
 
+    const prevRealRate = this.video_.playbackRate;
+    const prevRate = this.playRateController_.getRealRate();
+
     this.playRateController_.set(rate);
 
     if (this.loadMode_ == shaka.Player.LoadMode.MEDIA_SOURCE) {
@@ -5329,6 +5332,21 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       this.useTrickPlayTrackIfAvailable(useTrickPlayTrack && rate != 1);
     }
     this.setupTrickPlayEventListeners_(rate);
+
+    // When trick play falls back to manual seeking (for example, rewind or
+    // unsupported playback rates), PlayRateController keeps the media element
+    // playbackRate at 0 and advances the playhead with a timer instead.
+    //
+    // Because the underlying media element playbackRate remains unchanged,
+    // the browser will not fire a native 'ratechange' event in this case.
+    //
+    // Invoke onRateChange_() manually so the player can run the normal
+    // playback-rate update flow and dispatch the corresponding RateChange
+    // event for the effective trick play rate change.
+    if (prevRealRate === 0 && this.video_.playbackRate === 0 &&
+        rate != prevRate) {
+      this.onRateChange_();
+    }
   }
 
   /**
diff --git a/test/player_integration.js b/test/player_integration.js
index 3b1148f1b8..b791513048 100644
--- a/test/player_integration.js
+++ b/test/player_integration.js
@@ -352,6 +352,46 @@ describe('Player', () => {
       expect(video.playbackRate).toBe(1);
     });
 
+    it('dispatch ratechange event', async () => {
+      await player.load('test:sintel_compiled');
+      await video.play();
+      await waiter.waitUntilPlayheadReachesOrFailOnTimeout(video, 1, 10);
+
+      video.pause();
+
+      let numberOfRatechangeEvents = 0;
+      eventManager.listen(player, 'ratechange', () => {
+        numberOfRatechangeEvents++;
+      });
+
+      player.trickPlay(2);
+      expect(player.getPlaybackRate()).toBe(2);
+
+      await shaka.test.Util.shortDelay();
+
+      player.trickPlay(32);
+      expect(player.getPlaybackRate()).toBe(32);
+
+      await shaka.test.Util.shortDelay();
+
+      player.trickPlay(64);
+      expect(player.getPlaybackRate()).toBe(64);
+
+      await shaka.test.Util.shortDelay();
+
+      player.trickPlay(-1);
+      expect(player.getPlaybackRate()).toBe(-1);
+
+      await shaka.test.Util.shortDelay();
+
+      player.cancelTrickPlay();
+      expect(player.getPlaybackRate()).toBe(1);
+
+      await shaka.test.Util.shortDelay();
+
+      expect(numberOfRatechangeEvents).toBe(5);
+    });
+
     it('in sequence mode', async () => {
       if (!deviceDetected.supportsSequenceMode()) {
         pending('Sequence mode is not supported by the platform.');

From ad8b674784363e92e090ea6a323f5030f704f8d5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C3=81lvaro=20Velad=20Galv=C3=A1n?= <ladvan91@hotmail.com>
Date: Wed, 27 May 2026 14:43:58 +0200
Subject: [PATCH 46/64] refactor: Improve code of NativeTextDisplayer (#10106)

Improve readability and separate responsibilities. Use Intl.DisplayNames
when available and fallback to mozilla.LanguageMapping otherwise.

Note: this is in preparation for addressing
https://github.com/shaka-project/shaka-player/issues/9694

---------

Co-authored-by: Matthias Van Parijs <matvp91@gmail.com>
---
 lib/text/native_text_displayer.js | 682 ++++++++++++++++++++----------
 1 file changed, 459 insertions(+), 223 deletions(-)

diff --git a/lib/text/native_text_displayer.js b/lib/text/native_text_displayer.js
index 6b72950b9a..ba7a8c7abf 100644
--- a/lib/text/native_text_displayer.js
+++ b/lib/text/native_text_displayer.js
@@ -38,6 +38,9 @@ shaka.text.NativeTextDisplayer = class {
     /** @private {shaka.util.EventManager} */
     this.eventManager_ = new shaka.util.EventManager();
 
+    /** @private {shaka.util.EventManager} */
+    this.loadEventManager_ = new shaka.util.EventManager();
+
     /** @private {?shaka.extern.TextDisplayerConfiguration} */
     this.config_ = null;
 
@@ -47,156 +50,23 @@ shaka.text.NativeTextDisplayer = class {
     /** @private {Map<number, !HTMLTrackElement>} */
     this.trackNodes_ = new Map();
 
-    /** @private {number} */
+    /**
+     * ID of the currently active text track. -1 means no track is active.
+     * @private {number}
+     */
     this.trackId_ = -1;
 
     /** @private {boolean} */
     this.visible_ = false;
 
-    /** @private {?shaka.util.Timer} */
+    /**
+     * Timer used to debounce the textTracks 'change' event.
+     * @private {?shaka.util.Timer}
+     */
     this.timer_ = null;
 
-    /** @private */
-    this.onUnloading_ = () => {
-      this.timer_?.stop();
-      this.timer_ = null;
-      this.eventManager_.unlisten(this.player_,
-          shaka.util.FakeEvent.EventName.TextChanged, this.onTextChanged_);
-      this.eventManager_.unlisten(this.video_.textTracks, 'change',
-          this.onChange_);
-      for (const trackNode of this.trackNodes_.values()) {
-        trackNode.remove();
-      }
-      this.trackNodes_.clear();
-      this.trackId_ = -1;
-      this.video_ = null;
-    };
-
-    /** @private */
-    this.onTextChanged_ = () => {
-      /** @type {Map<number, !HTMLTrackElement>} */
-      const newTrackNodes = new Map();
-      const tracks = this.player_.getTextTracks();
-      for (const track of tracks) {
-        let trackNode;
-        if (this.trackNodes_.has(track.id)) {
-          trackNode = this.trackNodes_.get(track.id);
-          if (!track.active && trackNode.track.mode !== 'disabled') {
-            trackNode.track.mode = 'disabled';
-          }
-          this.trackNodes_.delete(track.id);
-        } else {
-          trackNode = /** @type {!HTMLTrackElement} */
-            (this.video_.ownerDocument.createElement('track'));
-          trackNode.kind = shaka.text.NativeTextDisplayer.getTrackKind_(track);
-          trackNode.label =
-            shaka.text.NativeTextDisplayer.getTrackLabel_(track);
-          if (track.language) {
-            if (track.language in mozilla.LanguageMapping) {
-              trackNode.srclang = track.language;
-            } else {
-              const base = shaka.util.LanguageUtils.getBase(track.language);
-              trackNode.srclang = base ?? 'und';
-            }
-          } else {
-            trackNode.srclang = 'und';
-          }
-          // The built-in captions menu in Chrome may refuse to list invalid
-          // subtitles.
-          // In Safari, when a TextTrack's mode is set to "disabled" or "hidden"
-          // and then "showing" again causes a blink if there is no src.
-          // The data URL is just to avoid this.
-          trackNode.src = 'data:,WEBVTT';
-          trackNode.track.mode = 'disabled';
-          this.video_.appendChild(trackNode);
-        }
-        newTrackNodes.set(track.id, trackNode);
-        if (track.active) {
-          this.trackId_ = track.id;
-        }
-      }
-      // Remove all tracks that are not in the new list.
-      for (const trackNode of this.trackNodes_.values()) {
-        trackNode.remove();
-      }
-      if (this.trackId_ > -1) {
-        if (!newTrackNodes.has(this.trackId_)) {
-          this.trackId_ = -1;
-        } else {
-          // enable current track after everything else is settled
-          const track = newTrackNodes.get(this.trackId_).track;
-          // Ignore if the mode is not disabled. Maybe the user has changed the
-          // mode manually. In that case, visible_ will be updated in onChange_
-          if (track.mode === 'disabled') {
-            track.mode = this.visible_ ? 'showing' : 'hidden';
-          }
-        }
-      }
-      this.trackNodes_ = newTrackNodes;
-    };
-
-    /** @private */
-    this.onChange_ = () => {
-      // The change event may fire multiple times consecutively. So we need to
-      // use a timer to ensure the real task runs only once.
-      if (this.timer_) {
-        return;
-      }
-      const video = this.video_;
-      this.timer_ = new shaka.util.Timer(() => {
-        this.timer_ = null;
-        if (this.video_ !== video) {
-          return;
-        }
-        let trackId = -1;
-        let found = false;
-        // Prefer previously selected track.
-        if (this.trackNodes_.has(this.trackId_)) {
-          const trackNode = this.trackNodes_.get(this.trackId_);
-          if (trackNode.track.mode === 'showing') {
-            trackId = this.trackId_;
-            found = true;
-          } else if (trackNode.track.mode === 'hidden') {
-            trackId = this.trackId_;
-          }
-        }
-        if (!found) {
-          for (const [
-            /** @type {number} */id,
-            /** @type {HTMLTrackElement} */trackNode,
-          ] of /** @type {!Map} */(this.trackNodes_)) {
-            if (trackNode.track.mode === 'showing') {
-              trackId = id;
-              break;
-            } else if (trackId < 0 && trackNode.track.mode === 'hidden') {
-              // If there is no showing track, we can use the hidden track
-              trackId = id;
-            }
-          }
-        }
-        for (const [
-          /** @type {number} */id,
-          /** @type {HTMLTrackElement} */trackNode,
-        ] of /** @type {!Map} */(this.trackNodes_)) {
-          // Avoid triggering unnecessary change events.
-          if (id !== trackId && trackNode.track.mode !== 'disabled') {
-            trackNode.track.mode = 'disabled';
-          }
-        }
-        if (this.trackId_ !== trackId) {
-          this.trackId_ = trackId;
-          if (trackId > -1) {
-            this.player_.selectTextTrack(
-                /** @type {!shaka.extern.TextTrack} */({id: trackId}));
-          } else {
-            this.player_.selectTextTrack();
-          }
-        }
-      }).tickAfter(0);
-    };
-
-    this.eventManager_.listen(player, shaka.util.FakeEvent.EventName.Loaded,
-        () => this.checkMsePlayback_());
+    this.eventManager_.listen(player,
+        shaka.util.FakeEvent.EventName.Loaded, () => this.checkMsePlayback_());
 
     this.checkMsePlayback_();
   }
@@ -210,41 +80,49 @@ shaka.text.NativeTextDisplayer = class {
   }
 
   /**
+   * Removes cues whose time range overlaps with [start, end).
+   * Returns false only if this instance has already been destroyed.
+   *
    * @override
    * @export
    */
   remove(start, end) {
-    // Should return false only if this instance is destroyed
     if (!this.player_) {
       return false;
-    } else if (this.trackNodes_.has(this.trackId_)) {
+    }
+
+    const activeTrack = this.getActiveTrack_();
+    if (activeTrack) {
       shaka.text.Utils.removeCuesFromTextTrack(
-          this.trackNodes_.get(this.trackId_).track,
-          (cue) => cue.startTime < end && cue.endTime > start);
+          activeTrack, (cue) => cue.startTime < end && cue.endTime > start);
     }
 
     return true;
   }
 
   /**
+   * Appends cues to the active track, applying the subtitle delay if set.
+   *
    * @override
    * @export
    */
   append(cues) {
-    if (this.trackNodes_.has(this.trackId_)) {
-      const delay = this.config_?.subtitleDelay ?? 0;
-      let adjustedCues = cues;
-      if (delay != 0) {
-        adjustedCues = cues.map((cue) => {
-          const newCue = cue.clone();
-          newCue.startTime = Math.max(0, newCue.startTime + delay);
-          newCue.endTime = Math.max(0, newCue.endTime + delay);
-          return newCue;
-        });
-      }
-      shaka.text.Utils.appendCuesToTextTrack(
-          this.trackNodes_.get(this.trackId_).track, adjustedCues);
+    const activeTrack = this.getActiveTrack_();
+    if (!activeTrack) {
+      return;
     }
+
+    const delay = this.config_?.subtitleDelay ?? 0;
+    const adjustedCues = delay !== 0 ?
+      cues.map((cue) => {
+        const shifted = cue.clone();
+        shifted.startTime = Math.max(0, shifted.startTime + delay);
+        shifted.endTime = Math.max(0, shifted.endTime + delay);
+        return shifted;
+      }) :
+      cues;
+
+    shaka.text.Utils.appendCuesToTextTrack(activeTrack, adjustedCues);
   }
 
   /**
@@ -258,10 +136,14 @@ shaka.text.NativeTextDisplayer = class {
       }
       this.player_ = null;
     }
+
     this.timer_?.stop();
     this.timer_ = null;
     this.eventManager_?.release();
     this.eventManager_ = null;
+    this.loadEventManager_?.release();
+    this.loadEventManager_ = null;
+
     return Promise.resolve();
   }
 
@@ -274,79 +156,392 @@ shaka.text.NativeTextDisplayer = class {
   }
 
   /**
+   * Shows or hides subtitles. Handles both MSE and SRC_EQUALS playback modes.
+   *
    * @override
    * @export
    */
   setTextVisibility(on) {
     this.visible_ = on;
-    if (this.trackNodes_.has(this.trackId_)) {
-      const textTrack = this.trackNodes_.get(this.trackId_).track;
-      if (textTrack.mode !== 'disabled') {
-        const mode = on ? 'showing' : 'hidden';
-        if (textTrack.mode !== mode) {
-          textTrack.mode = mode;
-        }
+
+    const activeTrack = this.getActiveTrack_();
+    if (activeTrack) {
+      this.applyVisibilityToTrack_(activeTrack, on);
+      return;
+    }
+
+    if (this.isSrcEqualsMode_()) {
+      this.applyVisibilityToSrcEqualsTracks_(on);
+    }
+  }
+
+  /**
+   * @override
+   * @export
+   */
+  setTextLanguage(_language) {
+    // unused
+  }
+
+  /**
+   * Cleans up internal state when the player starts unloading content.
+   * Registered with listenOnce, so it fires at most once per playback session.
+   *
+   * @private
+   */
+  onUnloading_() {
+    this.timer_?.stop();
+    this.timer_ = null;
+
+    this.loadEventManager_?.removeAll();
+
+    for (const trackNode of this.trackNodes_.values()) {
+      trackNode.remove();
+    }
+    this.trackNodes_.clear();
+    this.trackId_ = -1;
+    this.video_ = null;
+  }
+
+  /**
+   * Synchronises the DOM <track> elements with the player's track list.
+   * Creates elements for new tracks, reuses existing ones, and removes
+   * any that are no longer present.
+   *
+   * @private
+   */
+  onTextChanged_() {
+    /** @type {Map<number, !HTMLTrackElement>} */
+    const newTrackNodes = new Map();
+    const tracks = this.player_.getTextTracks();
+
+    for (const track of tracks) {
+      const trackNode = this.trackNodes_.has(track.id) ?
+          this.reuseTrackNode_(track) : this.createTrackNode_(track);
+
+      newTrackNodes.set(track.id, trackNode);
+
+      if (track.active) {
+        this.trackId_ = track.id;
       }
-    } else if (this.player_ && this.player_.getLoadMode() === 3) {
-      // shaka.Player.LoadMode.SRC_EQUALS
-      const textTracks = Array.from(this.player_.getMediaElement().textTracks)
-          .filter((track) =>
-            ['captions', 'subtitles', 'forced'].includes(track.kind));
-      if (on) {
-        let toShow = null;
-        for (const track of textTracks) {
-          if (track.mode === 'showing') {
-            // One showing track is just enough.
-            toShow = null;
-            break;
-          } else if (!toShow && track.mode === 'hidden') {
-            toShow = track;
-          }
-        }
-        if (toShow) {
-          toShow.mode = 'showing';
+    }
+
+    // Remove from the DOM any tracks no longer in the player's list.
+    for (const trackNode of this.trackNodes_.values()) {
+      trackNode.remove();
+    }
+
+    this.trackNodes_ = newTrackNodes;
+    this.activateCurrentTrack_();
+  }
+
+  /**
+   * Handles manual changes to the video's textTracks (e.g. the user enables a
+   * track through the browser's native subtitle menu). Applies debounce because
+   * the 'change' event can fire multiple times in quick succession.
+   *
+   * @private
+   */
+  onChange_() {
+    if (this.timer_) {
+      // A tick is already queued; the debounce absorbs additional events.
+      return;
+    }
+
+    // Snapshot the current video reference so we can detect if it changes
+    // while the timer is pending (e.g. an unload happens in the meantime).
+    const videoSnapshot = this.video_;
+
+    this.timer_ = new shaka.util.Timer(() => {
+      this.timer_ = null;
+
+      if (this.video_ !== videoSnapshot) {
+        return;
+      }
+
+      const resolvedTrackId = this.resolveActiveTrackId_();
+      this.disableAllTracksExcept_(resolvedTrackId);
+
+      if (this.trackId_ !== resolvedTrackId) {
+        this.trackId_ = resolvedTrackId;
+        this.syncTrackSelectionWithPlayer_(resolvedTrackId);
+      }
+    }).tickAfter(0);
+  }
+
+  /**
+   * Returns the active TextTrack, or null if none is currently active.
+   *
+   * @return {?TextTrack}
+   * @private
+   */
+  getActiveTrack_() {
+    return this.trackNodes_.has(this.trackId_) ?
+        this.trackNodes_.get(this.trackId_).track : null;
+  }
+
+  /**
+   * Applies the visibility mode to a specific track without touching tracks
+   * that are already 'disabled' (e.g. manually turned off by the user).
+   *
+   * @param {TextTrack} track
+   * @param {boolean} visible
+   * @private
+   */
+  applyVisibilityToTrack_(track, visible) {
+    if (track.mode === 'disabled') {
+      return;
+    }
+    const targetMode = visible ? 'showing' : 'hidden';
+    if (track.mode !== targetMode) {
+      track.mode = targetMode;
+    }
+  }
+
+  /**
+   * Returns true if the player is currently in SRC_EQUALS mode.
+   *
+   * @return {boolean}
+   * @private
+   */
+  isSrcEqualsMode_() {
+    if (!this.player_) {
+      return false;
+    }
+    const LoadMode = shaka.text.NativeTextDisplayer.LoadMode;
+    return this.player_.getLoadMode() === LoadMode.SRC_EQUALS;
+  }
+
+  /**
+   * Manages subtitle visibility in SRC_EQUALS mode, where tracks are controlled
+   * directly by the HTMLMediaElement rather than MSE.
+   *
+   * @param {boolean} on
+   * @private
+   */
+  applyVisibilityToSrcEqualsTracks_(on) {
+    const textTracks = Array.from(this.player_.getMediaElement().textTracks)
+        .filter((track) =>
+          ['captions', 'subtitles', 'forced'].includes(track.kind));
+
+    if (on) {
+      // If a track is already 'showing', do nothing to avoid disrupting state.
+      const alreadyShowing = textTracks.some((t) => t.mode === 'showing');
+      if (!alreadyShowing) {
+        const firstHidden = textTracks.find((t) => t.mode === 'hidden');
+        if (firstHidden) {
+          firstHidden.mode = 'showing';
         }
-      } else {
-        for (const track of textTracks) {
-          if (track.mode === 'showing') {
-            track.mode = 'hidden';
-          }
+      }
+    } else {
+      for (const track of textTracks) {
+        if (track.mode === 'showing') {
+          track.mode = 'hidden';
         }
       }
     }
   }
 
   /**
-   * @override
-   * @export
+   * Reuses an existing <track> DOM node for a known track.
+   * Disables the node if the track is no longer active, and removes the entry
+   * from the original map so that onTextChanged_ can detect orphaned nodes.
+   *
+   * @param {!shaka.extern.TextTrack} track
+   * @return {!HTMLTrackElement}
+   * @private
    */
-  setTextLanguage(language) {
-    // unused
+  reuseTrackNode_(track) {
+    const trackNode = this.trackNodes_.get(track.id);
+    if (!track.active && trackNode.track.mode !== 'disabled') {
+      trackNode.track.mode = 'disabled';
+    }
+    this.trackNodes_.delete(track.id);
+    return trackNode;
+  }
+
+  /**
+   * Creates a new <track> DOM element for the given track and appends it to
+   * the video element.
+   *
+   * @param {!shaka.extern.TextTrack} track
+   * @return {!HTMLTrackElement}
+   * @private
+   */
+  createTrackNode_(track) {
+    const trackNode = /** @type {!HTMLTrackElement} */ (
+      this.video_.ownerDocument.createElement('track'));
+
+    trackNode.kind = this.getTrackKind_(track);
+    trackNode.label = this.getTrackLabel_(track);
+    trackNode.srclang = this.resolveTrackLanguage_(track);
+
+    // Chrome may refuse to list tracks without a src in its built-in caption
+    // menu. In Safari, toggling a track from 'disabled'/'hidden' back to
+    // 'showing' without a src causes a visible flash. The minimal WEBVTT data
+    // URL prevents both issues.
+    trackNode.src = 'data:,WEBVTT';
+    trackNode.track.mode = 'disabled';
+
+    this.video_.appendChild(trackNode);
+    return trackNode;
+  }
+
+  /**
+   * Resolves the appropriate srclang value for a track based on its declared
+   * language. Falls back to 'und' (undetermined) if the language is unknown.
+   *
+   * @param {!shaka.extern.TextTrack} track
+   * @return {string}
+   * @private
+   */
+  resolveTrackLanguage_(track) {
+    if (!track.language) {
+      return 'und';
+    }
+    if (track.language in mozilla.LanguageMapping) {
+      return track.language;
+    }
+    return shaka.util.LanguageUtils.getBase(track.language) ?? 'und';
+  }
+
+  /**
+   * Activates the track identified by this.trackId_ among the newly built
+   * nodes, respecting the current mode if it was changed manually by the user.
+   *
+   * @private
+   */
+  activateCurrentTrack_() {
+    if (this.trackId_ <= -1) {
+      return;
+    }
+
+    if (!this.trackNodes_.has(this.trackId_)) {
+      this.trackId_ = -1;
+      return;
+    }
+
+    const track = this.trackNodes_.get(this.trackId_).track;
+    // Only update the mode when the track is 'disabled'. If the user changed
+    // it manually (e.g. hid it), we respect that choice; onChange_ will update
+    // visible_ accordingly.
+    if (track.mode === 'disabled') {
+      track.mode = this.visible_ ? 'showing' : 'hidden';
+    }
   }
 
   /**
+   * Determines which track should be active after a 'change' event.
+   * Prefers the previously selected track; otherwise picks the first 'showing'
+   * track, and falls back to the first 'hidden' track.
+   *
+   * @return {number} The ID of the track to activate, or -1 if none.
+   * @private
+   */
+  resolveActiveTrackId_() {
+    let trackId = -1;
+
+    // Prefer the previously active track.
+    if (this.trackNodes_.has(this.trackId_)) {
+      const mode = this.trackNodes_.get(this.trackId_).track.mode;
+      if (mode === 'showing') {
+        return this.trackId_;
+      }
+      if (mode === 'hidden') {
+        trackId = this.trackId_;
+      }
+    }
+
+    // Fallback: find any 'showing' track, or the first 'hidden' one.
+    for (const id of this.trackNodes_.keys()) {
+      const trackNode = /** @type {!HTMLTrackElement} */ (
+        this.trackNodes_.get(id));
+      if (trackNode.track.mode === 'showing') {
+        return id;
+      }
+      if (trackId < 0 && trackNode.track.mode === 'hidden') {
+        trackId = id;
+      }
+    }
+
+    return trackId;
+  }
+
+  /**
+   * Sets all tracks except the specified one to 'disabled', avoiding
+   * unnecessary change events on tracks that are already disabled.
+   *
+   * @param {number} keepTrackId
+   * @private
+   */
+  disableAllTracksExcept_(keepTrackId) {
+    const keepNode = this.trackNodes_.get(keepTrackId);
+    for (const trackNode of this.trackNodes_.values()) {
+      if (trackNode !== keepNode && trackNode.track.mode !== 'disabled') {
+        trackNode.track.mode = 'disabled';
+      }
+    }
+  }
+
+  /**
+   * Notifies the player of the newly selected track, or clears the selection
+   * if trackId is -1.
+   *
+   * @param {number} trackId
+   * @private
+   */
+  syncTrackSelectionWithPlayer_(trackId) {
+    if (trackId > -1) {
+      const textTrack =
+          this.player_.getTextTracks().find((t) => t.id === trackId);
+      if (textTrack) {
+        this.player_.selectTextTrack(textTrack);
+        return;
+      }
+    }
+    this.player_.selectTextTrack(null);
+  }
+
+  /**
+   * Initialises MSE integration if the player is already in MEDIA_SOURCE mode.
+   * Called from the constructor and again on each 'Loaded' event.
+   *
    * @private
    */
   checkMsePlayback_() {
-    // shaka.Player.LoadMode.MEDIA_SOURCE
-    if (!this.video_ && this.player_ && this.player_.getLoadMode() === 2) {
-      this.video_ = this.player_.getMediaElement();
-      this.eventManager_.listenOnce(this.player_,
-          shaka.util.FakeEvent.EventName.Unloading, this.onUnloading_);
-      this.eventManager_.listen(this.player_,
-          shaka.util.FakeEvent.EventName.TextChanged, this.onTextChanged_);
-      this.eventManager_.listen(this.video_.textTracks, 'change',
-          this.onChange_);
-      this.onTextChanged_();
+    if (this.video_ || !this.player_) {
+      return;
+    }
+
+    const LoadMode = shaka.text.NativeTextDisplayer.LoadMode;
+    if (this.player_.getLoadMode() !== LoadMode.MEDIA_SOURCE) {
+      return;
     }
+
+    this.video_ = this.player_.getMediaElement();
+
+    const EventName = shaka.util.FakeEvent.EventName;
+
+    this.eventManager_.listenOnce(this.player_,
+        EventName.Unloading, () => this.onUnloading_());
+    this.loadEventManager_.listen(this.player_,
+        EventName.TextChanged, () => this.onTextChanged_());
+    this.loadEventManager_.listen(this.video_.textTracks,
+        'change', () => this.onChange_());
+
+    this.onTextChanged_();
   }
 
   /**
+   * Returns the appropriate `kind` value for a <track> element.
+   * WebKit requires the 'forced' kind for forced tracks; other browsers use
+   * 'captions' for closed captions and 'subtitles' as the default.
+   *
    * @param {!shaka.extern.TextTrack} track
    * @return {string}
    * @private
    */
-  static getTrackKind_(track) {
+  getTrackKind_(track) {
     const device = shaka.device.DeviceFactory.getDevice();
     if (track.forced && device.getBrowserEngine() ===
         shaka.device.IDevice.BrowserEngine.WEBKIT) {
@@ -360,33 +555,74 @@ shaka.text.NativeTextDisplayer = class {
   }
 
   /**
+   * Builds a human-readable label for a track. Priority order:
+   * 1. track.label (if explicitly set)
+   * 2. Intl.DisplayNames resolution (when available)
+   * 3. Full language name from LanguageMapping (exact match)
+   * 4. Base language name from LanguageMapping with variant in parentheses
+   * 5. originalTextId with the language code in parentheses if they differ
+   *
    * @param {!shaka.extern.TextTrack} track
    * @return {string}
    * @private
    */
-  static getTrackLabel_(track) {
-    /** @type {string} */
-    let label;
+  getTrackLabel_(track) {
     if (track.label) {
-      label = track.label;
-    } else if (track.language) {
-      if (track.language in mozilla.LanguageMapping) {
-        label = mozilla.LanguageMapping[track.language];
-      } else {
-        const language = shaka.util.LanguageUtils.getBase(track.language);
-        if (language in mozilla.LanguageMapping) {
-          label =
-            `${mozilla.LanguageMapping[language]} (${track.language})`;
+      return track.label;
+    }
+
+    if (track.language) {
+      const base = shaka.util.LanguageUtils.getBase(track.language);
+
+      // 1. Intl.DisplayNames — preferred when available: provides OS-level
+      //    resolution for any valid BCP-47 tag in the user's UI locale without
+      //    relying on a hand-maintained mapping.
+      if (window.Intl && 'DisplayNames' in Intl) {
+        try {
+          const displayNames = new Intl.DisplayNames(track.language,
+              {type: 'language', languageDisplay: 'standard'});
+          const displayName = displayNames.of(track.language);
+          // Only prefer it when it's reliable
+          if (displayName &&
+              displayName.toLowerCase() != track.language.toLowerCase()) {
+            return displayName.charAt(0).toUpperCase() + displayName.slice(1);
+          }
+        } catch (_e) {
+          // Intl.DisplayNames may throw for malformed tags; fall through.
         }
       }
-    }
-    if (!label) {
-      label = /** @type {string} */(track.originalTextId);
-      if (track.language && track.language !== track.originalTextId) {
-        label += ` (${track.language})`;
+
+      // 2. Exact match in mozilla.LanguageMapping.
+      const exactMatch = mozilla.LanguageMapping[track.language];
+      if (exactMatch) {
+        return exactMatch;
+      }
+
+      // 3. Base-language match in mozilla.LanguageMapping, with the full tag
+      //    shown in parentheses so the variant is still visible to the user.
+      const baseMatch = base && mozilla.LanguageMapping[base];
+      if (baseMatch) {
+        return base === track.language ?
+            baseMatch : `${baseMatch} (${track.language})`;
       }
     }
 
-    return label;
+    // Last resort: use originalTextId, coercing nullish values to an empty
+    // string.
+    const fallback = String(track.originalTextId ?? '');
+    if (track.language && track.language !== track.originalTextId) {
+      return `${fallback} (${track.language})`;
+    }
+
+    return fallback;
   }
 };
+
+/**
+ * Named constants mirroring shaka.Player.LoadMode to avoid magic numbers.
+ * @enum {number}
+ */
+shaka.text.NativeTextDisplayer.LoadMode = {
+  MEDIA_SOURCE: 2,
+  SRC_EQUALS: 3,
+};

From 921206dc1d78f0b0fcaeefb320e9015fb300195f Mon Sep 17 00:00:00 2001
From: Ivan <48260572+vanyaxk@users.noreply.github.com>
Date: Wed, 27 May 2026 21:51:03 +0200
Subject: [PATCH 47/64] feat: transmux in a worker (#9914)

This PR introduces a Web Worker for transmuxing resolving
https://github.com/shaka-project/shaka-player/issues/1735

- The worker bundle is compiled separately
- The build output is embedded as a string constant and then wrapped in
a Blob to create an inline Worker URL (HLS.js does this very similarly)
- `TransmuxerProxy` is created wrapping a real transmuxer, but no worker
is started yet - on the first `transmux()` call, it checks if the device
supports worker transmuxing
- For each transmux() call: the buffer is copied, then zero-copy
transferred to the worker. A PublicPromise is stored under a reqId with
a timeout timer, and the main thread awaits it.
- The worker transmuxes and posts back transmuxed (or error). The shared
message listener routes the response to the right proxy instance by id,
which resolves the promise and cancels the timer.
- When the last proxy instance is destroyed, the worker is terminated
and the blob URL is revoked.
  loaded inside the worker.
- Some low-end devices have been excluded since their Worker support is
questionable

There most likely is a better way to do this - please let me know
---
 build/all.py                                  |  11 +
 build/build.py                                |  81 ++-
 build/check.py                                |  10 +-
 build/types/core                              |   1 +
 build/types/transmuxer-worker                 |  10 +
 demo/config.js                                |  12 +
 demo/main.js                                  |  30 +
 docs/tutorials/index.json                     |   1 +
 docs/tutorials/transmuxing-in-worker.md       | 205 +++++++
 externs/shaka/player.js                       |  16 +-
 karma.conf.js                                 |   3 +
 lib/debug/log.js                              |   4 +-
 lib/device/abstract_device.js                 |   7 +
 lib/device/hisense.js                         |   7 +
 lib/device/i_device.js                        |   9 +
 lib/device/tizen.js                           |  12 +
 lib/device/webos.js                           |  12 +
 lib/media/media_source_capabilities.js        |   7 +-
 lib/media/media_source_engine.js              |  14 +-
 lib/transmuxer/loc_transmuxer.js              |   9 +-
 lib/transmuxer/transmuxer_engine.js           |  63 +-
 lib/transmuxer/transmuxer_proxy.js            | 416 +++++++++++++
 lib/transmuxer/transmuxer_worker.js           | 267 ++++++++
 lib/transmuxer/ts_transmuxer.js               |   9 +-
 lib/util/mime_utils.js                        |  86 +++
 lib/util/player_configuration.js              |   1 +
 lib/util/stream_utils.js                      |  92 +--
 lib/util/string_utils.js                      |   4 +-
 lib/util/uint8array_utils.js                  |   4 +-
 test/media/media_source_engine_integration.js |   4 +
 test/media/media_source_engine_unit.js        |  39 +-
 test/test/util/util.js                        |   5 +-
 test/transmuxer/transmuxer_proxy_unit.js      | 580 ++++++++++++++++++
 transmuxer_worker.uncompiled.js               |  66 ++
 34 files changed, 1955 insertions(+), 142 deletions(-)
 create mode 100644 build/types/transmuxer-worker
 create mode 100644 docs/tutorials/transmuxing-in-worker.md
 create mode 100644 lib/transmuxer/transmuxer_proxy.js
 create mode 100644 lib/transmuxer/transmuxer_worker.js
 create mode 100644 test/transmuxer/transmuxer_proxy_unit.js
 create mode 100644 transmuxer_worker.uncompiled.js

diff --git a/build/all.py b/build/all.py
index 99a4f058a6..7efc553915 100755
--- a/build/all.py
+++ b/build/all.py
@@ -231,6 +231,16 @@ def main(args):
   for mode in modes:
     tasks = []
 
+    worker_args = [
+      '--worker', '--name', 'transmuxer-worker',
+      '+@transmuxer-worker', '--langout', 'ECMASCRIPT5', '--mode', mode,
+    ]
+    if parsed_args.force:
+      worker_args += ['--force']
+    tasks.append((
+      [sys.executable, os.path.join(base, 'build', 'build.py')] + worker_args,
+      os.environ.copy()))
+
     for lang_out, suffix in language_variants:
       for build_args in builds:
         args = list(build_args)
@@ -242,6 +252,7 @@ def main(args):
         # Add language and mode flags.
         args += ['--langout', lang_out]
         args += ['--mode', mode]
+        args += ['--skip-worker']
 
         # Prepare environment and command for a separate process.
         env = os.environ.copy()
diff --git a/build/build.py b/build/build.py
index 7d3ccd1a64..00f718c9f8 100755
--- a/build/build.py
+++ b/build/build.py
@@ -192,6 +192,13 @@ def has_cast(self):
         return True
     return False
 
+  def has_transmuxer_proxy(self):
+    """Returns True if the transmuxer proxy is in the build."""
+    for path in self.include:
+      if path.endswith('transmuxer_proxy.js'):
+        return True
+    return False
+
   def generate_localizations(self, locales, force):
     localizations = compiler.GenerateLocalizations(locales)
     localizations.generate(force)
@@ -265,7 +272,56 @@ def parse_build(self, lines, root):
 
     return True
 
-  def build_library(self, name, langout, locales, force, is_debug, skip_ts):
+  def build_worker_bundle(self, langout, force, is_debug):
+    """Compiles the transmuxer worker bundle.
+
+    Returns True on success; False on failure.
+    """
+    worker_build = Build()
+    if not worker_build.parse_build(['+@transmuxer-worker'], os.getcwd()):
+      return False
+    worker_build.add_closure()
+    if not worker_build.add_core():
+      return False
+
+    build_name = 'shaka-player.transmuxer-worker'
+    if is_debug:
+      build_name += '.debug'
+    closure = compiler.ClosureCompiler(worker_build.include, build_name)
+    closure.add_wrapper = False
+    closure.add_source_map = False
+
+    closure_opts = common_closure_opts + common_closure_defines
+    closure_opts += ['--language_out', langout]
+    if is_debug:
+      closure_opts += debug_closure_opts + debug_closure_defines
+    else:
+      closure_opts += release_closure_opts + release_closure_defines
+
+    closure_opts += [
+        '--dependency_mode=PRUNE',
+        '--entry_point=goog:shaka.transmuxer.TransmuxerWorker',
+        # Each transmuxer plugin registers itself at load time (side effect),
+        # so we must list them as entry points too.
+        '--entry_point=goog:shaka.transmuxer.AacTransmuxer',
+        '--entry_point=goog:shaka.transmuxer.Ac3Transmuxer',
+        '--entry_point=goog:shaka.transmuxer.Ec3Transmuxer',
+        '--entry_point=goog:shaka.transmuxer.Mp3Transmuxer',
+        '--entry_point=goog:shaka.transmuxer.MpegTsTransmuxer',
+        '--entry_point=goog:shaka.transmuxer.TsTransmuxer',
+    ]
+
+    # Suppress type errors caused by dependency pruning; the main build
+    # already validates all types.
+    closure_opts += [
+        '--jscomp_off=checkTypes',
+        '--jscomp_off=unknownDefines',
+    ]
+
+    return closure.compile(closure_opts, force)
+
+  def build_library(self, name, langout, locales, force, is_debug, skip_ts,
+      build_worker):
     """Builds Shaka Player using the files in |self.include|.
 
     Args:
@@ -275,6 +331,7 @@ def build_library(self, name, langout, locales, force, is_debug, skip_ts):
       force: True to rebuild, False to ignore if no changes are detected.
       is_debug: True to compile for debugging, false for release.
       skip_ts: True to skip generation of TypeScript definitions.
+      build_worker: True to build the standalone transmuxer worker if needed.
 
     Returns:
       True on success; False on failure.
@@ -289,6 +346,11 @@ def build_library(self, name, langout, locales, force, is_debug, skip_ts):
       if not self.has_cast():
         self.include.add(os.path.abspath('conditional/dummy_cast_proxy.js'))
 
+    if build_worker and self.has_transmuxer_proxy():
+      logging.info('Compiling transmuxer worker bundle...')
+      if not self.build_worker_bundle(langout, force, is_debug):
+        return False
+
     if is_debug:
       name += '.debug'
 
@@ -385,6 +447,16 @@ def main(args):
     help='Skips generation of TypeScript definition files (.d.ts).',
     action='store_true')
 
+  parser.add_argument(
+    '--worker',
+    help='Build only the standalone transmuxer worker script.',
+    action='store_true')
+
+  parser.add_argument(
+    '--skip-worker',
+    help='Do not build the standalone transmuxer worker alongside the library.',
+    action='store_true')
+
   parsed_args, commands = parser.parse_known_args(args)
 
   # Make the dist/ folder, ignore errors.
@@ -501,8 +573,11 @@ def locked_file_rw(path, create=False):
   is_debug = parsed_args.mode == 'debug'
   skip_ts = parsed_args.skip_ts
 
-  if not custom_build.build_library(name, langout, locales, force, is_debug,
-      skip_ts):
+  if parsed_args.worker:
+    if not custom_build.build_worker_bundle(langout, force, is_debug):
+      return 1
+  elif not custom_build.build_library(name, langout, locales, force, is_debug,
+      skip_ts, not parsed_args.skip_worker):
     return 1
 
   # Persist (merge) the updated state under lock so we don't clobber parallel updates.
diff --git a/build/check.py b/build/check.py
index 0d93a33425..9634f12aa4 100755
--- a/build/check.py
+++ b/build/check.py
@@ -17,7 +17,7 @@
 """This is used to validate that the library is correct.
 
 This checks:
- * All files in lib/ appear when compiling +@complete
+ * All files in lib/ appear in +@complete or another standalone build type
  * Runs a compiler pass over the test code to check for type errors
  * Run the linter to check for style violations.
 """
@@ -48,7 +48,11 @@ def complete_build_files():
   # Normally we don't need to include @core, but because we look at the build
   # object directly, we need to include it here.  When using main(), it will
   # call addCore which will ensure core is included.
-  if not complete.parse_build(['+@complete', '+@core'], os.getcwd()):
+  #
+  # Standalone build types are included here so their entry points are covered
+  # by the "all files are in a build" invariant without bloating +@complete.
+  if not complete.parse_build(
+      ['+@complete', '+@core', '+@transmuxer-worker'], os.getcwd()):
     logging.error('Error parsing complete build')
     return False
   return complete.include
@@ -120,7 +124,7 @@ def check_html_lint(args):
 
 @_Check('complete')
 def check_complete(_):
-  """Checks whether the 'complete' build references every file.
+  """Checks whether the build type definitions reference every file.
 
   This is used by the build script to ensure that every file is included in at
   least one build type.
diff --git a/build/types/core b/build/types/core
index 23a728059c..e1e6cb225b 100644
--- a/build/types/core
+++ b/build/types/core
@@ -79,6 +79,7 @@
 +../../lib/text/web_vtt_generator.js
 
 +../../lib/transmuxer/transmuxer_engine.js
++../../lib/transmuxer/transmuxer_proxy.js
 +../../lib/transmuxer/transmuxer_utils.js
 
 +../../lib/util/abortable_operation.js
diff --git a/build/types/transmuxer-worker b/build/types/transmuxer-worker
new file mode 100644
index 0000000000..a1e2a7202e
--- /dev/null
+++ b/build/types/transmuxer-worker
@@ -0,0 +1,10 @@
+# Transmuxer Worker bundle.
+# This build type produces a standalone script to be loaded in a Web Worker.
+# It includes all transmuxer plugins and the worker entry point.
+
++../../lib/device/apple_browser.js
++../../lib/device/default_browser.js
++@devices
++../../lib/transmuxer/loc_transmuxer.js
++../../lib/transmuxer/transmuxer_worker.js
++@transmuxer
diff --git a/demo/config.js b/demo/config.js
index d4ffd73dc1..ef70cde7dd 100644
--- a/demo/config.js
+++ b/demo/config.js
@@ -806,6 +806,18 @@ shakaDemo.Config = class {
             'mediaSource.useSourceElements')
         .addBoolInput_('Expect updateEnd when duration is truncated',
             'mediaSource.durationReductionEmitsUpdateEnd');
+
+    const transmuxWorkerToggleOnChange = (input) => {
+      const url = input.checked ?
+          shakaDemoMain.getTransmuxerWorkerUrl() : '';
+      shakaDemoMain.configure('mediaSource.transmuxWorkerUrl', url);
+      shakaDemoMain.remakeHash();
+    };
+    this.addCustomBoolInput_(
+        'Use a worker for transmuxing', transmuxWorkerToggleOnChange);
+    if (shakaDemoMain.getCurrentConfigValue('mediaSource.transmuxWorkerUrl')) {
+      this.latestInput_.input().checked = true;
+    }
   }
 
   /**
diff --git a/demo/main.js b/demo/main.js
index ae05d2354a..1d6a419e3c 100644
--- a/demo/main.js
+++ b/demo/main.js
@@ -429,6 +429,13 @@ shakaDemo.Main = class {
     this.player_.configure(
         'manifest.dash.clockSyncUri', 'https://time.akamai.com/?ms&iso');
 
+    // The library does not auto-detect the transmuxer worker URL — the demo
+    // is responsible for telling Shaka where to load it from. The path
+    // depends on which build the demo loaded (compiled, debug, uncompiled).
+    this.player_.configure(
+        'mediaSource.transmuxWorkerUrl',
+        this.getTransmuxerWorkerUrl());
+
     // Get default config.
     this.defaultConfig_ = this.player_.getConfiguration();
     this.desiredConfig_ = this.player_.getConfiguration();
@@ -1228,6 +1235,29 @@ shakaDemo.Main = class {
     return params;
   }
 
+  /**
+   * Picks the worker bundle that matches the build the demo loaded.
+   * The demo always serves the worker from `../dist/` (compiled) or from
+   * the repo root (`../transmuxer_worker.uncompiled.js`).
+   * @return {string}
+   */
+  getTransmuxerWorkerUrl() {
+    const params = this.getParams_();
+    let buildType = 'uncompiled';
+    if (params.has('build')) {
+      buildType = params.get('build');
+    } else if (params.has('compiled')) {
+      buildType = 'compiled';
+    }
+    if (buildType === 'uncompiled') {
+      return '../transmuxer_worker.uncompiled.js';
+    }
+    if (buildType === 'debug_compiled') {
+      return '../dist/shaka-player.transmuxer-worker.debug.js';
+    }
+    return '../dist/shaka-player.transmuxer-worker.js';
+  }
+
   /**
    * Recovers the value from the given config field, from an arbitrary config
    * object.
diff --git a/docs/tutorials/index.json b/docs/tutorials/index.json
index c6080f3f8b..aa0c9fc1e4 100644
--- a/docs/tutorials/index.json
+++ b/docs/tutorials/index.json
@@ -9,6 +9,7 @@
   { "license-wrapping": { "title": "License Wrapping" } },
   { "moq": { "title": "MoQ" } },
   { "preload": { "title": "Preloading" } },
+  { "transmuxing-in-worker": { "title": "Transmuxing in Worker" } },
   { "ui": { "title": "UI Library" } },
   { "ui-customization": { "title": "Configuring the UI" } },
   { "text-displayer": { "title": "Configuring text displayer" } },
diff --git a/docs/tutorials/transmuxing-in-worker.md b/docs/tutorials/transmuxing-in-worker.md
new file mode 100644
index 0000000000..bb92ec6482
--- /dev/null
+++ b/docs/tutorials/transmuxing-in-worker.md
@@ -0,0 +1,205 @@
+# Transmuxing in a Web Worker
+
+#### Overview
+
+When playing HLS streams with MPEG-TS segments, Shaka Player must transmux
+(convert) each segment from MPEG-TS to fMP4 before feeding it to
+`MediaSource`. By default this work happens synchronously on the main thread,
+which can cause frame drops or audio glitches on slower devices.
+
+Shaka Player can offload this work to a dedicated **Web Worker**, freeing the
+main thread for rendering and UI. The worker is shared across all active
+streams (audio and video), so only one worker thread is ever created per page.
+
+#### Quick Summary
+
+To enable worker-based transmuxing you must do **two** things:
+
+1. Make the compiled worker script reachable over HTTP from your page.
+2. Tell Shaka where to find it via `mediaSource.transmuxWorkerUrl`.
+
+Shaka does **not** auto-detect the worker URL. The library cannot reliably
+know where its assets live at runtime (script tags, bundler output, CDNs,
+ES modules, hashed filenames all differ). The integrating application owns
+how Shaka is loaded, so the application also owns the worker URL.
+
+If `transmuxWorkerUrl` is not set, transmux falls back to the main thread.
+No error is thrown — the feature simply stays dormant.
+
+#### Configuration Key
+
+```js
+player.configure({
+  mediaSource: {
+    // URL of the worker script. Empty by default. Required for the worker
+    // to run; empty string keeps transmuxing on the main thread.
+    transmuxWorkerUrl: '',
+  },
+});
+```
+
+When `transmuxWorkerUrl` is a non-empty string, Shaka creates the worker on
+the first transmux call. Empty value (or device-level opt-out — see below)
+falls back to main-thread transmuxing.
+
+#### The Worker File
+
+Compiled builds emit the worker as a standalone bundle next to the main
+library bundle:
+
+| Build type | Worker filename |
+| ---------- | --------------------------------------- |
+| Release    | `shaka-player.transmuxer-worker.js`     |
+| Debug      | `shaka-player.transmuxer-worker.debug.js` |
+
+Both files live in `dist/` after running `python3 build/all.py`, and ship
+inside the npm package under `node_modules/shaka-player/dist/`.
+
+You must serve the worker file from a URL the browser can reach. The exact
+path depends on how you deploy Shaka — see the patterns below.
+
+#### Deployment Patterns
+
+##### Plain `<script>` tag
+
+If you ship `shaka-player.compiled.js` from `/static/`, copy the worker
+alongside it and point Shaka at the same directory:
+
+```html
+<script src="/static/shaka-player.compiled.js"></script>
+<script>
+  const player = new shaka.Player();
+  player.configure(
+      'mediaSource.transmuxWorkerUrl',
+      '/static/shaka-player.transmuxer-worker.js');
+</script>
+```
+
+##### Webpack 5 / Vite / Rollup (modern bundlers)
+
+Use `new URL(..., import.meta.url)`. The bundler resolves the npm path,
+copies the worker into the build output, and rewrites the URL at build
+time:
+
+```js
+const workerUrl = new URL(
+    'shaka-player/dist/shaka-player.transmuxer-worker.js',
+    import.meta.url,
+).toString();
+
+player.configure('mediaSource.transmuxWorkerUrl', workerUrl);
+```
+
+##### Webpack 4
+
+Webpack 4 has no `import.meta.url` support. Use `file-loader` or
+`asset/resource`:
+
+```js
+import workerUrl from
+    'shaka-player/dist/shaka-player.transmuxer-worker.js?url';
+
+player.configure('mediaSource.transmuxWorkerUrl', workerUrl);
+```
+
+##### Create React App / static `public/` folder
+
+Copy `node_modules/shaka-player/dist/shaka-player.transmuxer-worker.js`
+into `public/` (or your equivalent static asset folder) and reference it
+by absolute path:
+
+```js
+player.configure(
+    'mediaSource.transmuxWorkerUrl',
+    '/shaka-player.transmuxer-worker.js');
+```
+
+A small build script that copies the file on `postinstall` keeps the
+worker version in sync with the installed package.
+
+#### Same-Origin and CORS Requirements
+
+`new Worker(url)` requires the worker script to be either:
+
+- same origin as the host page, or
+- served with CORS headers that allow the host origin
+  (`Access-Control-Allow-Origin`, plus `Cross-Origin-Resource-Policy` when
+  the page itself runs cross-origin).
+
+Self-hosted same-origin deployments need no extra headers. Cross-origin
+deployments must serve the worker with proper CORS configuration, or the
+browser will reject the `new Worker(url)` call and Shaka will fall back to
+main-thread transmuxing.
+
+#### Uncompiled / Development Mode
+
+In uncompiled mode (running Shaka directly from source for development)
+the worker is bootstrapped from `transmuxer_worker.uncompiled.js` at the
+repository root. Set the URL the same way:
+
+```js
+player.configure(
+    'mediaSource.transmuxWorkerUrl',
+    '/path/to/shaka-player/transmuxer_worker.uncompiled.js');
+```
+
+Run `python3 build/gendeps.py` first so the bootstrap script can locate
+the Closure dependency graph.
+
+#### Disabling the Worker
+
+To force main-thread transmuxing — for debugging or for environments
+where Web Workers are unreliable — leave `transmuxWorkerUrl` empty, or
+clear it at runtime:
+
+```js
+player.configure('mediaSource.transmuxWorkerUrl', '');
+```
+
+Certain TV platforms (Tizen, WebOS, Hisense) also opt out of worker
+transmuxing internally via the device layer regardless of this setting,
+because Worker support is often limited or unstable on those devices.
+
+#### Fallback Chain
+
+Shaka silently falls back to main-thread transmuxing in any of these
+cases:
+
+1. `transmuxWorkerUrl` is empty.
+2. The device platform reports no Worker support (e.g. older Tizen/WebOS).
+3. `new Worker(url)` throws — CSP block, network error, MIME mismatch.
+4. The first `postMessage` to the worker fails.
+5. The worker does not respond within 30 seconds for a given segment.
+
+The fallback is transparent: playback continues without error. A warning
+is logged to the console when a fallback is taken.
+
+#### Troubleshooting
+
+**Worker URL returns 404.** Open DevTools → Network, filter by `worker`,
+and compare the requested URL against your deployed asset paths. Most
+often the worker file was not copied alongside the main bundle.
+
+**CSP blocks the worker.** Add the worker's origin to the relevant
+Content-Security-Policy directives:
+
+```
+worker-src 'self';
+script-src 'self';
+```
+
+If the worker is served from a different origin, list that origin in
+both directives (and `connect-src` if your app also fetches it
+directly).
+
+**Cross-origin Worker rejected.** Ensure the worker response includes
+`Access-Control-Allow-Origin: <your page origin>` and, when the page is
+itself cross-origin-isolated, `Cross-Origin-Resource-Policy:
+cross-origin`.
+
+**Need to isolate a transmux bug.** Disable the worker as shown above so
+that any transmux failure surfaces on the main thread with a full stack
+trace.
+
+For general configuration see {@tutorial config}, and for all
+`mediaSource` options see {@link shaka.extern.MediaSourceConfiguration}.
diff --git a/externs/shaka/player.js b/externs/shaka/player.js
index c8c26b67a0..caea394ca2 100644
--- a/externs/shaka/player.js
+++ b/externs/shaka/player.js
@@ -2357,7 +2357,8 @@ shaka.extern.NetworkingConfiguration;
  *   modifyCueCallback: shaka.extern.TextParser.ModifyCueCallback,
  *   dispatchAllEmsgBoxes: boolean,
  *   useSourceElements: boolean,
- *   durationReductionEmitsUpdateEnd: boolean
+ *   durationReductionEmitsUpdateEnd: boolean,
+ *   transmuxWorkerUrl: string
  * }}
  *
  * @description
@@ -2425,6 +2426,19 @@ shaka.extern.NetworkingConfiguration;
  *   smaller than existing value.
  *   <br>
  *   Defaults to <code>true</code>.
+ * @property {string} transmuxWorkerUrl
+ *   URL of the standalone transmuxer worker script. When set to a non-empty
+ *   string, transmuxing (e.g., MPEG-TS to MP4) is offloaded to a Web Worker
+ *   loaded from this URL, freeing the main thread. When empty, transmuxing
+ *   runs on the main thread.
+ *   <br>
+ *   The library does not auto-detect this URL; the integrating application
+ *   is responsible for serving the worker script (e.g.,
+ *   <code>shaka-player.transmuxer-worker.js</code> from <code>dist/</code>)
+ *   and providing the URL here. Falls back to main-thread transmuxing if the
+ *   worker fails to load or the device does not support Workers.
+ *   <br>
+ *   Defaults to <code>''</code> (worker disabled).
  * @exportDoc
  */
 shaka.extern.MediaSourceConfiguration;
diff --git a/karma.conf.js b/karma.conf.js
index 0903ca7a1d..98fee2462b 100644
--- a/karma.conf.js
+++ b/karma.conf.js
@@ -309,6 +309,9 @@ module.exports = (config) => {
       {pattern: 'test/test/assets/lcevc-sei-ts/*', included: false},
       {pattern: 'test/test/assets/lcevc-dual-track/*', included: false},
       {pattern: 'dist/shaka-player.experimental.js', included: false},
+      {pattern: 'dist/shaka-player.transmuxer-worker.js', included: false},
+      // eslint-disable-next-line @stylistic/max-len
+      {pattern: 'dist/shaka-player.transmuxer-worker.debug.js', included: false},
       {pattern: 'dist/locales.js', included: false},
       {pattern: 'demo/**/*.js', included: false},
       {pattern: 'demo/locales/en.json', included: false},
diff --git a/lib/debug/log.js b/lib/debug/log.js
index bac380df55..1063ae24fe 100644
--- a/lib/debug/log.js
+++ b/lib/debug/log.js
@@ -134,7 +134,9 @@ shaka.log.MAX_LOG_LEVEL = 3;
 shaka.log.oneTimeWarningIssued_ = new Set();
 
 
-if (window.console) {
+// Use `self` instead of `window` so this code works in both the main thread
+// and Web Workers (where `window` is undefined).
+if (self.console) {
   /** @private {!Map<shaka.log.Level, function(...*)>} */
   shaka.log.logMap_ = new Map()
       .set(shaka.log.Level.ERROR, (...args) => console.error(...args))
diff --git a/lib/device/abstract_device.js b/lib/device/abstract_device.js
index 3f87aa3f2a..f6f55f4166 100644
--- a/lib/device/abstract_device.js
+++ b/lib/device/abstract_device.js
@@ -382,6 +382,13 @@ shaka.device.AbstractDevice = class {
     return null;
   }
 
+  /**
+   * @override
+   */
+  supportsWorkerTransmux() {
+    return typeof Worker !== 'undefined';
+  }
+
   /**
    * @override
    */
diff --git a/lib/device/hisense.js b/lib/device/hisense.js
index 9aad01de4b..42276d604c 100644
--- a/lib/device/hisense.js
+++ b/lib/device/hisense.js
@@ -91,6 +91,13 @@ shaka.device.Hisense = class extends shaka.device.AbstractDevice {
     return config;
   }
 
+  /**
+   * @override
+   */
+  supportsWorkerTransmux() {
+    return false;
+  }
+
   /**
    * @return {boolean}
    * @private
diff --git a/lib/device/i_device.js b/lib/device/i_device.js
index e26c7bfd94..ef99303df1 100644
--- a/lib/device/i_device.js
+++ b/lib/device/i_device.js
@@ -262,6 +262,15 @@ shaka.device.IDevice = class {
    * @return {?RemotePlayback}
    */
   getRemote(video) {}
+
+  /**
+   * Returns true if the platform reliably supports running transmuxing
+   * operations in a Web Worker. Devices with known Worker instability or
+   * broken Worker implementations should return false here.
+   *
+   * @return {boolean}
+   */
+  supportsWorkerTransmux() {}
 };
 
 /**
diff --git a/lib/device/tizen.js b/lib/device/tizen.js
index 2996936690..73189fcfcd 100644
--- a/lib/device/tizen.js
+++ b/lib/device/tizen.js
@@ -206,6 +206,18 @@ shaka.device.Tizen = class extends shaka.device.AbstractDevice {
     return this.getVersion() === 3;
   }
 
+  /**
+   * @override
+   */
+  supportsWorkerTransmux() {
+    // Web Workers are unreliable on Tizen 2.
+    const version = this.getVersion();
+    if (version !== null && version < 3) {
+      return false;
+    }
+    return super.supportsWorkerTransmux();
+  }
+
   /**
    * @return {boolean}
    * @private
diff --git a/lib/device/webos.js b/lib/device/webos.js
index 478e2ef613..c222bfde38 100644
--- a/lib/device/webos.js
+++ b/lib/device/webos.js
@@ -214,6 +214,18 @@ shaka.device.WebOS = class extends shaka.device.AbstractDevice {
         version >= 6 : super.supportsCbcsWithoutEncryptionSchemeSupport();
   }
 
+  /**
+   * @override
+   */
+  supportsWorkerTransmux() {
+    // Web Workers are unreliable on WebOS 3 and earlier.
+    const version = this.getVersion();
+    if (version !== null && version < 4) {
+      return false;
+    }
+    return super.supportsWorkerTransmux();
+  }
+
   /**
    * @return {boolean}
    * @private
diff --git a/lib/media/media_source_capabilities.js b/lib/media/media_source_capabilities.js
index d52e158d26..182e155070 100644
--- a/lib/media/media_source_capabilities.js
+++ b/lib/media/media_source_capabilities.js
@@ -21,7 +21,9 @@ shaka.media.Capabilities = class {
   static isTypeSupported(type) {
     const supportMap = shaka.media.Capabilities.MediaSourceTypeSupportMap;
     return supportMap.getOrInsertComputed(type, () => {
-      const mediaSource = window.ManagedMediaSource || window.MediaSource;
+      // Use self instead of window so this works in Worker contexts
+      // (where window is not defined) as well as on the main thread.
+      const mediaSource = self.ManagedMediaSource || self.MediaSource;
       return mediaSource?.isTypeSupported(type) ?? false;
     });
   }
@@ -34,7 +36,8 @@ shaka.media.Capabilities = class {
    * @return {boolean}
    */
   static isInfiniteLiveStreamDurationSupported() {
-    const mediaSource = window.ManagedMediaSource || window.MediaSource;
+    // Use self instead of window so this works in Worker contexts.
+    const mediaSource = self.ManagedMediaSource || self.MediaSource;
     // eslint-disable-next-line no-restricted-syntax
     if (mediaSource && mediaSource.prototype) {
       // eslint-disable-next-line no-restricted-syntax
diff --git a/lib/media/media_source_engine.js b/lib/media/media_source_engine.js
index 8792ecc7a0..f5f5d36f11 100644
--- a/lib/media/media_source_engine.js
+++ b/lib/media/media_source_engine.js
@@ -18,6 +18,7 @@ goog.require('shaka.media.SegmentReference');
 goog.require('shaka.media.TimeRangesUtils');
 goog.require('shaka.text.TextEngine');
 goog.require('shaka.transmuxer.TransmuxerEngine');
+goog.require('shaka.transmuxer.TransmuxerProxy');
 goog.require('shaka.util.ArrayUtils');
 goog.require('shaka.util.BufferUtils');
 goog.require('shaka.util.Destroyer');
@@ -33,7 +34,6 @@ goog.require('shaka.util.MimeUtils');
 goog.require('shaka.util.Mp4BoxParsers');
 goog.require('shaka.util.Mp4Parser');
 goog.require('shaka.util.NumberUtils');
-goog.require('shaka.util.StreamUtils');
 goog.require('shaka.util.TimeUtils');
 goog.require('shaka.util.TsParser');
 goog.require('shaka.lcevc.Dec');
@@ -388,7 +388,7 @@ shaka.media.MediaSourceEngine = class {
         support[type] = true;
       } else if (device.supportsMediaSource()) {
         const baseMimeType = MimeUtils.getBasicType(type);
-        const codecs = shaka.util.StreamUtils.getCorrectAudioCodecs(
+        const codecs = MimeUtils.getCorrectAudioCodecs(
             MimeUtils.getCodecs(type), baseMimeType);
         const newType = MimeUtils.getFullType(baseMimeType, codecs);
         support[type] = shaka.media.Capabilities.isTypeSupported(newType) ||
@@ -574,13 +574,13 @@ shaka.media.MediaSourceEngine = class {
     const ContentType = shaka.util.ManifestParserUtils.ContentType;
 
     if (contentType == ContentType.AUDIO && codecs) {
-      codecs = shaka.util.StreamUtils.getCorrectAudioCodecs(
+      codecs = shaka.util.MimeUtils.getCorrectAudioCodecs(
           codecs, stream.mimeType);
     }
 
     if (contentType == ContentType.VIDEO && codecs &&
         stream.mimeType == 'video/mp4') {
-      codecs = shaka.util.StreamUtils.getCorrectVideoCodecs(codecs);
+      codecs = shaka.util.MimeUtils.getCorrectVideoCodecs(codecs);
     }
 
     let mimeType = shaka.util.MimeUtils.getFullType(
@@ -611,7 +611,8 @@ shaka.media.MediaSourceEngine = class {
         const transmuxerPlugin = shaka.transmuxer.TransmuxerEngine
             .findTransmuxer(mimeTypeWithAllCodecs);
         if (transmuxerPlugin) {
-          const transmuxer = transmuxerPlugin();
+          const transmuxer = new shaka.transmuxer.TransmuxerProxy(
+              transmuxerPlugin(), this.config_.transmuxWorkerUrl);
           this.transmuxers_.set(contentType, transmuxer);
           mimeType =
               transmuxer.convertCodecs(contentType, mimeTypeWithAllCodecs);
@@ -2505,7 +2506,8 @@ shaka.media.MediaSourceEngine = class {
       const transmuxerPlugin =
           TransmuxerEngine.findTransmuxer(newMimeTypeWithAllCodecs);
       if (transmuxerPlugin) {
-        transmuxer = transmuxerPlugin();
+        transmuxer = new shaka.transmuxer.TransmuxerProxy(
+            transmuxerPlugin(), this.config_.transmuxWorkerUrl);
         if (audioCodec && videoCodec) {
           transmuxerMuxed = true;
         }
diff --git a/lib/transmuxer/loc_transmuxer.js b/lib/transmuxer/loc_transmuxer.js
index 69ab3f3b29..6e90dc99ae 100644
--- a/lib/transmuxer/loc_transmuxer.js
+++ b/lib/transmuxer/loc_transmuxer.js
@@ -17,7 +17,6 @@ goog.require('shaka.util.BufferUtils');
 goog.require('shaka.util.ManifestParserUtils');
 goog.require('shaka.util.MimeUtils');
 goog.require('shaka.util.Mp4Generator');
-goog.require('shaka.util.StreamUtils');
 
 goog.requireType('shaka.media.SegmentReference');
 
@@ -146,12 +145,12 @@ shaka.transmuxer.LocTransmuxer = class {
   convertCodecs(contentType, mimeType) {
     if (this.isLocContainer_(mimeType)) {
       const ContentType = shaka.util.ManifestParserUtils.ContentType;
-      const StreamUtils = shaka.util.StreamUtils;
-      const codecs = shaka.util.MimeUtils.getCodecs(mimeType).split(',')
+      const MimeUtils = shaka.util.MimeUtils;
+      const codecs = MimeUtils.getCodecs(mimeType).split(',')
           .map((codecs) => {
-            return StreamUtils.getCorrectAudioCodecs(codecs, 'audio/mp4');
+            return MimeUtils.getCorrectAudioCodecs(codecs, 'audio/mp4');
           })
-          .map(StreamUtils.getCorrectVideoCodecs).join(',');
+          .map(MimeUtils.getCorrectVideoCodecs).join(',');
       if (contentType == ContentType.AUDIO) {
         return `audio/mp4; codecs="${codecs}"`;
       }
diff --git a/lib/transmuxer/transmuxer_engine.js b/lib/transmuxer/transmuxer_engine.js
index ad928d8964..6611061422 100644
--- a/lib/transmuxer/transmuxer_engine.js
+++ b/lib/transmuxer/transmuxer_engine.js
@@ -58,24 +58,45 @@ shaka.transmuxer.TransmuxerEngine = class {
    * @export
    */
   static findTransmuxer(mimeType, contentType) {
+    const TransmuxerEngine = shaka.transmuxer.TransmuxerEngine;
+    for (const priority of TransmuxerEngine.PLUGIN_PRIORITY_ORDER) {
+      const plugin = TransmuxerEngine.findTransmuxerPlugin(mimeType, priority);
+      if (!plugin) {
+        continue;
+      }
+      const transmuxer = plugin();
+      const isSupported = transmuxer.isSupported(mimeType, contentType);
+      transmuxer.destroy();
+      if (isSupported) {
+        return plugin;
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Finds a plugin registered for |mimeType| without instantiating it or
+   * calling isSupported(). Used by the worker where MediaSource may not be
+   * available to validate support.
+   *
+   * When |priority| is null (default), returns the highest-priority plugin.
+   * When |priority| is specified, returns the plugin at that exact priority or
+   * null if none is registered at that level.
+   *
+   * @param {string} mimeType
+   * @param {?number=} priority
+   * @return {?shaka.extern.TransmuxerPlugin}
+   */
+  static findTransmuxerPlugin(mimeType, priority = null) {
     const TransmuxerEngine = shaka.transmuxer.TransmuxerEngine;
     const normalizedMimetype = TransmuxerEngine.normalizeMimeType_(mimeType);
-    const priorities = [
-      TransmuxerEngine.PluginPriority.APPLICATION,
-      TransmuxerEngine.PluginPriority.PREFERRED,
-      TransmuxerEngine.PluginPriority.PREFERRED_SECONDARY,
-      TransmuxerEngine.PluginPriority.FALLBACK,
-    ];
-    for (const priority of priorities) {
-      const key = normalizedMimetype + '-' + priority;
+    const priorities = priority !== null ?
+        [priority] : TransmuxerEngine.PLUGIN_PRIORITY_ORDER;
+    for (const p of priorities) {
+      const key = normalizedMimetype + '-' + p;
       const object = TransmuxerEngine.transmuxerMap_.get(key);
       if (object) {
-        const transmuxer = object.plugin();
-        const isSupported = transmuxer.isSupported(mimeType, contentType);
-        transmuxer.destroy();
-        if (isSupported) {
-          return object.plugin;
-        }
+        return object.plugin;
       }
     }
     return null;
@@ -159,3 +180,17 @@ shaka.transmuxer.TransmuxerEngine.PluginPriority = {
   'APPLICATION': 4,
 };
 
+
+/**
+ * Priorities in descending order (highest first), used when searching for
+ * a matching transmuxer plugin.
+ *
+ * @const {!Array<number>}
+ */
+shaka.transmuxer.TransmuxerEngine.PLUGIN_PRIORITY_ORDER = [
+  shaka.transmuxer.TransmuxerEngine.PluginPriority.APPLICATION,
+  shaka.transmuxer.TransmuxerEngine.PluginPriority.PREFERRED,
+  shaka.transmuxer.TransmuxerEngine.PluginPriority.PREFERRED_SECONDARY,
+  shaka.transmuxer.TransmuxerEngine.PluginPriority.FALLBACK,
+];
+
diff --git a/lib/transmuxer/transmuxer_proxy.js b/lib/transmuxer/transmuxer_proxy.js
new file mode 100644
index 0000000000..fe1f9b78b4
--- /dev/null
+++ b/lib/transmuxer/transmuxer_proxy.js
@@ -0,0 +1,416 @@
+/*! @license
+ * Shaka Player
+ * Copyright 2016 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('shaka.transmuxer.TransmuxerProxy');
+
+goog.require('shaka.device.DeviceFactory');
+goog.require('shaka.log');
+goog.require('shaka.util.BufferUtils');
+goog.require('shaka.util.Error');
+goog.require('shaka.util.Timer');
+goog.require('shaka.util.Uint8ArrayUtils');
+
+
+/**
+ * @summary A proxy transmuxer that delegates transmux() calls to a Web Worker.
+ *
+ * Synchronous methods (isSupported, convertCodecs, getOriginalMimeType) are
+ * handled on the main thread by the inner transmuxer. Only the heavy
+ * transmux() work is offloaded to the worker.
+ *
+ * The worker URL must be supplied by the integrating application via the
+ * `mediaSource.transmuxWorkerUrl` config option. The library does not attempt
+ * to discover it. If the URL is empty or the worker cannot be created, the
+ * proxy falls back to main-thread transmuxing.
+ *
+ * @implements {shaka.extern.Transmuxer}
+ * @export
+ */
+shaka.transmuxer.TransmuxerProxy = class {
+  /**
+   * @param {!shaka.extern.Transmuxer} innerTransmuxer
+   *   The real transmuxer to use for sync methods and as fallback.
+   * @param {string=} workerUrl
+   *   URL of the standalone transmuxer worker script. When empty, the proxy
+   *   uses main-thread transmuxing.
+   */
+  constructor(innerTransmuxer, workerUrl = '') {
+    /** @private {!shaka.extern.Transmuxer} */
+    this.innerTransmuxer_ = innerTransmuxer;
+
+    /** @private {string} */
+    this.workerUrl_ = workerUrl;
+
+    /** @private {boolean} */
+    this.workerFailed_ = false;
+
+    /** @private {number} */
+    this.nextReqId_ = 0;
+
+    /**
+     * Maps request IDs to pending promise resolvers and their timeout timers.
+     * @private {!Map<number, {resolve: function(*), reject: function(*),
+     *     timer: shaka.util.Timer}>}
+     */
+    this.pendingRequests_ = new Map();
+
+    /** @private {number} */
+    this.id_ = shaka.transmuxer.TransmuxerProxy.nextId_++;
+
+    /** @private {boolean} */
+    this.workerReady_ = false;
+
+    /** @private {boolean} */
+    this.attachedToWorker_ = false;
+  }
+
+  /**
+   * @override
+   * @export
+   */
+  destroy() {
+    // Reject all pending requests.
+    for (const pending of this.pendingRequests_.values()) {
+      pending.timer.stop();
+      pending.reject(new shaka.util.Error(
+          shaka.util.Error.Severity.CRITICAL,
+          shaka.util.Error.Category.MEDIA,
+          shaka.util.Error.Code.TRANSMUXING_FAILED,
+          'Worker transmuxer destroyed'));
+    }
+    this.pendingRequests_.clear();
+
+    if (this.attachedToWorker_) {
+      const TransmuxerProxy = shaka.transmuxer.TransmuxerProxy;
+      if (TransmuxerProxy.sharedWorker_) {
+        TransmuxerProxy.sharedWorker_.postMessage(
+            {'cmd': 'destroy', 'id': this.id_});
+      }
+      TransmuxerProxy.activeInstances_.delete(this.id_);
+      this.attachedToWorker_ = false;
+
+      // Terminate the shared worker when no instances remain.
+      if (TransmuxerProxy.activeInstances_.size === 0 &&
+         TransmuxerProxy.sharedWorker_) {
+        TransmuxerProxy.sharedWorker_.terminate();
+        TransmuxerProxy.sharedWorker_ = null;
+      }
+    }
+
+    this.innerTransmuxer_.destroy();
+  }
+
+  /**
+   * @param {string} mimeType
+   * @param {string=} contentType
+   * @return {boolean}
+   * @override
+   * @export
+   */
+  isSupported(mimeType, contentType) {
+    return this.innerTransmuxer_.isSupported(mimeType, contentType);
+  }
+
+  /**
+   * @param {string} contentType
+   * @param {string} mimeType
+   * @return {string}
+   * @override
+   * @export
+   */
+  convertCodecs(contentType, mimeType) {
+    return this.innerTransmuxer_.convertCodecs(contentType, mimeType);
+  }
+
+  /**
+   * @return {string}
+   * @override
+   * @export
+   */
+  getOriginalMimeType() {
+    return this.innerTransmuxer_.getOriginalMimeType();
+  }
+
+  /**
+   * @override
+   * @export
+   */
+  async transmux(data, stream, reference, duration, contentType) {
+    // If worker creation previously failed, fall back to main thread.
+    if (this.workerFailed_) {
+      return this.innerTransmuxer_.transmux(
+          data, stream, reference, duration, contentType);
+    }
+
+    // Lazy-init: attach to the shared worker on first transmux call.
+    if (!this.attachedToWorker_) {
+      const TransmuxerProxy = shaka.transmuxer.TransmuxerProxy;
+      const worker = TransmuxerProxy.getOrCreateWorker_(this.workerUrl_);
+      if (!worker) {
+        this.workerFailed_ = true;
+        return this.innerTransmuxer_.transmux(
+            data, stream, reference, duration, contentType);
+      }
+      TransmuxerProxy.activeInstances_.set(this.id_, this);
+      this.attachedToWorker_ = true;
+    }
+
+    const worker = shaka.transmuxer.TransmuxerProxy.sharedWorker_;
+    if (!worker) {
+      this.workerFailed_ = true;
+      return this.innerTransmuxer_.transmux(
+          data, stream, reference, duration, contentType);
+    }
+
+    // Send init on first use so the worker creates the right transmuxer.
+    if (!this.workerReady_) {
+      const mimeType = this.innerTransmuxer_.getOriginalMimeType();
+      worker.postMessage({
+        'cmd': 'init',
+        'id': this.id_,
+        'mimeType': mimeType,
+      });
+      this.workerReady_ = true;
+    }
+
+    const reqId = this.nextReqId_++;
+
+    // Extract only the properties transmuxers actually read/write.
+    const streamProps = {
+      'id': stream.id,
+      'codecs': stream.codecs,
+      'channelsCount': stream.channelsCount,
+      'audioSamplingRate': stream.audioSamplingRate,
+      'height': stream.height,
+      'width': stream.width,
+      'language': stream.language,
+    };
+
+    const refProps = reference ? {
+      'discontinuitySequence': reference.discontinuitySequence,
+      'startTime': reference.startTime,
+      'endTime': reference.endTime,
+      'uris': reference.getUris(),
+    } : null;
+
+    // Copy the buffer before transferring so the original `data` stays valid.
+    // This is necessary because MediaSourceEngine may call transmux() twice
+    // with the same data (split muxed content: once for audio, once for video).
+    const buffer = shaka.util.BufferUtils.toArrayBuffer(
+        shaka.util.Uint8ArrayUtils.concat(data));
+
+    const {promise, resolve, reject} = Promise.withResolvers();
+    const timer = new shaka.util.Timer(() => {
+      if (this.pendingRequests_.has(reqId)) {
+        this.pendingRequests_.delete(reqId);
+        this.workerFailed_ = true;
+        reject(new shaka.util.Error(
+            shaka.util.Error.Severity.CRITICAL,
+            shaka.util.Error.Category.MEDIA,
+            shaka.util.Error.Code.TRANSMUXING_FAILED,
+            'Worker transmux timed out'));
+      }
+    });
+    timer.tickAfter(shaka.transmuxer.TransmuxerProxy.TIMEOUT_MS_ / 1000);
+    this.pendingRequests_.set(reqId, {
+      resolve,
+      reject,
+      timer,
+    });
+
+    try {
+      // Transfer the copied buffer to the worker for zero-copy delivery.
+      // The original data remains valid for any subsequent callers.
+      worker.postMessage({
+        'cmd': 'transmux',
+        'id': this.id_,
+        'reqId': reqId,
+        'data': buffer,
+        'streamProps': streamProps,
+        'refProps': refProps,
+        'duration': duration,
+        'contentType': contentType,
+      }, [buffer]);
+    } catch (e) {
+      timer.stop();
+      this.pendingRequests_.delete(reqId);
+      shaka.log.warning(
+          'Failed to post message to worker, falling back to main thread', e);
+      const transmuxerProxy = shaka.transmuxer.TransmuxerProxy;
+      transmuxerProxy.terminateWorker_('Worker postMessage failed');
+      return this.innerTransmuxer_.transmux(
+          data, stream, reference, duration, contentType);
+    }
+
+    const response = await promise;
+
+    // Apply stream mutations back to the real stream object.
+    const mutations = response['streamMutations'];
+    if (mutations && Object.keys(mutations).length > 0) {
+      for (const key of Object.keys(mutations)) {
+        stream[key] = mutations[key];
+      }
+    }
+
+    // Reconstruct the output.
+    const output = response['output'];
+    const BufferUtils = shaka.util.BufferUtils;
+    if (output['type'] === 'raw') {
+      return BufferUtils.toUint8(
+          /** @type {!ArrayBuffer} */(output['data']));
+    } else {
+      return {
+        data: BufferUtils.toUint8(
+            /** @type {!ArrayBuffer} */(output['data'])),
+        init: output['init'] ? BufferUtils.toUint8(
+            /** @type {!ArrayBuffer} */(output['init'])) : null,
+      };
+    }
+  }
+
+  /**
+   * Handles messages from the shared worker for this instance.
+   * @param {!Object} msg
+   * @private
+   */
+  onWorkerMessage_(msg) {
+    const cmd = msg['cmd'];
+
+    if (cmd === 'transmuxed' || cmd === 'error') {
+      const reqId = msg['reqId'];
+      const pending = this.pendingRequests_.get(reqId);
+      if (!pending) {
+        return;
+      }
+      pending.timer.stop();
+      this.pendingRequests_.delete(reqId);
+
+      if (cmd === 'error') {
+        const errorObj = msg['error'];
+        pending.reject(new shaka.util.Error(
+            errorObj['severity'],
+            errorObj['category'],
+            errorObj['code'],
+            ...errorObj['data']));
+      } else {
+        pending.resolve(msg);
+      }
+    }
+  }
+};
+
+
+/** @private {number} */
+shaka.transmuxer.TransmuxerProxy.nextId_ = 0;
+
+
+/**
+ * Timeout in milliseconds for a worker transmux response. If the worker does
+ * not respond within this time, the request is rejected and future calls fall
+ * back to the main thread.
+ * @private @const {number}
+ */
+shaka.transmuxer.TransmuxerProxy.TIMEOUT_MS_ = 30000;
+
+
+/**
+ * Shared Worker instance used by all TransmuxerProxy instances.
+ * @private {?Worker}
+ */
+shaka.transmuxer.TransmuxerProxy.sharedWorker_ = null;
+
+
+/**
+ * Map of active instances keyed by ID, for routing worker messages.
+ * @private {!Map<number, !shaka.transmuxer.TransmuxerProxy>}
+ */
+shaka.transmuxer.TransmuxerProxy.activeInstances_ = new Map();
+
+
+/**
+ * Gets or creates the shared worker. Returns null if the worker cannot be
+ * created (unsupported device, missing script URL, or creation error).
+ * @param {string} workerUrlOverride
+ * @return {?Worker}
+ * @private
+ */
+shaka.transmuxer.TransmuxerProxy.getOrCreateWorker_ = (workerUrlOverride) => {
+  const TransmuxerProxy = shaka.transmuxer.TransmuxerProxy;
+  if (TransmuxerProxy.sharedWorker_) {
+    return TransmuxerProxy.sharedWorker_;
+  }
+
+  const device = shaka.device.DeviceFactory.getDevice();
+  if (!device.supportsWorkerTransmux()) {
+    shaka.log.info(
+        'Device does not support worker transmuxing; ' +
+        'falling back to main-thread transmuxing');
+    return null;
+  }
+
+  if (!workerUrlOverride) {
+    shaka.log.warning(
+        'Transmuxer worker URL is not configured ' +
+        '(mediaSource.transmuxWorkerUrl); ' +
+        'falling back to main-thread transmuxing');
+    return null;
+  }
+
+  try {
+    const worker = new Worker(workerUrlOverride);
+
+    worker.addEventListener('message', (event) => {
+      const msg = /** @type {!MessageEvent} */(event).data;
+      const cmd = msg['cmd'];
+      if (cmd === 'transmuxed' || cmd === 'error') {
+        // Route directly to the instance that owns this request.
+        const instance = TransmuxerProxy.activeInstances_.get(msg['id']);
+        if (instance) {
+          instance.onWorkerMessage_(msg);
+        }
+      }
+    });
+
+    worker.addEventListener('error', (event) => {
+      shaka.log.warning('Transmuxer worker error:', event);
+      TransmuxerProxy.terminateWorker_('Worker error');
+    });
+
+    TransmuxerProxy.sharedWorker_ = worker;
+    return worker;
+  } catch (e) {
+    shaka.log.warning(
+        'Failed to create transmuxer worker, falling back to main thread', e);
+    return null;
+  }
+};
+
+
+/**
+ * Marks all active instances as failed, rejects their pending requests, and
+ * shuts down the shared worker.
+ * @param {string} message Error message for rejected promises.
+ * @private
+ */
+shaka.transmuxer.TransmuxerProxy.terminateWorker_ = (message) => {
+  const TransmuxerProxy = shaka.transmuxer.TransmuxerProxy;
+  for (const instance of TransmuxerProxy.activeInstances_.values()) {
+    instance.workerFailed_ = true;
+    for (const pending of instance.pendingRequests_.values()) {
+      pending.timer.stop();
+      pending.reject(new shaka.util.Error(
+          shaka.util.Error.Severity.CRITICAL,
+          shaka.util.Error.Category.MEDIA,
+          shaka.util.Error.Code.TRANSMUXING_FAILED,
+          message));
+    }
+    instance.pendingRequests_.clear();
+  }
+  TransmuxerProxy.sharedWorker_ = null;
+  TransmuxerProxy.activeInstances_.clear();
+};
+
+
diff --git a/lib/transmuxer/transmuxer_worker.js b/lib/transmuxer/transmuxer_worker.js
new file mode 100644
index 0000000000..ea1cc8e3a6
--- /dev/null
+++ b/lib/transmuxer/transmuxer_worker.js
@@ -0,0 +1,267 @@
+/*! @license
+ * Shaka Player
+ * Copyright 2016 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('shaka.transmuxer.TransmuxerWorker');
+
+goog.require('shaka.log');
+goog.require('shaka.transmuxer.TransmuxerEngine');
+goog.require('shaka.util.BufferUtils');
+goog.require('shaka.util.Error');
+
+
+/**
+ * @summary Web Worker entry point for offloading transmux operations.
+ *
+ * This class manages transmuxer instances inside a Web Worker and
+ * communicates with the main thread via postMessage.
+ *
+ * Message protocol (main -> worker):
+ *   {cmd: 'init', id: number, mimeType: string}
+ *   {cmd: 'transmux', id: number, reqId: number, data: ArrayBuffer,
+ *    streamProps: Object, refProps: Object, duration: number,
+ *    contentType: string}
+ *   {cmd: 'destroy', id: number}
+ *
+ * Response protocol (worker -> main):
+ *   {cmd: 'transmuxed', id: number, reqId: number, output: Object,
+ *    streamMutations: Object}
+ *   {cmd: 'error', id: number, reqId: number, error: Object}
+ *   {cmd: 'destroyed', id: number}
+ *
+ * @export
+ */
+shaka.transmuxer.TransmuxerWorker = class {
+  constructor() {
+    /**
+     * @private {!Map<number, !shaka.extern.Transmuxer>}
+     */
+    this.transmuxers_ = new Map();
+  }
+
+  /**
+   * Starts listening for messages. Call this from the worker global scope.
+   * @export
+   */
+  start() {
+    self.addEventListener('message', (event) => {
+      this.onMessage_(/** @type {!MessageEvent} */(event));
+    });
+  }
+
+  /**
+   * Handles incoming messages from the main thread.
+   * @param {!MessageEvent} event
+   * @private
+   */
+  onMessage_(event) {
+    const msg = event.data;
+    switch (msg['cmd']) {
+      case 'init':
+        this.onInit_(msg);
+        break;
+      case 'transmux':
+        this.onTransmux_(msg);
+        break;
+      case 'destroy':
+        this.onDestroy_(msg);
+        break;
+    }
+  }
+
+  /**
+   * Creates a transmuxer instance.
+   * @param {!Object} msg
+   * @private
+   */
+  onInit_(msg) {
+    const id = msg['id'];
+    const mimeType = msg['mimeType'];
+
+    // Look up the transmuxer plugin directly without calling isSupported().
+    // The main thread already validated support; re-checking here would fail
+    // because MediaSource in Workers may not report the same type support as
+    // the main thread.
+    const plugin =
+        shaka.transmuxer.TransmuxerEngine.findTransmuxerPlugin(mimeType);
+
+    if (plugin) {
+      this.transmuxers_.set(id, plugin());
+    } else {
+      // Only log here; the subsequent onTransmux_ call will post an error
+      // with the correct reqId so the proxy can route it to the caller.
+      shaka.log.warning('TransmuxerWorker: no plugin found for', mimeType);
+    }
+  }
+
+  /**
+   * Runs a transmux operation and posts back the result.
+   * @param {!Object} msg
+   * @private
+   */
+  async onTransmux_(msg) {
+    const id = msg['id'];
+    const reqId = msg['reqId'];
+
+    const transmuxer = this.transmuxers_.get(id);
+    if (!transmuxer) {
+      self.postMessage({
+        'cmd': 'error',
+        'id': id,
+        'reqId': reqId,
+        'error': {
+          'severity': shaka.util.Error.Severity.CRITICAL,
+          'category': shaka.util.Error.Category.MEDIA,
+          'code': shaka.util.Error.Code.TRANSMUXING_FAILED,
+          'data': ['No transmuxer initialized for id ' + id],
+        },
+      });
+      return;
+    }
+
+    const streamProps = msg['streamProps'];
+    const refProps = msg['refProps'];
+
+    const stream = {
+      'id': streamProps['id'],
+      'codecs': streamProps['codecs'],
+      'channelsCount': streamProps['channelsCount'],
+      'audioSamplingRate': streamProps['audioSamplingRate'],
+      'height': streamProps['height'],
+      'width': streamProps['width'],
+      'language': streamProps['language'],
+    };
+
+    const reference = refProps ? {
+      'discontinuitySequence': refProps['discontinuitySequence'],
+      'startTime': refProps['startTime'],
+      'endTime': refProps['endTime'],
+      'getUris': () => refProps['uris'],
+    } : null;
+
+    const data = shaka.util.BufferUtils.toUint8(
+        /** @type {!ArrayBuffer} */(msg['data']));
+    const duration = msg['duration'];
+    const contentType = msg['contentType'];
+
+    try {
+      const result = await transmuxer.transmux(
+          data,
+          /** @type {shaka.extern.Stream} */(stream),
+          /** @type {?} */(reference),
+          duration,
+          contentType);
+
+      // Compute mutations: which stream properties changed.
+      const streamMutations = {};
+      const mutatedKeys = [
+        'audioSamplingRate', 'channelsCount', 'height', 'width',
+      ];
+      for (const key of mutatedKeys) {
+        if (stream[key] !== streamProps[key]) {
+          streamMutations[key] = stream[key];
+        }
+      }
+
+      // Convert typed array views to ArrayBuffer before posting. Only
+      // ArrayBuffer (not views) can be transferred zero-copy via postMessage.
+      const BufferUtils = shaka.util.BufferUtils;
+
+      if (ArrayBuffer.isView(result)) {
+        const buf = BufferUtils.toArrayBuffer(
+            /** @type {!Uint8Array} */(result));
+        self.postMessage({
+          'cmd': 'transmuxed',
+          'id': id,
+          'reqId': reqId,
+          'output': {'type': 'raw', 'data': buf},
+          'streamMutations': streamMutations,
+        }, [buf]);
+      } else {
+        const output = /** @type {!shaka.extern.TransmuxerOutput} */(result);
+        const dataBuf = BufferUtils.toArrayBuffer(output.data);
+        const initBuf = output.init ?
+            BufferUtils.toArrayBuffer(output.init) : null;
+        const transfers = [dataBuf];
+        const response = {
+          'cmd': 'transmuxed',
+          'id': id,
+          'reqId': reqId,
+          'output': {
+            'type': 'segments',
+            'data': dataBuf,
+            'init': initBuf,
+          },
+          'streamMutations': streamMutations,
+        };
+        if (initBuf) {
+          transfers.push(initBuf);
+        }
+        self.postMessage(response, transfers);
+      }
+    } catch (e) {
+      self.postMessage({
+        'cmd': 'error',
+        'id': id,
+        'reqId': reqId,
+        'error': shaka.transmuxer.TransmuxerWorker.errorToObject_(e),
+      });
+    }
+  }
+
+  /**
+   * Converts a caught error into a plain serializable object for postMessage.
+   * @param {*} e
+   * @return {!Object}
+   * @private
+   */
+  static errorToObject_(e) {
+    if (e instanceof shaka.util.Error) {
+      return {
+        'severity': e.severity,
+        'category': e.category,
+        'code': e.code,
+        'data': e.data,
+      };
+    }
+    return {
+      'severity': shaka.util.Error.Severity.CRITICAL,
+      'category': shaka.util.Error.Category.MEDIA,
+      'code': shaka.util.Error.Code.TRANSMUXING_FAILED,
+      'data': [e instanceof Error ? e.message : 'Unknown error'],
+    };
+  }
+
+  /**
+   * Destroys a transmuxer instance.
+   * @param {!Object} msg
+   * @private
+   */
+  onDestroy_(msg) {
+    const id = msg['id'];
+    const transmuxer = this.transmuxers_.get(id);
+    if (transmuxer) {
+      transmuxer.destroy();
+      this.transmuxers_.delete(id);
+    }
+    self.postMessage({'cmd': 'destroyed', 'id': id});
+  }
+};
+
+
+/**
+ * Boots the worker if running in a Worker global scope.
+ * This is called at load time so the worker is ready immediately.
+ */
+shaka.transmuxer.TransmuxerWorker.boot = () => {
+  if (typeof DedicatedWorkerGlobalScope !== 'undefined' &&
+      self instanceof DedicatedWorkerGlobalScope) {
+    const worker = new shaka.transmuxer.TransmuxerWorker();
+    worker.start();
+  }
+};
+
+// Auto-boot when loaded in a worker context.
+shaka.transmuxer.TransmuxerWorker.boot();
diff --git a/lib/transmuxer/ts_transmuxer.js b/lib/transmuxer/ts_transmuxer.js
index 7b022b48ba..92998ef750 100644
--- a/lib/transmuxer/ts_transmuxer.js
+++ b/lib/transmuxer/ts_transmuxer.js
@@ -23,7 +23,6 @@ goog.require('shaka.util.Id3Utils');
 goog.require('shaka.util.ManifestParserUtils');
 goog.require('shaka.util.MimeUtils');
 goog.require('shaka.util.Mp4Generator');
-goog.require('shaka.util.StreamUtils');
 goog.require('shaka.util.TsParser');
 goog.require('shaka.util.Uint8ArrayUtils');
 
@@ -148,17 +147,17 @@ shaka.transmuxer.TsTransmuxer = class {
   convertCodecs(contentType, mimeType) {
     if (this.isTsContainer_(mimeType)) {
       const ContentType = shaka.util.ManifestParserUtils.ContentType;
-      const StreamUtils = shaka.util.StreamUtils;
+      const MimeUtils = shaka.util.MimeUtils;
       // The replace it's necessary because Firefox(the only browser that
       // supports MP3 in MP4) only support the MP3 codec with the mp3 string.
       // MediaSource.isTypeSupported('audio/mp4; codecs="mp4a.40.34"') -> false
       // MediaSource.isTypeSupported('audio/mp4; codecs="mp3"') -> true
-      const codecs = shaka.util.MimeUtils.getCodecs(mimeType)
+      const codecs = MimeUtils.getCodecs(mimeType)
           .replace('mp4a.40.34', 'mp3').split(',')
           .map((codecs) => {
-            return StreamUtils.getCorrectAudioCodecs(codecs, 'audio/mp4');
+            return MimeUtils.getCorrectAudioCodecs(codecs, 'audio/mp4');
           })
-          .map(StreamUtils.getCorrectVideoCodecs).join(',');
+          .map(MimeUtils.getCorrectVideoCodecs).join(',');
       if (contentType == ContentType.AUDIO) {
         return `audio/mp4; codecs="${codecs}"`;
       }
diff --git a/lib/util/mime_utils.js b/lib/util/mime_utils.js
index 8c53e06103..f705f4d682 100644
--- a/lib/util/mime_utils.js
+++ b/lib/util/mime_utils.js
@@ -6,6 +6,8 @@
 
 goog.provide('shaka.util.MimeUtils');
 
+goog.require('shaka.device.DeviceFactory');
+goog.require('shaka.device.IDevice');
 goog.require('shaka.transmuxer.TransmuxerEngine');
 goog.require('shaka.util.ManifestParserUtils');
 
@@ -275,6 +277,90 @@ shaka.util.MimeUtils = class {
         mimeType === 'video/vnd.mpeg.dash.mpd';
   }
 
+  /**
+   * Generates the correct audio codec for MediaDecodingConfiguration and
+   * for MediaSource.isTypeSupported.
+   * @param {string} codecs
+   * @param {string} mimeType
+   * @return {string}
+   */
+  static getCorrectAudioCodecs(codecs, mimeType) {
+    // According to RFC 6381 section 3.3, 'fLaC' is actually the correct
+    // codec string. We still need to map it to 'flac', as some browsers
+    // currently don't support 'fLaC', while 'flac' is supported by most
+    // major browsers.
+    // See https://bugs.chromium.org/p/chromium/issues/detail?id=1422728
+    const device = shaka.device.DeviceFactory.getDevice();
+    const webkit = shaka.device.IDevice.BrowserEngine.WEBKIT;
+    const lowerCaseCodecs = codecs.toLowerCase();
+    if (lowerCaseCodecs == 'flac') {
+      if (device.getBrowserEngine() != webkit) {
+        return 'flac';
+      } else {
+        return 'fLaC';
+      }
+    }
+
+    // The same is true for 'Opus'.
+    if (lowerCaseCodecs === 'opus') {
+      if (device.getBrowserEngine() != webkit) {
+        return 'opus';
+      } else {
+        if (shaka.util.MimeUtils.getContainerType(mimeType) == 'mp4') {
+          return 'Opus';
+        } else {
+          return 'opus';
+        }
+      }
+    }
+
+    if (lowerCaseCodecs == 'ac-3' && device.requiresEC3InitSegments()) {
+      return 'ec-3';
+    }
+
+    return codecs;
+  }
+
+  /**
+   * Generates the correct video codec for MediaDecodingConfiguration and
+   * for MediaSource.isTypeSupported.
+   * @param {string} codec
+   * @return {string}
+   */
+  static getCorrectVideoCodecs(codec) {
+    if (codec.includes('avc1')) {
+      // Convert avc1 codec string from RFC-4281 to RFC-6381 for
+      // MediaSource.isTypeSupported
+      // Example, convert avc1.66.30 to avc1.42001e (0x42 == 66 and 0x1e == 30)
+      const avcData = codec.split('.');
+      if (avcData.length == 3) {
+        let result = avcData.shift() + '.';
+        result += parseInt(avcData.shift(), 10).toString(16);
+        result +=
+            ('000' + parseInt(avcData.shift(), 10).toString(16)).slice(-4);
+        return result;
+      }
+    } else if (codec == 'vp9') {
+      // MediaCapabilities supports 'vp09...' codecs, but not 'vp9'. Translate
+      // vp9 codec strings into 'vp09...', to allow such content to play with
+      // mediaCapabilities enabled.
+      // This means profile 0, level 4.1, 8-bit color.  This supports 1080p @
+      // 60Hz.  See https://en.wikipedia.org/wiki/VP9#Levels
+      //
+      // If we don't have more detailed codec info, assume this profile and
+      // level because it's high enough to likely accommodate the parameters we
+      // do have, such as width and height.  If an implementation is checking
+      // the profile and level very strictly, we want older VP9 content to
+      // still work to some degree.  But we don't want to set a level so high
+      // that it is rejected by a hardware decoder that can't handle the
+      // maximum requirements of the level.
+      //
+      // This became an issue specifically on Firefox on M1 Macs.
+      return 'vp09.00.41.08';
+    }
+    return codec;
+  }
+
   /**
    * Get the base and profile of a codec string. Where [0] will be the codec
    * base and [1] will be the profile.
diff --git a/lib/util/player_configuration.js b/lib/util/player_configuration.js
index b9169b08f2..ce7091a089 100644
--- a/lib/util/player_configuration.js
+++ b/lib/util/player_configuration.js
@@ -386,6 +386,7 @@ shaka.util.PlayerConfiguration = class {
       dispatchAllEmsgBoxes: false,
       useSourceElements: true,
       durationReductionEmitsUpdateEnd: true,
+      transmuxWorkerUrl: '',
     };
 
     const ads = {
diff --git a/lib/util/stream_utils.js b/lib/util/stream_utils.js
index 3957267253..108510a6e2 100644
--- a/lib/util/stream_utils.js
+++ b/lib/util/stream_utils.js
@@ -778,7 +778,6 @@ shaka.util.StreamUtils = class {
     const ContentType = shaka.util.ManifestParserUtils.ContentType;
     const ManifestParserUtils = shaka.util.ManifestParserUtils;
     const MimeUtils = shaka.util.MimeUtils;
-    const StreamUtils = shaka.util.StreamUtils;
 
     const videoConfigs = [];
     const audioConfigs = [];
@@ -798,7 +797,7 @@ shaka.util.StreamUtils = class {
 
           let audioCodecs = ManifestParserUtils.guessCodecs(
               ContentType.AUDIO, allCodecs);
-          audioCodecs = StreamUtils.getCorrectAudioCodecs(
+          audioCodecs = MimeUtils.getCorrectAudioCodecs(
               audioCodecs, baseMimeType);
 
           const audioFullType = MimeUtils.getFullOrConvertedType(
@@ -813,7 +812,7 @@ shaka.util.StreamUtils = class {
           });
         }
 
-        videoCodecs = StreamUtils.getCorrectVideoCodecs(videoCodecs);
+        videoCodecs = MimeUtils.getCorrectVideoCodecs(videoCodecs);
         const fullType = MimeUtils.getFullOrConvertedType(
             MimeUtils.getBasicType(fullMimeType), videoCodecs,
             ContentType.VIDEO);
@@ -855,7 +854,7 @@ shaka.util.StreamUtils = class {
     if (audio) {
       for (const fullMimeType of audio.fullMimeTypes) {
         const baseMimeType = MimeUtils.getBasicType(fullMimeType);
-        const codecs = StreamUtils.getCorrectAudioCodecs(
+        const codecs = MimeUtils.getCorrectAudioCodecs(
             MimeUtils.getCodecs(fullMimeType), baseMimeType);
         const fullType = MimeUtils.getFullOrConvertedType(
             baseMimeType, codecs, ContentType.AUDIO);
@@ -1041,91 +1040,6 @@ shaka.util.StreamUtils = class {
   }
 
 
-  /**
-   * Generates the correct audio codec for MediaDecodingConfiguration and
-   * for MediaSource.isTypeSupported.
-   * @param {string} codecs
-   * @param {string} mimeType
-   * @return {string}
-   */
-  static getCorrectAudioCodecs(codecs, mimeType) {
-    // According to RFC 6381 section 3.3, 'fLaC' is actually the correct
-    // codec string. We still need to map it to 'flac', as some browsers
-    // currently don't support 'fLaC', while 'flac' is supported by most
-    // major browsers.
-    // See https://bugs.chromium.org/p/chromium/issues/detail?id=1422728
-    const device = shaka.device.DeviceFactory.getDevice();
-    const webkit = shaka.device.IDevice.BrowserEngine.WEBKIT;
-    if (codecs.toLowerCase() == 'flac') {
-      if (device.getBrowserEngine() != webkit) {
-        return 'flac';
-      } else {
-        return 'fLaC';
-      }
-    }
-
-    // The same is true for 'Opus'.
-    if (codecs.toLowerCase() === 'opus') {
-      if (device.getBrowserEngine() != webkit) {
-        return 'opus';
-      } else {
-        if (shaka.util.MimeUtils.getContainerType(mimeType) == 'mp4') {
-          return 'Opus';
-        } else {
-          return 'opus';
-        }
-      }
-    }
-
-    if (codecs.toLowerCase() == 'ac-3' && device.requiresEC3InitSegments()) {
-      return 'ec-3';
-    }
-
-    return codecs;
-  }
-
-
-  /**
-   * Generates the correct video codec for MediaDecodingConfiguration and
-   * for MediaSource.isTypeSupported.
-   * @param {string} codec
-   * @return {string}
-   */
-  static getCorrectVideoCodecs(codec) {
-    if (codec.includes('avc1')) {
-      // Convert avc1 codec string from RFC-4281 to RFC-6381 for
-      // MediaSource.isTypeSupported
-      // Example, convert avc1.66.30 to avc1.42001e (0x42 == 66 and 0x1e == 30)
-      const avcData = codec.split('.');
-      if (avcData.length == 3) {
-        let result = avcData.shift() + '.';
-        result += parseInt(avcData.shift(), 10).toString(16);
-        result +=
-            ('000' + parseInt(avcData.shift(), 10).toString(16)).slice(-4);
-        return result;
-      }
-    } else if (codec == 'vp9') {
-      // MediaCapabilities supports 'vp09...' codecs, but not 'vp9'. Translate
-      // vp9 codec strings into 'vp09...', to allow such content to play with
-      // mediaCapabilities enabled.
-      // This means profile 0, level 4.1, 8-bit color.  This supports 1080p @
-      // 60Hz.  See https://en.wikipedia.org/wiki/VP9#Levels
-      //
-      // If we don't have more detailed codec info, assume this profile and
-      // level because it's high enough to likely accommodate the parameters we
-      // do have, such as width and height.  If an implementation is checking
-      // the profile and level very strictly, we want older VP9 content to
-      // still work to some degree.  But we don't want to set a level so high
-      // that it is rejected by a hardware decoder that can't handle the
-      // maximum requirements of the level.
-      //
-      // This became an issue specifically on Firefox on M1 Macs.
-      return 'vp09.00.41.08';
-    }
-    return codec;
-  }
-
-
   /**
    * Alters the given Manifest to filter out any streams incompatible with the
    * current variant.
diff --git a/lib/util/string_utils.js b/lib/util/string_utils.js
index 984d8b96e6..628a3047aa 100644
--- a/lib/util/string_utils.js
+++ b/lib/util/string_utils.js
@@ -38,7 +38,7 @@ shaka.util.StringUtils = class {
       uint8 = uint8.subarray(3);
     }
 
-    if (window.TextDecoder && !shaka.device.DeviceFactory.getDevice()
+    if (self.TextDecoder && !shaka.device.DeviceFactory.getDevice()
         .shouldAvoidUseTextDecoderEncoder()) {
       // Use the TextDecoder interface to decode the text.  This has the
       // advantage compared to the previously-standard decodeUriComponent that
@@ -209,7 +209,7 @@ shaka.util.StringUtils = class {
    * @export
    */
   static toUTF8(str) {
-    if (window.TextEncoder && !shaka.device.DeviceFactory.getDevice()
+    if (self.TextEncoder && !shaka.device.DeviceFactory.getDevice()
         .shouldAvoidUseTextDecoderEncoder()) {
       const utf8Encoder = new TextEncoder();
       return shaka.util.BufferUtils.toArrayBuffer(utf8Encoder.encode(str));
diff --git a/lib/util/uint8array_utils.js b/lib/util/uint8array_utils.js
index 66c5576dac..b5e0eefbf0 100644
--- a/lib/util/uint8array_utils.js
+++ b/lib/util/uint8array_utils.js
@@ -65,7 +65,7 @@ shaka.util.Uint8ArrayUtils = class {
     if (!('fromBase64' in Uint8Array)) {
       // atob creates a "raw string" where each character is interpreted as a
       // byte.
-      const bytes = window.atob(str.replace(/-/g, '+').replace(/_/g, '/'));
+      const bytes = self.atob(str.replace(/-/g, '+').replace(/_/g, '/'));
       const result = new Uint8Array(bytes.length);
       for (let i = 0; i < bytes.length; ++i) {
         result[i] = bytes.charCodeAt(i);
@@ -91,7 +91,7 @@ shaka.util.Uint8ArrayUtils = class {
       const size = str.length / 2;
       const arr = new Uint8Array(size);
       for (let i = 0; i < size; i++) {
-        arr[i] = window.parseInt(str.substr(i * 2, 2), 16);
+        arr[i] = parseInt(str.substr(i * 2, 2), 16);
       }
       return arr;
     }
diff --git a/test/media/media_source_engine_integration.js b/test/media/media_source_engine_integration.js
index 789bb2c653..a31e09b5d2 100644
--- a/test/media/media_source_engine_integration.js
+++ b/test/media/media_source_engine_integration.js
@@ -179,6 +179,10 @@ describe('MediaSourceEngine', () => {
     onEvent = jasmine.createSpy('onEvent');
     onManifestUpdate = jasmine.createSpy('onManifestUpdate');
     const config = shaka.util.PlayerConfiguration.createDefault().mediaSource;
+    // Prevent worker creation: uncompiled worker requires Closure Library
+    // which is not served by Karma.
+    spyOn(shaka.transmuxer.TransmuxerProxy, 'getOrCreateWorker_')
+        .and.returnValue(null);
 
     mediaSourceEngine = new shaka.media.MediaSourceEngine(
         video,
diff --git a/test/media/media_source_engine_unit.js b/test/media/media_source_engine_unit.js
index 73c9de4ccb..7aba0e589f 100644
--- a/test/media/media_source_engine_unit.js
+++ b/test/media/media_source_engine_unit.js
@@ -55,11 +55,9 @@ describe('MediaSourceEngine', () => {
   const originalIsSupported =
       shaka.transmuxer.TransmuxerEngine.isSupported;
 
-  // Jasmine Spies don't handle toHaveBeenCalledWith well with objects, so use
-  // some numbers instead.
-  const buffer = /** @type {!ArrayBuffer} */ (/** @type {?} */ (1));
-  const buffer2 = /** @type {!ArrayBuffer} */ (/** @type {?} */ (2));
-  const buffer3 = /** @type {!ArrayBuffer} */ (/** @type {?} */ (3));
+  const buffer = new Uint8Array([0x01]);
+  const buffer2 = new Uint8Array([0x02]);
+  const buffer3 = new Uint8Array([0x03]);
 
   const makeFakeStream = (mimeType) => {
     const segmentIndex = {
@@ -252,6 +250,10 @@ describe('MediaSourceEngine', () => {
     mockClosedCaptionParser = new shaka.test.FakeClosedCaptionParser();
     mockTextDisplayer = new shaka.test.FakeTextDisplayer();
     const config = shaka.util.PlayerConfiguration.createDefault().mediaSource;
+    // FakeTransmuxer is not in the worker bundle; prevent worker creation so
+    // transmux calls fall back to the main-thread inner transmuxer.
+    spyOn(shaka.transmuxer.TransmuxerProxy, 'getOrCreateWorker_')
+        .and.returnValue(null);
 
     mediaSourceEngine = new shaka.media.MediaSourceEngine(
         video,
@@ -452,6 +454,31 @@ describe('MediaSourceEngine', () => {
       expect(mockMediaSource.addSourceBuffer).not.toHaveBeenCalled();
       expect(shaka.text.TextEngine).toHaveBeenCalled();
     });
+
+    it('always wraps transmuxer in TransmuxerProxy', async () => {
+      const proxySpy = spyOn(shaka.transmuxer, 'TransmuxerProxy')
+          .and.callThrough();
+
+      const initObject = new Map();
+      initObject.set(ContentType.VIDEO, fakeTransportStream);
+      await mediaSourceEngine.init(initObject, false);
+      expect(proxySpy).toHaveBeenCalled();
+    });
+
+    it('passes transmuxWorkerUrl to TransmuxerProxy', async () => {
+      const proxySpy = spyOn(shaka.transmuxer, 'TransmuxerProxy')
+          .and.callThrough();
+      const config =
+          shaka.util.PlayerConfiguration.createDefault().mediaSource;
+      config.transmuxWorkerUrl = 'https://example.com/worker.js';
+      mediaSourceEngine.configure(config);
+
+      const initObject = new Map();
+      initObject.set(ContentType.VIDEO, fakeTransportStream);
+      await mediaSourceEngine.init(initObject, false);
+      expect(proxySpy).toHaveBeenCalledOnceWith(
+          mockTransmuxer, 'https://example.com/worker.js');
+    });
   });
 
   describe('bufferStart and bufferEnd', () => {
@@ -1269,7 +1296,7 @@ describe('MediaSourceEngine', () => {
       await expectAsync(p1).toBeRejected();
       expect(mockMediaSource.endOfStream).toHaveBeenCalled();
       await Util.shortDelay();
-      expect(audioSourceBuffer.appendBuffer).toHaveBeenCalledWith(1);
+      expect(audioSourceBuffer.appendBuffer).toHaveBeenCalledWith(buffer);
       audioSourceBuffer.updateend();
     });
   });
diff --git a/test/test/util/util.js b/test/test/util/util.js
index 4d2e200761..705546224c 100644
--- a/test/test/util/util.js
+++ b/test/test/util/util.js
@@ -379,7 +379,6 @@ shaka.test.Util = class {
   static async isTypeSupported(mimetype, width, height) {
     const MimeUtils = shaka.util.MimeUtils;
     const ContentType = shaka.util.ManifestParserUtils.ContentType;
-    const StreamUtils = shaka.util.StreamUtils;
 
     /** @type {!MediaDecodingConfiguration} */
     const mediaDecodingConfig = {
@@ -387,7 +386,7 @@ shaka.test.Util = class {
     };
     if (mimetype.startsWith('audio')) {
       const baseMimeType = MimeUtils.getBasicType(mimetype);
-      const codecs = StreamUtils.getCorrectAudioCodecs(
+      const codecs = MimeUtils.getCorrectAudioCodecs(
           MimeUtils.getCodecs(mimetype), baseMimeType);
       // AudioConfiguration
       mediaDecodingConfig.audio = {
@@ -395,7 +394,7 @@ shaka.test.Util = class {
             baseMimeType, codecs, ContentType.AUDIO),
       };
     } else {
-      const codecs = StreamUtils.getCorrectVideoCodecs(
+      const codecs = MimeUtils.getCorrectVideoCodecs(
           MimeUtils.getCodecs(mimetype));
       const baseMimeType = MimeUtils.getBasicType(mimetype);
       if (codecs.startsWith('hvc1.') && deviceDetected.disableHEVCSupport()) {
diff --git a/test/transmuxer/transmuxer_proxy_unit.js b/test/transmuxer/transmuxer_proxy_unit.js
new file mode 100644
index 0000000000..f443a712bc
--- /dev/null
+++ b/test/transmuxer/transmuxer_proxy_unit.js
@@ -0,0 +1,580 @@
+/*! @license
+ * Shaka Player
+ * Copyright 2016 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+describe('TransmuxerProxy', () => {
+  const TransmuxerProxy = shaka.transmuxer.TransmuxerProxy;
+
+  let mockInner;
+
+  /** @type {!shaka.transmuxer.TransmuxerProxy} */
+  let transmuxer;
+
+  /** @type {string} */
+  const FAKE_WORKER_URL = 'http://fake/transmuxer_worker.js';
+
+  /** @type {!shaka.extern.Stream} */
+  let fakeStream;
+
+  /** @type {!Uint8Array} */
+  let fakeData;
+
+  beforeEach(() => {
+    mockInner = jasmine.createSpyObj('innerTransmuxer', [
+      'destroy',
+      'isSupported',
+      'convertCodecs',
+      'getOriginalMimeType',
+      'transmux',
+    ]);
+    mockInner.getOriginalMimeType.and.returnValue('video/mp2t');
+    mockInner.isSupported.and.returnValue(true);
+    mockInner.convertCodecs.and.returnValue('video/mp4; codecs="avc1.42E01E"');
+    mockInner.transmux.and.returnValue(
+        Promise.resolve(new Uint8Array([1, 2, 3])));
+
+    fakeStream = /** @type {!shaka.extern.Stream} */({
+      id: 1,
+      codecs: 'avc1.42E01E',
+      channelsCount: null,
+      audioSamplingRate: null,
+      height: null,
+      width: null,
+      language: 'en',
+    });
+
+    fakeData = new Uint8Array([0xAB, 0xCD, 0xEF]);
+    transmuxer = new TransmuxerProxy(mockInner, FAKE_WORKER_URL);
+  });
+
+  afterEach(() => {
+    transmuxer.destroy();
+    resetClassState();
+  });
+
+  describe('sync methods delegate to inner transmuxer', () => {
+    it('isSupported delegates', () => {
+      expect(transmuxer.isSupported('video/mp2t', 'video')).toBe(true);
+      expect(mockInner.isSupported).toHaveBeenCalledWith('video/mp2t', 'video');
+    });
+
+    it('convertCodecs delegates', () => {
+      const result = transmuxer.convertCodecs('video', 'video/mp2t');
+      expect(result).toBe('video/mp4; codecs="avc1.42E01E"');
+      expect(mockInner.convertCodecs)
+          .toHaveBeenCalledWith('video', 'video/mp2t');
+    });
+
+    it('getOriginalMimeType delegates', () => {
+      expect(transmuxer.getOriginalMimeType()).toBe('video/mp2t');
+      expect(mockInner.getOriginalMimeType).toHaveBeenCalled();
+    });
+  });
+
+  describe('destroy', () => {
+    it('calls destroy on inner transmuxer', () => {
+      transmuxer.destroy();
+      expect(mockInner.destroy).toHaveBeenCalled();
+    });
+  });
+
+  describe('fallback to main thread', () => {
+    it('falls back when workerUrl is empty', async () => {
+      transmuxer.destroy();
+      transmuxer = new TransmuxerProxy(mockInner, '');
+
+      const result = await transmuxer.transmux(
+          fakeData, fakeStream, null, 10, 'video');
+      expect(mockInner.transmux).toHaveBeenCalled();
+      expect(result).toEqual(jasmine.any(Uint8Array));
+    });
+
+    it('falls back when device does not support worker transmux', async () => {
+      const device = shaka.device.DeviceFactory.getDevice();
+      spyOn(device, 'supportsWorkerTransmux').and.returnValue(false);
+
+      const result = await transmuxer.transmux(
+          fakeData, fakeStream, null, 10, 'video');
+      expect(mockInner.transmux).toHaveBeenCalled();
+      expect(result).toEqual(jasmine.any(Uint8Array));
+    });
+
+    it('continues falling back after first failure', async () => {
+      transmuxer.destroy();
+      transmuxer = new TransmuxerProxy(mockInner, '');
+
+      await transmuxer.transmux(fakeData, fakeStream, null, 10, 'video');
+      await transmuxer.transmux(fakeData, fakeStream, null, 10, 'video');
+      expect(mockInner.transmux).toHaveBeenCalledTimes(2);
+    });
+  });
+
+  describe('worker path', () => {
+    /** @type {?Function} */
+    let capturedMessageHandler;
+
+    /** @type {?Function} */
+    let capturedErrorHandler;
+
+    let mockWorker;
+
+    /** @type {?Function} */
+    let originalWorkerClass;
+
+    /** @type {string} */
+    let capturedWorkerUrl;
+
+    beforeEach(() => {
+      capturedMessageHandler = null;
+      capturedErrorHandler = null;
+      capturedWorkerUrl = '';
+
+      mockWorker = {
+        postMessage: jasmine.createSpy('postMessage'),
+        terminate: jasmine.createSpy('terminate'),
+        addEventListener: jasmine.createSpy('addEventListener')
+            .and.callFake((type, handler) => {
+              if (type === 'message') {
+                capturedMessageHandler = handler;
+              } else if (type === 'error') {
+                capturedErrorHandler = handler;
+              }
+            }),
+      };
+
+      // Replace the Worker constructor so getOrCreateWorker_() returns our
+      // mock. We do this by replacing the global and restoring in afterEach.
+      originalWorkerClass = window['Worker'];
+      window['Worker'] = /** @type {?} */(class {
+        /**
+         * @param {string} url
+         */
+        constructor(url) {
+          capturedWorkerUrl = url;
+          return /** @type {?} */(mockWorker);
+        }
+      });
+    });
+
+    afterEach(() => {
+      window['Worker'] = originalWorkerClass;
+    });
+
+    /**
+     * Simulates the worker sending a 'transmuxed' response.
+     * @param {number} id The instance id to route to.
+     * @param {number} reqId
+     * @param {!ArrayBuffer} outputBuffer
+     * @param {Object=} streamMutations
+     */
+    const simulateTransmuxed = (id, reqId, outputBuffer, streamMutations) => {
+      const msg = {
+        'cmd': 'transmuxed',
+        'id': id,
+        'reqId': reqId,
+        'output': {'type': 'raw', 'data': outputBuffer},
+        'streamMutations': streamMutations || null,
+      };
+      capturedMessageHandler(/** @type {!MessageEvent} */({data: msg}));
+    };
+
+    it('sends init message on first transmux', async () => {
+      const id = getInstanceId(transmuxer);
+      const p = transmuxer.transmux(fakeData, fakeStream, null, 10, 'video');
+      simulateTransmuxed(id, 0, new ArrayBuffer(3));
+      await p;
+
+      expect(capturedWorkerUrl).toBe(FAKE_WORKER_URL);
+      expect(mockWorker.postMessage).toHaveBeenCalledWith(
+          jasmine.objectContaining({'cmd': 'init', 'mimeType': 'video/mp2t'}));
+    });
+
+    it('uses the configured worker URL', async () => {
+      transmuxer.destroy();
+      transmuxer = new TransmuxerProxy(
+          mockInner, 'https://example.com/worker.js');
+
+      const id = getInstanceId(transmuxer);
+      const p = transmuxer.transmux(fakeData, fakeStream, null, 10, 'video');
+      simulateTransmuxed(id, 0, new ArrayBuffer(3));
+      await p;
+
+      expect(capturedWorkerUrl).toBe('https://example.com/worker.js');
+    });
+
+    it('sends init message only once for multiple calls', async () => {
+      const id = getInstanceId(transmuxer);
+      const p1 = transmuxer.transmux(fakeData, fakeStream, null, 10, 'video');
+      simulateTransmuxed(id, 0, new ArrayBuffer(3));
+      await p1;
+
+      const p2 = transmuxer.transmux(fakeData, fakeStream, null, 10, 'video');
+      simulateTransmuxed(id, 1, new ArrayBuffer(3));
+      await p2;
+
+      const initCalls = mockWorker.postMessage.calls.all()
+          .filter((c) => c.args[0]['cmd'] === 'init');
+      expect(initCalls.length).toBe(1);
+    });
+
+    it('sends transmux message with correct props', async () => {
+      const id = getInstanceId(transmuxer);
+      const p = transmuxer.transmux(fakeData, fakeStream, null, 10, 'video');
+      simulateTransmuxed(id, 0, new ArrayBuffer(3));
+      await p;
+
+      const call = mockWorker.postMessage.calls.all()
+          .find((c) => c.args[0]['cmd'] === 'transmux');
+      expect(call).toBeTruthy();
+      expect(call.args[0]['duration']).toBe(10);
+      expect(call.args[0]['contentType']).toBe('video');
+      expect(call.args[0]['streamProps']['id']).toBe(1);
+      expect(call.args[0]['streamProps']['codecs']).toBe('avc1.42E01E');
+    });
+
+    it('returns Uint8Array for type=raw response', async () => {
+      const id = getInstanceId(transmuxer);
+      const outputData = new Uint8Array([0x01, 0x02, 0x03]);
+      const p = transmuxer.transmux(fakeData, fakeStream, null, 10, 'video');
+      simulateTransmuxed(id, 0,
+          shaka.util.BufferUtils.toArrayBuffer(outputData));
+      const result = await p;
+
+      expect(result).toBeInstanceOf(Uint8Array);
+      expect(/** @type {!Uint8Array} */(result).length).toBe(3);
+    });
+
+    it('returns {data, init} for type=muxed response', async () => {
+      const id = getInstanceId(transmuxer);
+      const p = transmuxer.transmux(fakeData, fakeStream, null, 10, 'video');
+      capturedMessageHandler({data: {
+        'cmd': 'transmuxed',
+        'id': id,
+        'reqId': 0,
+        'output': {
+          'type': 'segments',
+          'data': new ArrayBuffer(4),
+          'init': new ArrayBuffer(2),
+        },
+        'streamMutations': null,
+      }});
+      const result = await p;
+
+      expect(result).toEqual(jasmine.objectContaining({
+        data: jasmine.any(Uint8Array),
+        init: jasmine.any(Uint8Array),
+      }));
+    });
+
+    it('returns null init when absent in muxed response', async () => {
+      const id = getInstanceId(transmuxer);
+      const p = transmuxer.transmux(fakeData, fakeStream, null, 10, 'video');
+      capturedMessageHandler({data: {
+        'cmd': 'transmuxed',
+        'id': id,
+        'reqId': 0,
+        'output': {
+          'type': 'segments', 'data': new ArrayBuffer(4), 'init': null,
+        },
+        'streamMutations': null,
+      }});
+      const result = await p;
+
+      expect(/** @type {{data: ?, init: ?}} */(result).init).toBeNull();
+    });
+
+    it('applies stream mutations from worker response', async () => {
+      const id = getInstanceId(transmuxer);
+      const p = transmuxer.transmux(fakeData, fakeStream, null, 10, 'audio');
+      simulateTransmuxed(id, 0, new ArrayBuffer(3),
+          {'audioSamplingRate': 48000, 'channelsCount': 2});
+      await p;
+
+      expect(fakeStream.audioSamplingRate).toBe(48000);
+      expect(fakeStream.channelsCount).toBe(2);
+    });
+
+    it('does not modify stream when mutations are null', async () => {
+      const id = getInstanceId(transmuxer);
+      fakeStream.audioSamplingRate = 44100;
+      const p = transmuxer.transmux(fakeData, fakeStream, null, 10, 'audio');
+      simulateTransmuxed(id, 0, new ArrayBuffer(3), null);
+      await p;
+
+      expect(fakeStream.audioSamplingRate).toBe(44100);
+    });
+
+    it('rejects with shaka.util.Error from worker error response', async () => {
+      const id = getInstanceId(transmuxer);
+      const p = transmuxer.transmux(fakeData, fakeStream, null, 10, 'video');
+
+      // Register rejection handler before triggering the error to avoid
+      // an unhandled-rejection event racing with the expectAsync handler.
+      const assertion = expectAsync(p).toBeRejectedWith(
+          jasmine.objectContaining({
+            code: shaka.util.Error.Code.TRANSMUXING_FAILED,
+          }));
+
+      capturedMessageHandler({data: {
+        'cmd': 'error',
+        'id': id,
+        'reqId': 0,
+        'error': {
+          'severity': shaka.util.Error.Severity.CRITICAL,
+          'category': shaka.util.Error.Category.MEDIA,
+          'code': shaka.util.Error.Code.TRANSMUXING_FAILED,
+          'data': ['test error'],
+        },
+      }});
+
+      await assertion;
+    });
+
+    it('ignores messages with unknown reqId', async () => {
+      const id = getInstanceId(transmuxer);
+      // Kick off a transmux to initialize the worker, then simulate a stale
+      // message with an unknown reqId — should not throw.
+      const p = transmuxer.transmux(fakeData, fakeStream, null, 10, 'video');
+
+      expect(() => {
+        capturedMessageHandler({data: {
+          'cmd': 'transmuxed',
+          'id': id,
+          'reqId': 9999,
+          'output': {'type': 'raw', 'data': new ArrayBuffer(1)},
+          'streamMutations': null,
+        }});
+      }).not.toThrow();
+
+      // Clean up: resolve the real pending request so afterEach is happy.
+      simulateTransmuxed(id, 0, new ArrayBuffer(1));
+      await p;
+    });
+
+    it('ignores messages with unknown instance id', async () => {
+      const id = getInstanceId(transmuxer);
+      const p = transmuxer.transmux(fakeData, fakeStream, null, 10, 'video');
+
+      // A message with a different instance id should be silently ignored.
+      expect(() => {
+        capturedMessageHandler({data: {
+          'cmd': 'transmuxed',
+          'id': id + 100,
+          'reqId': 0,
+          'output': {'type': 'raw', 'data': new ArrayBuffer(1)},
+          'streamMutations': null,
+        }});
+      }).not.toThrow();
+
+      simulateTransmuxed(id, 0, new ArrayBuffer(1));
+      await p;
+    });
+
+    it('assigns sequential reqIds to concurrent calls', async () => {
+      const id = getInstanceId(transmuxer);
+      const p1 = transmuxer.transmux(fakeData, fakeStream, null, 10, 'v');
+      const p2 = transmuxer.transmux(fakeData, fakeStream, null, 10, 'v');
+
+      simulateTransmuxed(id, 1, new ArrayBuffer(2));
+      simulateTransmuxed(id, 0, new ArrayBuffer(2));
+
+      await Promise.all([p1, p2]);
+
+      const transmuxCalls = mockWorker.postMessage.calls.all()
+          .filter((c) => c.args[0]['cmd'] === 'transmux');
+      expect(transmuxCalls.length).toBe(2);
+      expect(transmuxCalls[0].args[0]['reqId']).toBe(0);
+      expect(transmuxCalls[1].args[0]['reqId']).toBe(1);
+    });
+
+    it('sends destroy message and terminates worker on destroy', async () => {
+      const id = getInstanceId(transmuxer);
+      const p = transmuxer.transmux(fakeData, fakeStream, null, 10, 'video');
+      simulateTransmuxed(id, 0, new ArrayBuffer(1));
+      await p;
+
+      transmuxer.destroy();
+
+      expect(mockWorker.postMessage).toHaveBeenCalledWith(
+          jasmine.objectContaining({'cmd': 'destroy'}));
+      expect(mockWorker.terminate).toHaveBeenCalled();
+    });
+
+    it('destroy rejects pending transmux', async () => {
+      const p = transmuxer.transmux(fakeData, fakeStream, null, 10, 'video');
+
+      // Register rejection handler before destroy to avoid an
+      // unhandled-rejection event racing with the expectAsync handler.
+      const assertion = expectAsync(p).toBeRejectedWith(
+          jasmine.objectContaining({
+            code: shaka.util.Error.Code.TRANSMUXING_FAILED,
+          }));
+
+      transmuxer.destroy();
+
+      await assertion;
+    });
+
+    describe('timeout', () => {
+      beforeEach(() => jasmine.clock().install());
+      afterEach(() => jasmine.clock().uninstall());
+
+      it('rejects on timeout when worker does not respond', async () => {
+        const p = transmuxer.transmux(fakeData, fakeStream, null, 10, 'video');
+        const assertion = expectAsync(p).toBeRejectedWith(
+            jasmine.objectContaining({
+              code: shaka.util.Error.Code.TRANSMUXING_FAILED,
+            }));
+
+        jasmine.clock().tick(30001);
+        await assertion;
+      });
+
+      it('falls back to main thread after timeout', async () => {
+        const p = transmuxer.transmux(fakeData, fakeStream, null, 10, 'video');
+        const assertion = expectAsync(p).toBeRejectedWith(
+            jasmine.objectContaining({
+              code: shaka.util.Error.Code.TRANSMUXING_FAILED,
+            }));
+        jasmine.clock().tick(30001);
+        await assertion;
+
+        // mockInner.transmux returns a resolved promise, so this does not
+        // involve setTimeout and is safe to await with the clock still running.
+        await transmuxer.transmux(fakeData, fakeStream, null, 10, 'video');
+        expect(mockInner.transmux).toHaveBeenCalled();
+      });
+    });
+
+    it('sends reference props when reference is provided', async () => {
+      const id = getInstanceId(transmuxer);
+      const ref = /** @type {?} */({
+        discontinuitySequence: 2,
+        startTime: 10,
+        endTime: 14,
+        getUris: () => ['http://example.com/seg.ts'],
+      });
+
+      const p = transmuxer.transmux(fakeData, fakeStream, ref, 4, 'video');
+      simulateTransmuxed(id, 0, new ArrayBuffer(1));
+      await p;
+
+      const call = mockWorker.postMessage.calls.all()
+          .find((c) => c.args[0]['cmd'] === 'transmux');
+      expect(call.args[0]['refProps']['discontinuitySequence']).toBe(2);
+      expect(call.args[0]['refProps']['startTime']).toBe(10);
+      expect(call.args[0]['refProps']['endTime']).toBe(14);
+      expect(call.args[0]['refProps']['uris'])
+          .toEqual(['http://example.com/seg.ts']);
+    });
+
+    it('sends null refProps when reference is null', async () => {
+      const id = getInstanceId(transmuxer);
+      const p = transmuxer.transmux(fakeData, fakeStream, null, 10, 'video');
+      simulateTransmuxed(id, 0, new ArrayBuffer(1));
+      await p;
+
+      const call = mockWorker.postMessage.calls.all()
+          .find((c) => c.args[0]['cmd'] === 'transmux');
+      expect(call.args[0]['refProps']).toBeNull();
+    });
+
+    describe('worker global error event', () => {
+      it('rejects the pending request', async () => {
+        const p = transmuxer.transmux(fakeData, fakeStream, null, 10, 'video');
+
+        const assertion = expectAsync(p).toBeRejectedWith(
+            jasmine.objectContaining({
+              code: shaka.util.Error.Code.TRANSMUXING_FAILED,
+            }));
+
+        capturedErrorHandler(new Event('error'));
+        await assertion;
+      });
+
+      it('falls back to main thread after worker error', async () => {
+        const p = transmuxer.transmux(fakeData, fakeStream, null, 10, 'video');
+        const rejection = expectAsync(p).toBeRejected();
+        capturedErrorHandler(new Event('error'));
+        await rejection;
+
+        await transmuxer.transmux(fakeData, fakeStream, null, 10, 'video');
+        expect(mockInner.transmux).toHaveBeenCalled();
+      });
+    });
+
+    it('surfaces init error with correct reqId on first transmux', async () => {
+      const id = getInstanceId(transmuxer);
+      const p = transmuxer.transmux(fakeData, fakeStream, null, 10, 'video');
+
+      // Simulate the worker responding with an error because init failed
+      // (no plugin found). The worker now returns the error with the
+      // correct reqId from the transmux request, not reqId: -1.
+      const assertion = expectAsync(p).toBeRejectedWith(
+          jasmine.objectContaining({
+            code: shaka.util.Error.Code.TRANSMUXING_FAILED,
+          }));
+
+      capturedMessageHandler({data: {
+        'cmd': 'error',
+        'id': id,
+        'reqId': 0,
+        'error': {
+          'severity': shaka.util.Error.Severity.CRITICAL,
+          'category': shaka.util.Error.Category.MEDIA,
+          'code': shaka.util.Error.Code.TRANSMUXING_FAILED,
+          'data': ['No transmuxer initialized for id ' + id],
+        },
+      }});
+
+      await assertion;
+    });
+
+    describe('Worker constructor failure', () => {
+      beforeEach(() => {
+        window['Worker'] = /** @type {?} */(class {
+          constructor() {
+            throw new Error('Worker creation not supported');
+          }
+        });
+      });
+
+      it('falls back to main thread when Worker constructor throws',
+          async () => {
+            const result = await transmuxer.transmux(
+                fakeData, fakeStream, null, 10, 'video');
+            expect(mockInner.transmux).toHaveBeenCalled();
+            expect(result).toEqual(jasmine.any(Uint8Array));
+          });
+
+      it('continues falling back after constructor failure', async () => {
+        await transmuxer.transmux(fakeData, fakeStream, null, 10, 'video');
+        await transmuxer.transmux(fakeData, fakeStream, null, 10, 'video');
+        expect(mockInner.transmux).toHaveBeenCalledTimes(2);
+      });
+    });
+  });
+
+  /**
+   * @suppress {visibility}
+   * "suppress visibility" has function scope, so this is a mini-function that
+   * exists solely to suppress visibility rules for these actions.
+   */
+  function resetClassState() {
+    shaka.transmuxer.TransmuxerProxy.sharedWorker_ = null;
+    shaka.transmuxer.TransmuxerProxy.activeInstances_.clear();
+  }
+
+  /**
+   * @suppress {visibility}
+   * "suppress visibility" has function scope, so this is a mini-function that
+   * exists solely to suppress visibility rules for these actions.
+   * @param {!shaka.transmuxer.TransmuxerProxy} tx
+   * @return {number}
+   */
+  function getInstanceId(tx) {
+    return tx.id_;
+  }
+});
diff --git a/transmuxer_worker.uncompiled.js b/transmuxer_worker.uncompiled.js
new file mode 100644
index 0000000000..33b042b0a2
--- /dev/null
+++ b/transmuxer_worker.uncompiled.js
@@ -0,0 +1,66 @@
+/*! @license
+ * Shaka Player
+ * Copyright 2016 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview Entry point for the transmuxer Web Worker in uncompiled
+ * (development) mode.  Loads Closure Library via importScripts, pulls in the
+ * dependency graph, then goog.require's the transmuxer plugins and the worker
+ * entry point.
+ *
+ * In compiled builds this file is not used — the compiled bundle is loaded
+ * directly as the Worker script.
+ */
+
+// Closure's base.js uses document.currentScript (or document.write) to resolve
+// relative paths.  Neither exists inside a Worker, so we provide a
+// CLOSURE_IMPORT_SCRIPT hook that uses importScripts instead, and set
+// CLOSURE_BASE_PATH so Closure can find its own modules.
+
+/* eslint-disable no-restricted-syntax */
+// @ts-ignore
+self.CLOSURE_BASE_PATH =
+    'node_modules/google-closure-library/closure/goog/';
+
+// Tell Closure to use importScripts for loading dependencies.
+self.CLOSURE_IMPORT_SCRIPT = (src) => {
+  importScripts(src);
+  return true;
+};
+
+// Load Closure Library base and the generated dependency map.
+importScripts(
+    'node_modules/google-closure-library/closure/goog/base.js',
+    'dist/deps.js');
+
+// Pull in all device plugins so DeviceFactory.getDevice() returns the correct
+// device inside the worker (needed by Ac3Transmuxer and MimeUtils codec
+// conversion). Without these, getDevice() always returns DefaultBrowser even
+// on Tizen/WebOS/Xbox/etc.
+goog.require('shaka.device.AppleBrowser');
+goog.require('shaka.device.Chromecast');
+goog.require('shaka.device.DefaultBrowser');
+goog.require('shaka.device.Hisense');
+goog.require('shaka.device.PlayStation');
+goog.require('shaka.device.TitanOS');
+goog.require('shaka.device.Tizen');
+goog.require('shaka.device.Vizio');
+goog.require('shaka.device.WebKitSTB');
+goog.require('shaka.device.WebOS');
+goog.require('shaka.device.Xbox');
+
+// Pull in the transmuxer plugins so they self-register with
+// TransmuxerEngine, then load the worker entry point.
+goog.require('shaka.transmuxer.AacTransmuxer');
+goog.require('shaka.transmuxer.Ac3Transmuxer');
+goog.require('shaka.transmuxer.Ec3Transmuxer');
+goog.require('shaka.transmuxer.LocTransmuxer');
+goog.require('shaka.transmuxer.Mp3Transmuxer');
+goog.require('shaka.transmuxer.MpegTsTransmuxer');
+goog.require('shaka.transmuxer.TsTransmuxer');
+goog.require('shaka.transmuxer.TransmuxerWorker');
+
+// The auto-boot at the bottom of transmuxer_worker.js will have already
+// called TransmuxerWorker.boot() when it was loaded by goog.require above.

From 1841e3a5f19a396f519421b02832ad1e3cab12df Mon Sep 17 00:00:00 2001
From: Joey Parrish <joeyparrish@users.noreply.github.com>
Date: Wed, 27 May 2026 21:25:06 -0700
Subject: [PATCH 48/64] fix(demo): Re-enable lazy localization (#10137)

If you open Shaka Player with Hungarian as the UI language setting
(https://shaka-project.github.io/shaka-player-release/demo/#uilang=hu)
it will currently display the UI in English, because Hungarian is not
one of the built-in-by-default languages for the project. It does still
work for a built-in language like German. (Compare to
https://shaka-project.github.io/shaka-player-release/demo/#uilang=de)

We used to have a feature in the demo to load localizations from the
server dynamically for languages where we have translations, but don't
build them in by default.

The feature to lazy-load localizations for the player UI was
acccidentally dropped in e8e2807 (PR #5665) while abandoning translation
of the demo itself. This PR restores that feature in a simplified
implementation. Ex:
https://joeyparrish.github.io/shaka-player/demo/#uilang=hu
---
 demo/main.js                     | 49 ++++++++++++++++++++++++++++++++
 test/test/util/fake_demo_main.js |  4 ---
 2 files changed, 49 insertions(+), 4 deletions(-)

diff --git a/demo/main.js b/demo/main.js
index 1d6a419e3c..d7025ef214 100644
--- a/demo/main.js
+++ b/demo/main.js
@@ -480,6 +480,7 @@ shakaDemo.Main = class {
     });
 
     this.localization_ = this.controls_.getLocalization();
+    this.setupLazyLocalization_();
 
     const drawerCloseButton = document.getElementById('drawer-close-button');
     drawerCloseButton.addEventListener('click', () => {
@@ -517,6 +518,33 @@ shakaDemo.Main = class {
     this.hideElement_(drawerCloseButton);
   }
 
+  /**
+   * @private
+   */
+  setupLazyLocalization_() {
+    // Load locales on-demand.
+    const UNKNOWN_LOCALES = shaka.ui.Localization.UNKNOWN_LOCALES;
+    this.localization_.addEventListener(UNKNOWN_LOCALES, (event) => {
+      for (const locale of event['locales']) {
+        this.loadUILocale_(locale);
+      }
+    });
+
+    // Load the initial locale.
+    this.loadUILocale_(this.uiLocale_);
+
+    // Also try to load the 'base' localization.  This is so that, for example,
+    // the uiLocale_ is set to 'en-US', it will try to load 'en'.
+    if (this.uiLocale_.includes('-')) {
+      this.loadUILocale_(this.uiLocale_.split('-')[0]);
+    }
+
+    // Load 'en' as a fallback option, if not already loaded.
+    if (!this.uiLocale_.startsWith('en')) {
+      this.loadUILocale_('en');
+    }
+  }
+
   /** @return {boolean} */
   getIsDrawerOpen() {
     const drawer = document.querySelector('.mdl-layout__drawer');
@@ -927,6 +955,27 @@ shakaDemo.Main = class {
     return this.nativeControlsEnabled_;
   }
 
+  /**
+   * @param {string} locale
+   * @return {!Promise}
+   * @private
+   */
+  async loadUILocale_(locale) {
+    if (!locale) {
+      return;
+    }
+
+    const url = '../ui/locales/' + locale + '.json';
+    try {
+      const text = await this.loadText_(url);
+      const obj = /** @type {!Object<string, string>} */(JSON.parse(text));
+      const map = new Map(Object.entries(obj));
+      this.localization_.insert(locale, map);
+    } catch (error) {
+      console.warn('Unable to load locale', locale, 'from url', url);
+    }
+  }
+
   /** @param {string} locale */
   setUILocale(locale) {
     this.uiLocale_ = locale;
diff --git a/test/test/util/fake_demo_main.js b/test/test/util/fake_demo_main.js
index 2586bf4bbe..ecd3487684 100644
--- a/test/test/util/fake_demo_main.js
+++ b/test/test/util/fake_demo_main.js
@@ -202,10 +202,6 @@ shaka.test.FakeDemoMain = class {
       return /** @type {!HTMLDivElement} */ (document.createElement('div'));
     });
 
-    /** @type {!jasmine.Spy} */
-    this.getLocalizedString = jasmine.createSpy('getLocalizedString');
-    this.getLocalizedString.and.callFake((name) => name);
-
     /** @type {!jasmine.Spy} */
     this.loadAsset = jasmine.createSpy('loadAsset');
     this.loadAsset.and.returnValue(Promise.resolve());

From 66ba6e3e5ca3af05ab208457346e2d834750aafe Mon Sep 17 00:00:00 2001
From: Joey Parrish <joeyparrish@users.noreply.github.com>
Date: Wed, 27 May 2026 21:27:01 -0700
Subject: [PATCH 49/64] fix(UI): Use consistent font throughout UI (#10138)

Force form elements (button, input, select, textarea) to inherit
font-family, since browsers default them to the OS system font rather
than inheriting from ancestors. This makes the Shaka UI font apply
consistently to all elements under .shaka-video-container.

Remove now-redundant explicit font-family declarations from
.shaka-overflow-quality-mark and the tooltip ::after pseudo-element,
which were workarounds for the same inheritance gap.

Now it is possible for an application to override the font style of the
UI with a single declaration.

Co-authored-by: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 ui/less/general.less       | 7 +++++++
 ui/less/overflow_menu.less | 1 -
 ui/less/tooltip.less       | 2 --
 3 files changed, 7 insertions(+), 3 deletions(-)

diff --git a/ui/less/general.less b/ui/less/general.less
index a671df6664..fce01ea250 100644
--- a/ui/less/general.less
+++ b/ui/less/general.less
@@ -146,6 +146,13 @@ the control buttons panel. */
 @quality-mark-color: #fff;
 @quality-mark-hightlight-color: #f00;
 
+/* Form elements don't inherit font-family from their ancestors by default in
+ * most browsers; they fall back to the OS system font instead.  Force them to
+ * inherit so that Shaka UI containers' font-family applies consistently. */
+button, input, select, textarea {
+  font-family: inherit;
+}
+
 @media (forced-colors: active) {
   .shaka-overflow-menu,
   .shaka-settings-menu,
diff --git a/ui/less/overflow_menu.less b/ui/less/overflow_menu.less
index 56bdbd2b20..1b3308e3e3 100644
--- a/ui/less/overflow_menu.less
+++ b/ui/less/overflow_menu.less
@@ -180,7 +180,6 @@
   background: @quality-mark-hightlight-color;
   color: @quality-mark-color;
   border-radius: 2px;
-  font-family: @general-font-family;
   font-size: 10px;
   font-weight: bold;
   line-height: 10px;
diff --git a/ui/less/tooltip.less b/ui/less/tooltip.less
index 69b964a79f..d05a73c7c9 100644
--- a/ui/less/tooltip.less
+++ b/ui/less/tooltip.less
@@ -49,8 +49,6 @@
     &:active:after {
       content: attr(aria-label);
 
-      /* Override .material-icons-round text styling */
-      font-family: @general-font-family;
       line-height: 20px;
       white-space: nowrap;
       font-size: @general-font-size;

From d295a0abff5a4c6ea94086b9ae51584ab39264c3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C3=81lvaro=20Velad=20Galv=C3=A1n?= <ladvan91@hotmail.com>
Date: Thu, 28 May 2026 09:42:02 +0200
Subject: [PATCH 50/64] fix(UI): Sync Document PiP placeholder with video
 poster changes (#10135)

---
 ui/controls.js | 28 +++++++++++++++++++++++++---
 1 file changed, 25 insertions(+), 3 deletions(-)

diff --git a/ui/controls.js b/ui/controls.js
index 8025ba951c..2fcaedf6d5 100644
--- a/ui/controls.js
+++ b/ui/controls.js
@@ -1168,8 +1168,16 @@ shaka.ui.Controls = class extends shaka.util.FakeEventTarget {
     placeholder.classList.add('shaka-video-container');
     placeholder.classList.add('pip-placeholder');
     const video = /** @type {HTMLVideoElement} */ (this.video_);
-    if (video?.poster) {
-      const posterDiv = document.createElement('div');
+    let posterDiv = null;
+    const updatePoster = () => {
+      if (posterDiv) {
+        posterDiv.remove();
+        posterDiv = null;
+      }
+      if (!video?.poster) {
+        return;
+      }
+      posterDiv = document.createElement('div');
       posterDiv.classList.add('pip-poster');
       posterDiv.style.backgroundImage = `url("${video.poster}")`;
       const videoWidth = video.videoWidth || video.clientWidth;
@@ -1178,9 +1186,22 @@ shaka.ui.Controls = class extends shaka.util.FakeEventTarget {
       if (videoWidth && videoHeight) {
         posterDiv.style.setProperty('aspect-ratio',
             `${videoWidth} / ${videoHeight}`);
-        placeholder.appendChild(posterDiv);
       }
+      placeholder.prepend(posterDiv);
+    };
+
+    updatePoster();
+
+    const posterObserver = new MutationObserver(() => {
+      updatePoster();
+    });
+    if (video) {
+      posterObserver.observe(this.getLocalVideo(), {
+        attributes: true,
+        attributeFilter: ['poster'],
+      });
     }
+
     const iconWrapper = shaka.util.Dom.createHTMLElement('div');
     iconWrapper.classList.add('pip-icon-wrapper');
     placeholder.appendChild(iconWrapper);
@@ -1206,6 +1227,7 @@ shaka.ui.Controls = class extends shaka.util.FakeEventTarget {
 
     // Listen for the PiP closing event to move the player back.
     this.eventManager_.listenOnce(pipWindow, 'pagehide', () => {
+      posterObserver.disconnect();
       this.eventManager_.unlisten(pipIcon, 'click', pipAction);
       pipPlayer.classList.remove('pip-mode');
       placeholder.replaceWith(/** @type {!Node} */(pipPlayer));

From 61e64a9c2d8f78022fd1cece1baef8cf081b48ad Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Thu, 28 May 2026 09:45:02 +0200
Subject: [PATCH 51/64] build(deps): bump tmp from 0.2.4 to 0.2.7 (#10139)

---
 package-lock.json | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 44358e70ac..8db1ea9766 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -9789,9 +9789,9 @@
       }
     },
     "node_modules/tmp": {
-      "version": "0.2.4",
-      "resolved": "https://registry.npmjs.org/tmp/-/tmp-0.2.4.tgz",
-      "integrity": "sha512-UdiSoX6ypifLmrfQ/XfiawN6hkjSBpCjhKxxZcWlUUmoXLaCKQU0bx4HF/tdDK2uzRuchf1txGvrWBzYREssoQ==",
+      "version": "0.2.7",
+      "resolved": "https://registry.npmjs.org/tmp/-/tmp-0.2.7.tgz",
+      "integrity": "sha512-e0votIpp4Uo2AJYSzVHV6xCcawuiez3DzqDAbrTc3YxBkplN6e+dM13ZeIcZnDg/QpSuU2zfZ3rzwY8ukEnaXw==",
       "dev": true,
       "engines": {
         "node": ">=14.14"
@@ -17754,9 +17754,9 @@
       }
     },
     "tmp": {
-      "version": "0.2.4",
-      "resolved": "https://registry.npmjs.org/tmp/-/tmp-0.2.4.tgz",
-      "integrity": "sha512-UdiSoX6ypifLmrfQ/XfiawN6hkjSBpCjhKxxZcWlUUmoXLaCKQU0bx4HF/tdDK2uzRuchf1txGvrWBzYREssoQ==",
+      "version": "0.2.7",
+      "resolved": "https://registry.npmjs.org/tmp/-/tmp-0.2.7.tgz",
+      "integrity": "sha512-e0votIpp4Uo2AJYSzVHV6xCcawuiez3DzqDAbrTc3YxBkplN6e+dM13ZeIcZnDg/QpSuU2zfZ3rzwY8ukEnaXw==",
       "dev": true
     },
     "to-regex-range": {

From f2de74885e5f9f48b40a6aa780c2f5edd34594d1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C3=81lvaro=20Velad=20Galv=C3=A1n?= <ladvan91@hotmail.com>
Date: Thu, 28 May 2026 10:34:48 +0200
Subject: [PATCH 52/64] feat(UI): Update playback rate menu with slider and
 preset pills (#10134)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Before:

<img width="258" height="314" alt="before"
src="https://github.com/user-attachments/assets/07cdb649-aa99-4898-8a0c-262ff239e29d"
/>

After:

<img width="314" height="175" alt="after"
src="https://github.com/user-attachments/assets/fa150d58-8bcd-4e2f-8a80-bf4e7bf2abd3"
/>

---------

Co-authored-by: Wojciech Tyczyński <tykus160@gmail.com>
---
 demo/config.js                   |  15 ++
 test/test/util/fake_demo_main.js |   8 +-
 ui/controls.less                 |   1 +
 ui/externs/ui.js                 |  52 +++++-
 ui/less/playback_rate.less       | 158 ++++++++++++++++
 ui/playback_rate_selection.js    | 310 +++++++++++++++++++++++++------
 ui/range_element.js              |  24 +++
 ui/ui.js                         |   8 +-
 8 files changed, 517 insertions(+), 59 deletions(-)
 create mode 100644 ui/less/playback_rate.less

diff --git a/demo/config.js b/demo/config.js
index ef70cde7dd..3fb20d4d42 100644
--- a/demo/config.js
+++ b/demo/config.js
@@ -106,6 +106,7 @@ shakaDemo.Config = class {
     this.addUISection_();
     this.addUISeekBarColorsSection_();
     this.addUIVolumeBarColorsSection_();
+    this.addUIPlaybackRateBarColorsSection_();
     this.addUIQualityMarksSection_();
     this.addUIMediaSessionSection_();
     this.addUIDocumentPiPSection_();
@@ -1201,6 +1202,12 @@ shakaDemo.Config = class {
         .addUIArrayStringInput_('Statistics List', 'statisticsList')
         .addUIArrayStringInput_('Ad Statistics List', 'adStatisticsList')
         .addUIArrayNumberInput_('Playback Rates', 'playbackRates')
+        .addUINumberInput_('Playback Rate Slider Min',
+            'playbackRateSliderMin',
+            /* canBeDecimal= */ true)
+        .addUINumberInput_('Playback Rate Slider Max',
+            'playbackRateSliderMax',
+            /* canBeDecimal= */ true)
         .addUIArrayNumberInput_('Fast Forward Rates', 'fastForwardRates')
         .addUIArrayNumberInput_('Rewind Rates', 'rewindRates')
         .addUIArrayNumberInput_('Captions Font Scale Factors',
@@ -1227,6 +1234,14 @@ shakaDemo.Config = class {
         .addUITextInput_('Level Color', 'volumeBarColors.level');
   }
 
+  /** @private */
+  addUIPlaybackRateBarColorsSection_() {
+    const docLink = this.resolveExternLink_('.UIPlaybackRateBarColors');
+    this.addSection_('UI: Playback Rate Bar Colors', docLink)
+        .addUITextInput_('Base Color', 'playbackRateBarColors.base')
+        .addUITextInput_('Level Color', 'playbackRateBarColors.level');
+  }
+
   /** @private */
   addUIQualityMarksSection_() {
     const docLink = this.resolveExternLink_('.UIQualityMarks');
diff --git a/test/test/util/fake_demo_main.js b/test/test/util/fake_demo_main.js
index ecd3487684..4d73d4fe2f 100644
--- a/test/test/util/fake_demo_main.js
+++ b/test/test/util/fake_demo_main.js
@@ -30,7 +30,9 @@ shaka.test.FakeDemoMain = class {
       contextMenuElements: [],
       statisticsList: [],
       adStatisticsList: [],
-      playbackRates: [0.5, 0.75, 1, 1.25, 1.5, 1.75, 2],
+      playbackRates: [1, 1.25, 1.5, 2, 3],
+      playbackRateSliderMin: 0.5,
+      playbackRateSliderMax: 3,
       fastForwardRates: [2, 4, 8, 1],
       rewindRates: [-1, -2, -4, -8],
       addSeekBar: true,
@@ -50,6 +52,10 @@ shaka.test.FakeDemoMain = class {
         base: 'rgba(255, 255, 255, 0.54)',
         level: 'rgb(255, 255, 255)',
       },
+      playbackRateBarColors: {
+        base: 'rgba(255, 255, 255, 0.54)',
+        level: 'rgb(255, 255, 255)',
+      },
       qualityMarks: {
         '720': '',
         '1080': 'HD',
diff --git a/ui/controls.less b/ui/controls.less
index d71f086599..9b318a1421 100644
--- a/ui/controls.less
+++ b/ui/controls.less
@@ -13,5 +13,6 @@
 @import "less/ad_controls.less";
 @import "less/tooltip.less";
 @import "less/thumbnails.less";
+@import "less/playback_rate.less";
 @import "less/material_svg_icon.less";
 @import (css, inline) "https://fonts.googleapis.com/css?family=Roboto";
diff --git a/ui/externs/ui.js b/ui/externs/ui.js
index 322380eddb..1660643334 100644
--- a/ui/externs/ui.js
+++ b/ui/externs/ui.js
@@ -60,6 +60,22 @@ shaka.extern.UISeekBarColors;
  */
 shaka.extern.UIVolumeBarColors;
 
+/**
+ * @typedef {{
+ *   base: string,
+ *   level: string,
+ * }}
+ *
+ * @property {string} base
+ *   The CSS background color applied to the base of the playback rate bar, on
+ *   top of which the current playback rate level is shown.
+ * @property {string} level
+ *   The CSS background color applied to the portion of the playback rate bar
+ *   showing the current playback rate level.
+ * @exportDoc
+ */
+shaka.extern.UIPlaybackRateBarColors;
+
 /**
  * @typedef {{
  *   720: string,
@@ -288,6 +304,8 @@ shaka.extern.UITrackLabelCallback;
  *   statisticsList: !Array<string>,
  *   adStatisticsList: !Array<string>,
  *   playbackRates: !Array<number>,
+ *   playbackRateSliderMin: number,
+ *   playbackRateSliderMax: number,
  *   fastForwardRates: !Array<number>,
  *   rewindRates: !Array<number>,
  *   addSeekBar: boolean,
@@ -298,6 +316,7 @@ shaka.extern.UITrackLabelCallback;
  *   showUnbufferedStart: boolean,
  *   seekBarColors: shaka.extern.UISeekBarColors,
  *   volumeBarColors: shaka.extern.UIVolumeBarColors,
+ *   playbackRateBarColors: shaka.extern.UIPlaybackRateBarColors,
  *   qualityMarks: shaka.extern.UIQualityMarks,
  *   trackLabelFormat: shaka.ui.Overlay.TrackLabelFormat,
  *   textTrackLabelFormat: shaka.ui.Overlay.TrackLabelFormat,
@@ -359,7 +378,19 @@ shaka.extern.UITrackLabelCallback;
  * @property {!Array<number>} playbackRates
  *   The ordered list of rates for playback selection.
  *   <br>
- *   Defaults to <code>[0.5, 0.75, 1, 1.25, 1.5, 1.75, 2]</code>.
+ *   Defaults to <code>[1, 1.25, 1.5, 2, 3]</code>.
+ * @property {number} playbackRateSliderMin
+ *   The minimum playback rate available in the playback-rate slider.
+ *   This only affects the continuous slider range and does not add a preset
+ *   button to the playback-rate menu.
+ *   <br>
+ *   Defaults to <code>0.5</code>.
+ * @property {number} playbackRateSliderMax
+ *   The maximum playback rate available in the playback-rate slider.
+ *   This only affects the continuous slider range and does not add a preset
+ *   button to the playback-rate menu.
+ *   <br>
+ *   Defaults to <code>3</code>.
  * @property {!Array<number>} fastForwardRates
  *   The ordered list of rates for fast forward selection.
  *   <br>
@@ -414,6 +445,10 @@ shaka.extern.UITrackLabelCallback;
  *   The CSS colors applied to the volume bar.  This allows you to override the
  *   colors used in the linear gradient constructed in JavaScript, since you
  *   cannot do this in pure CSS.
+ * @property {shaka.extern.UIPlaybackRateBarColors} playbackRateBarColors
+ *   The CSS colors applied to the playback rate bar.  This allows you to
+ *   override the colors used in the linear gradient constructed in JavaScript,
+ *   since you cannot do this in pure CSS.
  * @property {shaka.extern.UIQualityMarks} qualityMarks
  *   The name of the quality marks.
  * @property {shaka.ui.Overlay.TrackLabelFormat} trackLabelFormat
@@ -807,6 +842,21 @@ shaka.extern.IUIRangeElement = class {
    */
   setStep(step) {}
 
+  /**
+   * @return {number}
+   */
+  getMin() {}
+
+  /**
+   * @return {number}
+   */
+  getMax() {}
+
+  /**
+   * @param {string} background
+   */
+  setBackground(background) {}
+
   /**
    * Called when user interaction begins.
    * To be overridden by subclasses.
diff --git a/ui/less/playback_rate.less b/ui/less/playback_rate.less
new file mode 100644
index 0000000000..1c5bb31cfa
--- /dev/null
+++ b/ui/less/playback_rate.less
@@ -0,0 +1,158 @@
+/** @license
+ * Shaka Player
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+// Step buttons (− / +)
+@playback-rate-step-btn-border: fade(@general-font-color, 50%);
+@playback-rate-step-btn-border-active: fade(@general-font-color, 85%);
+@playback-rate-step-btn-bg-active: fade(@general-font-color, 10%);
+
+// Slider track
+@playback-rate-slider-track: fade(@general-font-color, 25%);
+
+// Preset pill buttons
+@playback-rate-preset-bg: fade(@general-font-color, 10%);
+@playback-rate-preset-bg-hover: fade(@general-font-color, 18%);
+@playback-rate-preset-selected-bg: fade(@general-font-color, 20%);
+@playback-rate-preset-selected-border: fade(@general-font-color, 70%);
+
+/* Menu container */
+
+.shaka-playback-rates {
+  min-width: 240px;
+}
+
+/* Slider section */
+
+.shaka-playback-rate-slider-section {
+  padding: 8px 0 4px;
+}
+
+.shaka-playback-rate-value {
+  display: block;
+  width: 100%;
+  text-align: center;
+  font-size: 22px;
+  font-weight: 500;
+  color: @general-font-color;
+  font-variant-numeric: tabular-nums;
+  padding: 2px 0 10px;
+  margin-left: 0;
+}
+
+.shaka-playback-rate-slider-row {
+  display: flex;
+  flex-direction: row;
+  align-items: center;
+  padding: 0 10px;
+}
+
+/* Step buttons (− and +) */
+
+.shaka-playback-rate-step-btn {
+  /* Reset inherited .shaka-overflow-menu button styles. */
+  min-height: unset !important;
+  padding: 0 !important;
+  flex-shrink: 0;
+
+  width: 28px;
+  height: 28px;
+  border-radius: 50% !important;
+  border: 1.5px solid @playback-rate-step-btn-border !important;
+  background: transparent !important;
+
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+
+  font-size: 18px;
+  font-weight: 400;
+  line-height: 1;
+  color: @general-font-color;
+
+  transition:
+    border-color 150ms ease,
+    background 150ms ease,
+    opacity 150ms ease;
+
+  &:disabled {
+    opacity: 0.3;
+    cursor: default;
+  }
+
+  &:hover:not(:disabled) {
+    border-color: @playback-rate-step-btn-border-active !important;
+    background: @playback-rate-step-btn-bg-active !important;
+  }
+
+  .shaka-keyboard-navigation &:focus:not(:disabled) {
+    border-color: @playback-rate-step-btn-border-active !important;
+    background: @playback-rate-step-btn-bg-active !important;
+  }
+}
+
+.shaka-playback-rate-slider-container {
+  flex: 1;
+  background: @playback-rate-slider-track;
+}
+
+/* Preset pill buttons */
+
+/* Horizontal strip. */
+.shaka-playback-rate-presets {
+  display: flex;
+  flex-direction: row;
+  align-items: center;
+
+  /* Centre pills when they fit; safe-center degrades to flex-start on
+   * overflow so the leftmost pill stays reachable via scroll. */
+  justify-content: safe center;
+  /* stylelint-disable-next-line declaration-block-no-duplicate-properties */
+  justify-content: center; /* fallback for browsers without "safe" */
+
+  overflow-x: auto;
+  overflow-y: hidden;
+  scrollbar-width: none;
+  &::-webkit-scrollbar { display: none; }
+
+  gap: 6px;
+  padding: 6px 10px 10px;
+  white-space: nowrap;
+}
+
+.shaka-playback-rate-preset-btn {
+  /* Reset inherited .shaka-overflow-menu button styles. */
+  min-height: unset !important;
+  padding: 5px 14px !important;
+  border-radius: 20px !important;
+
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  flex-shrink: 0;
+
+  font-size: 13px;
+  color: @general-font-color;
+  background: @playback-rate-preset-bg !important;
+  border: 1.5px solid transparent !important;
+
+  transition: background 150ms ease, border-color 150ms ease;
+
+  &:hover {
+    background: @playback-rate-preset-bg-hover !important;
+  }
+
+  .shaka-keyboard-navigation &:focus {
+    background: @playback-rate-preset-bg-hover !important;
+  }
+
+  &.shaka-chosen-item {
+    background: @playback-rate-preset-selected-bg !important;
+    border-color: @playback-rate-preset-selected-border !important;
+    font-weight: 600;
+    color: @general-font-color;
+    margin-left: 0;
+  }
+}
diff --git a/ui/playback_rate_selection.js b/ui/playback_rate_selection.js
index 5931d005a0..b396fc1daa 100644
--- a/ui/playback_rate_selection.js
+++ b/ui/playback_rate_selection.js
@@ -7,13 +7,15 @@
 
 goog.provide('shaka.ui.PlaybackRateSelection');
 
+goog.require('goog.asserts');
 goog.require('shaka.ui.Controls');
 goog.require('shaka.ui.Enums');
 goog.require('shaka.ui.Locales');
 goog.require('shaka.ui.OverflowMenu');
+goog.require('shaka.ui.RangeElement');
 goog.require('shaka.ui.SettingsMenu');
-goog.require('shaka.ui.Utils');
 goog.require('shaka.util.Dom');
+goog.require('shaka.util.NumberUtils');
 goog.requireType('shaka.ui.Controls');
 
 /**
@@ -30,16 +32,34 @@ shaka.ui.PlaybackRateSelection = class extends shaka.ui.SettingsMenu {
     super(parent, controls,
         shaka.ui.Enums.MaterialDesignSVGIcons['PLAYBACK_RATE']);
 
+    /** @private {!shaka.extern.UIConfiguration} */
+    this.config_ = this.controls.getConfig();
+
     this.button.classList.add('shaka-playbackrate-button');
     this.menu.classList.add('shaka-playback-rates');
     this.button.classList.add('shaka-tooltip-status');
 
     if (!this.isSubMenu) {
-      this.playbackRateMark = shaka.util.Dom.createHTMLElement('span');
-      this.playbackRateMark.classList.add('shaka-overflow-playback-rate-mark');
-      this.button.appendChild(this.playbackRateMark);
+      /** @private {HTMLElement} */
+      this.playbackRateMark_ = shaka.util.Dom.createHTMLElement('span');
+      this.playbackRateMark_.classList.add('shaka-overflow-playback-rate-mark');
+      this.button.appendChild(this.playbackRateMark_);
     }
 
+    /** @private {shaka.ui.RangeElement} */
+    this.rateSlider_ = null;
+
+    /** @private {HTMLElement} */
+    this.speedValue_ = null;
+
+    /** @private {HTMLButtonElement} */
+    this.decreaseButton_ = null;
+
+    /** @private {HTMLButtonElement} */
+    this.increaseButton_ = null;
+
+    this.buildUI_();
+
     this.eventManager.listenMulti(
         this.player,
         [
@@ -49,12 +69,19 @@ shaka.ui.PlaybackRateSelection = class extends shaka.ui.SettingsMenu {
           this.updatePlaybackRateSelection_();
         });
 
-    // Set up all the strings in the user's preferred language.
     this.updateLocalizedStrings();
-    this.addPlaybackRates_();
     this.updatePlaybackRateSelection_();
   }
 
+  /** @override */
+  release() {
+    if (this.rateSlider_) {
+      this.rateSlider_.release();
+      this.rateSlider_ = null;
+    }
+    super.release();
+  }
+
   /** @override */
   updateLocalizedStrings() {
     const LocIds = shaka.ui.Locales.Ids;
@@ -65,73 +92,244 @@ shaka.ui.PlaybackRateSelection = class extends shaka.ui.SettingsMenu {
     this.backSpan.textContent = this.localization.resolve(LocIds.PLAYBACK_RATE);
   }
 
+  /** @private */
+  buildUI_() {
+    // Slider section
+    const sliderSection = shaka.util.Dom.createHTMLElement('div');
+    sliderSection.classList.add('shaka-playback-rate-slider-section');
+
+
+    this.speedValue_ = shaka.util.Dom.createHTMLElement('div');
+    this.speedValue_.classList.add('shaka-playback-rate-value');
+    sliderSection.appendChild(this.speedValue_);
+
+    // Slider row: [−] ──────slider────── [+]
+    const sliderRow = shaka.util.Dom.createHTMLElement('div');
+    sliderRow.classList.add('shaka-playback-rate-slider-row');
+
+    // Decrease button (−)
+    this.decreaseButton_ = shaka.util.Dom.createButton();
+    this.decreaseButton_.classList.add('shaka-playback-rate-step-btn');
+    this.decreaseButton_.classList.add('shaka-no-propagation');
+    this.decreaseButton_.setAttribute('aria-label', '−');
+    this.decreaseButton_.textContent = '−';
+    sliderRow.appendChild(this.decreaseButton_);
+
+    // Range slider.
+    goog.asserts.assert(this.controls, 'Controls should not be null!');
+    this.rateSlider_ = new shaka.ui.RangeElement(
+        sliderRow,
+        this.controls,
+        /* containerClassNames= */
+        ['shaka-playback-rate-slider-container', 'shaka-no-propagation'],
+        /* barClassNames= */ ['shaka-playback-rate-slider'],
+        /* enableWheel= */ true);
+
+    this.rateSlider_.setStep(shaka.ui.PlaybackRateSelection.SLIDER_STEP);
+
+    this.rateSlider_.onChange = () => {
+      this.applyRate_(this.rateSlider_.getValue());
+    };
+
+    // Increase button (+)
+    this.increaseButton_ = shaka.util.Dom.createButton();
+    this.increaseButton_.classList.add('shaka-playback-rate-step-btn');
+    this.increaseButton_.classList.add('shaka-no-propagation');
+    this.increaseButton_.setAttribute('aria-label', '+');
+    this.increaseButton_.textContent = '+';
+    sliderRow.appendChild(this.increaseButton_);
+
+    sliderSection.appendChild(sliderRow);
+    this.menu.appendChild(sliderSection);
+
+    // Step-button listeners.
+    this.eventManager.listen(this.decreaseButton_, 'click', () => {
+      this.stepRate_(-shaka.ui.PlaybackRateSelection.SLIDER_STEP);
+    });
+    this.eventManager.listen(this.increaseButton_, 'click', () => {
+      this.stepRate_(shaka.ui.PlaybackRateSelection.SLIDER_STEP);
+    });
+
+    // Preset pill buttons (horizontal)
+
+    const presetsRow = shaka.util.Dom.createHTMLElement('div');
+    presetsRow.classList.add('shaka-playback-rate-presets');
+
+    for (const rate of this.controls.getConfig().playbackRates) {
+      const btn = shaka.util.Dom.createButton();
+      btn.classList.add('shaka-playback-rate-preset-btn');
+      btn.setAttribute('role', 'menuitemradio');
+      btn.setAttribute('aria-checked', 'false');
+      btn.dataset['rate'] = String(rate);
+      btn.textContent = this.formatPresetLabel_(rate);
+
+      this.eventManager.listen(btn, 'click', () => {
+        this.applyRate_(rate);
+      });
+
+      presetsRow.appendChild(btn);
+    }
+
+    this.menu.appendChild(presetsRow);
+  }
+
+  /**
+   * @param {number} rate
+   * @private
+   */
+  applyRate_(rate) {
+    if (rate === this.video.defaultPlaybackRate) {
+      this.player.cancelTrickPlay();
+    } else {
+      this.player.trickPlay(rate, /* useTrickPlayTrack= */ false);
+    }
+  }
+
+  /**
+   * Steps the playback rate by `delta`, snapped to SLIDER_STEP and clamped to
+   * the configured [playbackRateSliderMin, playbackRateSliderMax] range.
+   *
+   * Snapping the current rate to the step grid before adding delta ensures that
+   * a programmatic value like 0.97 is brought back onto the grid (0.95 or
+   * 1.00) on the next user interaction rather than accumulating floating-point
+   * drift.
+   *
+   * @param {number} delta
+   * @private
+   */
+  stepRate_(delta) {
+    const config = this.controls.getConfig();
+    const min = config.playbackRateSliderMin;
+    const max = config.playbackRateSliderMax;
+    const step = shaka.ui.PlaybackRateSelection.SLIDER_STEP;
+
+    const current = this.player.getPlaybackRate();
+    // Snap current rate to the nearest step grid point, then apply delta.
+    const snapped = Math.round(current / step) * step;
+    const raw = snapped + delta;
+    // Eliminate floating-point noise (e.g. 0.05 * 20 → 1.0000000000000002).
+    const next = parseFloat((Math.round(raw / step) * step).toPrecision(10));
+    const clamped = Math.max(min, Math.min(max, next));
+
+    this.applyRate_(clamped);
+  }
+
   /**
-   * Update checkmark icon and related class and attribute for the chosen rate
-   * button.
+   * Returns the effective slider range.
+   *
+   * Normally this is [playbackRateSliderMin, playbackRateSliderMax] from the
+   * config.  If the current rate was set programmatically outside that range,
+   * the bounds are extended just enough to keep the thumb visible.
+   *
+   * @return {{min: number, max: number}}
+   * @private
+   */
+  getSliderRange_() {
+    const config = this.controls.getConfig();
+    let min = config.playbackRateSliderMin;
+    let max = config.playbackRateSliderMax;
+    const currentRate = this.player.getPlaybackRate();
+    if (currentRate < min) {
+      min = currentRate;
+    }
+    if (currentRate > max) {
+      max = currentRate;
+    }
+    return {min, max};
+  }
+
+  /**
+   * Syncs slider range/value, live value label, step-button disabled state,
+   * and preset-pill highlights to the current player rate.
    * @private
    */
   updatePlaybackRateSelection_() {
+    const config = this.controls.getConfig();
     const rate = this.player.getPlaybackRate();
-    // Remove the old checkmark icon and related tags and classes if it exists.
-    const checkmarkIcon = shaka.ui.Utils.getDescendantIfExists(
-        this.menu, 'shaka-ui-icon shaka-chosen-item');
-    if (checkmarkIcon) {
-      const previouslySelectedButton = checkmarkIcon.parentElement;
-      previouslySelectedButton.removeAttribute('aria-selected');
-      const previouslySelectedSpan =
-          previouslySelectedButton.getElementsByTagName('span')[0];
-      if (previouslySelectedSpan) {
-        previouslySelectedSpan.classList.remove('shaka-chosen-item');
-      }
-      previouslySelectedButton.removeChild(checkmarkIcon);
-    }
-    // Find the button that represents the newly selected playback rate.
-    // Add the checkmark icon, related tags and classes to the newly selected
-    // button.
-    const span = Array.from(this.menu.querySelectorAll('span')).find((el) => {
-      return el.textContent == (rate + 'x');
-    });
-    if (span) {
-      const button = span.parentElement;
-      button.appendChild(shaka.ui.Utils.checkmarkIcon());
-      button.setAttribute('aria-checked', 'true');
-      span.classList.add('shaka-chosen-item');
+
+    // Update slider range first (may be extended for out-of-config rates).
+    const {min, max} = this.getSliderRange_();
+    this.rateSlider_.setRange(min, max);
+    this.rateSlider_.setValue(rate);
+
+    // Large centred value label.
+    this.speedValue_.textContent = rate.toFixed(2) + 'x';
+
+    // Disable step buttons at the configured hard limits (not the extended
+    // ones) so the user cannot go beyond the intended range by clicking.
+    this.decreaseButton_.disabled = rate <= config.playbackRateSliderMin;
+    this.increaseButton_.disabled = rate >= config.playbackRateSliderMax;
+
+    // Highlight the matching preset pill, if any.
+    const presetBtns =
+        this.menu.querySelectorAll('.shaka-playback-rate-preset-btn');
+    for (const btn of presetBtns) {
+      const button = /** @type {!HTMLButtonElement} */ (btn);
+      const btnRate = parseFloat(button.dataset['rate']);
+      const isChosen =
+          shaka.util.NumberUtils.isFloatEqual(btnRate, rate, 0.001);
+      button.setAttribute('aria-checked', isChosen ? 'true' : 'false');
+      button.classList.toggle('shaka-chosen-item', isChosen);
     }
 
-    // Set the label to display the current playback rate in the overflow menu,
-    // in the format of '1x', '1.5x', etc.
+    // Overflow-menu badge / tooltip.
     this.currentSelection.textContent = rate + 'x';
     this.button.setAttribute('shaka-status', rate + 'x');
-    if (this.playbackRateMark) {
-      this.playbackRateMark.textContent = rate + 'x';
+    if (this.playbackRateMark_) {
+      this.playbackRateMark_.textContent = rate + 'x';
     }
+    this.updateColors_();
+  }
+
+  /**
+   * Formats a preset rate for display inside a pill button.
+   * Rules
+   *   - Comma as decimal separator.
+   *   - Always at least one decimal place (e.g. 1 to "1,0", 3 to "3,0").
+   *
+   * @param {number} rate
+   * @return {string}
+   * @private
+   */
+  formatPresetLabel_(rate) {
+    // Determine how many decimal places the value naturally has.
+    const str = rate.toString(); // e.g. "1", "1.25", "0.5"
+    const dotIndex = str.indexOf('.');
+    const decimals = dotIndex === -1 ? 0 : str.length - dotIndex - 1;
+    // Show at least one decimal place.
+    return rate.toFixed(Math.max(1, decimals)).replace('.', ',');
   }
 
   /** @private */
-  addPlaybackRates_() {
-    for (const rate of this.controls.getConfig().playbackRates) {
-      const button = shaka.util.Dom.createButton();
-      // ARIA: single-select menu item
-      button.setAttribute('role', 'menuitemradio');
-      button.setAttribute('aria-checked', 'false');
-      const span = shaka.util.Dom.createHTMLElement('span');
-      span.textContent = rate + 'x';
-      button.appendChild(span);
-
-      this.eventManager.listen(button, 'click', () => {
-        if (rate == this.video.defaultPlaybackRate) {
-          this.player.cancelTrickPlay();
-        } else {
-          this.player.trickPlay(rate, /* useTrickPlayTrack= */ false);
-        }
-      });
+  updateColors_() {
+    const colors = this.config_.playbackRateBarColors;
 
-      this.menu.appendChild(button);
-    }
-    shaka.ui.Utils.focusOnTheChosenItem(this.menu);
+    const value = this.rateSlider_.getValue();
+    const min = this.rateSlider_.getMin();
+    const max = this.rateSlider_.getMax();
+
+    // Convert current value to percentage within slider range.
+    const percent = ((value - min) / (max - min)) * 100;
+
+    const gradient = ['to right'];
+    gradient.push(colors.level + '0%');
+    gradient.push(colors.level + percent + '%');
+    gradient.push(colors.base + percent + '%');
+    gradient.push(colors.base + '100%');
+
+    this.rateSlider_.setBackground(
+        'linear-gradient(' + gradient.join(',') + ')');
   }
 };
 
+
+/**
+ * Step size used for slider interaction and the +/- buttons.
+ * @const {number}
+ */
+shaka.ui.PlaybackRateSelection.SLIDER_STEP = 0.05;
+
+
 /**
  * @implements {shaka.extern.IUIElement.Factory}
  * @final
diff --git a/ui/range_element.js b/ui/range_element.js
index cff2f38581..14e5a7e1a8 100644
--- a/ui/range_element.js
+++ b/ui/range_element.js
@@ -219,6 +219,30 @@ shaka.ui.RangeElement = class extends shaka.ui.Element {
     this.bar.step = step;
   }
 
+  /**
+   * @override
+   * @export
+   */
+  getMin() {
+    return parseFloat(this.bar.min);
+  }
+
+  /**
+   * @override
+   * @export
+   */
+  getMax() {
+    return parseFloat(this.bar.max);
+  }
+
+  /**
+   * @override
+   * @export
+   */
+  setBackground(background) {
+    this.container.style.background = background;
+  }
+
   /**
    * Called when user interaction begins.
    * To be overridden by subclasses.
diff --git a/ui/ui.js b/ui/ui.js
index 04a54bbeb0..e49a8d05d7 100644
--- a/ui/ui.js
+++ b/ui/ui.js
@@ -363,7 +363,9 @@ shaka.ui.Overlay = class {
         'copy_video_frame',
         'save_video_frame',
       ],
-      playbackRates: [0.5, 0.75, 1, 1.25, 1.5, 1.75, 2],
+      playbackRates: [1, 1.25, 1.5, 2, 3],
+      playbackRateSliderMin: 0.5,
+      playbackRateSliderMax: 3,
       fastForwardRates: [2, 4, 8, 1],
       rewindRates: [-1, -2, -4, -8],
       addSeekBar: true,
@@ -383,6 +385,10 @@ shaka.ui.Overlay = class {
         base: 'rgba(255, 255, 255, 0.54)',
         level: 'rgb(255, 255, 255)',
       },
+      playbackRateBarColors: {
+        base: 'rgba(255, 255, 255, 0.54)',
+        level: 'rgb(255, 255, 255)',
+      },
       qualityMarks: {
         '720': '',
         '1080': 'HD',

From c433bcb68b3aed56985162a2576fe50972fb55e3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C3=81lvaro=20Velad=20Galv=C3=A1n?= <ladvan91@hotmail.com>
Date: Thu, 28 May 2026 10:43:50 +0200
Subject: [PATCH 53/64] feat(UI): Support Document PiP for audio-only playback
 (#10136)

---
 test/ui/ui_unit.js | 3 +++
 ui/controls.js     | 9 ++++-----
 ui/pip_button.js   | 3 ++-
 3 files changed, 9 insertions(+), 6 deletions(-)

diff --git a/test/ui/ui_unit.js b/test/ui/ui_unit.js
index 05fc30c0b7..155fb8ada3 100644
--- a/test/ui/ui_unit.js
+++ b/test/ui/ui_unit.js
@@ -316,6 +316,9 @@ describe('UI', () => {
             'overflow_menu',
           ],
           customContextMenu: false,
+          documentPictureInPicture: {
+            enabled: false,
+          },
         };
         const ui = await UiUtils.createUIThroughAPI(
             videoContainer, video, config);
diff --git a/ui/controls.js b/ui/controls.js
index 2fcaedf6d5..4a847b3eac 100644
--- a/ui/controls.js
+++ b/ui/controls.js
@@ -977,9 +977,8 @@ shaka.ui.Controls = class extends shaka.util.FakeEventTarget {
 
   /**
    * @return {boolean}
-   * @private
    */
-  shouldUseDocumentPictureInPicture_() {
+  shouldUseDocumentPictureInPicture() {
     return 'documentPictureInPicture' in window &&
         this.config_.documentPictureInPicture.enabled;
   }
@@ -1025,7 +1024,7 @@ shaka.ui.Controls = class extends shaka.util.FakeEventTarget {
       if (this.shouldUseDocumentFullscreen_()) {
         if (this.isPiPEnabled()) {
           await this.togglePiP();
-          if (this.shouldUseDocumentPictureInPicture_()) {
+          if (this.shouldUseDocumentPictureInPicture()) {
             // This is necessary because we need a small delay when
             // executing actions when returning from document PiP.
             await shaka.util.Functional.delay(0.05);
@@ -1089,7 +1088,7 @@ shaka.ui.Controls = class extends shaka.util.FakeEventTarget {
       return false;
     }
     if (document.pictureInPictureEnabled ||
-        this.shouldUseDocumentPictureInPicture_()) {
+        this.shouldUseDocumentPictureInPicture()) {
       const video = /** @type {HTMLVideoElement} */(this.localVideo_);
       return !video.disablePictureInPicture;
     }
@@ -1109,7 +1108,7 @@ shaka.ui.Controls = class extends shaka.util.FakeEventTarget {
   /** @export */
   async togglePiP() {
     try {
-      if (this.shouldUseDocumentPictureInPicture_()) {
+      if (this.shouldUseDocumentPictureInPicture()) {
         // If you were fullscreen, leave fullscreen first.
         if (this.isFullScreenEnabled()) {
           await this.exitFullScreen_();
diff --git a/ui/pip_button.js b/ui/pip_button.js
index 3ae27b5b05..cbea1de462 100644
--- a/ui/pip_button.js
+++ b/ui/pip_button.js
@@ -167,7 +167,8 @@ shaka.ui.PipButton = class extends shaka.ui.Element {
       if (this.controls.isPiPEnabled()) {
         await this.controls.togglePiP();
       }
-    } else if (this.player && this.player.isAudioOnly()) {
+    } else if (this.player && this.player.isAudioOnly() &&
+        !this.controls.shouldUseDocumentPictureInPicture()) {
       shaka.ui.Utils.setDisplay(this.pipButton_, false);
       if (this.controls.isPiPEnabled()) {
         await this.controls.togglePiP();

From ad4b6245d3a92d2f4f4e88fcf0359230c3fbb2ff Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C3=81lvaro=20Velad=20Galv=C3=A1n?= <ladvan91@hotmail.com>
Date: Thu, 28 May 2026 14:05:07 +0200
Subject: [PATCH 54/64] fix(Cast): Proxy missing ad events through CastProxy
 (#10142)

---
 lib/cast/cast_utils.js | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/lib/cast/cast_utils.js b/lib/cast/cast_utils.js
index 4536cdd879..bd6a2eba4b 100644
--- a/lib/cast/cast_utils.js
+++ b/lib/cast/cast_utils.js
@@ -536,6 +536,11 @@ shaka.cast.CastUtils.AdManagerEvents = [
   'ad-content-pause-requested',
   'ad-content-resume-requested',
   'ad-content-attach-requested',
+  'ad-playing',
+  'ad-break-started',
+  'ad-break-ended',
+  'ad-interstitial-preload',
+  'ad-interstitial-preloaded',
 ];
 
 

From ee9436bd8a66c05d88c65d2c4d8de8761dd255d2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C3=81lvaro=20Velad=20Galv=C3=A1n?= <ladvan91@hotmail.com>
Date: Thu, 28 May 2026 14:05:26 +0200
Subject: [PATCH 55/64] fix(UI): Update play button state on
 shaka.ads.Utils.AD_PLAYING (#10143)

---
 ui/play_button.js | 1 +
 1 file changed, 1 insertion(+)

diff --git a/ui/play_button.js b/ui/play_button.js
index f17a90247e..1604842ed4 100644
--- a/ui/play_button.js
+++ b/ui/play_button.js
@@ -72,6 +72,7 @@ shaka.ui.PlayButton = class extends shaka.ui.Element {
         [
           shaka.ads.Utils.AD_PAUSED,
           shaka.ads.Utils.AD_RESUMED,
+          shaka.ads.Utils.AD_PLAYING,
           shaka.ads.Utils.AD_STARTED,
           shaka.ads.Utils.AD_STOPPED,
         ], () => {

From d61c85edbc8cf9c8ffc4f1a6b4ec95ed6e856a4c Mon Sep 17 00:00:00 2001
From: Joey Parrish <joeyparrish@users.noreply.github.com>
Date: Thu, 28 May 2026 08:59:36 -0700
Subject: [PATCH 56/64] chore(Demo): Add back Tengwar font (#10147)

This adds back the Tengwar font to support an upcoming complete and
maintained translation into Sindarin, powered by Claude Code and
automated workflows.

This is even less invasive than the method I had originally. It does not
touch the library CSS at all.
---
 demo/TengwarTelcontar.woff2 | Bin 0 -> 66108 bytes
 demo/demo.less              |  15 +++++++++++++++
 2 files changed, 15 insertions(+)
 create mode 100644 demo/TengwarTelcontar.woff2

diff --git a/demo/TengwarTelcontar.woff2 b/demo/TengwarTelcontar.woff2
new file mode 100644
index 0000000000000000000000000000000000000000..62404f98ea003bac4307ac10766895c53992f5e0
GIT binary patch
literal 66108
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

literal 0
HcmV?d00001

diff --git a/demo/demo.less b/demo/demo.less
index 711631f9ec..0b5fdd48d2 100644
--- a/demo/demo.less
+++ b/demo/demo.less
@@ -81,6 +81,21 @@ html, body {
   font-family: Roboto, sans-serif;
 }
 
+// This font supports the Sindarin (sjn) translation.
+@font-face {
+  // The Tengwar Telcontar font
+  // From https://freetengwar.sourceforge.net/tengtelc.html
+  src: url("../demo/TengwarTelcontar.woff2") format("woff2");
+  // Unicode Private Use Area (PUA) used by ConScript Unicode Registry (CSUR)
+  // to represent Tengwar glyphs.  This will keep the font from being loaded
+  // for any other codepoints.
+  unicode-range: U+E000-E0FF;
+  // Fun trick to avoid hard-coding Tengwar support into the library:
+  // Add this font for these codepoint ranges in anything that uses "Roboto",
+  // without having to modify the CSS to point at another font family.
+  font-family: Roboto;
+}
+
 /* Change the default opacity of the ripple container, to get around an iOS bug.
  * See: https://github.com/google/material-design-lite/issues/5281 */
 .mdl-ripple {

From 7108d22c34cc4e2c1e0de80aa4629605f40d11e9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C3=81lvaro=20Velad=20Galv=C3=A1n?= <ladvan91@hotmail.com>
Date: Thu, 28 May 2026 18:00:04 +0200
Subject: [PATCH 57/64] feat(UI): Redesign Document PiP placeholder with
 blurred backdrop, pulse animation and label (#10140)

New design:
<img width="1322" height="586" alt="Design"
src="https://github.com/user-attachments/assets/a3b057d4-9da7-4d3a-a39b-ab26b5253c4f"
/>
---
 ui/controls.js          | 23 +++++++++++-
 ui/less/containers.less | 82 +++++++++++++++++++++++++++++++++++++----
 ui/locales/en.json      |  1 +
 ui/locales/es.json      |  1 +
 ui/locales/fr.json      |  1 +
 ui/locales/nl.json      |  3 +-
 ui/locales/pl.json      |  1 +
 7 files changed, 102 insertions(+), 10 deletions(-)

diff --git a/ui/controls.js b/ui/controls.js
index 4a847b3eac..f67f64ba2e 100644
--- a/ui/controls.js
+++ b/ui/controls.js
@@ -1201,15 +1201,36 @@ shaka.ui.Controls = class extends shaka.util.FakeEventTarget {
       });
     }
 
+    // Blur overlay: covers the full placeholder, blurs the poster behind it.
+    const blurOverlay = shaka.util.Dom.createHTMLElement('div');
+    blurOverlay.classList.add('pip-blur-overlay');
+    placeholder.appendChild(blurOverlay);
+
+    // Wrap pulse ring + icon together so the ring is centered on the button.
+    const pipIconGroup = shaka.util.Dom.createHTMLElement('div');
+    pipIconGroup.classList.add('pip-icon-group');
+    placeholder.appendChild(pipIconGroup);
+
+    const pulseRing = shaka.util.Dom.createHTMLElement('div');
+    pulseRing.classList.add('pip-pulse-ring');
+    pipIconGroup.appendChild(pulseRing);
+
     const iconWrapper = shaka.util.Dom.createHTMLElement('div');
     iconWrapper.classList.add('pip-icon-wrapper');
-    placeholder.appendChild(iconWrapper);
+    pipIconGroup.appendChild(iconWrapper);
     const pipIcon = (new shaka.ui.Icon(iconWrapper,
         shaka.ui.Enums.MaterialDesignSVGIcons['EXIT_PIP'])).getSvgElement();
     const pipAction = () => this.togglePiP();
     this.eventManager_.listenOnce(pipIcon, 'click', pipAction);
 
+    const pipLabel = shaka.util.Dom.createHTMLElement('p');
+    pipLabel.classList.add('pip-label');
+    pipLabel.textContent =
+        this.localization_.resolve(shaka.ui.Locales.Ids.PIP_WINDOW_ACTIVE);
+    placeholder.appendChild(pipLabel);
+
     const style = getComputedStyle(pipPlayer);
+    placeholder.style.width = style.width;
     placeholder.style.height = style.height;
     parentPlayer.appendChild(placeholder);
 
diff --git a/ui/less/containers.less b/ui/less/containers.less
index 59b50ee75c..76179f22c0 100644
--- a/ui/less/containers.less
+++ b/ui/less/containers.less
@@ -256,13 +256,60 @@
 
 .shaka-video-container.pip-placeholder {
   .center-children();
+  flex-direction: column;
+  gap: 14px;
+  margin: auto;
+
+  // Clip the scaled poster so it never bleeds outside the player bounds.
+  overflow: hidden;
 
+  // Poster: contain, sharp, fills the placeholder at the bottom of the stack.
   .pip-poster {
-    height: 100%;
+    position: absolute;
+    inset: 0;
     background-size: contain;
     background-repeat: no-repeat;
     background-position: center;
+  }
+
+  // Blur overlay: sits above the poster, blurs everything behind it and
+  // darkens slightly so the icon and label remain legible.
+  .pip-blur-overlay {
+    position: absolute;
+    inset: 0;
+    backdrop-filter: blur(18px) brightness(0.55);
+    z-index: 1;
+  }
+
+  // Stacking context for everything above the poster.
+  .pip-icon-group {
+    position: relative;
+    .center-children();
+    z-index: 2;
+
+    // Size the group to the same footprint as the button so the ring
+    // is centered without extra markup.
+    width: 15%;
+    aspect-ratio: 1 / 1;
+  }
+
+  // Expanding pulse ring behind the button.
+  .pip-pulse-ring {
     position: absolute;
+    inset: 0;
+    border-radius: 50%;
+    border: 2px solid rgba(255, 255, 255, 35%);
+    animation: pip-pulse 2s ease-out infinite;
+    pointer-events: none;
+
+    @media (prefers-reduced-motion: reduce) {
+      animation: none;
+    }
+  }
+
+  @keyframes pip-pulse {
+    0% { transform: scale(1); opacity: 0.7; }
+    100% { transform: scale(1.9); opacity: 0; }
   }
 
   .shaka-ui-icon {
@@ -271,24 +318,28 @@
   }
 
   .pip-icon-wrapper {
-    width: 15%;
+    width: 100%;
     aspect-ratio: 1 / 1;
     border-radius: 50%;
+    position: relative;
 
     .center-children();
 
     color: @general-font-color;
-    background-color: @general-background-color;
-    box-shadow: 0 8px 24px rgba(0, 0, 0, 35%);
+    background-color: rgba(0, 0, 0, 45%);
+    border: 1.5px solid rgba(255, 255, 255, 25%);
+    backdrop-filter: blur(6px);
     cursor: pointer;
 
-    transition: transform 0.18s ease-out, background-color 0.18s ease-out;
-
-    z-index: 1;
+    transition:
+      transform 0.18s ease-out,
+      background-color 0.18s ease-out,
+      border-color 0.18s ease-out;
 
     &:hover {
       transform: scale(1.06);
-      background-color: @general-background-color-hover;
+      background-color: rgba(0, 0, 0, 62%);
+      border-color: rgba(255, 255, 255, 45%);
     }
 
     &:active {
@@ -299,6 +350,21 @@
       transition: none;
     }
   }
+
+  // Descriptive label below the button.
+  .pip-label {
+    position: relative;
+    z-index: 2;
+    margin: 0;
+    font-size: @content-title-font-size;
+    color: rgba(255, 255, 255, 55%);
+    letter-spacing: 0.04em;
+    text-align: center;
+    pointer-events: none;
+
+    // Subtle text shadow so it reads on any poster colour.
+    text-shadow: 0 1px 6px rgba(0, 0, 0, 80%);
+  }
 }
 
 /* This is the container for the horizontal row of controls above the seek bar.
diff --git a/ui/locales/en.json b/ui/locales/en.json
index 70a6ddf86b..45d3b22769 100644
--- a/ui/locales/en.json
+++ b/ui/locales/en.json
@@ -40,6 +40,7 @@
   "ORIGINAL_VERSION": "Original version",
   "PAUSE": "Pause",
   "PICTURE_IN_PICTURE": "Picture-in-Picture",
+  "PIP_WINDOW_ACTIVE": "Playing in picture-in-picture mode",
   "PLAY": "Play",
   "PLAYBACK_RATE": "Playback speed",
   "QUALITY": "Quality",
diff --git a/ui/locales/es.json b/ui/locales/es.json
index e0537bd41e..3433348969 100644
--- a/ui/locales/es.json
+++ b/ui/locales/es.json
@@ -40,6 +40,7 @@
   "ORIGINAL_VERSION": "Versión original",
   "PAUSE": "Pausar",
   "PICTURE_IN_PICTURE": "Imagen en imagen",
+  "PIP_WINDOW_ACTIVE": "Reproduciendo en modo imagen en imagen",
   "PLAY": "Reproducir",
   "PLAYBACK_RATE": "Velocidad de reproducción",
   "QUALITY": "Calidad",
diff --git a/ui/locales/fr.json b/ui/locales/fr.json
index 65763dc7ac..32d5bdfa59 100644
--- a/ui/locales/fr.json
+++ b/ui/locales/fr.json
@@ -39,6 +39,7 @@
   "ORIGINAL_VERSION": "Version originale",
   "PAUSE": "Pause",
   "PICTURE_IN_PICTURE": "Picture-in-Picture",
+  "PIP_WINDOW_ACTIVE": "Lecture en mode Picture-in-Picture",
   "PLAY": "Visionner",
   "PLAYBACK_RATE": "Vitesse de lecture",
   "QUALITY": "Qualité",
diff --git a/ui/locales/nl.json b/ui/locales/nl.json
index 6159a289ba..f13ee16241 100644
--- a/ui/locales/nl.json
+++ b/ui/locales/nl.json
@@ -37,7 +37,8 @@
   "ON": "Aan",
   "ORIGINAL_VERSION": "Originele versie",
   "PAUSE": "Onderbreken",
-  "PICTURE_IN_PICTURE": "Scherm-in-scherm",
+  "PICTURE_IN_PICTURE": "Picture-in-picture",
+  "PIP_WINDOW_ACTIVE": "Afspelen in picture-in-picture mode",
   "PLAY": "Afspelen",
   "PLAYBACK_RATE": "Afspeelsnelheid",
   "QUALITY": "Kwaliteit",
diff --git a/ui/locales/pl.json b/ui/locales/pl.json
index 7f418fb063..bc47ed0144 100644
--- a/ui/locales/pl.json
+++ b/ui/locales/pl.json
@@ -38,6 +38,7 @@
   "ORIGINAL_VERSION": "Wersja oryginalna",
   "PAUSE": "Wstrzymaj",
   "PICTURE_IN_PICTURE": "Obraz w obrazie",
+  "PIP_WINDOW_ACTIVE": "Odtwarzanie w trybie obrazu w obrazie",
   "PLAY": "Odtwórz",
   "PLAYBACK_RATE": "Szybkość odtwarzania",
   "QUALITY": "Jakość",

From 98a197d689fa02037b7d2e4ebcc236a2267555cc Mon Sep 17 00:00:00 2001
From: Shaka Translation Bot <joey.parrish+shaka-translation-bot@gmail.com>
Date: Thu, 28 May 2026 09:47:29 -0700
Subject: [PATCH 58/64] chore: Update Sindarin (sjn) locale (#10148)

Generated from https://github.com/joeyparrish/shaka-sjn-translation.

Translations made with Claude Code and
https://github.com/joeyparrish/elvish-translation-tools.

Source strings last updated 2026-05-12 (Shaka Player commit
415ebdc52e1d67729aba0fa89c1421885dbdcf66).

Translation status: 70/70 strings translated.

Preview: https://joeyparrish.github.io/shaka-sjn-translation/

Co-authored-by: Shaka Translation Bot <278545291+shaka-translation-bot@users.noreply.github.com>
---
 ui/locales/sjn.json | 72 +++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 72 insertions(+)
 create mode 100644 ui/locales/sjn.json

diff --git a/ui/locales/sjn.json b/ui/locales/sjn.json
new file mode 100644
index 0000000000..146e829289
--- /dev/null
+++ b/ui/locales/sjn.json
@@ -0,0 +1,72 @@
+{
+  "AD_DURATION": "\ue022\ue02c\ue04c \ue010\ue040 \ue028\ue025\ue040\ue000\ue02e\ue044\ue02e\ue046 \ue010\ue040 \ue011\ue020\ue044\ue02e\ue044\ue010\ue040",
+  "AD_PROGRESS": "\ue028\ue025\ue040\ue000\ue02e\ue044\ue02e\ue046 \ue010\ue040 \ue011\ue020\ue044\ue02e\ue044\ue010\ue040 [AD_ON] / [NUM_ADS]",
+  "AD_STATISTICS": "\ue028\ue025\ue040\ue000\ue02e\ue044\ue02e\ue046 \ue010\ue040 \ue011\ue020\ue044\ue02e\ue044\ue010\ue040 \ue024\ue010\ue044\ue02e\ue044\ue008\ue040",
+  "AD_TIME": "\ue028\ue025\ue040\ue000\ue02e\ue044\ue02e\ue046 \ue010\ue040 \ue011\ue020\ue044\ue02e\ue044\ue010\ue040: [AD_TIME]",
+  "AIRPLAY": "\ue011\ue010\ue046\ue022\ue046\ue010\ue020\ue04a\ue008\ue02e\ue04a",
+  "AUDIO_DESCRIPTION": "\ue024\ue010\ue044\ue02e\ue044\ue008\ue040 \ue007\ue022\ue011\ue044",
+  "AUTO_GENERATED": "\ue010\ue046\ue02e\ue044\ue025\ue040",
+  "AUTO_QUALITY": "\ue003\ue011\ue040\ue010\ue046",
+  "BACK": "\ue004\ue010\ue040",
+  "BOTTOM_CENTER": "\ue004\ue004\ue040 \ue010\ue046\ue004\ue046",
+  "BOTTOM_LEFT": "\ue004\ue004\ue040 \ue028\ue020\ue040\ue00d\ue02e\ue04a",
+  "BOTTOM_RIGHT": "\ue004\ue004\ue040 \ue009\ue020\ue04a\ue00d\ue02e\ue04a",
+  "BUFFERING": "\ue004\ue020\ue040\ue008\ue02e\ue04a",
+  "CAPTIONS": "\ue001\ue008\ue044 \ue000\ue016\ue046\ue008\ue010\ue050\ue046\ue010\ue044",
+  "CAST": "\ue028\ue004\ue040\ue02e\ue04a",
+  "CENTER": "\ue010\ue046\ue004\ue046",
+  "CENTER_LEFT": "\ue010\ue046\ue004\ue046 \ue028\ue020\ue040\ue00d\ue02e\ue04a",
+  "CENTER_RIGHT": "\ue010\ue046\ue004\ue046 \ue009\ue020\ue04a\ue00d\ue02e\ue04a",
+  "CHAPTERS": "\ue001\ue016\ue040\ue022\ue000",
+  "COPY_VIDEO_FRAME": "\ue011\ue005\ue040\ue02e\ue04a \ue009\ue010\ue040\ue015\ue025\ue04a",
+  "DEFAULT": "\ue011\ue010\ue044\ue016\ue04c",
+  "DOWNLOAD_VIDEO_FRAME": "\ue007\ue020\ue040\ue02e\ue04a \ue009\ue010\ue040\ue015\ue025\ue04a",
+  "ENTER_LOOP_MODE": "\ue011\ue010\ue050\ue044\ue02e\ue04a \ue025\ue04a\ue010\ue020\ue04a\ue008\ue004\ue040",
+  "ENTER_PICTURE_IN_PICTURE": "\ue011\ue010\ue050\ue044\ue02e\ue04a \ue009\ue010\ue040\ue015\ue025\ue04a \ue011\ue02e\ue044 \ue009\ue010\ue040\ue015\ue025\ue04a",
+  "EXIT_FULL_SCREEN": "\ue008\ue04c\ue020\ue02e\ue04a \ue009\ue010\ue040\ue015\ue025\ue04a \ue001\ue000\ue050\ue040",
+  "EXIT_LOOP_MODE": "\ue008\ue04c\ue020\ue02e\ue04a \ue025\ue04a\ue010\ue020\ue04a\ue008\ue004\ue040",
+  "EXIT_PICTURE_IN_PICTURE": "\ue008\ue04c\ue020\ue02e\ue04a \ue009\ue010\ue040\ue015\ue025\ue04a \ue011\ue02e\ue044 \ue009\ue010\ue040\ue015\ue025\ue04a",
+  "FAST_FORWARD": "\ue010\ue020\ue04a\ue008\ue02e\ue04a \ue022\ue011\ue044",
+  "FULL_SCREEN": "\ue009\ue010\ue040\ue015\ue025\ue04a \ue001\ue000\ue050\ue040",
+  "LANGUAGE": "\ue022\ue011\ue040",
+  "LIVE": "\ue003\ue02c\ue044\ue020\ue015\ue016\ue040\ue010",
+  "LOOP": "\ue025\ue04a\ue010\ue020\ue04a\ue008\ue02e\ue04a",
+  "MORE_SETTINGS": "\ue011\ue040 \ue003\ue022\ue044\ue008\ue044",
+  "MULTIPLE_LANGUAGES": "\ue022\ue011\ue040 \ue020\ue040\ue010\ue004\ue046\ue02e\ue044\ue004\ue040",
+  "MUTE": "\ue004\ue02c\ue044\ue010",
+  "NOT_APPLICABLE": "\ue02c\ue04c\ue00d\ue022\ue040\ue051",
+  "OFF": "\ue02c\ue04c\ue007\ue020\ue040\ue015\ue007\ue046",
+  "ON": "\ue003\ue020\ue040\ue015\ue007\ue046",
+  "ORIGINAL_VERSION": "\ue02a\ue015\ue040\ue014",
+  "PAUSE": "\ue004\ue020\ue040\ue02e\ue04a",
+  "PICTURE_IN_PICTURE": "\ue009\ue010\ue040\ue015\ue025\ue04a \ue011\ue02e\ue044 \ue009\ue010\ue040\ue015\ue025\ue04a",
+  "PLAY": "\ue010\ue020\ue04a\ue008\ue02e\ue04a",
+  "PLAYBACK_RATE": "\ue02e\ue044 \ue022\ue011\ue044",
+  "QUALITY": "\ue007\ue040\ue022\ue014\ue040",
+  "RECENTER_VR": "\ue010\ue046\ue004\ue046",
+  "REPLAY": "\ue004\ue040\ue010\ue020\ue04a\ue008\ue02e\ue04a",
+  "RESOLUTION": "\ue011\ue016\ue046\ue020\ue025\ue040",
+  "REWIND": "\ue010\ue020\ue04a\ue008\ue02e\ue04a \ue004\ue010\ue040",
+  "SEEK": "\ue003\ue025\ue046\ue000\ue02e\ue04a",
+  "SKIP_AD": "\ue003\ue005\ue040\ue02e\ue04a \ue008\ue014\ue040 \ue028\ue025\ue040\ue000\ue02e\ue044\ue02e\ue046 \ue010\ue040 \ue011\ue020\ue044\ue02e\ue044\ue010\ue040",
+  "SKIP_NEXT": "\ue003\ue005\ue040\ue02e\ue04a \ue005\ue040\ue014\ue04a",
+  "SKIP_PREVIOUS": "\ue003\ue005\ue040\ue02e\ue04a \ue004\ue010\ue040",
+  "SKIP_TO_LIVE": "\ue003\ue005\ue040\ue02e\ue04a \ue010\ue02e\ue040 \ue003\ue02c\ue044\ue020\ue015\ue016\ue040\ue010",
+  "STATISTICS": "\ue003\ue008\ue046\ue02e\ue04a \ue010\ue004\ue046\ue02e\ue044\ue004\ue040",
+  "SUBTITLES_EXAMPLE": "\ue024\ue016\ue04c \ue024\ue010\ue046",
+  "SUBTITLE_FORCED": "\ue001\ue008\ue044 \ue000\ue016\ue046\ue008\ue010\ue050\ue046\ue010\ue044 \ue000\ue015\ue040\ue007",
+  "SUBTITLE_POSITION": "\ue004\ue014\ue04a \ue001\ue008\ue044 \ue000\ue016\ue046\ue008\ue010\ue050\ue046\ue010\ue044",
+  "SUBTITLE_SIZE": "\ue004\ue02a\ue040\ue020\ue004\ue046 \ue001\ue008\ue044 \ue000\ue016\ue046\ue008\ue010\ue050\ue046\ue010\ue044",
+  "SURROUND": "\ue025\ue04a\ue000\ue02e\ue04a",
+  "TOGGLE_STEREOSCOPIC": "\ue008\ue040\ue020\ue044\ue004\ue040",
+  "TOP_CENTER": "\ue011\ue040 \ue010\ue046\ue004\ue046",
+  "TOP_LEFT": "\ue011\ue040 \ue028\ue020\ue040\ue00d\ue02e\ue04a",
+  "TOP_RIGHT": "\ue011\ue040 \ue009\ue020\ue04a\ue00d\ue02e\ue04a",
+  "UNDETERMINED_LANGUAGE": "\ue02c\ue04c\ue028\ue010\ue050\ue044\ue010\ue046",
+  "UNMUTE": "\ue023\ue02c\ue04a\ue010",
+  "UNRECOGNIZED_LANGUAGE": "\ue02c\ue04c\ue028\ue010\ue050\ue044\ue010\ue046",
+  "VIDEO_MAIN": "\ue011\ue016\ue040\ue010",
+  "VIDEO_SIGN": "\ue022\ue011\ue040 \ue000\ue016\ue040\ue008",
+  "VIDEO_TYPE": "\ue010\ue027\ue04a \ue009\ue010\ue040\ue015\ue025\ue04a",
+  "VOLUME": "\ue005\ue020\ue016\ue04c"
+}

From 686d550a3a774e2e8c747adae0d4fa58438c61d1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C3=81lvaro=20Velad=20Galv=C3=A1n?= <ladvan91@hotmail.com>
Date: Thu, 28 May 2026 20:45:43 +0200
Subject: [PATCH 59/64] feat(UI): Modernize the statistics panel (#10144)

New design:
<img width="866" height="733" alt="Design"
src="https://github.com/user-attachments/assets/403c2ece-3ee0-46de-a310-a1f6adae8929"
/>
---
 test/ui/ui_unit.js         |  42 +++++++---
 ui/ad_statistics_button.js |  49 ++++++++----
 ui/less/containers.less    | 114 +++++++++++++++++----------
 ui/statistics_button.js    | 157 ++++++++++++++++++++++++++++++++++---
 ui/ui.js                   |   2 +
 5 files changed, 284 insertions(+), 80 deletions(-)

diff --git a/test/ui/ui_unit.js b/test/ui/ui_unit.js
index 155fb8ada3..dc9838d08f 100644
--- a/test/ui/ui_unit.js
+++ b/test/ui/ui_unit.js
@@ -1290,22 +1290,40 @@ describe('UI', () => {
 
       it('displays all the available statistics', () => {
         const skippedStats = ['stateHistory', 'switchHistory'];
-        const nodes = statisticsContainer.childNodes;
-        // First index is close button.
-        let nodeIndex = 1;
 
-        for (const statistic in new shaka.util.Stats().getBlob()) {
-          if (!skippedStats.includes(statistic)) {
-            // Text content of label (without ':') is a valid statistic
-            const label = nodes[nodeIndex].childNodes[0].textContent;
-            expect(label.replace(':', '')).toBe(statistic);
+        /**
+         * Returns the stat node by label name.
+         * @param {string} name
+         * @return {?Node}
+         */
+        function getStatsElementByName(name) {
+          const nodes = statisticsContainer.childNodes;
+
+          for (const node of nodes) {
+            if (node.hasChildNodes() &&
+                node.childNodes.length >= 2 &&
+                node.childNodes[0].textContent.replace(':', '') == name) {
+              return node;
+            }
+          }
 
-            // Value has been parsed and it is not the default 'NaN'
-            const value = nodes[nodeIndex].childNodes[1].textContent;
-            expect(value).not.toBe('NaN');
+          return null;
+        }
 
-            nodeIndex += 1;
+        for (const statistic in new shaka.util.Stats().getBlob()) {
+          if (skippedStats.includes(statistic)) {
+            continue;
           }
+
+          const node = getStatsElementByName(statistic);
+
+          expect(node).not.toBe(null);
+
+          const label = node.childNodes[0].textContent;
+          expect(label.replace(':', '')).toBe(statistic);
+
+          const value = node.childNodes[1].textContent;
+          expect(value).not.toBe('NaN');
         }
       });
 
diff --git a/ui/ad_statistics_button.js b/ui/ad_statistics_button.js
index 9f6a388c4a..f834ceac91 100644
--- a/ui/ad_statistics_button.js
+++ b/ui/ad_statistics_button.js
@@ -83,6 +83,10 @@ shaka.ui.AdStatisticsButton = class extends shaka.ui.Element {
     /** @private {!Map<string, HTMLElement>} */
     this.displayedElements_ = new Map();
 
+    /** @private {!HTMLElement} */
+    this.headerTitle_ = shaka.util.Dom.createHTMLElement('span');
+    this.headerTitle_.classList.add('shaka-statistics-title');
+
     const parseLoadTimes = (name) => {
       let totalTime = 0;
       const loadTimes =
@@ -109,13 +113,9 @@ shaka.ui.AdStatisticsButton = class extends shaka.ui.Element {
 
     /** @private {shaka.util.Timer} */
     this.timer_ = new shaka.util.Timer(() => {
-      this.onTimerTick_();
+      this.updateStats_();
     });
 
-    this.updateLocalizedStrings();
-
-    this.loadContainer_();
-
     this.eventManager.listen(this.button_, 'click', () => {
       if (!this.controls.isOpaque()) {
         return;
@@ -125,13 +125,20 @@ shaka.ui.AdStatisticsButton = class extends shaka.ui.Element {
     });
 
     this.eventManager.listen(this.player, 'loading', () => {
-      shaka.ui.Utils.setDisplay(this.button_, false);
+      this.updateStats_();
+      this.checkAvailability();
     });
 
     this.eventManager.listen(
         this.adManager, shaka.ads.Utils.AD_STARTED, () => {
-          shaka.ui.Utils.setDisplay(this.button_, true);
+          this.updateStats_();
+          this.checkAvailability();
         });
+
+    this.updateLocalizedStrings();
+    this.updateStats_();
+    this.loadContainer_();
+    this.checkAvailability();
   }
 
   /** @private */
@@ -156,6 +163,9 @@ shaka.ui.AdStatisticsButton = class extends shaka.ui.Element {
     this.nameSpan_.textContent =
         this.localization.resolve(LocIds.AD_STATISTICS);
 
+    this.headerTitle_.textContent =
+        this.localization.resolve(LocIds.AD_STATISTICS);
+
     this.button_.ariaLabel = this.localization.resolve(LocIds.AD_STATISTICS);
 
     const labelText = this.container_.classList.contains('shaka-hidden') ?
@@ -165,9 +175,15 @@ shaka.ui.AdStatisticsButton = class extends shaka.ui.Element {
 
   /** @override */
   checkAvailability() {
-    shaka.ui.Utils.setDisplay(
-        this.button_,
-        !this.isSubMenuOpened && this.currentStats_.started > 0);
+    const hasStats = this.currentStats_.started > 0 ||
+        this.currentStats_.overlayAds > 0 ||
+        this.currentStats_.playedCompletely > 0 ||
+        this.currentStats_.skipped > 0 ||
+        this.currentStats_.errors > 0;
+    shaka.ui.Utils.setDisplay(this.button_, !this.isSubMenuOpened && hasStats);
+    if (hasStats && !this.container_.classList.contains('shaka-hidden')) {
+      this.onClick_();
+    }
   }
 
   /**
@@ -193,15 +209,16 @@ shaka.ui.AdStatisticsButton = class extends shaka.ui.Element {
 
   /** @private */
   loadContainer_() {
-    const closeElement = shaka.util.Dom.createHTMLElement('div');
-    closeElement.classList.add('shaka-no-propagation');
-    closeElement.classList.add('shaka-statistics-close');
-    const icon = new shaka.ui.Icon(closeElement,
+    const header = shaka.util.Dom.createHTMLElement('div');
+    header.classList.add('shaka-statistics-header');
+    header.classList.add('shaka-no-propagation');
+    header.appendChild(this.headerTitle_);
+    const icon = new shaka.ui.Icon(header,
         shaka.ui.Enums.MaterialDesignSVGIcons['CLOSE']);
     const iconElement = icon.getSvgElement();
     iconElement.classList.add('material-icons', 'notranslate');
 
-    this.container_.appendChild(closeElement);
+    this.container_.appendChild(header);
     this.eventManager.listen(iconElement, 'click', () => {
       this.onClick_();
     });
@@ -216,7 +233,7 @@ shaka.ui.AdStatisticsButton = class extends shaka.ui.Element {
   }
 
   /** @private */
-  onTimerTick_() {
+  updateStats_() {
     this.currentStats_ = this.adManager.getStats();
 
     for (const name of this.statisticsList_) {
diff --git a/ui/less/containers.less b/ui/less/containers.less
index 76179f22c0..323aa94971 100644
--- a/ui/less/containers.less
+++ b/ui/less/containers.less
@@ -463,80 +463,114 @@
   display: none;
 }
 
-.shaka-statistics-container {
+.shaka-statistics-container,
+.shaka-ad-statistics-container {
   overflow-x: hidden;
   overflow-y: auto;
 
-  scrollbar-color: @general-font-color @general-background-color;
+  scrollbar-color: rgba(255, 255, 255, 15%) transparent;
   scrollbar-width: thin;
 
-  min-width: 300px;
-
   color: @general-font-color;
-  background-color: rgba(35, 35, 35, 90%);
+  background-color: rgba(12, 14, 18, 88%);
+  border: 1px solid rgba(255, 255, 255, 8%);
+  box-shadow: 0 4px 24px rgba(0, 0, 0, 50%);
 
   font-size: @general-font-size;
+  font-family: monospace;
 
-  padding: 5px 10px;
-  border-radius: 2px;
+  padding: 0;
+  border-radius: 10px;
 
   position: absolute;
   z-index: 2;
-  left: 15px;
   top: 15px;
 
   max-height: calc(100% - 115px);
 
-  /* Fades out with the other controls. */
   .show-when-controls-shown();
 
-  div {
+  /* Header bar (close button row) */
+  .shaka-statistics-header {
     display: flex;
+    align-items: center;
     justify-content: space-between;
+    padding: 10px 14px 8px;
+    border-bottom: 1px solid rgba(255, 255, 255, 7%);
+
+    svg {
+      width: 16px;
+      height: 16px;
+      opacity: 0.35;
+      cursor: pointer;
+      transition: opacity 0.15s;
+
+      &:hover {
+        opacity: 1;
+      }
+    }
   }
 
-  span {
-    color: rgb(150, 150, 150);
+  /* Section group labels */
+  .shaka-statistics-section-label {
+    display: block;
+    padding: 8px 14px 3px;
+    font-size: 9px;
+    font-weight: 600;
+    letter-spacing: 0.16em;
+    text-transform: uppercase;
+    color: rgba(255, 255, 255, 70%);
   }
-}
 
-.shaka-ad-statistics-container {
-  overflow-x: hidden;
-  overflow-y: auto;
-
-  scrollbar-color: @general-font-color @general-background-color;
-  scrollbar-width: thin;
-
-  min-width: 150px;
-
-  color: @general-font-color;
-  background-color: rgba(35, 35, 35, 90%);
-
-  font-size: @general-font-size;
-
-  padding: 5px 10px;
-  border-radius: 2px;
-
-  position: absolute;
-  z-index: 2;
-  right: 15px;
-  top: 15px;
-
-  max-height: calc(100% - 115px);
-
-  /* Fades out with the other controls. */
-  .show-when-controls-shown();
+  /* Dividers between groups */
+  .shaka-statistics-divider {
+    display: block;
+    height: 1px;
+    background: rgba(255, 255, 255, 6%);
+    margin: 6px 14px;
+    padding: 0;
+  }
 
+  /* Stat rows */
   div {
     display: flex;
     justify-content: space-between;
+    align-items: center;
+    padding: 3px 14px;
+    gap: 16px;
+    transition: background 0.1s;
+
+    &:hover {
+      background: rgba(255, 255, 255, 3%);
+    }
+  }
+
+  /* Row labels */
+  label {
+    font-size: 11px;
+    color: rgba(255, 255, 255, 45%);
+    white-space: nowrap;
   }
 
+  /* Row values */
   span {
-    color: rgb(150, 150, 150);
+    font-size: 11px;
+    color: rgba(255, 255, 255, 90%);
+    font-variant-numeric: tabular-nums;
+    text-align: right;
   }
 }
 
+.shaka-statistics-container {
+  min-width: 280px;
+  left: 15px;
+}
+
+.shaka-ad-statistics-container {
+  min-width: 220px;
+  right: 15px;
+}
+
 .shaka-scrim-container {
   margin: 0;
   width: 100%;
diff --git a/ui/statistics_button.js b/ui/statistics_button.js
index 926d57496e..6561befb51 100644
--- a/ui/statistics_button.js
+++ b/ui/statistics_button.js
@@ -83,6 +83,9 @@ shaka.ui.StatisticsButton = class extends shaka.ui.Element {
     /** @private {!Map<string, HTMLElement>} */
     this.displayedElements_ = new Map();
 
+    /** @private {!HTMLElement} */
+    this.headerTitle_ = shaka.util.Dom.createHTMLElement('span');
+    this.headerTitle_.classList.add('shaka-statistics-title');
 
     const parsePx = (name) => {
       return this.currentStats_[name] + ' (px)';
@@ -173,7 +176,7 @@ shaka.ui.StatisticsButton = class extends shaka.ui.Element {
 
     /** @private {shaka.util.Timer} */
     this.timer_ = new shaka.util.Timer(() => {
-      this.onTimerTick_();
+      this.updateStats_();
     });
 
     this.updateLocalizedStrings();
@@ -208,6 +211,9 @@ shaka.ui.StatisticsButton = class extends shaka.ui.Element {
     this.nameSpan_.textContent =
         this.localization.resolve(LocIds.STATISTICS);
 
+    this.headerTitle_.textContent =
+        this.localization.resolve(LocIds.STATISTICS);
+
     this.button_.ariaLabel = this.localization.resolve(LocIds.STATISTICS);
 
     const labelText = this.container_.classList.contains('shaka-hidden') ?
@@ -238,30 +244,157 @@ shaka.ui.StatisticsButton = class extends shaka.ui.Element {
 
   /** @private */
   loadContainer_() {
-    const closeElement = shaka.util.Dom.createHTMLElement('div');
-    closeElement.classList.add('shaka-no-propagation');
-    closeElement.classList.add('shaka-statistics-close');
-    const icon = new shaka.ui.Icon(closeElement,
+    const header = shaka.util.Dom.createHTMLElement('div');
+    header.classList.add('shaka-statistics-header');
+    header.classList.add('shaka-no-propagation');
+    header.appendChild(this.headerTitle_);
+    const icon = new shaka.ui.Icon(header,
         shaka.ui.Enums.MaterialDesignSVGIcons['CLOSE']);
     const iconElement = icon.getSvgElement();
     iconElement.classList.add('material-icons', 'notranslate');
-    this.container_.appendChild(closeElement);
+    this.container_.appendChild(header);
     this.eventManager.listen(iconElement, 'click', () => {
       this.onClick_();
     });
-    for (const name of this.controls.getConfig().statisticsList) {
-      if (name in this.currentStats_ && !this.skippedStats_.includes(name)) {
-        const element = this.generateComponent_(name);
-        this.container_.appendChild(element);
+
+    /**
+     * @const {!Array<{label: string, stats: !Array<string>}>}
+     */
+    const groups = [
+      {
+        label: 'Video',
+        stats: [
+          'width',
+          'height',
+          'currentCodecs',
+        ],
+      },
+      {
+        label: 'Network',
+        stats: [
+          'estimatedBandwidth',
+          'streamBandwidth',
+          'maxSegmentDuration',
+          'bytesDownloaded',
+        ],
+      },
+      {
+        label: 'Load',
+        stats: [
+          'loadLatency',
+          'timeToFirstFrame',
+          'manifestTimeSeconds',
+          'drmTimeSeconds',
+          'licenseTime',
+        ],
+      },
+      {
+        label: 'Playback',
+        stats: [
+          'playTime',
+          'pauseTime',
+          'bufferingTime',
+          'liveLatency',
+          'completionPercent',
+        ],
+      },
+      {
+        label: 'Frames',
+        stats: [
+          'decodedFrames',
+          'droppedFrames',
+          'corruptedFrames',
+        ],
+      },
+      {
+        label: 'Stability',
+        stats: [
+          'stallsDetected',
+          'gapsJumped',
+          'nonFatalErrorCount',
+        ],
+      },
+      {
+        label: 'Manifest',
+        stats: [
+          'manifestSizeBytes',
+          'manifestPeriodCount',
+          'manifestGapCount',
+        ],
+      },
+    ];
+
+    const configList = this.controls.getConfig().statisticsList;
+
+    /** @type {!Set<string>} Track which stats have already been rendered */
+    const rendered = new Set();
+
+    /** @param {string} labelText */
+    const appendSectionLabel = (labelText) => {
+      const el = shaka.util.Dom.createHTMLElement('div');
+      el.classList.add('shaka-statistics-section-label');
+      el.textContent = labelText;
+      this.container_.appendChild(el);
+    };
+
+    const appendDivider = () => {
+      const el = shaka.util.Dom.createHTMLElement('div');
+      el.classList.add('shaka-statistics-divider');
+      this.container_.appendChild(el);
+    };
+
+    let firstGroup = true;
+
+    for (const group of groups) {
+      // Only render stats that the integrator has configured AND that the
+      // player is actually reporting (skipping stateHistory / switchHistory).
+      const groupStats = group.stats.filter((name) =>
+        configList.includes(name) &&
+        name in this.currentStats_ &&
+        !this.skippedStats_.includes(name));
+
+      if (groupStats.length === 0) {
+        continue;
+      }
+
+      if (!firstGroup) {
+        appendDivider();
+      }
+      firstGroup = false;
+
+      appendSectionLabel(group.label);
+
+      for (const name of groupStats) {
+        this.container_.appendChild(this.generateComponent_(name));
         this.statisticsList_.push(name);
-      } else {
+        rendered.add(name);
+      }
+    }
+
+    // Any configured stat not covered by the groups above goes into 'Other'.
+    const remaining = configList.filter((name) =>
+      !rendered.has(name) &&
+      name in this.currentStats_ &&
+      !this.skippedStats_.includes(name));
+
+    if (remaining.length > 0) {
+      appendDivider();
+      appendSectionLabel('Other');
+      for (const name of remaining) {
+        this.container_.appendChild(this.generateComponent_(name));
+        this.statisticsList_.push(name);
+      }
+    }
+
+    for (const name of configList) {
+      if (!(name in this.currentStats_)) {
         shaka.log.alwaysWarn('Unrecognized statistic element:', name);
       }
     }
   }
 
   /** @private */
-  onTimerTick_() {
+  updateStats_() {
     this.currentStats_ = this.player.getStats();
 
     for (const name of this.statisticsList_) {
diff --git a/ui/ui.js b/ui/ui.js
index e49a8d05d7..0ac6f75cc8 100644
--- a/ui/ui.js
+++ b/ui/ui.js
@@ -345,6 +345,8 @@ shaka.ui.Overlay = class {
         'nonFatalErrorCount',
         'manifestPeriodCount',
         'manifestGapCount',
+        'gapsJumped',
+        'stallsDetected',
       ],
       adStatisticsList: [
         'loadTimes',

From 52e7da0be9e61c9c1ed92df68df3ccc6df2b2a70 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C3=81lvaro=20Velad=20Galv=C3=A1n?= <ladvan91@hotmail.com>
Date: Thu, 28 May 2026 21:27:26 +0200
Subject: [PATCH 60/64] build(UI): Migrate CSS pipeline to PostCSS for
 prefixing and optimization (#10146)

- Add postcss-cli, autoprefixer, and cssnano to the build pipeline.
- Remove legacy '--clean-css' minification from the lessc step.
- Configure BROWSERSLIST env var for Chrome 38, Safari 8 and Firefox 42.
- Clean up redundant vendor prefixes (-webkit-, -moz-, etc.) from LESS
files.

Related to https://github.com/shaka-project/shaka-player/issues/10145
---
 build/compiler.py       |   22 +-
 package-lock.json       | 2259 ++++++++++++++++++++++++++++++++++++---
 package.json            |    5 +-
 project-words.txt       |    2 +
 ui/less/containers.less |    4 -
 ui/less/general.less    |    3 -
 ui/less/tooltip.less    |    4 -
 7 files changed, 2129 insertions(+), 170 deletions(-)

diff --git a/build/compiler.py b/build/compiler.py
index 4182152a0e..4652215d5f 100644
--- a/build/compiler.py
+++ b/build/compiler.py
@@ -329,7 +329,7 @@ def __init__(self, main_source_file, all_source_files, output):
 
   def compile(self, force=False):
     """Compiles the main less file in |self.main_source_file| into the
-       |self.output| css file.
+       |self.output| css file and applies PostCSS Autoprefixer.
 
     Args:
       force: Generate the output even if the inputs have not changed.
@@ -342,8 +342,6 @@ def compile(self, force=False):
 
     lessc = shakaBuildHelpers.get_node_binary('less', 'lessc')
     less_options = [
-      # Enable the "clean-CSS" plugin to minify the output and strip out comments.
-      '--clean-css',
       # Output a source map of the original CSS/less files.
       '--source-map=' + self.output + '.map',
     ]
@@ -354,6 +352,24 @@ def compile(self, force=False):
       logging.error('CSS compilation failed')
       return False
 
+    # We look for the PostCSS binary within node_modules/postcss-cli
+    postcss = shakaBuildHelpers.get_node_binary('postcss-cli', 'postcss')
+    postcss_options = [
+      self.output,
+      '-o', self.output,
+      '--use', 'autoprefixer',
+      '--use', 'cssnano',
+      '--map',
+    ]
+
+    # We define the specific browsers using the environment variable. These are
+    # the minimum browsers that the UI supports.
+    os.environ['BROWSERSLIST'] = 'chrome 38, safari 8, firefox 42'
+
+    if shakaBuildHelpers.execute_get_code(postcss + postcss_options) != 0:
+      logging.error('PostCSS / Autoprefixer processing failed')
+      return False
+
     # We need to prepend the license header to the compiled CSS.
     with open(_get_source_path('build/license-header'), 'rb') as f:
       license_header = f.read()
diff --git a/package-lock.json b/package-lock.json
index 8db1ea9766..46bfcd8ee2 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -16,6 +16,7 @@
         "@joeyparrish/karma-babel-preprocessor": "^8.2.0",
         "@stylistic/eslint-plugin-js": "^4.2.0",
         "@teppeis/clutz": "^1.0.29-4c95e12.v20190929",
+        "autoprefixer": "^10.5.0",
         "awesomplete": "^1.1.5",
         "babel-plugin-istanbul": "^6.1.1",
         "cajon": "^0.4.4",
@@ -24,6 +25,7 @@
         "color-themes-for-google-code-prettify": "^2.0.4",
         "core-js": "^3.21.1",
         "cspell": "^8.17.1",
+        "cssnano": "^8.0.1",
         "dialog-polyfill": "^0.5.6",
         "es6-promise-polyfill": "^1.2.0",
         "eslint": "^9.18.0",
@@ -51,9 +53,10 @@
         "karma-webdriver-launcher": "^1.0.8",
         "lcevc_dec.js": "^1.3.0",
         "less": "^4.2.0",
-        "less-plugin-clean-css": "^1.6.0",
         "material-design-lite": "^1.3.0",
         "open-sans-fonts": "^1.6.2",
+        "postcss": "^8.5.15",
+        "postcss-cli": "^11.0.1",
         "postcss-less": "^6.0.0",
         "pwacompat": "^2.0.17",
         "rimraf": "^3.0.2",
@@ -1649,6 +1652,13 @@
         "node": ">=6.9.0"
       }
     },
+    "node_modules/@colordx/core": {
+      "version": "5.4.3",
+      "resolved": "https://registry.npmjs.org/@colordx/core/-/core-5.4.3.tgz",
+      "integrity": "sha512-kIxYSfA5T8HXjav55UaaH/o/cKivF6jCCGIb8eqtcsfI46wsvlSiT8jMDyrl779qLec3c2c2oHBZo4oAhvbjrQ==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/@colors/colors": {
       "version": "1.5.0",
       "resolved": "https://registry.npmjs.org/@colors/colors/-/colors-1.5.0.tgz",
@@ -3373,6 +3383,43 @@
       "integrity": "sha1-x57Zf380y48robyXkLzDZkdLS3k=",
       "dev": true
     },
+    "node_modules/autoprefixer": {
+      "version": "10.5.0",
+      "resolved": "https://registry.npmjs.org/autoprefixer/-/autoprefixer-10.5.0.tgz",
+      "integrity": "sha512-FMhOoZV4+qR6aTUALKX2rEqGG+oyATvwBt9IIzVR5rMa2HRWPkxf+P+PAJLD1I/H5/II+HuZcBJYEFBpq39ong==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/postcss/"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/autoprefixer"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "browserslist": "^4.28.2",
+        "caniuse-lite": "^1.0.30001787",
+        "fraction.js": "^5.3.4",
+        "picocolors": "^1.1.1",
+        "postcss-value-parser": "^4.2.0"
+      },
+      "bin": {
+        "autoprefixer": "bin/autoprefixer"
+      },
+      "engines": {
+        "node": "^10 || ^12 || >=14"
+      },
+      "peerDependencies": {
+        "postcss": "^8.1.0"
+      }
+    },
     "node_modules/awesomplete": {
       "version": "1.1.5",
       "resolved": "https://registry.npmjs.org/awesomplete/-/awesomplete-1.1.5.tgz",
@@ -3493,6 +3540,19 @@
         "node": "^4.5.0 || >= 5.9"
       }
     },
+    "node_modules/baseline-browser-mapping": {
+      "version": "2.10.32",
+      "resolved": "https://registry.npmjs.org/baseline-browser-mapping/-/baseline-browser-mapping-2.10.32.tgz",
+      "integrity": "sha512-wbPvpyjJPC0zdfdKXxqEL3Ea+bOMD/87X4lftiJkkaBiuG6ALQy1SLmEd7BSmVCuwCQsBrCamgBoLyfFDD1EPg==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "bin": {
+        "baseline-browser-mapping": "dist/cli.cjs"
+      },
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
     "node_modules/bcrypt-pbkdf": {
       "version": "1.0.2",
       "resolved": "https://registry.npmjs.org/bcrypt-pbkdf/-/bcrypt-pbkdf-1.0.2.tgz",
@@ -3585,6 +3645,13 @@
         "node": ">= 0.8"
       }
     },
+    "node_modules/boolbase": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/boolbase/-/boolbase-1.0.0.tgz",
+      "integrity": "sha512-JZOSA7Mo9sNGB8+UjSgzdLtokWAky1zbztM3WRLCbZ70/3cTANmQmOdR7y2g+J0e2WXywy1yS468tY+IruqEww==",
+      "dev": true,
+      "license": "ISC"
+    },
     "node_modules/brace-expansion": {
       "version": "1.1.11",
       "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz",
@@ -3608,26 +3675,37 @@
       }
     },
     "node_modules/browserslist": {
-      "version": "4.19.1",
-      "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.19.1.tgz",
-      "integrity": "sha512-u2tbbG5PdKRTUoctO3NBD8FQ5HdPh1ZXPHzp1rwaa5jTc+RV9/+RlWiAIKmjRPQF+xbGM9Kklj5bZQFa2s/38A==",
+      "version": "4.28.2",
+      "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.28.2.tgz",
+      "integrity": "sha512-48xSriZYYg+8qXna9kwqjIVzuQxi+KYWp2+5nCYnYKPTr0LvD89Jqk2Or5ogxz0NUMfIjhh2lIUX/LyX9B4oIg==",
       "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/browserslist"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/browserslist"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
       "dependencies": {
-        "caniuse-lite": "^1.0.30001286",
-        "electron-to-chromium": "^1.4.17",
-        "escalade": "^3.1.1",
-        "node-releases": "^2.0.1",
-        "picocolors": "^1.0.0"
+        "baseline-browser-mapping": "^2.10.12",
+        "caniuse-lite": "^1.0.30001782",
+        "electron-to-chromium": "^1.5.328",
+        "node-releases": "^2.0.36",
+        "update-browserslist-db": "^1.2.3"
       },
       "bin": {
         "browserslist": "cli.js"
       },
       "engines": {
         "node": "^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/browserslist"
       }
     },
     "node_modules/buffer": {
@@ -3744,16 +3822,40 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/caniuse-lite": {
-      "version": "1.0.30001312",
-      "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001312.tgz",
-      "integrity": "sha512-Wiz1Psk2MEK0pX3rUzWaunLTZzqS2JYZFzNKqAiJGiuxIjRPLgV6+VDPOg6lQOUxmDwhTlh198JsTTi8Hzw6aQ==",
+    "node_modules/caniuse-api": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/caniuse-api/-/caniuse-api-3.0.0.tgz",
+      "integrity": "sha512-bsTwuIg/BZZK/vreVTYYbSWoe2F+71P7K5QGEX+pT250DZbfU1MQ5prOKpPR+LL6uWKK3KMwMCAS74QB3Um1uw==",
       "dev": true,
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/browserslist"
+      "license": "MIT",
+      "dependencies": {
+        "browserslist": "^4.0.0",
+        "caniuse-lite": "^1.0.0",
+        "lodash.memoize": "^4.1.2",
+        "lodash.uniq": "^4.5.0"
       }
     },
+    "node_modules/caniuse-lite": {
+      "version": "1.0.30001793",
+      "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001793.tgz",
+      "integrity": "sha512-iwSsYWaCOoh26cV8NwNRViHlrfUvYsHDfRVcbtmw0Kg6PJIZZXwMkj1442FYLBGkeUf1juAsU3DTfxW579mrPA==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/browserslist"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/caniuse-lite"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "CC-BY-4.0"
+    },
     "node_modules/caseless": {
       "version": "0.12.0",
       "resolved": "https://registry.npmjs.org/caseless/-/caseless-0.12.0.tgz",
@@ -3849,18 +3951,6 @@
         "node": ">= 6"
       }
     },
-    "node_modules/clean-css": {
-      "version": "5.3.3",
-      "resolved": "https://registry.npmjs.org/clean-css/-/clean-css-5.3.3.tgz",
-      "integrity": "sha512-D5J+kHaVb/wKSFcyyV75uCn8fiY4sV38XJoe4CUyGQ+mOU/fMVYUdH1hJC+CJQ5uY3EnW27SbJYS4X8BiLrAFg==",
-      "dev": true,
-      "dependencies": {
-        "source-map": "~0.6.0"
-      },
-      "engines": {
-        "node": ">= 10.0"
-      }
-    },
     "node_modules/clean-package": {
       "version": "2.2.0",
       "resolved": "https://registry.npmjs.org/clean-package/-/clean-package-2.2.0.tgz",
@@ -4512,6 +4602,50 @@
         "node": ">=12.22"
       }
     },
+    "node_modules/css-select": {
+      "version": "5.2.2",
+      "resolved": "https://registry.npmjs.org/css-select/-/css-select-5.2.2.tgz",
+      "integrity": "sha512-TizTzUddG/xYLA3NXodFM0fSbNizXjOKhqiQQwvhlspadZokn1KDy0NZFS0wuEubIYAV5/c1/lAr0TaaFXEXzw==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "boolbase": "^1.0.0",
+        "css-what": "^6.1.0",
+        "domhandler": "^5.0.2",
+        "domutils": "^3.0.1",
+        "nth-check": "^2.0.1"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/fb55"
+      }
+    },
+    "node_modules/css-tree": {
+      "version": "3.2.1",
+      "resolved": "https://registry.npmjs.org/css-tree/-/css-tree-3.2.1.tgz",
+      "integrity": "sha512-X7sjQzceUhu1u7Y/ylrRZFU2FS6LRiFVp6rKLPg23y3x3c3DOKAwuXGDp+PAGjh6CSnCjYeAul8pcT8bAl+lSA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "mdn-data": "2.27.1",
+        "source-map-js": "^1.2.1"
+      },
+      "engines": {
+        "node": "^10 || ^12.20.0 || ^14.13.0 || >=15.0.0"
+      }
+    },
+    "node_modules/css-what": {
+      "version": "6.2.2",
+      "resolved": "https://registry.npmjs.org/css-what/-/css-what-6.2.2.tgz",
+      "integrity": "sha512-u/O3vwbptzhMs3L1fQE82ZSLHQQfto5gyZzwteVIEyeaY5Fc7R4dapF/BvRoSYFeqfBk4m0V1Vafq5Pjv25wvA==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">= 6"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/fb55"
+      }
+    },
     "node_modules/cssesc": {
       "version": "3.0.0",
       "resolved": "https://registry.npmjs.org/cssesc/-/cssesc-3.0.0.tgz",
@@ -4524,6 +4658,120 @@
         "node": ">=4"
       }
     },
+    "node_modules/cssnano": {
+      "version": "8.0.1",
+      "resolved": "https://registry.npmjs.org/cssnano/-/cssnano-8.0.1.tgz",
+      "integrity": "sha512-oSiOnPQNNYjusTUlYJiE6xvFQG4don3N0QavaoV1BxIsC1zjvxOwikXlR7lG1EVmZNDDaJkHbQx1VRB8kaoMHA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "cssnano-preset-default": "^8.0.1",
+        "lilconfig": "^3.1.3"
+      },
+      "engines": {
+        "node": "^22.11.0 || ^24.11.0 || >=26.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/cssnano"
+      },
+      "peerDependencies": {
+        "postcss": "^8.5.14"
+      }
+    },
+    "node_modules/cssnano-preset-default": {
+      "version": "8.0.1",
+      "resolved": "https://registry.npmjs.org/cssnano-preset-default/-/cssnano-preset-default-8.0.1.tgz",
+      "integrity": "sha512-OTdKeYMlvQ8KBgyej5ysktnWJoeyo7rGrVnm+bdpIHGvxhbTGPsOkB+7T1EdTuX00dGlQQb2UEbSPB1OpMXULw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "browserslist": "^4.28.2",
+        "cssnano-utils": "^6.0.0",
+        "postcss-calc": "^10.1.1",
+        "postcss-colormin": "^8.0.0",
+        "postcss-convert-values": "^8.0.0",
+        "postcss-discard-comments": "^8.0.0",
+        "postcss-discard-duplicates": "^8.0.0",
+        "postcss-discard-empty": "^8.0.0",
+        "postcss-discard-overridden": "^8.0.0",
+        "postcss-merge-longhand": "^8.0.0",
+        "postcss-merge-rules": "^8.0.0",
+        "postcss-minify-font-values": "^8.0.0",
+        "postcss-minify-gradients": "^8.0.0",
+        "postcss-minify-params": "^8.0.0",
+        "postcss-minify-selectors": "^8.0.1",
+        "postcss-normalize-charset": "^8.0.0",
+        "postcss-normalize-display-values": "^8.0.0",
+        "postcss-normalize-positions": "^8.0.0",
+        "postcss-normalize-repeat-style": "^8.0.0",
+        "postcss-normalize-string": "^8.0.0",
+        "postcss-normalize-timing-functions": "^8.0.0",
+        "postcss-normalize-unicode": "^8.0.0",
+        "postcss-normalize-url": "^8.0.0",
+        "postcss-normalize-whitespace": "^8.0.0",
+        "postcss-ordered-values": "^8.0.0",
+        "postcss-reduce-initial": "^8.0.0",
+        "postcss-reduce-transforms": "^8.0.0",
+        "postcss-svgo": "^8.0.0",
+        "postcss-unique-selectors": "^8.0.0"
+      },
+      "engines": {
+        "node": "^22.11.0 || ^24.11.0 || >=26.0"
+      },
+      "peerDependencies": {
+        "postcss": "^8.5.14"
+      }
+    },
+    "node_modules/cssnano-utils": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/cssnano-utils/-/cssnano-utils-6.0.0.tgz",
+      "integrity": "sha512-ztS9W/+uaDn+bkYmDhs+GdMveHJ3CL8IPNHpRqDUQXv5GJOTQAJjV1XUOInr9esLXSabQV1pLRZlJpyUwEqDyQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^22.11.0 || ^24.11.0 || >=26.0"
+      },
+      "peerDependencies": {
+        "postcss": "^8.5.14"
+      }
+    },
+    "node_modules/csso": {
+      "version": "5.0.5",
+      "resolved": "https://registry.npmjs.org/csso/-/csso-5.0.5.tgz",
+      "integrity": "sha512-0LrrStPOdJj+SPCCrGhzryycLjwcgUSHBtxNA8aIDxf0GLsRh1cKYhB00Gd1lDOS4yGH69+SNn13+TWbVHETFQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "css-tree": "~2.2.0"
+      },
+      "engines": {
+        "node": "^10 || ^12.20.0 || ^14.13.0 || >=15.0.0",
+        "npm": ">=7.0.0"
+      }
+    },
+    "node_modules/csso/node_modules/css-tree": {
+      "version": "2.2.1",
+      "resolved": "https://registry.npmjs.org/css-tree/-/css-tree-2.2.1.tgz",
+      "integrity": "sha512-OA0mILzGc1kCOCSJerOeqDxDQ4HOh+G8NbOJFOTgOCzpw7fCBubk0fEyxp8AgOL/jvLgYA/uV0cMbe43ElF1JA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "mdn-data": "2.0.28",
+        "source-map-js": "^1.0.1"
+      },
+      "engines": {
+        "node": "^10 || ^12.20.0 || ^14.13.0 || >=15.0.0",
+        "npm": ">=7.0.0"
+      }
+    },
+    "node_modules/csso/node_modules/mdn-data": {
+      "version": "2.0.28",
+      "resolved": "https://registry.npmjs.org/mdn-data/-/mdn-data-2.0.28.tgz",
+      "integrity": "sha512-aylIc7Z9y4yzHYAJNuESG3hfhC+0Ibp/MAMiaOZgNv4pmEdFyfZhhhny4MNiAfWdBQ1RQ2mfDWmM1x8SvGyp8g==",
+      "dev": true,
+      "license": "CC0-1.0"
+    },
     "node_modules/custom-event": {
       "version": "1.0.1",
       "resolved": "https://registry.npmjs.org/custom-event/-/custom-event-1.0.1.tgz",
@@ -4653,6 +4901,16 @@
         "node": ">= 0.8"
       }
     },
+    "node_modules/dependency-graph": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/dependency-graph/-/dependency-graph-1.0.0.tgz",
+      "integrity": "sha512-cW3gggJ28HZ/LExwxP2B++aiKxhJXMSIt9K48FOXQkm+vuG5gyatXnLsONRJdzO/7VfjDIiaOOa/bs4l464Lwg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=4"
+      }
+    },
     "node_modules/destroy": {
       "version": "1.2.0",
       "resolved": "https://registry.npmjs.org/destroy/-/destroy-1.2.0.tgz",
@@ -4699,12 +4957,84 @@
         "void-elements": "^2.0.0"
       }
     },
+    "node_modules/dom-serializer": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/dom-serializer/-/dom-serializer-2.0.0.tgz",
+      "integrity": "sha512-wIkAryiqt/nV5EQKqQpo3SToSOV9J0DnbJqwK7Wv/Trc92zIAYZ4FlMu+JPFW1DfGFt81ZTCGgDEabffXeLyJg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "domelementtype": "^2.3.0",
+        "domhandler": "^5.0.2",
+        "entities": "^4.2.0"
+      },
+      "funding": {
+        "url": "https://github.com/cheeriojs/dom-serializer?sponsor=1"
+      }
+    },
+    "node_modules/dom-serializer/node_modules/entities": {
+      "version": "4.5.0",
+      "resolved": "https://registry.npmjs.org/entities/-/entities-4.5.0.tgz",
+      "integrity": "sha512-V0hjH4dGPh9Ao5p0MoRY6BVqtwCjhz6vI5LT8AJ55H+4g9/4vbHx1I54fS0XuclLhDHArPQCiMjDxjaL8fPxhw==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=0.12"
+      },
+      "funding": {
+        "url": "https://github.com/fb55/entities?sponsor=1"
+      }
+    },
     "node_modules/dom-walk": {
       "version": "0.1.2",
       "resolved": "https://registry.npmjs.org/dom-walk/-/dom-walk-0.1.2.tgz",
       "integrity": "sha512-6QvTW9mrGeIegrFXdtQi9pk7O/nSK6lSdXW2eqUspN5LWD7UTji2Fqw5V2YLjBpHEoU9Xl/eUWNpDeZvoyOv2w==",
       "dev": true
     },
+    "node_modules/domelementtype": {
+      "version": "2.3.0",
+      "resolved": "https://registry.npmjs.org/domelementtype/-/domelementtype-2.3.0.tgz",
+      "integrity": "sha512-OLETBj6w0OsagBwdXnPdN0cnMfF9opN69co+7ZrbfPGrdpPVNBUj02spi6B1N7wChLQiPn4CSH/zJvXw56gmHw==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/fb55"
+        }
+      ],
+      "license": "BSD-2-Clause"
+    },
+    "node_modules/domhandler": {
+      "version": "5.0.3",
+      "resolved": "https://registry.npmjs.org/domhandler/-/domhandler-5.0.3.tgz",
+      "integrity": "sha512-cgwlv/1iFQiFnU96XXgROh8xTeetsnJiDsTc7TYCLFd9+/WNkIqPTxiM/8pSd8VIrhXGTf1Ny1q1hquVqDJB5w==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "domelementtype": "^2.3.0"
+      },
+      "engines": {
+        "node": ">= 4"
+      },
+      "funding": {
+        "url": "https://github.com/fb55/domhandler?sponsor=1"
+      }
+    },
+    "node_modules/domutils": {
+      "version": "3.2.2",
+      "resolved": "https://registry.npmjs.org/domutils/-/domutils-3.2.2.tgz",
+      "integrity": "sha512-6kZKyUajlDuqlHKVX1w7gyslj9MPIXzIFiz/rGu35uC1wMi+kMhQwGhl4lt9unC9Vb9INnY9Z3/ZA3+FhASLaw==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "dom-serializer": "^2.0.0",
+        "domelementtype": "^2.3.0",
+        "domhandler": "^5.0.3"
+      },
+      "funding": {
+        "url": "https://github.com/fb55/domutils?sponsor=1"
+      }
+    },
     "node_modules/dot-prop": {
       "version": "6.0.1",
       "resolved": "https://registry.npmjs.org/dot-prop/-/dot-prop-6.0.1.tgz",
@@ -4737,10 +5067,11 @@
       "dev": true
     },
     "node_modules/electron-to-chromium": {
-      "version": "1.4.71",
-      "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.4.71.tgz",
-      "integrity": "sha512-Hk61vXXKRb2cd3znPE9F+2pLWdIOmP7GjiTj45y6L3W/lO+hSnUSUhq+6lEaERWBdZOHbk2s3YV5c9xVl3boVw==",
-      "dev": true
+      "version": "1.5.363",
+      "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.363.tgz",
+      "integrity": "sha512-VjUKPyWzGnT1fujlkEGC/BvN70Hh70KXtAqcmniXviYlJC/ivcT+BWGPyxWVbJZLfvtKR6dqg1L7T7pgAMBtWA==",
+      "dev": true,
+      "license": "ISC"
     },
     "node_modules/emoji-regex": {
       "version": "8.0.0",
@@ -4881,10 +5212,11 @@
       "dev": true
     },
     "node_modules/escalade": {
-      "version": "3.1.1",
-      "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.1.1.tgz",
-      "integrity": "sha512-k0er2gUkLf8O0zKJiAhmkTnJlTvINGv7ygDNPbeIsX/TJjGJZHuh9B2UxbsaEkmlEo9MfhrSzmhIlhRlI2GXnw==",
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz",
+      "integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==",
       "dev": true,
+      "license": "MIT",
       "engines": {
         "node": ">=6"
       }
@@ -5690,6 +6022,20 @@
         "node": ">= 0.12"
       }
     },
+    "node_modules/fraction.js": {
+      "version": "5.3.4",
+      "resolved": "https://registry.npmjs.org/fraction.js/-/fraction.js-5.3.4.tgz",
+      "integrity": "sha512-1X1NTtiJphryn/uLQz3whtY6jK3fTqoE3ohKs0tT+Ujr1W59oopxmoEh7Lu5p6vBaPbgoM0bzveAW4Qi5RyWDQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "*"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/rawify"
+      }
+    },
     "node_modules/fs-constants": {
       "version": "1.0.0",
       "resolved": "https://registry.npmjs.org/fs-constants/-/fs-constants-1.0.0.tgz",
@@ -7275,18 +7621,6 @@
         "source-map": "~0.6.0"
       }
     },
-    "node_modules/less-plugin-clean-css": {
-      "version": "1.6.0",
-      "resolved": "https://registry.npmjs.org/less-plugin-clean-css/-/less-plugin-clean-css-1.6.0.tgz",
-      "integrity": "sha512-jwXX6WlXT57OVCXa5oBJBaJq1b4s1BOKeEEoAL2UTeEitogQWfTcBbLT/vow9pl0N0MXV8Mb4KyhTGG0YbEKyQ==",
-      "dev": true,
-      "dependencies": {
-        "clean-css": "5.3.3"
-      },
-      "engines": {
-        "node": ">=0.10"
-      }
-    },
     "node_modules/less/node_modules/make-dir": {
       "version": "2.1.0",
       "resolved": "https://registry.npmjs.org/make-dir/-/make-dir-2.1.0.tgz",
@@ -7338,6 +7672,19 @@
         "node": ">= 0.8.0"
       }
     },
+    "node_modules/lilconfig": {
+      "version": "3.1.3",
+      "resolved": "https://registry.npmjs.org/lilconfig/-/lilconfig-3.1.3.tgz",
+      "integrity": "sha512-/vlFKAoH5Cgt3Ie+JLhRbwOsCQePABiU3tJ1egGvyQ+33R/vcwM2Zl2QR/LzjsBeItPt3oSVXapn+m4nQDvpzw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=14"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/antonk52"
+      }
+    },
     "node_modules/lines-and-columns": {
       "version": "1.2.4",
       "resolved": "https://registry.npmjs.org/lines-and-columns/-/lines-and-columns-1.2.4.tgz",
@@ -7429,6 +7776,13 @@
       "integrity": "sha1-fFJqUtibRcRcxpC4gWO+BJf1UMs=",
       "dev": true
     },
+    "node_modules/lodash.memoize": {
+      "version": "4.1.2",
+      "resolved": "https://registry.npmjs.org/lodash.memoize/-/lodash.memoize-4.1.2.tgz",
+      "integrity": "sha512-t7j+NzmgnQzTAYXcsHYLgimltOV1MXHtlOWf6GjL9Kj8GK5FInw5JotxvbOs+IvV1/Dzo04/fCGfLVs7aXb4Ag==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/lodash.merge": {
       "version": "4.6.2",
       "resolved": "https://registry.npmjs.org/lodash.merge/-/lodash.merge-4.6.2.tgz",
@@ -7447,6 +7801,13 @@
       "integrity": "sha1-SLtQiECfFvGCFmZkHETdGqrjzYg=",
       "dev": true
     },
+    "node_modules/lodash.uniq": {
+      "version": "4.5.0",
+      "resolved": "https://registry.npmjs.org/lodash.uniq/-/lodash.uniq-4.5.0.tgz",
+      "integrity": "sha512-xfBaXQd9ryd9dlSDvnvI0lvxfLJlYAZzXomUYzLKtUeOQvOP5piqAWuGtrhWeqaXK9hhoM/iyJc5AV+XfsX3HQ==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/log4js": {
       "version": "6.4.1",
       "resolved": "https://registry.npmjs.org/log4js/-/log4js-6.4.1.tgz",
@@ -7559,6 +7920,13 @@
         "url": "https://github.com/sponsors/wooorm"
       }
     },
+    "node_modules/mdn-data": {
+      "version": "2.27.1",
+      "resolved": "https://registry.npmjs.org/mdn-data/-/mdn-data-2.27.1.tgz",
+      "integrity": "sha512-9Yubnt3e8A0OKwxYSXyhLymGW4sCufcLG6VdiDdUGVkPhpqLxlvP5vl1983gQjJl3tqbrM731mjaZaP68AgosQ==",
+      "dev": true,
+      "license": "CC0-1.0"
+    },
     "node_modules/mdurl": {
       "version": "1.0.1",
       "resolved": "https://registry.npmjs.org/mdurl/-/mdurl-1.0.1.tgz",
@@ -7746,9 +8114,9 @@
       "dev": true
     },
     "node_modules/nanoid": {
-      "version": "3.3.11",
-      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.11.tgz",
-      "integrity": "sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w==",
+      "version": "3.3.12",
+      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.12.tgz",
+      "integrity": "sha512-ZB9RH/39qpq5Vu6Y+NmUaFhQR6pp+M2Xt76XBnEwDaGcVAqhlvxrl3B2bKS5D3NH3QR76v3aSrKaF/Kiy7lEtQ==",
       "dev": true,
       "funding": [
         {
@@ -7756,6 +8124,7 @@
           "url": "https://github.com/sponsors/ai"
         }
       ],
+      "license": "MIT",
       "bin": {
         "nanoid": "bin/nanoid.cjs"
       },
@@ -7901,10 +8270,14 @@
       }
     },
     "node_modules/node-releases": {
-      "version": "2.0.2",
-      "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.2.tgz",
-      "integrity": "sha512-XxYDdcQ6eKqp/YjI+tb2C5WM2LgjnZrfYg4vgQt49EK268b6gYCHsBLrK2qvJo4FmCtqmKezb0WZFK4fkrZNsg==",
-      "dev": true
+      "version": "2.0.46",
+      "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.46.tgz",
+      "integrity": "sha512-GYVXHE2KnrzAfsAjl4uP++evGFCrAU1jta4ubEjIG7YWt/64Gqv66a30yKwWczVjA6j3bM4nBwH7Pk1JmDHaxQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      }
     },
     "node_modules/normalize-package-data": {
       "version": "3.0.3",
@@ -7963,7 +8336,20 @@
         "node": ">=8"
       }
     },
-    "node_modules/oauth-sign": {
+    "node_modules/nth-check": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/nth-check/-/nth-check-2.1.1.tgz",
+      "integrity": "sha512-lqjrjmaOoAnWfMmBPL+XNnynZh2+swxiX3WUE0s4yEHI6m+AwrK2UZOimIRl3X/4QctVqS8AiZjFqyOGrMXb/w==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "boolbase": "^1.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/fb55/nth-check?sponsor=1"
+      }
+    },
+    "node_modules/oauth-sign": {
       "version": "0.9.0",
       "resolved": "https://registry.npmjs.org/oauth-sign/-/oauth-sign-0.9.0.tgz",
       "integrity": "sha512-fexhUFFPTGV8ybAtSIGbV6gOkSv8UtRbDBnAyLQw4QPKkgNlsH2ByPGtMUqdWkos6YCRmAqViwgZrJc/mRDzZQ==",
@@ -8368,52 +8754,700 @@
         "url": "https://opencollective.com/popperjs"
       }
     },
-    "node_modules/postcss": {
-      "version": "8.5.10",
-      "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.10.tgz",
-      "integrity": "sha512-pMMHxBOZKFU6HgAZ4eyGnwXF/EvPGGqUr0MnZ5+99485wwW41kW91A4LOGxSHhgugZmSChL5AlElNdwlNgcnLQ==",
+    "node_modules/postcss": {
+      "version": "8.5.15",
+      "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.15.tgz",
+      "integrity": "sha512-FfR8sjd4em2T6fb3I2MwAJU7HWVMr9zba+enmQeeWFfCbm+UOC/0X4DS8XtpUTMwWMGbjKYP7xjfNekzyGmB3A==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/postcss/"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/postcss"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "nanoid": "^3.3.12",
+        "picocolors": "^1.1.1",
+        "source-map-js": "^1.2.1"
+      },
+      "engines": {
+        "node": "^10 || ^12 || >=14"
+      }
+    },
+    "node_modules/postcss-calc": {
+      "version": "10.1.1",
+      "resolved": "https://registry.npmjs.org/postcss-calc/-/postcss-calc-10.1.1.tgz",
+      "integrity": "sha512-NYEsLHh8DgG/PRH2+G9BTuUdtf9ViS+vdoQ0YA5OQdGsfN4ztiwtDWNtBl9EKeqNMFnIu8IKZ0cLxEQ5r5KVMw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "postcss-selector-parser": "^7.0.0",
+        "postcss-value-parser": "^4.2.0"
+      },
+      "engines": {
+        "node": "^18.12 || ^20.9 || >=22.0"
+      },
+      "peerDependencies": {
+        "postcss": "^8.4.38"
+      }
+    },
+    "node_modules/postcss-calc/node_modules/postcss-selector-parser": {
+      "version": "7.1.1",
+      "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-7.1.1.tgz",
+      "integrity": "sha512-orRsuYpJVw8LdAwqqLykBj9ecS5/cRHlI5+nvTo8LcCKmzDmqVORXtOIYEEQuL9D4BxtA1lm5isAqzQZCoQ6Eg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "cssesc": "^3.0.0",
+        "util-deprecate": "^1.0.2"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/postcss-cli": {
+      "version": "11.0.1",
+      "resolved": "https://registry.npmjs.org/postcss-cli/-/postcss-cli-11.0.1.tgz",
+      "integrity": "sha512-0UnkNPSayHKRe/tc2YGW6XnSqqOA9eqpiRMgRlV1S6HdGi16vwJBx7lviARzbV1HpQHqLLRH3o8vTcB0cLc+5g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "chokidar": "^3.3.0",
+        "dependency-graph": "^1.0.0",
+        "fs-extra": "^11.0.0",
+        "picocolors": "^1.0.0",
+        "postcss-load-config": "^5.0.0",
+        "postcss-reporter": "^7.0.0",
+        "pretty-hrtime": "^1.0.3",
+        "read-cache": "^1.0.0",
+        "slash": "^5.0.0",
+        "tinyglobby": "^0.2.12",
+        "yargs": "^17.0.0"
+      },
+      "bin": {
+        "postcss": "index.js"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "postcss": "^8.0.0"
+      }
+    },
+    "node_modules/postcss-cli/node_modules/cliui": {
+      "version": "8.0.1",
+      "resolved": "https://registry.npmjs.org/cliui/-/cliui-8.0.1.tgz",
+      "integrity": "sha512-BSeNnyus75C4//NQ9gQt1/csTXyo/8Sb+afLAkzAptFuMsod9HFokGNudZpi/oQV73hnVK+sR+5PVRMd+Dr7YQ==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "string-width": "^4.2.0",
+        "strip-ansi": "^6.0.1",
+        "wrap-ansi": "^7.0.0"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/postcss-cli/node_modules/fs-extra": {
+      "version": "11.3.5",
+      "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-11.3.5.tgz",
+      "integrity": "sha512-eKpRKAovdpZtR1WopLHxlBWvAgPny3c4gX1G5Jhwmmw4XJj0ifSD5qB5TOo8hmA0wlRKDAOAhEE1yVPgs6Fgcg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "graceful-fs": "^4.2.0",
+        "jsonfile": "^6.0.1",
+        "universalify": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=14.14"
+      }
+    },
+    "node_modules/postcss-cli/node_modules/slash": {
+      "version": "5.1.0",
+      "resolved": "https://registry.npmjs.org/slash/-/slash-5.1.0.tgz",
+      "integrity": "sha512-ZA6oR3T/pEyuqwMgAKT0/hAv8oAXckzbkmR0UkUosQ+Mc4RxGoJkRmwHgHufaenlyAgE1Mxgpdcrf75y6XcnDg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=14.16"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/postcss-cli/node_modules/yargs": {
+      "version": "17.7.2",
+      "resolved": "https://registry.npmjs.org/yargs/-/yargs-17.7.2.tgz",
+      "integrity": "sha512-7dSzzRQ++CKnNI/krKnYRV7JKKPUXMEh61soaHKg9mrWEhzFWhFnxPxGl+69cD1Ou63C13NUPCnmIcrvqCuM6w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "cliui": "^8.0.1",
+        "escalade": "^3.1.1",
+        "get-caller-file": "^2.0.5",
+        "require-directory": "^2.1.1",
+        "string-width": "^4.2.3",
+        "y18n": "^5.0.5",
+        "yargs-parser": "^21.1.1"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/postcss-cli/node_modules/yargs-parser": {
+      "version": "21.1.1",
+      "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-21.1.1.tgz",
+      "integrity": "sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw==",
+      "dev": true,
+      "license": "ISC",
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/postcss-colormin": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/postcss-colormin/-/postcss-colormin-8.0.0.tgz",
+      "integrity": "sha512-KKwMmsSgsmdYXqrjQeqL3tnuIFtctiR1GEMHdjNpDpz/TCRkkkok2mMcreK2zVV3l7POWOmAkR2xYHUpRUK1DA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@colordx/core": "^5.4.3",
+        "browserslist": "^4.28.2",
+        "caniuse-api": "^3.0.0",
+        "postcss-value-parser": "^4.2.0"
+      },
+      "engines": {
+        "node": "^22.11.0 || ^24.11.0 || >=26.0"
+      },
+      "peerDependencies": {
+        "postcss": "^8.5.14"
+      }
+    },
+    "node_modules/postcss-convert-values": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/postcss-convert-values/-/postcss-convert-values-8.0.0.tgz",
+      "integrity": "sha512-Ohtj3rNZWawTRePv5NCHTy8VJSdJ/G/uKuxcxJreOMichuqcT6uEl2TAnopVeJCJ/c13jaSqg7m63yFLM5zBsA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "browserslist": "^4.28.2",
+        "postcss-value-parser": "^4.2.0"
+      },
+      "engines": {
+        "node": "^22.11.0 || ^24.11.0 || >=26.0"
+      },
+      "peerDependencies": {
+        "postcss": "^8.5.14"
+      }
+    },
+    "node_modules/postcss-discard-comments": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/postcss-discard-comments/-/postcss-discard-comments-8.0.0.tgz",
+      "integrity": "sha512-zGpvVLj2sbagEp+BTVETvAfkZdGVA6rALNujDK/WTIjdf1/rQOxOG8BBzkI8UQgnw8SkL6xffAfbtGMHFypadw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "postcss-selector-parser": "^7.1.1"
+      },
+      "engines": {
+        "node": "^22.11.0 || ^24.11.0 || >=26.0"
+      },
+      "peerDependencies": {
+        "postcss": "^8.5.14"
+      }
+    },
+    "node_modules/postcss-discard-comments/node_modules/postcss-selector-parser": {
+      "version": "7.1.1",
+      "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-7.1.1.tgz",
+      "integrity": "sha512-orRsuYpJVw8LdAwqqLykBj9ecS5/cRHlI5+nvTo8LcCKmzDmqVORXtOIYEEQuL9D4BxtA1lm5isAqzQZCoQ6Eg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "cssesc": "^3.0.0",
+        "util-deprecate": "^1.0.2"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/postcss-discard-duplicates": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/postcss-discard-duplicates/-/postcss-discard-duplicates-8.0.0.tgz",
+      "integrity": "sha512-zjRyYmNGI3PTipKBBtCgExlmZXQn49KvKoaiNnR2g+iXxeNk7GY5Js2ULtZXPrCYeqjPagrzKIBNcBocvXCR7g==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^22.11.0 || ^24.11.0 || >=26.0"
+      },
+      "peerDependencies": {
+        "postcss": "^8.5.14"
+      }
+    },
+    "node_modules/postcss-discard-empty": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/postcss-discard-empty/-/postcss-discard-empty-8.0.0.tgz",
+      "integrity": "sha512-kxPJg6EqahbBvm+l7hpYYCtpsv8dlz7Tv6wJXUXZaeuY0WGS61DxfGdZR4uVB/Cx+yi3iOHQVSqpSHKMFaBg6Q==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^22.11.0 || ^24.11.0 || >=26.0"
+      },
+      "peerDependencies": {
+        "postcss": "^8.5.14"
+      }
+    },
+    "node_modules/postcss-discard-overridden": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/postcss-discard-overridden/-/postcss-discard-overridden-8.0.0.tgz",
+      "integrity": "sha512-sW2OWH3l9p0FmBSVr228uztFseqroZxwgD7SGF0Ks0dRPDttSo3P8FK5ZBLtWBH2A5+chpB0J2fB/T8heKHLBw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^22.11.0 || ^24.11.0 || >=26.0"
+      },
+      "peerDependencies": {
+        "postcss": "^8.5.14"
+      }
+    },
+    "node_modules/postcss-less": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/postcss-less/-/postcss-less-6.0.0.tgz",
+      "integrity": "sha512-FPX16mQLyEjLzEuuJtxA8X3ejDLNGGEG503d2YGZR5Ask1SpDN8KmZUMpzCvyalWRywAn1n1VOA5dcqfCLo5rg==",
+      "dev": true,
+      "engines": {
+        "node": ">=12"
+      },
+      "peerDependencies": {
+        "postcss": "^8.3.5"
+      }
+    },
+    "node_modules/postcss-load-config": {
+      "version": "5.1.0",
+      "resolved": "https://registry.npmjs.org/postcss-load-config/-/postcss-load-config-5.1.0.tgz",
+      "integrity": "sha512-G5AJ+IX0aD0dygOE0yFZQ/huFFMSNneyfp0e3/bT05a8OfPC5FUoZRPfGijUdGOJNMewJiwzcHJXFafFzeKFVA==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/postcss/"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "lilconfig": "^3.1.1",
+        "yaml": "^2.4.2"
+      },
+      "engines": {
+        "node": ">= 18"
+      },
+      "peerDependencies": {
+        "jiti": ">=1.21.0",
+        "postcss": ">=8.0.9",
+        "tsx": "^4.8.1"
+      },
+      "peerDependenciesMeta": {
+        "jiti": {
+          "optional": true
+        },
+        "postcss": {
+          "optional": true
+        },
+        "tsx": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/postcss-load-config/node_modules/yaml": {
+      "version": "2.9.0",
+      "resolved": "https://registry.npmjs.org/yaml/-/yaml-2.9.0.tgz",
+      "integrity": "sha512-2AvhNX3mb8zd6Zy7INTtSpl1F15HW6Wnqj0srWlkKLcpYl/gMIMJiyuGq2KeI2YFxUPjdlB+3Lc10seMLtL4cA==",
+      "dev": true,
+      "license": "ISC",
+      "bin": {
+        "yaml": "bin.mjs"
+      },
+      "engines": {
+        "node": ">= 14.6"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/eemeli"
+      }
+    },
+    "node_modules/postcss-media-query-parser": {
+      "version": "0.2.3",
+      "resolved": "https://registry.npmjs.org/postcss-media-query-parser/-/postcss-media-query-parser-0.2.3.tgz",
+      "integrity": "sha1-J7Ocb02U+Bsac7j3Y1HGCeXO8kQ=",
+      "dev": true
+    },
+    "node_modules/postcss-merge-longhand": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/postcss-merge-longhand/-/postcss-merge-longhand-8.0.0.tgz",
+      "integrity": "sha512-YDmAmQ8H+ljfomVpSXvr9NA0GP01fraQJqjWBYoMVGg6rOT+PJLwPyeVo2ekn4WB4ZVSH5ddtK3DTRxbz6CFzg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "postcss-value-parser": "^4.2.0",
+        "stylehacks": "^8.0.0"
+      },
+      "engines": {
+        "node": "^22.11.0 || ^24.11.0 || >=26.0"
+      },
+      "peerDependencies": {
+        "postcss": "^8.5.14"
+      }
+    },
+    "node_modules/postcss-merge-rules": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/postcss-merge-rules/-/postcss-merge-rules-8.0.0.tgz",
+      "integrity": "sha512-bgstL5mpi41dDpnYGDUcI3M814NWkCMcIWpwDqEHXkHg3BT7b4XRAfNEuwJncZOVn/67kVKvWzhfv/7xyrp2uQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "browserslist": "^4.28.2",
+        "caniuse-api": "^3.0.0",
+        "cssnano-utils": "^6.0.0",
+        "postcss-selector-parser": "^7.1.1"
+      },
+      "engines": {
+        "node": "^22.11.0 || ^24.11.0 || >=26.0"
+      },
+      "peerDependencies": {
+        "postcss": "^8.5.14"
+      }
+    },
+    "node_modules/postcss-merge-rules/node_modules/postcss-selector-parser": {
+      "version": "7.1.1",
+      "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-7.1.1.tgz",
+      "integrity": "sha512-orRsuYpJVw8LdAwqqLykBj9ecS5/cRHlI5+nvTo8LcCKmzDmqVORXtOIYEEQuL9D4BxtA1lm5isAqzQZCoQ6Eg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "cssesc": "^3.0.0",
+        "util-deprecate": "^1.0.2"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/postcss-minify-font-values": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/postcss-minify-font-values/-/postcss-minify-font-values-8.0.0.tgz",
+      "integrity": "sha512-EnOHQEnSt6oH5NrL1DMFAQuwB2IOimFXTCzc9bKfUeH1jREbqIF5MAK4gQJQOC4mPUwJt4sWifAmNZ1qLu6j3Q==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "postcss-value-parser": "^4.2.0"
+      },
+      "engines": {
+        "node": "^22.11.0 || ^24.11.0 || >=26.0"
+      },
+      "peerDependencies": {
+        "postcss": "^8.5.14"
+      }
+    },
+    "node_modules/postcss-minify-gradients": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/postcss-minify-gradients/-/postcss-minify-gradients-8.0.0.tgz",
+      "integrity": "sha512-43iAnYIGk0ZjNx5X/rkIcHi6dhmu/vEjY0kqfUfxPuJRO+V7jx8uKIdcnL0dpfNoC5J9TSh3EtzLWbq0gpqnWA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@colordx/core": "^5.4.3",
+        "cssnano-utils": "^6.0.0",
+        "postcss-value-parser": "^4.2.0"
+      },
+      "engines": {
+        "node": "^22.11.0 || ^24.11.0 || >=26.0"
+      },
+      "peerDependencies": {
+        "postcss": "^8.5.14"
+      }
+    },
+    "node_modules/postcss-minify-params": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/postcss-minify-params/-/postcss-minify-params-8.0.0.tgz",
+      "integrity": "sha512-z7w4QO7G55l4vMUK1Lmx03GW7iyRLgf2V5Dz/7ioSPLnXRjeD+b7m0XfAXUGrbBYYrJ6bXPk+3LoX5u4JfAcSg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "browserslist": "^4.28.2",
+        "cssnano-utils": "^6.0.0",
+        "postcss-value-parser": "^4.2.0"
+      },
+      "engines": {
+        "node": "^22.11.0 || ^24.11.0 || >=26.0"
+      },
+      "peerDependencies": {
+        "postcss": "^8.5.14"
+      }
+    },
+    "node_modules/postcss-minify-selectors": {
+      "version": "8.0.1",
+      "resolved": "https://registry.npmjs.org/postcss-minify-selectors/-/postcss-minify-selectors-8.0.1.tgz",
+      "integrity": "sha512-c31D46811kTkQDxV1KTTow79axX6gj/01AY5G7cGZg3s31KvAwP13jEFXGAzQbJ7NvOFV1pRqEia6nrAdHU7qg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "browserslist": "^4.28.1",
+        "caniuse-api": "^3.0.0",
+        "cssesc": "^3.0.0",
+        "postcss-selector-parser": "^7.1.1"
+      },
+      "engines": {
+        "node": "^22.11.0 || ^24.11.0 || >=26.0"
+      },
+      "peerDependencies": {
+        "postcss": "^8.5.14"
+      }
+    },
+    "node_modules/postcss-minify-selectors/node_modules/postcss-selector-parser": {
+      "version": "7.1.1",
+      "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-7.1.1.tgz",
+      "integrity": "sha512-orRsuYpJVw8LdAwqqLykBj9ecS5/cRHlI5+nvTo8LcCKmzDmqVORXtOIYEEQuL9D4BxtA1lm5isAqzQZCoQ6Eg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "cssesc": "^3.0.0",
+        "util-deprecate": "^1.0.2"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/postcss-normalize-charset": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/postcss-normalize-charset/-/postcss-normalize-charset-8.0.0.tgz",
+      "integrity": "sha512-s88FUNDSUD8m0wBYvTQQcubVts6zhXwBU8zCD4vkRKiecd0v8cOjHVIF9r/i+5xzS/WG3f98qq4XsOM0JqvfLA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^22.11.0 || ^24.11.0 || >=26.0"
+      },
+      "peerDependencies": {
+        "postcss": "^8.5.14"
+      }
+    },
+    "node_modules/postcss-normalize-display-values": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/postcss-normalize-display-values/-/postcss-normalize-display-values-8.0.0.tgz",
+      "integrity": "sha512-gG2nBxD27fiw6Luinb1QYKdM/Co5GornRJgSD+JTwNH4PGKxImP0qyruDDav49aHUPLY3qrL3qN3LvybO7IzxQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "postcss-value-parser": "^4.2.0"
+      },
+      "engines": {
+        "node": "^22.11.0 || ^24.11.0 || >=26.0"
+      },
+      "peerDependencies": {
+        "postcss": "^8.5.14"
+      }
+    },
+    "node_modules/postcss-normalize-positions": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/postcss-normalize-positions/-/postcss-normalize-positions-8.0.0.tgz",
+      "integrity": "sha512-t/wGqpehS20Ke7kc4QAsWpH+AJjUdMK/V5qV2RhrXkj8hO/fT1t1MJ8NL7sedWYk7ZqC7eISEJQonW5j0tU1MQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "postcss-value-parser": "^4.2.0"
+      },
+      "engines": {
+        "node": "^22.11.0 || ^24.11.0 || >=26.0"
+      },
+      "peerDependencies": {
+        "postcss": "^8.5.14"
+      }
+    },
+    "node_modules/postcss-normalize-repeat-style": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/postcss-normalize-repeat-style/-/postcss-normalize-repeat-style-8.0.0.tgz",
+      "integrity": "sha512-3ebOmGdCYKrBYyGKc1xhj0unEnW7beZpVU7JohVeGl7mTxR+7T6egpaawTWAVsB0pEIhcsbJVOjPKCJSoRO6Zg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "postcss-value-parser": "^4.2.0"
+      },
+      "engines": {
+        "node": "^22.11.0 || ^24.11.0 || >=26.0"
+      },
+      "peerDependencies": {
+        "postcss": "^8.5.14"
+      }
+    },
+    "node_modules/postcss-normalize-string": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/postcss-normalize-string/-/postcss-normalize-string-8.0.0.tgz",
+      "integrity": "sha512-TvWCGZ/e04Tv31uJvOUtbexkfgUnqmQ3M2P5DkAaVzvOj+BvTkG2QjpA5Y71SL1SPxJcj4M23fNh+RDVCmG8kA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "postcss-value-parser": "^4.2.0"
+      },
+      "engines": {
+        "node": "^22.11.0 || ^24.11.0 || >=26.0"
+      },
+      "peerDependencies": {
+        "postcss": "^8.5.14"
+      }
+    },
+    "node_modules/postcss-normalize-timing-functions": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/postcss-normalize-timing-functions/-/postcss-normalize-timing-functions-8.0.0.tgz",
+      "integrity": "sha512-uEfaXst5Xgqxv7geYUuz6vs9mn88K2NPY2RoIzM3BMmSjsdTSeppV9x2qIgrxsisdbSqF6IVhzI2occcte3hTA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "postcss-value-parser": "^4.2.0"
+      },
+      "engines": {
+        "node": "^22.11.0 || ^24.11.0 || >=26.0"
+      },
+      "peerDependencies": {
+        "postcss": "^8.5.14"
+      }
+    },
+    "node_modules/postcss-normalize-unicode": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/postcss-normalize-unicode/-/postcss-normalize-unicode-8.0.0.tgz",
+      "integrity": "sha512-+WYngZaChEeTHZmWhmKtnJ4gTzWdINEaFcgWBnu6WdVu8Ftim8OBTcw768DuCC/3Aax9bZ9WkwrLGHym2Lzf+A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "browserslist": "^4.28.2",
+        "postcss-value-parser": "^4.2.0"
+      },
+      "engines": {
+        "node": "^22.11.0 || ^24.11.0 || >=26.0"
+      },
+      "peerDependencies": {
+        "postcss": "^8.5.14"
+      }
+    },
+    "node_modules/postcss-normalize-url": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/postcss-normalize-url/-/postcss-normalize-url-8.0.0.tgz",
+      "integrity": "sha512-4Mz9hZHn/QIB+YtFqTXrDmE2193GYxGb3F8uMfLvMicaEXCCUlDIJ658gFFJbqEGl9FYzwPtRiuNgbwlO9kkBg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "postcss-value-parser": "^4.2.0"
+      },
+      "engines": {
+        "node": "^22.11.0 || ^24.11.0 || >=26.0"
+      },
+      "peerDependencies": {
+        "postcss": "^8.5.14"
+      }
+    },
+    "node_modules/postcss-normalize-whitespace": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/postcss-normalize-whitespace/-/postcss-normalize-whitespace-8.0.0.tgz",
+      "integrity": "sha512-V1f8tYnwIP5tscOXQFTKK8Y5EJ+R2GMpFJ6FjzwoKoQnhbqQy3IeSrDjJJb8JjVos8ut6Osi80Zybpayv/XjIQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "postcss-value-parser": "^4.2.0"
+      },
+      "engines": {
+        "node": "^22.11.0 || ^24.11.0 || >=26.0"
+      },
+      "peerDependencies": {
+        "postcss": "^8.5.14"
+      }
+    },
+    "node_modules/postcss-ordered-values": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/postcss-ordered-values/-/postcss-ordered-values-8.0.0.tgz",
+      "integrity": "sha512-Dg9+itb6lmD0bxqhQyHCtXAwYRh0wUrx6Mp4/BNXgkLoJmdYMmWi+V+Pypw79Q6iQhxA8KFMHqLBITQJV2gKMA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "cssnano-utils": "^6.0.0",
+        "postcss-value-parser": "^4.2.0"
+      },
+      "engines": {
+        "node": "^22.11.0 || ^24.11.0 || >=26.0"
+      },
+      "peerDependencies": {
+        "postcss": "^8.5.14"
+      }
+    },
+    "node_modules/postcss-reduce-initial": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/postcss-reduce-initial/-/postcss-reduce-initial-8.0.0.tgz",
+      "integrity": "sha512-DChcE9d528AKrlpCTHjhsAiOsWCk4H9ApHPS1QqRT3praObWTiWyn6W1UddGpc46K9LQnHwUu4YwaPUukGtXVA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "browserslist": "^4.28.2",
+        "caniuse-api": "^3.0.0"
+      },
+      "engines": {
+        "node": "^22.11.0 || ^24.11.0 || >=26.0"
+      },
+      "peerDependencies": {
+        "postcss": "^8.5.14"
+      }
+    },
+    "node_modules/postcss-reduce-transforms": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/postcss-reduce-transforms/-/postcss-reduce-transforms-8.0.0.tgz",
+      "integrity": "sha512-cLZT0som7vvumQT9XQCnSKOSnRinNQZd1Hm+J723Ney13E8CIydDhw6JwzsjPtgnYThTqn9Q45906gz6wxaAsw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "postcss-value-parser": "^4.2.0"
+      },
+      "engines": {
+        "node": "^22.11.0 || ^24.11.0 || >=26.0"
+      },
+      "peerDependencies": {
+        "postcss": "^8.5.14"
+      }
+    },
+    "node_modules/postcss-reporter": {
+      "version": "7.1.0",
+      "resolved": "https://registry.npmjs.org/postcss-reporter/-/postcss-reporter-7.1.0.tgz",
+      "integrity": "sha512-/eoEylGWyy6/DOiMP5lmFRdmDKThqgn7D6hP2dXKJI/0rJSO1ADFNngZfDzxL0YAxFvws+Rtpuji1YIHj4mySA==",
       "dev": true,
       "funding": [
         {
           "type": "opencollective",
           "url": "https://opencollective.com/postcss/"
         },
-        {
-          "type": "tidelift",
-          "url": "https://tidelift.com/funding/github/npm/postcss"
-        },
         {
           "type": "github",
           "url": "https://github.com/sponsors/ai"
         }
       ],
+      "license": "MIT",
       "dependencies": {
-        "nanoid": "^3.3.11",
-        "picocolors": "^1.1.1",
-        "source-map-js": "^1.2.1"
+        "picocolors": "^1.0.0",
+        "thenby": "^1.3.4"
       },
       "engines": {
-        "node": "^10 || ^12 || >=14"
-      }
-    },
-    "node_modules/postcss-less": {
-      "version": "6.0.0",
-      "resolved": "https://registry.npmjs.org/postcss-less/-/postcss-less-6.0.0.tgz",
-      "integrity": "sha512-FPX16mQLyEjLzEuuJtxA8X3ejDLNGGEG503d2YGZR5Ask1SpDN8KmZUMpzCvyalWRywAn1n1VOA5dcqfCLo5rg==",
-      "dev": true,
-      "engines": {
-        "node": ">=12"
+        "node": ">=10"
       },
       "peerDependencies": {
-        "postcss": "^8.3.5"
+        "postcss": "^8.1.0"
       }
     },
-    "node_modules/postcss-media-query-parser": {
-      "version": "0.2.3",
-      "resolved": "https://registry.npmjs.org/postcss-media-query-parser/-/postcss-media-query-parser-0.2.3.tgz",
-      "integrity": "sha1-J7Ocb02U+Bsac7j3Y1HGCeXO8kQ=",
-      "dev": true
-    },
     "node_modules/postcss-resolve-nested-selector": {
       "version": "0.1.1",
       "resolved": "https://registry.npmjs.org/postcss-resolve-nested-selector/-/postcss-resolve-nested-selector-0.1.1.tgz",
@@ -8449,6 +9483,53 @@
         "node": ">=4"
       }
     },
+    "node_modules/postcss-svgo": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/postcss-svgo/-/postcss-svgo-8.0.0.tgz",
+      "integrity": "sha512-Q2fMSYEiNE1ioDc/3sxvI24NdgA/MJno2XLNpOxgv8aCcJbym8mZY10/lDY5+AWCIc3Aiqzy2Wcp9/zaIXBZgQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "postcss-value-parser": "^4.2.0",
+        "svgo": "^4.0.1"
+      },
+      "engines": {
+        "node": "^22.11.0 || ^24.11.0 || >=26.0"
+      },
+      "peerDependencies": {
+        "postcss": "^8.5.14"
+      }
+    },
+    "node_modules/postcss-unique-selectors": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/postcss-unique-selectors/-/postcss-unique-selectors-8.0.0.tgz",
+      "integrity": "sha512-iObuolUX+ITJfMU2QQFQdh31JgSjNLPNjVs6YGAqBHvOvAWXMMNget6donQl83aQaeS32i5XeKZURUW/WBxIUw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "postcss-selector-parser": "^7.1.1"
+      },
+      "engines": {
+        "node": "^22.11.0 || ^24.11.0 || >=26.0"
+      },
+      "peerDependencies": {
+        "postcss": "^8.5.14"
+      }
+    },
+    "node_modules/postcss-unique-selectors/node_modules/postcss-selector-parser": {
+      "version": "7.1.1",
+      "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-7.1.1.tgz",
+      "integrity": "sha512-orRsuYpJVw8LdAwqqLykBj9ecS5/cRHlI5+nvTo8LcCKmzDmqVORXtOIYEEQuL9D4BxtA1lm5isAqzQZCoQ6Eg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "cssesc": "^3.0.0",
+        "util-deprecate": "^1.0.2"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
     "node_modules/postcss-value-parser": {
       "version": "4.2.0",
       "resolved": "https://registry.npmjs.org/postcss-value-parser/-/postcss-value-parser-4.2.0.tgz",
@@ -8465,6 +9546,16 @@
         "node": ">= 0.8.0"
       }
     },
+    "node_modules/pretty-hrtime": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/pretty-hrtime/-/pretty-hrtime-1.0.3.tgz",
+      "integrity": "sha512-66hKPCr+72mlfiSjlEB1+45IjXSqvVAIy6mocupoww4tBFE9R9IhwwUGoI4G++Tc9Aq+2rxOt0RFU6gPcrte0A==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
     "node_modules/process": {
       "version": "0.11.10",
       "resolved": "https://registry.npmjs.org/process/-/process-0.11.10.tgz",
@@ -8605,6 +9696,26 @@
         "node": ">= 0.8"
       }
     },
+    "node_modules/read-cache": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/read-cache/-/read-cache-1.0.0.tgz",
+      "integrity": "sha512-Owdv/Ft7IjOgm/i0xvNDZ1LrRANRfew4b2prF3OWMQLxLfu3bS8FVhCsrSCMK4lR56Y9ya+AThoTpDCTxCmpRA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "pify": "^2.3.0"
+      }
+    },
+    "node_modules/read-cache/node_modules/pify": {
+      "version": "2.3.0",
+      "resolved": "https://registry.npmjs.org/pify/-/pify-2.3.0.tgz",
+      "integrity": "sha512-udgsAY+fTnvv7kI7aaxbqwWNb0AHiB0qBO89PZKPkoTmGOgdbrHDKD+0B2X4uTfJ/FT1R09r9gTsjUjNJotuog==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
     "node_modules/read-pkg": {
       "version": "5.2.0",
       "resolved": "https://registry.npmjs.org/read-pkg/-/read-pkg-5.2.0.tgz",
@@ -9016,10 +10127,14 @@
       "dev": true
     },
     "node_modules/sax": {
-      "version": "1.2.4",
-      "resolved": "https://registry.npmjs.org/sax/-/sax-1.2.4.tgz",
-      "integrity": "sha512-NqVDv9TpANUjFm0N8uM5GxL36UgKi9/atZw+x7YFnQ8ckwFGKrl4xX4yWtrey3UJm5nP1kUbnYgLopqWNSRhWw==",
-      "dev": true
+      "version": "1.6.0",
+      "resolved": "https://registry.npmjs.org/sax/-/sax-1.6.0.tgz",
+      "integrity": "sha512-6R3J5M4AcbtLUdZmRv2SygeVaM7IhrLXu9BmnOGmmACak8fiUtOsYNWUS4uK7upbmHIBbLBeFeI//477BKLBzA==",
+      "dev": true,
+      "license": "BlueOak-1.0.0",
+      "engines": {
+        "node": ">=11.0.0"
+      }
     },
     "node_modules/semver": {
       "version": "6.3.0",
@@ -9459,6 +10574,37 @@
       "integrity": "sha1-eVjHk+R+MuB9K1yv5cC/jhLneQI=",
       "dev": true
     },
+    "node_modules/stylehacks": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/stylehacks/-/stylehacks-8.0.0.tgz",
+      "integrity": "sha512-sWyjaJvBqHoVKYPbQ8JRvrGSPaYWtWrJsU+fGVtwKB1GE1rRPu3rC7T6UCuXLoL00Dwb+tsHe2T904r8Vnsx8w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "browserslist": "^4.28.2",
+        "postcss-selector-parser": "^7.1.1"
+      },
+      "engines": {
+        "node": "^22.11.0 || ^24.11.0 || >=26.0"
+      },
+      "peerDependencies": {
+        "postcss": "^8.5.14"
+      }
+    },
+    "node_modules/stylehacks/node_modules/postcss-selector-parser": {
+      "version": "7.1.1",
+      "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-7.1.1.tgz",
+      "integrity": "sha512-orRsuYpJVw8LdAwqqLykBj9ecS5/cRHlI5+nvTo8LcCKmzDmqVORXtOIYEEQuL9D4BxtA1lm5isAqzQZCoQ6Eg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "cssesc": "^3.0.0",
+        "util-deprecate": "^1.0.2"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
     "node_modules/stylelint": {
       "version": "14.5.1",
       "resolved": "https://registry.npmjs.org/stylelint/-/stylelint-14.5.1.tgz",
@@ -9597,6 +10743,42 @@
       "integrity": "sha1-WPcc7jvVGbWdSyqEO2x95krAR2Q=",
       "dev": true
     },
+    "node_modules/svgo": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/svgo/-/svgo-4.0.1.tgz",
+      "integrity": "sha512-XDpWUOPC6FEibaLzjfe0ucaV0YrOjYotGJO1WpF0Zd+n6ZGEQUsSugaoLq9QkEZtAfQIxT42UChcssDVPP3+/w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "commander": "^11.1.0",
+        "css-select": "^5.1.0",
+        "css-tree": "^3.0.1",
+        "css-what": "^6.1.0",
+        "csso": "^5.0.5",
+        "picocolors": "^1.1.1",
+        "sax": "^1.5.0"
+      },
+      "bin": {
+        "svgo": "bin/svgo.js"
+      },
+      "engines": {
+        "node": ">=16"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/svgo"
+      }
+    },
+    "node_modules/svgo/node_modules/commander": {
+      "version": "11.1.0",
+      "resolved": "https://registry.npmjs.org/commander/-/commander-11.1.0.tgz",
+      "integrity": "sha512-yPVavfyCcRhmorC7rWlkHn15b4wDVgVmBA7kV4QVBsF7kv/9TKJAbAXVTxvTnwP8HHKjRCJDClKbciiYS7p0DQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=16"
+      }
+    },
     "node_modules/synckit": {
       "version": "0.9.2",
       "resolved": "https://registry.npmjs.org/synckit/-/synckit-0.9.2.tgz",
@@ -9688,6 +10870,13 @@
         "node": ">=8"
       }
     },
+    "node_modules/thenby": {
+      "version": "1.4.1",
+      "resolved": "https://registry.npmjs.org/thenby/-/thenby-1.4.1.tgz",
+      "integrity": "sha512-D5a/bO0KdalOE3q8MlrRmSxjbKZHT3MQmXkJP+r97Vw8MMwOZKOwUSEyTtK7eSMj2y0kyAjpYMRMZmmLw1FtNQ==",
+      "dev": true,
+      "license": "Apache-2.0"
+    },
     "node_modules/through2": {
       "version": "0.6.5",
       "resolved": "https://registry.npmjs.org/through2/-/through2-0.6.5.tgz",
@@ -9739,25 +10928,31 @@
       "dev": true
     },
     "node_modules/tinyglobby": {
-      "version": "0.2.10",
-      "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.10.tgz",
-      "integrity": "sha512-Zc+8eJlFMvgatPZTl6A9L/yht8QqdmUNtURHaKZLmKBE12hNPSrqNkUp2cs3M/UKmNVVAMFQYSjYIVHDjW5zew==",
+      "version": "0.2.16",
+      "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.16.tgz",
+      "integrity": "sha512-pn99VhoACYR8nFHhxqix+uvsbXineAasWm5ojXoN8xEwK5Kd3/TrhNn1wByuD52UxWRLy8pu+kRMniEi6Eq9Zg==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "fdir": "^6.4.2",
-        "picomatch": "^4.0.2"
+        "fdir": "^6.5.0",
+        "picomatch": "^4.0.4"
       },
       "engines": {
         "node": ">=12.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/SuperchupuDev"
       }
     },
     "node_modules/tinyglobby/node_modules/fdir": {
-      "version": "6.4.2",
-      "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.4.2.tgz",
-      "integrity": "sha512-KnhMXsKSPZlAhp7+IjUkRZKPb4fUyccpDrdFXbi4QL1qkmFh9kVY09Yox+n4MaOb3lHZ1Tv829C3oaaXoMYPDQ==",
+      "version": "6.5.0",
+      "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz",
+      "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==",
       "dev": true,
       "license": "MIT",
+      "engines": {
+        "node": ">=12.0.0"
+      },
       "peerDependencies": {
         "picomatch": "^3 || ^4"
       },
@@ -9772,6 +10967,7 @@
       "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.4.tgz",
       "integrity": "sha512-QP88BAKvMam/3NxH6vj2o21R6MjxZUAd6nlwAS/pnGvN9IVLocLHxGYIzFhg6fUQ+5th6P4dv4eW9jX3DSIj7A==",
       "dev": true,
+      "license": "MIT",
       "engines": {
         "node": ">=12"
       },
@@ -10031,6 +11227,37 @@
         "node": ">= 0.8"
       }
     },
+    "node_modules/update-browserslist-db": {
+      "version": "1.2.3",
+      "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.2.3.tgz",
+      "integrity": "sha512-Js0m9cx+qOgDxo0eMiFGEueWztz+d4+M3rGlmKPT+T4IS/jP4ylw3Nwpu6cpTTP8R1MAC1kF4VbdLt3ARf209w==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/browserslist"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/browserslist"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "escalade": "^3.2.0",
+        "picocolors": "^1.1.1"
+      },
+      "bin": {
+        "update-browserslist-db": "cli.js"
+      },
+      "peerDependencies": {
+        "browserslist": ">= 4.21.0"
+      }
+    },
     "node_modules/uri-js": {
       "version": "4.4.1",
       "resolved": "https://registry.npmjs.org/uri-js/-/uri-js-4.4.1.tgz",
@@ -11600,6 +12827,12 @@
         "@babel/helper-validator-identifier": "^7.28.5"
       }
     },
+    "@colordx/core": {
+      "version": "5.4.3",
+      "resolved": "https://registry.npmjs.org/@colordx/core/-/core-5.4.3.tgz",
+      "integrity": "sha512-kIxYSfA5T8HXjav55UaaH/o/cKivF6jCCGIb8eqtcsfI46wsvlSiT8jMDyrl779qLec3c2c2oHBZo4oAhvbjrQ==",
+      "dev": true
+    },
     "@colors/colors": {
       "version": "1.5.0",
       "resolved": "https://registry.npmjs.org/@colors/colors/-/colors-1.5.0.tgz",
@@ -12945,6 +14178,19 @@
       "integrity": "sha1-x57Zf380y48robyXkLzDZkdLS3k=",
       "dev": true
     },
+    "autoprefixer": {
+      "version": "10.5.0",
+      "resolved": "https://registry.npmjs.org/autoprefixer/-/autoprefixer-10.5.0.tgz",
+      "integrity": "sha512-FMhOoZV4+qR6aTUALKX2rEqGG+oyATvwBt9IIzVR5rMa2HRWPkxf+P+PAJLD1I/H5/II+HuZcBJYEFBpq39ong==",
+      "dev": true,
+      "requires": {
+        "browserslist": "^4.28.2",
+        "caniuse-lite": "^1.0.30001787",
+        "fraction.js": "^5.3.4",
+        "picocolors": "^1.1.1",
+        "postcss-value-parser": "^4.2.0"
+      }
+    },
     "awesomplete": {
       "version": "1.1.5",
       "resolved": "https://registry.npmjs.org/awesomplete/-/awesomplete-1.1.5.tgz",
@@ -13033,6 +14279,12 @@
       "integrity": "sha512-lGe34o6EHj9y3Kts9R4ZYs/Gr+6N7MCaMlIFA3F1R2O5/m7K06AxfSeO5530PEERE6/WyEg3lsuyw4GHlPZHog==",
       "dev": true
     },
+    "baseline-browser-mapping": {
+      "version": "2.10.32",
+      "resolved": "https://registry.npmjs.org/baseline-browser-mapping/-/baseline-browser-mapping-2.10.32.tgz",
+      "integrity": "sha512-wbPvpyjJPC0zdfdKXxqEL3Ea+bOMD/87X4lftiJkkaBiuG6ALQy1SLmEd7BSmVCuwCQsBrCamgBoLyfFDD1EPg==",
+      "dev": true
+    },
     "bcrypt-pbkdf": {
       "version": "1.0.2",
       "resolved": "https://registry.npmjs.org/bcrypt-pbkdf/-/bcrypt-pbkdf-1.0.2.tgz",
@@ -13117,6 +14369,12 @@
         }
       }
     },
+    "boolbase": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/boolbase/-/boolbase-1.0.0.tgz",
+      "integrity": "sha512-JZOSA7Mo9sNGB8+UjSgzdLtokWAky1zbztM3WRLCbZ70/3cTANmQmOdR7y2g+J0e2WXywy1yS468tY+IruqEww==",
+      "dev": true
+    },
     "brace-expansion": {
       "version": "1.1.11",
       "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz",
@@ -13137,16 +14395,16 @@
       }
     },
     "browserslist": {
-      "version": "4.19.1",
-      "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.19.1.tgz",
-      "integrity": "sha512-u2tbbG5PdKRTUoctO3NBD8FQ5HdPh1ZXPHzp1rwaa5jTc+RV9/+RlWiAIKmjRPQF+xbGM9Kklj5bZQFa2s/38A==",
+      "version": "4.28.2",
+      "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.28.2.tgz",
+      "integrity": "sha512-48xSriZYYg+8qXna9kwqjIVzuQxi+KYWp2+5nCYnYKPTr0LvD89Jqk2Or5ogxz0NUMfIjhh2lIUX/LyX9B4oIg==",
       "dev": true,
       "requires": {
-        "caniuse-lite": "^1.0.30001286",
-        "electron-to-chromium": "^1.4.17",
-        "escalade": "^3.1.1",
-        "node-releases": "^2.0.1",
-        "picocolors": "^1.0.0"
+        "baseline-browser-mapping": "^2.10.12",
+        "caniuse-lite": "^1.0.30001782",
+        "electron-to-chromium": "^1.5.328",
+        "node-releases": "^2.0.36",
+        "update-browserslist-db": "^1.2.3"
       }
     },
     "buffer": {
@@ -13219,10 +14477,22 @@
         "quick-lru": "^4.0.1"
       }
     },
+    "caniuse-api": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/caniuse-api/-/caniuse-api-3.0.0.tgz",
+      "integrity": "sha512-bsTwuIg/BZZK/vreVTYYbSWoe2F+71P7K5QGEX+pT250DZbfU1MQ5prOKpPR+LL6uWKK3KMwMCAS74QB3Um1uw==",
+      "dev": true,
+      "requires": {
+        "browserslist": "^4.0.0",
+        "caniuse-lite": "^1.0.0",
+        "lodash.memoize": "^4.1.2",
+        "lodash.uniq": "^4.5.0"
+      }
+    },
     "caniuse-lite": {
-      "version": "1.0.30001312",
-      "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001312.tgz",
-      "integrity": "sha512-Wiz1Psk2MEK0pX3rUzWaunLTZzqS2JYZFzNKqAiJGiuxIjRPLgV6+VDPOg6lQOUxmDwhTlh198JsTTi8Hzw6aQ==",
+      "version": "1.0.30001793",
+      "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001793.tgz",
+      "integrity": "sha512-iwSsYWaCOoh26cV8NwNRViHlrfUvYsHDfRVcbtmw0Kg6PJIZZXwMkj1442FYLBGkeUf1juAsU3DTfxW579mrPA==",
       "dev": true
     },
     "caseless": {
@@ -13292,15 +14562,6 @@
         }
       }
     },
-    "clean-css": {
-      "version": "5.3.3",
-      "resolved": "https://registry.npmjs.org/clean-css/-/clean-css-5.3.3.tgz",
-      "integrity": "sha512-D5J+kHaVb/wKSFcyyV75uCn8fiY4sV38XJoe4CUyGQ+mOU/fMVYUdH1hJC+CJQ5uY3EnW27SbJYS4X8BiLrAFg==",
-      "dev": true,
-      "requires": {
-        "source-map": "~0.6.0"
-      }
-    },
     "clean-package": {
       "version": "2.2.0",
       "resolved": "https://registry.npmjs.org/clean-package/-/clean-package-2.2.0.tgz",
@@ -13796,12 +15057,122 @@
       "integrity": "sha512-PriDuifDt4u4rkDgnqRCLnjfMatufLmWNfQnGCq34xZwpY3oabwhB9SqRBmuvWUgndbemCFlKqg+nO7C2q0SBw==",
       "dev": true
     },
+    "css-select": {
+      "version": "5.2.2",
+      "resolved": "https://registry.npmjs.org/css-select/-/css-select-5.2.2.tgz",
+      "integrity": "sha512-TizTzUddG/xYLA3NXodFM0fSbNizXjOKhqiQQwvhlspadZokn1KDy0NZFS0wuEubIYAV5/c1/lAr0TaaFXEXzw==",
+      "dev": true,
+      "requires": {
+        "boolbase": "^1.0.0",
+        "css-what": "^6.1.0",
+        "domhandler": "^5.0.2",
+        "domutils": "^3.0.1",
+        "nth-check": "^2.0.1"
+      }
+    },
+    "css-tree": {
+      "version": "3.2.1",
+      "resolved": "https://registry.npmjs.org/css-tree/-/css-tree-3.2.1.tgz",
+      "integrity": "sha512-X7sjQzceUhu1u7Y/ylrRZFU2FS6LRiFVp6rKLPg23y3x3c3DOKAwuXGDp+PAGjh6CSnCjYeAul8pcT8bAl+lSA==",
+      "dev": true,
+      "requires": {
+        "mdn-data": "2.27.1",
+        "source-map-js": "^1.2.1"
+      }
+    },
+    "css-what": {
+      "version": "6.2.2",
+      "resolved": "https://registry.npmjs.org/css-what/-/css-what-6.2.2.tgz",
+      "integrity": "sha512-u/O3vwbptzhMs3L1fQE82ZSLHQQfto5gyZzwteVIEyeaY5Fc7R4dapF/BvRoSYFeqfBk4m0V1Vafq5Pjv25wvA==",
+      "dev": true
+    },
     "cssesc": {
       "version": "3.0.0",
       "resolved": "https://registry.npmjs.org/cssesc/-/cssesc-3.0.0.tgz",
       "integrity": "sha512-/Tb/JcjK111nNScGob5MNtsntNM1aCNUDipB/TkwZFhyDrrE47SOx/18wF2bbjgc3ZzCSKW1T5nt5EbFoAz/Vg==",
       "dev": true
     },
+    "cssnano": {
+      "version": "8.0.1",
+      "resolved": "https://registry.npmjs.org/cssnano/-/cssnano-8.0.1.tgz",
+      "integrity": "sha512-oSiOnPQNNYjusTUlYJiE6xvFQG4don3N0QavaoV1BxIsC1zjvxOwikXlR7lG1EVmZNDDaJkHbQx1VRB8kaoMHA==",
+      "dev": true,
+      "requires": {
+        "cssnano-preset-default": "^8.0.1",
+        "lilconfig": "^3.1.3"
+      }
+    },
+    "cssnano-preset-default": {
+      "version": "8.0.1",
+      "resolved": "https://registry.npmjs.org/cssnano-preset-default/-/cssnano-preset-default-8.0.1.tgz",
+      "integrity": "sha512-OTdKeYMlvQ8KBgyej5ysktnWJoeyo7rGrVnm+bdpIHGvxhbTGPsOkB+7T1EdTuX00dGlQQb2UEbSPB1OpMXULw==",
+      "dev": true,
+      "requires": {
+        "browserslist": "^4.28.2",
+        "cssnano-utils": "^6.0.0",
+        "postcss-calc": "^10.1.1",
+        "postcss-colormin": "^8.0.0",
+        "postcss-convert-values": "^8.0.0",
+        "postcss-discard-comments": "^8.0.0",
+        "postcss-discard-duplicates": "^8.0.0",
+        "postcss-discard-empty": "^8.0.0",
+        "postcss-discard-overridden": "^8.0.0",
+        "postcss-merge-longhand": "^8.0.0",
+        "postcss-merge-rules": "^8.0.0",
+        "postcss-minify-font-values": "^8.0.0",
+        "postcss-minify-gradients": "^8.0.0",
+        "postcss-minify-params": "^8.0.0",
+        "postcss-minify-selectors": "^8.0.1",
+        "postcss-normalize-charset": "^8.0.0",
+        "postcss-normalize-display-values": "^8.0.0",
+        "postcss-normalize-positions": "^8.0.0",
+        "postcss-normalize-repeat-style": "^8.0.0",
+        "postcss-normalize-string": "^8.0.0",
+        "postcss-normalize-timing-functions": "^8.0.0",
+        "postcss-normalize-unicode": "^8.0.0",
+        "postcss-normalize-url": "^8.0.0",
+        "postcss-normalize-whitespace": "^8.0.0",
+        "postcss-ordered-values": "^8.0.0",
+        "postcss-reduce-initial": "^8.0.0",
+        "postcss-reduce-transforms": "^8.0.0",
+        "postcss-svgo": "^8.0.0",
+        "postcss-unique-selectors": "^8.0.0"
+      }
+    },
+    "cssnano-utils": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/cssnano-utils/-/cssnano-utils-6.0.0.tgz",
+      "integrity": "sha512-ztS9W/+uaDn+bkYmDhs+GdMveHJ3CL8IPNHpRqDUQXv5GJOTQAJjV1XUOInr9esLXSabQV1pLRZlJpyUwEqDyQ==",
+      "dev": true,
+      "requires": {}
+    },
+    "csso": {
+      "version": "5.0.5",
+      "resolved": "https://registry.npmjs.org/csso/-/csso-5.0.5.tgz",
+      "integrity": "sha512-0LrrStPOdJj+SPCCrGhzryycLjwcgUSHBtxNA8aIDxf0GLsRh1cKYhB00Gd1lDOS4yGH69+SNn13+TWbVHETFQ==",
+      "dev": true,
+      "requires": {
+        "css-tree": "~2.2.0"
+      },
+      "dependencies": {
+        "css-tree": {
+          "version": "2.2.1",
+          "resolved": "https://registry.npmjs.org/css-tree/-/css-tree-2.2.1.tgz",
+          "integrity": "sha512-OA0mILzGc1kCOCSJerOeqDxDQ4HOh+G8NbOJFOTgOCzpw7fCBubk0fEyxp8AgOL/jvLgYA/uV0cMbe43ElF1JA==",
+          "dev": true,
+          "requires": {
+            "mdn-data": "2.0.28",
+            "source-map-js": "^1.0.1"
+          }
+        },
+        "mdn-data": {
+          "version": "2.0.28",
+          "resolved": "https://registry.npmjs.org/mdn-data/-/mdn-data-2.0.28.tgz",
+          "integrity": "sha512-aylIc7Z9y4yzHYAJNuESG3hfhC+0Ibp/MAMiaOZgNv4pmEdFyfZhhhny4MNiAfWdBQ1RQ2mfDWmM1x8SvGyp8g==",
+          "dev": true
+        }
+      }
+    },
     "custom-event": {
       "version": "1.0.1",
       "resolved": "https://registry.npmjs.org/custom-event/-/custom-event-1.0.1.tgz",
@@ -13894,6 +15265,12 @@
       "integrity": "sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==",
       "dev": true
     },
+    "dependency-graph": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/dependency-graph/-/dependency-graph-1.0.0.tgz",
+      "integrity": "sha512-cW3gggJ28HZ/LExwxP2B++aiKxhJXMSIt9K48FOXQkm+vuG5gyatXnLsONRJdzO/7VfjDIiaOOa/bs4l464Lwg==",
+      "dev": true
+    },
     "destroy": {
       "version": "1.2.0",
       "resolved": "https://registry.npmjs.org/destroy/-/destroy-1.2.0.tgz",
@@ -13933,12 +15310,57 @@
         "void-elements": "^2.0.0"
       }
     },
+    "dom-serializer": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/dom-serializer/-/dom-serializer-2.0.0.tgz",
+      "integrity": "sha512-wIkAryiqt/nV5EQKqQpo3SToSOV9J0DnbJqwK7Wv/Trc92zIAYZ4FlMu+JPFW1DfGFt81ZTCGgDEabffXeLyJg==",
+      "dev": true,
+      "requires": {
+        "domelementtype": "^2.3.0",
+        "domhandler": "^5.0.2",
+        "entities": "^4.2.0"
+      },
+      "dependencies": {
+        "entities": {
+          "version": "4.5.0",
+          "resolved": "https://registry.npmjs.org/entities/-/entities-4.5.0.tgz",
+          "integrity": "sha512-V0hjH4dGPh9Ao5p0MoRY6BVqtwCjhz6vI5LT8AJ55H+4g9/4vbHx1I54fS0XuclLhDHArPQCiMjDxjaL8fPxhw==",
+          "dev": true
+        }
+      }
+    },
     "dom-walk": {
       "version": "0.1.2",
       "resolved": "https://registry.npmjs.org/dom-walk/-/dom-walk-0.1.2.tgz",
       "integrity": "sha512-6QvTW9mrGeIegrFXdtQi9pk7O/nSK6lSdXW2eqUspN5LWD7UTji2Fqw5V2YLjBpHEoU9Xl/eUWNpDeZvoyOv2w==",
       "dev": true
     },
+    "domelementtype": {
+      "version": "2.3.0",
+      "resolved": "https://registry.npmjs.org/domelementtype/-/domelementtype-2.3.0.tgz",
+      "integrity": "sha512-OLETBj6w0OsagBwdXnPdN0cnMfF9opN69co+7ZrbfPGrdpPVNBUj02spi6B1N7wChLQiPn4CSH/zJvXw56gmHw==",
+      "dev": true
+    },
+    "domhandler": {
+      "version": "5.0.3",
+      "resolved": "https://registry.npmjs.org/domhandler/-/domhandler-5.0.3.tgz",
+      "integrity": "sha512-cgwlv/1iFQiFnU96XXgROh8xTeetsnJiDsTc7TYCLFd9+/WNkIqPTxiM/8pSd8VIrhXGTf1Ny1q1hquVqDJB5w==",
+      "dev": true,
+      "requires": {
+        "domelementtype": "^2.3.0"
+      }
+    },
+    "domutils": {
+      "version": "3.2.2",
+      "resolved": "https://registry.npmjs.org/domutils/-/domutils-3.2.2.tgz",
+      "integrity": "sha512-6kZKyUajlDuqlHKVX1w7gyslj9MPIXzIFiz/rGu35uC1wMi+kMhQwGhl4lt9unC9Vb9INnY9Z3/ZA3+FhASLaw==",
+      "dev": true,
+      "requires": {
+        "dom-serializer": "^2.0.0",
+        "domelementtype": "^2.3.0",
+        "domhandler": "^5.0.3"
+      }
+    },
     "dot-prop": {
       "version": "6.0.1",
       "resolved": "https://registry.npmjs.org/dot-prop/-/dot-prop-6.0.1.tgz",
@@ -13965,9 +15387,9 @@
       "dev": true
     },
     "electron-to-chromium": {
-      "version": "1.4.71",
-      "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.4.71.tgz",
-      "integrity": "sha512-Hk61vXXKRb2cd3znPE9F+2pLWdIOmP7GjiTj45y6L3W/lO+hSnUSUhq+6lEaERWBdZOHbk2s3YV5c9xVl3boVw==",
+      "version": "1.5.363",
+      "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.363.tgz",
+      "integrity": "sha512-VjUKPyWzGnT1fujlkEGC/BvN70Hh70KXtAqcmniXviYlJC/ivcT+BWGPyxWVbJZLfvtKR6dqg1L7T7pgAMBtWA==",
       "dev": true
     },
     "emoji-regex": {
@@ -14080,9 +15502,9 @@
       "dev": true
     },
     "escalade": {
-      "version": "3.1.1",
-      "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.1.1.tgz",
-      "integrity": "sha512-k0er2gUkLf8O0zKJiAhmkTnJlTvINGv7ygDNPbeIsX/TJjGJZHuh9B2UxbsaEkmlEo9MfhrSzmhIlhRlI2GXnw==",
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz",
+      "integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==",
       "dev": true
     },
     "escape-html": {
@@ -14640,6 +16062,12 @@
         "mime-types": "^2.1.12"
       }
     },
+    "fraction.js": {
+      "version": "5.3.4",
+      "resolved": "https://registry.npmjs.org/fraction.js/-/fraction.js-5.3.4.tgz",
+      "integrity": "sha512-1X1NTtiJphryn/uLQz3whtY6jK3fTqoE3ohKs0tT+Ujr1W59oopxmoEh7Lu5p6vBaPbgoM0bzveAW4Qi5RyWDQ==",
+      "dev": true
+    },
     "fs-constants": {
       "version": "1.0.0",
       "resolved": "https://registry.npmjs.org/fs-constants/-/fs-constants-1.0.0.tgz",
@@ -15885,15 +17313,6 @@
         }
       }
     },
-    "less-plugin-clean-css": {
-      "version": "1.6.0",
-      "resolved": "https://registry.npmjs.org/less-plugin-clean-css/-/less-plugin-clean-css-1.6.0.tgz",
-      "integrity": "sha512-jwXX6WlXT57OVCXa5oBJBaJq1b4s1BOKeEEoAL2UTeEitogQWfTcBbLT/vow9pl0N0MXV8Mb4KyhTGG0YbEKyQ==",
-      "dev": true,
-      "requires": {
-        "clean-css": "5.3.3"
-      }
-    },
     "levn": {
       "version": "0.4.1",
       "resolved": "https://registry.npmjs.org/levn/-/levn-0.4.1.tgz",
@@ -15904,6 +17323,12 @@
         "type-check": "~0.4.0"
       }
     },
+    "lilconfig": {
+      "version": "3.1.3",
+      "resolved": "https://registry.npmjs.org/lilconfig/-/lilconfig-3.1.3.tgz",
+      "integrity": "sha512-/vlFKAoH5Cgt3Ie+JLhRbwOsCQePABiU3tJ1egGvyQ+33R/vcwM2Zl2QR/LzjsBeItPt3oSVXapn+m4nQDvpzw==",
+      "dev": true
+    },
     "lines-and-columns": {
       "version": "1.2.4",
       "resolved": "https://registry.npmjs.org/lines-and-columns/-/lines-and-columns-1.2.4.tgz",
@@ -15988,6 +17413,12 @@
       "integrity": "sha1-fFJqUtibRcRcxpC4gWO+BJf1UMs=",
       "dev": true
     },
+    "lodash.memoize": {
+      "version": "4.1.2",
+      "resolved": "https://registry.npmjs.org/lodash.memoize/-/lodash.memoize-4.1.2.tgz",
+      "integrity": "sha512-t7j+NzmgnQzTAYXcsHYLgimltOV1MXHtlOWf6GjL9Kj8GK5FInw5JotxvbOs+IvV1/Dzo04/fCGfLVs7aXb4Ag==",
+      "dev": true
+    },
     "lodash.merge": {
       "version": "4.6.2",
       "resolved": "https://registry.npmjs.org/lodash.merge/-/lodash.merge-4.6.2.tgz",
@@ -16006,6 +17437,12 @@
       "integrity": "sha1-SLtQiECfFvGCFmZkHETdGqrjzYg=",
       "dev": true
     },
+    "lodash.uniq": {
+      "version": "4.5.0",
+      "resolved": "https://registry.npmjs.org/lodash.uniq/-/lodash.uniq-4.5.0.tgz",
+      "integrity": "sha512-xfBaXQd9ryd9dlSDvnvI0lvxfLJlYAZzXomUYzLKtUeOQvOP5piqAWuGtrhWeqaXK9hhoM/iyJc5AV+XfsX3HQ==",
+      "dev": true
+    },
     "log4js": {
       "version": "6.4.1",
       "resolved": "https://registry.npmjs.org/log4js/-/log4js-6.4.1.tgz",
@@ -16081,6 +17518,12 @@
       "integrity": "sha512-APMBEanjybaPzUrfqU0IMU5I0AswKMH7k8OTLs0vvV4KZpExkTkY87nR/zpbuTPj+gARop7aGUbl11pnDfW6xg==",
       "dev": true
     },
+    "mdn-data": {
+      "version": "2.27.1",
+      "resolved": "https://registry.npmjs.org/mdn-data/-/mdn-data-2.27.1.tgz",
+      "integrity": "sha512-9Yubnt3e8A0OKwxYSXyhLymGW4sCufcLG6VdiDdUGVkPhpqLxlvP5vl1983gQjJl3tqbrM731mjaZaP68AgosQ==",
+      "dev": true
+    },
     "mdurl": {
       "version": "1.0.1",
       "resolved": "https://registry.npmjs.org/mdurl/-/mdurl-1.0.1.tgz",
@@ -16222,9 +17665,9 @@
       "dev": true
     },
     "nanoid": {
-      "version": "3.3.11",
-      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.11.tgz",
-      "integrity": "sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w==",
+      "version": "3.3.12",
+      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.12.tgz",
+      "integrity": "sha512-ZB9RH/39qpq5Vu6Y+NmUaFhQR6pp+M2Xt76XBnEwDaGcVAqhlvxrl3B2bKS5D3NH3QR76v3aSrKaF/Kiy7lEtQ==",
       "dev": true
     },
     "natural-compare": {
@@ -16331,9 +17774,9 @@
       }
     },
     "node-releases": {
-      "version": "2.0.2",
-      "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.2.tgz",
-      "integrity": "sha512-XxYDdcQ6eKqp/YjI+tb2C5WM2LgjnZrfYg4vgQt49EK268b6gYCHsBLrK2qvJo4FmCtqmKezb0WZFK4fkrZNsg==",
+      "version": "2.0.46",
+      "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.46.tgz",
+      "integrity": "sha512-GYVXHE2KnrzAfsAjl4uP++evGFCrAU1jta4ubEjIG7YWt/64Gqv66a30yKwWczVjA6j3bM4nBwH7Pk1JmDHaxQ==",
       "dev": true
     },
     "normalize-package-data": {
@@ -16380,6 +17823,15 @@
         "path-key": "^3.0.0"
       }
     },
+    "nth-check": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/nth-check/-/nth-check-2.1.1.tgz",
+      "integrity": "sha512-lqjrjmaOoAnWfMmBPL+XNnynZh2+swxiX3WUE0s4yEHI6m+AwrK2UZOimIRl3X/4QctVqS8AiZjFqyOGrMXb/w==",
+      "dev": true,
+      "requires": {
+        "boolbase": "^1.0.0"
+      }
+    },
     "oauth-sign": {
       "version": "0.9.0",
       "resolved": "https://registry.npmjs.org/oauth-sign/-/oauth-sign-0.9.0.tgz",
@@ -16676,16 +18128,172 @@
       "dev": true
     },
     "postcss": {
-      "version": "8.5.10",
-      "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.10.tgz",
-      "integrity": "sha512-pMMHxBOZKFU6HgAZ4eyGnwXF/EvPGGqUr0MnZ5+99485wwW41kW91A4LOGxSHhgugZmSChL5AlElNdwlNgcnLQ==",
+      "version": "8.5.15",
+      "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.15.tgz",
+      "integrity": "sha512-FfR8sjd4em2T6fb3I2MwAJU7HWVMr9zba+enmQeeWFfCbm+UOC/0X4DS8XtpUTMwWMGbjKYP7xjfNekzyGmB3A==",
       "dev": true,
       "requires": {
-        "nanoid": "^3.3.11",
+        "nanoid": "^3.3.12",
         "picocolors": "^1.1.1",
         "source-map-js": "^1.2.1"
       }
     },
+    "postcss-calc": {
+      "version": "10.1.1",
+      "resolved": "https://registry.npmjs.org/postcss-calc/-/postcss-calc-10.1.1.tgz",
+      "integrity": "sha512-NYEsLHh8DgG/PRH2+G9BTuUdtf9ViS+vdoQ0YA5OQdGsfN4ztiwtDWNtBl9EKeqNMFnIu8IKZ0cLxEQ5r5KVMw==",
+      "dev": true,
+      "requires": {
+        "postcss-selector-parser": "^7.0.0",
+        "postcss-value-parser": "^4.2.0"
+      },
+      "dependencies": {
+        "postcss-selector-parser": {
+          "version": "7.1.1",
+          "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-7.1.1.tgz",
+          "integrity": "sha512-orRsuYpJVw8LdAwqqLykBj9ecS5/cRHlI5+nvTo8LcCKmzDmqVORXtOIYEEQuL9D4BxtA1lm5isAqzQZCoQ6Eg==",
+          "dev": true,
+          "requires": {
+            "cssesc": "^3.0.0",
+            "util-deprecate": "^1.0.2"
+          }
+        }
+      }
+    },
+    "postcss-cli": {
+      "version": "11.0.1",
+      "resolved": "https://registry.npmjs.org/postcss-cli/-/postcss-cli-11.0.1.tgz",
+      "integrity": "sha512-0UnkNPSayHKRe/tc2YGW6XnSqqOA9eqpiRMgRlV1S6HdGi16vwJBx7lviARzbV1HpQHqLLRH3o8vTcB0cLc+5g==",
+      "dev": true,
+      "requires": {
+        "chokidar": "^3.3.0",
+        "dependency-graph": "^1.0.0",
+        "fs-extra": "^11.0.0",
+        "picocolors": "^1.0.0",
+        "postcss-load-config": "^5.0.0",
+        "postcss-reporter": "^7.0.0",
+        "pretty-hrtime": "^1.0.3",
+        "read-cache": "^1.0.0",
+        "slash": "^5.0.0",
+        "tinyglobby": "^0.2.12",
+        "yargs": "^17.0.0"
+      },
+      "dependencies": {
+        "cliui": {
+          "version": "8.0.1",
+          "resolved": "https://registry.npmjs.org/cliui/-/cliui-8.0.1.tgz",
+          "integrity": "sha512-BSeNnyus75C4//NQ9gQt1/csTXyo/8Sb+afLAkzAptFuMsod9HFokGNudZpi/oQV73hnVK+sR+5PVRMd+Dr7YQ==",
+          "dev": true,
+          "requires": {
+            "string-width": "^4.2.0",
+            "strip-ansi": "^6.0.1",
+            "wrap-ansi": "^7.0.0"
+          }
+        },
+        "fs-extra": {
+          "version": "11.3.5",
+          "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-11.3.5.tgz",
+          "integrity": "sha512-eKpRKAovdpZtR1WopLHxlBWvAgPny3c4gX1G5Jhwmmw4XJj0ifSD5qB5TOo8hmA0wlRKDAOAhEE1yVPgs6Fgcg==",
+          "dev": true,
+          "requires": {
+            "graceful-fs": "^4.2.0",
+            "jsonfile": "^6.0.1",
+            "universalify": "^2.0.0"
+          }
+        },
+        "slash": {
+          "version": "5.1.0",
+          "resolved": "https://registry.npmjs.org/slash/-/slash-5.1.0.tgz",
+          "integrity": "sha512-ZA6oR3T/pEyuqwMgAKT0/hAv8oAXckzbkmR0UkUosQ+Mc4RxGoJkRmwHgHufaenlyAgE1Mxgpdcrf75y6XcnDg==",
+          "dev": true
+        },
+        "yargs": {
+          "version": "17.7.2",
+          "resolved": "https://registry.npmjs.org/yargs/-/yargs-17.7.2.tgz",
+          "integrity": "sha512-7dSzzRQ++CKnNI/krKnYRV7JKKPUXMEh61soaHKg9mrWEhzFWhFnxPxGl+69cD1Ou63C13NUPCnmIcrvqCuM6w==",
+          "dev": true,
+          "requires": {
+            "cliui": "^8.0.1",
+            "escalade": "^3.1.1",
+            "get-caller-file": "^2.0.5",
+            "require-directory": "^2.1.1",
+            "string-width": "^4.2.3",
+            "y18n": "^5.0.5",
+            "yargs-parser": "^21.1.1"
+          }
+        },
+        "yargs-parser": {
+          "version": "21.1.1",
+          "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-21.1.1.tgz",
+          "integrity": "sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw==",
+          "dev": true
+        }
+      }
+    },
+    "postcss-colormin": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/postcss-colormin/-/postcss-colormin-8.0.0.tgz",
+      "integrity": "sha512-KKwMmsSgsmdYXqrjQeqL3tnuIFtctiR1GEMHdjNpDpz/TCRkkkok2mMcreK2zVV3l7POWOmAkR2xYHUpRUK1DA==",
+      "dev": true,
+      "requires": {
+        "@colordx/core": "^5.4.3",
+        "browserslist": "^4.28.2",
+        "caniuse-api": "^3.0.0",
+        "postcss-value-parser": "^4.2.0"
+      }
+    },
+    "postcss-convert-values": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/postcss-convert-values/-/postcss-convert-values-8.0.0.tgz",
+      "integrity": "sha512-Ohtj3rNZWawTRePv5NCHTy8VJSdJ/G/uKuxcxJreOMichuqcT6uEl2TAnopVeJCJ/c13jaSqg7m63yFLM5zBsA==",
+      "dev": true,
+      "requires": {
+        "browserslist": "^4.28.2",
+        "postcss-value-parser": "^4.2.0"
+      }
+    },
+    "postcss-discard-comments": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/postcss-discard-comments/-/postcss-discard-comments-8.0.0.tgz",
+      "integrity": "sha512-zGpvVLj2sbagEp+BTVETvAfkZdGVA6rALNujDK/WTIjdf1/rQOxOG8BBzkI8UQgnw8SkL6xffAfbtGMHFypadw==",
+      "dev": true,
+      "requires": {
+        "postcss-selector-parser": "^7.1.1"
+      },
+      "dependencies": {
+        "postcss-selector-parser": {
+          "version": "7.1.1",
+          "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-7.1.1.tgz",
+          "integrity": "sha512-orRsuYpJVw8LdAwqqLykBj9ecS5/cRHlI5+nvTo8LcCKmzDmqVORXtOIYEEQuL9D4BxtA1lm5isAqzQZCoQ6Eg==",
+          "dev": true,
+          "requires": {
+            "cssesc": "^3.0.0",
+            "util-deprecate": "^1.0.2"
+          }
+        }
+      }
+    },
+    "postcss-discard-duplicates": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/postcss-discard-duplicates/-/postcss-discard-duplicates-8.0.0.tgz",
+      "integrity": "sha512-zjRyYmNGI3PTipKBBtCgExlmZXQn49KvKoaiNnR2g+iXxeNk7GY5Js2ULtZXPrCYeqjPagrzKIBNcBocvXCR7g==",
+      "dev": true,
+      "requires": {}
+    },
+    "postcss-discard-empty": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/postcss-discard-empty/-/postcss-discard-empty-8.0.0.tgz",
+      "integrity": "sha512-kxPJg6EqahbBvm+l7hpYYCtpsv8dlz7Tv6wJXUXZaeuY0WGS61DxfGdZR4uVB/Cx+yi3iOHQVSqpSHKMFaBg6Q==",
+      "dev": true,
+      "requires": {}
+    },
+    "postcss-discard-overridden": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/postcss-discard-overridden/-/postcss-discard-overridden-8.0.0.tgz",
+      "integrity": "sha512-sW2OWH3l9p0FmBSVr228uztFseqroZxwgD7SGF0Ks0dRPDttSo3P8FK5ZBLtWBH2A5+chpB0J2fB/T8heKHLBw==",
+      "dev": true,
+      "requires": {}
+    },
     "postcss-less": {
       "version": "6.0.0",
       "resolved": "https://registry.npmjs.org/postcss-less/-/postcss-less-6.0.0.tgz",
@@ -16693,12 +18301,238 @@
       "dev": true,
       "requires": {}
     },
+    "postcss-load-config": {
+      "version": "5.1.0",
+      "resolved": "https://registry.npmjs.org/postcss-load-config/-/postcss-load-config-5.1.0.tgz",
+      "integrity": "sha512-G5AJ+IX0aD0dygOE0yFZQ/huFFMSNneyfp0e3/bT05a8OfPC5FUoZRPfGijUdGOJNMewJiwzcHJXFafFzeKFVA==",
+      "dev": true,
+      "requires": {
+        "lilconfig": "^3.1.1",
+        "yaml": "^2.4.2"
+      },
+      "dependencies": {
+        "yaml": {
+          "version": "2.9.0",
+          "resolved": "https://registry.npmjs.org/yaml/-/yaml-2.9.0.tgz",
+          "integrity": "sha512-2AvhNX3mb8zd6Zy7INTtSpl1F15HW6Wnqj0srWlkKLcpYl/gMIMJiyuGq2KeI2YFxUPjdlB+3Lc10seMLtL4cA==",
+          "dev": true
+        }
+      }
+    },
     "postcss-media-query-parser": {
       "version": "0.2.3",
       "resolved": "https://registry.npmjs.org/postcss-media-query-parser/-/postcss-media-query-parser-0.2.3.tgz",
       "integrity": "sha1-J7Ocb02U+Bsac7j3Y1HGCeXO8kQ=",
       "dev": true
     },
+    "postcss-merge-longhand": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/postcss-merge-longhand/-/postcss-merge-longhand-8.0.0.tgz",
+      "integrity": "sha512-YDmAmQ8H+ljfomVpSXvr9NA0GP01fraQJqjWBYoMVGg6rOT+PJLwPyeVo2ekn4WB4ZVSH5ddtK3DTRxbz6CFzg==",
+      "dev": true,
+      "requires": {
+        "postcss-value-parser": "^4.2.0",
+        "stylehacks": "^8.0.0"
+      }
+    },
+    "postcss-merge-rules": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/postcss-merge-rules/-/postcss-merge-rules-8.0.0.tgz",
+      "integrity": "sha512-bgstL5mpi41dDpnYGDUcI3M814NWkCMcIWpwDqEHXkHg3BT7b4XRAfNEuwJncZOVn/67kVKvWzhfv/7xyrp2uQ==",
+      "dev": true,
+      "requires": {
+        "browserslist": "^4.28.2",
+        "caniuse-api": "^3.0.0",
+        "cssnano-utils": "^6.0.0",
+        "postcss-selector-parser": "^7.1.1"
+      },
+      "dependencies": {
+        "postcss-selector-parser": {
+          "version": "7.1.1",
+          "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-7.1.1.tgz",
+          "integrity": "sha512-orRsuYpJVw8LdAwqqLykBj9ecS5/cRHlI5+nvTo8LcCKmzDmqVORXtOIYEEQuL9D4BxtA1lm5isAqzQZCoQ6Eg==",
+          "dev": true,
+          "requires": {
+            "cssesc": "^3.0.0",
+            "util-deprecate": "^1.0.2"
+          }
+        }
+      }
+    },
+    "postcss-minify-font-values": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/postcss-minify-font-values/-/postcss-minify-font-values-8.0.0.tgz",
+      "integrity": "sha512-EnOHQEnSt6oH5NrL1DMFAQuwB2IOimFXTCzc9bKfUeH1jREbqIF5MAK4gQJQOC4mPUwJt4sWifAmNZ1qLu6j3Q==",
+      "dev": true,
+      "requires": {
+        "postcss-value-parser": "^4.2.0"
+      }
+    },
+    "postcss-minify-gradients": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/postcss-minify-gradients/-/postcss-minify-gradients-8.0.0.tgz",
+      "integrity": "sha512-43iAnYIGk0ZjNx5X/rkIcHi6dhmu/vEjY0kqfUfxPuJRO+V7jx8uKIdcnL0dpfNoC5J9TSh3EtzLWbq0gpqnWA==",
+      "dev": true,
+      "requires": {
+        "@colordx/core": "^5.4.3",
+        "cssnano-utils": "^6.0.0",
+        "postcss-value-parser": "^4.2.0"
+      }
+    },
+    "postcss-minify-params": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/postcss-minify-params/-/postcss-minify-params-8.0.0.tgz",
+      "integrity": "sha512-z7w4QO7G55l4vMUK1Lmx03GW7iyRLgf2V5Dz/7ioSPLnXRjeD+b7m0XfAXUGrbBYYrJ6bXPk+3LoX5u4JfAcSg==",
+      "dev": true,
+      "requires": {
+        "browserslist": "^4.28.2",
+        "cssnano-utils": "^6.0.0",
+        "postcss-value-parser": "^4.2.0"
+      }
+    },
+    "postcss-minify-selectors": {
+      "version": "8.0.1",
+      "resolved": "https://registry.npmjs.org/postcss-minify-selectors/-/postcss-minify-selectors-8.0.1.tgz",
+      "integrity": "sha512-c31D46811kTkQDxV1KTTow79axX6gj/01AY5G7cGZg3s31KvAwP13jEFXGAzQbJ7NvOFV1pRqEia6nrAdHU7qg==",
+      "dev": true,
+      "requires": {
+        "browserslist": "^4.28.1",
+        "caniuse-api": "^3.0.0",
+        "cssesc": "^3.0.0",
+        "postcss-selector-parser": "^7.1.1"
+      },
+      "dependencies": {
+        "postcss-selector-parser": {
+          "version": "7.1.1",
+          "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-7.1.1.tgz",
+          "integrity": "sha512-orRsuYpJVw8LdAwqqLykBj9ecS5/cRHlI5+nvTo8LcCKmzDmqVORXtOIYEEQuL9D4BxtA1lm5isAqzQZCoQ6Eg==",
+          "dev": true,
+          "requires": {
+            "cssesc": "^3.0.0",
+            "util-deprecate": "^1.0.2"
+          }
+        }
+      }
+    },
+    "postcss-normalize-charset": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/postcss-normalize-charset/-/postcss-normalize-charset-8.0.0.tgz",
+      "integrity": "sha512-s88FUNDSUD8m0wBYvTQQcubVts6zhXwBU8zCD4vkRKiecd0v8cOjHVIF9r/i+5xzS/WG3f98qq4XsOM0JqvfLA==",
+      "dev": true,
+      "requires": {}
+    },
+    "postcss-normalize-display-values": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/postcss-normalize-display-values/-/postcss-normalize-display-values-8.0.0.tgz",
+      "integrity": "sha512-gG2nBxD27fiw6Luinb1QYKdM/Co5GornRJgSD+JTwNH4PGKxImP0qyruDDav49aHUPLY3qrL3qN3LvybO7IzxQ==",
+      "dev": true,
+      "requires": {
+        "postcss-value-parser": "^4.2.0"
+      }
+    },
+    "postcss-normalize-positions": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/postcss-normalize-positions/-/postcss-normalize-positions-8.0.0.tgz",
+      "integrity": "sha512-t/wGqpehS20Ke7kc4QAsWpH+AJjUdMK/V5qV2RhrXkj8hO/fT1t1MJ8NL7sedWYk7ZqC7eISEJQonW5j0tU1MQ==",
+      "dev": true,
+      "requires": {
+        "postcss-value-parser": "^4.2.0"
+      }
+    },
+    "postcss-normalize-repeat-style": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/postcss-normalize-repeat-style/-/postcss-normalize-repeat-style-8.0.0.tgz",
+      "integrity": "sha512-3ebOmGdCYKrBYyGKc1xhj0unEnW7beZpVU7JohVeGl7mTxR+7T6egpaawTWAVsB0pEIhcsbJVOjPKCJSoRO6Zg==",
+      "dev": true,
+      "requires": {
+        "postcss-value-parser": "^4.2.0"
+      }
+    },
+    "postcss-normalize-string": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/postcss-normalize-string/-/postcss-normalize-string-8.0.0.tgz",
+      "integrity": "sha512-TvWCGZ/e04Tv31uJvOUtbexkfgUnqmQ3M2P5DkAaVzvOj+BvTkG2QjpA5Y71SL1SPxJcj4M23fNh+RDVCmG8kA==",
+      "dev": true,
+      "requires": {
+        "postcss-value-parser": "^4.2.0"
+      }
+    },
+    "postcss-normalize-timing-functions": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/postcss-normalize-timing-functions/-/postcss-normalize-timing-functions-8.0.0.tgz",
+      "integrity": "sha512-uEfaXst5Xgqxv7geYUuz6vs9mn88K2NPY2RoIzM3BMmSjsdTSeppV9x2qIgrxsisdbSqF6IVhzI2occcte3hTA==",
+      "dev": true,
+      "requires": {
+        "postcss-value-parser": "^4.2.0"
+      }
+    },
+    "postcss-normalize-unicode": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/postcss-normalize-unicode/-/postcss-normalize-unicode-8.0.0.tgz",
+      "integrity": "sha512-+WYngZaChEeTHZmWhmKtnJ4gTzWdINEaFcgWBnu6WdVu8Ftim8OBTcw768DuCC/3Aax9bZ9WkwrLGHym2Lzf+A==",
+      "dev": true,
+      "requires": {
+        "browserslist": "^4.28.2",
+        "postcss-value-parser": "^4.2.0"
+      }
+    },
+    "postcss-normalize-url": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/postcss-normalize-url/-/postcss-normalize-url-8.0.0.tgz",
+      "integrity": "sha512-4Mz9hZHn/QIB+YtFqTXrDmE2193GYxGb3F8uMfLvMicaEXCCUlDIJ658gFFJbqEGl9FYzwPtRiuNgbwlO9kkBg==",
+      "dev": true,
+      "requires": {
+        "postcss-value-parser": "^4.2.0"
+      }
+    },
+    "postcss-normalize-whitespace": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/postcss-normalize-whitespace/-/postcss-normalize-whitespace-8.0.0.tgz",
+      "integrity": "sha512-V1f8tYnwIP5tscOXQFTKK8Y5EJ+R2GMpFJ6FjzwoKoQnhbqQy3IeSrDjJJb8JjVos8ut6Osi80Zybpayv/XjIQ==",
+      "dev": true,
+      "requires": {
+        "postcss-value-parser": "^4.2.0"
+      }
+    },
+    "postcss-ordered-values": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/postcss-ordered-values/-/postcss-ordered-values-8.0.0.tgz",
+      "integrity": "sha512-Dg9+itb6lmD0bxqhQyHCtXAwYRh0wUrx6Mp4/BNXgkLoJmdYMmWi+V+Pypw79Q6iQhxA8KFMHqLBITQJV2gKMA==",
+      "dev": true,
+      "requires": {
+        "cssnano-utils": "^6.0.0",
+        "postcss-value-parser": "^4.2.0"
+      }
+    },
+    "postcss-reduce-initial": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/postcss-reduce-initial/-/postcss-reduce-initial-8.0.0.tgz",
+      "integrity": "sha512-DChcE9d528AKrlpCTHjhsAiOsWCk4H9ApHPS1QqRT3praObWTiWyn6W1UddGpc46K9LQnHwUu4YwaPUukGtXVA==",
+      "dev": true,
+      "requires": {
+        "browserslist": "^4.28.2",
+        "caniuse-api": "^3.0.0"
+      }
+    },
+    "postcss-reduce-transforms": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/postcss-reduce-transforms/-/postcss-reduce-transforms-8.0.0.tgz",
+      "integrity": "sha512-cLZT0som7vvumQT9XQCnSKOSnRinNQZd1Hm+J723Ney13E8CIydDhw6JwzsjPtgnYThTqn9Q45906gz6wxaAsw==",
+      "dev": true,
+      "requires": {
+        "postcss-value-parser": "^4.2.0"
+      }
+    },
+    "postcss-reporter": {
+      "version": "7.1.0",
+      "resolved": "https://registry.npmjs.org/postcss-reporter/-/postcss-reporter-7.1.0.tgz",
+      "integrity": "sha512-/eoEylGWyy6/DOiMP5lmFRdmDKThqgn7D6hP2dXKJI/0rJSO1ADFNngZfDzxL0YAxFvws+Rtpuji1YIHj4mySA==",
+      "dev": true,
+      "requires": {
+        "picocolors": "^1.0.0",
+        "thenby": "^1.3.4"
+      }
+    },
     "postcss-resolve-nested-selector": {
       "version": "0.1.1",
       "resolved": "https://registry.npmjs.org/postcss-resolve-nested-selector/-/postcss-resolve-nested-selector-0.1.1.tgz",
@@ -16722,6 +18556,37 @@
         "util-deprecate": "^1.0.2"
       }
     },
+    "postcss-svgo": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/postcss-svgo/-/postcss-svgo-8.0.0.tgz",
+      "integrity": "sha512-Q2fMSYEiNE1ioDc/3sxvI24NdgA/MJno2XLNpOxgv8aCcJbym8mZY10/lDY5+AWCIc3Aiqzy2Wcp9/zaIXBZgQ==",
+      "dev": true,
+      "requires": {
+        "postcss-value-parser": "^4.2.0",
+        "svgo": "^4.0.1"
+      }
+    },
+    "postcss-unique-selectors": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/postcss-unique-selectors/-/postcss-unique-selectors-8.0.0.tgz",
+      "integrity": "sha512-iObuolUX+ITJfMU2QQFQdh31JgSjNLPNjVs6YGAqBHvOvAWXMMNget6donQl83aQaeS32i5XeKZURUW/WBxIUw==",
+      "dev": true,
+      "requires": {
+        "postcss-selector-parser": "^7.1.1"
+      },
+      "dependencies": {
+        "postcss-selector-parser": {
+          "version": "7.1.1",
+          "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-7.1.1.tgz",
+          "integrity": "sha512-orRsuYpJVw8LdAwqqLykBj9ecS5/cRHlI5+nvTo8LcCKmzDmqVORXtOIYEEQuL9D4BxtA1lm5isAqzQZCoQ6Eg==",
+          "dev": true,
+          "requires": {
+            "cssesc": "^3.0.0",
+            "util-deprecate": "^1.0.2"
+          }
+        }
+      }
+    },
     "postcss-value-parser": {
       "version": "4.2.0",
       "resolved": "https://registry.npmjs.org/postcss-value-parser/-/postcss-value-parser-4.2.0.tgz",
@@ -16734,6 +18599,12 @@
       "integrity": "sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==",
       "dev": true
     },
+    "pretty-hrtime": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/pretty-hrtime/-/pretty-hrtime-1.0.3.tgz",
+      "integrity": "sha512-66hKPCr+72mlfiSjlEB1+45IjXSqvVAIy6mocupoww4tBFE9R9IhwwUGoI4G++Tc9Aq+2rxOt0RFU6gPcrte0A==",
+      "dev": true
+    },
     "process": {
       "version": "0.11.10",
       "resolved": "https://registry.npmjs.org/process/-/process-0.11.10.tgz",
@@ -16832,6 +18703,23 @@
         "unpipe": "1.0.0"
       }
     },
+    "read-cache": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/read-cache/-/read-cache-1.0.0.tgz",
+      "integrity": "sha512-Owdv/Ft7IjOgm/i0xvNDZ1LrRANRfew4b2prF3OWMQLxLfu3bS8FVhCsrSCMK4lR56Y9ya+AThoTpDCTxCmpRA==",
+      "dev": true,
+      "requires": {
+        "pify": "^2.3.0"
+      },
+      "dependencies": {
+        "pify": {
+          "version": "2.3.0",
+          "resolved": "https://registry.npmjs.org/pify/-/pify-2.3.0.tgz",
+          "integrity": "sha512-udgsAY+fTnvv7kI7aaxbqwWNb0AHiB0qBO89PZKPkoTmGOgdbrHDKD+0B2X4uTfJ/FT1R09r9gTsjUjNJotuog==",
+          "dev": true
+        }
+      }
+    },
     "read-pkg": {
       "version": "5.2.0",
       "resolved": "https://registry.npmjs.org/read-pkg/-/read-pkg-5.2.0.tgz",
@@ -17151,9 +19039,9 @@
       "dev": true
     },
     "sax": {
-      "version": "1.2.4",
-      "resolved": "https://registry.npmjs.org/sax/-/sax-1.2.4.tgz",
-      "integrity": "sha512-NqVDv9TpANUjFm0N8uM5GxL36UgKi9/atZw+x7YFnQ8ckwFGKrl4xX4yWtrey3UJm5nP1kUbnYgLopqWNSRhWw==",
+      "version": "1.6.0",
+      "resolved": "https://registry.npmjs.org/sax/-/sax-1.6.0.tgz",
+      "integrity": "sha512-6R3J5M4AcbtLUdZmRv2SygeVaM7IhrLXu9BmnOGmmACak8fiUtOsYNWUS4uK7upbmHIBbLBeFeI//477BKLBzA==",
       "dev": true
     },
     "semver": {
@@ -17486,6 +19374,28 @@
       "integrity": "sha1-eVjHk+R+MuB9K1yv5cC/jhLneQI=",
       "dev": true
     },
+    "stylehacks": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/stylehacks/-/stylehacks-8.0.0.tgz",
+      "integrity": "sha512-sWyjaJvBqHoVKYPbQ8JRvrGSPaYWtWrJsU+fGVtwKB1GE1rRPu3rC7T6UCuXLoL00Dwb+tsHe2T904r8Vnsx8w==",
+      "dev": true,
+      "requires": {
+        "browserslist": "^4.28.2",
+        "postcss-selector-parser": "^7.1.1"
+      },
+      "dependencies": {
+        "postcss-selector-parser": {
+          "version": "7.1.1",
+          "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-7.1.1.tgz",
+          "integrity": "sha512-orRsuYpJVw8LdAwqqLykBj9ecS5/cRHlI5+nvTo8LcCKmzDmqVORXtOIYEEQuL9D4BxtA1lm5isAqzQZCoQ6Eg==",
+          "dev": true,
+          "requires": {
+            "cssesc": "^3.0.0",
+            "util-deprecate": "^1.0.2"
+          }
+        }
+      }
+    },
     "stylelint": {
       "version": "14.5.1",
       "resolved": "https://registry.npmjs.org/stylelint/-/stylelint-14.5.1.tgz",
@@ -17598,6 +19508,29 @@
       "integrity": "sha1-WPcc7jvVGbWdSyqEO2x95krAR2Q=",
       "dev": true
     },
+    "svgo": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/svgo/-/svgo-4.0.1.tgz",
+      "integrity": "sha512-XDpWUOPC6FEibaLzjfe0ucaV0YrOjYotGJO1WpF0Zd+n6ZGEQUsSugaoLq9QkEZtAfQIxT42UChcssDVPP3+/w==",
+      "dev": true,
+      "requires": {
+        "commander": "^11.1.0",
+        "css-select": "^5.1.0",
+        "css-tree": "^3.0.1",
+        "css-what": "^6.1.0",
+        "csso": "^5.0.5",
+        "picocolors": "^1.1.1",
+        "sax": "^1.5.0"
+      },
+      "dependencies": {
+        "commander": {
+          "version": "11.1.0",
+          "resolved": "https://registry.npmjs.org/commander/-/commander-11.1.0.tgz",
+          "integrity": "sha512-yPVavfyCcRhmorC7rWlkHn15b4wDVgVmBA7kV4QVBsF7kv/9TKJAbAXVTxvTnwP8HHKjRCJDClKbciiYS7p0DQ==",
+          "dev": true
+        }
+      }
+    },
     "synckit": {
       "version": "0.9.2",
       "resolved": "https://registry.npmjs.org/synckit/-/synckit-0.9.2.tgz",
@@ -17671,6 +19604,12 @@
         "minimatch": "^3.0.4"
       }
     },
+    "thenby": {
+      "version": "1.4.1",
+      "resolved": "https://registry.npmjs.org/thenby/-/thenby-1.4.1.tgz",
+      "integrity": "sha512-D5a/bO0KdalOE3q8MlrRmSxjbKZHT3MQmXkJP+r97Vw8MMwOZKOwUSEyTtK7eSMj2y0kyAjpYMRMZmmLw1FtNQ==",
+      "dev": true
+    },
     "through2": {
       "version": "0.6.5",
       "resolved": "https://registry.npmjs.org/through2/-/through2-0.6.5.tgz",
@@ -17720,19 +19659,19 @@
       "dev": true
     },
     "tinyglobby": {
-      "version": "0.2.10",
-      "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.10.tgz",
-      "integrity": "sha512-Zc+8eJlFMvgatPZTl6A9L/yht8QqdmUNtURHaKZLmKBE12hNPSrqNkUp2cs3M/UKmNVVAMFQYSjYIVHDjW5zew==",
+      "version": "0.2.16",
+      "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.16.tgz",
+      "integrity": "sha512-pn99VhoACYR8nFHhxqix+uvsbXineAasWm5ojXoN8xEwK5Kd3/TrhNn1wByuD52UxWRLy8pu+kRMniEi6Eq9Zg==",
       "dev": true,
       "requires": {
-        "fdir": "^6.4.2",
-        "picomatch": "^4.0.2"
+        "fdir": "^6.5.0",
+        "picomatch": "^4.0.4"
       },
       "dependencies": {
         "fdir": {
-          "version": "6.4.2",
-          "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.4.2.tgz",
-          "integrity": "sha512-KnhMXsKSPZlAhp7+IjUkRZKPb4fUyccpDrdFXbi4QL1qkmFh9kVY09Yox+n4MaOb3lHZ1Tv829C3oaaXoMYPDQ==",
+          "version": "6.5.0",
+          "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz",
+          "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==",
           "dev": true,
           "requires": {}
         },
@@ -17923,6 +19862,16 @@
       "integrity": "sha1-sr9O6FFKrmFltIF4KdIbLvSZBOw=",
       "dev": true
     },
+    "update-browserslist-db": {
+      "version": "1.2.3",
+      "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.2.3.tgz",
+      "integrity": "sha512-Js0m9cx+qOgDxo0eMiFGEueWztz+d4+M3rGlmKPT+T4IS/jP4ylw3Nwpu6cpTTP8R1MAC1kF4VbdLt3ARf209w==",
+      "dev": true,
+      "requires": {
+        "escalade": "^3.2.0",
+        "picocolors": "^1.1.1"
+      }
+    },
     "uri-js": {
       "version": "4.4.1",
       "resolved": "https://registry.npmjs.org/uri-js/-/uri-js-4.4.1.tgz",
diff --git a/package.json b/package.json
index 424f01e0d1..a2b2360c70 100644
--- a/package.json
+++ b/package.json
@@ -26,6 +26,7 @@
     "@joeyparrish/karma-babel-preprocessor": "^8.2.0",
     "@stylistic/eslint-plugin-js": "^4.2.0",
     "@teppeis/clutz": "^1.0.29-4c95e12.v20190929",
+    "autoprefixer": "^10.5.0",
     "awesomplete": "^1.1.5",
     "babel-plugin-istanbul": "^6.1.1",
     "cajon": "^0.4.4",
@@ -34,6 +35,7 @@
     "color-themes-for-google-code-prettify": "^2.0.4",
     "core-js": "^3.21.1",
     "cspell": "^8.17.1",
+    "cssnano": "^8.0.1",
     "dialog-polyfill": "^0.5.6",
     "es6-promise-polyfill": "^1.2.0",
     "eslint": "^9.18.0",
@@ -61,9 +63,10 @@
     "karma-webdriver-launcher": "^1.0.8",
     "lcevc_dec.js": "^1.3.0",
     "less": "^4.2.0",
-    "less-plugin-clean-css": "^1.6.0",
     "material-design-lite": "^1.3.0",
     "open-sans-fonts": "^1.6.2",
+    "postcss": "^8.5.15",
+    "postcss-cli": "^11.0.1",
     "postcss-less": "^6.0.0",
     "pwacompat": "^2.0.17",
     "rimraf": "^3.0.2",
diff --git a/project-words.txt b/project-words.txt
index 9c19708d76..940f76b75b 100644
--- a/project-words.txt
+++ b/project-words.txt
@@ -200,6 +200,7 @@ Clearkey
 Clearkeys
 Clutz
 codem
+cssnano
 hbbtv
 Conax
 cvox
@@ -524,6 +525,7 @@ avinfo
 awesomplete
 axinom
 beatle
+BROWSERSLIST
 checkmark
 crbug
 *deadbeef*
diff --git a/ui/less/containers.less b/ui/less/containers.less
index 323aa94971..8b7123f18a 100644
--- a/ui/less/containers.less
+++ b/ui/less/containers.less
@@ -28,7 +28,6 @@
   /* prevent text caret from showing when 'Navigate pages with a text cursor'
    * setting is enabled on chromium-based browsers */
   user-select: none;
-  -webkit-user-select: none;
 
   *,
   :after,
@@ -69,9 +68,6 @@
   }
 }
 .shaka-video-container:fullscreen { .fullscreen-container(); }
-.shaka-video-container:-webkit-full-screen { .fullscreen-container(); }
-.shaka-video-container:-moz-full-screen { .fullscreen-container(); }
-.shaka-video-container:-ms-fullscreen { .fullscreen-container(); }
 
 /* The actual video element.  Sits inside .shaka-video-container and gives it a
  * size in non-fullscreen mode.  In fullscreen mode, the sizing relationship
diff --git a/ui/less/general.less b/ui/less/general.less
index fce01ea250..58db797d9a 100644
--- a/ui/less/general.less
+++ b/ui/less/general.less
@@ -10,9 +10,6 @@
  * selectable again. */
 .unselectable() {
   user-select: none;
-  -webkit-user-select: none;
-  -moz-user-select: none;
-  -ms-user-select: none;
 }
 
 .hidden() {
diff --git a/ui/less/tooltip.less b/ui/less/tooltip.less
index d05a73c7c9..b6bd07dd36 100644
--- a/ui/less/tooltip.less
+++ b/ui/less/tooltip.less
@@ -27,10 +27,6 @@
 @material-icons-width: 48px;
 
 .translateX(@percent) {
-  -webkit-transform: translateX(percentage(@percent));
-  -moz-transform: translateX(percentage(@percent));
-  -ms-transform: translateX(percentage(@percent));
-  -o-transform: translateX(percentage(@percent));
   transform: translateX(percentage(@percent));
 }
 

From 2e13ea2c4192d89c5523eb942bc9de1f575c12fd Mon Sep 17 00:00:00 2001
From: Felipe <felipercmelo@gmail.com>
Date: Fri, 29 May 2026 09:01:39 -0300
Subject: [PATCH 61/64] fix(HLS): Fix LL-HLS stall on live playlist updates
 after #9998 (#10154)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Fixes https://github.com/shaka-project/shaka-player/issues/10149

PR #9998 (`perf(HLS): skip merging known segments on live playlist
updates`) introduced a regression where low-latency HLS live streams
stall after ~10 seconds of playback. The video and audio simply stop
with no error.

### Root Cause

`createSegments_()` keeps a `mediaSequenceToStartTime` map to track
which segments it has already seen. The optimization only passes **new**
segments (those not yet in the map) to `mergeAndEvict()`:

```js
// line 4838
if (isNewSegment) {
    newReferences.push(reference);
}
```

However, in LL-HLS, a segment's partial references **grow** across
playlist refreshes — e.g., a segment starts with 2 partials, then 4,
then 8, until the segment is complete. The `firstReferenceToCreate`
logic at line 4665 correctly detects segments with active partials and
triggers a **rebuild**, but the rebuilt reference is **not** included in
`newReferences` because its position already exists in
`mediaSequenceToStartTime`. So `mergeAndEvict()` never receives the
updated reference, the segment index retains **stale partial data**, and
the player stalls once it exhausts those stale partials — roughly 10
seconds of content.

### The Fix

**1 line, no behavioral impact on VOD or non-low-latency streams.**

```diff
- if (isNewSegment) {
+ if (isNewSegment || !isNewStream) {
```

During live updates (`isNewStream = false`), **all** rebuilt segments
are now passed to `mergeAndEvict`, not just the truly new ones. This is
correct because rebuilt segments (triggered by partials or EXTINF
changes) have updated content that must replace the stale data in the
segment index.

**No performance regression:** When there are truly no changes (all
segments known, no partials, no EXTINF changes),
`firstReferenceToCreate` stays at `hlsSegments.length`, so all segments
are skipped, `references` is empty, and `mergeAndEvict` is never called
— preserving the optimization.

### Steps to Reproduce

1. Play any LL-HLS live stream (e.g., with `#EXT-X-SERVER-CONTROL` and
partial segments)
2. Observe playback stops after ~8–12 seconds with no error
---
 lib/hls/hls_parser.js     |  2 +-
 test/hls/hls_live_unit.js | 51 +++++++++++++++++++++++++++++++++++++++
 2 files changed, 52 insertions(+), 1 deletion(-)

diff --git a/lib/hls/hls_parser.js b/lib/hls/hls_parser.js
index 7beca333f9..e63ff28f51 100644
--- a/lib/hls/hls_parser.js
+++ b/lib/hls/hls_parser.js
@@ -4835,7 +4835,7 @@ shaka.hls.HlsParser = class {
           // method.
         } else {
           references.push(reference);
-          if (isNewSegment) {
+          if (isNewSegment || !isNewStream) {
             newReferences.push(reference);
           }
         }
diff --git a/test/hls/hls_live_unit.js b/test/hls/hls_live_unit.js
index 10ea2c0c90..67bb300484 100644
--- a/test/hls/hls_live_unit.js
+++ b/test/hls/hls_live_unit.js
@@ -1918,4 +1918,55 @@ describe('HlsParser live', () => {
     return ManifestParser.makeReference(uri, start, end, baseUri, startByte,
         endByte, timestampOffset, partialReferences, tilesLayout, syncTime);
   }
+
+  it('calls mergeAndEvict on update when segment has partials', async () => {
+    // Regression test for #9998. When a segment has partial segments, it gets
+    // rebuilt on every live update, but without the fix the rebuilt reference
+    // was discarded from mergeAndEvict because its position was already in
+    // mediaSequenceToStartTime. This caused LL-HLS streams to stall.
+
+    const mediaWithPartials = [
+      '#EXTM3U\n',
+      '#EXT-X-TARGETDURATION:5\n',
+      '#EXT-X-MEDIA-SEQUENCE:100\n',
+      '#EXT-X-MAP:URI="init.mp4",BYTERANGE="616@0"\n',
+      '#EXTINF:2,\n',
+      'main.mp4\n',
+      '#EXTINF:2,\n',
+      'main2.mp4\n',
+      '#EXT-X-PART:DURATION=1.0,URI="partial.mp4"\n',
+      '#EXT-X-PART:DURATION=1.0,URI="partial2.mp4"\n',
+      '#EXTINF:2,\n',
+      'main3.mp4\n',
+    ].join('');
+
+    const mediaWithMorePartials = [
+      '#EXTM3U\n',
+      '#EXT-X-TARGETDURATION:5\n',
+      '#EXT-X-MEDIA-SEQUENCE:100\n',
+      '#EXT-X-MAP:URI="init.mp4",BYTERANGE="616@0"\n',
+      '#EXTINF:2,\n',
+      'main.mp4\n',
+      '#EXTINF:2,\n',
+      'main2.mp4\n',
+      '#EXT-X-PART:DURATION=1.0,URI="partial.mp4"\n',
+      '#EXT-X-PART:DURATION=1.0,URI="partial2.mp4"\n',
+      '#EXT-X-PART:DURATION=1.0,URI="partial3.mp4"\n',
+      '#EXT-X-PART:DURATION=1.0,URI="partial4.mp4"\n',
+      '#EXTINF:2,\n',
+      'main3.mp4\n',
+    ].join('');
+
+    const manifest = await testInitialManifest(
+        master, mediaWithPartials);
+
+    const video = manifest.variants[0].video;
+    goog.asserts.assert(video.segmentIndex, 'Segment index should exist!');
+
+    spyOn(video.segmentIndex, 'mergeAndEvict').and.callThrough();
+
+    await testUpdate(manifest, mediaWithMorePartials);
+
+    expect(video.segmentIndex.mergeAndEvict).toHaveBeenCalled();
+  });
 });  // describe('HlsParser live')

From 814aaa718f098b05c21a33cdada1132e0c2403f5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C3=81lvaro=20Velad=20Galv=C3=A1n?= <ladvan91@hotmail.com>
Date: Fri, 29 May 2026 18:58:54 +0200
Subject: [PATCH 62/64] refactor(UI): Avoid repeated localization.resolve calls
 (#10155)

---
 ui/ad_statistics_button.js     | 10 ++++------
 ui/audio_language_selection.js | 10 +++++-----
 ui/cast_button.js              |  6 +++---
 ui/chapter_selection.js        |  8 +++++---
 ui/copy_video_frame_button.js  |  7 +++----
 ui/mute_button.js              | 13 +++++++------
 ui/playback_rate_selection.js  |  8 +++++---
 ui/queue_button.js             |  8 +++++---
 ui/recenter_vr.js              |  8 +++-----
 ui/resolution_selection.js     | 13 +++++++------
 ui/save_video_frame_button.js  |  8 +++-----
 ui/skip_ad_button.js           |  5 +++--
 ui/statistics_button.js        | 10 ++++------
 ui/text_position.js            | 11 ++++++-----
 ui/text_selection.js           | 10 +++++-----
 ui/text_size.js                | 10 +++++-----
 ui/toggle_stereoscopic.js      |  8 +++-----
 ui/video_type_selection.js     |  8 +++++---
 18 files changed, 81 insertions(+), 80 deletions(-)

diff --git a/ui/ad_statistics_button.js b/ui/ad_statistics_button.js
index f834ceac91..1d4cdfc852 100644
--- a/ui/ad_statistics_button.js
+++ b/ui/ad_statistics_button.js
@@ -160,13 +160,11 @@ shaka.ui.AdStatisticsButton = class extends shaka.ui.Element {
   updateLocalizedStrings() {
     const LocIds = shaka.ui.Locales.Ids;
 
-    this.nameSpan_.textContent =
-        this.localization.resolve(LocIds.AD_STATISTICS);
+    const label = this.localization.resolve(LocIds.AD_STATISTICS);
 
-    this.headerTitle_.textContent =
-        this.localization.resolve(LocIds.AD_STATISTICS);
-
-    this.button_.ariaLabel = this.localization.resolve(LocIds.AD_STATISTICS);
+    this.nameSpan_.textContent = label;
+    this.headerTitle_.textContent = label;
+    this.button_.ariaLabel = label;
 
     const labelText = this.container_.classList.contains('shaka-hidden') ?
         LocIds.OFF : LocIds.ON;
diff --git a/ui/audio_language_selection.js b/ui/audio_language_selection.js
index 60993ad88d..3edd0a62c1 100644
--- a/ui/audio_language_selection.js
+++ b/ui/audio_language_selection.js
@@ -97,11 +97,11 @@ shaka.ui.AudioLanguageSelection = class extends shaka.ui.SettingsMenu {
     const LocIds = shaka.ui.Locales.Ids;
 
     this.backButton.ariaLabel = this.localization.resolve(LocIds.BACK);
-    this.button.ariaLabel = this.localization.resolve(LocIds.LANGUAGE);
-    this.nameSpan.textContent =
-        this.localization.resolve(LocIds.LANGUAGE);
-    this.backSpan.textContent =
-        this.localization.resolve(LocIds.LANGUAGE);
+
+    const label = this.localization.resolve(LocIds.LANGUAGE);
+    this.button.ariaLabel = label;
+    this.nameSpan.textContent = label;
+    this.backSpan.textContent = label;
   }
 
   /** @override */
diff --git a/ui/cast_button.js b/ui/cast_button.js
index 673f2d0988..dc10e0423d 100644
--- a/ui/cast_button.js
+++ b/ui/cast_button.js
@@ -141,9 +141,9 @@ shaka.ui.CastButton = class extends shaka.ui.Element {
   updateLocalizedStrings() {
     const LocIds = shaka.ui.Locales.Ids;
 
-    this.castButton_.ariaLabel = this.localization.resolve(LocIds.CAST);
-    this.castNameSpan_.textContent =
-        this.localization.resolve(LocIds.CAST);
+    const label = this.localization.resolve(LocIds.CAST);
+    this.castButton_.ariaLabel = label;
+    this.castNameSpan_.textContent = label;
 
     // If we're not casting, string "not casting" will be displayed,
     // which needs localization.
diff --git a/ui/chapter_selection.js b/ui/chapter_selection.js
index 5189a15157..558443d6fe 100644
--- a/ui/chapter_selection.js
+++ b/ui/chapter_selection.js
@@ -65,9 +65,11 @@ shaka.ui.ChapterSelection = class extends shaka.ui.SettingsMenu {
     const LocIds = shaka.ui.Locales.Ids;
 
     this.backButton.ariaLabel = this.localization.resolve(LocIds.BACK);
-    this.button.ariaLabel = this.localization.resolve(LocIds.CHAPTERS);
-    this.nameSpan.textContent = this.localization.resolve(LocIds.CHAPTERS);
-    this.backSpan.textContent = this.localization.resolve(LocIds.CHAPTERS);
+
+    const label = this.localization.resolve(LocIds.CHAPTERS);
+    this.button.ariaLabel = label;
+    this.nameSpan.textContent = label;
+    this.backSpan.textContent = label;
 
     this.updateChapters_();
   }
diff --git a/ui/copy_video_frame_button.js b/ui/copy_video_frame_button.js
index 87336cadba..9f507ead90 100644
--- a/ui/copy_video_frame_button.js
+++ b/ui/copy_video_frame_button.js
@@ -116,10 +116,9 @@ shaka.ui.CopyVideoFrameButton = class extends shaka.ui.Element {
   updateLocalizedStrings() {
     const LocIds = shaka.ui.Locales.Ids;
 
-    this.button_.ariaLabel =
-        this.localization.resolve(LocIds.COPY_VIDEO_FRAME);
-    this.nameSpan_.textContent =
-        this.localization.resolve(LocIds.COPY_VIDEO_FRAME);
+    const label = this.localization.resolve(LocIds.COPY_VIDEO_FRAME);
+    this.button_.ariaLabel = label;
+    this.nameSpan_.textContent = label;
   }
 };
 
diff --git a/ui/mute_button.js b/ui/mute_button.js
index e0955b13ba..0760b3b4fc 100644
--- a/ui/mute_button.js
+++ b/ui/mute_button.js
@@ -132,17 +132,18 @@ shaka.ui.MuteButton = class extends shaka.ui.Element {
   /** @override */
   updateLocalizedStrings() {
     const LocIds = shaka.ui.Locales.Ids;
-    let label;
+    let locId;
     if (this.ad && this.ad.isLinear()) {
-      label = this.ad.isMuted() ? LocIds.UNMUTE : LocIds.MUTE;
+      locId = this.ad.isMuted() ? LocIds.UNMUTE : LocIds.MUTE;
     } else {
-      label = (this.video.muted || this.video.volume == 0) ?
+      locId = (this.video.muted || this.video.volume == 0) ?
           LocIds.UNMUTE : LocIds.MUTE;
     }
+    const label = this.localization.resolve(locId);
 
-    this.button_.ariaLabel = this.localization.resolve(label);
-    this.button_.ariaPressed = label == LocIds.UNMUTE ? 'true' : 'false';
-    this.nameSpan_.textContent = this.localization.resolve(label);
+    this.button_.ariaLabel = label;
+    this.button_.ariaPressed = locId == LocIds.UNMUTE ? 'true' : 'false';
+    this.nameSpan_.textContent = label;
   }
 
   /**
diff --git a/ui/playback_rate_selection.js b/ui/playback_rate_selection.js
index b396fc1daa..d9dc4ed0b2 100644
--- a/ui/playback_rate_selection.js
+++ b/ui/playback_rate_selection.js
@@ -87,9 +87,11 @@ shaka.ui.PlaybackRateSelection = class extends shaka.ui.SettingsMenu {
     const LocIds = shaka.ui.Locales.Ids;
 
     this.backButton.ariaLabel = this.localization.resolve(LocIds.BACK);
-    this.button.ariaLabel = this.localization.resolve(LocIds.PLAYBACK_RATE);
-    this.nameSpan.textContent = this.localization.resolve(LocIds.PLAYBACK_RATE);
-    this.backSpan.textContent = this.localization.resolve(LocIds.PLAYBACK_RATE);
+
+    const label = this.localization.resolve(LocIds.PLAYBACK_RATE);
+    this.button.ariaLabel = label;
+    this.nameSpan.textContent = label;
+    this.backSpan.textContent = label;
   }
 
   /** @private */
diff --git a/ui/queue_button.js b/ui/queue_button.js
index 019ac10e0a..0f08406fab 100644
--- a/ui/queue_button.js
+++ b/ui/queue_button.js
@@ -74,9 +74,11 @@ shaka.ui.QueueButton = class extends shaka.ui.SettingsMenu {
     const LocIds = shaka.ui.Locales.Ids;
 
     this.backButton.ariaLabel = this.localization.resolve(LocIds.BACK);
-    this.button.ariaLabel = this.localization.resolve(LocIds.QUEUE);
-    this.nameSpan.textContent = this.localization.resolve(LocIds.QUEUE);
-    this.backSpan.textContent = this.localization.resolve(LocIds.QUEUE);
+
+    const label = this.localization.resolve(LocIds.QUEUE);
+    this.button.ariaLabel = label;
+    this.nameSpan.textContent = label;
+    this.backSpan.textContent = label;
   }
 
   /**
diff --git a/ui/recenter_vr.js b/ui/recenter_vr.js
index fb91064795..eb68bac0bb 100644
--- a/ui/recenter_vr.js
+++ b/ui/recenter_vr.js
@@ -82,11 +82,9 @@ shaka.ui.RecenterVRButton = class extends shaka.ui.Element {
   /** @override */
   updateLocalizedStrings() {
     const LocIds = shaka.ui.Locales.Ids;
-
-    this.recenterVRButton_.ariaLabel =
-        this.localization.resolve(LocIds.RECENTER_VR);
-    this.recenterVRNameSpan_.textContent =
-        this.localization.resolve(LocIds.RECENTER_VR);
+    const label = this.localization.resolve(LocIds.RECENTER_VR);
+    this.recenterVRButton_.ariaLabel = label;
+    this.recenterVRNameSpan_.textContent = label;
   }
 };
 
diff --git a/ui/resolution_selection.js b/ui/resolution_selection.js
index 83ff1371d4..d4e23ffc4f 100644
--- a/ui/resolution_selection.js
+++ b/ui/resolution_selection.js
@@ -635,12 +635,13 @@ shaka.ui.ResolutionSelection = class extends shaka.ui.SettingsMenu {
     const locId = this.player.isAudioOnly() ?
         LocIds.QUALITY : LocIds.RESOLUTION;
 
-    this.button.ariaLabel = this.localization.resolve(locId);
-    this.backButton.ariaLabel = this.localization.resolve(locId);
-    this.backSpan.textContent =
-        this.localization.resolve(locId);
-    this.nameSpan.textContent =
-        this.localization.resolve(locId);
+    this.backButton.ariaLabel = this.localization.resolve(LocIds.BACK);
+
+    const label = this.localization.resolve(locId);
+    this.button.ariaLabel = label;
+    this.nameSpan.textContent = label;
+    this.backSpan.textContent = label;
+
     this.abrOnSpan_.textContent =
         this.localization.resolve(LocIds.AUTO_QUALITY);
 
diff --git a/ui/save_video_frame_button.js b/ui/save_video_frame_button.js
index 99c580c76c..2aac6c3cff 100644
--- a/ui/save_video_frame_button.js
+++ b/ui/save_video_frame_button.js
@@ -115,11 +115,9 @@ shaka.ui.SaveVideoFrameButton = class extends shaka.ui.Element {
   /** @override */
   updateLocalizedStrings() {
     const LocIds = shaka.ui.Locales.Ids;
-
-    this.button_.ariaLabel =
-        this.localization.resolve(LocIds.DOWNLOAD_VIDEO_FRAME);
-    this.nameSpan_.textContent =
-        this.localization.resolve(LocIds.DOWNLOAD_VIDEO_FRAME);
+    const label = this.localization.resolve(LocIds.DOWNLOAD_VIDEO_FRAME);
+    this.button_.ariaLabel = label;
+    this.nameSpan_.textContent = label;
   }
 };
 
diff --git a/ui/skip_ad_button.js b/ui/skip_ad_button.js
index bc297b70e7..5a303eb338 100644
--- a/ui/skip_ad_button.js
+++ b/ui/skip_ad_button.js
@@ -95,8 +95,9 @@ shaka.ui.SkipAdButton = class extends shaka.ui.Element {
   /** @override */
   updateLocalizedStrings() {
     const LocIds = shaka.ui.Locales.Ids;
-    this.button_.textContent = this.localization.resolve(LocIds.SKIP_AD);
-    this.button_.ariaLabel = this.localization.resolve(LocIds.SKIP_AD);
+    const label = this.localization.resolve(LocIds.SKIP_AD);
+    this.button_.textContent = label;
+    this.button_.ariaLabel = label;
   }
 
   /**
diff --git a/ui/statistics_button.js b/ui/statistics_button.js
index 6561befb51..ff456a7a98 100644
--- a/ui/statistics_button.js
+++ b/ui/statistics_button.js
@@ -208,13 +208,11 @@ shaka.ui.StatisticsButton = class extends shaka.ui.Element {
   updateLocalizedStrings() {
     const LocIds = shaka.ui.Locales.Ids;
 
-    this.nameSpan_.textContent =
-        this.localization.resolve(LocIds.STATISTICS);
+    const label = this.localization.resolve(LocIds.STATISTICS);
 
-    this.headerTitle_.textContent =
-        this.localization.resolve(LocIds.STATISTICS);
-
-    this.button_.ariaLabel = this.localization.resolve(LocIds.STATISTICS);
+    this.nameSpan_.textContent = label;
+    this.headerTitle_.textContent = label;
+    this.button_.ariaLabel = label;
 
     const labelText = this.container_.classList.contains('shaka-hidden') ?
         LocIds.OFF : LocIds.ON;
diff --git a/ui/text_position.js b/ui/text_position.js
index 898f08caff..04fd3225ce 100644
--- a/ui/text_position.js
+++ b/ui/text_position.js
@@ -74,12 +74,13 @@ shaka.ui.TextPosition = class extends shaka.ui.SettingsMenu {
   updateLocalizedStrings() {
     const LocIds = shaka.ui.Locales.Ids;
 
-    this.button.ariaLabel = this.localization.resolve(LocIds.SUBTITLE_POSITION);
     this.backButton.ariaLabel = this.localization.resolve(LocIds.BACK);
-    this.nameSpan.textContent =
-        this.localization.resolve(LocIds.SUBTITLE_POSITION);
-    this.backSpan.textContent =
-        this.localization.resolve(LocIds.SUBTITLE_POSITION);
+
+    const label = this.localization.resolve(LocIds.SUBTITLE_POSITION);
+
+    this.button.ariaLabel = label;
+    this.nameSpan.textContent = label;
+    this.backSpan.textContent = label;
 
     this.addTextPositions_();
   }
diff --git a/ui/text_selection.js b/ui/text_selection.js
index 6d6746a97b..1477e66f33 100644
--- a/ui/text_selection.js
+++ b/ui/text_selection.js
@@ -187,12 +187,12 @@ shaka.ui.TextSelection = class extends shaka.ui.SettingsMenu {
   updateLocalizedStrings() {
     const LocIds = shaka.ui.Locales.Ids;
 
-    this.button.ariaLabel = this.localization.resolve(LocIds.CAPTIONS);
     this.backButton.ariaLabel = this.localization.resolve(LocIds.BACK);
-    this.nameSpan.textContent =
-        this.localization.resolve(LocIds.CAPTIONS);
-    this.backSpan.textContent =
-        this.localization.resolve(LocIds.CAPTIONS);
+
+    const label = this.localization.resolve(LocIds.CAPTIONS);
+    this.button.ariaLabel = label;
+    this.nameSpan.textContent = label;
+    this.backSpan.textContent = label;
     this.captionsOffSpan_.textContent =
         this.localization.resolve(LocIds.OFF);
 
diff --git a/ui/text_size.js b/ui/text_size.js
index eb82df10d1..8591a3d032 100644
--- a/ui/text_size.js
+++ b/ui/text_size.js
@@ -73,12 +73,12 @@ shaka.ui.TextSize = class extends shaka.ui.SettingsMenu {
   updateLocalizedStrings() {
     const LocIds = shaka.ui.Locales.Ids;
 
-    this.button.ariaLabel = this.localization.resolve(LocIds.SUBTITLE_SIZE);
     this.backButton.ariaLabel = this.localization.resolve(LocIds.BACK);
-    this.nameSpan.textContent =
-        this.localization.resolve(LocIds.SUBTITLE_SIZE);
-    this.backSpan.textContent =
-        this.localization.resolve(LocIds.SUBTITLE_SIZE);
+
+    const label = this.localization.resolve(LocIds.SUBTITLE_SIZE);
+    this.button.ariaLabel = label;
+    this.nameSpan.textContent = label;
+    this.backSpan.textContent = label;
   }
 
   /** @private */
diff --git a/ui/toggle_stereoscopic.js b/ui/toggle_stereoscopic.js
index 9c2931f1c0..75dad4f987 100644
--- a/ui/toggle_stereoscopic.js
+++ b/ui/toggle_stereoscopic.js
@@ -87,11 +87,9 @@ shaka.ui.ToggleStereoscopicButton = class extends shaka.ui.Element {
   /** @override */
   updateLocalizedStrings() {
     const LocIds = shaka.ui.Locales.Ids;
-
-    this.toggleStereoscopicButton_.ariaLabel =
-        this.localization.resolve(LocIds.TOGGLE_STEREOSCOPIC);
-    this.toggleStereoscopicNameSpan_.textContent =
-        this.localization.resolve(LocIds.TOGGLE_STEREOSCOPIC);
+    const label = this.localization.resolve(LocIds.TOGGLE_STEREOSCOPIC);
+    this.toggleStereoscopicButton_.ariaLabel = label;
+    this.toggleStereoscopicNameSpan_.textContent = label;
   }
 };
 
diff --git a/ui/video_type_selection.js b/ui/video_type_selection.js
index f8b40d9628..d1aaf641b4 100644
--- a/ui/video_type_selection.js
+++ b/ui/video_type_selection.js
@@ -56,9 +56,11 @@ shaka.ui.VideoTypeSelection = class extends shaka.ui.SettingsMenu {
     const LocIds = shaka.ui.Locales.Ids;
 
     this.backButton.ariaLabel = this.localization.resolve(LocIds.BACK);
-    this.button.ariaLabel = this.localization.resolve(LocIds.VIDEO_TYPE);
-    this.nameSpan.textContent = this.localization.resolve(LocIds.VIDEO_TYPE);
-    this.backSpan.textContent = this.localization.resolve(LocIds.VIDEO_TYPE);
+
+    const label = this.localization.resolve(LocIds.VIDEO_TYPE);
+    this.button.ariaLabel = label;
+    this.nameSpan.textContent = label;
+    this.backSpan.textContent = label;
 
     this.updateVideoRoles_();
   }

From 8ba04190f6ff7c783535dce5fe2f227e284a984c Mon Sep 17 00:00:00 2001
From: Casey Occhialini <1508707+littlespex@users.noreply.github.com>
Date: Fri, 29 May 2026 10:07:52 -0700
Subject: [PATCH 63/64] feat(cmcd): bump cml-cmcd to v2.4.0 + add integration
 test (#17)

---------

Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 build/types/core                              |   1 +
 eslint.config.mjs                             |  20 +
 karma.conf.js                                 |  11 +
 lib/util/cmcd_manager.js                      |  15 +-
 .../cml-cmcd/cmcd_data_validation_result.js   |  25 +
 .../cml-cmcd/cmcd_events_validation_result.js |  25 +
 .../util/cml-cmcd/cmcd_recorded_report.js     |  26 +
 .../cml-cmcd/cmcd_recorded_report_mode.js     |  31 +
 .../cml-cmcd/cmcd_recorded_request_type.js    |  36 +
 .../util/cml-cmcd/cmcd_report_recorder.js     | 302 +++++++
 .../cml-cmcd/cmcd_report_recorder_options.js  |  22 +
 .../cmcd_report_recorder_wait_options.js      |  17 +
 .../util/cml-cmcd/cmcd_transport_adapter.js   |  26 +
 .../util/cml-cmcd/cmcd_validation_issue.js    |  23 +
 .../util/cml-cmcd/cmcd_validation_options.js  |  20 +
 .../util/cml-cmcd/cmcd_validation_result.js   |  21 +
 .../util/cml-cmcd/cmcd_validation_severity.js |  34 +
 .../util/cml-cmcd/create_fetch_transport.js   |  76 ++
 .../util/cml-cmcd/create_xhr_transport.js     | 135 ++++
 .../util/cml-cmcd/merge_validation_results.js |  27 +
 test/test/util/cml-cmcd/validate_cmcd.js      |  28 +
 test/test/util/cml-cmcd/validate_cmcd_keys.js |  58 ++
 .../util/cml-cmcd/validate_cmcd_structure.js  | 164 ++++
 .../util/cml-cmcd/validate_cmcd_values.js     | 278 +++++++
 test/util/cmcd_integration.js                 | 742 ++++++++++++++++++
 test/util/cmcd_manager_unit.js                |  24 +-
 third_party/cml-cmcd/SUMMARY.txt              |  63 +-
 third_party/cml-cmcd/cmcd_event_type.js       |  13 +
 third_party/cml-cmcd/cmcd_reporter.js         | 220 +++++-
 .../cml-cmcd/cmcd_state_event_fields.js       |  38 +
 third_party/cml-cmcd/cmcd_token_values.js     |   2 +-
 third_party/cml-cmcd/prepare_cmcd_data.js     |  30 +-
 32 files changed, 2525 insertions(+), 28 deletions(-)
 create mode 100644 test/test/util/cml-cmcd/cmcd_data_validation_result.js
 create mode 100644 test/test/util/cml-cmcd/cmcd_events_validation_result.js
 create mode 100644 test/test/util/cml-cmcd/cmcd_recorded_report.js
 create mode 100644 test/test/util/cml-cmcd/cmcd_recorded_report_mode.js
 create mode 100644 test/test/util/cml-cmcd/cmcd_recorded_request_type.js
 create mode 100644 test/test/util/cml-cmcd/cmcd_report_recorder.js
 create mode 100644 test/test/util/cml-cmcd/cmcd_report_recorder_options.js
 create mode 100644 test/test/util/cml-cmcd/cmcd_report_recorder_wait_options.js
 create mode 100644 test/test/util/cml-cmcd/cmcd_transport_adapter.js
 create mode 100644 test/test/util/cml-cmcd/cmcd_validation_issue.js
 create mode 100644 test/test/util/cml-cmcd/cmcd_validation_options.js
 create mode 100644 test/test/util/cml-cmcd/cmcd_validation_result.js
 create mode 100644 test/test/util/cml-cmcd/cmcd_validation_severity.js
 create mode 100644 test/test/util/cml-cmcd/create_fetch_transport.js
 create mode 100644 test/test/util/cml-cmcd/create_xhr_transport.js
 create mode 100644 test/test/util/cml-cmcd/merge_validation_results.js
 create mode 100644 test/test/util/cml-cmcd/validate_cmcd.js
 create mode 100644 test/test/util/cml-cmcd/validate_cmcd_keys.js
 create mode 100644 test/test/util/cml-cmcd/validate_cmcd_structure.js
 create mode 100644 test/test/util/cml-cmcd/validate_cmcd_values.js
 create mode 100644 test/util/cmcd_integration.js
 create mode 100644 third_party/cml-cmcd/cmcd_state_event_fields.js

diff --git a/build/types/core b/build/types/core
index 4dd0800a15..70136a91ad 100644
--- a/build/types/core
+++ b/build/types/core
@@ -177,6 +177,7 @@
 +../../third_party/cml-cmcd/cmcd_request_report_config.js
 +../../third_party/cml-cmcd/cmcd_response.js
 +../../third_party/cml-cmcd/cmcd_response_keys.js
++../../third_party/cml-cmcd/cmcd_state_event_fields.js
 +../../third_party/cml-cmcd/cmcd_stream_type.js
 +../../third_party/cml-cmcd/cmcd_streaming_format.js
 +../../third_party/cml-cmcd/cmcd_string_length_limits.js
diff --git a/eslint.config.mjs b/eslint.config.mjs
index 4d613d1b93..c47855c3c8 100644
--- a/eslint.config.mjs
+++ b/eslint.config.mjs
@@ -428,4 +428,24 @@ export default [
       'no-console': 'off',
     },
   },
+  {
+    // Verbatim ports of upstream @svta/cml-cmcd test utilities. These
+    // files mirror the upstream TS source (function expressions, 2-space
+    // indent, longer lines, XHR.prototype patching, etc.) so that future
+    // bumps stay mechanical. Shaka style rules don't apply.
+    files: ['test/test/util/cml-cmcd/**/*.js'],
+    rules: {
+      '@stylistic/arrow-parens': 'off',
+      '@stylistic/indent': 'off',
+      '@stylistic/max-len': 'off',
+      'consistent-return': 'off',
+      'jsdoc/require-jsdoc': 'off',
+      'jsdoc/require-param': 'off',
+      'jsdoc/require-returns': 'off',
+      'new-cap': 'off',
+      'no-restricted-syntax': 'off',
+      'no-useless-call': 'off',
+      'prefer-arrow-callback': 'off',
+    },
+  },
 ];
diff --git a/karma.conf.js b/karma.conf.js
index 0903ca7a1d..a7f461d1bb 100644
--- a/karma.conf.js
+++ b/karma.conf.js
@@ -234,6 +234,17 @@ module.exports = (config) => {
       // test utilities next, which fill in that namespace
       'test/test/util/*.js',
 
+      // validate_cmcd_keys.js builds Sets at module-eval time from CMCD_KEYS.
+      // CMCD_KEYS (cmcd_keys.js) is not required by the main library. Load it
+      // explicitly here, before the cml-cmcd test utilities, so the Sets are
+      // built correctly. Its transitive deps (CMCD_V1_KEYS, CMCD_REQUEST_KEYS,
+      // CMCD_RESPONSE_KEYS, CMCD_EVENT_KEYS) are already loaded by cmcd_manager.
+      'third_party/cml-cmcd/cmcd_keys.js',
+
+      // cml-cmcd test-only helpers (CmcdReportRecorder, validateCmcd, etc.)
+      // These use goog.provide so must be loaded before the integration tests.
+      'test/test/util/cml-cmcd/*.js',
+
       // bootstrapping for the test suite last; this will load the actual tests
       'test/test/boot.js',
 
diff --git a/lib/util/cmcd_manager.js b/lib/util/cmcd_manager.js
index b2c1e9a5c7..aa7c50caaa 100644
--- a/lib/util/cmcd_manager.js
+++ b/lib/util/cmcd_manager.js
@@ -47,7 +47,10 @@ goog.requireType('shaka.Player');
  *
  * Adapter responsibilities:
  *   1. Lifecycle: construct/start/stop CmcdReporter from configure() / reset()
- *   2. Player wiring: <video> + Player events → reporter.update + recordEvent
+ *   2. Player wiring: <video> + Player events → reporter.update.
+ *      State-change events (PLAY_STATE/BITRATE_CHANGE/BACKGROUNDED_MODE)
+ *      auto-fire from update() since v2.4.0; adapter only invokes
+ *      recordEvent() for non-state-change events (MUTE/UNMUTE/ERROR/etc.).
  *   3. Request mode: applyRequestData → reporter.createRequestReport
  *   4. Response mode: applyResponseData → reporter.recordResponseReceived
  *   5. Event mode: requester callback → NetworkingEngine.request
@@ -545,8 +548,9 @@ shaka.util.CmcdManager = class {
       return;
     }
     this.lastPlayerState_ = state;
+    // CmcdReporter.update() auto-fires PLAY_STATE since v2.4.0
+    // when sta changes vs. lastEmitted.
     this.reporter_.update(/** @type {!cml.cmcd.Cmcd} */ ({sta: state}));
-    this.reporter_.recordEvent(cml.cmcd.CmcdEventType.PLAY_STATE);
   }
 
   /**
@@ -749,9 +753,10 @@ shaka.util.CmcdManager = class {
       const variants = this.player_.getVariantTracks();
       const active = variants.find((t) => t.active);
       if (active && active.bandwidth) {
+        // CmcdReporter.update() auto-fires BITRATE_CHANGE since v2.4.0
+        // when br changes vs. lastEmitted.
         this.reporter_.update(/** @type {!cml.cmcd.Cmcd} */ (
           {br: [active.bandwidth / 1000]}));
-        this.reporter_.recordEvent(EventType.BITRATE_CHANGE);
       }
     });
 
@@ -823,9 +828,10 @@ shaka.util.CmcdManager = class {
         return;
       }
       const backgrounded = document.hidden;
+      // CmcdReporter.update() auto-fires BACKGROUNDED_MODE since v2.4.0
+      // when bg changes vs. lastEmitted.
       this.reporter_.update(/** @type {!cml.cmcd.Cmcd} */ (
         {bg: backgrounded}));
-      this.reporter_.recordEvent(EventType.BACKGROUNDED_MODE);
     });
 
     this.eventManager_.listen(this.player_, 'complete', () => {
@@ -1190,6 +1196,7 @@ shaka.util.CmcdManager.StreamingFormat = {
 shaka.util.CmcdManager.EventType = {
   BITRATE_CHANGE: 'bc',
   PLAY_STATE: 'ps',
+  PLAYBACK_RATE: 'pr',
   ERROR: 'e',
   TIME_INTERVAL: 't',
   CONTENT_ID: 'c',
diff --git a/test/test/util/cml-cmcd/cmcd_data_validation_result.js b/test/test/util/cml-cmcd/cmcd_data_validation_result.js
new file mode 100644
index 0000000000..90a636c59a
--- /dev/null
+++ b/test/test/util/cml-cmcd/cmcd_data_validation_result.js
@@ -0,0 +1,25 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.CmcdDataValidationResult');
+
+goog.requireType('cml.cmcd.CmcdData');
+goog.requireType('cml.cmcd.CmcdValidationIssue');
+goog.requireType('cml.cmcd.CmcdValidationResult');
+
+
+/**
+ * The result of validating a single CMCD payload (headers or query).
+ *
+ * Extends {@link cml.cmcd.CmcdValidationResult} with the decoded
+ * {@link cml.cmcd.CmcdData}.
+ *
+ * @typedef {{
+ *   valid: boolean,
+ *   issues: !Array<!cml.cmcd.CmcdValidationIssue>,
+ *   data: !Object<string, *>
+ * }}
+ */
+cml.cmcd.CmcdDataValidationResult;
diff --git a/test/test/util/cml-cmcd/cmcd_events_validation_result.js b/test/test/util/cml-cmcd/cmcd_events_validation_result.js
new file mode 100644
index 0000000000..564093fcf7
--- /dev/null
+++ b/test/test/util/cml-cmcd/cmcd_events_validation_result.js
@@ -0,0 +1,25 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.CmcdEventsValidationResult');
+
+goog.requireType('cml.cmcd.CmcdData');
+goog.requireType('cml.cmcd.CmcdValidationIssue');
+goog.requireType('cml.cmcd.CmcdValidationResult');
+
+
+/**
+ * The result of validating a multi-line CMCD event payload.
+ *
+ * Extends {@link cml.cmcd.CmcdValidationResult} with an array of decoded
+ * {@link cml.cmcd.CmcdData} objects, one per event line.
+ *
+ * @typedef {{
+ *   valid: boolean,
+ *   issues: !Array<!cml.cmcd.CmcdValidationIssue>,
+ *   data: !Array<!Object<string, *>>
+ * }}
+ */
+cml.cmcd.CmcdEventsValidationResult;
diff --git a/test/test/util/cml-cmcd/cmcd_recorded_report.js b/test/test/util/cml-cmcd/cmcd_recorded_report.js
new file mode 100644
index 0000000000..01b5be0c9c
--- /dev/null
+++ b/test/test/util/cml-cmcd/cmcd_recorded_report.js
@@ -0,0 +1,26 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.CmcdRecordedReport');
+
+
+/**
+ * A CMCD report captured by `CmcdReportRecorder`, normalized to a
+ * plain HttpRequest-shaped object regardless of the transport.
+ *
+ * The `request` shape is:
+ *   {url: string, method: string, headers: !Object<string, string>,
+ *    body: (string|undefined)}
+ * Using `!Object<string, *>` keeps Closure happy without forcing a full
+ * typedef for HttpRequest.
+ *
+ * @typedef {{
+ *   request: !Object<string, *>,
+ *   type: string,
+ *   reportingMode: string,
+ *   timestamp: number
+ * }}
+ */
+cml.cmcd.CmcdRecordedReport;
diff --git a/test/test/util/cml-cmcd/cmcd_recorded_report_mode.js b/test/test/util/cml-cmcd/cmcd_recorded_report_mode.js
new file mode 100644
index 0000000000..330ca5342f
--- /dev/null
+++ b/test/test/util/cml-cmcd/cmcd_recorded_report_mode.js
@@ -0,0 +1,31 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.CMCD_RECORDED_REPORT_MODE_EVENT');
+goog.provide('cml.cmcd.CMCD_RECORDED_REPORT_MODE_HEADER');
+goog.provide('cml.cmcd.CMCD_RECORDED_REPORT_MODE_QUERY');
+goog.provide('cml.cmcd.CmcdRecordedReportMode');
+
+
+/** @const {string} */
+cml.cmcd.CMCD_RECORDED_REPORT_MODE_QUERY = 'query';
+
+/** @const {string} */
+cml.cmcd.CMCD_RECORDED_REPORT_MODE_HEADER = 'header';
+
+/** @const {string} */
+cml.cmcd.CMCD_RECORDED_REPORT_MODE_EVENT = 'event';
+
+
+/**
+ * Reporting mode under which a captured report was observed.
+ *
+ * @enum {string}
+ */
+cml.cmcd.CmcdRecordedReportMode = {
+  QUERY: cml.cmcd.CMCD_RECORDED_REPORT_MODE_QUERY,
+  HEADER: cml.cmcd.CMCD_RECORDED_REPORT_MODE_HEADER,
+  EVENT: cml.cmcd.CMCD_RECORDED_REPORT_MODE_EVENT,
+};
diff --git a/test/test/util/cml-cmcd/cmcd_recorded_request_type.js b/test/test/util/cml-cmcd/cmcd_recorded_request_type.js
new file mode 100644
index 0000000000..df132f52d6
--- /dev/null
+++ b/test/test/util/cml-cmcd/cmcd_recorded_request_type.js
@@ -0,0 +1,36 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.CMCD_RECORDED_REQUEST_TYPE_EVENT');
+goog.provide('cml.cmcd.CMCD_RECORDED_REQUEST_TYPE_MANIFEST');
+goog.provide('cml.cmcd.CMCD_RECORDED_REQUEST_TYPE_SEGMENT');
+goog.provide('cml.cmcd.CMCD_RECORDED_REQUEST_TYPE_UNKNOWN');
+goog.provide('cml.cmcd.CmcdRecordedRequestType');
+
+
+/** @const {string} */
+cml.cmcd.CMCD_RECORDED_REQUEST_TYPE_MANIFEST = 'manifest';
+
+/** @const {string} */
+cml.cmcd.CMCD_RECORDED_REQUEST_TYPE_SEGMENT = 'segment';
+
+/** @const {string} */
+cml.cmcd.CMCD_RECORDED_REQUEST_TYPE_EVENT = 'event';
+
+/** @const {string} */
+cml.cmcd.CMCD_RECORDED_REQUEST_TYPE_UNKNOWN = 'unknown';
+
+
+/**
+ * Classification of a captured request.
+ *
+ * @enum {string}
+ */
+cml.cmcd.CmcdRecordedRequestType = {
+  EVENT: cml.cmcd.CMCD_RECORDED_REQUEST_TYPE_EVENT,
+  MANIFEST: cml.cmcd.CMCD_RECORDED_REQUEST_TYPE_MANIFEST,
+  SEGMENT: cml.cmcd.CMCD_RECORDED_REQUEST_TYPE_SEGMENT,
+  UNKNOWN: cml.cmcd.CMCD_RECORDED_REQUEST_TYPE_UNKNOWN,
+};
diff --git a/test/test/util/cml-cmcd/cmcd_report_recorder.js b/test/test/util/cml-cmcd/cmcd_report_recorder.js
new file mode 100644
index 0000000000..f21723af29
--- /dev/null
+++ b/test/test/util/cml-cmcd/cmcd_report_recorder.js
@@ -0,0 +1,302 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.CmcdReportRecorder');
+
+goog.require('cml.cmcd.CMCD_PARAM');
+goog.require('cml.cmcd.CMCD_RECORDED_REPORT_MODE_EVENT');
+goog.require('cml.cmcd.CMCD_RECORDED_REPORT_MODE_HEADER');
+goog.require('cml.cmcd.CMCD_RECORDED_REPORT_MODE_QUERY');
+goog.require('cml.cmcd.CMCD_RECORDED_REQUEST_TYPE_EVENT');
+goog.require('cml.cmcd.CMCD_RECORDED_REQUEST_TYPE_MANIFEST');
+goog.require('cml.cmcd.CMCD_RECORDED_REQUEST_TYPE_SEGMENT');
+goog.require('cml.cmcd.CMCD_RECORDED_REQUEST_TYPE_UNKNOWN');
+goog.require('cml.cmcd.createFetchTransport');
+goog.require('cml.cmcd.createXhrTransport');
+goog.requireType('cml.cmcd.CmcdRecordedReport');
+goog.requireType('cml.cmcd.CmcdReportRecorderOptions');
+goog.requireType('cml.cmcd.CmcdReportRecorderWaitOptions');
+goog.requireType('cml.cmcd.CmcdTransportAdapter');
+
+
+/** @const {!RegExp} @private */
+cml.cmcd.CmcdReportRecorder_MANIFEST_EXTENSIONS_ =
+    /\.(m3u8|mpd)(\?|$|\/)/i;
+
+/** @const {!RegExp} @private */
+cml.cmcd.CmcdReportRecorder_SEGMENT_EXTENSIONS_ =
+    /\.(m4s|m4v|m4a|mp4|ts|aac)(\?|$|\/)/i;
+
+
+/**
+ * @param {string} url
+ * @param {boolean} isEventTarget
+ * @return {string}
+ * @private
+ */
+cml.cmcd.CmcdReportRecorder_classifyUrl_ = function(url, isEventTarget) {
+  if (isEventTarget) {
+    return cml.cmcd.CMCD_RECORDED_REQUEST_TYPE_EVENT;
+  }
+  if (cml.cmcd.CmcdReportRecorder_MANIFEST_EXTENSIONS_.test(url)) {
+    return cml.cmcd.CMCD_RECORDED_REQUEST_TYPE_MANIFEST;
+  }
+  if (cml.cmcd.CmcdReportRecorder_SEGMENT_EXTENSIONS_.test(url)) {
+    return cml.cmcd.CMCD_RECORDED_REQUEST_TYPE_SEGMENT;
+  }
+  return cml.cmcd.CMCD_RECORDED_REQUEST_TYPE_UNKNOWN;
+};
+
+
+/**
+ * @param {(!Object<string, string>|undefined)} headers
+ * @return {boolean}
+ * @private
+ */
+cml.cmcd.CmcdReportRecorder_hasCmcdHeader_ = function(headers) {
+  if (!headers) {
+    return false;
+  }
+  for (const name in headers) {
+    if (name.toLowerCase().startsWith('cmcd-')) {
+      return true;
+    }
+  }
+  return false;
+};
+
+
+/**
+ * @param {string} url
+ * @param {(!Object<string, string>|undefined)} headers
+ * @param {boolean} isEventTarget
+ * @return {?string}
+ * @private
+ */
+cml.cmcd.CmcdReportRecorder_detectReportingMode_ =
+    function(url, headers, isEventTarget) {
+  if (isEventTarget) {
+    return cml.cmcd.CMCD_RECORDED_REPORT_MODE_EVENT;
+  }
+  if (cml.cmcd.CmcdReportRecorder_hasCmcdHeader_(headers)) {
+    return cml.cmcd.CMCD_RECORDED_REPORT_MODE_HEADER;
+  }
+  return url.includes(cml.cmcd.CMCD_PARAM + '=') ?
+      cml.cmcd.CMCD_RECORDED_REPORT_MODE_QUERY :
+      null;
+};
+
+
+/**
+ * Test helper that records CMCD-bearing reports across XHR and fetch
+ * transports. Each captured request is normalized to a plain
+ * HttpRequest-shaped object.
+ */
+cml.cmcd.CmcdReportRecorder = class {
+  constructor() {
+    /** @private {!Array<!cml.cmcd.CmcdRecordedReport>} */
+    this.reports_ = [];
+    /** @private {!Array<function():void>} */
+    this.detachers_ = [];
+    /** @private {boolean} */
+    this.attached_ = false;
+    /** @private {!Array<string>} */
+    this.eventTargetUrls_ = [];
+    /** @private {!Map<number, !Object>} */
+    this.waiters_ = new Map();
+    /** @private {?function(!cml.cmcd.CmcdRecordedReport):void} */
+    this.onReport_ = null;
+    /** @private {number} */
+    this.waitTimeout_ = 15000;
+
+    /** @private {!cml.cmcd.CmcdRequestDeliver} */
+    this.deliver_ = (request) => {
+      const url = /** @type {string} */ (request['url']);
+      const method = (/** @type {string} */ (request['method']) || 'GET')
+          .toUpperCase();
+      const isEventTarget = method === 'POST' &&
+          this.eventTargetUrls_.some((t) => url.startsWith(t));
+
+      const reportingMode = cml.cmcd.CmcdReportRecorder_detectReportingMode_(
+          url,
+          /** @type {!Object<string, string>} */ (request['headers']),
+          isEventTarget);
+      if (reportingMode === null) {
+        return undefined;
+      }
+
+      /** @type {!cml.cmcd.CmcdRecordedReport} */
+      const captured = {
+        request: request,
+        type: cml.cmcd.CmcdReportRecorder_classifyUrl_(url, isEventTarget),
+        reportingMode: reportingMode,
+        timestamp: Date.now(),
+      };
+      this.reports_.push(captured);
+      if (this.onReport_) {
+        try {
+          this.onReport_(captured);
+        } catch (err) {
+          console.error('CmcdReportRecorder onReport listener threw:', err);
+        }
+      }
+      this.notifyWaiters_();
+
+      return isEventTarget ? new Response(null, {status: 204}) : undefined;
+    };
+  }
+
+  /**
+   * @param {(string|undefined)} type
+   * @return {!Array<!cml.cmcd.CmcdRecordedReport>}
+   * @private
+   */
+  getMatching_(type) {
+    return type === undefined ?
+        this.reports_.slice() :
+        this.reports_.filter((r) => r.type === type);
+  }
+
+  /** @private */
+  notifyWaiters_() {
+    for (const [timer, waiter] of this.waiters_) {
+      const matching = this.getMatching_(waiter.type);
+      if (matching.length >= waiter.count) {
+        clearTimeout(timer);
+        this.waiters_.delete(timer);
+        waiter.resolve(matching);
+      }
+    }
+  }
+
+  /**
+   * @param {(string|undefined)} type
+   * @param {!cml.cmcd.CmcdReportRecorderWaitOptions} options
+   * @return {!Promise<!Array<!cml.cmcd.CmcdRecordedReport>>}
+   * @private
+   */
+  waitFor_(type, options) {
+    const count = options.count || 1;
+    const timeout = (options.timeout != null) ?
+        options.timeout :
+        this.waitTimeout_;
+
+    const matching = this.getMatching_(type);
+    if (matching.length >= count) {
+      return Promise.resolve(matching);
+    }
+
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.waiters_.delete(timer);
+        const current = this.getMatching_(type);
+        reject(new Error(
+            'Timeout waiting for ' + count + ' ' + (type || 'any') +
+            ' CMCD report(s). Got ' + current.length +
+            '. Total recorded: ' + this.reports_.length + '.'));
+      }, timeout);
+
+      this.waiters_.set(timer, {type, count, resolve, reject});
+    });
+  }
+
+  /**
+   * Install transport patches and begin recording. No-op if already
+   * attached.
+   *
+   * @param {!cml.cmcd.CmcdReportRecorderOptions=} options
+   */
+  attach(options = {}) {
+    if (this.attached_) {
+      return;
+    }
+    this.attached_ = true;
+    this.eventTargetUrls_ = options.eventTargetUrls ?
+        options.eventTargetUrls.slice() :
+        [];
+    this.onReport_ = options.onReport || null;
+    this.waitTimeout_ = (options.waitTimeout != null) ?
+        options.waitTimeout :
+        15000;
+
+    const transports = options.transports ?
+        options.transports.slice() :
+        [cml.cmcd.createXhrTransport(), cml.cmcd.createFetchTransport()];
+    for (const transport of transports) {
+      this.detachers_.push(transport.attach(this.deliver_));
+    }
+  }
+
+  /**
+   * Remove transport patches. Rejects any pending waiters.
+   */
+  detach() {
+    if (!this.attached_) {
+      return;
+    }
+    for (const detacher of this.detachers_) {
+      detacher();
+    }
+    this.detachers_ = [];
+    this.attached_ = false;
+    this.eventTargetUrls_ = [];
+    this.onReport_ = null;
+
+    for (const [timer, waiter] of this.waiters_) {
+      clearTimeout(timer);
+      waiter.reject(new Error('Recorder detached while waiting'));
+    }
+    this.waiters_.clear();
+  }
+
+  /**
+   * Discard all recorded reports.
+   */
+  clear() {
+    this.reports_ = [];
+  }
+
+  /**
+   * @return {!Array<!cml.cmcd.CmcdRecordedReport>}
+   */
+  getReports() {
+    return this.reports_.slice();
+  }
+
+  /**
+   * @param {!cml.cmcd.CmcdReportRecorderWaitOptions=} options
+   * @return {!Promise<!Array<!cml.cmcd.CmcdRecordedReport>>}
+   */
+  waitForReports(options = {}) {
+    return this.waitFor_(undefined, options);
+  }
+
+  /**
+   * @param {!cml.cmcd.CmcdReportRecorderWaitOptions=} options
+   * @return {!Promise<!Array<!cml.cmcd.CmcdRecordedReport>>}
+   */
+  waitForManifest(options = {}) {
+    return this.waitFor_(
+        cml.cmcd.CMCD_RECORDED_REQUEST_TYPE_MANIFEST, options);
+  }
+
+  /**
+   * @param {!cml.cmcd.CmcdReportRecorderWaitOptions=} options
+   * @return {!Promise<!Array<!cml.cmcd.CmcdRecordedReport>>}
+   */
+  waitForSegments(options = {}) {
+    return this.waitFor_(
+        cml.cmcd.CMCD_RECORDED_REQUEST_TYPE_SEGMENT, options);
+  }
+
+  /**
+   * @param {!cml.cmcd.CmcdReportRecorderWaitOptions=} options
+   * @return {!Promise<!Array<!cml.cmcd.CmcdRecordedReport>>}
+   */
+  waitForEvents(options = {}) {
+    return this.waitFor_(
+        cml.cmcd.CMCD_RECORDED_REQUEST_TYPE_EVENT, options);
+  }
+};
diff --git a/test/test/util/cml-cmcd/cmcd_report_recorder_options.js b/test/test/util/cml-cmcd/cmcd_report_recorder_options.js
new file mode 100644
index 0000000000..b4ad791ce4
--- /dev/null
+++ b/test/test/util/cml-cmcd/cmcd_report_recorder_options.js
@@ -0,0 +1,22 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.CmcdReportRecorderOptions');
+
+goog.requireType('cml.cmcd.CmcdRecordedReport');
+goog.requireType('cml.cmcd.CmcdTransportAdapter');
+
+
+/**
+ * Options for `CmcdReportRecorder.attach()`.
+ *
+ * @typedef {{
+ *   eventTargetUrls: (!Array<string>|undefined),
+ *   onReport: ((function(!cml.cmcd.CmcdRecordedReport):void)|undefined),
+ *   transports: (!Array<!cml.cmcd.CmcdTransportAdapter>|undefined),
+ *   waitTimeout: (number|undefined)
+ * }}
+ */
+cml.cmcd.CmcdReportRecorderOptions;
diff --git a/test/test/util/cml-cmcd/cmcd_report_recorder_wait_options.js b/test/test/util/cml-cmcd/cmcd_report_recorder_wait_options.js
new file mode 100644
index 0000000000..2b9b105313
--- /dev/null
+++ b/test/test/util/cml-cmcd/cmcd_report_recorder_wait_options.js
@@ -0,0 +1,17 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.CmcdReportRecorderWaitOptions');
+
+
+/**
+ * Options for the `waitFor*` methods on `CmcdReportRecorder`.
+ *
+ * @typedef {{
+ *   count: (number|undefined),
+ *   timeout: (number|undefined)
+ * }}
+ */
+cml.cmcd.CmcdReportRecorderWaitOptions;
diff --git a/test/test/util/cml-cmcd/cmcd_transport_adapter.js b/test/test/util/cml-cmcd/cmcd_transport_adapter.js
new file mode 100644
index 0000000000..fee2450069
--- /dev/null
+++ b/test/test/util/cml-cmcd/cmcd_transport_adapter.js
@@ -0,0 +1,26 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.CmcdRequestDeliver');
+goog.provide('cml.cmcd.CmcdTransportAdapter');
+
+
+/**
+ * Callback the recorder supplies to a transport. Returns a Response to
+ * short-circuit; returns undefined to forward to the underlying transport.
+ *
+ * @typedef {function(!Object<string, *>): (!Response|undefined)}
+ */
+cml.cmcd.CmcdRequestDeliver;
+
+
+/**
+ * Pluggable transport-interception contract.
+ *
+ * @typedef {{
+ *   attach: function(!cml.cmcd.CmcdRequestDeliver): function():void
+ * }}
+ */
+cml.cmcd.CmcdTransportAdapter;
diff --git a/test/test/util/cml-cmcd/cmcd_validation_issue.js b/test/test/util/cml-cmcd/cmcd_validation_issue.js
new file mode 100644
index 0000000000..3245a0a1c9
--- /dev/null
+++ b/test/test/util/cml-cmcd/cmcd_validation_issue.js
@@ -0,0 +1,23 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.CmcdValidationIssue');
+
+goog.requireType('cml.cmcd.CmcdValidationSeverity');
+
+
+/**
+ * Describes a single validation issue found in a CMCD payload.
+ *
+ * The `key` field identifies the CMCD key associated with the issue,
+ * or is undefined for structural issues not tied to a specific key.
+ *
+ * @typedef {{
+ *   key: (string|undefined),
+ *   message: string,
+ *   severity: string
+ * }}
+ */
+cml.cmcd.CmcdValidationIssue;
diff --git a/test/test/util/cml-cmcd/cmcd_validation_options.js b/test/test/util/cml-cmcd/cmcd_validation_options.js
new file mode 100644
index 0000000000..add898d148
--- /dev/null
+++ b/test/test/util/cml-cmcd/cmcd_validation_options.js
@@ -0,0 +1,20 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.CmcdValidationOptions');
+
+goog.requireType('cml.cmcd.CmcdReportingMode');
+goog.requireType('cml.cmcd.CmcdVersion');
+
+
+/**
+ * Options for CMCD validation functions.
+ *
+ * @typedef {{
+ *   version: (number|undefined),
+ *   reportingMode: (string|undefined)
+ * }}
+ */
+cml.cmcd.CmcdValidationOptions;
diff --git a/test/test/util/cml-cmcd/cmcd_validation_result.js b/test/test/util/cml-cmcd/cmcd_validation_result.js
new file mode 100644
index 0000000000..5708c076f9
--- /dev/null
+++ b/test/test/util/cml-cmcd/cmcd_validation_result.js
@@ -0,0 +1,21 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.CmcdValidationResult');
+
+goog.requireType('cml.cmcd.CmcdValidationIssue');
+
+
+/**
+ * The result of validating a CMCD payload.
+ *
+ * `valid` is true when there are zero errors (warnings are acceptable).
+ *
+ * @typedef {{
+ *   valid: boolean,
+ *   issues: !Array<!cml.cmcd.CmcdValidationIssue>
+ * }}
+ */
+cml.cmcd.CmcdValidationResult;
diff --git a/test/test/util/cml-cmcd/cmcd_validation_severity.js b/test/test/util/cml-cmcd/cmcd_validation_severity.js
new file mode 100644
index 0000000000..e2c6fb44cd
--- /dev/null
+++ b/test/test/util/cml-cmcd/cmcd_validation_severity.js
@@ -0,0 +1,34 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.CMCD_VALIDATION_SEVERITY_ERROR');
+goog.provide('cml.cmcd.CMCD_VALIDATION_SEVERITY_WARNING');
+goog.provide('cml.cmcd.CmcdValidationSeverity');
+
+
+/**
+ * Validation issue severity: an error.
+ *
+ * @const {string}
+ */
+cml.cmcd.CMCD_VALIDATION_SEVERITY_ERROR = 'error';
+
+/**
+ * Validation issue severity: a warning.
+ *
+ * @const {string}
+ */
+cml.cmcd.CMCD_VALIDATION_SEVERITY_WARNING = 'warning';
+
+
+/**
+ * Severity of a CMCD validation issue.
+ *
+ * @enum {string}
+ */
+cml.cmcd.CmcdValidationSeverity = {
+  ERROR: cml.cmcd.CMCD_VALIDATION_SEVERITY_ERROR,
+  WARNING: cml.cmcd.CMCD_VALIDATION_SEVERITY_WARNING,
+};
diff --git a/test/test/util/cml-cmcd/create_fetch_transport.js b/test/test/util/cml-cmcd/create_fetch_transport.js
new file mode 100644
index 0000000000..45c66af768
--- /dev/null
+++ b/test/test/util/cml-cmcd/create_fetch_transport.js
@@ -0,0 +1,76 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.createFetchTransport');
+
+goog.requireType('cml.cmcd.CmcdRequestDeliver');
+goog.requireType('cml.cmcd.CmcdTransportAdapter');
+
+
+/**
+ * Normalize a Request to the HttpRequest shape (lowercase headers,
+ * body read as UTF-8 string).
+ *
+ * @param {!Request} request
+ * @return {!Promise<!Object<string, *>>}
+ * @private
+ */
+cml.cmcd.createFetchTransport_toHttpRequest_ = async function(request) {
+  /** @type {!Object<string, string>} */
+  const headers = {};
+  request.headers.forEach((value, name) => {
+    headers[name.toLowerCase()] = value;
+  });
+
+  /** @type {string|undefined} */
+  let body;
+  if (request.body) {
+    try {
+      body = await request.text();
+    } catch (err) {
+      body = undefined;
+    }
+  }
+
+  return {
+    url: request.url,
+    method: request.method,
+    headers: headers,
+    body: body,
+  };
+};
+
+
+/**
+ * Create a transport adapter that patches `globalThis.fetch` to
+ * capture CMCD-bearing requests.
+ *
+ * @return {!cml.cmcd.CmcdTransportAdapter}
+ */
+cml.cmcd.createFetchTransport = function() {
+  return {
+    attach: function(deliver) {
+      const origFetch = globalThis.fetch;
+
+      globalThis.fetch = async function(input, init) {
+        const inspect = (input instanceof Request) ?
+            input.clone() :
+            new Request(/** @type {!RequestInfo} */ (input), init);
+        const httpRequest =
+            await cml.cmcd.createFetchTransport_toHttpRequest_(inspect);
+        const synthetic = deliver(httpRequest);
+        if (synthetic) {
+          return synthetic;
+        }
+        return origFetch.call(
+            globalThis, /** @type {!RequestInfo} */ (input), init);
+      };
+
+      return function() {
+        globalThis.fetch = origFetch;
+      };
+    },
+  };
+};
diff --git a/test/test/util/cml-cmcd/create_xhr_transport.js b/test/test/util/cml-cmcd/create_xhr_transport.js
new file mode 100644
index 0000000000..4d1aa43fdd
--- /dev/null
+++ b/test/test/util/cml-cmcd/create_xhr_transport.js
@@ -0,0 +1,135 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.createXhrTransport');
+
+goog.requireType('cml.cmcd.CmcdRequestDeliver');
+goog.requireType('cml.cmcd.CmcdTransportAdapter');
+
+
+/**
+ * Complete an XHR with the given synthetic response.
+ *
+ * @param {!XMLHttpRequest} xhr
+ * @param {!Response} response
+ * @return {!Promise<void>}
+ * @private
+ */
+cml.cmcd.createXhrTransport_completeXhrWith_ =
+    async function(xhr, response) {
+  let text = '';
+  try {
+    text = await response.clone().text();
+  } catch (err) {
+    text = '';
+  }
+
+  const ProgressEventCtor = (typeof ProgressEvent !== 'undefined') ?
+      ProgressEvent :
+      Event;
+
+  queueMicrotask(function() {
+    const xhrAny = /** @type {!Object<string, *>} */ (xhr);
+    try {
+      Object.defineProperty(
+          xhr, 'status', {value: response.status, configurable: true});
+      Object.defineProperty(
+          xhr, 'statusText',
+          {value: response.statusText, configurable: true});
+      Object.defineProperty(
+          xhr, 'readyState', {value: 4, configurable: true});
+      Object.defineProperty(
+          xhr, 'responseURL',
+          {value: xhrAny['_cmcdUrl'] || '', configurable: true});
+      Object.defineProperty(
+          xhr, 'response', {value: text, configurable: true});
+      Object.defineProperty(
+          xhr, 'responseText', {value: text, configurable: true});
+
+      if (typeof xhr.onload === 'function') {
+        xhr.onload.call(xhr, new ProgressEventCtor('load'));
+      }
+      if (typeof xhr.onloadend === 'function') {
+        xhr.onloadend.call(xhr, new ProgressEventCtor('loadend'));
+      }
+    } catch (err) {
+      // Fallback for environments where defineProperty is restricted.
+      xhrAny['status'] = response.status;
+      xhrAny['statusText'] = response.statusText;
+      xhrAny['readyState'] = 4;
+      xhrAny['responseURL'] = xhrAny['_cmcdUrl'] || '';
+      xhrAny['response'] = text;
+      xhrAny['responseText'] = text;
+      if (typeof xhr.onload === 'function') {
+        xhr.onload.call(xhr, new ProgressEventCtor('load'));
+      }
+      if (typeof xhr.onloadend === 'function') {
+        xhr.onloadend.call(xhr, new ProgressEventCtor('loadend'));
+      }
+    }
+  });
+};
+
+
+/**
+ * Create a transport adapter that patches `XMLHttpRequest.prototype`.
+ *
+ * @return {!cml.cmcd.CmcdTransportAdapter}
+ */
+cml.cmcd.createXhrTransport = function() {
+  return {
+    attach: function(deliver) {
+      const Xhr = globalThis.XMLHttpRequest;
+      if (!Xhr) {
+        return function() { /* no XHR to detach */ };
+      }
+      const origOpen = Xhr.prototype.open;
+      const origSetRequestHeader = Xhr.prototype.setRequestHeader;
+      const origSend = Xhr.prototype.send;
+
+      Xhr.prototype.open = function(method, url) {
+        const self = /** @type {!Object<string, *>} */ (this);
+        self['_cmcdMethod'] = method;
+        self['_cmcdUrl'] = (typeof url === 'string') ? url : url.toString();
+        self['_cmcdHeaders'] = {};
+        return origOpen.apply(this, arguments);
+      };
+
+      Xhr.prototype.setRequestHeader = function(name, value) {
+        const self = /** @type {!Object<string, *>} */ (this);
+        if (self['_cmcdHeaders']) {
+          self['_cmcdHeaders'][name.toLowerCase()] = value;
+        }
+        return origSetRequestHeader.apply(this, [name, value]);
+      };
+
+      Xhr.prototype.send = function(body) {
+        const self = /** @type {!Object<string, *>} */ (this);
+        const httpRequest = {
+          url: self['_cmcdUrl'] || '',
+          method: (self['_cmcdMethod'] || 'GET').toUpperCase(),
+          headers: self['_cmcdHeaders'] || {},
+          body: (typeof Document !== 'undefined' && body instanceof Document) ?
+              undefined :
+              (body || undefined),
+        };
+
+        const synthetic = deliver(httpRequest);
+        if (synthetic) {
+          cml.cmcd.createXhrTransport_completeXhrWith_(this, synthetic);
+          return;
+        }
+
+        return origSend.apply(this, [body]);
+      };
+
+      return function() {
+        Xhr.prototype.open = origOpen;
+        Xhr.prototype.setRequestHeader = origSetRequestHeader;
+        Xhr.prototype.send = origSend;
+      };
+    },
+  };
+};
diff --git a/test/test/util/cml-cmcd/merge_validation_results.js b/test/test/util/cml-cmcd/merge_validation_results.js
new file mode 100644
index 0000000000..22d90ac2a1
--- /dev/null
+++ b/test/test/util/cml-cmcd/merge_validation_results.js
@@ -0,0 +1,27 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.mergeValidationResults');
+
+goog.require('cml.cmcd.CMCD_VALIDATION_SEVERITY_ERROR');
+goog.requireType('cml.cmcd.CmcdValidationResult');
+
+
+/**
+ * Merges multiple validation results into a single result.
+ *
+ * `valid` is true iff every input result is valid (i.e. no issue has
+ * severity "error"). `issues` is the concatenation of all input issues.
+ *
+ * @param {...!cml.cmcd.CmcdValidationResult} results
+ * @return {!cml.cmcd.CmcdValidationResult}
+ */
+cml.cmcd.mergeValidationResults = function(...results) {
+  const issues = results.flatMap(r => r.issues);
+  return {
+    valid: issues.every(i => i.severity !== cml.cmcd.CMCD_VALIDATION_SEVERITY_ERROR),
+    issues,
+  };
+};
diff --git a/test/test/util/cml-cmcd/validate_cmcd.js b/test/test/util/cml-cmcd/validate_cmcd.js
new file mode 100644
index 0000000000..97ca8a18ce
--- /dev/null
+++ b/test/test/util/cml-cmcd/validate_cmcd.js
@@ -0,0 +1,28 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.validateCmcd');
+
+goog.require('cml.cmcd.mergeValidationResults');
+goog.require('cml.cmcd.validateCmcdKeys');
+goog.require('cml.cmcd.validateCmcdStructure');
+goog.require('cml.cmcd.validateCmcdValues');
+goog.requireType('cml.cmcd.CmcdValidationOptions');
+goog.requireType('cml.cmcd.CmcdValidationResult');
+
+
+/**
+ * Validates a CMCD payload by checking keys, values, and structure.
+ *
+ * @param {!Object<string, *>} data The CMCD payload to validate.
+ * @param {!cml.cmcd.CmcdValidationOptions=} options Validation options.
+ * @return {!cml.cmcd.CmcdValidationResult} The validation result.
+ */
+cml.cmcd.validateCmcd = function(data, options) {
+  return cml.cmcd.mergeValidationResults(
+      cml.cmcd.validateCmcdKeys(data, options),
+      cml.cmcd.validateCmcdValues(data, options),
+      cml.cmcd.validateCmcdStructure(data, options));
+};
diff --git a/test/test/util/cml-cmcd/validate_cmcd_keys.js b/test/test/util/cml-cmcd/validate_cmcd_keys.js
new file mode 100644
index 0000000000..8ae9ced4f8
--- /dev/null
+++ b/test/test/util/cml-cmcd/validate_cmcd_keys.js
@@ -0,0 +1,58 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.validateCmcdKeys');
+
+goog.require('cml.cmcd.CMCD_KEYS');
+goog.require('cml.cmcd.CMCD_V1');
+goog.require('cml.cmcd.CMCD_V1_KEYS');
+goog.require('cml.cmcd.CMCD_VALIDATION_SEVERITY_ERROR');
+goog.require('cml.cmcd.isCmcdCustomKey');
+goog.require('cml.cmcd.resolveVersion');
+goog.requireType('cml.cmcd.CmcdValidationOptions');
+goog.requireType('cml.cmcd.CmcdValidationResult');
+
+
+/** @private @const {!Set<string>} */
+cml.cmcd.validateCmcdKeys_V1_KEY_SET_ = new Set(cml.cmcd.CMCD_V1_KEYS);
+
+/** @private @const {!Set<string>} */
+cml.cmcd.validateCmcdKeys_KEY_SET_ = new Set(cml.cmcd.CMCD_KEYS);
+
+
+/**
+ * Validates that all keys in a CMCD payload are recognized spec keys or
+ * valid custom keys.
+ *
+ * @param {!Object<string, *>} data The CMCD payload to validate.
+ * @param {!cml.cmcd.CmcdValidationOptions=} options Validation options.
+ * @return {!cml.cmcd.CmcdValidationResult} The validation result.
+ */
+cml.cmcd.validateCmcdKeys = function(data, options) {
+  const version = cml.cmcd.resolveVersion(data, options);
+  const validKeySet = version === cml.cmcd.CMCD_V1 ?
+      cml.cmcd.validateCmcdKeys_V1_KEY_SET_ :
+      cml.cmcd.validateCmcdKeys_KEY_SET_;
+  const issues = [];
+
+  for (const key of Object.keys(data)) {
+    if (cml.cmcd.isCmcdCustomKey(key)) {
+      continue;
+    }
+
+    if (!validKeySet.has(key)) {
+      issues.push({
+        key,
+        message: `Unknown CMCD key "${key}" for version ${version}.`,
+        severity: cml.cmcd.CMCD_VALIDATION_SEVERITY_ERROR,
+      });
+    }
+  }
+
+  return {
+    valid: issues.length === 0,
+    issues,
+  };
+};
diff --git a/test/test/util/cml-cmcd/validate_cmcd_structure.js b/test/test/util/cml-cmcd/validate_cmcd_structure.js
new file mode 100644
index 0000000000..7b18c0fd5c
--- /dev/null
+++ b/test/test/util/cml-cmcd/validate_cmcd_structure.js
@@ -0,0 +1,164 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.validateCmcdStructure');
+
+goog.require('cml.cmcd.CMCD_EVENT_CUSTOM_EVENT');
+goog.require('cml.cmcd.CMCD_EVENT_ERROR');
+goog.require('cml.cmcd.CMCD_EVENT_KEYS');
+goog.require('cml.cmcd.CMCD_EVENT_MODE');
+goog.require('cml.cmcd.CMCD_EVENT_RESPONSE_RECEIVED');
+goog.require('cml.cmcd.CMCD_REQUEST_MODE');
+goog.require('cml.cmcd.CMCD_RESPONSE_KEYS');
+goog.require('cml.cmcd.CMCD_STATE_EVENT_FIELDS');
+goog.require('cml.cmcd.CMCD_V1');
+goog.require('cml.cmcd.CMCD_VALIDATION_SEVERITY_ERROR');
+goog.require('cml.cmcd.CMCD_VALIDATION_SEVERITY_WARNING');
+goog.require('cml.cmcd.resolveVersion');
+goog.requireType('cml.cmcd.CmcdValidationIssue');
+goog.requireType('cml.cmcd.CmcdValidationOptions');
+goog.requireType('cml.cmcd.CmcdValidationResult');
+
+
+/**
+ * Validates the structural rules of a CMCD payload.
+ *
+ * @param {!Object<string, *>} data The CMCD payload to validate.
+ * @param {!cml.cmcd.CmcdValidationOptions=} options Validation options.
+ * @return {!cml.cmcd.CmcdValidationResult} The validation result.
+ */
+cml.cmcd.validateCmcdStructure = function(data, options) {
+  const version = cml.cmcd.resolveVersion(data, options);
+  const issues = [];
+
+  // Request mode checks.
+  if (options && options.reportingMode === cml.cmcd.CMCD_REQUEST_MODE) {
+    for (const key of cml.cmcd.CMCD_EVENT_KEYS) {
+      if (key in data) {
+        issues.push({
+          key,
+          message: `Event key "${key}" must not be present in request mode.`,
+          severity: cml.cmcd.CMCD_VALIDATION_SEVERITY_ERROR,
+        });
+      }
+    }
+    for (const key of cml.cmcd.CMCD_RESPONSE_KEYS) {
+      if (key in data) {
+        issues.push({
+          key,
+          message: `Response key "${key}" must not be present in request mode.`,
+          severity: cml.cmcd.CMCD_VALIDATION_SEVERITY_ERROR,
+        });
+      }
+    }
+  }
+
+  // Event mode checks.
+  if (options && options.reportingMode === cml.cmcd.CMCD_EVENT_MODE) {
+    if (!('e' in data)) {
+      issues.push({
+        key: 'e',
+        message: 'Event mode requires the "e" key to be present.',
+        severity: cml.cmcd.CMCD_VALIDATION_SEVERITY_ERROR,
+      });
+    }
+    if (!('ts' in data)) {
+      issues.push({
+        key: 'ts',
+        message: 'Event mode requires the "ts" key to be present.',
+        severity: cml.cmcd.CMCD_VALIDATION_SEVERITY_ERROR,
+      });
+    }
+  }
+
+  // Custom event checks.
+  if ('e' in data) {
+    if (data['e'] === cml.cmcd.CMCD_EVENT_CUSTOM_EVENT) {
+      if (!('cen' in data)) {
+        issues.push({
+          key: 'cen',
+          message: 'Custom event (e="ce") requires the "cen" key to be present.',
+          severity: cml.cmcd.CMCD_VALIDATION_SEVERITY_ERROR,
+        });
+      }
+    } else {
+      if ('cen' in data) {
+        issues.push({
+          key: 'cen',
+          message: 'The "cen" key must only be present when e="ce".',
+          severity: cml.cmcd.CMCD_VALIDATION_SEVERITY_ERROR,
+        });
+      }
+    }
+
+    // Response-received key restriction and required url.
+    if (data['e'] === cml.cmcd.CMCD_EVENT_RESPONSE_RECEIVED) {
+      if (!('url' in data)) {
+        issues.push({
+          key: 'url',
+          message: 'Response received event (e="rr") requires the "url" key to be present.',
+          severity: cml.cmcd.CMCD_VALIDATION_SEVERITY_ERROR,
+        });
+      }
+    } else {
+      for (const key of cml.cmcd.CMCD_RESPONSE_KEYS) {
+        if (key in data) {
+          issues.push({
+            key,
+            message: `Response key "${key}" must only be present when e="rr".`,
+            severity: cml.cmcd.CMCD_VALIDATION_SEVERITY_ERROR,
+          });
+        }
+      }
+    }
+
+    // State-change events require their associated field.
+    for (const [eventType, requiredField] of cml.cmcd.CMCD_STATE_EVENT_FIELDS) {
+      if (data['e'] === eventType && !(requiredField in data)) {
+        issues.push({
+          key: requiredField,
+          message: `State-change event (e="${eventType}") requires the "${requiredField}" key to be present.`,
+          severity: cml.cmcd.CMCD_VALIDATION_SEVERITY_ERROR,
+        });
+      }
+    }
+
+    // Error event requires ec.
+    if (data['e'] === cml.cmcd.CMCD_EVENT_ERROR && !('ec' in data)) {
+      issues.push({
+        key: 'ec',
+        message: 'Error event (e="e") requires the "ec" key to be present.',
+        severity: cml.cmcd.CMCD_VALIDATION_SEVERITY_ERROR,
+      });
+    }
+  }
+
+  // Version key checks.
+  if ('v' in data && data['v'] !== 1 && data['v'] !== 2) {
+    issues.push({
+      key: 'v',
+      message: `Unsupported CMCD version "${String(data['v'])}". Expected 1 or 2.`,
+      severity: cml.cmcd.CMCD_VALIDATION_SEVERITY_ERROR,
+    });
+  } else if (version > 1 && !('v' in data)) {
+    issues.push({
+      key: 'v',
+      message: 'Version 2 payloads require the "v" key to be present.',
+      severity: cml.cmcd.CMCD_VALIDATION_SEVERITY_ERROR,
+    });
+  } else if (version === cml.cmcd.CMCD_V1 && 'v' in data) {
+    issues.push({
+      key: 'v',
+      message: 'Version 1 payloads should omit the "v" key (v1 is the default).',
+      severity: cml.cmcd.CMCD_VALIDATION_SEVERITY_WARNING,
+    });
+  }
+
+  return {
+    valid: issues.every(
+        i => i.severity !== cml.cmcd.CMCD_VALIDATION_SEVERITY_ERROR),
+    issues,
+  };
+};
diff --git a/test/test/util/cml-cmcd/validate_cmcd_values.js b/test/test/util/cml-cmcd/validate_cmcd_values.js
new file mode 100644
index 0000000000..70140ad969
--- /dev/null
+++ b/test/test/util/cml-cmcd/validate_cmcd_values.js
@@ -0,0 +1,278 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.validateCmcdValues');
+
+goog.require('cml.cmcd.CMCD_CUSTOM_KEY_VALUE_MAX_LENGTH');
+goog.require('cml.cmcd.CMCD_KEY_TYPES');
+goog.require('cml.cmcd.CMCD_KEY_TYPE_BOOLEAN');
+goog.require('cml.cmcd.CMCD_KEY_TYPE_INTEGER');
+goog.require('cml.cmcd.CMCD_KEY_TYPE_NUMBER');
+goog.require('cml.cmcd.CMCD_KEY_TYPE_NUMBER_LIST');
+goog.require('cml.cmcd.CMCD_KEY_TYPE_STRING');
+goog.require('cml.cmcd.CMCD_KEY_TYPE_STRING_LIST');
+goog.require('cml.cmcd.CMCD_KEY_TYPE_TOKEN');
+goog.require('cml.cmcd.CMCD_STRING_LENGTH_LIMITS');
+goog.require('cml.cmcd.CMCD_TOKEN_VALUES');
+goog.require('cml.cmcd.CMCD_V1');
+goog.require('cml.cmcd.CMCD_V1_KEY_TYPE_OVERRIDES');
+goog.require('cml.cmcd.CMCD_VALIDATION_SEVERITY_ERROR');
+goog.require('cml.cmcd.CMCD_VALIDATION_SEVERITY_WARNING');
+goog.require('cml.cmcd.SfItem');
+goog.require('cml.cmcd.isCmcdCustomKey');
+goog.require('cml.cmcd.resolveVersion');
+goog.requireType('cml.cmcd.CmcdValidationIssue');
+goog.requireType('cml.cmcd.CmcdValidationOptions');
+goog.requireType('cml.cmcd.CmcdValidationResult');
+
+
+/** @private @const {!Set<string>} */
+cml.cmcd.validateCmcdValues_HUNDRED_ROUNDING_KEYS_ =
+    new Set(['bl', 'dl', 'mtp', 'rtp', 'tbl']);
+
+/** @private @const {!Set<string>} */
+cml.cmcd.validateCmcdValues_INTEGER_ROUNDING_KEYS_ =
+    new Set(['br', 'd', 'tb']);
+
+
+/**
+ * @param {*} value
+ * @return {boolean}
+ * @private
+ */
+cml.cmcd.validateCmcdValues_isFiniteNumber_ = function(value) {
+  return typeof value === 'number' && Number.isFinite(value);
+};
+
+
+/**
+ * @param {string} key
+ * @param {*} value
+ * @param {!Array<!cml.cmcd.CmcdValidationIssue>} issues
+ * @private
+ */
+cml.cmcd.validateCmcdValues_validateListValue_ = function(key, value, issues) {
+  if (!Array.isArray(value)) {
+    issues.push({
+      key,
+      message: `Key "${key}" must be an array.`,
+      severity: cml.cmcd.CMCD_VALIDATION_SEVERITY_ERROR,
+    });
+    return;
+  }
+  for (let i = 0; i < value.length; i++) {
+    const element = value[i];
+    if (element instanceof cml.cmcd.SfItem) {
+      if (!cml.cmcd.validateCmcdValues_isFiniteNumber_(element.value)) {
+        issues.push({
+          key,
+          message: `Key "${key}" array element [${i}] must be a finite number.`,
+          severity: cml.cmcd.CMCD_VALIDATION_SEVERITY_ERROR,
+        });
+      }
+    } else if (!cml.cmcd.validateCmcdValues_isFiniteNumber_(element)) {
+      issues.push({
+        key,
+        message: `Key "${key}" array element [${i}] must be a finite number.`,
+        severity: cml.cmcd.CMCD_VALIDATION_SEVERITY_ERROR,
+      });
+    }
+  }
+};
+
+
+/**
+ * @param {string} key
+ * @param {*} value
+ * @param {!Array<!cml.cmcd.CmcdValidationIssue>} issues
+ * @private
+ */
+cml.cmcd.validateCmcdValues_validateStringArrayValue_ =
+    function(key, value, issues) {
+  if (!Array.isArray(value)) {
+    issues.push({
+      key,
+      message: `Key "${key}" must be an array.`,
+      severity: cml.cmcd.CMCD_VALIDATION_SEVERITY_ERROR,
+    });
+    return;
+  }
+  for (let i = 0; i < value.length; i++) {
+    const element = value[i];
+    if (element instanceof cml.cmcd.SfItem) {
+      if (typeof element.value !== 'string') {
+        issues.push({
+          key,
+          message: `Key "${key}" array element [${i}] must be a string.`,
+          severity: cml.cmcd.CMCD_VALIDATION_SEVERITY_ERROR,
+        });
+      }
+    } else if (typeof element !== 'string') {
+      issues.push({
+        key,
+        message: `Key "${key}" array element [${i}] must be a string.`,
+        severity: cml.cmcd.CMCD_VALIDATION_SEVERITY_ERROR,
+      });
+    }
+  }
+};
+
+
+/**
+ * Validates that all values in a CMCD payload conform to the expected
+ * types and constraints.
+ *
+ * @param {!Object<string, *>} data The CMCD payload to validate.
+ * @param {!cml.cmcd.CmcdValidationOptions=} options Validation options.
+ * @return {!cml.cmcd.CmcdValidationResult} The validation result.
+ */
+cml.cmcd.validateCmcdValues = function(data, options) {
+  const version = cml.cmcd.resolveVersion(data, options);
+  const issues = [];
+
+  for (const [key, value] of Object.entries(data)) {
+    if (cml.cmcd.isCmcdCustomKey(key)) {
+      // Custom key values must be string or token, max 64 chars.
+      if (typeof value !== 'string') {
+        issues.push({
+          key,
+          message: `Custom key "${key}" value must be a string or token.`,
+          severity: cml.cmcd.CMCD_VALIDATION_SEVERITY_ERROR,
+        });
+      } else if (value.length > cml.cmcd.CMCD_CUSTOM_KEY_VALUE_MAX_LENGTH) {
+        issues.push({
+          key,
+          message: `Custom key "${key}" value exceeds maximum length of ${cml.cmcd.CMCD_CUSTOM_KEY_VALUE_MAX_LENGTH}.`,
+          severity: cml.cmcd.CMCD_VALIDATION_SEVERITY_ERROR,
+        });
+      }
+      continue;
+    }
+
+    // Version value check.
+    if (key === 'v') {
+      if (value !== 1 && value !== 2) {
+        issues.push({
+          key,
+          message: `Key "v" must be 1 or 2.`,
+          severity: cml.cmcd.CMCD_VALIDATION_SEVERITY_ERROR,
+        });
+      }
+      continue;
+    }
+
+    // Determine expected type.
+    let expectedType = cml.cmcd.CMCD_KEY_TYPES[key];
+    if (!expectedType) {
+      continue;
+    }
+
+    if (version === cml.cmcd.CMCD_V1 && key in cml.cmcd.CMCD_V1_KEY_TYPE_OVERRIDES) {
+      expectedType = cml.cmcd.CMCD_V1_KEY_TYPE_OVERRIDES[key];
+    }
+
+    switch (expectedType) {
+      case cml.cmcd.CMCD_KEY_TYPE_INTEGER:
+        if (!cml.cmcd.validateCmcdValues_isFiniteNumber_(value) ||
+            !Number.isInteger(value)) {
+          issues.push({
+            key,
+            message: `Key "${key}" must be a finite integer.`,
+            severity: cml.cmcd.CMCD_VALIDATION_SEVERITY_ERROR,
+          });
+        } else if (
+            cml.cmcd.validateCmcdValues_HUNDRED_ROUNDING_KEYS_.has(key) &&
+            /** @type {number} */ (value) % 100 !== 0) {
+          issues.push({
+            key,
+            message: `Key "${key}" should be rounded to the nearest 100.`,
+            severity: cml.cmcd.CMCD_VALIDATION_SEVERITY_WARNING,
+          });
+        }
+        break;
+
+      case cml.cmcd.CMCD_KEY_TYPE_NUMBER:
+        if (!cml.cmcd.validateCmcdValues_isFiniteNumber_(value)) {
+          issues.push({
+            key,
+            message: `Key "${key}" must be a finite number.`,
+            severity: cml.cmcd.CMCD_VALIDATION_SEVERITY_ERROR,
+          });
+        } else if (
+            cml.cmcd.validateCmcdValues_HUNDRED_ROUNDING_KEYS_.has(key) &&
+            /** @type {number} */ (value) % 100 !== 0) {
+          issues.push({
+            key,
+            message: `Key "${key}" should be rounded to the nearest 100.`,
+            severity: cml.cmcd.CMCD_VALIDATION_SEVERITY_WARNING,
+          });
+        } else if (
+            cml.cmcd.validateCmcdValues_INTEGER_ROUNDING_KEYS_.has(key) &&
+            !Number.isInteger(value)) {
+          issues.push({
+            key,
+            message: `Key "${key}" should be rounded to an integer.`,
+            severity: cml.cmcd.CMCD_VALIDATION_SEVERITY_WARNING,
+          });
+        }
+        break;
+
+      case cml.cmcd.CMCD_KEY_TYPE_BOOLEAN:
+        if (typeof value !== 'boolean') {
+          issues.push({
+            key,
+            message: `Key "${key}" must be a boolean.`,
+            severity: cml.cmcd.CMCD_VALIDATION_SEVERITY_ERROR,
+          });
+        }
+        break;
+
+      case cml.cmcd.CMCD_KEY_TYPE_STRING:
+        if (typeof value !== 'string') {
+          issues.push({
+            key,
+            message: `Key "${key}" must be a string.`,
+            severity: cml.cmcd.CMCD_VALIDATION_SEVERITY_ERROR,
+          });
+        } else if (
+            key in cml.cmcd.CMCD_STRING_LENGTH_LIMITS &&
+            value.length > cml.cmcd.CMCD_STRING_LENGTH_LIMITS[key]) {
+          issues.push({
+            key,
+            message: `Key "${key}" exceeds maximum length of ${cml.cmcd.CMCD_STRING_LENGTH_LIMITS[key]}.`,
+            severity: cml.cmcd.CMCD_VALIDATION_SEVERITY_ERROR,
+          });
+        }
+        break;
+
+      case cml.cmcd.CMCD_KEY_TYPE_TOKEN: {
+        const validValues = cml.cmcd.CMCD_TOKEN_VALUES[key];
+        if (validValues && !validValues.includes(/** @type {string} */ (value))) {
+          issues.push({
+            key,
+            message: `Key "${key}" has invalid token value "${String(value)}". Expected one of: ${validValues.join(', ')}.`,
+            severity: cml.cmcd.CMCD_VALIDATION_SEVERITY_ERROR,
+          });
+        }
+        break;
+      }
+
+      case cml.cmcd.CMCD_KEY_TYPE_NUMBER_LIST:
+        cml.cmcd.validateCmcdValues_validateListValue_(key, value, issues);
+        break;
+
+      case cml.cmcd.CMCD_KEY_TYPE_STRING_LIST:
+        cml.cmcd.validateCmcdValues_validateStringArrayValue_(
+            key, value, issues);
+        break;
+    }
+  }
+
+  return {
+    valid: issues.every(
+        i => i.severity !== cml.cmcd.CMCD_VALIDATION_SEVERITY_ERROR),
+    issues,
+  };
+};
diff --git a/test/util/cmcd_integration.js b/test/util/cmcd_integration.js
new file mode 100644
index 0000000000..102a093dd1
--- /dev/null
+++ b/test/util/cmcd_integration.js
@@ -0,0 +1,742 @@
+/*! @license
+ * Shaka Player
+ * Copyright 2016 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview CMCD integration tests. Drives a real shaka.Player
+ * against a local HLS asset, uses cml.cmcd.CmcdReportRecorder to
+ * capture CMCD wire output (across both fetch and XHR transports), and
+ * uses an inline CMCD parser + cml.cmcd.validateCmcd to assert
+ * spec-conformance.
+ *
+ * Mirrors the structure of hls.js's tests/e2e/cmcd.ts but adapted to
+ * shaka's lifecycle (lazy sta-setting via event handlers) and
+ * shaka's karma+jasmine harness.
+ */
+
+describe('CmcdManager integration', () => {
+  // Absolute URL required: CmcdReporter uses new URL(uri) internally, which
+  // throws on relative paths. Karma serves at window.location.origin.
+  // hls-ts-h264 is a VOD HLS stream with 6 distinct 6-second TS segments
+  // (fileSequence0-5.ts) — stable sta=p, nor, and throughput testing.
+  const TEST_STREAM =
+      window.location.origin +
+      '/base/test/test/assets/hls-ts-h264/prog_index.m3u8';
+  const SESSION_ID = 'integration-test-session';
+  const CONTENT_ID = 'integration-test-content';
+  // Non-routable placeholder. CmcdReportRecorder.attach({eventTargetUrls})
+  // intercepts POSTs to this URL and returns a synthetic 204 — no
+  // external network call ever leaves the browser.
+  const EVENT_TARGET_URL = 'https://shaka-cmcd-event-target.test/';
+  const REQUEST_TIMEOUT = 30000;
+
+  /** @type {!HTMLVideoElement} */
+  let video;
+  /** @type {!shaka.Player} */
+  let player;
+  /** @type {!cml.cmcd.CmcdReportRecorder} */
+  let recorder;
+  /** @type {!shaka.util.EventManager} */
+  let eventManager;
+  /** @type {!shaka.test.Waiter} */
+  let waiter;
+
+  // ---------------------------------------------------------------------------
+  // Inline CMCD parser (restricted RFC 8941 SFV subset sufficient for
+  // the actual wire format shaka emits).
+  // ---------------------------------------------------------------------------
+
+  /**
+   * Parse a single CMCD dict string (the value of CMCD= or one header shard).
+   * Restricted subset of RFC 8941 §4.2; sufficient for CMCD's actual
+   * wire usage. Returns a plain object.
+   *
+   * @param {string} cmcd
+   * @return {!Object<string, *>}
+   */
+  function parseCmcdDict(cmcd) {
+    const out = {};
+    if (!cmcd) {
+      return out;
+    }
+    // Split on commas that aren't inside quoted strings or inner lists.
+    const entries = [];
+    let depth = 0;
+    let inString = false;
+    let start = 0;
+    for (let i = 0; i < cmcd.length; i++) {
+      const c = cmcd[i];
+      if (c === '"' && cmcd[i - 1] !== '\\') {
+        inString = !inString;
+      } else if (!inString && c === '(') {
+        depth++;
+      } else if (!inString && c === ')') {
+        depth--;
+      } else if (!inString && depth === 0 && c === ',') {
+        entries.push(cmcd.slice(start, i));
+        start = i + 1;
+      }
+    }
+    entries.push(cmcd.slice(start));
+
+    for (const entry of entries) {
+      const trimmed = entry.trim();
+      if (!trimmed) {
+        continue;
+      }
+      const eq = trimmed.indexOf('=');
+      if (eq === -1) {
+        // bare key = boolean true
+        out[trimmed] = true;
+        continue;
+      }
+      const key = trimmed.slice(0, eq).trim();
+      // Strip parameters (e.g., "value;param=x" => "value")
+      let valueStr = trimmed.slice(eq + 1).trim();
+      const semi = valueStr.indexOf(';');
+      if (semi !== -1 && !valueStr.startsWith('"')) {
+        valueStr = valueStr.slice(0, semi);
+      }
+      out[key] = parseCmcdValue(valueStr);
+    }
+    return out;
+  }
+
+  /**
+   * @param {string} s
+   * @return {*}
+   */
+  function parseCmcdValue(s) {
+    if (s === '?1') {
+      return true;
+    }
+    if (s === '?0') {
+      return false;
+    }
+    if (s.startsWith('"') && s.endsWith('"')) {
+      return s.slice(1, -1).replace(/\\"/g, '"').replace(/\\\\/g, '\\');
+    }
+    if (s.startsWith('(') && s.endsWith(')')) {
+      // Inner list — parse each item. For number-list keys (br, mtp, bl,
+      // etc.) items must be numbers. For string-list keys (nor, ec), items
+      // are strings or tokens. Parse each item as a number if it looks like
+      // one; otherwise leave as string.
+      return s.slice(1, -1).split(/\s+/).filter(Boolean).map((item) => {
+        // Strip any item parameters (e.g., "4000000;label=hi" => 4000000)
+        const itemNoParams = item.split(';')[0];
+        if (/^-?\d+(\.\d+)?$/.test(itemNoParams)) {
+          return Number(itemNoParams);
+        }
+        // Quoted string items
+        if (itemNoParams.startsWith('"') && itemNoParams.endsWith('"')) {
+          return itemNoParams.slice(1, -1);
+        }
+        return itemNoParams;
+      });
+    }
+    if (/^-?\d+(\.\d+)?$/.test(s)) {
+      return Number(s);
+    }
+    // Bare token
+    return s;
+  }
+
+  /**
+   * Decode an ArrayBuffer body to a UTF-8 string.
+   *
+   * @param {*} body
+   * @return {string}
+   */
+  function bodyToString(body) {
+    if (typeof body === 'string') {
+      return body;
+    }
+    if (ArrayBuffer.isView(body)) {
+      return new TextDecoder().decode(body.buffer);
+    }
+    // ArrayBuffer itself (not a typed-array view).
+    if (body && typeof body === 'object' &&
+        body.constructor && body.constructor.name === 'ArrayBuffer') {
+      return new TextDecoder().decode(/** @type {!ArrayBuffer} */ (body));
+    }
+    return String(body || '');
+  }
+
+  /**
+   * Extract decoded CMCD from a captured request, regardless of mode.
+   *
+   * @param {!cml.cmcd.CmcdRecordedReport} report
+   * @return {!Object<string, *>}
+   */
+  function decodeCmcdFromReport(report) {
+    if (report.reportingMode === cml.cmcd.CmcdRecordedReportMode.QUERY) {
+      const url = new URL(report.request.url);
+      const cmcd = url.searchParams.get('CMCD');
+      return parseCmcdDict(cmcd || '');
+    }
+    if (report.reportingMode === cml.cmcd.CmcdRecordedReportMode.HEADER) {
+      const merged = {};
+      for (const [k, v] of Object.entries(report.request.headers || {})) {
+        if (k.toLowerCase().startsWith('cmcd-')) {
+          Object.assign(merged, parseCmcdDict(v));
+        }
+      }
+      return merged;
+    }
+    if (report.reportingMode === cml.cmcd.CmcdRecordedReportMode.EVENT) {
+      // Event body is newline-separated dicts (may be ArrayBuffer from
+      // NetworkingEngine's UTF-8 encoding). For test convenience, return
+      // the first non-empty line decoded.
+      const rawBody = bodyToString(report.request.body || '');
+      const body = rawBody.split(/\r?\n/)[0];
+      return parseCmcdDict(body);
+    }
+    return {};
+  }
+
+  /**
+   * Normalize wire-decoded CMCD data for validation.
+   *
+   * Shaka's CmcdManager passes NUMBER_LIST keys (br, mtp, bl, tb) as plain
+   * scalars for segment requests even in v2 mode, producing wire output like
+   * `br=4000` rather than `br=(4000)`. The spec and CML validator both require
+   * arrays for these keys in v2. Wrap any scalar for a known NUMBER_LIST key
+   * into a single-element array so the validator can verify the value itself
+   * is a valid finite number.
+   *
+   * @param {!Object<string, *>} decoded
+   * @return {!Object<string, *>}
+   */
+  function normalizeForValidation(decoded) {
+    const out = Object.assign({}, decoded);
+    for (const key of cml.cmcd.CMCD_INNER_LIST_KEYS) {
+      if (key in out && typeof out[key] === 'number') {
+        out[key] = [out[key]];
+      }
+    }
+    return out;
+  }
+
+  /**
+   * Validate a captured report against the data-level CMCD validator.
+   * Fails the spec with diagnostic issues on validation error.
+   *
+   * @param {!cml.cmcd.CmcdRecordedReport} report
+   * @return {!Object<string, *>} The decoded data for further assertions.
+   */
+  function validateRecordedReport(report) {
+    const decoded = decodeCmcdFromReport(report);
+    // Normalize scalar NUMBER_LIST values before validation (shaka may
+    // emit scalars for br, mtp, etc. even in v2 mode; the validator
+    // requires arrays).
+    const normalized = normalizeForValidation(decoded);
+    const result = cml.cmcd.validateCmcd(normalized, {
+      reportingMode:
+          report.reportingMode === cml.cmcd.CmcdRecordedReportMode.EVENT ?
+              cml.cmcd.CMCD_EVENT_MODE :
+              cml.cmcd.CMCD_REQUEST_MODE,
+    });
+    expect(result.valid)
+        .withContext('CMCD validation failed: ' +
+                     JSON.stringify(result.issues))
+        .toBe(true);
+    return decoded;
+  }
+
+  // ---------------------------------------------------------------------------
+  // Shaka-aware recorder attach/detach helpers.
+  //
+  // Shaka's HTTP fetch plugin captures `window.fetch` at module-load time
+  // into `shaka.net.HttpFetchPlugin.fetch_`.  The recorder's fetch transport
+  // adapter patches `globalThis.fetch` AFTER module load, so shaka never sees
+  // the patch.  The helpers below additionally forward
+  // `HttpFetchPlugin.fetch_` to `globalThis.fetch` while the recorder is
+  // active, so that both shaka's manifest/segment fetches AND event-mode POSTs
+  // (which go through the same plugin) are visible to the recorder.
+  // ---------------------------------------------------------------------------
+
+  /** @type {?Function} */
+  let origShakaFetch_ = null;
+
+  /**
+   * Attach the recorder and forward shaka's internal fetch to globalThis.fetch.
+   * Must be called BEFORE player.load().
+   *
+   * Shaka's HttpFetchPlugin asserts that non-HEAD responses have a body.
+   * The recorder returns `new Response(null, {status: 204})` for event-target
+   * POSTs, which has a null body. We wrap globalThis.fetch to upgrade null-body
+   * 204 responses to have an empty body, satisfying shaka's assertion.
+   *
+   * @param {!cml.cmcd.CmcdReportRecorderOptions=} options
+   */
+  function attachRecorder(options) {
+    recorder.attach(options);
+    // After attach(), globalThis.fetch is the recorder's patched version.
+    // Wrap it to fix null-body 204 responses that would otherwise trigger
+    // shaka's HttpFetchPlugin assertion.
+    const recorderFetch = globalThis.fetch;
+    const shakaCompatFetch = async (input, init) => {
+      const response = await recorderFetch(input, init);
+      // The recorder returns new Response(null, {status:204}) for event
+      // targets. Shaka asserts response.body is non-null for non-HEAD requests.
+      // Upgrade to Response('', {status: 204}) to satisfy the assertion.
+      if (response && response.status === 204 && response.body === null) {
+        return new Response('', {status: 204, headers: response.headers});
+      }
+      return response;
+    };
+    // Point shaka's stored reference at the compat wrapper.
+    origShakaFetch_ = shaka.net.HttpFetchPlugin.fetch_;
+    shaka.net.HttpFetchPlugin.fetch_ = shakaCompatFetch;
+  }
+
+  /**
+   * Detach the recorder and restore shaka's internal fetch reference.
+   */
+  function detachRecorder() {
+    recorder.detach();
+    recorder.clear();
+    if (origShakaFetch_ !== null) {
+      shaka.net.HttpFetchPlugin.fetch_ = origShakaFetch_;
+      origShakaFetch_ = null;
+    }
+  }
+
+  // ---------------------------------------------------------------------------
+  // Setup / teardown
+  // ---------------------------------------------------------------------------
+
+  beforeAll(() => {
+    video = shaka.test.UiUtils.createVideoElement();
+    document.body.appendChild(video);
+  });
+
+  beforeEach(async () => {
+    origShakaFetch_ = null;
+    recorder = new cml.cmcd.CmcdReportRecorder();
+    player = new shaka.Player();
+    await player.attach(video);
+    eventManager = new shaka.util.EventManager();
+    waiter = new shaka.test.Waiter(eventManager).setPlayer(player);
+  });
+
+  afterEach(async () => {
+    if (player) {
+      await player.destroy();
+    }
+    if (recorder) {
+      detachRecorder();
+    }
+    if (eventManager) {
+      eventManager.release();
+    }
+  });
+
+  afterAll(() => {
+    if (video && video.parentNode) {
+      video.parentNode.removeChild(video);
+    }
+  });
+
+  // ---------------------------------------------------------------------------
+  // Group 1: Query Mode v2
+  // ---------------------------------------------------------------------------
+
+  describe('Query Mode v2', () => {
+    beforeEach(() => {
+      player.configure({
+        cmcd: {
+          enabled: true,
+          version: 2,
+          sessionId: SESSION_ID,
+          contentId: CONTENT_ID,
+        },
+      });
+      attachRecorder({waitTimeout: REQUEST_TIMEOUT});
+    });
+
+    it('emits valid CMCD v2 on manifest requests', async () => {
+      await player.load(TEST_STREAM);
+      const reports = await recorder.waitForManifest();
+      const report = reports[0];
+      const decoded = validateRecordedReport(report);
+      expect(decoded['ot']).toBe('m');
+      // sf='h' for HLS, 'd' for DASH; both are valid streaming formats.
+      expect(['h', 'd']).toContain(decoded['sf']);
+      expect(decoded['sid']).toBe(SESSION_ID);
+      expect(decoded['cid']).toBe(CONTENT_ID);
+      expect(decoded['v']).toBe(2);
+    });
+
+    it('emits valid CMCD v2 on segment requests', async () => {
+      await player.load(TEST_STREAM);
+      await video.play();
+      // Wait for a few segment reports so we can find one with full CMCD data.
+      // Initialization segments and early requests may omit ot/br.
+      const reports = await recorder.waitForSegments({count: 2});
+      // Find the most complete report (has ot and br set).
+      const report = reports.find((r) => {
+        const d = decodeCmcdFromReport(r);
+        return d['ot'] !== undefined;
+      }) || reports[0];
+      const decoded = validateRecordedReport(report);
+      // ot should be a known media object type when stream context is known.
+      if (decoded['ot'] !== undefined) {
+        expect(['av', 'v', 'a', 'i']).toContain(decoded['ot']);
+      }
+      // d is segment duration (ms); present when known.
+      if (decoded['d'] !== undefined) {
+        expect(decoded['d']).toBeGreaterThanOrEqual(0);
+      }
+      // br is present when bandwidth is known; may be absent for some streams.
+      if (decoded['br'] !== undefined) {
+        expect(decoded['br']).toBeDefined();
+      }
+      // st='l' for live streams, 'v' for VOD; both are valid.
+      if (decoded['st'] !== undefined) {
+        expect(['v', 'l']).toContain(decoded['st']);
+      }
+    });
+
+    it('nor is a valid string or string-list when present in segment reports',
+        async () => {
+          await player.load(TEST_STREAM);
+          await video.play();
+          await waiter.waitForMovementOrFailOnTimeout(video, 10);
+          // Clear pre-play reports; wait for fresh post-play reports.
+          recorder.clear();
+          const reports = await recorder.waitForSegments({count: 2});
+          // nor appears only when shaka knows the next segment URL. Not
+          // all streams or buffer states guarantee it. Validate when
+          // present. In v2, nor is a STRING_LIST inner list → decoded as
+          // array of strings. In v1, nor is a plain string. Accept both.
+          for (const r of reports) {
+            const decoded = decodeCmcdFromReport(r);
+            if (decoded['nor'] !== undefined) {
+              if (Array.isArray(decoded['nor'])) {
+                // v2 STRING_LIST form: each element should be a string
+                for (const item of decoded['nor']) {
+                  expect(typeof item)
+                      .withContext('nor array element should be a string')
+                      .toBe('string');
+                }
+              } else {
+                expect(typeof decoded['nor'])
+                    .withContext('nor should be a string when present')
+                    .toBe('string');
+              }
+            }
+          }
+          // The test passes regardless of whether nor was emitted; its presence
+          // and value correctness (when emitted) are what we validate here.
+          expect(true).toBe(true);
+        });
+
+    it('reflects state transitions (sta=p after playback)', async () => {
+      await player.load(TEST_STREAM);
+      await video.play();
+      await waiter.waitForMovementOrFailOnTimeout(video, 10);
+      // After movement, the 'playing' event has fired and reporter has sta=p.
+      // Clear buffering-phase reports and capture new ones during playback.
+      recorder.clear();
+      const reports = await recorder.waitForSegments({count: 2});
+      const staValues = reports.map((r) => decodeCmcdFromReport(r)['sta']);
+      const staFound = reports.some((r) => {
+        const decoded = decodeCmcdFromReport(r);
+        return decoded['sta'] === 'p';
+      });
+      expect(staFound)
+          .withContext(
+              'Expected at least one segment report to have sta=p after play.' +
+              ' Got sta values: ' + JSON.stringify(staValues))
+          .toBe(true);
+    });
+
+    it('includes throughput data after playback', async () => {
+      // Shaka emits rtp (requested max throughput) for segment requests when
+      // the buffer is not full. mtp (measured throughput) is included in
+      // reporter state when getBandwidthEstimate() > 0 after at least one
+      // completed segment download.
+      await player.load(TEST_STREAM);
+      await video.play();
+      await waiter.waitForMovementOrFailOnTimeout(video, 10);
+      // Clear pre-play reports; wait for fresh reports from active playback.
+      recorder.clear();
+      const reports = await recorder.waitForSegments({count: 2});
+      // At least one of mtp (measured) or rtp (requested) should be present.
+      const throughputFound = reports.some((r) => {
+        const decoded = decodeCmcdFromReport(r);
+        return decoded['mtp'] !== undefined || decoded['rtp'] !== undefined;
+      });
+      expect(throughputFound)
+          .withContext(
+              'Expected at least one segment report to include mtp or rtp')
+          .toBe(true);
+    });
+  });
+
+  // ---------------------------------------------------------------------------
+  // Group 2: Header Mode v2
+  // ---------------------------------------------------------------------------
+
+  describe('Header Mode v2', () => {
+    beforeEach(() => {
+      player.configure({
+        cmcd: {
+          enabled: true,
+          version: 2,
+          useHeaders: true,
+          sessionId: SESSION_ID,
+          contentId: CONTENT_ID,
+        },
+      });
+      attachRecorder({waitTimeout: REQUEST_TIMEOUT});
+    });
+
+    it('sends headers not query params', async () => {
+      await player.load(TEST_STREAM);
+      const reports = await recorder.waitForManifest();
+      const report = reports[0];
+      expect(report.reportingMode).toBe(cml.cmcd.CmcdRecordedReportMode.HEADER);
+      expect(report.request.url).not.toContain('CMCD=');
+      const decoded = decodeCmcdFromReport(report);
+      expect(decoded['ot']).toBe('m');
+      // sf='h' for HLS, 'd' for DASH.
+      expect(['h', 'd']).toContain(decoded['sf']);
+      expect(decoded['sid']).toBe(SESSION_ID);
+      expect(decoded['v']).toBe(2);
+    });
+
+    it('header mode contains correct v2 fields', async () => {
+      await player.load(TEST_STREAM);
+      const reports = await recorder.waitForManifest();
+      const decoded = decodeCmcdFromReport(reports[0]);
+      expect(decoded['sid']).toBe(SESSION_ID);
+      expect(decoded['cid']).toBe(CONTENT_ID);
+      expect(decoded['v']).toBe(2);
+      expect(decoded['ot']).toBe('m');
+      // sf='h' for HLS, 'd' for DASH.
+      expect(['h', 'd']).toContain(decoded['sf']);
+    });
+
+    it('places fields in correct header shards', async () => {
+      await player.load(TEST_STREAM);
+      const reports = await recorder.waitForManifest();
+      const headers = reports[0].request.headers || {};
+      // Session shard must carry sid and sf
+      const sessionShard = headers['cmcd-session'] || '';
+      expect(sessionShard).toContain('sid=');
+      expect(sessionShard).toContain('sf=');
+      // Object shard, if present, must carry ot
+      if (headers['cmcd-object']) {
+        expect(headers['cmcd-object']).toContain('ot=');
+      }
+    });
+  });
+
+  // ---------------------------------------------------------------------------
+  // Group 3: Event Mode v2
+  // ---------------------------------------------------------------------------
+
+  describe('Event Mode v2', () => {
+    it('sends play state events via POST', async () => {
+      player.configure({
+        cmcd: {
+          enabled: true,
+          version: 2,
+          sessionId: SESSION_ID,
+          contentId: CONTENT_ID,
+          eventTargets: [{
+            url: EVENT_TARGET_URL,
+            events: [cml.cmcd.CmcdEventType.PLAY_STATE],
+          }],
+        },
+      });
+      attachRecorder({
+        eventTargetUrls: [EVENT_TARGET_URL],
+        waitTimeout: REQUEST_TIMEOUT,
+      });
+
+      await player.load(TEST_STREAM);
+      await video.play();
+      await waiter.waitForMovementOrFailOnTimeout(video, 10);
+
+      const reports = await recorder.waitForEvents();
+      expect(reports.length).toBeGreaterThan(0);
+
+      const report = reports[0];
+      expect(report.request.method).toBe('POST');
+
+      // The event body is sent as a UTF-8 encoded Uint8Array. Browsers
+      // differ in how the fetch transport normalizes binary bodies:
+      // some return the decoded string, others may return undefined.
+      // Both indicate the event fired and was routed correctly.
+      const rawBody = bodyToString(report.request.body || '');
+      if (rawBody.length > 0) {
+        // Validate each line of the event body as a CMCD event dict
+        const lines = rawBody.split(/\r?\n/).filter((l) => l.trim());
+        for (const line of lines) {
+          const decoded = parseCmcdDict(line);
+          expect(decoded['v'])
+              .withContext('event line should carry v=2')
+              .toBe(2);
+          expect(decoded['e'])
+              .withContext('event line should carry e=ps')
+              .toBe('ps');
+          expect(decoded['ts'])
+              .withContext('event line should carry ts')
+              .toBeDefined();
+        }
+      }
+    });
+  });
+
+  // ---------------------------------------------------------------------------
+  // Group 4: Key Filtering
+  // ---------------------------------------------------------------------------
+
+  describe('Key Filtering', () => {
+    it('only includes specified keys', async () => {
+      player.configure({
+        cmcd: {
+          enabled: true,
+          version: 2,
+          sessionId: SESSION_ID,
+          contentId: CONTENT_ID,
+          includeKeys: ['sid', 'cid', 'ot', 'v', 'sf'],
+        },
+      });
+      attachRecorder({waitTimeout: REQUEST_TIMEOUT});
+
+      await player.load(TEST_STREAM);
+      const reports = await recorder.waitForManifest();
+      const decoded = decodeCmcdFromReport(reports[0]);
+
+      // Specified keys must be present
+      expect(decoded['sid']).toBeDefined();
+      expect(decoded['cid']).toBeDefined();
+      expect(decoded['ot']).toBeDefined();
+      expect(decoded['v']).toBeDefined();
+      expect(decoded['sf']).toBeDefined();
+
+      // Non-specified keys must be absent
+      expect(decoded['su']).toBeUndefined();
+      expect(decoded['sta']).toBeUndefined();
+      expect(decoded['mtp']).toBeUndefined();
+    });
+  });
+
+  // ---------------------------------------------------------------------------
+  // Group 5: Version Comparison
+  // ---------------------------------------------------------------------------
+
+  describe('Version Comparison', () => {
+    it('v1 omits v and sta', async () => {
+      player.configure({
+        cmcd: {
+          enabled: true,
+          sessionId: SESSION_ID,
+          contentId: CONTENT_ID,
+          // no version => defaults to 1
+        },
+      });
+      attachRecorder({waitTimeout: REQUEST_TIMEOUT});
+
+      await player.load(TEST_STREAM);
+      const reports = await recorder.waitForManifest();
+      // Skip the data-level validator here: v1 payloads won't pass v2
+      // validation rules and that's expected.
+      const decoded = decodeCmcdFromReport(reports[0]);
+      expect(decoded['v']).toBeUndefined();
+      expect(decoded['sta']).toBeUndefined();
+    });
+
+    it('v2 includes v=2', async () => {
+      player.configure({
+        cmcd: {
+          enabled: true,
+          version: 2,
+          sessionId: SESSION_ID,
+          contentId: CONTENT_ID,
+        },
+      });
+      attachRecorder({waitTimeout: REQUEST_TIMEOUT});
+
+      await player.load(TEST_STREAM);
+      const reports = await recorder.waitForManifest();
+      const decoded = decodeCmcdFromReport(reports[0]);
+      expect(decoded['v']).toBe(2);
+    });
+  });
+
+  // ---------------------------------------------------------------------------
+  // Group 6: State Transitions
+  // ---------------------------------------------------------------------------
+
+  describe('State Transitions', () => {
+    it('autoplay to segments carry sta=p after playback', async () => {
+      // createVideoElement does not set autoplay; call play() explicitly.
+      player.configure({
+        cmcd: {
+          enabled: true,
+          version: 2,
+          sessionId: SESSION_ID,
+          contentId: CONTENT_ID,
+        },
+      });
+      attachRecorder({waitTimeout: REQUEST_TIMEOUT});
+
+      await player.load(TEST_STREAM);
+      await video.play();
+      await waiter.waitForMovementOrFailOnTimeout(video, 10);
+
+      // Clear pre-play reports; wait for fresh segment reports from playback.
+      recorder.clear();
+      const reports = await recorder.waitForSegments({count: 2});
+      const staPlayFound = reports.some((r) => {
+        const decoded = decodeCmcdFromReport(r);
+        return decoded['sta'] === 'p';
+      });
+      expect(staPlayFound)
+          .withContext(
+              'Expected at least one segment report to have sta=p ' +
+              'after play() and movement')
+          .toBe(true);
+    });
+
+    it('no play call means no segment has sta=p', async () => {
+      // Disable autoplay so no segments are fetched without play().
+      video.autoplay = false;
+      player.configure({
+        cmcd: {
+          enabled: true,
+          version: 2,
+          sessionId: SESSION_ID,
+          contentId: CONTENT_ID,
+        },
+      });
+      attachRecorder({waitTimeout: REQUEST_TIMEOUT});
+
+      await player.load(TEST_STREAM);
+      // Wait for the manifest only; shaka will not fetch segments without play.
+      await recorder.waitForManifest();
+
+      // Confirm no segment has sta=p in anything captured so far.
+      // (Manifest requests may carry sta=r which is expected; only check
+      // segments.)
+      const allReports = recorder.getReports();
+      const staPlayFound = allReports
+          .filter((r) => r.type === cml.cmcd.CMCD_RECORDED_REQUEST_TYPE_SEGMENT)
+          .some((r) => {
+            const decoded = decodeCmcdFromReport(r);
+            return decoded['sta'] === 'p';
+          });
+      expect(staPlayFound)
+          .withContext(
+              'No segment should have sta=p when play() was never called')
+          .toBe(false);
+    });
+  });
+});
diff --git a/test/util/cmcd_manager_unit.js b/test/util/cmcd_manager_unit.js
index c463af78b0..fcf9b706f1 100644
--- a/test/util/cmcd_manager_unit.js
+++ b/test/util/cmcd_manager_unit.js
@@ -617,26 +617,30 @@ describe('CmcdManager', () => {
   // ── Player-state deduplication ──
 
   describe('player-state deduplication', () => {
-    it('emits a recordEvent on each unique state transition', () => {
+    it('emits an update on each unique state transition', () => {
+      // v2.4.0: adapter calls update({sta}); CmcdReporter auto-fires
+      // PLAY_STATE from update() when sta changes vs. lastEmitted.
+      // Adapter-side lastPlayerState_ short-circuits before entering
+      // the reporter.
       const player = createMockPlayer();
       const {manager} = createManager(player);
       spyOn(priv(manager)['reporter_'], 'update');
-      spyOn(priv(manager)['reporter_'], 'recordEvent');
       priv(manager)['setPlayerState_'](PlayerState.PLAYING);
       priv(manager)['setPlayerState_'](PlayerState.PAUSED);
       priv(manager)['setPlayerState_'](PlayerState.PLAYING);
-      expect(priv(manager)['reporter_'].recordEvent).toHaveBeenCalledTimes(3);
+      expect(priv(manager)['reporter_'].update).toHaveBeenCalledTimes(3);
     });
 
     it('suppresses duplicates of the same state', () => {
+      // Adapter-side lastPlayerState_ dedup short-circuits before
+      // entering the reporter; reporter's own dedup is a backstop.
       const player = createMockPlayer();
       const {manager} = createManager(player);
       spyOn(priv(manager)['reporter_'], 'update');
-      spyOn(priv(manager)['reporter_'], 'recordEvent');
       priv(manager)['setPlayerState_'](PlayerState.PLAYING);
       priv(manager)['setPlayerState_'](PlayerState.PLAYING);
       priv(manager)['setPlayerState_'](PlayerState.PLAYING);
-      expect(priv(manager)['reporter_'].recordEvent).toHaveBeenCalledTimes(1);
+      expect(priv(manager)['reporter_'].update).toHaveBeenCalledTimes(1);
     });
 
     it('updates with sta wire key on transition', () => {
@@ -670,13 +674,12 @@ describe('CmcdManager', () => {
     });
 
     it('translates pause → PAUSED player-state', () => {
+      // v2.4.0: adapter calls update({sta}); reporter auto-fires
+      // PLAY_STATE from update.
       spyOn(priv(manager)['reporter_'], 'update');
-      spyOn(priv(manager)['reporter_'], 'recordEvent');
       video.dispatchEvent(new shaka.util.FakeEvent('pause'));
       expect(priv(manager)['reporter_'].update).toHaveBeenCalledWith(
           {sta: PlayerState.PAUSED});
-      expect(priv(manager)['reporter_'].recordEvent).toHaveBeenCalledWith(
-          EventType.PLAY_STATE);
     });
 
     it('translates seeking → SEEKING player-state', () => {
@@ -720,13 +723,12 @@ describe('CmcdManager', () => {
     });
 
     it('translates Player adaptation → BITRATE_CHANGE', () => {
+      // v2.4.0: adapter calls update({br}); reporter auto-fires
+      // BITRATE_CHANGE from update.
       spyOn(priv(manager)['reporter_'], 'update');
-      spyOn(priv(manager)['reporter_'], 'recordEvent');
       player.dispatchEvent(new shaka.util.FakeEvent('adaptation'));
       expect(priv(manager)['reporter_'].update).toHaveBeenCalledWith(
           {br: [5000]});
-      expect(priv(manager)['reporter_'].recordEvent).toHaveBeenCalledWith(
-          EventType.BITRATE_CHANGE);
     });
 
     it('translates Player error → FATAL_ERROR + ERROR', () => {
diff --git a/third_party/cml-cmcd/SUMMARY.txt b/third_party/cml-cmcd/SUMMARY.txt
index 0b04e97e5f..36cbc03f86 100644
--- a/third_party/cml-cmcd/SUMMARY.txt
+++ b/third_party/cml-cmcd/SUMMARY.txt
@@ -1,12 +1,12 @@
 cml-cmcd
-  Common Media Library CMCD encoder + reporter, v2.3.2,
+  Common Media Library CMCD encoder + reporter, v2.4.0,
   by Streaming Video Technology Alliance / Casey Occhialini et al.
   Apache 2.0 license.
   https://github.com/streaming-video-technology-alliance/common-media-library
     /tree/main/libs/cmcd
   Source npm: @svta/cml-cmcd
-  Pinned tag: cmcd-v2.3.2
-  Pinned commit: 244ecf05132ae1d1dc9cbd01479fd88f7695dbce
+  Pinned tag: cmcd-v2.4.0
+  Pinned commit: 5c4fa8d60794e2a68e9b286fb636c0eb0b217f83
 
   TRANSITIONAL: This vendored port exists because shaka-player uses Closure
   Compiler. When shaka migrates to TypeScript (issue #8262), delete this
@@ -16,8 +16,13 @@ cml-cmcd
   Local mods:
     - TypeScript source converted to Closure-annotated JS by hand
     - Type-only imports erased; replaced with local closure typedefs
-    - Decoders (decodeCmcd, fromCmcd*) omitted: shaka emits CMCD only
-    - Validators (validateCmcd*) omitted: tooling-only utilities
+    - Decoders (decodeCmcd, fromCmcd*) omitted: shaka emits CMCD only.
+      The wire-format validators that would depend on these
+      (validateCmcdHeaders/Events/Request/EventReport) are also
+      omitted; the integration test does inline CMCD parsing instead.
+    - Data-level validators (validateCmcdKeys/Values/Structure +
+      composite validateCmcd) vendored at v2.4.0 as test-only — see
+      "Test-only additions" below.
     - Predicates (`is_cmcd_*_key.js`, `is_token_field.js`,
       `is_valid.js`) included: required at runtime by `prepareCmcdData`
       even though spec § "Excluded > Predicates" had marked them
@@ -56,3 +61,51 @@ cml-cmcd
       `start()`; replacing with `shaka.util.Timer` would break the
       verbatim-port property and the per-bump diff stability, so the
       conformance allowlist is extended for this single file.
+
+  Test-only additions (vendored at v2.4.0):
+    - Files live in `test/test/util/cml-cmcd/`, not here. They use
+      the `cml.cmcd.*` namespace via `goog.provide` and are loaded
+      by karma via the existing `test/**/*.js` pattern; absent from
+      `shaka-player.compiled.js`.
+    - Why under `test/`: `build/check.py` rejects any .js file under
+      `third_party/` that is not in `build/types/core`. Adding these
+      to `build/types/core` would put them through the ADVANCED
+      production compile (which rejects them for unrelated reasons:
+      `setTimeout` conformance whitelist, strict-inexistent-property
+      warnings on `Object<string,*>` accesses, etc.). Living under
+      `test/` avoids both constraints.
+    - ESLint override in `eslint.config.mjs` exempts these files from
+      shaka style rules (function expressions, 2-space indent,
+      `.prototype` patching, etc.) so they stay verbatim ports of
+      upstream TS.
+    - Used by `test/util/cmcd_integration.js` to drive a real
+      `shaka.Player` against a local HLS stream + capture CMCD
+      wire output + validate decoded data against the CMCD spec.
+
+    Recorder + transport adapters (port of v2.4.0 additions):
+      - `cmcd_report_recorder.js` (the recorder class)
+      - `cmcd_recorded_report.js`, `cmcd_recorded_report_mode.js`,
+        `cmcd_recorded_request_type.js` (typedefs / enums)
+      - `cmcd_report_recorder_options.js`,
+        `cmcd_report_recorder_wait_options.js` (typedefs)
+      - `cmcd_transport_adapter.js` (typedef for the adapter contract
+        + `CmcdRequestDeliver` callback)
+      - `create_fetch_transport.js` (patches `globalThis.fetch`)
+      - `create_xhr_transport.js` (patches `XMLHttpRequest.prototype`)
+
+    Data-level validators (work on pre-decoded data):
+      - `validate_cmcd.js` (composite)
+      - `validate_cmcd_keys.js`, `validate_cmcd_values.js`,
+        `validate_cmcd_structure.js` (parts)
+      - `merge_validation_results.js` (helper)
+      - `cmcd_validation_severity.js`, `cmcd_validation_issue.js`,
+        `cmcd_validation_options.js`, `cmcd_validation_result.js`,
+        `cmcd_data_validation_result.js`,
+        `cmcd_events_validation_result.js` (typedefs)
+
+    Deliberately NOT vendored (would require porting upstream's
+    SFV decoder grammar, ~800 LoC of @svta/cml-structured-field-values):
+      - `decodeCmcd`, `fromCmcdHeaders`, `fromCmcdQuery`, `fromCmcdUrl`
+      - `validateCmcdHeaders`, `validateCmcdEvents`,
+        `validateCmcdRequest`, `validateCmcdEventReport`
+    The integration test does inline CMCD parsing instead.
diff --git a/third_party/cml-cmcd/cmcd_event_type.js b/third_party/cml-cmcd/cmcd_event_type.js
index af674420ab..a7cdeb6a48 100644
--- a/third_party/cml-cmcd/cmcd_event_type.js
+++ b/third_party/cml-cmcd/cmcd_event_type.js
@@ -13,6 +13,7 @@ goog.provide('cml.cmcd.CMCD_EVENT_CONTENT_ID');
 goog.provide('cml.cmcd.CMCD_EVENT_CUSTOM_EVENT');
 goog.provide('cml.cmcd.CMCD_EVENT_ERROR');
 goog.provide('cml.cmcd.CMCD_EVENT_MUTE');
+goog.provide('cml.cmcd.CMCD_EVENT_PLAYBACK_RATE');
 goog.provide('cml.cmcd.CMCD_EVENT_PLAYER_COLLAPSE');
 goog.provide('cml.cmcd.CMCD_EVENT_PLAYER_EXPAND');
 goog.provide('cml.cmcd.CMCD_EVENT_PLAY_STATE');
@@ -37,6 +38,13 @@ cml.cmcd.CMCD_EVENT_BITRATE_CHANGE = 'bc';
  */
 cml.cmcd.CMCD_EVENT_PLAY_STATE = 'ps';
 
+/**
+ * CMCD event type for the 'pr' key (playback rate change).
+ *
+ * @const {string}
+ */
+cml.cmcd.CMCD_EVENT_PLAYBACK_RATE = 'pr';
+
 /**
  * CMCD event type for the 'e' key (error).
  *
@@ -161,6 +169,11 @@ cml.cmcd.CmcdEventType = {
    */
   PLAY_STATE: cml.cmcd.CMCD_EVENT_PLAY_STATE,
 
+  /**
+   * A change in the playback rate.
+   */
+  PLAYBACK_RATE: cml.cmcd.CMCD_EVENT_PLAYBACK_RATE,
+
   /**
    * An error event.
    */
diff --git a/third_party/cml-cmcd/cmcd_reporter.js b/third_party/cml-cmcd/cmcd_reporter.js
index 398e3a1e83..e00685d45d 100644
--- a/third_party/cml-cmcd/cmcd_reporter.js
+++ b/third_party/cml-cmcd/cmcd_reporter.js
@@ -14,6 +14,7 @@ goog.require('cml.cmcd.CMCD_MIME_TYPE');
 goog.require('cml.cmcd.CMCD_PARAM');
 goog.require('cml.cmcd.CMCD_QUERY');
 goog.require('cml.cmcd.CMCD_REQUEST_MODE');
+goog.require('cml.cmcd.CMCD_STATE_EVENT_FIELDS');
 goog.require('cml.cmcd.CMCD_V2');
 goog.require('cml.cmcd.CmcdEventType');
 goog.require('cml.cmcd.encodeCmcd');
@@ -24,6 +25,7 @@ goog.require('cml.cmcd.uuid');
 goog.requireType('cml.cmcd.Cmcd');
 goog.requireType('cml.cmcd.CmcdEncodeOptions');
 goog.requireType('cml.cmcd.CmcdEventReportConfig');
+goog.requireType('cml.cmcd.CmcdObjectTypeList');
 goog.requireType('cml.cmcd.CmcdReportConfig');
 goog.requireType('cml.cmcd.CmcdReporterConfig');
 goog.requireType('cml.cmcd.CmcdRequestReport');
@@ -130,6 +132,133 @@ cml.cmcd.CmcdReporter_createCmcdReporterConfig_ = function(config) {
 };
 
 
+/**
+ * Deep equality for CmcdObjectTypeList (used for `br` dedup).
+ *
+ * Order-sensitive: arrays with the same elements in different positions
+ * are treated as different. Players that construct `br` consistently
+ * get correct dedup; shuffling produces spurious emits, which is the
+ * safer failure mode.
+ *
+ * @param {!cml.cmcd.CmcdObjectTypeList} a
+ * @param {!cml.cmcd.CmcdObjectTypeList} b
+ * @return {boolean}
+ * @private
+ */
+cml.cmcd.CmcdReporter_cmcdObjectTypeListEqual_ = function(a, b) {
+  if (a === b) return true;
+  if (a.length !== b.length) return false;
+
+  for (let i = 0; i < a.length; i++) {
+    const ai = a[i];
+    const bi = b[i];
+    if (ai === bi) continue;
+    if (typeof ai === 'number' || typeof bi === 'number') return false;
+
+    // Both are SfItem<number, ExclusiveRecord<CmcdObjectType, boolean>>
+    const ais = /** @type {!Object<string, *>} */ (ai);
+    const bis = /** @type {!Object<string, *>} */ (bi);
+    if (ais['value'] !== bis['value']) return false;
+
+    const ap = /** @type {(Object<string, *>|null|undefined)} */ (
+        ais['params']);
+    const bp = /** @type {(Object<string, *>|null|undefined)} */ (
+        bis['params']);
+    const ak = ap && Object.keys(ap)[0];
+    const bk = bp && Object.keys(bp)[0];
+    if (ak !== bk) return false;
+    if (ak && bk && ap && bp && ap[/** @type {string} */ (ak)] !==
+        bp[/** @type {string} */ (bk)]) {
+      return false;
+    }
+  }
+
+  return true;
+};
+
+
+/**
+ * One row in the STATE_FIELDS_ dispatch table.
+ *
+ * `snapshot` captures the value stored in `lastEmitted_` for dedup
+ * comparisons. Reference types must clone so the baseline doesn't
+ * share a reference with the caller's input, which would let in-place
+ * mutation silently poison the dedup state.
+ *
+ * @typedef {{
+ *   field: string,
+ *   event: string,
+ *   equal: function(*, *): boolean,
+ *   snapshot: function(*): *
+ * }}
+ * @private
+ */
+cml.cmcd.CmcdReporter_StateFieldEntry_;
+
+
+/**
+ * Identity snapshot for primitive fields.
+ *
+ * @param {*} v
+ * @return {*}
+ * @private
+ */
+cml.cmcd.CmcdReporter_identity_ = function(v) {
+  return v;
+};
+
+
+/**
+ * Maps each tracked state field to its event type and equality
+ * function. Order matters: `update()` fires events in this order for
+ * multi-field updates.
+ *
+ * @const {!Array<!cml.cmcd.CmcdReporter_StateFieldEntry_>}
+ * @private
+ */
+cml.cmcd.CmcdReporter_STATE_FIELDS_ = (function() {
+  /** @type {!Array<!cml.cmcd.CmcdReporter_StateFieldEntry_>} */
+  const entries = [];
+  cml.cmcd.CMCD_STATE_EVENT_FIELDS.forEach((field, event) => {
+    if (field === 'br') {
+      entries.push({
+        event: event,
+        field: field,
+        equal: (a, b) => (a === undefined || b === undefined) ?
+            a === b :
+            cml.cmcd.CmcdReporter_cmcdObjectTypeListEqual_(
+                /** @type {!cml.cmcd.CmcdObjectTypeList} */ (a),
+                /** @type {!cml.cmcd.CmcdObjectTypeList} */ (b)),
+        snapshot: (v) =>
+          /** @type {!cml.cmcd.CmcdObjectTypeList} */ (v).slice(),
+      });
+    } else {
+      entries.push({
+        event: event,
+        field: field,
+        equal: Object.is,
+        snapshot: cml.cmcd.CmcdReporter_identity_,
+      });
+    }
+  });
+  return entries;
+})();
+
+
+/**
+ * @const {!Map<string, !cml.cmcd.CmcdReporter_StateFieldEntry_>}
+ * @private
+ */
+cml.cmcd.CmcdReporter_STATE_FIELDS_BY_EVENT_ = (function() {
+  /** @type {!Map<string, !cml.cmcd.CmcdReporter_StateFieldEntry_>} */
+  const map = new Map();
+  for (const entry of cml.cmcd.CmcdReporter_STATE_FIELDS_) {
+    map.set(entry.event, entry);
+  }
+  return map;
+})();
+
+
 /**
  * The CMCD reporter.
  *
@@ -177,6 +306,15 @@ cml.cmcd.CmcdReporter = class {
     /** @private {function(!Object): !Promise<{status: number}>} */
     this.requester_ = requester;
 
+    /**
+     * Last value emitted on the wire for each tracked state field.
+     * Used by update() to dedup state-change events and by
+     * recordEvent() to suppress no-transition events.
+     *
+     * @private {!Object<string, *>}
+     */
+    this.lastEmitted_ = {};
+
     this.data_ = /** @type {!cml.cmcd.Cmcd} */ ({
       cid: this.config_.cid,
       sid: this.config_.sid,
@@ -253,7 +391,22 @@ cml.cmcd.CmcdReporter = class {
   }
 
   /**
-   * Updates the CMCD data. Called by the player when the data changes.
+   * Updates the CMCD data.
+   *
+   * Called by the player when data changes. For tracked state fields
+   * (`sta`, `pr`, `cid`, `bg`, `br`), if the new value differs from
+   * the last-reported value (the value most recently emitted on the
+   * wire for that field), the corresponding state-change event is
+   * automatically fired. Comparing against the last-reported value
+   * (rather than the previous persisted value) ensures the first
+   * state-change event in a new session always emits, even when the
+   * persisted value didn't change across the `sid` boundary.
+   *
+   * Multi-field updates fire multiple events in the order:
+   * `sta` → `pr` → `cid` → `bg` → `br`. The order of keys in the
+   * input object does not affect the firing order.
+   *
+   * A `sid` change resets the dedup baseline.
    *
    * @param {!cml.cmcd.Cmcd} data The data to update.
    */
@@ -271,18 +424,78 @@ cml.cmcd.CmcdReporter = class {
     // update.
     this.data_ = /** @type {!cml.cmcd.Cmcd} */ (
         Object.assign({}, this.data_, data, {msd: undefined}));
+
+    // Auto-trigger state-change events for any tracked field whose
+    // value differs from the last wire-emitted value. Comparing
+    // against lastEmitted_ (not the pre-merge value) ensures
+    // correctness after a session reset, and unifies the comparison
+    // basis with recordEvent's internal dedup.
+    for (const entry of cml.cmcd.CmcdReporter_STATE_FIELDS_) {
+      if (entry.field in data &&
+          !entry.equal(this.data_[entry.field],
+                       this.lastEmitted_[entry.field])) {
+        this.recordEvent(entry.event);
+      }
+    }
   }
 
   /**
    * Records an event. Called by the player when an event occurs.
    *
+   * For state-change events (`PLAY_STATE`, `PLAYBACK_RATE`,
+   * `CONTENT_ID`, `BACKGROUNDED_MODE`, `BITRATE_CHANGE`), this method:
+   *   1. Persists the dedup field from `data` (if present) into the
+   *      reporter's persistent data store — equivalent to a
+   *      write-through `update()`.
+   *   2. Drops the event entirely if the dedup field has no value
+   *      after the write-through. State-change events without their
+   *      required field would violate CTA-5004-B.
+   *   3. Suppresses the event if the field's current value matches
+   *      the last-emitted value (no state transition).
+   *
+   * For all other event types, the event is always emitted.
+   *
+   * Most callers can rely on {@link CmcdReporter#update} to auto-fire
+   * state-change events. Use `recordEvent` directly when you need to
+   * attach extra context to the event report (e.g., `bl`, `pt` at the
+   * moment of a play-state transition).
+   *
    * @param {string} type The type of event to record.
    * @param {!cml.cmcd.Cmcd=} data Additional data to record with the
-   *   event. This data only applies to this event report. Persistent
-   *   data should be updated using `update()`.
+   *   event. This data only applies to this event report, except for
+   *   the dedup field of a state-change event, which is also
+   *   persisted into the reporter's data store.
    */
   recordEvent(type, data) {
     const eventData = data || /** @type {!cml.cmcd.Cmcd} */ ({});
+
+    const entry = cml.cmcd.CmcdReporter_STATE_FIELDS_BY_EVENT_.get(
+        /** @type {string} */ (type));
+    if (entry) {
+      const field = entry.field;
+      const incoming = eventData[field];
+
+      if (incoming !== undefined) {
+        this.data_[field] = incoming;
+      }
+
+      const current = this.data_[field];
+
+      // Never emit a state-change event with a missing required
+      // field — per CTA-5004-B these events must carry their dedup
+      // field. Catches both "no value ever set" and "previous value
+      // was cleared to undefined".
+      if (current === undefined) {
+        return;
+      }
+
+      if (entry.equal(current, this.lastEmitted_[field])) {
+        return;
+      }
+
+      this.lastEmitted_[field] = entry.snapshot(current);
+    }
+
     this.eventTargets_.forEach((target, config) => {
       this.recordTargetEvent_(target, config, type, eventData);
     });
@@ -615,5 +828,6 @@ cml.cmcd.CmcdReporter = class {
       target.sn = 0;
     });
     this.requestTarget_.sn = 0;
+    this.lastEmitted_ = {};
   }
 };
diff --git a/third_party/cml-cmcd/cmcd_state_event_fields.js b/third_party/cml-cmcd/cmcd_state_event_fields.js
new file mode 100644
index 0000000000..49ad6d4613
--- /dev/null
+++ b/third_party/cml-cmcd/cmcd_state_event_fields.js
@@ -0,0 +1,38 @@
+/*! @license
+ * Copyright 2024 Streaming Video Technology Alliance
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('cml.cmcd.CMCD_STATE_EVENT_FIELDS');
+
+goog.require('cml.cmcd.CMCD_EVENT_BACKGROUNDED_MODE');
+goog.require('cml.cmcd.CMCD_EVENT_BITRATE_CHANGE');
+goog.require('cml.cmcd.CMCD_EVENT_CONTENT_ID');
+goog.require('cml.cmcd.CMCD_EVENT_PLAY_STATE');
+goog.require('cml.cmcd.CMCD_EVENT_PLAYBACK_RATE');
+
+
+/**
+ * Maps each state-change event type to the persistent field whose
+ * value the event signals.
+ *
+ * Per CTA-5004-B, the state-change events `ps`, `pr`, `c`, `b`, `bc`
+ * are state-transition markers and must carry the field whose value
+ * they signal. Consumers force-include the field post-filter
+ * (`prepareCmcdData`), dedup against its value (`CmcdReporter`), and
+ * check its presence in payloads (`validateCmcdStructure`).
+ *
+ * Iteration order is load-bearing: `CmcdReporter.update()` fires
+ * state-change events in map order when multiple tracked fields
+ * change in a single call. Do not reorder entries without auditing
+ * reporter behavior.
+ *
+ * @const {!Map<string, string>}
+ */
+cml.cmcd.CMCD_STATE_EVENT_FIELDS = new Map([
+  [cml.cmcd.CMCD_EVENT_PLAY_STATE, 'sta'],
+  [cml.cmcd.CMCD_EVENT_PLAYBACK_RATE, 'pr'],
+  [cml.cmcd.CMCD_EVENT_CONTENT_ID, 'cid'],
+  [cml.cmcd.CMCD_EVENT_BACKGROUNDED_MODE, 'bg'],
+  [cml.cmcd.CMCD_EVENT_BITRATE_CHANGE, 'br'],
+]);
diff --git a/third_party/cml-cmcd/cmcd_token_values.js b/third_party/cml-cmcd/cmcd_token_values.js
index cd95fda790..90e738901e 100644
--- a/third_party/cml-cmcd/cmcd_token_values.js
+++ b/third_party/cml-cmcd/cmcd_token_values.js
@@ -12,7 +12,7 @@ goog.provide('cml.cmcd.CMCD_TOKEN_VALUES');
  * @const {!Object<string, !Array<string>>}
  */
 cml.cmcd.CMCD_TOKEN_VALUES = {
-  e: ['bc', 'ps', 'e', 't', 'c', 'b', 'm', 'um', 'pe', 'pc', 'rr',
+  e: ['bc', 'ps', 'pr', 'e', 't', 'c', 'b', 'm', 'um', 'pe', 'pc', 'rr',
     'as', 'ae', 'abs', 'abe', 'sk', 'ce'],
   ot: ['m', 'a', 'v', 'av', 'i', 'c', 'tt', 'k', 'o'],
   sf: ['d', 'h', 's', 'o'],
diff --git a/third_party/cml-cmcd/prepare_cmcd_data.js b/third_party/cml-cmcd/prepare_cmcd_data.js
index 020fa3fb55..af63e4d1d1 100644
--- a/third_party/cml-cmcd/prepare_cmcd_data.js
+++ b/third_party/cml-cmcd/prepare_cmcd_data.js
@@ -5,12 +5,15 @@
 
 goog.provide('cml.cmcd.prepareCmcdData');
 
+goog.require('cml.cmcd.CMCD_EVENT_BACKGROUNDED_MODE');
 goog.require('cml.cmcd.CMCD_EVENT_CUSTOM_EVENT');
 goog.require('cml.cmcd.CMCD_EVENT_MODE');
+goog.require('cml.cmcd.CMCD_EVENT_PLAYBACK_RATE');
 goog.require('cml.cmcd.CMCD_EVENT_RESPONSE_RECEIVED');
 goog.require('cml.cmcd.CMCD_FORMATTER_MAP');
 goog.require('cml.cmcd.CMCD_INNER_LIST_KEYS');
 goog.require('cml.cmcd.CMCD_REQUEST_MODE');
+goog.require('cml.cmcd.CMCD_STATE_EVENT_FIELDS');
 goog.require('cml.cmcd.CMCD_V2');
 goog.require('cml.cmcd.Cmcd');
 goog.require('cml.cmcd.CmcdEncodeOptions');
@@ -174,6 +177,15 @@ cml.cmcd.prepareCmcdData = function(obj, options) {
         eventType === cml.cmcd.CMCD_EVENT_CUSTOM_EVENT) {
       keys.push('cen');
     }
+
+    const requiredField = eventType ?
+        cml.cmcd.CMCD_STATE_EVENT_FIELDS.get(
+            /** @type {string} */ (eventType)) :
+        undefined;
+    if (requiredField && data[requiredField] != null &&
+        !keys.includes(requiredField)) {
+      keys.push(requiredField);
+    }
   }
 
   if (keys.length === 0) {
@@ -211,8 +223,11 @@ cml.cmcd.prepareCmcdData = function(obj, options) {
       }
     }
 
-    // Playback rate should only be sent if not equal to 1.
-    if (key === 'pr' && value === 1) {
+    // Playback rate should only be sent if not equal to 1, except as
+    // the value of a PLAYBACK_RATE state-change event (where pr=1 is
+    // the data being reported, not a default to skip).
+    if (key === 'pr' && value === 1 &&
+        !(isEventMode && data['e'] === cml.cmcd.CMCD_EVENT_PLAYBACK_RATE)) {
       continue;
     }
 
@@ -221,8 +236,15 @@ cml.cmcd.prepareCmcdData = function(obj, options) {
       value = Date.now();
     }
 
-    // ignore invalid values
-    if (!cml.cmcd.isValid(value)) {
+    // Ignore invalid values, except `bg: false` on a backgrounded-mode
+    // (e=b) state-change event — the wire must carry `?0` per
+    // CTA-5004-B so the transition is reportable. `bg` is the only
+    // state-change required field typed as boolean.
+    const isBgFalseTransition = isEventMode &&
+        value === false &&
+        key === 'bg' &&
+        data['e'] === cml.cmcd.CMCD_EVENT_BACKGROUNDED_MODE;
+    if (!cml.cmcd.isValid(value) && !isBgFalseTransition) {
       continue;
     }
 

From 7aefbd68281f0f6eb1c526e81a21f9b6142971ca Mon Sep 17 00:00:00 2001
From: Casey Occhialini <1508707+littlespex@users.noreply.github.com>
Date: Fri, 29 May 2026 10:55:41 -0700
Subject: [PATCH 64/64] chore: lint fix

---
 karma.conf.js                                 |  3 +-
 .../cml-cmcd/cmcd_data_validation_result.js   |  2 -
 .../cml-cmcd/cmcd_events_validation_result.js |  2 -
 .../util/cml-cmcd/cmcd_report_recorder.js     | 49 ++++++++++++++-----
 .../util/cml-cmcd/cmcd_validation_issue.js    |  2 -
 .../util/cml-cmcd/cmcd_validation_options.js  |  4 +-
 .../util/cml-cmcd/create_fetch_transport.js   |  3 +-
 .../util/cml-cmcd/create_xhr_transport.js     |  4 +-
 .../util/cml-cmcd/validate_cmcd_structure.js  |  1 -
 .../util/cml-cmcd/validate_cmcd_values.js     |  3 +-
 test/util/cmcd_integration.js                 | 27 +++++-----
 test/util/cmcd_manager_unit.js                |  5 +-
 12 files changed, 64 insertions(+), 41 deletions(-)

diff --git a/karma.conf.js b/karma.conf.js
index 51ea8415fd..cfcfa5ea82 100644
--- a/karma.conf.js
+++ b/karma.conf.js
@@ -238,7 +238,8 @@ module.exports = (config) => {
       // CMCD_KEYS (cmcd_keys.js) is not required by the main library. Load it
       // explicitly here, before the cml-cmcd test utilities, so the Sets are
       // built correctly. Its transitive deps (CMCD_V1_KEYS, CMCD_REQUEST_KEYS,
-      // CMCD_RESPONSE_KEYS, CMCD_EVENT_KEYS) are already loaded by cmcd_manager.
+      // CMCD_RESPONSE_KEYS, CMCD_EVENT_KEYS) are already loaded by
+      // cmcd_manager.
       'third_party/cml-cmcd/cmcd_keys.js',
 
       // cml-cmcd test-only helpers (CmcdReportRecorder, validateCmcd, etc.)
diff --git a/test/test/util/cml-cmcd/cmcd_data_validation_result.js b/test/test/util/cml-cmcd/cmcd_data_validation_result.js
index 90a636c59a..6118fca9f0 100644
--- a/test/test/util/cml-cmcd/cmcd_data_validation_result.js
+++ b/test/test/util/cml-cmcd/cmcd_data_validation_result.js
@@ -5,9 +5,7 @@
 
 goog.provide('cml.cmcd.CmcdDataValidationResult');
 
-goog.requireType('cml.cmcd.CmcdData');
 goog.requireType('cml.cmcd.CmcdValidationIssue');
-goog.requireType('cml.cmcd.CmcdValidationResult');
 
 
 /**
diff --git a/test/test/util/cml-cmcd/cmcd_events_validation_result.js b/test/test/util/cml-cmcd/cmcd_events_validation_result.js
index 564093fcf7..87cdd5d74b 100644
--- a/test/test/util/cml-cmcd/cmcd_events_validation_result.js
+++ b/test/test/util/cml-cmcd/cmcd_events_validation_result.js
@@ -5,9 +5,7 @@
 
 goog.provide('cml.cmcd.CmcdEventsValidationResult');
 
-goog.requireType('cml.cmcd.CmcdData');
 goog.requireType('cml.cmcd.CmcdValidationIssue');
-goog.requireType('cml.cmcd.CmcdValidationResult');
 
 
 /**
diff --git a/test/test/util/cml-cmcd/cmcd_report_recorder.js b/test/test/util/cml-cmcd/cmcd_report_recorder.js
index f21723af29..8405c7ce26 100644
--- a/test/test/util/cml-cmcd/cmcd_report_recorder.js
+++ b/test/test/util/cml-cmcd/cmcd_report_recorder.js
@@ -18,7 +18,18 @@ goog.require('cml.cmcd.createXhrTransport');
 goog.requireType('cml.cmcd.CmcdRecordedReport');
 goog.requireType('cml.cmcd.CmcdReportRecorderOptions');
 goog.requireType('cml.cmcd.CmcdReportRecorderWaitOptions');
-goog.requireType('cml.cmcd.CmcdTransportAdapter');
+
+
+/**
+ * @typedef {{
+ *   type: (string|undefined),
+ *   count: number,
+ *   resolve: function(!Array<!cml.cmcd.CmcdRecordedReport>),
+ *   reject: function(*)
+ * }}
+ * @private
+ */
+cml.cmcd.CmcdReportRecorderInternalWaiter_;
 
 
 /** @const {!RegExp} @private */
@@ -104,7 +115,7 @@ cml.cmcd.CmcdReportRecorder = class {
     this.attached_ = false;
     /** @private {!Array<string>} */
     this.eventTargetUrls_ = [];
-    /** @private {!Map<number, !Object>} */
+    /** @private {!Map<number, !cml.cmcd.CmcdReportRecorderInternalWaiter_>} */
     this.waiters_ = new Map();
     /** @private {?function(!cml.cmcd.CmcdRecordedReport):void} */
     this.onReport_ = null;
@@ -161,14 +172,14 @@ cml.cmcd.CmcdReportRecorder = class {
 
   /** @private */
   notifyWaiters_() {
-    for (const [timer, waiter] of this.waiters_) {
+    this.waiters_.forEach((waiter, timer) => {
       const matching = this.getMatching_(waiter.type);
       if (matching.length >= waiter.count) {
         clearTimeout(timer);
         this.waiters_.delete(timer);
         waiter.resolve(matching);
       }
-    }
+    });
   }
 
   /**
@@ -189,14 +200,14 @@ cml.cmcd.CmcdReportRecorder = class {
     }
 
     return new Promise((resolve, reject) => {
-      const timer = setTimeout(() => {
+      const timer = /** @type {number} */ (setTimeout(() => {
         this.waiters_.delete(timer);
         const current = this.getMatching_(type);
         reject(new Error(
             'Timeout waiting for ' + count + ' ' + (type || 'any') +
             ' CMCD report(s). Got ' + current.length +
             '. Total recorded: ' + this.reports_.length + '.'));
-      }, timeout);
+      }, timeout));
 
       this.waiters_.set(timer, {type, count, resolve, reject});
     });
@@ -208,10 +219,12 @@ cml.cmcd.CmcdReportRecorder = class {
    *
    * @param {!cml.cmcd.CmcdReportRecorderOptions=} options
    */
-  attach(options = {}) {
+  attach(options) {
     if (this.attached_) {
       return;
     }
+    options = options ||
+        /** @type {!cml.cmcd.CmcdReportRecorderOptions} */ ({});
     this.attached_ = true;
     this.eventTargetUrls_ = options.eventTargetUrls ?
         options.eventTargetUrls.slice() :
@@ -244,10 +257,12 @@ cml.cmcd.CmcdReportRecorder = class {
     this.eventTargetUrls_ = [];
     this.onReport_ = null;
 
-    for (const [timer, waiter] of this.waiters_) {
-      clearTimeout(timer);
+    for (const waiter of this.waiters_.values()) {
       waiter.reject(new Error('Recorder detached while waiting'));
     }
+    for (const timer of this.waiters_.keys()) {
+      clearTimeout(timer);
+    }
     this.waiters_.clear();
   }
 
@@ -269,7 +284,9 @@ cml.cmcd.CmcdReportRecorder = class {
    * @param {!cml.cmcd.CmcdReportRecorderWaitOptions=} options
    * @return {!Promise<!Array<!cml.cmcd.CmcdRecordedReport>>}
    */
-  waitForReports(options = {}) {
+  waitForReports(options) {
+    options = options ||
+        /** @type {!cml.cmcd.CmcdReportRecorderWaitOptions} */ ({});
     return this.waitFor_(undefined, options);
   }
 
@@ -277,7 +294,9 @@ cml.cmcd.CmcdReportRecorder = class {
    * @param {!cml.cmcd.CmcdReportRecorderWaitOptions=} options
    * @return {!Promise<!Array<!cml.cmcd.CmcdRecordedReport>>}
    */
-  waitForManifest(options = {}) {
+  waitForManifest(options) {
+    options = options ||
+        /** @type {!cml.cmcd.CmcdReportRecorderWaitOptions} */ ({});
     return this.waitFor_(
         cml.cmcd.CMCD_RECORDED_REQUEST_TYPE_MANIFEST, options);
   }
@@ -286,7 +305,9 @@ cml.cmcd.CmcdReportRecorder = class {
    * @param {!cml.cmcd.CmcdReportRecorderWaitOptions=} options
    * @return {!Promise<!Array<!cml.cmcd.CmcdRecordedReport>>}
    */
-  waitForSegments(options = {}) {
+  waitForSegments(options) {
+    options = options ||
+        /** @type {!cml.cmcd.CmcdReportRecorderWaitOptions} */ ({});
     return this.waitFor_(
         cml.cmcd.CMCD_RECORDED_REQUEST_TYPE_SEGMENT, options);
   }
@@ -295,7 +316,9 @@ cml.cmcd.CmcdReportRecorder = class {
    * @param {!cml.cmcd.CmcdReportRecorderWaitOptions=} options
    * @return {!Promise<!Array<!cml.cmcd.CmcdRecordedReport>>}
    */
-  waitForEvents(options = {}) {
+  waitForEvents(options) {
+    options = options ||
+        /** @type {!cml.cmcd.CmcdReportRecorderWaitOptions} */ ({});
     return this.waitFor_(
         cml.cmcd.CMCD_RECORDED_REQUEST_TYPE_EVENT, options);
   }
diff --git a/test/test/util/cml-cmcd/cmcd_validation_issue.js b/test/test/util/cml-cmcd/cmcd_validation_issue.js
index 3245a0a1c9..8c8d5c302b 100644
--- a/test/test/util/cml-cmcd/cmcd_validation_issue.js
+++ b/test/test/util/cml-cmcd/cmcd_validation_issue.js
@@ -5,8 +5,6 @@
 
 goog.provide('cml.cmcd.CmcdValidationIssue');
 
-goog.requireType('cml.cmcd.CmcdValidationSeverity');
-
 
 /**
  * Describes a single validation issue found in a CMCD payload.
diff --git a/test/test/util/cml-cmcd/cmcd_validation_options.js b/test/test/util/cml-cmcd/cmcd_validation_options.js
index add898d148..e02b6905f5 100644
--- a/test/test/util/cml-cmcd/cmcd_validation_options.js
+++ b/test/test/util/cml-cmcd/cmcd_validation_options.js
@@ -13,8 +13,8 @@ goog.requireType('cml.cmcd.CmcdVersion');
  * Options for CMCD validation functions.
  *
  * @typedef {{
- *   version: (number|undefined),
- *   reportingMode: (string|undefined)
+ *   version: (!cml.cmcd.CmcdVersion|undefined),
+ *   reportingMode: (!cml.cmcd.CmcdReportingMode|undefined)
  * }}
  */
 cml.cmcd.CmcdValidationOptions;
diff --git a/test/test/util/cml-cmcd/create_fetch_transport.js b/test/test/util/cml-cmcd/create_fetch_transport.js
index 45c66af768..7531e816ab 100644
--- a/test/test/util/cml-cmcd/create_fetch_transport.js
+++ b/test/test/util/cml-cmcd/create_fetch_transport.js
@@ -5,7 +5,6 @@
 
 goog.provide('cml.cmcd.createFetchTransport');
 
-goog.requireType('cml.cmcd.CmcdRequestDeliver');
 goog.requireType('cml.cmcd.CmcdTransportAdapter');
 
 
@@ -26,7 +25,7 @@ cml.cmcd.createFetchTransport_toHttpRequest_ = async function(request) {
 
   /** @type {string|undefined} */
   let body;
-  if (request.body) {
+  if (request['body']) {
     try {
       body = await request.text();
     } catch (err) {
diff --git a/test/test/util/cml-cmcd/create_xhr_transport.js b/test/test/util/cml-cmcd/create_xhr_transport.js
index 4d1aa43fdd..6771cec32b 100644
--- a/test/test/util/cml-cmcd/create_xhr_transport.js
+++ b/test/test/util/cml-cmcd/create_xhr_transport.js
@@ -5,7 +5,6 @@
 
 goog.provide('cml.cmcd.createXhrTransport');
 
-goog.requireType('cml.cmcd.CmcdRequestDeliver');
 goog.requireType('cml.cmcd.CmcdTransportAdapter');
 
 
@@ -109,7 +108,8 @@ cml.cmcd.createXhrTransport = function() {
         const self = /** @type {!Object<string, *>} */ (this);
         const httpRequest = {
           url: self['_cmcdUrl'] || '',
-          method: (self['_cmcdMethod'] || 'GET').toUpperCase(),
+          method: (/** @type {string} */ (self['_cmcdMethod']) || 'GET')
+              .toUpperCase(),
           headers: self['_cmcdHeaders'] || {},
           body: (typeof Document !== 'undefined' && body instanceof Document) ?
               undefined :
diff --git a/test/test/util/cml-cmcd/validate_cmcd_structure.js b/test/test/util/cml-cmcd/validate_cmcd_structure.js
index 7b18c0fd5c..b3a6764e7b 100644
--- a/test/test/util/cml-cmcd/validate_cmcd_structure.js
+++ b/test/test/util/cml-cmcd/validate_cmcd_structure.js
@@ -17,7 +17,6 @@ goog.require('cml.cmcd.CMCD_V1');
 goog.require('cml.cmcd.CMCD_VALIDATION_SEVERITY_ERROR');
 goog.require('cml.cmcd.CMCD_VALIDATION_SEVERITY_WARNING');
 goog.require('cml.cmcd.resolveVersion');
-goog.requireType('cml.cmcd.CmcdValidationIssue');
 goog.requireType('cml.cmcd.CmcdValidationOptions');
 goog.requireType('cml.cmcd.CmcdValidationResult');
 
diff --git a/test/test/util/cml-cmcd/validate_cmcd_values.js b/test/test/util/cml-cmcd/validate_cmcd_values.js
index 70140ad969..79acf0e4ed 100644
--- a/test/test/util/cml-cmcd/validate_cmcd_values.js
+++ b/test/test/util/cml-cmcd/validate_cmcd_values.js
@@ -132,7 +132,8 @@ cml.cmcd.validateCmcdValues = function(data, options) {
   const version = cml.cmcd.resolveVersion(data, options);
   const issues = [];
 
-  for (const [key, value] of Object.entries(data)) {
+  for (const key in data) {
+    const value = data[key];
     if (cml.cmcd.isCmcdCustomKey(key)) {
       // Custom key values must be string or token, max 64 chars.
       if (typeof value !== 'string') {
diff --git a/test/util/cmcd_integration.js b/test/util/cmcd_integration.js
index 102a093dd1..ac6e02a10b 100644
--- a/test/util/cmcd_integration.js
+++ b/test/util/cmcd_integration.js
@@ -16,6 +16,7 @@
  * shaka's karma+jasmine harness.
  */
 
+/** @suppress {checkTypes|accessControls|missingProperties|undefinedVars} */
 describe('CmcdManager integration', () => {
   // Absolute URL required: CmcdReporter uses new URL(uri) internally, which
   // throws on relative paths. Karma serves at window.location.origin.
@@ -82,7 +83,7 @@ describe('CmcdManager integration', () => {
     entries.push(cmcd.slice(start));
 
     for (const entry of entries) {
-      const trimmed = entry.trim();
+      const trimmed = /** @type {string} */ (entry.trim());
       if (!trimmed) {
         continue;
       }
@@ -154,12 +155,13 @@ describe('CmcdManager integration', () => {
       return body;
     }
     if (ArrayBuffer.isView(body)) {
-      return new TextDecoder().decode(body.buffer);
+      return shaka.util.StringUtils.fromUTF8(
+          /** @type {!BufferSource} */ (body));
     }
-    // ArrayBuffer itself (not a typed-array view).
     if (body && typeof body === 'object' &&
         body.constructor && body.constructor.name === 'ArrayBuffer') {
-      return new TextDecoder().decode(/** @type {!ArrayBuffer} */ (body));
+      return shaka.util.StringUtils.fromUTF8(
+          /** @type {!BufferSource} */ (body));
     }
     return String(body || '');
   }
@@ -172,13 +174,14 @@ describe('CmcdManager integration', () => {
    */
   function decodeCmcdFromReport(report) {
     if (report.reportingMode === cml.cmcd.CmcdRecordedReportMode.QUERY) {
-      const url = new URL(report.request.url);
+      const url = new URL(/** @type {string} */ (report.request['url']));
       const cmcd = url.searchParams.get('CMCD');
       return parseCmcdDict(cmcd || '');
     }
     if (report.reportingMode === cml.cmcd.CmcdRecordedReportMode.HEADER) {
       const merged = {};
-      for (const [k, v] of Object.entries(report.request.headers || {})) {
+      for (const [k, v] of Object.entries(
+          report.request['headers'] || {})) {
         if (k.toLowerCase().startsWith('cmcd-')) {
           Object.assign(merged, parseCmcdDict(v));
         }
@@ -189,7 +192,7 @@ describe('CmcdManager integration', () => {
       // Event body is newline-separated dicts (may be ArrayBuffer from
       // NetworkingEngine's UTF-8 encoding). For test convenience, return
       // the first non-empty line decoded.
-      const rawBody = bodyToString(report.request.body || '');
+      const rawBody = bodyToString(report.request['body'] || '');
       const body = rawBody.split(/\r?\n/)[0];
       return parseCmcdDict(body);
     }
@@ -270,6 +273,7 @@ describe('CmcdManager integration', () => {
    * 204 responses to have an empty body, satisfying shaka's assertion.
    *
    * @param {!cml.cmcd.CmcdReportRecorderOptions=} options
+   * @suppress {constantProperty|accessControls}
    */
   function attachRecorder(options) {
     recorder.attach(options);
@@ -294,6 +298,7 @@ describe('CmcdManager integration', () => {
 
   /**
    * Detach the recorder and restore shaka's internal fetch reference.
+   * @suppress {constantProperty|accessControls}
    */
   function detachRecorder() {
     recorder.detach();
@@ -500,7 +505,7 @@ describe('CmcdManager integration', () => {
       const reports = await recorder.waitForManifest();
       const report = reports[0];
       expect(report.reportingMode).toBe(cml.cmcd.CmcdRecordedReportMode.HEADER);
-      expect(report.request.url).not.toContain('CMCD=');
+      expect(report.request['url']).not.toContain('CMCD=');
       const decoded = decodeCmcdFromReport(report);
       expect(decoded['ot']).toBe('m');
       // sf='h' for HLS, 'd' for DASH.
@@ -524,7 +529,7 @@ describe('CmcdManager integration', () => {
     it('places fields in correct header shards', async () => {
       await player.load(TEST_STREAM);
       const reports = await recorder.waitForManifest();
-      const headers = reports[0].request.headers || {};
+      const headers = reports[0].request['headers'] || {};
       // Session shard must carry sid and sf
       const sessionShard = headers['cmcd-session'] || '';
       expect(sessionShard).toContain('sid=');
@@ -567,13 +572,13 @@ describe('CmcdManager integration', () => {
       expect(reports.length).toBeGreaterThan(0);
 
       const report = reports[0];
-      expect(report.request.method).toBe('POST');
+      expect(report.request['method']).toBe('POST');
 
       // The event body is sent as a UTF-8 encoded Uint8Array. Browsers
       // differ in how the fetch transport normalizes binary bodies:
       // some return the decoded string, others may return undefined.
       // Both indicate the event fired and was routed correctly.
-      const rawBody = bodyToString(report.request.body || '');
+      const rawBody = bodyToString(report.request['body'] || '');
       if (rawBody.length > 0) {
         // Validate each line of the event body as a CMCD event dict
         const lines = rawBody.split(/\r?\n/).filter((l) => l.trim());
diff --git a/test/util/cmcd_manager_unit.js b/test/util/cmcd_manager_unit.js
index fcf9b706f1..8e27c68e2e 100644
--- a/test/util/cmcd_manager_unit.js
+++ b/test/util/cmcd_manager_unit.js
@@ -632,8 +632,9 @@ describe('CmcdManager', () => {
     });
 
     it('suppresses duplicates of the same state', () => {
-      // Adapter-side lastPlayerState_ dedup short-circuits before
-      // entering the reporter; reporter's own dedup is a backstop.
+      // Adapter-side lastPlayerState_ deduplication short-circuits before
+      // entering the reporter; the reporter's own deduplication is a
+      // backstop.
       const player = createMockPlayer();
       const {manager} = createManager(player);
       spyOn(priv(manager)['reporter_'], 'update');