feat(media): add conformance corpus and MSF-01/CMSF-01 playback support

Establish a language-neutral media conformance corpus and bring the
media stack up to the current catalog drafts.

Conformance: add a schema-validated corpus of LOC property blocks, LOC
semantics, catalogs, and BMFF structures, with a runner that executes
all 127 vectors against production. Expectations are authored
independently of the implementation. An opt-in lane compares results
against an external LibMoQ build over the media-probe protocol; neither
repository vendors the other.

Transport/LOC: use vi64 for the draft-18 property wire, selected from
the negotiated draft rather than configuration. Support the draft-14,
draft-16, and draft-18 wire profiles while retaining LOC-01 semantic
resolution behind APIs designed for additive LOC-02/-04 and MSFTS
support.

Catalogs: parse MSF-01/CMSF-01 documents alongside MSF-00, including
root initDataList, per-track initRef, and content-protection metadata.
Parse and apply MSF-01 op-array deltas in document order while
preserving reference integrity.

Player: resolve catalog init references for CMAF bootstrap, apply
ordered catalog updates, and preserve content-protection metadata
without claiming protected-playback support.

Browser/MSE: make playback startup a single owned, cancellable
lifecycle; wait for non-zero startup positioning to settle; prevent
late play completions and superseded SourceBuffer events from mutating
current state; and serialize re-entrant state announcements. Add
debug-only startup and buffer chronology diagnostics.

Examples/CI: allow the Node publisher to emit modern catalog and delta
shapes, and add the conformance and soak workflows.

MediaSource implementation, attachment, and legacy-epoch controls are
diagnostic tools. Production defaults remain ManagedMediaSource-first,
automatic attachment, and shared cross-track epochs. This commit does
not claim that the Safari A/V synchronization issue is resolved.

Author: rwl4

.gitattributes

@@ -0,0 +1,5 @@
+# Wire vectors are normative BYTES. Marking them binary stops Git from
+# diffing them as text (a vector ending in 0x20 is not "trailing whitespace")
+# and, more importantly, from ever applying EOL normalization — a CRLF rewrite
+# on checkout would silently change the bytes the vector asserts.
+*.bin binary

.github/workflows/ci.yml

@@ -0,0 +1,92 @@
+# PR gate — fast, hermetic checks only. Every step here exists and runs today;
+# expensive lanes (soaks, fuzz, browser, differential) live in nightly.yml and
+# are added only when their implementations land.
+name: ci
+
+on:
+  pull_request:
+  push:
+    branches: [main]
+
+concurrency:
+  group: ci-${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+permissions:
+  contents: read
+
+jobs:
+  gate:
+    runs-on: ubuntu-latest
+    timeout-minutes: 30
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          # Full history so the whitespace check can diff the PR's committed range.
+          fetch-depth: 0
+
+      # pnpm version comes from the root package.json "packageManager" field.
+      - uses: pnpm/action-setup@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 24
+          cache: pnpm
+
+      - name: Install (frozen lockfile)
+        run: pnpm install --frozen-lockfile
+
+      - name: Build all packages
+        run: pnpm -r build
+
+      - name: Test
+        run: pnpm test
+
+      - name: Typecheck (per package)
+        run: |
+          set -euo pipefail
+          for p in transport webtransport playback loc player browser msf playa; do
+            echo "── tsc: packages/$p"
+            pnpm --dir "packages/$p" exec tsc --noEmit
+          done
+
+      - name: Typecheck + run the media conformance corpus
+        run: |
+          set -euo pipefail
+          pnpm --filter @moqt/media-conformance-runner typecheck
+          pnpm test:corpus
+
+      - name: Examples (player build + node-relay typecheck)
+        run: |
+          set -euo pipefail
+          pnpm --filter @moqt/examples build
+          pnpm --filter @moqt/example-node-relay typecheck
+
+      - name: Whitespace check (committed PR range)
+        run: |
+          set -euo pipefail
+          if [ "${{ github.event_name }}" = "pull_request" ]; then
+            base="${{ github.event.pull_request.base.sha }}"
+          else
+            # push: previous tip when available; first/force pushes fall back to HEAD~1.
+            base="${{ github.event.before }}"
+            if [ "$base" = "0000000000000000000000000000000000000000" ] || ! git cat-file -e "$base" 2>/dev/null; then
+              base="$(git rev-parse HEAD~1 2>/dev/null || git rev-parse HEAD)"
+            fi
+          fi
+          echo "Checking whitespace over $base..HEAD"
+          git diff --check "$base"..HEAD
+
+      - name: Post-build dirty-tree check
+        # Build/test must not mutate tracked files: a diff here means generated
+        # output drifted from what is committed (a plain diff --check on a clean
+        # checkout would be vacuous — this is the check that has teeth).
+        run: |
+          set -euo pipefail
+          status="$(git status --porcelain)"
+          if [ -n "$status" ]; then
+            echo "Working tree dirty after build/test:"
+            echo "$status"
+            git diff | head -100
+            exit 1
+          fi

.github/workflows/nightly.yml

@@ -0,0 +1,49 @@
+# Scheduled lanes — the expensive checks that must not block PRs or publishing.
+# Only lanes whose implementations exist are wired; the media differential,
+# browser matrix, and corpus fuzz lanes are added by their own slices.
+name: nightly
+
+on:
+  schedule:
+    - cron: "17 9 * * *" # daily, 09:17 UTC (off the top-of-hour rush)
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  soak:
+    runs-on: ubuntu-latest
+    timeout-minutes: 120
+    steps:
+      - uses: actions/checkout@v4
+      - uses: pnpm/action-setup@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 24
+          cache: pnpm
+      - name: Install (frozen lockfile)
+        run: pnpm install --frozen-lockfile
+      - name: Build all packages
+        run: pnpm -r build
+      - name: Scenario soak (draft-18)
+        run: pnpm test:soak
+      - name: Scenario soak (legacy drafts)
+        run: pnpm test:soak:legacy
+
+  fuzz:
+    runs-on: ubuntu-latest
+    timeout-minutes: 120
+    steps:
+      - uses: actions/checkout@v4
+      - uses: pnpm/action-setup@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 24
+          cache: pnpm
+      - name: Install (frozen lockfile)
+        run: pnpm install --frozen-lockfile
+      - name: Build all packages
+        run: pnpm -r build
+      - name: Property/parser-crash fuzz (FC_RUNS=5000)
+        run: pnpm test:soak:fuzz

conformance/media/MANIFEST.json

@@ -0,0 +1,10 @@
+{
+  "corpusSchema": "moq-media-corpus/1",
+  "domains": {
+    "bmff": 7,
+    "catalog": 55,
+    "loc": 32,
+    "properties": 33
+  },
+  "totalVectors": 127
+}

conformance/media/README.md

@@ -0,0 +1,163 @@
+# Media Conformance Corpus (`moq-media-corpus/1`)
+
+A language-neutral corpus of media-format conformance vectors — LOC property
+blocks, LOC semantics, catalogs, BMFF structures — consumed by two
+implementations: this repository (TypeScript, via `runner/`) and an external
+LibMoQ (C) build, reached only through the `moq-media-probe/1` JSONL protocol —
+neither repository vendors the other. This is **private test infrastructure**:
+it lives outside `packages/` and is never published to npm.
+
+Every vector is schema-validated, and a vector is executed only against a seam
+that actually exists. A vector kind whose runner API does not exist yet is
+capability-marked rather than silently skipped — counted and reported, never run
+against a non-existent API. Nothing is marked pending today.
+
+## Layout
+
+```
+conformance/media/
+  README.md            # this file — governance
+  MANIFEST.json        # derived index (schema + per-domain counts + total)
+  schema/              # JSON Schema for the manifest + scenario formats
+  vectors/
+    properties/        # Layer-A property-block-decode (executable)
+    loc/               # loc-properties (A+B) + loc-semantics (both executable)
+    catalog/           # catalog-parse (executable via parseCatalogAuto)
+    bmff/              # bmff-structure (executable via mp4-box utilities)
+  runner/              # private TS workspace package: loader, validator, tests
+```
+
+## Governance
+
+### Provenance (where the bytes came from)
+
+Every entry carries a mandatory `provenance` block with a `class`:
+
+- **`spec-derived`** — bytes hand-constructed to match a cited draft section
+  (e.g. a canonical vi64 encoding). The only class that is *conformance*
+  evidence, and only after independent review against the citation.
+- **`third-party`** — output of an external tool (ffmpeg, GPAC, moq-rs). Interop
+  evidence.
+- **`implementation-generated`** — output of Playa or LibMoQ. *Regression pins
+  only*, never conformance evidence.
+
+Provenance says where the bytes came from; `expectationBasis` (below) says what
+the expectation *claims*. A spec-derived vector can still be an `interpretation`.
+
+### `expectationBasis` (what the expectation claims)
+
+- **`normative`** — a MUST / registry entry with a precise citation.
+- **`interpretation`** — a documented Playa policy where the spec is ambiguous,
+  silent, or its registry is incomplete (see policies below).
+- **`interop`** — matches observed third-party behavior.
+- **`regression`** — pins current behavior with no spec claim (e.g. the silent
+  audio-level masking and duplicate last-wins the current parser exhibits).
+
+### Oracle independence (the load-bearing rule)
+
+For a `normative` or `interpretation` vector, the `expect` block is an
+**independently authored literal** — reasoned from the cited draft, never
+captured from the implementation under test. The authoring script then runs
+Playa *only* to populate `differential.playa`: absent (⇒ Playa matches the
+authored truth) or `diverges` + `currentBehavior` (⇒ it does not). This prevents
+an existing bug from being blessed as the normative answer. A `regression`
+vector is the sole exception — its `expect` legitimately IS the current
+implementation behavior, because that is what a regression pin means.
+
+The eighteen draft-18 divergence drivers (`loc/props-d18-*-diverges`) are the
+concrete payoff — every draft-18 value ≥ 64 in both directions (9 decode + 9
+encode). They drove the vi64 wiring fix: the `-diverges` id suffix records that
+origin, and they now pass against production directly (no differential).
+
+### Canonical ordering / duplicate policy
+
+- **PropertyMap decode** preserves occurrence order and duplicates losslessly
+  (dedup / last-wins is a Layer-B *semantic* policy, never a Layer-A behavior).
+- **Canonical encode** emits Key-Value-Pairs in **stable ascending-ID order**,
+  preserving the relative order of duplicate IDs — matching the current
+  encoders. (draft-18 §1.4.3.)
+- Trace event order is the **actual emission order** (never re-sorted); JSON key
+  order within a record is cosmetic (structural comparison).
+
+### Documented policies (all `interpretation`)
+
+These are exercised by their vectors once the corresponding format support
+lands; recorded now so the corpus and its consumers share one reading. Each also becomes an upstream
+issue (to be filed).
+
+- **LOC02-P1** — LOC-02 id `0x06` is interpreted as TIMESTAMP per the IANA table
+  (§6.1), which registers only TIMESTAMP; the §2.3.3.1 Audio Level prose
+  assignment (also `0x06`) is treated as an erratum. No value-magnitude
+  heuristics; Audio Level is unavailable in LOC-02; a session-scoped diagnostic
+  is emitted; the raw id/value is always preserved.
+- **LOC02-P1b** — LOC-02 ids `0x04` (Video Frame Marking) and `0x0D` (Video
+  Config) are accepted per their unambiguous prose assignments even though the
+  §6.1 registry omits them (the registry resolves conflicts; it does not
+  invalidate unambiguous definitions). One session-scoped diagnostic lists the
+  prose-only properties accepted.
+- **LOC02-P3** — running LOC-02 semantics over transport-18 is an *interop
+  profile*, not strict paired-draft conformance (LOC-02 normatively references
+  transport-17). Nine-byte Timestamps are accepted.
+- **LOC-P2** — a zero Timescale (unspecified in every LOC draft) is a
+  construction-time rejection (`invalid-timescale-zero`).
+
+### Stable ids + tombstones
+
+Ids are stable slugs (`domain/name`). They are never renamed. A retired vector
+is **tombstoned rather than deleted**: its manifest entry is replaced by
+`{ "id": "domain/name", "retired": { "reason": "…" } }`, which the schema
+accepts as an inert entry (no execution, no file). This keeps the id reserved
+(never reused) and the history diffable. Reviving a retired behavior uses a new
+id.
+
+### Canonical encoding
+
+- Every u64/i64-typed field is **always a decimal string** — never a JSON number
+  (a JSON number above 2^53-1 silently loses precision). The loader rejects a
+  JSON number in a wide-integer field.
+- Floats are prohibited. Bytes are lowercase hex; long blobs are
+  `{sha256, byteLength}`. Strings compare as exact code points.
+- Error comparisons use `error.category`, never message text.
+
+### Read-only + regeneration
+
+The corpus is read-only by default. The runtime `GEN_CORPUS=1` regeneration gate
+may rewrite ONLY `implementation-generated` entries produced by this repo;
+`assertRegenerable` refuses spec-derived and third-party bytes.
+
+The corpus was authored by `runner/src/build-corpus.ts` (run manually with
+`AUTHOR_CORPUS=1`), which constructs spec-derived bytes deterministically and
+captures the exact current production behavior for executable vectors. It is
+byte-stable across runs.
+
+### Third-party fixture import (LibMoQ)
+
+The 14 LibMoQ MSF fixtures are imported byte-for-byte (5 executable MSF-00,
+9 forward-looking MSF-01/CMSF-01) with pinned provenance in
+`provenance/libmoq-msf-fixtures.json` (+ a human table in the sibling `.md`).
+
+Normal authoring is **hermetic** — it re-derives from the checked-in snapshot
+(`vectors/catalog/libmoq_*.json`), so a fresh clone or CI reproduces the corpus
+with no external checkout. The pinned per-fixture SHA-256 gates every byte, so a
+tampered snapshot fails authoring.
+
+```
+# Hermetic re-author (default; no LibMoQ needed):
+AUTHOR_CORPUS=1 tsx conformance/media/runner/src/build-corpus.ts
+
+# Deliberately RE-IMPORT from a LibMoQ worktree (opt-in). Verifies the worktree
+# HEAD is the pinned commit before copying, then re-gates every byte by SHA-256:
+LIBMOQ_REFRESH=1 LIBMOQ_ROOT=/path/to/libmoq \
+  AUTHOR_CORPUS=1 tsx conformance/media/runner/src/build-corpus.ts
+```
+
+The pinned commit lives in `build-corpus.ts` (`LIBMOQ_COMMIT`) and the provenance
+file. Refresh runs `git rev-parse HEAD` via a direct exec (never a shell), so a
+`LIBMOQ_ROOT` containing spaces or metacharacters is handled literally.
+
+## Running
+
+```
+pnpm test:corpus       # the runner test suite (loader, validator, per-domain execution)
+pnpm test              # includes the corpus lane
+```

conformance/media/provenance/LIBMOQ-MSF-FIXTURES.md

@@ -0,0 +1,28 @@
+# LibMoQ MSF fixture import — pinned provenance
+
+**Source:** `openmoq/moq5 (LibMoQ)` @ `455318cade7445880a294e2ec6e6a5ccb67cb776` — path `media/msf/tests/fixtures`
+
+The planned **13 executable + 1 MSF-01-shaped** split was **disproved** by the source audit (5 + 9); the
+MSF-01/CMSF-01 parser promoted the later-era catalogs and the op-array delta parser
+promoted the delta documents. All 14 fixtures now **resolve to 14 executable /
+0 forward-looking** (5 numeric MSF-00/CMSF-00 + 7 MSF-01/CMSF-01 catalogs + 2 MSF-01 op-array deltas).
+ Byte-exact profile identities are preserved: 4 MSF-01 catalogs, 3 CMSF-01 catalogs, 2 MSF-01 delta documents.
+
+This file is generated by `AUTHOR_CORPUS=1 build-corpus.ts`; the JSON sibling is the machine-checked authority.
+
+| # | LibMoQ fixture | SHA-256 | Corpus ID | Corpus file | Era/profile | Capability | Basis |
+|--:|---|---|---|---|---|---|---|
+| 1 | `av_single.json` | `f07dd4722601…` | `catalog/libmoq-av-single` | `libmoq_av_single.json` | msf-00 | executable | normative |
+| 2 | `cmsf_clearkey.json` | `74831a3b1b74…` | `catalog/libmoq-cmsf-clearkey` | `libmoq_cmsf_clearkey.json` | cmsf-01 | executable | interpretation |
+| 3 | `cmsf_cmaf_simulcast.json` | `9d53c32066d0…` | `catalog/libmoq-cmsf-cmaf-simulcast` | `libmoq_cmsf_cmaf_simulcast.json` | cmsf-01 | executable | interpretation |
+| 4 | `cmsf_drm_cbcs.json` | `48b036709de7…` | `catalog/libmoq-cmsf-drm-cbcs` | `libmoq_cmsf_drm_cbcs.json` | cmsf-01 | executable | interpretation |
+| 5 | `delta_add_clone.json` | `9b1f6fa8140f…` | `catalog/libmoq-delta-add-clone` | `libmoq_delta_add_clone.json` | msf-01-delta | executable | interpretation |
+| 6 | `delta_remove.json` | `1cc3b8d80da3…` | `catalog/libmoq-delta-remove` | `libmoq_delta_remove.json` | msf-01-delta | executable | interpretation |
+| 7 | `empty_tracks.json` | `cc93a54da66a…` | `catalog/libmoq-empty-tracks` | `libmoq_empty_tracks.json` | msf-00 | executable | normative |
+| 8 | `mediatimeline.json` | `b5da1dc96f6f…` | `catalog/libmoq-mediatimeline` | `libmoq_mediatimeline.json` | msf-01 | executable | interpretation |
+| 9 | `minimal.json` | `a0bf6eed5a81…` | `catalog/libmoq-minimal` | `libmoq_minimal.json` | msf-00 | executable | normative |
+| 10 | `template.json` | `98d6cb8196bc…` | `catalog/libmoq-template` | `libmoq_template.json` | msf-01 | executable | interpretation |
+| 11 | `termination.json` | `dfdc4e8e5652…` | `catalog/libmoq-termination` | `libmoq_termination.json` | msf-01 | executable | interpretation |
+| 12 | `unknown_fields.json` | `4f3fc0bc4e0e…` | `catalog/libmoq-unknown-fields` | `libmoq_unknown_fields.json` | msf-00 | executable | regression |
+| 13 | `vod.json` | `e377cfa4e892…` | `catalog/libmoq-vod` | `libmoq_vod.json` | msf-01 | executable | interpretation |
+| 14 | `with_init_data.json` | `6c70626f51fe…` | `catalog/libmoq-with-init-data` | `libmoq_with_init_data.json` | msf-00 | executable | normative |