[bugfix]: keep _rms_norm_dispatch output in the input dtype under autocast

2026-07-07 02:08:20 -07:00
130 changed files with 441 additions and 9349 deletions
@@ -80,23 +80,6 @@ MODAL_ENV="BUILDKITE_REPO=$BUILDKITE_REPO BUILDKITE_COMMIT=$BUILDKITE_COMMIT BUI

 POST_RUN_HOOK=""

-is_truthy() {
-    case "${1:-}" in
-        1|true|TRUE|yes|YES|on|ON) return 0 ;;
-        *) return 1 ;;
-    esac
-}
-
-ssim_bootstrap_args() {
-    local title="${PR_TITLE:-}"
-    local message="${BUILDKITE_MESSAGE:-}"
-    if is_truthy "${FASTVIDEO_SSIM_BOOTSTRAP_MODE:-}" \
-        || [[ "$title" == *"[new-model]"* ]] \
-        || [[ "$message" == *"[new-model]"* ]]; then
-        printf ' --bootstrap-mode'
-    fi
-}
-
 upload_performance_artifacts() {
    SHORT_SHA=${BUILDKITE_COMMIT:0:7}
    LOCAL_DIR="downloaded_reports"
@@ -189,12 +172,7 @@ case "$TEST_TYPE" in
        ;;
    "ssim")
        log "Running SSIM tests..."
-        SSIM_BOOTSTRAP_ARGS=$(ssim_bootstrap_args)
-        if [ -n "$SSIM_BOOTSTRAP_ARGS" ]; then
-            log "SSIM bootstrap mode enabled for new-model reference draft generation"
-        fi
-        MODAL_COMMAND="$MODAL_ENV HF_API_KEY=$HF_API_KEY python3 -m modal run "
-        MODAL_COMMAND+="$MODAL_SSIM_TEST_FILE::run_ssim_tests$SSIM_BOOTSTRAP_ARGS"
+        MODAL_COMMAND="$MODAL_ENV HF_API_KEY=$HF_API_KEY python3 -m modal run $MODAL_SSIM_TEST_FILE::run_ssim_tests"
        ;;
    "training")
        log "Running training tests..."
@@ -52,7 +52,6 @@ jobs:
            core.setOutput('pr_sha', pr.head.sha);
            core.setOutput('pr_branch', pr.head.ref);
            core.setOutput('pr_number', String(prNumber));
-            core.setOutput('pr_title', pr.title);

      - name: Trigger Full Suite
        if: steps.perm.outputs.has_write == 'true'
@@ -61,7 +60,6 @@ jobs:
          PR_SHA: ${{ steps.label.outputs.pr_sha }}
          PR_BRANCH: ${{ steps.label.outputs.pr_branch }}
          PR_NUMBER: ${{ steps.label.outputs.pr_number }}
-          PR_TITLE: ${{ steps.label.outputs.pr_title }}
          BK_ORG: ${{ vars.BUILDKITE_ORG_SLUG }}
          BK_PIPELINE: ${{ vars.BUILDKITE_PIPELINE_SLUG }}
        run: |
@@ -73,7 +71,6 @@ jobs:
              --arg commit "$PR_SHA" \
              --arg branch "$PR_BRANCH" \
              --arg message "Full Suite for PR #${PR_NUMBER} (via /merge)" \
-              --arg pr_title "$PR_TITLE" \
              --argjson pr_id "$PR_NUMBER" \
              '{
                commit: $commit,
@@ -83,12 +80,11 @@ jobs:
                pull_request_id: $pr_id,
                pull_request_base_branch: "main",
                env: {
-                    TEST_SCOPE: "full",
-                    FULL_SUITE: "true",
-                    PR_NUMBER: ($pr_id | tostring),
-                    PR_TITLE: $pr_title
-                  }
-                }')"
+                  TEST_SCOPE: "full",
+                  FULL_SUITE: "true",
+                  PR_NUMBER: ($pr_id | tostring)
+                }
+              }')"

  parse-command:
    if: >-
@@ -245,7 +241,6 @@ jobs:
          TEST_SCOPE: ${{ needs.parse-command.outputs.test_scope }}
          FULL_SUITE: ${{ needs.parse-command.outputs.full_suite }}
          TEST_TYPE: ${{ needs.parse-command.outputs.test_type }}
-          PR_TITLE: ${{ github.event.issue.title }}
          BK_ORG: ${{ vars.BUILDKITE_ORG_SLUG }}
          BK_PIPELINE: ${{ vars.BUILDKITE_PIPELINE_SLUG }}
        run: |
@@ -262,7 +257,6 @@ jobs:
              --arg full_suite "$FULL_SUITE" \
              --arg test_type "$TEST_TYPE" \
              --arg pr_number "$PR_NUMBER" \
-              --arg pr_title "$PR_TITLE" \
              '{
                commit: $commit,
                branch: $branch,
@@ -272,9 +266,8 @@ jobs:
                pull_request_base_branch: "main",
                env: {
                  TEST_SCOPE: $test_scope,
-                    FULL_SUITE: $full_suite,
-                    TEST_TYPE: $test_type,
-                    PR_NUMBER: $pr_number,
-                    PR_TITLE: $pr_title
-                  }
-                }')"
+                  FULL_SUITE: $full_suite,
+                  TEST_TYPE: $test_type,
+                  PR_NUMBER: $pr_number
+                }
+              }')"
@@ -56,7 +56,6 @@ jobs:
          PR_SHA: ${{ github.event.pull_request.head.sha }}
          PR_BRANCH: ${{ github.event.pull_request.head.ref }}
          PR_NUMBER: ${{ github.event.pull_request.number }}
-          PR_TITLE: ${{ github.event.pull_request.title }}
          BK_ORG: ${{ vars.BUILDKITE_ORG_SLUG }}
          BK_PIPELINE: ${{ vars.BUILDKITE_PIPELINE_SLUG }}
        run: |
@@ -68,7 +67,6 @@ jobs:
              --arg commit "$PR_SHA" \
              --arg branch "$PR_BRANCH" \
              --arg message "Full Suite for PR #${PR_NUMBER}" \
-              --arg pr_title "$PR_TITLE" \
              --argjson pr_id "$PR_NUMBER" \
              '{
                commit: $commit,
@@ -80,7 +78,6 @@ jobs:
                env: {
                  TEST_SCOPE: "full",
                  FULL_SUITE: "true",
-                  PR_NUMBER: ($pr_id | tostring),
-                  PR_TITLE: $pr_title
+                  PR_NUMBER: ($pr_id | tostring)
                }
              }')"
@@ -1,95 +0,0 @@
-name: Publish FastVideo Kernel to Hugging Face Hub
-
-# Version-gated like the PyPI flow (publish-kernel.yml): a push to main only
-# publishes when the fastvideo-kernel version actually changes. Use
-# workflow_dispatch as the manual override.
-on:
-  push:
-    branches:
-      - main
-    paths:
-      - "fastvideo-kernel/pyproject.toml"
-  workflow_dispatch:
-    inputs:
-      branch:
-        description: "Hub branch to upload the build"
-        default: ""
-        required: false
-
-# A Hub build takes hours; never race two publishes to the same repo.
-concurrency:
-  group: ${{ github.workflow }}
-  cancel-in-progress: false
-
-jobs:
-  check-version-change:
-    runs-on: ubuntu-latest
-    outputs:
-      version-changed: ${{ steps.check-version.outputs.changed }}
-      new-version: ${{ steps.check-version.outputs.new-version }}
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 2
-
-      - name: Check if version changed
-        id: check-version
-        run: |
-          cd fastvideo-kernel
-          # Get current commit's version from pyproject.toml
-          # Use ^ to match start of line to avoid matching minimum-version
-          NEW_VERSION=$(grep -oP '^version\s*=\s*"\K[^"]+' pyproject.toml)
-          echo "New version: $NEW_VERSION"
-
-          # Get previous version from git history
-          # Note: git show expects path relative to repo root
-          OLD_VERSION=$(git show HEAD~1:fastvideo-kernel/pyproject.toml | grep -oP '^version\s*=\s*"\K[^"]+' || echo "0.0.0")
-          echo "Old version: $OLD_VERSION"
-
-          if [ "$NEW_VERSION" != "$OLD_VERSION" ]; then
-            echo "Version changed from $OLD_VERSION to $NEW_VERSION"
-            echo "changed=true" >> "$GITHUB_OUTPUT"
-            echo "new-version=$NEW_VERSION" >> "$GITHUB_OUTPUT"
-          else
-            echo "Version did not change"
-            echo "changed=false" >> "$GITHUB_OUTPUT"
-          fi
-
-  build:
-    needs: check-version-change
-    if: ${{ needs.check-version-change.outputs.version-changed == 'true' || github.event_name == 'workflow_dispatch' }}
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Build kernel via HF Jobs and upload to hao-ai-lab/fastvideo-kernel
-        # Pinned to a commit SHA: this third-party action receives HF_TOKEN.
-        uses: huggingface/kernel-builder-job@ee590cee1ff01e922310401f18d5554b8da448ac # main, 2026-06-03
-        with:
-          token: ${{ secrets.HF_TOKEN }}
-          namespace: hao-ai-lab
-          flavor: cpu-xl
-          timeout: "21600"
-          script: |
-            set +x
-            export HF_TOKEN="${{ secrets.HF_TOKEN }}"
-            export GIT_LFS_SKIP_SMUDGE=1
-
-            git clone "${{ github.server_url }}/${{ github.repository }}" FastVideo
-            cd FastVideo
-            git checkout "${{ github.sha }}"
-            git submodule update --init --recursive fastvideo-kernel/include/cutlass fastvideo-kernel/include/tk
-            cd fastvideo-kernel
-
-            UPLOAD_BRANCH="${{ github.event.inputs.branch }}"
-            BRANCH_ARGS=()
-            if [ -n "${UPLOAD_BRANCH}" ]; then
-              BRANCH_ARGS=(--branch "${UPLOAD_BRANCH}")
-            fi
-
-            nix run github:huggingface/kernels#kernel-builder -- build-and-upload \
-              --max-jobs 4 \
-              --cores 8 \
-              --repo-id hao-ai-lab/fastvideo-kernel \
-              "${BRANCH_ARGS[@]}"
@@ -1,22 +0,0 @@
-{
-  "alpha_yaw": 0.08734091699186919,
-  "alpha_pitch": 0.08169667696275307,
-  "alpha_turn": 5.724587470723463e-17,
-  "beta_fwd": 0.02842768078408099,
-  "beta_strafe": 0.022531015077067108,
-  "focal_length": 457.0,
-  "frame_shape": [
-    352,
-    640
-  ],
-  "calibrated_from": [
-    "1_wasd_only",
-    "camera",
-    "camera4hold_alpha1",
-    "fully_random",
-    "wasdonly_alpha1",
-    "wasd4holdrandview_simple_1key1mouse1"
-  ],
-  "residual_rms": 15.890399609478676,
-  "n_equations": 4125232
-}
@@ -79,11 +79,10 @@ fastvideo/performance/
 ```

 The HF dataset (`FastVideo/performance-tracking` by default) holds one
-normalized JSON per run. For v2 records, the rolling baseline is the median of
-the last 5 successful, baseline-eligible records in the same comparison cohort:
-`model_id`, `gpu_type`, `workload_id`, `variant_id`, `benchmark_version`,
-`recipe_fingerprint`, `hardware_profile_id`, and `software_profile_id`. PR and
-local records are visible in the dashboard but are not baseline eligible.
+normalized JSON per `(model_id, gpu_type, run)` tuple. The rolling baseline is
+the median of the last 5 successful, baseline-eligible records for that
+model+GPU. PR and local records are visible in the dashboard but are not
+baseline eligible.

 ## Planned Coverage

@@ -159,16 +158,13 @@ unrealistic memory growth, and optionally large component-specific slowdowns
 even when the rolling baseline is empty. They are hand-set with generous
 headroom and almost never need touching.

-### Rolling baseline (per comparison cohort)
+### Rolling baseline (per `(model_id, gpu_type)`)

 `compare_baseline.py` loads the last 5 successful, baseline-eligible records
-for the same comparison cohort from the HF dataset, computes the median for
-each available metric, and evaluates the current run with the metric's
-rolling regression policy. For v2 records, that cohort is `model_id`,
-`gpu_type`, `workload_id`, `variant_id`, `benchmark_version`,
-`recipe_fingerprint`, `hardware_profile_id`, and `software_profile_id`. For
-latency, memory, and component times, higher values are regressions. For
-throughput, lower values are regressions.
+for the same `(model_id, gpu_type)` from the HF dataset, computes the median
+for each available metric, and evaluates the current run with the metric's
+rolling regression policy. For latency, memory, and component times, higher
+values are regressions. For throughput, lower values are regressions.

 A metric exceeds its rolling threshold when both of these are true:

@@ -234,10 +230,8 @@ Recipe fingerprinting, hardware/software profile IDs, exact-identity
 comparison, and dashboard cohort grouping land with this change: v2 records
 compare only within their identity cohort, and a record that opens a NEW
 cohort is marked `baseline_status: "initialized_new_cohort"` (regression
-gating starts once that cohort accumulates history). Legacy v1 configs still
-run and are normalized for reporting, but their records skip rolling-baseline
-comparison entirely (`baseline_status: "skipped_missing_identity"`, never
-baseline eligible); only static thresholds gate them. Metric-specific
+gating starts once that cohort accumulates history). Legacy v1 configs keep
+the `(model_id, gpu_type)` rolling-baseline comparison. Metric-specific
 threshold policies and promoted baselines remain separate follow-ups.

 ### Raw record (`results/perf_*.json`)
@@ -247,7 +241,7 @@ Written by `test_inference_performance.py`. One file per benchmark run.
 ```jsonc
 {
  "benchmark_id": "wan-t2v-1.3b-2gpu",
-  "result_schema_version": 2,
+  "config_schema_version": 2,
  "workload_id": "wan-t2v",
  "variant_id": "1.3b-sp2",
  "benchmark_version": 2,
@@ -276,15 +270,8 @@ Written by `test_inference_performance.py`. One file per benchmark run.
    }
  },
  "commit": "<full sha>",
-  "run_source": "pr",
-  "branch": "feature/perf-change",
  "pr_number": "1234",
-  "test_scope": "direct",
-  "build_url": "https://buildkite.example/build",
-  "build_id": "<buildkite-build-id>",
-  "job_id": "<buildkite-job-id>",
  "timestamp": "2026-05-08T22:00:00+00:00",
-  "quality_metadata": { "quality_status": "canonical" },
  "text_encoder_time_s": 2.141,
  "dit_time_s": 8.437,
  "vae_decode_time_s": 3.208,
@@ -335,7 +322,6 @@ result, used as the rolling-baseline source of truth.
 ```jsonc
 {
  "model_id": "wan-t2v-1.3b-2gpu",
-  "result_schema_version": 2,
  "workload_id": "wan-t2v",
  "variant_id": "1.3b-sp2",
  "benchmark_version": 2,
@@ -359,30 +345,17 @@ result, used as the rolling-baseline source of truth.
  "hardware_profile_id": "hw-<sha256-prefix>",
  "software_profile_id": "sw-<sha256-prefix>",
  "environment_fingerprint": "env-<sha256-prefix>",
-  "run_source": "pr",
-  "branch": "feature/perf-change",
-  "pr_number": "1234",
-  "test_scope": "direct",
-  "build_url": "https://buildkite.example/build",
-  "build_id": "<buildkite-build-id>",
-  "job_id": "<buildkite-job-id>",
-  "quality_metadata": { "quality_status": "canonical" },
  "success": true
 }
 ```

 ### Compatibility with legacy records

-Older records in the HF dataset may not have `result_schema_version`,
-component timing fields, or v2 identity/profile fields. Records without
-`result_schema_version` are treated as v1. The comparator ignores missing or
-`null` metrics when computing a median, and the dashboard lists skipped plots
-for metric series that have no non-null values. Records missing both
-`run_source` and `baseline_eligible` are treated as legacy successful
-main/full-suite uploads and remain eligible for rolling baselines.
-Current `perf_*.json` artifacts that lack the v2 comparison identity are
-normalized for reporting but skip rolling-baseline comparison and are not marked
-baseline eligible.
+Older records in the HF dataset may not have component timing fields. The
+comparator ignores missing or `null` metrics when computing a median, and the
+dashboard lists skipped plots for metric series that have no non-null values.
+Records missing both `run_source` and `baseline_eligible` are treated as legacy
+successful main/full-suite uploads and remain eligible for rolling baselines.

 New records compare only against the same `model_id`, `gpu_type`,
 `workload_id`, `variant_id`, `benchmark_version`, `recipe_fingerprint`,
@@ -404,7 +377,7 @@ FlashInfer, Cutlass DSL, SageAttention, Triton, and xFormers when installed.
 | `PERF_REPORTS_DIR` | `/root/data/perf_reports` | `compare_baseline.py`, `dashboard.py` | Where the Markdown summary and Plotly HTML get written for Buildkite to pick up. |
 | `HF_REPO_ID` | `FastVideo/performance-tracking` | `fastvideo/performance/hf_store.py` | HF dataset repo holding rolling-baseline records. |
 | `HF_API_KEY`, `HUGGINGFACE_HUB_TOKEN`, `HF_TOKEN` | unset | `fastvideo/performance/hf_store.py` | Required for upload or private dataset reads. |
-| `PERF_RUN_SOURCE` | inferred | `compare_baseline.py`, `test_inference_performance.py` | Source metadata for uploaded records: `pr`, `local`, `scheduled_main`, or `unknown`. |
+| `PERF_RUN_SOURCE` | inferred | `compare_baseline.py` | Source metadata for uploaded records: `pr`, `local`, `scheduled_main`, or `unknown`. |
 | `PERF_UPLOAD_POLICY` | `never` | `compare_baseline.py` | Upload policy: `never`, `pass`, or `always`. |
 | `PERF_PYTEST_RC` | unset | `compare_baseline.py` | Static-threshold pytest exit code, used so scheduled-main failures can be uploaded with `success=false`. |
 | `TEST_SCOPE` | unset | `compare_baseline.py` | CI context used to infer scheduled-main runs together with `BUILDKITE_BRANCH=main`. |
@@ -421,14 +394,11 @@ point is `fastvideo/tests/modal/pr_test.py:run_performance_tests` and the
 Buildkite artifact upload is in
 `.buildkite/scripts/pr_test.sh:upload_performance_artifacts`.

-Each performance build runs pytest first. PR and direct runs only continue to
-`compare_baseline.py` when that fixed-threshold phase passes; if pytest fails,
-Markdown summaries and normalized JSON artifacts are not emitted. Scheduled
-main runs set `PERF_UPLOAD_POLICY=always`, so they still run
-`compare_baseline.py` (with `PERF_PYTEST_RC` set) after a fixed-threshold
-failure. Those failed scheduled main runs emit summaries and normalized
-records, upload records with `success=false`, and are excluded from future
-rolling baselines. The dashboard still runs best-effort for observability.
+Each performance build runs pytest first. If that fixed-threshold phase fails,
+PR/direct runs skip `compare_baseline.py` because they only upload passing
+records. Scheduled-main runs still execute `compare_baseline.py` with
+`PERF_PYTEST_RC` set so the failed canonical attempt is visible in normalized
+JSON and dashboard history. The dashboard runs best-effort for observability.
 When the rolling-baseline phase runs, it emits:

 * **Markdown summary** — appended to `$GITHUB_STEP_SUMMARY` when that variable
@@ -436,7 +406,7 @@ When the rolling-baseline phase runs, it emits:
  per-benchmark row with current vs. baseline values for latency, throughput,
  memory, text encoder time, DiT time, and VAE decode time.
 * **Plotly dashboard** — `dashboard_<sha>_<ts>.html` showing time-series for
-  each metric grouped by comparison cohort.
+  each metric grouped by `(model_id, gpu_type)`.
 * **Normalized records** — `normalized_perf_*.json`, one per benchmark.
  Useful as input to the
  [`reseed-performance-baseline`](https://github.com/hao-ai-lab/FastVideo/blob/main/.agents/skills/reseed-performance-baseline/SKILL.md)
@@ -510,8 +480,8 @@ When the rolling-baseline phase runs, it emits:

 ## Troubleshooting

-**"No baseline for ... Initializing"** — first run for this comparison cohort.
-Run will pass and (if persisting) seed the first record.
+**"No baseline for ... Initializing"** — first run for this `(model_id,
+gpu_type)`. Run will pass and (if persisting) seed the first record.

 **Persistent failure right after a torch / kernel / image upgrade** —
 genuine regression *or* baseline drift. Compare the failing normalized record
@@ -180,30 +180,6 @@ python fastvideo/tests/ssim/reference_videos_cli.py copy-local \
  --device-folder L40S_reference_videos
 ```

-### SSIM Bootstrap Mode
-
-Normal SSIM runs are strict: if a reference video or latent is missing, the
-test fails. For new-model PRs, CI can run SSIM in bootstrap mode so missing
-references are uploaded as draft artifacts for review instead of immediately
-blocking on a missing canonical reference.
-
-Buildkite enables SSIM bootstrap mode when either condition is true:
-
- the PR title or Buildkite message contains `[new-model]`;
- `FASTVIDEO_SSIM_BOOTSTRAP_MODE=1` is set for the Buildkite job.
-
-Bootstrap mode passes `--ssim-bootstrap-mode` to pytest. When a generated
-artifact is available, the test uploads it under the `drafts/...` namespace in
-the SSIM reference repo and marks that case as expected-failed. After reviewing
-the draft, promote it into the canonical reference layout:
-
-```bash
-python fastvideo/tests/ssim/reference_videos_cli.py promote-draft \
-  --quality-tier default \
-  --device-folder L40S_reference_videos \
-  --model-id <model_id>
-```
-
 ## CI Integration

 FastVideo CI tests are orchestrated by Buildkite and run on Modal GPU
@@ -161,18 +161,6 @@ training:
    decay_interval_steps: 0
 ```

-`training.data.data_path` can also mix multiple preprocessed datasets by using a mapping from dataset path to repeat count:
-
-```yaml
-training:
-  data:
-    data_path:
-      data/zeldam2-clean: 1
-      data/multi3d_games: 2
-```
-
-The repeat count duplicates that dataset's parquet file list before shuffling/sampling, so the example above trains with roughly twice as much `multi3d_games` exposure as `zeldam2-clean`. Paths are just suggested locations; use any local path that contains a FastVideo preprocessed parquet dataset.
-
 See [Training Trackers](trackers.md) to configure Weights & Biases or SwanLab,
 including SwanLab installation and authentication.

@@ -338,40 +326,6 @@ Self-Forcing inherits all DMD2 parameters, plus:
 | `enable_gradient_in_rollout` | `true` | Enable backprop through rollout |
 | `start_gradient_frame` | `0` | Frame index where gradients begin |

-### Streaming Long Tuning
-
-`StreamingLongTuningMethod` extends Self-Forcing for LongLive-style rollouts. It
-keeps a streaming state, generates overlapping chunks, and trains only the new
-frames while preserving context from earlier chunks.
-
-For the MatrixGame2/Zelda world-model example, self-forcing and long tuning are
-separate runs: first train or load the 1k-step self-forcing checkpoint using
-`examples/train/scenario/worldmodel/zelda/self_forcing_causal_i2v.yaml`,
-then run
-`examples/train/scenario/worldmodel/zelda/streaming_long_tuning_causal_i2v.yaml`
-from that checkpoint for the 3k-step streaming long-tuning stage.
-
-```yaml
-method:
-  _target_: fastvideo.train.methods.distribution_matching.streaming_long_tuning.StreamingLongTuningMethod
-  streaming_chunk_size: 9
-  streaming_max_length: 39
-  streaming_fixed_overlap_latents: 3
-  streaming_reencode_overlap_anchor: true
-  streaming_anchor_inject_k: 1
-  streaming_require_full_blocks: true
-  multi_phased_distill_schedule:
-    - stage: streaming_long
-      start_step: 0
-      end_step: 3000
-      num_latent_t: 39
-      streaming_training: true
-```
-
-See
-`examples/train/scenario/worldmodel/zelda/streaming_long_tuning_causal_i2v.yaml`
-for a complete MatrixGame2/Zelda configuration.
-
 ---

 ## Callbacks
@@ -1,37 +0,0 @@
-from fastvideo import VideoGenerator
-
-OUTPUT_PATH = "video_samples_kandinsky5_i2v"
-
-IMAGE_PATH = "assets/girl.png"
-
-
-def main():
-    generator = VideoGenerator.from_pretrained(
-        "kandinskylab/Kandinsky-5.0-I2V-Pro-distilled-5s-Diffusers", 
-        # "kandinskylab/Kandinsky-5.0-I2V-Pro-sft-5s-Diffusers"
-        # "kandinskylab/Kandinsky-5.0-I2V-Lite-5s-Diffusers"
-        num_gpus=1,
-        use_fsdp_inference=False,
-        dit_cpu_offload=False,
-        vae_cpu_offload=False,
-        text_encoder_cpu_offload=True,
-        pin_cpu_memory=True,
-        # image_encoder_cpu_offload=False,
-    )
-
-    prompt = (
-        "A woman stands up and walks away"
-    )
-    _ = generator.generate_video(
-        prompt,
-        image_path=IMAGE_PATH,
-        output_path=OUTPUT_PATH,
-        save_video=True,
-        height=1024,
-        width=1024,
-        num_frames=121,
-    )
-
-
-if __name__ == "__main__":
-    main()
@@ -1,37 +0,0 @@
-from fastvideo import VideoGenerator
-
-OUTPUT_PATH = "video_samples_kandinsky5_t2v"
-
-def main():
-    generator = VideoGenerator.from_pretrained(
-        "kandinskylab/Kandinsky-5.0-T2V-Lite-sft-5s-Diffusers",
-        # "kandinskylab/Kandinsky-5.0-T2V-Pro-sft-5s-Diffusers"
-        # "kandinskylab/Kandinsky-5.0-T2V-Lite-distilled16steps-5s-Diffusers"
-        # "kandinskylab/Kandinsky-5.0-T2V-Pro-distilled-5s-Diffusers"
-        num_gpus=1,
-        use_fsdp_inference=False,
-        dit_cpu_offload=False,
-        vae_cpu_offload=False,
-        text_encoder_cpu_offload=True,
-        pin_cpu_memory=True,
-        # image_encoder_cpu_offload=False,
-    )
-
-    prompt = (
-        "A curious raccoon peers through a vibrant field of yellow sunflowers, its eyes "
-        "wide with interest. The playful yet serene atmosphere is complemented by soft "
-        "natural light filtering through the petals. Mid-shot, warm and cheerful tones."
-    )
-    _ = generator.generate_video(prompt, output_path=OUTPUT_PATH, save_video=True,height=512, width=768, num_frames=121)
-
-    prompt2 = (
-        "A majestic lion strides across the golden savanna, its powerful frame "
-        "glistening under the warm afternoon sun. The tall grass ripples gently in "
-        "the breeze, enhancing the lion's commanding presence. The tone is vibrant, "
-        "embodying the raw energy of the wild. Low angle, steady tracking shot, "
-        "cinematic.")
-    _ = generator.generate_video(prompt2, output_path=OUTPUT_PATH, save_video=True, height=512, width=768, num_frames=121)
-
-
-if __name__ == "__main__":
-    main()
@@ -1,69 +0,0 @@
-# LTX-2.3 distilled inference configs
-
-Ready-to-run `fastvideo generate` run configs for the LTX-2.3
-distilled model (`FastVideo/LTX-2.3-Distilled-Diffusers`), covering both
-workloads (t2v / i2v), both two-stage step schedules (`5+2`, `8+3` = denoise
-+ refine), and four resolutions.
-
-```bash
-fastvideo generate --config examples/inference/ltx2_3/t2v_8s3_1280x832.yaml
-```
-
-Each config is self-contained (no preset registry needed): the two-stage
-refine is wired via `generator.pipeline.preset_overrides.refine`, and the
-base sampling knobs live under `request.sampling`. The refine upsampler
-auto-resolves from the model's `spatial_upscaler`.
-
-## Configs
-
-| workload | schedule | resolution (HxW) | file |
-|---|---|---|---|
-| t2v | 5+2 | 1280x832 | `t2v_5s2_1280x832.yaml` |
-| t2v | 5+2 | 1024x1536 | `t2v_5s2_1024x1536.yaml` |
-| t2v | 5+2 | 768x1280 | `t2v_5s2_768x1280.yaml` |
-| t2v | 5+2 | 512x768 | `t2v_5s2_512x768.yaml` |
-| t2v | 8+3 | 1280x832 | `t2v_8s3_1280x832.yaml` |
-| t2v | 8+3 | 1024x1536 | `t2v_8s3_1024x1536.yaml` |
-| t2v | 8+3 | 768x1280 | `t2v_8s3_768x1280.yaml` |
-| t2v | 8+3 | 512x768 | `t2v_8s3_512x768.yaml` |
-| i2v | 5+2 | 1280x832 | `i2v_5s2_1280x832.yaml` |
-| i2v | 5+2 | 1024x1536 | `i2v_5s2_1024x1536.yaml` |
-| i2v | 5+2 | 768x1280 | `i2v_5s2_768x1280.yaml` |
-| i2v | 5+2 | 512x768 | `i2v_5s2_512x768.yaml` |
-| i2v | 8+3 | 1280x832 | `i2v_8s3_1280x832.yaml` |
-| i2v | 8+3 | 1024x1536 | `i2v_8s3_1024x1536.yaml` |
-| i2v | 8+3 | 768x1280 | `i2v_8s3_768x1280.yaml` |
-| i2v | 8+3 | 512x768 | `i2v_8s3_512x768.yaml` |
-
-## Overriding without editing a file
-
-Dotted overrides (prefixes `generator.` / `request.`) let you tweak any field:
-
-```bash
-# swap prompt
-fastvideo generate --config examples/inference/ltx2_3/t2v_8s3_1280x832.yaml \
-  --request.prompt "a red fox running through fresh snow"
-
-# change output path / gpu count
-fastvideo generate --config examples/inference/ltx2_3/t2v_5s2_512x768.yaml \
-  --request.output.output_path outputs/preview.mp4 \
-  --generator.engine.num_gpus 4
-```
-
-## i2v
-
-The `i2v_*` configs take a first-frame image via
-`request.extensions.ltx2_images` (`[[path, frame_offset, weight]]`). Edit the
-path in the file, or override it:
-
-```bash
-fastvideo generate --config examples/inference/ltx2_3/i2v_8s3_1280x832.yaml \
-  --request.extensions.ltx2_images '[["/data/portrait.jpg", 0, 1.0]]'
-```
-
-## Schedules
-
-`5+2` is the fast preview schedule; `8+3` is the higher-quality distilled
-recipe. Refine (`preset_overrides.refine.num_inference_steps`) only accepts 2
-or 3 steps.
-
@@ -1,38 +0,0 @@
-# LTX-2.3 distilled i2v — 5+2 two-stage at 1024x1536.
-#
-# Run:
-#   fastvideo generate --config examples/inference/ltx2_3/i2v_5s2_1024x1536.yaml
-#
-# Stage 1 denoises for 5 steps at half resolution; the latents are then
-# spatially upsampled and refined for 2 steps (refine only supports 2 or 3).
-# The refine upsampler auto-resolves from the model's `spatial_upscaler`.
-generator:
-  model_path: FastVideo/LTX-2.3-Distilled-Diffusers
-  engine:
-    num_gpus: 1
-  pipeline:
-    workload_type: i2v
-    preset_overrides:
-      refine:
-        enabled: true
-        num_inference_steps: 2
-        guidance_scale: 1.0
-        add_noise: true
-request:
-  prompt: >-
-    The subject slowly turns toward the camera with a soft, natural expression, hair and clothing swaying gently, shallow depth of field, subtle cinematic motion.
-  sampling:
-    height: 1024
-    width: 1536
-    num_frames: 121
-    fps: 24
-    guidance_scale: 1.0
-    num_inference_steps: 5
-  # i2v conditioning — replace the path with your own first-frame image.
-  extensions:
-    ltx2_images:
-      - ["/path/to/your/first_frame.jpg", 0, 1.0]
-    ltx2_image_crf: 0.0
-  output:
-    output_path: outputs/ltx2_3_i2v_5s2_1024x1536.mp4
-    save_video: true
@@ -1,38 +0,0 @@
-# LTX-2.3 distilled i2v — 5+2 two-stage at 1280x832.
-#
-# Run:
-#   fastvideo generate --config examples/inference/ltx2_3/i2v_5s2_1280x832.yaml
-#
-# Stage 1 denoises for 5 steps at half resolution; the latents are then
-# spatially upsampled and refined for 2 steps (refine only supports 2 or 3).
-# The refine upsampler auto-resolves from the model's `spatial_upscaler`.
-generator:
-  model_path: FastVideo/LTX-2.3-Distilled-Diffusers
-  engine:
-    num_gpus: 1
-  pipeline:
-    workload_type: i2v
-    preset_overrides:
-      refine:
-        enabled: true
-        num_inference_steps: 2
-        guidance_scale: 1.0
-        add_noise: true
-request:
-  prompt: >-
-    The subject slowly turns toward the camera with a soft, natural expression, hair and clothing swaying gently, shallow depth of field, subtle cinematic motion.
-  sampling:
-    height: 1280
-    width: 832
-    num_frames: 121
-    fps: 24
-    guidance_scale: 1.0
-    num_inference_steps: 5
-  # i2v conditioning — replace the path with your own first-frame image.
-  extensions:
-    ltx2_images:
-      - ["/path/to/your/first_frame.jpg", 0, 1.0]
-    ltx2_image_crf: 0.0
-  output:
-    output_path: outputs/ltx2_3_i2v_5s2_1280x832.mp4
-    save_video: true
@@ -1,38 +0,0 @@
-# LTX-2.3 distilled i2v — 5+2 two-stage at 512x768.
-#
-# Run:
-#   fastvideo generate --config examples/inference/ltx2_3/i2v_5s2_512x768.yaml
-#
-# Stage 1 denoises for 5 steps at half resolution; the latents are then
-# spatially upsampled and refined for 2 steps (refine only supports 2 or 3).
-# The refine upsampler auto-resolves from the model's `spatial_upscaler`.
-generator:
-  model_path: FastVideo/LTX-2.3-Distilled-Diffusers
-  engine:
-    num_gpus: 1
-  pipeline:
-    workload_type: i2v
-    preset_overrides:
-      refine:
-        enabled: true
-        num_inference_steps: 2
-        guidance_scale: 1.0
-        add_noise: true
-request:
-  prompt: >-
-    The subject slowly turns toward the camera with a soft, natural expression, hair and clothing swaying gently, shallow depth of field, subtle cinematic motion.
-  sampling:
-    height: 512
-    width: 768
-    num_frames: 121
-    fps: 24
-    guidance_scale: 1.0
-    num_inference_steps: 5
-  # i2v conditioning — replace the path with your own first-frame image.
-  extensions:
-    ltx2_images:
-      - ["/path/to/your/first_frame.jpg", 0, 1.0]
-    ltx2_image_crf: 0.0
-  output:
-    output_path: outputs/ltx2_3_i2v_5s2_512x768.mp4
-    save_video: true
@@ -1,38 +0,0 @@
-# LTX-2.3 distilled i2v — 5+2 two-stage at 768x1280.
-#
-# Run:
-#   fastvideo generate --config examples/inference/ltx2_3/i2v_5s2_768x1280.yaml
-#
-# Stage 1 denoises for 5 steps at half resolution; the latents are then
-# spatially upsampled and refined for 2 steps (refine only supports 2 or 3).
-# The refine upsampler auto-resolves from the model's `spatial_upscaler`.
-generator:
-  model_path: FastVideo/LTX-2.3-Distilled-Diffusers
-  engine:
-    num_gpus: 1
-  pipeline:
-    workload_type: i2v
-    preset_overrides:
-      refine:
-        enabled: true
-        num_inference_steps: 2
-        guidance_scale: 1.0
-        add_noise: true
-request:
-  prompt: >-
-    The subject slowly turns toward the camera with a soft, natural expression, hair and clothing swaying gently, shallow depth of field, subtle cinematic motion.
-  sampling:
-    height: 768
-    width: 1280
-    num_frames: 121
-    fps: 24
-    guidance_scale: 1.0
-    num_inference_steps: 5
-  # i2v conditioning — replace the path with your own first-frame image.
-  extensions:
-    ltx2_images:
-      - ["/path/to/your/first_frame.jpg", 0, 1.0]
-    ltx2_image_crf: 0.0
-  output:
-    output_path: outputs/ltx2_3_i2v_5s2_768x1280.mp4
-    save_video: true
@@ -1,38 +0,0 @@
-# LTX-2.3 distilled i2v — 8+3 two-stage at 1024x1536.
-#
-# Run:
-#   fastvideo generate --config examples/inference/ltx2_3/i2v_8s3_1024x1536.yaml
-#
-# Stage 1 denoises for 8 steps at half resolution; the latents are then
-# spatially upsampled and refined for 3 steps (refine only supports 2 or 3).
-# The refine upsampler auto-resolves from the model's `spatial_upscaler`.
-generator:
-  model_path: FastVideo/LTX-2.3-Distilled-Diffusers
-  engine:
-    num_gpus: 1
-  pipeline:
-    workload_type: i2v
-    preset_overrides:
-      refine:
-        enabled: true
-        num_inference_steps: 3
-        guidance_scale: 1.0
-        add_noise: true
-request:
-  prompt: >-
-    The subject slowly turns toward the camera with a soft, natural expression, hair and clothing swaying gently, shallow depth of field, subtle cinematic motion.
-  sampling:
-    height: 1024
-    width: 1536
-    num_frames: 121
-    fps: 24
-    guidance_scale: 1.0
-    num_inference_steps: 8
-  # i2v conditioning — replace the path with your own first-frame image.
-  extensions:
-    ltx2_images:
-      - ["/path/to/your/first_frame.jpg", 0, 1.0]
-    ltx2_image_crf: 0.0
-  output:
-    output_path: outputs/ltx2_3_i2v_8s3_1024x1536.mp4
-    save_video: true
@@ -1,38 +0,0 @@
-# LTX-2.3 distilled i2v — 8+3 two-stage at 1280x832.
-#
-# Run:
-#   fastvideo generate --config examples/inference/ltx2_3/i2v_8s3_1280x832.yaml
-#
-# Stage 1 denoises for 8 steps at half resolution; the latents are then
-# spatially upsampled and refined for 3 steps (refine only supports 2 or 3).
-# The refine upsampler auto-resolves from the model's `spatial_upscaler`.
-generator:
-  model_path: FastVideo/LTX-2.3-Distilled-Diffusers
-  engine:
-    num_gpus: 1
-  pipeline:
-    workload_type: i2v
-    preset_overrides:
-      refine:
-        enabled: true
-        num_inference_steps: 3
-        guidance_scale: 1.0
-        add_noise: true
-request:
-  prompt: >-
-    The subject slowly turns toward the camera with a soft, natural expression, hair and clothing swaying gently, shallow depth of field, subtle cinematic motion.
-  sampling:
-    height: 1280
-    width: 832
-    num_frames: 121
-    fps: 24
-    guidance_scale: 1.0
-    num_inference_steps: 8
-  # i2v conditioning — replace the path with your own first-frame image.
-  extensions:
-    ltx2_images:
-      - ["/path/to/your/first_frame.jpg", 0, 1.0]
-    ltx2_image_crf: 0.0
-  output:
-    output_path: outputs/ltx2_3_i2v_8s3_1280x832.mp4
-    save_video: true
@@ -1,38 +0,0 @@
-# LTX-2.3 distilled i2v — 8+3 two-stage at 512x768.
-#
-# Run:
-#   fastvideo generate --config examples/inference/ltx2_3/i2v_8s3_512x768.yaml
-#
-# Stage 1 denoises for 8 steps at half resolution; the latents are then
-# spatially upsampled and refined for 3 steps (refine only supports 2 or 3).
-# The refine upsampler auto-resolves from the model's `spatial_upscaler`.
-generator:
-  model_path: FastVideo/LTX-2.3-Distilled-Diffusers
-  engine:
-    num_gpus: 1
-  pipeline:
-    workload_type: i2v
-    preset_overrides:
-      refine:
-        enabled: true
-        num_inference_steps: 3
-        guidance_scale: 1.0
-        add_noise: true
-request:
-  prompt: >-
-    The subject slowly turns toward the camera with a soft, natural expression, hair and clothing swaying gently, shallow depth of field, subtle cinematic motion.
-  sampling:
-    height: 512
-    width: 768
-    num_frames: 121
-    fps: 24
-    guidance_scale: 1.0
-    num_inference_steps: 8
-  # i2v conditioning — replace the path with your own first-frame image.
-  extensions:
-    ltx2_images:
-      - ["/path/to/your/first_frame.jpg", 0, 1.0]
-    ltx2_image_crf: 0.0
-  output:
-    output_path: outputs/ltx2_3_i2v_8s3_512x768.mp4
-    save_video: true
@@ -1,38 +0,0 @@
-# LTX-2.3 distilled i2v — 8+3 two-stage at 768x1280.
-#
-# Run:
-#   fastvideo generate --config examples/inference/ltx2_3/i2v_8s3_768x1280.yaml
-#
-# Stage 1 denoises for 8 steps at half resolution; the latents are then
-# spatially upsampled and refined for 3 steps (refine only supports 2 or 3).
-# The refine upsampler auto-resolves from the model's `spatial_upscaler`.
-generator:
-  model_path: FastVideo/LTX-2.3-Distilled-Diffusers
-  engine:
-    num_gpus: 1
-  pipeline:
-    workload_type: i2v
-    preset_overrides:
-      refine:
-        enabled: true
-        num_inference_steps: 3
-        guidance_scale: 1.0
-        add_noise: true
-request:
-  prompt: >-
-    The subject slowly turns toward the camera with a soft, natural expression, hair and clothing swaying gently, shallow depth of field, subtle cinematic motion.
-  sampling:
-    height: 768
-    width: 1280
-    num_frames: 121
-    fps: 24
-    guidance_scale: 1.0
-    num_inference_steps: 8
-  # i2v conditioning — replace the path with your own first-frame image.
-  extensions:
-    ltx2_images:
-      - ["/path/to/your/first_frame.jpg", 0, 1.0]
-    ltx2_image_crf: 0.0
-  output:
-    output_path: outputs/ltx2_3_i2v_8s3_768x1280.mp4
-    save_video: true
@@ -1,33 +0,0 @@
-# LTX-2.3 distilled t2v — 5+2 two-stage at 1024x1536.
-#
-# Run:
-#   fastvideo generate --config examples/inference/ltx2_3/t2v_5s2_1024x1536.yaml
-#
-# Stage 1 denoises for 5 steps at half resolution; the latents are then
-# spatially upsampled and refined for 2 steps (refine only supports 2 or 3).
-# The refine upsampler auto-resolves from the model's `spatial_upscaler`.
-generator:
-  model_path: FastVideo/LTX-2.3-Distilled-Diffusers
-  engine:
-    num_gpus: 1
-  pipeline:
-    workload_type: t2v
-    preset_overrides:
-      refine:
-        enabled: true
-        num_inference_steps: 2
-        guidance_scale: 1.0
-        add_noise: true
-request:
-  prompt: >-
-    A cinematic drone shot flying over dramatic coastal cliffs at sunrise, golden light spilling across the water, gentle waves breaking on the rocks below, ultra-detailed, smooth camera motion.
-  sampling:
-    height: 1024
-    width: 1536
-    num_frames: 121
-    fps: 24
-    guidance_scale: 1.0
-    num_inference_steps: 5
-  output:
-    output_path: outputs/ltx2_3_t2v_5s2_1024x1536.mp4
-    save_video: true
@@ -1,33 +0,0 @@
-# LTX-2.3 distilled t2v — 5+2 two-stage at 1280x832.
-#
-# Run:
-#   fastvideo generate --config examples/inference/ltx2_3/t2v_5s2_1280x832.yaml
-#
-# Stage 1 denoises for 5 steps at half resolution; the latents are then
-# spatially upsampled and refined for 2 steps (refine only supports 2 or 3).
-# The refine upsampler auto-resolves from the model's `spatial_upscaler`.
-generator:
-  model_path: FastVideo/LTX-2.3-Distilled-Diffusers
-  engine:
-    num_gpus: 1
-  pipeline:
-    workload_type: t2v
-    preset_overrides:
-      refine:
-        enabled: true
-        num_inference_steps: 2
-        guidance_scale: 1.0
-        add_noise: true
-request:
-  prompt: >-
-    A cinematic drone shot flying over dramatic coastal cliffs at sunrise, golden light spilling across the water, gentle waves breaking on the rocks below, ultra-detailed, smooth camera motion.
-  sampling:
-    height: 1280
-    width: 832
-    num_frames: 121
-    fps: 24
-    guidance_scale: 1.0
-    num_inference_steps: 5
-  output:
-    output_path: outputs/ltx2_3_t2v_5s2_1280x832.mp4
-    save_video: true
@@ -1,33 +0,0 @@
-# LTX-2.3 distilled t2v — 5+2 two-stage at 512x768.
-#
-# Run:
-#   fastvideo generate --config examples/inference/ltx2_3/t2v_5s2_512x768.yaml
-#
-# Stage 1 denoises for 5 steps at half resolution; the latents are then
-# spatially upsampled and refined for 2 steps (refine only supports 2 or 3).
-# The refine upsampler auto-resolves from the model's `spatial_upscaler`.
-generator:
-  model_path: FastVideo/LTX-2.3-Distilled-Diffusers
-  engine:
-    num_gpus: 1
-  pipeline:
-    workload_type: t2v
-    preset_overrides:
-      refine:
-        enabled: true
-        num_inference_steps: 2
-        guidance_scale: 1.0
-        add_noise: true
-request:
-  prompt: >-
-    A cinematic drone shot flying over dramatic coastal cliffs at sunrise, golden light spilling across the water, gentle waves breaking on the rocks below, ultra-detailed, smooth camera motion.
-  sampling:
-    height: 512
-    width: 768
-    num_frames: 121
-    fps: 24
-    guidance_scale: 1.0
-    num_inference_steps: 5
-  output:
-    output_path: outputs/ltx2_3_t2v_5s2_512x768.mp4
-    save_video: true
@@ -1,33 +0,0 @@
-# LTX-2.3 distilled t2v — 5+2 two-stage at 768x1280.
-#
-# Run:
-#   fastvideo generate --config examples/inference/ltx2_3/t2v_5s2_768x1280.yaml
-#
-# Stage 1 denoises for 5 steps at half resolution; the latents are then
-# spatially upsampled and refined for 2 steps (refine only supports 2 or 3).
-# The refine upsampler auto-resolves from the model's `spatial_upscaler`.
-generator:
-  model_path: FastVideo/LTX-2.3-Distilled-Diffusers
-  engine:
-    num_gpus: 1
-  pipeline:
-    workload_type: t2v
-    preset_overrides:
-      refine:
-        enabled: true
-        num_inference_steps: 2
-        guidance_scale: 1.0
-        add_noise: true
-request:
-  prompt: >-
-    A cinematic drone shot flying over dramatic coastal cliffs at sunrise, golden light spilling across the water, gentle waves breaking on the rocks below, ultra-detailed, smooth camera motion.
-  sampling:
-    height: 768
-    width: 1280
-    num_frames: 121
-    fps: 24
-    guidance_scale: 1.0
-    num_inference_steps: 5
-  output:
-    output_path: outputs/ltx2_3_t2v_5s2_768x1280.mp4
-    save_video: true
@@ -1,33 +0,0 @@
-# LTX-2.3 distilled t2v — 8+3 two-stage at 1024x1536.
-#
-# Run:
-#   fastvideo generate --config examples/inference/ltx2_3/t2v_8s3_1024x1536.yaml
-#
-# Stage 1 denoises for 8 steps at half resolution; the latents are then
-# spatially upsampled and refined for 3 steps (refine only supports 2 or 3).
-# The refine upsampler auto-resolves from the model's `spatial_upscaler`.
-generator:
-  model_path: FastVideo/LTX-2.3-Distilled-Diffusers
-  engine:
-    num_gpus: 1
-  pipeline:
-    workload_type: t2v
-    preset_overrides:
-      refine:
-        enabled: true
-        num_inference_steps: 3
-        guidance_scale: 1.0
-        add_noise: true
-request:
-  prompt: >-
-    A cinematic drone shot flying over dramatic coastal cliffs at sunrise, golden light spilling across the water, gentle waves breaking on the rocks below, ultra-detailed, smooth camera motion.
-  sampling:
-    height: 1024
-    width: 1536
-    num_frames: 121
-    fps: 24
-    guidance_scale: 1.0
-    num_inference_steps: 8
-  output:
-    output_path: outputs/ltx2_3_t2v_8s3_1024x1536.mp4
-    save_video: true
@@ -1,33 +0,0 @@
-# LTX-2.3 distilled t2v — 8+3 two-stage at 1280x832.
-#
-# Run:
-#   fastvideo generate --config examples/inference/ltx2_3/t2v_8s3_1280x832.yaml
-#
-# Stage 1 denoises for 8 steps at half resolution; the latents are then
-# spatially upsampled and refined for 3 steps (refine only supports 2 or 3).
-# The refine upsampler auto-resolves from the model's `spatial_upscaler`.
-generator:
-  model_path: FastVideo/LTX-2.3-Distilled-Diffusers
-  engine:
-    num_gpus: 1
-  pipeline:
-    workload_type: t2v
-    preset_overrides:
-      refine:
-        enabled: true
-        num_inference_steps: 3
-        guidance_scale: 1.0
-        add_noise: true
-request:
-  prompt: >-
-    A cinematic drone shot flying over dramatic coastal cliffs at sunrise, golden light spilling across the water, gentle waves breaking on the rocks below, ultra-detailed, smooth camera motion.
-  sampling:
-    height: 1280
-    width: 832
-    num_frames: 121
-    fps: 24
-    guidance_scale: 1.0
-    num_inference_steps: 8
-  output:
-    output_path: outputs/ltx2_3_t2v_8s3_1280x832.mp4
-    save_video: true
@@ -1,33 +0,0 @@
-# LTX-2.3 distilled t2v — 8+3 two-stage at 512x768.
-#
-# Run:
-#   fastvideo generate --config examples/inference/ltx2_3/t2v_8s3_512x768.yaml
-#
-# Stage 1 denoises for 8 steps at half resolution; the latents are then
-# spatially upsampled and refined for 3 steps (refine only supports 2 or 3).
-# The refine upsampler auto-resolves from the model's `spatial_upscaler`.
-generator:
-  model_path: FastVideo/LTX-2.3-Distilled-Diffusers
-  engine:
-    num_gpus: 1
-  pipeline:
-    workload_type: t2v
-    preset_overrides:
-      refine:
-        enabled: true
-        num_inference_steps: 3
-        guidance_scale: 1.0
-        add_noise: true
-request:
-  prompt: >-
-    A cinematic drone shot flying over dramatic coastal cliffs at sunrise, golden light spilling across the water, gentle waves breaking on the rocks below, ultra-detailed, smooth camera motion.
-  sampling:
-    height: 512
-    width: 768
-    num_frames: 121
-    fps: 24
-    guidance_scale: 1.0
-    num_inference_steps: 8
-  output:
-    output_path: outputs/ltx2_3_t2v_8s3_512x768.mp4
-    save_video: true
@@ -1,33 +0,0 @@
-# LTX-2.3 distilled t2v — 8+3 two-stage at 768x1280.
-#
-# Run:
-#   fastvideo generate --config examples/inference/ltx2_3/t2v_8s3_768x1280.yaml
-#
-# Stage 1 denoises for 8 steps at half resolution; the latents are then
-# spatially upsampled and refined for 3 steps (refine only supports 2 or 3).
-# The refine upsampler auto-resolves from the model's `spatial_upscaler`.
-generator:
-  model_path: FastVideo/LTX-2.3-Distilled-Diffusers
-  engine:
-    num_gpus: 1
-  pipeline:
-    workload_type: t2v
-    preset_overrides:
-      refine:
-        enabled: true
-        num_inference_steps: 3
-        guidance_scale: 1.0
-        add_noise: true
-request:
-  prompt: >-
-    A cinematic drone shot flying over dramatic coastal cliffs at sunrise, golden light spilling across the water, gentle waves breaking on the rocks below, ultra-detailed, smooth camera motion.
-  sampling:
-    height: 768
-    width: 1280
-    num_frames: 121
-    fps: 24
-    guidance_scale: 1.0
-    num_inference_steps: 8
-  output:
-    output_path: outputs/ltx2_3_t2v_8s3_768x1280.mp4
-    save_video: true
@@ -100,6 +100,9 @@ callbacks:
    sampling_steps: [4]
    sampling_timesteps: [1000, 750, 500, 250]
    num_frames: 81
+    # Validation/inference uses standard CFG in both clean and Self-Forcing,
+    # so this directly matches Self-Forcing guidance_scale=3.0.
+    guidance_scale: 3.0

 pipeline:
  flow_shift: 5
@@ -1,119 +1,32 @@
 # World-Model: Matrix-Game 2.0 I2V

-Training scenarios for the Matrix-Game 2.0 I2V world model on Solaris (Minecraft)
-data and Zelda data, using the new YAML-driven trainer
-(`fastvideo/train/entrypoint/train.py`).
-
-## Solaris Configs
+Three training scenarios for the Matrix-Game 2.0 I2V world model on the
+new YAML-driven trainer (`fastvideo/train/entrypoint/train.py`).

 | Config | Method | Student | Notes |
 |---|---|---|---|
-| `solaris/finetune_i2v.yaml` | `FineTuneMethod` | `MatrixGame2Model` (bidirectional) | Multi-step SFT from `mg_bidirectional_Solaris`. |
-| `solaris/dfsft_causal_i2v.yaml` | `DiffusionForcingSFTMethod` | `MatrixGame2CausalModel` | Diffusion-Forcing SFT with chunkwise timesteps. |
-| `solaris/self_forcing_causal_i2v.yaml` | `SelfForcingMethod` | `MatrixGame2CausalModel` | Matrix-Game 2.0 DMD/Self-Forcing distillation; teacher = bidirectional, critic = bidirectional. |
-
-## Zelda Configs
-
-| Config | Method | Student | Notes |
-|---|---|---|---|
-| `zelda/finetune_i2v.yaml` | `FineTuneMethod` | `MatrixGame2Model` (bidirectional) | Zelda bidirectional I2V finetuning from `FastVideo/Matrix-Game-2.0-Base-Diffusers`. Uses 33-frame clips and Zelda validation with action overlays. |
-| `zelda/dfsft_causal_i2v.yaml` | `DiffusionForcingSFTMethod` | `MatrixGame2CausalModel` | Zelda causal Diffusion-Forcing SFT from `mignonjia/mg_bidirectional_zelda`. Uses the same Zelda data, resolution, optimizer, and validation defaults as the Zelda finetune config. |
-| `zelda/self_forcing_causal_i2v.yaml` | `SelfForcingMethod` | `MatrixGame2CausalModel` | Zelda DMD/Self-Forcing distillation; student init = `mignonjia/mg_causal_zelda`, teacher = bidirectional (`mignonjia/mg_bidirectional_zelda`), critic = bidirectional. |
-| `zelda/streaming_long_tuning_causal_i2v.yaml` | `StreamingLongTuningMethod` | `MatrixGame2CausalModel` | LongLive-style streaming long tuning from the 1k-step Zelda self-forcing checkpoint. |
-
-Zelda world-model distillation is a two-run workflow: first run
-`zelda/self_forcing_causal_i2v.yaml` to train or load the 1k-step
-self-forcing checkpoint (`mignonjia/mg_sf_distilled_zelda_1k_steps`), then run
-`zelda/streaming_long_tuning_causal_i2v.yaml` for the 3k-step streaming
-long-tuning stage. The long-tuning YAML starts from that 1k-step checkpoint; it
-does not run the short self-forcing stage inside the same config.
-
-## Zelda Training Data
-
-The Zelda training configs use `data/zeldam2-clean` as a suggested local path.
-Download the dataset from Hugging Face before running those configs:
-
-```bash
-python scripts/huggingface/download_hf.py \
-    --repo_id mignonjia/zeldam2-clean \
-    --local_dir data/zeldam2-clean \
-    --repo_type dataset
-```
-
-You can store the dataset elsewhere; update `training.data.data_path` in the
-YAML to point at that location.
-
-## Multi3D Training Data
-
-`zelda/finetune_i2v.yaml` includes an optional, commented-out Multi3D entry.
-Enable it only when you want to mix Zelda with multi-game data from
-`data/multi3d_games`. You can store this dataset anywhere; before enabling it,
-update the matching commented `training.data.data_path` key in the YAML to the
-correct location.
-
-To mix datasets in a training YAML, set `training.data.data_path` to a
-path-to-repeat-count mapping. For example, `zelda/finetune_i2v.yaml` can use
-`data/zeldam2-clean: 1` and `# data/multi3d_games: 10`; uncommenting the
-Multi3D entry repeats the multi-game parquet list ten times before training
-samples are shuffled.
-
-## World Model Validation Data
-
-The Zelda validation configs expect a small public validation bundle under
-`data/zelda_validation_data`.
-
-Download it from Hugging Face before running the Zelda scenarios:
-
-```bash
-python scripts/huggingface/download_hf.py \
-    --repo_id mignonjia/zelda_validation_data \
-    --local_dir data/zelda_validation_data \
-    --repo_type dataset
-```
-
-The bundle contains `validation_zelda.json`, `images/`, and `actions/`.
-The Zelda configs point
-`callbacks.validation.dataset_file` at
-`data/zelda_validation_data/validation_zelda.json`.
+| `finetune_i2v.yaml` | `FineTuneMethod` | `MatrixGame2Model` (bidirectional) | Multi-step SFT from `mg_bidirectional_Solaris`. |
+| `dfsft_causal_i2v.yaml` | `DiffusionForcingSFTMethod` | `MatrixGame2CausalModel` | Diffusion-Forcing SFT with chunkwise timesteps. |
+| `self_forcing_causal_i2v.yaml` | `SelfForcingMethod` | `MatrixGame2CausalModel` | DMD/Self-Forcing distillation; teacher = bidirectional, critic = bidirectional. |

 ## Usage

-### Solaris
-
 ```bash
 bash examples/train/run.sh \
-    examples/train/scenario/worldmodel/solaris/finetune_i2v.yaml
+    examples/train/scenario/worldmodel/finetune_i2v.yaml

 bash examples/train/run.sh \
-    examples/train/scenario/worldmodel/solaris/dfsft_causal_i2v.yaml
+    examples/train/scenario/worldmodel/dfsft_causal_i2v.yaml

 bash examples/train/run.sh \
-    examples/train/scenario/worldmodel/solaris/self_forcing_causal_i2v.yaml
-```
-
-### Zelda
-
-```bash
-# Finetuning / DFSFT
-bash examples/train/run.sh \
-    examples/train/scenario/worldmodel/zelda/finetune_i2v.yaml
-
-bash examples/train/run.sh \
-    examples/train/scenario/worldmodel/zelda/dfsft_causal_i2v.yaml
-
-# Distillation / long tuning
-bash examples/train/run.sh \
-    examples/train/scenario/worldmodel/zelda/self_forcing_causal_i2v.yaml
-
-bash examples/train/run.sh \
-    examples/train/scenario/worldmodel/zelda/streaming_long_tuning_causal_i2v.yaml
+    examples/train/scenario/worldmodel/self_forcing_causal_i2v.yaml
 ```

 Override any field on the command line:

 ```bash
 bash examples/train/run.sh \
-    examples/train/scenario/worldmodel/solaris/dfsft_causal_i2v.yaml \
+    examples/train/scenario/worldmodel/dfsft_causal_i2v.yaml \
    --training.distributed.num_gpus 8 \
    --training.optimizer.learning_rate 1e-5
 ```
@@ -97,4 +97,4 @@ callbacks:
    guidance_scale: 6.0

 pipeline:
-  flow_shift: 5
+  flow_shift: 5
@@ -1,94 +0,0 @@
-# Diffusion-Forcing SFT: Zelda world model I2V Causal
-
-models:
-  student:
-    _target_: fastvideo.train.models.matrixgame2.matrixgame2_causal.MatrixGame2CausalModel
-    init_from: mignonjia/mg_bidirectional_zelda
-    trainable: true
-
-method:
-  _target_: fastvideo.train.methods.fine_tuning.dfsft.DiffusionForcingSFTMethod
-  chunk_size: 3
-
-training:
-  distributed:
-    num_gpus: 8
-    sp_size: 1
-    tp_size: 1
-    hsdp_replicate_dim: 1
-    hsdp_shard_dim: 8
-
-  data:
-    data_path:
-      data/zeldam2-clean: 1
-    dataloader_num_workers: 1
-    train_batch_size: 1
-    training_cfg_rate: 0.0
-    seed: 42
-    num_latent_t: 9
-    num_height: 480
-    num_width: 832
-    num_frames: 33
-
-  optimizer:
-    learning_rate: 2.0e-5
-    betas: [0.9, 0.95]
-    weight_decay: 0.0
-    lr_scheduler: constant
-    lr_warmup_steps: 0
-
-  loop:
-    max_train_steps: 60000
-    gradient_accumulation_steps: 1
-
-  checkpoint:
-    output_dir: outputs/matrixgame_finetune/checkpoints/zelda_causal_dfsft
-    training_state_checkpointing_steps: 5000
-    checkpoints_total_limit: 3
-
-  tracker:
-    entity: hapo-exp
-    project_name: mg_1.3b_zelda
-    run_name: zelda_causal_dfsft
-
-  model:
-    enable_gradient_checkpointing_type: full
-
-  dit_precision: fp32
-
-callbacks:
-  grad_clip:
-    max_grad_norm: 1.0
-  validation:
-    pipeline_target: fastvideo.pipelines.basic.matrixgame2.matrixgame2_causal_dmd_pipeline.MatrixGame2CausalDMDPipeline
-    dataset_file: data/zelda_validation_data/validation_zelda.json
-    every_steps: 200
-    sampling_steps: [40]
-    sampling_timesteps: [1000, 975, 950, 925, 900, 875, 850, 825, 800, 775,
-                         750, 725, 700, 675, 650, 625, 600, 575, 550, 525,
-                         500, 475, 450, 425, 400, 375, 350, 325, 300, 275,
-                         250, 225, 200, 175, 150, 125, 100, 75, 50, 25]
-    num_frames: 33
-    overlay_actions: true
-    guidance_scale: 6.0
-    metrics:
-      enabled: true
-      names:
-        - vbench.imaging_quality
-        - vbench.aesthetic_quality
-        - vbench.temporal_flickering
-        - vbench.motion_smoothness
-        - vbench.subject_consistency
-        - vbench.background_consistency
-        - vbench.dynamic_degree
-        - optical_flow.synthetic_optical_flow
-      calibration_path: assets/eval/worldmodel_synthetic_flow_calibration.json
-      skip_missing_deps: true
-      strict: false
-      unload_after_validation: true
-
-pipeline:
-  flow_shift: 5
-  dit_config:
-    local_attn_size: 6
-    sink_size: 1
@@ -1,88 +0,0 @@
-# Matrix-Game 2.0 Zelda + multi-game I2V finetune.
-
-models:
-  student:
-    _target_: fastvideo.train.models.matrixgame2.matrixgame2.MatrixGame2Model
-    init_from: FastVideo/Matrix-Game-2.0-Base-Diffusers
-    trainable: true
-
-method:
-  _target_: fastvideo.train.methods.fine_tuning.finetune.FineTuneMethod
-
-training:
-  distributed:
-    num_gpus: 8
-    sp_size: 1
-    tp_size: 1
-    hsdp_replicate_dim: 1
-    hsdp_shard_dim: 8
-
-  data:
-    data_path:
-      data/zeldam2-clean: 1
-      # data/multi3d_games: 10
-    dataloader_num_workers: 1
-    train_batch_size: 1
-    training_cfg_rate: 0.0  # unused for MatrixGame2 I2V; no text_embedding CFG dropout
-    seed: 42
-    num_latent_t: 9
-    num_height: 480
-    num_width: 832
-    num_frames: 33
-
-  optimizer:
-    learning_rate: 2.0e-5
-    betas: [0.9, 0.95]
-    weight_decay: 0.0
-    lr_scheduler: constant
-    lr_warmup_steps: 0
-
-  loop:
-    max_train_steps: 60000
-    gradient_accumulation_steps: 1
-
-  checkpoint:
-    output_dir: outputs/matrixgame_finetune/checkpoints/zelda_with_mg_init
-    training_state_checkpointing_steps: 5000
-    checkpoints_total_limit: 3
-
-  tracker:
-    project_name: mg_1.3b_zelda
-    run_name: zelda_with_mg_init
-
-  model:
-    enable_gradient_checkpointing_type: full
-
-  dit_precision: fp32
-
-callbacks:
-  grad_clip:
-    _target_: fastvideo.train.callbacks.grad_clip.GradNormClipCallback
-    max_grad_norm: 1.0
-  validation:
-    _target_: fastvideo.train.callbacks.validation.ValidationCallback
-    pipeline_target: fastvideo.pipelines.basic.matrixgame2.matrixgame2_i2v_pipeline.MatrixGame2I2VPipeline
-    dataset_file: data/zelda_validation_data/validation_zelda.json
-    every_steps: 200
-    sampling_steps: [40]
-    num_frames: 33
-    overlay_actions: true
-    guidance_scale: 6.0
-    metrics:
-      enabled: true
-      names:
-        - vbench.imaging_quality
-        - vbench.aesthetic_quality
-        - vbench.temporal_flickering
-        - vbench.motion_smoothness
-        - vbench.subject_consistency
-        - vbench.background_consistency
-        - vbench.dynamic_degree
-        - optical_flow.synthetic_optical_flow
-      calibration_path: assets/eval/worldmodel_synthetic_flow_calibration.json
-      skip_missing_deps: true
-      strict: false
-      unload_after_validation: true
-
-pipeline:
-  flow_shift: 5
@@ -1,120 +0,0 @@
-# Self-forcing distillation: Zelda world model I2V Causal
-
-models:
-  student:
-    _target_: fastvideo.train.models.matrixgame2.matrixgame2_causal.MatrixGame2CausalModel
-    init_from: mignonjia/mg_causal_zelda
-    trainable: true
-  teacher:
-    _target_: fastvideo.train.models.matrixgame2.matrixgame2.MatrixGame2Model
-    init_from: mignonjia/mg_bidirectional_zelda
-    trainable: false
-    disable_custom_init_weights: true
-  critic:
-    _target_: fastvideo.train.models.matrixgame2.matrixgame2.MatrixGame2Model
-    init_from: mignonjia/mg_bidirectional_zelda
-    trainable: true
-    disable_custom_init_weights: true
-
-method:
-  _target_: fastvideo.train.methods.distribution_matching.self_forcing.SelfForcingMethod
-  rollout_mode: simulate
-  generator_update_interval: 5
-  dmd_denoising_steps: [1000, 750, 500, 250]
-  warp_denoising_step: true
-  min_timestep_ratio: 0.02
-  max_timestep_ratio: 0.98
-
-  chunk_size: 3
-  student_sample_type: sde
-  same_step_across_blocks: true
-  last_step_only: false
-  context_noise: 0.0
-  enable_gradient_in_rollout: true
-  start_gradient_frame: 0
-
-  # Critic optimizer
-  fake_score_learning_rate: 3.0e-7
-  fake_score_betas: [0.9, 0.95]
-  fake_score_lr_scheduler: constant
-
-training:
-  distributed:
-    num_gpus: 8
-    sp_size: 1
-    tp_size: 1
-    hsdp_replicate_dim: 1
-    hsdp_shard_dim: 8
-
-  data:
-    data_path: data/zeldam2-clean
-    dataloader_num_workers: 4
-    train_batch_size: 1
-    training_cfg_rate: 0.0
-    seed: 1001
-    num_latent_t: 9
-    num_height: 480
-    num_width: 832
-    num_frames: 33
-
-  optimizer:
-    learning_rate: 3.0e-6
-    betas: [0.9, 0.95]
-    weight_decay: 0.0
-    lr_scheduler: constant
-    lr_warmup_steps: 0
-
-  loop:
-    max_train_steps: 1000
-    gradient_accumulation_steps: 1
-
-  checkpoint:
-    output_dir: outputs/zelda_causal_self_forcing
-    training_state_checkpointing_steps: 1000
-    checkpoints_total_limit: 1
-
-  tracker:
-    project_name: wangame_sf
-    run_name: mg2_self_forcing_9_latents
-
-  model:
-    enable_gradient_checkpointing_type: full
-
-  dit_precision: fp32
-
-callbacks:
-  ema:
-    decay: 0.99
-    start_iter: 200
-  grad_clip:
-    max_grad_norm: 1.0
-  validation:
-    pipeline_target: fastvideo.pipelines.basic.matrixgame2.matrixgame2_causal_dmd_pipeline.MatrixGame2CausalDMDPipeline
-    dataset_file: data/zelda_validation_data/validation_zelda.json
-    every_steps: 100
-    sampling_steps: [4]
-    sampling_timesteps: [1000, 750, 500, 250]
-    num_frames: 153
-    overlay_actions: true
-    keyboard_value_scale: 1.0
-    metrics:
-      enabled: true
-      names:
-        - vbench.imaging_quality
-        - vbench.aesthetic_quality
-        - vbench.temporal_flickering
-        - vbench.motion_smoothness
-        - vbench.subject_consistency
-        - vbench.background_consistency
-        - vbench.dynamic_degree
-        - optical_flow.synthetic_optical_flow
-      calibration_path: assets/eval/worldmodel_synthetic_flow_calibration.json
-      skip_missing_deps: true
-      strict: false
-      unload_after_validation: true
-
-pipeline:
-  flow_shift: 5
-  dit_config:
-    local_attn_size: 6
-    sink_size: 1
@@ -1,140 +0,0 @@
-# MatrixGame2 I2V LongLive-style streaming distillation: Zelda world model I2V Causal
-# Student init from self forcing after 1k steps
-
-models:
-  student:
-    _target_: fastvideo.train.models.matrixgame2.matrixgame2_causal.MatrixGame2CausalModel
-    init_from: mignonjia/mg_sf_distilled_zelda_1k_steps 
-    trainable: true
-    # transformer_override_safetensor: outputs/matrixgame_dmd/checkpoints/mg_zelda_sf_m2/checkpoint-1000_weight_only/ema/generator_ema.safetensors
-  teacher:
-    _target_: fastvideo.train.models.matrixgame2.matrixgame2.MatrixGame2Model
-    init_from: mignonjia/mg_bidirectional_zelda
-    trainable: false
-    disable_custom_init_weights: true
-  critic:
-    _target_: fastvideo.train.models.matrixgame2.matrixgame2.MatrixGame2Model
-    init_from: mignonjia/mg_bidirectional_zelda
-    trainable: true
-    disable_custom_init_weights: true
-
-method:
-  _target_: fastvideo.train.methods.distribution_matching.streaming_long_tuning.StreamingLongTuningMethod
-  rollout_mode: simulate
-  generator_update_interval: 5
-  dmd_denoising_steps: [1000, 750, 500, 250]
-  warp_denoising_step: true
-  min_timestep_ratio: 0.02
-  max_timestep_ratio: 0.98
-
-  chunk_size: 3
-  student_sample_type: sde
-  same_step_across_blocks: true
-  last_step_only: false
-  context_noise: 0.0
-  enable_gradient_in_rollout: true
-  start_gradient_frame: 0
-
-  streaming_training: true
-  streaming_chunk_size: 9
-  streaming_max_length: 39
-  streaming_fixed_overlap_latents: 3
-  streaming_reencode_overlap_anchor: true
-  streaming_anchor_inject_k: 1
-  streaming_require_full_blocks: true
-
-  multi_phased_distill_schedule:
-    - stage: streaming_long
-      start_step: 0
-      end_step: 3000
-      num_latent_t: 39
-      streaming_training: true
-      streaming_chunk_size: 9
-      streaming_max_length: 39
-      streaming_fixed_overlap_latents: 3
-
-  # Critic optimizer
-  fake_score_learning_rate: 3.0e-7
-  fake_score_betas: [0.9, 0.95]
-  fake_score_lr_scheduler: constant
-
-training:
-  distributed:
-    num_gpus: 8
-    sp_size: 1
-    tp_size: 1
-    hsdp_replicate_dim: 1
-    hsdp_shard_dim: 8
-
-  data:
-    data_path: data/zeldam2-clean
-    dataloader_num_workers: 4
-    train_batch_size: 1
-    training_cfg_rate: 0.0
-    seed: 1001
-    num_latent_t: 39
-    num_height: 480
-    num_width: 832
-    num_frames: 153
-
-  optimizer:
-    learning_rate: 3.0e-6
-    betas: [0.9, 0.95]
-    weight_decay: 0.0
-    lr_scheduler: constant
-    lr_warmup_steps: 0
-
-  loop:
-    max_train_steps: 3000
-    gradient_accumulation_steps: 1
-
-  checkpoint:
-    output_dir: outputs/zelda_causal_long_tuning
-    training_state_checkpointing_steps: 1000
-    checkpoints_total_limit: 2
-
-  tracker:
-    project_name: wangame_sf
-    run_name: mg2_39only_streaming_long
-
-  model:
-    enable_gradient_checkpointing_type: full
-
-  dit_precision: fp32
-
-callbacks:
-  ema:
-    decay: 0.99
-    start_iter: 200
-  grad_clip:
-    max_grad_norm: 1.0
-  validation:
-    pipeline_target: fastvideo.pipelines.basic.matrixgame2.matrixgame2_causal_dmd_pipeline.MatrixGame2CausalDMDPipeline
-    dataset_file: data/zelda_validation_data/validation_zelda.json
-    every_steps: 100
-    sampling_steps: [4]
-    sampling_timesteps: [1000, 750, 500, 250]
-    num_frames: 153
-    overlay_actions: true
-    keyboard_value_scale: 1.0
-    metrics:
-      enabled: true
-      names:
-        - vbench.imaging_quality
-        - vbench.aesthetic_quality
-        - vbench.temporal_flickering
-        - vbench.motion_smoothness
-        - vbench.subject_consistency
-        - vbench.background_consistency
-        - vbench.dynamic_degree
-        - optical_flow.synthetic_optical_flow
-      calibration_path: assets/eval/worldmodel_synthetic_flow_calibration.json
-      skip_missing_deps: true
-      strict: false
-      unload_after_validation: true
-
-pipeline:
-  flow_shift: 5
-  dit_config:
-    local_attn_size: 6
-    sink_size: 1
@@ -1,37 +0,0 @@
---
-license: apache-2.0
---
-
-# FastVideo Kernel
-
-Hub-compatible FastVideo CUDA kernels packaged with Hugging Face `kernel-builder`.
-
-## Usage
-
-```python
-from kernels import get_kernel
-
-fastvideo_kernel = get_kernel("hao-ai-lab/fastvideo-kernel", version=1)
-```
-
-The module exposes:
-
- `sta_fwd`
- `block_sparse_fwd`
- `block_sparse_bwd`
- `rms_norm`
- `layer_norm`
- `int8_quant`
- `int8_gemm`
-
-These APIs are thin wrappers around the native FastVideo kernels. Higher-level
-fallback logic remains in the regular `fastvideo-kernel` Python package.
-
-## Requirements
-
-This first Hub build targets CUDA Hopper (`sm_90a`) because the native attention
-kernels rely on Hopper/ThunderKittens features.
-
-## Source
-
-Source repository: https://github.com/hao-ai-lab/FastVideo/tree/main/fastvideo-kernel
@@ -40,25 +40,6 @@ Notes:

 ## Installation

-### Hugging Face Kernel Hub
-
-FastVideo kernels are built and published with the Hugging Face
-[`kernels`](https://huggingface.co/docs/kernels/index) project. Downstream code
-loads the precompiled kernels from
-[`hao-ai-lab/fastvideo-kernel`](https://huggingface.co/hao-ai-lab/fastvideo-kernel)
-without building locally:
-
-```python
-from kernels import get_kernel
-
-fastvideo_kernel = get_kernel("hao-ai-lab/fastvideo-kernel", version=1)
-```
-
-The Hub package exposes the native CUDA entrypoints (`sta_fwd`,
-`block_sparse_fwd`, `block_sparse_bwd`, `rms_norm`, `layer_norm`, `int8_quant`,
-and `int8_gemm`). The full FastVideo Python package still provides the
-high-level fallback logic used during local development.
-
 ### Standard Installation (Local Development)
 This will automatically detect your GPU architecture. If an NVIDIA Hopper (H100/sm_90a) GPU is detected, ThunderKittens kernels will be enabled. Otherwise, they will be skipped, and the package will use Triton fallbacks at runtime.

@@ -1,52 +0,0 @@
-[general]
-name = "fastvideo_kernel"
-version = 1
-license = "Apache-2.0"
-backends = ["cuda"]
-upstream = "https://github.com/hao-ai-lab/FastVideo.git"
-source = "https://github.com/hao-ai-lab/FastVideo.git"
-
-[general.hub]
-repo-id = "hao-ai-lab/fastvideo-kernel"
-
-[torch]
-src = [
-  "torch-ext/torch_binding.cpp",
-  "torch-ext/torch_binding.h",
-]
-
-[kernel.fastvideo_kernel]
-backend = "cuda"
-depends = ["torch"]
-include = [
-  "csrc",
-  "csrc/turbodiffusion",
-  "include/cutlass/include",
-  "include/tk/include",
-  "include/tk/prototype",
-]
-src = [
-  "csrc/attention/st_attn_h100.cu",
-  "csrc/attention/block_sparse_h100.cu",
-  "csrc/turbodiffusion/gemm/gemm.cu",
-  "csrc/turbodiffusion/norm/rmsnorm.cu",
-  "csrc/turbodiffusion/norm/layernorm.cu",
-  "csrc/turbodiffusion/quant/quant.cu",
-]
-# Deliberately Hopper-only (sm_90a): the TK attention kernels here require
-# Hopper, unlike the multi-arch PyPI wheels (see .github/workflows/publish-kernel.yml).
-cuda-capabilities = ["9.0a"]
-cuda-flags = [
-  "-DNDEBUG",
-  "-O3",
-  "-std=c++20",
-  "--use_fast_math",
-  "--expt-extended-lambda",
-  "--expt-relaxed-constexpr",
-  "-Xcompiler=-fno-strict-aliasing",
-  "-Xcompiler=-fPIC",
-  "-DTORCH_COMPILE",
-  "-DKITTENS_HOPPER",
-  "-DFASTVIDEO_KERNEL_DISABLE_PYBIND_REGISTRATION",
-  "-Xptxas=--warn-on-spills",
-]
@@ -71,12 +71,11 @@ void int8_gemm(

 }

-#ifndef FASTVIDEO_KERNEL_DISABLE_PYBIND_REGISTRATION
 void register_gemm(pybind11::module_ &m) {
    m.def("gemm_cuda", &int8_gemm);
 }
-#endif


  

+
@@ -9,10 +9,10 @@
 #include "norm/layernorm.hpp"

 auto layer_norm(
-  at::Tensor const Input,
+  at::Tensor const Input, 
  float eps,
-  std::optional<at::Tensor> W,
-  std::optional<at::Tensor> const B,
+  std::optional<at::Tensor const> W,
+  std::optional<at::Tensor const> const B,
  std::optional<at::Tensor> Output
 ) {
  int64_t const m = Input.size(0);
@@ -93,8 +93,7 @@ auto layer_norm(
  return Output;
 }

-#ifndef FASTVIDEO_KERNEL_DISABLE_PYBIND_REGISTRATION
 void register_layer_norm(pybind11::module_ &m) {
    m.def("layer_norm_cuda", &layer_norm);
 }
-#endif
+
@@ -75,8 +75,6 @@ auto rms_norm(
  return Output;
 }

-#ifndef FASTVIDEO_KERNEL_DISABLE_PYBIND_REGISTRATION
 void register_rms_norm(pybind11::module_ &m) {
    m.def("rms_norm_cuda", &rms_norm);
 }
-#endif
@@ -70,8 +70,6 @@ auto quant(
  return std::make_tuple(Output, Output_S);
 }

-#ifndef FASTVIDEO_KERNEL_DISABLE_PYBIND_REGISTRATION
 void register_quant(pybind11::module_ &m) {
    m.def("quant_cuda", &quant);
 }
-#endif
@@ -1,11 +0,0 @@
-import torch
-from kernels import get_kernel
-
-
-fastvideo_kernel = get_kernel("hao-ai-lab/fastvideo-kernel", version=1)
-
-x = torch.randn((16, 1024), device="cuda", dtype=torch.float16)
-weight = torch.ones((1024,), device="cuda", dtype=torch.float16)
-y = fastvideo_kernel.rms_norm(x, 1e-6, weight)
-
-print(y.shape)
@@ -1,18 +0,0 @@
-{
-  description = "Flake for FastVideo Kernel Hub builds";
-
-  inputs = {
-    self.submodules = true;
-    kernel-builder.url = "github:huggingface/kernels";
-  };
-
-  outputs =
-    {
-      self,
-      kernel-builder,
-    }:
-    kernel-builder.lib.genKernelFlakeOutputs {
-      inherit self;
-      path = ./.;
-    };
-}
@@ -1,122 +0,0 @@
-from typing import Optional
-
-import torch
-
-from ._ops import ops
-
-
-def sta_fwd(
-    q: torch.Tensor,
-    k: torch.Tensor,
-    v: torch.Tensor,
-    out: torch.Tensor,
-    kernel_t_size: int,
-    kernel_h_size: int,
-    kernel_w_size: int,
-    text_length: int,
-    process_text: bool,
-    has_text: bool,
-    kernel_aspect_ratio_flag: int,
-) -> torch.Tensor:
-    return ops.sta_fwd(
-        q,
-        k,
-        v,
-        out,
-        kernel_t_size,
-        kernel_h_size,
-        kernel_w_size,
-        text_length,
-        process_text,
-        has_text,
-        kernel_aspect_ratio_flag,
-    )
-
-
-def block_sparse_fwd(
-    q: torch.Tensor,
-    k: torch.Tensor,
-    v: torch.Tensor,
-    q2k_block_sparse_index: torch.Tensor,
-    q2k_block_sparse_num: torch.Tensor,
-    kv_block_size: torch.Tensor,
-) -> tuple[torch.Tensor, torch.Tensor]:
-    out, lse = ops.block_sparse_fwd(
-        q,
-        k,
-        v,
-        q2k_block_sparse_index,
-        q2k_block_sparse_num,
-        kv_block_size,
-    )
-    return out, lse
-
-
-def block_sparse_bwd(
-    q: torch.Tensor,
-    k: torch.Tensor,
-    v: torch.Tensor,
-    out: torch.Tensor,
-    l_vec: torch.Tensor,
-    out_grad: torch.Tensor,
-    k2q_block_sparse_index: torch.Tensor,
-    k2q_block_sparse_num: torch.Tensor,
-    kv_block_size: torch.Tensor,
-) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
-    q_grad, k_grad, v_grad = ops.block_sparse_bwd(
-        q,
-        k,
-        v,
-        out,
-        l_vec,
-        out_grad,
-        k2q_block_sparse_index,
-        k2q_block_sparse_num,
-        kv_block_size,
-    )
-    return q_grad, k_grad, v_grad
-
-
-def rms_norm(
-    input: torch.Tensor,
-    eps: float,
-    weight: Optional[torch.Tensor] = None,
-    output: Optional[torch.Tensor] = None,
-) -> torch.Tensor:
-    return ops.rms_norm_cuda(input, eps, weight, output)
-
-
-def layer_norm(
-    input: torch.Tensor,
-    eps: float,
-    weight: Optional[torch.Tensor] = None,
-    bias: Optional[torch.Tensor] = None,
-    output: Optional[torch.Tensor] = None,
-) -> torch.Tensor:
-    return ops.layer_norm_cuda(input, eps, weight, bias, output)
-
-
-def int8_quant(input: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]:
-    quantized, scale = ops.quant_cuda(input)
-    return quantized, scale
-
-
-def int8_gemm(
-    a: torch.Tensor,
-    a_scale: torch.Tensor,
-    b: torch.Tensor,
-    b_scale: torch.Tensor,
-    out: torch.Tensor,
-) -> torch.Tensor:
-    return ops.gemm_cuda(a, a_scale, b, b_scale, out)
-
-
-__all__ = [
-    "sta_fwd",
-    "block_sparse_fwd",
-    "block_sparse_bwd",
-    "rms_norm",
-    "layer_norm",
-    "int8_quant",
-    "int8_gemm",
-]
@@ -1,99 +0,0 @@
-#include <torch/library.h>
-
-#include "registration.h"
-#include "torch_binding.h"
-
-torch::Tensor rms_norm_cuda(
-    torch::Tensor const& input,
-    double eps,
-    std::optional<torch::Tensor> const& weight,
-    std::optional<torch::Tensor> const& output) {
-  std::optional<at::Tensor> mutable_output = output;
-  auto result = rms_norm(input, static_cast<float>(eps), weight, mutable_output);
-  TORCH_CHECK(result.has_value(), "rms_norm_cuda did not produce an output tensor");
-  return result.value();
-}
-
-torch::Tensor layer_norm_cuda(
-    torch::Tensor const& input,
-    double eps,
-    std::optional<torch::Tensor> const& weight,
-    std::optional<torch::Tensor> const& bias,
-    std::optional<torch::Tensor> const& output) {
-  auto result = layer_norm(input, static_cast<float>(eps), weight, bias, output);
-  TORCH_CHECK(result.has_value(), "layer_norm_cuda did not produce an output tensor");
-  return result.value();
-}
-
-std::tuple<torch::Tensor, torch::Tensor> quant_cuda(torch::Tensor const& input) {
-  std::optional<torch::Tensor> output;
-  std::optional<torch::Tensor> output_scale;
-  auto result = quant(input, output, output_scale);
-  TORCH_CHECK(std::get<0>(result).has_value(), "quant_cuda did not produce an int8 tensor");
-  TORCH_CHECK(std::get<1>(result).has_value(), "quant_cuda did not produce a scale tensor");
-  return std::make_tuple(std::get<0>(result).value(), std::get<1>(result).value());
-}
-
-torch::Tensor gemm_cuda(
-    torch::Tensor const& a,
-    torch::Tensor const& a_scale,
-    torch::Tensor const& b,
-    torch::Tensor const& b_scale,
-    torch::Tensor c) {
-  int8_gemm(a, a_scale, b, b_scale, c);
-  return c;
-}
-
-TORCH_LIBRARY_EXPAND(TORCH_EXTENSION_NAME, ops) {
-  ops.def(
-      // `out` is written in place and returned, so the return must be declared
-      // as the same alias set — otherwise torch.compile can reorder/eliminate
-      // the mutation and silently produce wrong results.
-      "sta_fwd(Tensor q, Tensor k, Tensor v, Tensor(a!) out, int kernel_t_size, int kernel_h_size, "
-      "int kernel_w_size, int text_length, bool process_text, bool has_text, "
-      "int kernel_aspect_ratio_flag) -> Tensor(a!)");
-#if defined(CUDA_KERNEL)
-  ops.impl("sta_fwd", torch::kCUDA, &sta_forward);
-#endif
-
-  ops.def(
-      "block_sparse_fwd(Tensor q, Tensor k, Tensor v, Tensor q2k_block_sparse_index, "
-      "Tensor q2k_block_sparse_num, Tensor kv_block_size) -> Tensor[]");
-#if defined(CUDA_KERNEL)
-  ops.impl("block_sparse_fwd", torch::kCUDA, &block_sparse_attention_forward);
-#endif
-
-  ops.def(
-      "block_sparse_bwd(Tensor q, Tensor k, Tensor v, Tensor out, Tensor l_vec, Tensor out_grad, "
-      "Tensor k2q_block_sparse_index, Tensor k2q_block_sparse_num, Tensor kv_block_size) -> Tensor[]");
-#if defined(CUDA_KERNEL)
-  ops.impl("block_sparse_bwd", torch::kCUDA, &block_sparse_attention_backward);
-#endif
-
-  // When `output` is provided it is written in place and aliased by the
-  // return value; the schema must say so for torch.compile correctness.
-  ops.def("rms_norm_cuda(Tensor input, float eps, Tensor? weight=None, Tensor(a!)? output=None) -> Tensor(a!)");
-#if defined(CUDA_KERNEL)
-  ops.impl("rms_norm_cuda", torch::kCUDA, &rms_norm_cuda);
-#endif
-
-  ops.def(
-      "layer_norm_cuda(Tensor input, float eps, Tensor? weight=None, Tensor? bias=None, "
-      "Tensor(a!)? output=None) -> Tensor(a!)");
-#if defined(CUDA_KERNEL)
-  ops.impl("layer_norm_cuda", torch::kCUDA, &layer_norm_cuda);
-#endif
-
-  ops.def("quant_cuda(Tensor input) -> (Tensor, Tensor)");
-#if defined(CUDA_KERNEL)
-  ops.impl("quant_cuda", torch::kCUDA, &quant_cuda);
-#endif
-
-  // `c` is the accumulator written in place and returned (same alias set).
-  ops.def("gemm_cuda(Tensor a, Tensor a_scale, Tensor b, Tensor b_scale, Tensor(a!) c) -> Tensor(a!)");
-#if defined(CUDA_KERNEL)
-  ops.impl("gemm_cuda", torch::kCUDA, &gemm_cuda);
-#endif
-}
-
-REGISTER_EXTENSION(TORCH_EXTENSION_NAME)
@@ -1,86 +0,0 @@
-#pragma once
-
-#include <optional>
-#include <tuple>
-#include <vector>
-
-#include <torch/torch.h>
-
-torch::Tensor sta_forward(
-    torch::Tensor q,
-    torch::Tensor k,
-    torch::Tensor v,
-    torch::Tensor o,
-    int kernel_t_size,
-    int kernel_h_size,
-    int kernel_w_size,
-    int text_length,
-    bool process_text,
-    bool has_text,
-    int kernel_aspect_ratio_flag);
-
-std::vector<torch::Tensor> block_sparse_attention_forward(
-    torch::Tensor q,
-    torch::Tensor k,
-    torch::Tensor v,
-    torch::Tensor q2k_block_sparse_index,
-    torch::Tensor q2k_block_sparse_num,
-    torch::Tensor kv_block_size);
-
-std::vector<torch::Tensor> block_sparse_attention_backward(
-    torch::Tensor q,
-    torch::Tensor k,
-    torch::Tensor v,
-    torch::Tensor o,
-    torch::Tensor l_vec,
-    torch::Tensor og,
-    torch::Tensor k2q_block_sparse_index,
-    torch::Tensor k2q_block_sparse_num,
-    torch::Tensor kv_block_size);
-
-std::optional<at::Tensor> rms_norm(
-    at::Tensor const& input,
-    float eps,
-    std::optional<at::Tensor> const& weight,
-    std::optional<at::Tensor>& output);
-
-std::optional<at::Tensor> layer_norm(
-    at::Tensor const input,
-    float eps,
-    std::optional<at::Tensor> weight,
-    std::optional<at::Tensor> const bias,
-    std::optional<at::Tensor> output);
-
-std::tuple<std::optional<torch::Tensor>, std::optional<torch::Tensor>> quant(
-    torch::Tensor const& input,
-    std::optional<torch::Tensor>& output,
-    std::optional<torch::Tensor>& output_scale);
-
-void int8_gemm(
-    at::Tensor const& a,
-    at::Tensor const& a_scale,
-    at::Tensor const& b,
-    at::Tensor const& b_scale,
-    torch::Tensor& c);
-
-torch::Tensor rms_norm_cuda(
-    torch::Tensor const& input,
-    double eps,
-    std::optional<torch::Tensor> const& weight,
-    std::optional<torch::Tensor> const& output);
-
-torch::Tensor layer_norm_cuda(
-    torch::Tensor const& input,
-    double eps,
-    std::optional<torch::Tensor> const& weight,
-    std::optional<torch::Tensor> const& bias,
-    std::optional<torch::Tensor> const& output);
-
-std::tuple<torch::Tensor, torch::Tensor> quant_cuda(torch::Tensor const& input);
-
-torch::Tensor gemm_cuda(
-    torch::Tensor const& a,
-    torch::Tensor const& a_scale,
-    torch::Tensor const& b,
-    torch::Tensor const& b_scale,
-    torch::Tensor c);
@@ -338,11 +338,7 @@ class FlashAttentionImpl(AttentionImpl):
                )

            qkv = torch.stack([query, key, value], dim=2)
-            key_padding_mask = _key_padding_mask_from_attn_mask(attn_mask, attn_mask.shape[-1]).to(device=query.device)
-            if key_padding_mask.shape[-1] > qkv.shape[1]:
-                raise ValueError("Invalid key padding mask length for FLASH_ATTN: "
-                                 f"expected at most {qkv.shape[1]}, got {key_padding_mask.shape[-1]}")
-            attn_mask_padded = F.pad(key_padding_mask, (qkv.shape[1] - key_padding_mask.shape[-1], 0), value=True)
+            attn_mask_padded = F.pad(attn_mask, (qkv.shape[1] - attn_mask.shape[1], 0), value=True)
            output = flash_attn_no_pad(qkv, attn_mask_padded, causal=False, dropout_p=0, softmax_scale=None)
        elif self.nvfp4_fa4:
            output = self._forward_nvfp4(query, key, value)
@@ -1,147 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-"""NABLA block-sparse flex-attention backend (Kandinsky5 "nabla" checkpoints).
-
-The block mask is data-dependent: nablaT_v2 mean-pools 64-token blocks of the
-fractal-ordered sequence, thresholds the softmaxed block map, and ORs it with a
-precomputed spatio-temporal-window (STA) mask carried on the attention
-metadata. The mask spans the full sequence, so this backend does not support
-sequence parallelism — use it via LocalAttention only.
-"""
-
-import math
-from dataclasses import dataclass
-from typing import Any
-
-import torch
-
-try:
-    from torch.nn.attention.flex_attention import BlockMask, flex_attention
-    flex_attention = torch.compile(flex_attention, dynamic=False, mode="max-autotune-no-cudagraphs")
-    CAN_USE_FLEX_ATTN = True
-except ImportError:
-    CAN_USE_FLEX_ATTN = False
-
-from fastvideo.attention.backends.abstract import (
-    AttentionBackend,
-    AttentionImpl,
-    AttentionMetadata,
-    AttentionMetadataBuilder,
-)
-
-
-def nablaT_v2(
-    q: torch.Tensor,
-    k: torch.Tensor,
-    sta: torch.Tensor,
-    thr: float = 0.9,
-) -> "BlockMask":
-    q = q.transpose(1, 2).contiguous()
-    k = k.transpose(1, 2).contiguous()
-
-    # Map estimation
-    B, h, S, D = q.shape
-    s1 = S // 64
-    qa = q.reshape(B, h, s1, 64, D).mean(-2)
-    ka = k.reshape(B, h, s1, 64, D).mean(-2).transpose(-2, -1)
-    map = qa @ ka
-
-    map = torch.softmax(map / math.sqrt(D), dim=-1)
-    # Map binarization
-    vals, inds = map.sort(-1)
-    cvals = vals.cumsum_(-1)
-    mask = (cvals >= 1 - thr).int()
-    mask = mask.gather(-1, inds.argsort(-1))
-
-    mask = torch.logical_or(mask, sta)
-
-    # BlockMask creation
-    kv_nb = mask.sum(-1).to(torch.int32)
-    kv_inds = mask.argsort(dim=-1, descending=True).to(torch.int32)
-    return BlockMask.from_kv_blocks(torch.zeros_like(kv_nb), kv_inds, kv_nb, kv_inds, BLOCK_SIZE=64, mask_mod=None)
-
-
-class NablaAttentionBackend(AttentionBackend):
-
-    @staticmethod
-    def get_name() -> str:
-        return "NABLA_ATTN"
-
-    @staticmethod
-    def get_impl_cls() -> type["NablaAttentionImpl"]:
-        return NablaAttentionImpl
-
-    @staticmethod
-    def get_metadata_cls() -> type["NablaAttentionMetadata"]:
-        return NablaAttentionMetadata
-
-    @staticmethod
-    def get_builder_cls() -> type["NablaAttentionMetadataBuilder"]:
-        return NablaAttentionMetadataBuilder
-
-
-@dataclass
-class NablaAttentionMetadata(AttentionMetadata):
-    # Block-level STA window mask [1, 1, S/64, S/64], precomputed once per run.
-    sta_mask: torch.Tensor = None  # type: ignore[assignment]
-    # Cumulative-probability threshold for block-map binarization.
-    P: float = 0.9
-    visual_shape: tuple[int, int, int] = (0, 0, 0)
-
-
-class NablaAttentionMetadataBuilder(AttentionMetadataBuilder):
-
-    def __init__(self) -> None:
-        pass
-
-    def prepare(self) -> None:
-        pass
-
-    def build(
-        self,
-        current_timestep: int,
-        sta_mask: torch.Tensor,
-        P: float,
-        visual_shape: tuple[int, int, int],
-        **kwargs: Any,
-    ) -> NablaAttentionMetadata:
-        return NablaAttentionMetadata(
-            current_timestep=current_timestep,
-            sta_mask=sta_mask,
-            P=P,
-            visual_shape=visual_shape,
-        )
-
-
-class NablaAttentionImpl(AttentionImpl):
-
-    def __init__(
-        self,
-        num_heads: int,
-        head_size: int,
-        softmax_scale: float,
-        causal: bool = False,
-        num_kv_heads: int | None = None,
-        prefix: str = "",
-        **extra_impl_args,
-    ) -> None:
-        if not CAN_USE_FLEX_ATTN:
-            raise RuntimeError("NABLA attention requires torch.nn.attention.flex_attention, "
-                               "which is unavailable in this PyTorch build.")
-        if causal:
-            raise ValueError("NABLA attention does not support causal masking.")
-
-    def forward(
-        self,
-        query: torch.Tensor,
-        key: torch.Tensor,
-        value: torch.Tensor,
-        attn_metadata: NablaAttentionMetadata,
-    ) -> torch.Tensor:
-        # q/k/v: [B, S, heads, head_dim], fractal-ordered by the model; S % 64 == 0.
-        block_mask = nablaT_v2(query, key, attn_metadata.sta_mask, thr=attn_metadata.P)
-        return flex_attention(
-            query=query.transpose(1, 2),
-            key=key.transpose(1, 2),
-            value=value.transpose(1, 2),
-            block_mask=block_mask,
-        ).transpose(1, 2)
@@ -2,7 +2,6 @@

 import torch
 from dataclasses import dataclass
-from torch.nn import functional as F
 from fastvideo.attention.backends.abstract import (  # FlashAttentionMetadata,
    AttentionBackend, AttentionImpl, AttentionMetadata, AttentionMetadataBuilder)
 from fastvideo.logger import init_logger
@@ -20,7 +19,7 @@ class SDPABackend(AttentionBackend):

    @staticmethod
    def get_name() -> str:
-        return "TORCH_SDPA"
+        return "SDPA"

    @staticmethod
    def get_impl_cls() -> type["SDPAImpl"]:
@@ -50,51 +49,9 @@ class SDPAMetadataBuilder(AttentionMetadataBuilder):
            current_timestep: int,
            attn_mask: torch.Tensor,
    ) -> SDPAMetadata:
-        # Store the mask exactly as passed. The metadata is cross-backend:
-        # call sites (HYWorld, HunyuanVideo15) build SDPAMetadata while the
-        # layer's selector may pick FLASH_ATTN, and the shared convention for
-        # padding masks is the tokenizer-style 2D [batch, key_len]. Any
-        # reshaping for torch.sdpa happens inside the SDPA impl
-        # (_normalize_attn_mask_for_sdpa).
        return SDPAMetadata(current_timestep=current_timestep, attn_mask=attn_mask)


-def _normalize_attn_mask_for_sdpa(
-    attn_mask: torch.Tensor | None,
-    query: torch.Tensor,
-    key: torch.Tensor,
-) -> torch.Tensor | None:
-    if attn_mask is None:
-        return None
-
-    attn_mask = attn_mask.to(device=query.device)
-    # F.scaled_dot_product_attention only accepts bool or float masks;
-    # tokenizers commonly produce int64 0/1 padding masks.
-    if attn_mask.dtype != torch.bool and not attn_mask.dtype.is_floating_point:
-        attn_mask = attn_mask != 0
-
-    key_len = key.shape[-2]
-    if attn_mask.shape[-1] > key_len:
-        raise ValueError("Invalid attention mask length for SDPA: "
-                         f"expected at most {key_len}, got {attn_mask.shape[-1]}")
-    if attn_mask.shape[-1] < key_len:
-        # Front-pad as "attend": double-stream layouts (HYWorld) prepend
-        # non-text tokens the tokenizer mask does not cover.
-        valid_value = True if attn_mask.dtype == torch.bool else 0.0
-        attn_mask = F.pad(attn_mask, (key_len - attn_mask.shape[-1], 0), value=valid_value)
-
-    if attn_mask.dim() == 2:
-        # In-tree producers pass 2D [batch, key_len] padding masks; lift to a
-        # broadcastable [batch, 1, 1, key_len] here so torch.sdpa does not
-        # reinterpret 2D as its documented [query_len, key_len] broadcast.
-        return attn_mask[:, None, None, :]
-    if attn_mask.dim() == 3:
-        return attn_mask[:, None, :, :]
-    if attn_mask.dim() == 4:
-        return attn_mask
-    raise ValueError(f"Unsupported attention mask shape for SDPA: {attn_mask.shape}")
-
-
 class SDPAImpl(AttentionImpl):

    def __init__(
@@ -125,7 +82,6 @@ class SDPAImpl(AttentionImpl):

        attn_mask = attn_metadata.attn_mask if (attn_metadata is not None
                                                and hasattr(attn_metadata, "attn_mask")) else None
-        attn_mask = _normalize_attn_mask_for_sdpa(attn_mask, query, key)
        attn_kwargs = {
            "attn_mask": attn_mask,
            "dropout_p": self.dropout,
@@ -252,7 +252,6 @@ class LocalAttention(nn.Module):
                 causal: bool = False,
                 supported_attention_backends: tuple[AttentionBackendEnum, ...]
                 | None = None,
-                 default_backend: AttentionBackendEnum | None = None,
                 **extra_impl_args) -> None:
        super().__init__()
        if softmax_scale is None:
@@ -263,10 +262,7 @@ class LocalAttention(nn.Module):
            num_kv_heads = num_heads

        dtype = get_compute_dtype()
-        attn_backend = get_attn_backend(head_size,
-                                        dtype,
-                                        supported_attention_backends=supported_attention_backends,
-                                        default_backend=default_backend)
+        attn_backend = get_attn_backend(head_size, dtype, supported_attention_backends=supported_attention_backends)
        impl_cls = attn_backend.get_impl_cls()
        self.attn_impl = impl_cls(num_heads=num_heads,
                                  head_size=head_size,
@@ -84,9 +84,8 @@ def get_attn_backend(
    dtype: torch.dtype,
    supported_attention_backends: tuple[AttentionBackendEnum, ...]
    | None = None,
-    default_backend: AttentionBackendEnum | None = None,
 ) -> type[AttentionBackend]:
-    return _cached_get_attn_backend(head_size, dtype, supported_attention_backends, default_backend)
+    return _cached_get_attn_backend(head_size, dtype, supported_attention_backends)


@cache
@@ -95,7 +94,6 @@ def _cached_get_attn_backend(
    dtype: torch.dtype,
    supported_attention_backends: tuple[AttentionBackendEnum, ...]
    | None = None,
-    default_backend: AttentionBackendEnum | None = None,
 ) -> type[AttentionBackend]:
    # Check whether a particular choice of backend was
    # previously forced.
@@ -114,12 +112,6 @@ def _cached_get_attn_backend(
        if backend_by_env_var is not None:
            selected_backend = backend_name_to_enum(backend_by_env_var)

-    # Layer-level default (e.g. a checkpoint that requires a specific sparse
-    # backend). Lower precedence than the global force and the env var, so
-    # users can still override it.
-    if selected_backend is None and default_backend is not None:
-        selected_backend = default_backend
-
    # get device-specific attn_backend
    from fastvideo.platforms import current_platform

@@ -2,24 +2,14 @@
 from dataclasses import dataclass, field

 from fastvideo.configs.models.dits.base import DiTArchConfig, DiTConfig
-from fastvideo.platforms import AttentionBackendEnum
-
-
-def _is_kandinsky5_transformer_block(n: str, m) -> bool:
-    return ("text_transformer_blocks" in n or "visual_transformer_blocks" in n) and n.split(".")[-1].isdigit()


@dataclass
 class Kandinsky5ArchConfig(DiTArchConfig):
-    _fsdp_shard_conditions: list = field(default_factory=lambda: [_is_kandinsky5_transformer_block])
-
-    # NABLA block-sparse attention for attention_type="nabla" checkpoints, plus
-    # the dense backends every DiT supports.
-    _supported_attention_backends: tuple[AttentionBackendEnum, ...] = (
-        AttentionBackendEnum.NABLA_ATTN,
-        AttentionBackendEnum.FLASH_ATTN,
-        AttentionBackendEnum.TORCH_SDPA,
-    )
+    _fsdp_shard_conditions: list = field(default_factory=lambda: [
+        lambda n, m:
+        ("text_transformer_blocks" in n or "visual_transformer_blocks" in n) and n.split(".")[-1].isdigit()
+    ])

    # Native FastVideo implementation uses the same parameter names as diffusers
    # except FFN internals: Diffusers FFN uses `in_layer/out_layer`, while
@@ -43,16 +43,11 @@ class TextEncoderArchConfig(EncoderArchConfig):
    require_processor: bool = False

    def __post_init__(self) -> None:
-        # update_model_arch re-runs __post_init__ after pipeline configs may
-        # have customized tokenizer_kwargs (e.g. kandinsky5/gen3c/longcat set
-        # "padding"); rebuilding the dict here would silently wipe those
-        # customizations, so only fill in defaults for keys not already set.
-        defaults = {
+        self.tokenizer_kwargs = {
            "truncation": True,
            "max_length": self.text_len,
            "return_tensors": "pt",
        }
-        self.tokenizer_kwargs = defaults | self.tokenizer_kwargs


@dataclass
@@ -6,7 +6,6 @@ from fastvideo.configs.pipelines.hunyuan import FastHunyuanConfig, HunyuanConfig
 from fastvideo.configs.pipelines.hunyuan15 import Hunyuan15T2V480PConfig, Hunyuan15T2V720PConfig
 from fastvideo.configs.pipelines.hunyuangamecraft import HunyuanGameCraftPipelineConfig
 from fastvideo.configs.pipelines.hyworld import HYWorldConfig
-from fastvideo.configs.pipelines.kandinsky5 import Kandinsky5I2VConfig, Kandinsky5T2VConfig
 from fastvideo.configs.pipelines.matrixgame2 import MatrixGame2I2V480PConfig
 from fastvideo.configs.pipelines.matrixgame3 import MatrixGame3I2V720PConfig
 from fastvideo.pipelines.basic.ltx2.pipeline_configs import LTX2T2VConfig
@@ -18,6 +17,6 @@ __all__ = [
    "HunyuanConfig", "FastHunyuanConfig", "HunyuanGameCraftPipelineConfig", "PipelineConfig", "Hunyuan15T2V480PConfig",
    "Hunyuan15T2V720PConfig", "WanT2V480PConfig", "WanI2V480PConfig", "WanT2V720PConfig", "WanI2V720PConfig",
    "SelfForcingWanT2V480PConfig", "LucyEditDevConfig", "CosmosConfig", "Cosmos25Config", "LTX2T2VConfig",
-    "DreamXWorld5BCamPipelineConfig", "DreamXWorld5BARPipelineConfig", "HYWorldConfig", "Kandinsky5T2VConfig",
-    "Kandinsky5I2VConfig", "MatrixGame2I2V480PConfig", "MatrixGame3I2V720PConfig", "get_pipeline_config_cls_from_name"
+    "DreamXWorld5BCamPipelineConfig", "DreamXWorld5BARPipelineConfig", "HYWorldConfig", "MatrixGame2I2V480PConfig",
+    "MatrixGame3I2V720PConfig", "get_pipeline_config_cls_from_name"
 ]
@@ -1,122 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-
-from __future__ import annotations
-
-from collections.abc import Callable
-from dataclasses import dataclass, field
-from typing import Any
-
-import torch
-
-from fastvideo.configs.models import DiTConfig, EncoderConfig, VAEConfig
-from fastvideo.configs.models.dits import Kandinsky5VideoConfig
-from fastvideo.configs.models.encoders import BaseEncoderOutput, CLIPTextConfig
-from fastvideo.configs.models.encoders.reason1 import Reason1Config
-from fastvideo.configs.models.vaes import HunyuanVAEConfig
-from fastvideo.configs.pipelines.base import PipelineConfig, preprocess_text
-
-# Byte-exact copy of the upstream Kandinsky5/diffusers template, including the
-# "promt"/"scren" typos: the checkpoints were trained with this exact system  # codespell:ignore promt,scren
-# prompt, and ENCODE_START_IDX below is the tokenized length of everything
-# before the user prompt. Fixing the typos shifts user content to index 127
-# and mis-conditions every generation.
-KANDINSKY5_PROMPT_TEMPLATE = "\n".join([
-    "<|im_start|>system\nYou are a promt engineer. Describe the video in detail.",  # codespell:ignore promt
-    "Describe how the camera moves or shakes, describe the zoom and view angle, whether it follows the objects.",
-    "Describe the location of the video, main characters or objects and their action.",
-    "Describe the dynamism of the video and presented actions.",
-    "Name the visual style of the video: whether it is a professional footage, user generated content, some kind of animation, video game or scren content.",  # codespell:ignore scren
-    "Describe the visual effects, postprocessing and transitions if they are presented in the video.",
-    "Pay attention to the order of key actions shown in the scene.<|im_end|>",
-    "<|im_start|>user\n{}<|im_end|>",
-])
-KANDINSKY5_PROMPT_TEMPLATE_ENCODE_START_IDX = 129
-
-
-def kandinsky5_qwen_preprocess_text(prompt: str) -> str:
-    if not prompt.strip():
-        prompt = "."
-    return KANDINSKY5_PROMPT_TEMPLATE.format(prompt)
-
-
-def kandinsky5_qwen_postprocess_text(outputs: BaseEncoderOutput,
-                                     mask: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]:
-    if outputs.hidden_states is None:
-        raise RuntimeError("Kandinsky5 Qwen prompt embeddings require hidden_states.")
-    hidden_states = outputs.hidden_states[-1]
-    prompt_embeds = hidden_states[:, KANDINSKY5_PROMPT_TEMPLATE_ENCODE_START_IDX:]
-    mask = mask[:, KANDINSKY5_PROMPT_TEMPLATE_ENCODE_START_IDX:]
-    if prompt_embeds.shape[1] == 0:
-        prompt_embeds = hidden_states[:, -1:]
-        mask = torch.ones((mask.shape[0], 1), dtype=mask.dtype, device=mask.device)
-    return prompt_embeds, mask
-
-
-def kandinsky5_clip_postprocess_text(outputs: BaseEncoderOutput) -> torch.Tensor:
-    if outputs.pooler_output is None:
-        raise RuntimeError("Kandinsky5 CLIP pooled output is required.")
-    return outputs.pooler_output
-
-
-@dataclass
-class Kandinsky5T2VConfig(PipelineConfig):
-    """Kandinsky-5.0 Lite text-to-video pipeline configuration."""
-
-    dit_config: DiTConfig = field(default_factory=Kandinsky5VideoConfig)
-    vae_config: VAEConfig = field(default_factory=HunyuanVAEConfig)
-
-    text_encoder_configs: tuple[EncoderConfig, ...] = field(default_factory=lambda: (Reason1Config(), CLIPTextConfig()))
-    preprocess_text_funcs: tuple[Callable[[str], Any], ...] = field(
-        default_factory=lambda: (kandinsky5_qwen_preprocess_text, preprocess_text))
-    postprocess_text_funcs: tuple[Callable[..., Any], ...] = field(
-        default_factory=lambda: (kandinsky5_qwen_postprocess_text, kandinsky5_clip_postprocess_text))
-
-    dit_precision: str = "bf16"
-    vae_precision: str = "bf16"
-    text_encoder_precisions: tuple[str, ...] = field(default_factory=lambda: ("bf16", "bf16"))
-    text_encoder_max_lengths: tuple[int, ...] = field(
-        default_factory=lambda: (KANDINSKY5_PROMPT_TEMPLATE_ENCODE_START_IDX + 512, 77))
-
-    flow_shift: float | None = 5.0
-    vae_tiling: bool = True
-
-    def __post_init__(self) -> None:
-        if len(self.text_encoder_configs) != 2:
-            raise ValueError(f"Kandinsky5 pipeline requires exactly 2 text encoders (qwen and clip), "
-                             f"but got {len(self.text_encoder_configs)} encoder(s).")
-        if len(self.text_encoder_precisions) != 2:
-            raise ValueError("Kandinsky5 pipeline requires exactly 2 text encoder precisions, "
-                             f"but got {len(self.text_encoder_precisions)}.")
-        if len(self.text_encoder_max_lengths) != 2:
-            raise ValueError("Kandinsky5 pipeline requires exactly 2 text encoder max lengths, "
-                             f"but got {len(self.text_encoder_max_lengths)}.")
-
-        self.vae_config.load_encoder = False
-        self.vae_config.load_decoder = True
-
-        qwen_cfg = self.text_encoder_configs[0]
-        qwen_cfg.arch_config.output_hidden_states = True
-        qwen_cfg.arch_config.tokenizer_kwargs.update({
-            "padding": True,
-            "truncation": True,
-            "return_tensors": "pt",
-        })
-
-        clip_cfg = self.text_encoder_configs[1]
-        clip_cfg.arch_config.tokenizer_kwargs.update({
-            "padding": "max_length",
-            "max_length": 77,
-            "truncation": True,
-            "add_special_tokens": True,
-            "return_tensors": "pt",
-        })
-
-
-@dataclass
-class Kandinsky5I2VConfig(Kandinsky5T2VConfig):
-    """Kandinsky-5.0 image-to-video pipeline configuration."""
-
-    def __post_init__(self) -> None:
-        super().__post_init__()
-        # I2V needs the VAE encoder to encode the conditioning image.
-        self.vae_config.load_encoder = True
@@ -2,7 +2,6 @@
 import os
 import pickle
 import random
-from collections.abc import Sequence
 from typing import Any

 import pyarrow as pa
@@ -95,56 +94,8 @@ class DP_SP_BatchSampler(Sampler[list[int]]):
        return len(self.sp_group_local_indices) // self.batch_size


-def _parse_data_path_specs(path: str | Sequence[str] | dict[str, int]) -> list[tuple[str, int]]:
-    """Parse one or more dataset roots with old-framework repeat counts."""
-    if isinstance(path, dict):
-        return [
-            (str(root), int(repeat))
-            for root, repeat in path.items()
-            if int(repeat) > 0
-        ]
-    if isinstance(path, Sequence) and not isinstance(path, str):
-        return [(str(root), 1) for root in path]
-
-    specs: list[tuple[str, int]] = []
-    for part in str(path).split(","):
-        part = part.strip()
-        if not part:
-            continue
-        if ":" in part:
-            dir_path, count_str = part.rsplit(":", 1)
-            count = int(count_str)
-        else:
-            dir_path, count = part, 1
-        if count > 0:
-            specs.append((dir_path.strip(), count))
-    return specs
-
-
-def get_parquet_files_and_length(path: str | Sequence[str] | dict[str, int]):
-    specs = _parse_data_path_specs(path)
-    if len(specs) != 1 or specs[0][1] != 1:
-        all_file_names: list[str] = []
-        all_lengths: list[int] = []
-        for root, repeat in specs:
-            file_names, lengths = get_parquet_files_and_length(str(root))
-            for _ in range(repeat):
-                all_file_names.extend(file_names)
-                all_lengths.extend(lengths)
-        if not all_file_names:
-            raise FileNotFoundError(
-                "No parquet files found under dataset paths: "
-                f"{path}. "
-                "Please verify these paths point to preprocessed parquet data."
-            )
-        file_lengths = sorted(
-            zip(all_file_names, all_lengths, strict=True),
-            key=lambda x: x[0],
-        )
-        file_names_sorted, lengths_sorted = zip(*file_lengths, strict=True)
-        return file_names_sorted, lengths_sorted
-
-    dataset_root = os.path.realpath(os.path.expanduser(specs[0][0]))
+def get_parquet_files_and_length(path: str):
+    dataset_root = os.path.realpath(os.path.expanduser(path))
    # Check if cached info exists
    cache_dir = os.path.join(dataset_root, "map_style_cache")
    cache_file = os.path.join(cache_dir, "file_info.pkl")
@@ -317,7 +268,7 @@ class LatentsParquetMapStyleDataset(Dataset):

    def __init__(
        self,
-        path: str | Sequence[str] | dict[str, int],
+        path: str,
        batch_size: int,
        parquet_schema: pa.Schema,
        cfg_rate: float = 0.0,
@@ -407,6 +358,7 @@ class LatentsParquetMapStyleDataset(Dataset):
    def __len__(self):
        return sum(self.lengths)

+
 # ────────────────────────────────────────────────────────────────────────────
 # 3.  Loader helper – everything else stays just like your original trainer
 # ────────────────────────────────────────────────────────────────────────────
@@ -122,44 +122,6 @@ to run a subset of the Evaluator's registered metrics on this batch
 (useful for scoring different corpora with different metric subsets in
 successive calls without burning model loads).

-### Training-time validation metrics
-
-The modular trainer can score validation videos during training through
-`callbacks.validation.metrics`. Each distributed rank that writes local
-validation videos also runs its local metrics on `cuda:<local_rank>`;
-rank 0 only merges scalar summaries and logs artifacts.
-
-```yaml
-callbacks:
-  validation:
-    pipeline_target: fastvideo.pipelines.basic.matrixgame2.matrixgame2_causal_dmd_pipeline.MatrixGame2CausalDMDPipeline
-    dataset_file: examples/distill/MatrixGame2.0/validation.json
-    sampling_steps: [4]
-    metrics:
-      enabled: true
-      names:
-        - vbench.imaging_quality
-        - vbench.aesthetic_quality
-        - optical_flow.synthetic_optical_flow
-        - common.fvd
-      skip_missing_deps: true
-      strict: false
-      unload_after_validation: true
-
-      # `synthetic_optical_flow` also needs actions in the validation
-      # manifest (`action_path`) plus a repo-local calibration file.
-      calibration_path: assets/eval/worldmodel_synthetic_flow_calibration.json
-```
-
-Metric summaries are written under
-`<output_dir>/eval/step_<step>/inference_steps_<n>_rank_<rank>.json` and
-scalar means are logged with the `metrics/validation/...` prefix.
-Install `fastvideo[eval]` for optical-flow dependencies such as
-`ptlflow`; VBench metrics use the pinned submodule under
-`fastvideo/third_party/eval/vbench`. FVD uses `ref_video` entries from
-the validation manifest when present, or the standard
-`FASTVIDEO_FVD_REF_FEATURES` / eval-cache reference feature path.
-
 ### CLI

 ```bash
@@ -388,3 +350,5 @@ sweep several baselines into a table, see

 - **MIND** metrics. Depend on a separate `vipe` upstream submodule.
 - **VBench-2.0**. Sibling vbench2 package; needs its own port.
+- **Training-time eval callback** (`EvalCallback`) and the
+  `RolloutEvaluator` helper.
@@ -63,7 +63,7 @@ class ThirdPersonCalibration:
    beta_fwd: float
    beta_strafe: float
    focal_length: float
-    r_z: float = 0.0
+    r_z: float
    r_y: float = 0.0
    init_pitch: float = 0.0
    notes: str = ""
@@ -261,22 +261,6 @@ def _mm_fp4(
    )


-def _coerce_fp4_input_dtype(x: torch.Tensor) -> torch.Tensor:
-    """Coerce an activation to a dtype the FP4 linear accepts.
-
-    The pre-attention norm can emit fp32 (e.g. in eager mode, without the
-    torch.compile fusion that keeps it bf16). The FP4 linear emits bf16
-    regardless (see _mm_fp4 out dtype), so cast fp32 -> bf16 rather than
-    failing, matching the sibling fastvideo/layers/fp4linear.py. Non-floating
-    inputs (e.g. int/bool) are a genuine error and are rejected fast.
-    """
-    if not x.is_floating_point():
-        raise TypeError(f"fp4 linear expects floating-point inputs, got {x.dtype}")
-    if x.dtype not in (torch.bfloat16, torch.float16):
-        x = x.to(torch.bfloat16)
-    return x
-
-
 class NVFP4QuantizeMethod(QuantizeMethodBase):

    def __init__(self, layer_prefix: str = ""):
@@ -301,7 +285,8 @@ class NVFP4QuantizeMethod(QuantizeMethodBase):

    def quantize_input(self, x: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
        SfLayout, _, _ = _require_flashinfer()
-        x = _coerce_fp4_input_dtype(x)
+        assert x.dtype == torch.bfloat16 or x.dtype == torch.float16, (
+            f"only allow bf16/fp16 inputs to fp4 linear, got {x.dtype}")
        x_2d = x.view(-1, x.shape[-1])
        x_fp4, x_scale = _nvfp4_quantize(
            x_2d,
@@ -347,7 +332,8 @@ class NVFP4QuantizeMethod(QuantizeMethodBase):
            if x_scale.dim() > 2:
                x_scale = x_scale.view(-1, x_scale.shape[-1])
        else:
-            x = _coerce_fp4_input_dtype(x)
+            assert x.dtype == torch.bfloat16 or x.dtype == torch.float16, (
+                f"only allow bf16/fp16 inputs to fp4 linear, got {x.dtype}")
            x = x.view(-1, x.shape[-1])
            x_global_sf = self.x_global_sf
            x_fp4, x_scale = _nvfp4_quantize(
@@ -665,8 +665,7 @@ class CausalWanTransformer3DModel(BaseDiT):
            else:
                causal_kwargs = {
                    "kv_cache": kv_cache[block_index],
-                    "crossattn_cache": (crossattn_cache[block_index]
-                                        if crossattn_cache is not None else None),
+                    "crossattn_cache": crossattn_cache[block_index],
                    "current_start": current_start,
                    "cache_start": cache_start,
                    "block_mask": self.block_mask,
@@ -699,8 +699,8 @@ class IndividualTokenRefinerBlock(nn.Module):
        if mask is None:
            attn_output = self.attn(q, k, v) 
        else:
-            from fastvideo.attention.backends.sdpa import SDPAMetadataBuilder
-            attn_metadata = SDPAMetadataBuilder().build(
+            from fastvideo.attention.backends.flash_attn import FlashAttnMetadataBuilder
+            attn_metadata = FlashAttnMetadataBuilder().build(
                current_timestep=0,
                attn_mask=mask,
            )
@@ -173,11 +173,8 @@ class HYWorldDoubleStreamBlock(MMDoubleStreamBlock):
        img_v_prope = img_v_prope.permute(0, 2, 1, 3)  # [batch, seqlen, num_heads, head_dim]
        # end hyworld

-        # The metadata only carries the text padding mask; the executing
-        # attention kernel is still whatever the layer's selector picked
-        # (flash-attn when installed), not necessarily torch SDPA.
-        from fastvideo.attention.backends.sdpa import SDPAMetadataBuilder
-        attn_metadata = SDPAMetadataBuilder().build(
+        from fastvideo.attention.backends.flash_attn import FlashAttnMetadataBuilder
+        attn_metadata = FlashAttnMetadataBuilder().build(
            current_timestep=0,
            attn_mask=encoder_attention_mask,
        )
@@ -195,9 +192,14 @@ class HYWorldDoubleStreamBlock(MMDoubleStreamBlock):
            )
        
        # begin hyworld
-        # attention with prope (same text mask, so reuse the metadata)
+        # attention with prope
+        from fastvideo.attention.backends.flash_attn import FlashAttnMetadataBuilder
+        attn_metadata_prope = FlashAttnMetadataBuilder().build(
+            current_timestep=0,
+            attn_mask=encoder_attention_mask,
+        )       
        # NOTE: Do NOT pass freqs_cis to prope attention - HY-WorldPlay does not apply RoPE to prope
-        with set_forward_context(current_timestep=0, attn_metadata=attn_metadata):
+        with set_forward_context(current_timestep=0, attn_metadata=attn_metadata_prope):
            img_attn_prope, _ = self.attn(
                img_q_prope,
                img_k_prope,
@@ -10,21 +10,13 @@ import torch.nn as nn
 import torch.nn.functional as F

 from fastvideo.attention import LocalAttention
-from fastvideo.attention.backends.nabla import CAN_USE_FLEX_ATTN, flex_attention, nablaT_v2
 from fastvideo.configs.models.dits import Kandinsky5VideoConfig
 from fastvideo.layers.layernorm import LayerNormScaleShift
 from fastvideo.layers.linear import ReplicatedLinear
 from fastvideo.layers.mlp import MLP
-from fastvideo.logger import init_logger
 from fastvideo.models.dits.base import BaseDiT
 from fastvideo.platforms import AttentionBackendEnum

-logger = init_logger(__name__)
-
-if not CAN_USE_FLEX_ATTN:
-    logger.warning("torch.nn.attention.flex_attention is unavailable in this PyTorch build; "
-                   "Kandinsky5 NABLA sparse attention (Pro checkpoints) cannot be used.")
-
 FRACTAL_PIXEL_SIZE = 8
 _ARCH_CONFIG_DEFAULTS = Kandinsky5VideoConfig().arch_config

@@ -271,9 +263,10 @@ class Kandinsky5Modulation(nn.Module):


 def _apply_rotary(x: torch.Tensor, rope: torch.Tensor) -> torch.Tensor:
+    orig_dtype = x.dtype
    x_ = x.reshape(*x.shape[:-1], -1, 1, 2).to(torch.float32)
    x_out = (rope * x_).sum(dim=-1)
-    return x_out.reshape(*x.shape).to(x.dtype)
+    return x_out.reshape(*x.shape).to(orig_dtype)


 class Kandinsky5Attention(nn.Module):
@@ -284,7 +277,6 @@ class Kandinsky5Attention(nn.Module):
        head_dim: int,
        supported_attention_backends: tuple[AttentionBackendEnum, ...] | None,
        prefix: str = "",
-        use_nabla: bool = False,
    ):
        super().__init__()
        assert num_channels % head_dim == 0
@@ -314,17 +306,6 @@ class Kandinsky5Attention(nn.Module):
            causal=False,
            supported_attention_backends=supported_attention_backends,
        )
-        # NABLA checkpoints get a second attention layer whose backend defaults
-        # to NABLA_ATTN; FASTVIDEO_ATTENTION_BACKEND still overrides it.
-        self.nabla_attention = None
-        if use_nabla:
-            self.nabla_attention = LocalAttention(
-                num_heads=self.num_heads,
-                head_size=head_dim,
-                causal=False,
-                supported_attention_backends=supported_attention_backends,
-                default_backend=AttentionBackendEnum.NABLA_ATTN,
-            )

    def forward(
        self,
@@ -358,54 +339,27 @@ class Kandinsky5Attention(nn.Module):
            key = _apply_rotary(key, rotary_emb).type_as(key)

        if sparse_params is not None:
-            if self.nabla_attention is None:
-                raise RuntimeError("sparse_params passed to an attention layer built without use_nabla; "
-                                   "this checkpoint/config combination is inconsistent.")
-            try:
-                # Backend impl reads sta_mask/P from the forward-context
-                # attention metadata built by the denoising stage.
-                hidden_states = self.nabla_attention(query, key, value)
-            except AssertionError as exc:
-                # Standalone parity tests call the model without a pipeline
-                # forward context; run the NABLA kernel directly.
-                if "Forward context is not set" not in str(exc):
-                    raise
-                attn_mask = nablaT_v2(query, key, sparse_params["sta_mask"], thr=sparse_params["P"])
-                hidden_states = flex_attention(
-                    query=query.transpose(1, 2),
-                    key=key.transpose(1, 2),
-                    value=value.transpose(1, 2),
-                    block_mask=attn_mask,
-                ).transpose(1, 2)
-        else:
-            try:
-                hidden_states = self.local_attention(query, key, value)
+            raise NotImplementedError(
+                "Sparse attention is not yet supported for Kandinsky5 in FastVideo."
+            )

-            except AssertionError as exc:
-                # LocalAttention requires pipeline forward context. Standalone
-                # parity tests call the model directly, so fallback to Torch SDPA.
-                if "Forward context is not set" not in str(exc):
-                    raise
-
-                query_shape = query.shape[:-2]
-                key_shape = key.shape[:-2]
-                query = query.reshape(query_shape[0], -1, self.num_heads,
-                                      query.shape[-1]).transpose(1, 2)
-                key = key.reshape(key_shape[0], -1, self.num_heads,
-                                  key.shape[-1]).transpose(1, 2)
-                value = value.reshape(key_shape[0], -1, self.num_heads,
-                                      value.shape[-1]).transpose(1, 2)
-                hidden_states = F.scaled_dot_product_attention(
-                    query,
-                    key,
-                    value,
-                    attn_mask=None,
-                    is_causal=False,
-                )
-                hidden_states = hidden_states.transpose(1, 2).reshape(
-                    *query_shape, self.num_heads, -1)
-                
-        hidden_states = hidden_states.flatten(-2, -1)
+        try:
+            hidden_states = self.local_attention(query, key, value)
+        except AssertionError as exc:
+            # LocalAttention requires pipeline forward context. Standalone
+            # parity tests call the model directly, so fallback to Torch SDPA.
+            if "Forward context is not set" not in str(exc):
+                raise
+            query = query.transpose(1, 2)
+            key = key.transpose(1, 2)
+            value = value.transpose(1, 2)
+            hidden_states = F.scaled_dot_product_attention(query,
+                                                           key,
+                                                           value,
+                                                           attn_mask=None,
+                                                           is_causal=False)
+            hidden_states = hidden_states.transpose(1, 2)
+        hidden_states = hidden_states.flatten(2)

        hidden_states, _ = self.out_layer(hidden_states)
        return hidden_states
@@ -522,8 +476,7 @@ class Kandinsky5TransformerDecoderBlock(nn.Module):
                 head_dim: int,
                 supported_attention_backends: tuple[AttentionBackendEnum, ...]
                 | None = None,
-                 prefix: str = "",
-                 use_nabla: bool = False):
+                 prefix: str = ""):
        super().__init__()
        self.visual_modulation = Kandinsky5Modulation(time_dim, model_dim, 9)

@@ -538,8 +491,7 @@ class Kandinsky5TransformerDecoderBlock(nn.Module):
            model_dim,
            head_dim,
            supported_attention_backends=supported_attention_backends,
-            prefix=f"{prefix}.self_attention",
-            use_nabla=use_nabla)
+            prefix=f"{prefix}.self_attention")

        self.cross_attention_norm = LayerNormScaleShift(
            model_dim,
@@ -672,8 +624,7 @@ class Kandinsky5Transformer3DModel(BaseDiT):
                                              arch.ff_dim,
                                              head_dim,
                                              self._supported_attention_backends,
-                                              prefix=f"{config.prefix}.visual_transformer_blocks.{i}",
-                                              use_nabla=arch.attention_type == "nabla")
+                                              prefix=f"{config.prefix}.visual_transformer_blocks.{i}")
            for i in range(arch.num_visual_blocks)
        ])

@@ -743,7 +694,6 @@ class Kandinsky5Transformer3DModel(BaseDiT):
                                                  scale_factor)
        to_fractal = sparse_params[
            "to_fractal"] if sparse_params is not None else False
-        
        visual_embed, visual_rope = fractal_flatten(visual_embed, visual_rope,
                                                    visual_shape,
                                                    block_mask=to_fractal)
@@ -774,7 +724,6 @@ class Kandinsky5Transformer3DModel(BaseDiT):

        if return_dict:
            return Kandinsky5TransformerOutput(sample=x)
-        
        return x

    def materialize_non_persistent_buffers(self, device: torch.device,
@@ -72,8 +72,12 @@ def _rms_norm_dispatch(
    """Use QuACK RMSNorm only for LTX-2 refine stage, else Torch RMSNorm."""
    if _is_ltx2_refine_stage():
        return _quack_rmsnorm(x, weight=weight, eps=eps)
+    # torch 2.12 added rms_norm to autocast's float32 cast policy, so under
+    # autocast(bfloat16) this norm now returns float32 where torch <= 2.11
+    # returned bfloat16. Restore the input dtype so autocast-blind consumers
+    # downstream don't receive upcast activations.
    return torch.nn.functional.rms_norm(
-        x, (x.shape[-1], ), weight=weight, eps=eps)
+        x, (x.shape[-1], ), weight=weight, eps=eps).to(x.dtype)


 class StageAwareRMSNorm(nn.RMSNorm):
@@ -16,8 +16,6 @@ from fastvideo.layers.rotary_embedding import (
 )
 from fastvideo.platforms import AttentionBackendEnum

-from .utils import retain_kv_with_sink
-

 DISABLE_COMPILE = False
 flex_attention = torch.compile(
@@ -102,7 +100,6 @@ def _update_kv_cache_and_attend(
    start_frame: int,
    num_frame_per_block: int,
    local_attn_size: int,
-    sink_size: int,
    *,
    use_k_for_num_tokens: bool = False,
    store_first_only: bool = False,
@@ -136,6 +133,7 @@ def _update_kv_cache_and_attend(
        k.shape[1] if use_k_for_num_tokens else q.shape[1]
    ) == num_frame_per_block

+    sink_size = 0
    max_attention_size = local_attn_size
    sink_tokens = sink_size * 1
    kv_cache_size = kv_cache["k"].shape[1]
@@ -208,22 +206,16 @@ def _update_kv_cache_and_attend(

    # Store new k, v in cache
    if store_first_only:
-        kv_cache["k"][:, local_start_index:local_end_index] = k[
-            : kv_cache["k"].shape[0]
-        ]
-        kv_cache["v"][:, local_start_index:local_end_index] = v[
-            : kv_cache["v"].shape[0]
-        ]
+        kv_cache["k"][:, local_start_index:local_end_index] = k[:1]
+        kv_cache["v"][:, local_start_index:local_end_index] = v[:1]
    else:
        kv_cache["k"][:, local_start_index:local_end_index] = k
        kv_cache["v"][:, local_start_index:local_end_index] = v

-    cached_k, cached_v = retain_kv_with_sink(
-        kv_cache["k"][:, :local_end_index],
-        kv_cache["v"][:, :local_end_index],
-        min(local_end_index, max_attention_size),
-        sink_tokens,
-    )
+    # Retrieve from cache and perform attention
+    cache_start = max(0, local_end_index - max_attention_size)
+    cached_k = kv_cache["k"][:, cache_start:local_end_index]
+    cached_v = kv_cache["v"][:, cache_start:local_end_index]

    if repeat_factor is not None:
        cached_k = cached_k.repeat(repeat_factor, 1, 1, 1)
@@ -269,7 +261,6 @@ class ActionModule(nn.Module):
        enable_mouse=True,
        enable_keyboard=True,
        local_attn_size=6,
-        sink_size=0,
        blocks: list | None = None,
    ):
        super().__init__()
@@ -283,7 +274,6 @@ class ActionModule(nn.Module):
        )
        blocks = blocks if blocks is not None else []
        self.local_attn_size = local_attn_size
-        self.sink_size = sink_size
        self.enable_mouse = enable_mouse
        self.enable_keyboard = enable_keyboard

@@ -575,7 +565,6 @@ class ActionModule(nn.Module):
                    start_frame,
                    num_frame_per_block,
                    self.local_attn_size,
-                    self.sink_size,
                    use_k_for_num_tokens=False,
                )
        else:
@@ -700,7 +689,6 @@ class ActionModule(nn.Module):
                        start_frame,
                        num_frame_per_block,
                        self.local_attn_size,
-                        self.sink_size,
                        use_k_for_num_tokens=True,
                        store_first_only=True,
                        repeat_factor=S,
@@ -731,7 +719,6 @@ class ActionModule(nn.Module):
                        start_frame,
                        num_frame_per_block,
                        self.local_attn_size,
-                        self.sink_size,
                        use_k_for_num_tokens=True,
                    )
            else:
@@ -46,7 +46,6 @@ from fastvideo.platforms import AttentionBackendEnum, current_platform

 from .action_module import ActionModule
 from .model import MatrixGame2CrossAttention
-from .utils import retain_kv_with_sink

 logger = init_logger(__name__)

@@ -346,12 +345,9 @@ class CausalMatrixGame2SelfAttention(nn.Module):
                kv_cache["k"][:, local_start_index:local_end_index] = stored_key
                kv_cache["v"][:, local_start_index:local_end_index] = v

-            k_for_attn, v_for_attn = retain_kv_with_sink(
-                kv_cache["k"][:, :local_end_index],
-                kv_cache["v"][:, :local_end_index],
-                min(local_end_index, max_attention_size),
-                sink_tokens,
-            )
+            kv_start = max(0, local_end_index - max_attention_size)
+            k_for_attn = kv_cache["k"][:, kv_start:local_end_index]
+            v_for_attn = kv_cache["v"][:, kv_start:local_end_index]

            if relativistic:
                window_len, query_lo, _ = relativistic_window_offsets(
@@ -422,7 +418,6 @@ class CausalMatrixGame2TransformerBlock(nn.Module):
        self.hidden_dim = dim
        self.num_attention_heads = num_heads
        self.local_attn_size = local_attn_size
-        self.sink_size = sink_size
        dim_head = dim // num_heads
        if qk_norm == "rms_norm":
            self.norm_q = RMSNorm(dim_head, eps=eps)
@@ -479,7 +474,6 @@ class CausalMatrixGame2TransformerBlock(nn.Module):
                ),
                patch_size=action_config["patch_size"],
                local_attn_size=local_attn_size,
-                sink_size=sink_size,
                qk_norm=action_config["qk_norm"],
                qkv_bias=action_config["qkv_bias"],
                vae_time_compression_ratio=action_config[
@@ -653,8 +647,6 @@ class CausalMatrixGame2WanModel(BaseDiT):
        self.num_channels_latents = config.num_channels_latents
        self.patch_size = config.patch_size

-        # Long tuning controls the causal window from YAML; consume it here
-        # like Wan so train wrappers do not need runtime patching.
        arch_cfg = getattr(config, "arch_config", None)
        self.local_attn_size = (
            getattr(
@@ -670,12 +662,6 @@ class CausalMatrixGame2WanModel(BaseDiT):
            if arch_cfg
            else getattr(config, "sink_size", 0)
        )
-        if self.sink_size < 0:
-            raise ValueError("sink_size must be non-negative")
-        if self.local_attn_size != -1 and self.sink_size >= self.local_attn_size:
-            raise ValueError(
-                "sink_size must be smaller than local_attn_size for "
-                "MatrixGame2 causal attention")
        self.rope_cache_policy = (
            getattr(arch_cfg, "rope_cache_policy",
                    getattr(config, "rope_cache_policy", "absolute"))
@@ -763,52 +749,6 @@ class CausalMatrixGame2WanModel(BaseDiT):

        self.__post_init__()

-    def set_causal_attention_window(
-        self,
-        *,
-        local_attn_size: int | None = None,
-        sink_size: int | None = None,
-    ) -> None:
-        local_attn_size = (
-            self.local_attn_size if local_attn_size is None else int(local_attn_size)
-        )
-        sink_size = self.sink_size if sink_size is None else int(sink_size)
-        if sink_size < 0:
-            raise ValueError("sink_size must be non-negative")
-        if local_attn_size != -1 and sink_size >= local_attn_size:
-            raise ValueError(
-                "sink_size must be smaller than local_attn_size for "
-                "MatrixGame2 causal attention")
-
-        self.local_attn_size = local_attn_size
-        self.sink_size = sink_size
-        self.block_mask = None
-        self.block_mask_keyboard = None
-        self.block_mask_mouse = None
-
-        for block in self.blocks:
-            if hasattr(block, "local_attn_size"):
-                block.local_attn_size = local_attn_size
-            if hasattr(block, "sink_size"):
-                block.sink_size = sink_size
-
-            attn1 = getattr(block, "attn1", None)
-            if attn1 is not None:
-                if hasattr(attn1, "local_attn_size"):
-                    attn1.local_attn_size = local_attn_size
-                if hasattr(attn1, "sink_size"):
-                    attn1.sink_size = sink_size
-
-            action_model = getattr(block, "action_model", None)
-            if action_model is not None:
-                if hasattr(action_model, "local_attn_size"):
-                    action_model.local_attn_size = local_attn_size
-                if hasattr(action_model, "sink_size"):
-                    action_model.sink_size = sink_size
-
-    def set_sink_size(self, sink_size: int) -> None:
-        self.set_causal_attention_window(sink_size=sink_size)
-
    @staticmethod
    def _prepare_blockwise_causal_attn_mask(
        device: torch.device | str,
@@ -816,7 +756,6 @@ class CausalMatrixGame2WanModel(BaseDiT):
        frame_seqlen: int = 880,
        num_frame_per_block: int = 1,
        local_attn_size: int = -1,
-        sink_size: int = 0,
    ) -> BlockMask:
        total_length = num_frames * frame_seqlen
        padded_length = math.ceil(total_length / 128) * 128 - total_length
@@ -843,10 +782,7 @@ class CausalMatrixGame2WanModel(BaseDiT):
            else:
                return (
                    (kv_idx < ends[q_idx])
-                    & (
-                        (kv_idx < sink_size * frame_seqlen)
-                        | (kv_idx >= (ends[q_idx] - local_attn_size * frame_seqlen))
-                    )
+                    & (kv_idx >= (ends[q_idx] - local_attn_size * frame_seqlen))
                ) | (q_idx == kv_idx)

        block_mask = create_block_mask(
@@ -860,9 +796,8 @@ class CausalMatrixGame2WanModel(BaseDiT):
        )

        if not dist.is_initialized() or dist.get_rank() == 0:
-            logger.info(
-                "cache a block wise causal mask with block size of %s frames",
-                num_frame_per_block,
+            print(
+                f" cache a block wise causal mask with block size of {num_frame_per_block} frames"
            )

        return block_mask
@@ -874,7 +809,6 @@ class CausalMatrixGame2WanModel(BaseDiT):
        frame_seqlen: int = 880,
        num_frame_per_block: int = 1,
        local_attn_size: int = -1,
-        sink_size: int = 0,
    ) -> BlockMask:
        total_length2 = num_frames * frame_seqlen
        padded_length2 = math.ceil(total_length2 / 32) * 32 - total_length2
@@ -900,7 +834,7 @@ class CausalMatrixGame2WanModel(BaseDiT):
            else:
                return (
                    (kv_idx < ends2[q_idx])
-                    & ((kv_idx < sink_size) | (kv_idx >= (ends2[q_idx] - local_attn_size)))
+                    & (kv_idx >= (ends2[q_idx] - local_attn_size))
                ) | (q_idx == kv_idx)

        block_mask2 = create_block_mask(
@@ -914,9 +848,8 @@ class CausalMatrixGame2WanModel(BaseDiT):
        )

        if not dist.is_initialized() or dist.get_rank() == 0:
-            logger.info(
-                "cache a block wise causal mask for keyboard with block size of %s frames",
-                num_frame_per_block,
+            print(
+                f" cache a block wise causal mask for keyboard with block size of {num_frame_per_block} frames"
            )

        return block_mask2
@@ -928,7 +861,6 @@ class CausalMatrixGame2WanModel(BaseDiT):
        frame_seqlen: int = 1,
        num_frame_per_block: int = 1,
        local_attn_size: int = -1,
-        sink_size: int = 0,
    ) -> BlockMask:
        total_length2 = num_frames * frame_seqlen
        padded_length2 = math.ceil(total_length2 / 32) * 32 - total_length2
@@ -954,7 +886,7 @@ class CausalMatrixGame2WanModel(BaseDiT):
            else:
                return (
                    (kv_idx < ends2[q_idx])
-                    & ((kv_idx < sink_size) | (kv_idx >= (ends2[q_idx] - local_attn_size)))
+                    & (kv_idx >= (ends2[q_idx] - local_attn_size))
                ) | (q_idx == kv_idx)

        block_mask2 = create_block_mask(
@@ -968,9 +900,8 @@ class CausalMatrixGame2WanModel(BaseDiT):
        )

        if not dist.is_initialized() or dist.get_rank() == 0:
-            logger.info(
-                "cache a block wise causal mask for action with block size of %s frames",
-                num_frame_per_block,
+            print(
+                f" cache a block wise causal mask for action with block size of {num_frame_per_block} frames"
            )

        return block_mask2
@@ -1132,7 +1063,6 @@ class CausalMatrixGame2WanModel(BaseDiT):
            frame_seqlen=post_patch_height * post_patch_width,
            num_frame_per_block=self.num_frame_per_block,
            local_attn_size=self.local_attn_size,
-            sink_size=self.sink_size,
        )
        if self.use_rope_keyboard:
            block_mask_keyboard = self._prepare_blockwise_causal_attn_mask_action(
@@ -1141,7 +1071,6 @@ class CausalMatrixGame2WanModel(BaseDiT):
                frame_seqlen=1,
                num_frame_per_block=self.num_frame_per_block,
                local_attn_size=self.local_attn_size,
-                sink_size=self.sink_size,
            )
        else:
            block_mask_keyboard = self._prepare_blockwise_causal_attn_mask_keyboard(
@@ -1150,7 +1079,6 @@ class CausalMatrixGame2WanModel(BaseDiT):
                frame_seqlen=post_patch_height * post_patch_width,
                num_frame_per_block=self.num_frame_per_block,
                local_attn_size=self.local_attn_size,
-                sink_size=self.sink_size,
            )
        block_mask_mouse = self._prepare_blockwise_causal_attn_mask_action(
            device=hidden_states.device,
@@ -1158,7 +1086,6 @@ class CausalMatrixGame2WanModel(BaseDiT):
            frame_seqlen=1,
            num_frame_per_block=self.num_frame_per_block,
            local_attn_size=self.local_attn_size,
-            sink_size=self.sink_size,
        )
        if kv_cache is None:
            kv_cache = [None] * len(self.blocks)
@@ -1312,7 +1239,6 @@ class CausalMatrixGame2WanModel(BaseDiT):
                frame_seqlen=post_patch_height * post_patch_width,
                num_frame_per_block=self.num_frame_per_block,
                local_attn_size=self.local_attn_size,
-                sink_size=self.sink_size,
            )
        if self.block_mask_keyboard is None:
            if self.use_rope_keyboard:
@@ -1322,7 +1248,6 @@ class CausalMatrixGame2WanModel(BaseDiT):
                    frame_seqlen=1,
                    num_frame_per_block=self.num_frame_per_block,
                    local_attn_size=self.local_attn_size,
-                    sink_size=self.sink_size,
                )
            else:
                self.block_mask_keyboard = self._prepare_blockwise_causal_attn_mask_keyboard(
@@ -1331,7 +1256,6 @@ class CausalMatrixGame2WanModel(BaseDiT):
                    frame_seqlen=post_patch_height * post_patch_width,
                    num_frame_per_block=self.num_frame_per_block,
                    local_attn_size=self.local_attn_size,
-                    sink_size=self.sink_size,
                )
        if self.block_mask_mouse is None:
            self.block_mask_mouse = self._prepare_blockwise_causal_attn_mask_action(
@@ -1340,7 +1264,6 @@ class CausalMatrixGame2WanModel(BaseDiT):
                frame_seqlen=1,
                num_frame_per_block=self.num_frame_per_block,
                local_attn_size=self.local_attn_size,
-                sink_size=self.sink_size,
            )

        hidden_states = self.patch_embedding(hidden_states)
@@ -452,7 +452,7 @@ class MatrixGame2WanModel(BaseDiT):
            and len(encoder_hidden_states_image) > 0
        ):
            encoder_hidden_states_image = encoder_hidden_states_image[0]
-        elif not isinstance(encoder_hidden_states_image, torch.Tensor):
+        else:
            encoder_hidden_states_image = None

        batch_size, num_channels, num_frames, height, width = (
@@ -4,18 +4,12 @@ import asyncio
 import os
 import random

-import numpy as np
 import torch
 from PIL import Image

 from fastvideo.distributed.parallel_state import get_local_torch_device
 from fastvideo.utils import logger

-try:
-    import cv2
-except ImportError:
-    cv2 = None
-

 CAM_VALUE = 0.1
 CAMERA_MAP = {
@@ -40,256 +34,6 @@ KEYBOARD_MAP_7 = {  # templerun_distilled_model: still/w/s/left/right/a/d
    "d": [0, 0, 0, 0, 0, 0, 1],  # d
 }
 KEYBOARD_MAP = KEYBOARD_MAP_4  # Default for backward compatibility
-SOLARIS_MOVEMENT_KEY_INDICES = {
-    "W": 11,
-    "S": 12,
-    "A": 13,
-    "D": 14,
-}
-
-
-def retain_kv_with_sink(
-    k: torch.Tensor,
-    v: torch.Tensor,
-    target_len: int,
-    sink_size: int,
-) -> tuple[torch.Tensor, torch.Tensor]:
-    if k.shape[1] <= target_len or sink_size <= 0:
-        return k[:, -target_len:], v[:, -target_len:]
-
-    sink_len = min(int(sink_size), target_len, k.shape[1])
-    tail_len = target_len - sink_len
-    sink_k = k[:, :sink_len]
-    sink_v = v[:, :sink_len]
-    if tail_len <= 0:
-        return sink_k, sink_v
-
-    tail_k = k[:, sink_len:][:, -tail_len:]
-    tail_v = v[:, sink_len:][:, -tail_len:]
-    return torch.cat([sink_k, tail_k], dim=1), torch.cat([sink_v, tail_v], dim=1)
-
-
-def _require_cv2() -> bool:
-    if cv2 is None:
-        logger.warning(
-            "OpenCV is not available; skipping MatrixGame2 validation overlay."
-        )
-        return False
-    return True
-
-
-def _matrixgame2_overlay_keys_from_keyboard(
-    keyboard_frame: np.ndarray | torch.Tensor,
-) -> dict[str, bool]:
-    vec = np.asarray(keyboard_frame, dtype=np.float32).reshape(-1)
-    dim = vec.shape[0]
-
-    if dim >= 23:
-        return {
-            key: bool(vec[idx] > 0.5)
-            for key, idx in SOLARIS_MOVEMENT_KEY_INDICES.items()
-        }
-    if dim == 7:
-        return {
-            "W": bool(vec[1] > 0.5),
-            "S": bool(vec[2] > 0.5),
-            "A": bool(vec[5] > 0.5),
-            "D": bool(vec[6] > 0.5),
-        }
-    if dim >= 6:
-        return {
-            "W": bool(vec[0] > 0.5),
-            "S": bool(vec[1] > 0.5),
-            "A": bool(vec[2] > 0.5),
-            "D": bool(vec[3] > 0.5),
-        }
-    if dim == 4:
-        return {
-            "W": bool(vec[0] > 0.5),
-            "S": bool(vec[1] > 0.5),
-            "A": bool(vec[2] > 0.5),
-            "D": bool(vec[3] > 0.5),
-        }
-    if dim == 2:
-        return {
-            "W": bool(vec[0] > 0.5),
-            "S": bool(vec[1] > 0.5),
-            "A": False,
-            "D": False,
-        }
-    return {"W": False, "S": False, "A": False, "D": False}
-
-
-def draw_rounded_rectangle(
-    image: np.ndarray,
-    top_left: tuple[int, int],
-    bottom_right: tuple[int, int],
-    color: tuple[int, int, int],
-    radius: int = 10,
-    alpha: float = 0.5,
-) -> None:
-    if not _require_cv2():
-        return
-
-    overlay = image.copy()
-    x1, y1 = top_left
-    x2, y2 = bottom_right
-
-    cv2.rectangle(overlay, (x1 + radius, y1), (x2 - radius, y2), color, -1)
-    cv2.rectangle(overlay, (x1, y1 + radius), (x2, y2 - radius), color, -1)
-    cv2.ellipse(overlay, (x1 + radius, y1 + radius), (radius, radius), 180, 0, 90, color, -1)
-    cv2.ellipse(overlay, (x2 - radius, y1 + radius), (radius, radius), 270, 0, 90, color, -1)
-    cv2.ellipse(overlay, (x1 + radius, y2 - radius), (radius, radius), 90, 0, 90, color, -1)
-    cv2.ellipse(overlay, (x2 - radius, y2 - radius), (radius, radius), 0, 0, 90, color, -1)
-    cv2.addWeighted(overlay, alpha, image, 1 - alpha, 0, image)
-
-
-def draw_keys_on_frame(
-    frame: np.ndarray,
-    keys: dict[str, bool],
-    key_size: tuple[int, int] = (30, 30),
-    top_margin: int = 15,
-) -> None:
-    if not _require_cv2():
-        return
-
-    left_margin = 15
-    gap = 3
-    key_positions = {
-        "W": (left_margin + key_size[0] + gap, top_margin),
-        "A": (left_margin, top_margin + key_size[1] + gap),
-        "S": (left_margin + key_size[0] + gap, top_margin + key_size[1] + gap),
-        "D": (
-            left_margin + (key_size[0] + gap) * 2,
-            top_margin + key_size[1] + gap,
-        ),
-    }
-
-    for key, (x, y) in key_positions.items():
-        pressed = keys.get(key, False)
-        color = (0, 255, 0) if pressed else (200, 200, 200)
-        alpha = 0.8 if pressed else 0.5
-        draw_rounded_rectangle(
-            frame,
-            (x, y),
-            (x + key_size[0], y + key_size[1]),
-            color,
-            radius=5,
-            alpha=alpha,
-        )
-        text_size = cv2.getTextSize(
-            key, cv2.FONT_HERSHEY_SIMPLEX, 0.5, 1
-        )[0]
-        text_x = x + (key_size[0] - text_size[0]) // 2
-        text_y = y + (key_size[1] + text_size[1]) // 2
-        cv2.putText(
-            frame,
-            key,
-            (text_x, text_y),
-            cv2.FONT_HERSHEY_SIMPLEX,
-            0.5,
-            (0, 0, 0),
-            1,
-        )
-
-
-def draw_mouse_on_frame(
-    frame: np.ndarray,
-    yaw: float,
-    pitch: float,
-    top_margin: int = 15,
-) -> None:
-    if not _require_cv2():
-        return
-
-    _, width, _ = frame.shape
-    right_margin = 15
-    crosshair_radius = 25
-    crosshair_x = width - right_margin - crosshair_radius
-    crosshair_y = top_margin + crosshair_radius
-
-    dx = int(yaw * crosshair_radius * 8)
-    dy = int(-pitch * crosshair_radius * 8)
-    max_arrow = crosshair_radius - 5
-    dx = max(-max_arrow, min(max_arrow, dx))
-    dy = max(-max_arrow, min(max_arrow, dy))
-
-    cv2.circle(frame, (crosshair_x, crosshair_y), crosshair_radius, (50, 50, 50), -1)
-    cv2.circle(frame, (crosshair_x, crosshair_y), crosshair_radius, (200, 200, 200), 1)
-    cv2.line(
-        frame,
-        (crosshair_x - crosshair_radius + 5, crosshair_y),
-        (crosshair_x + crosshair_radius - 5, crosshair_y),
-        (100, 100, 100),
-        1,
-    )
-    cv2.line(
-        frame,
-        (crosshair_x, crosshair_y - crosshair_radius + 5),
-        (crosshair_x, crosshair_y + crosshair_radius - 5),
-        (100, 100, 100),
-        1,
-    )
-
-    if abs(dx) > 1 or abs(dy) > 1:
-        cv2.arrowedLine(
-            frame,
-            (crosshair_x, crosshair_y),
-            (crosshair_x + dx, crosshair_y + dy),
-            (0, 255, 0),
-            2,
-            tipLength=0.3,
-        )
-
-
-def overlay_validation_actions_on_frames(
-    frames: list[np.ndarray],
-    keyboard_cond: np.ndarray | torch.Tensor | None = None,
-    mouse_cond: np.ndarray | torch.Tensor | None = None,
-) -> list[np.ndarray]:
-    if (keyboard_cond is None and mouse_cond is None) or not _require_cv2():
-        return frames
-
-    if keyboard_cond is not None and torch.is_tensor(keyboard_cond):
-        keyboard_cond = keyboard_cond.detach().cpu().float().numpy()
-    if mouse_cond is not None and torch.is_tensor(mouse_cond):
-        mouse_cond = mouse_cond.detach().cpu().float().numpy()
-
-    if keyboard_cond is not None:
-        keyboard_cond = np.asarray(keyboard_cond, dtype=np.float32)
-        if keyboard_cond.ndim == 3 and keyboard_cond.shape[0] == 1:
-            keyboard_cond = keyboard_cond[0]
-    if mouse_cond is not None:
-        mouse_cond = np.asarray(mouse_cond, dtype=np.float32)
-        if mouse_cond.ndim == 3 and mouse_cond.shape[0] == 1:
-            mouse_cond = mouse_cond[0]
-
-    processed_frames: list[np.ndarray] = []
-    for frame_idx, frame in enumerate(frames):
-        frame = np.ascontiguousarray(frame.copy())
-        if keyboard_cond is not None and frame_idx < len(keyboard_cond):
-            draw_keys_on_frame(
-                frame,
-                _matrixgame2_overlay_keys_from_keyboard(keyboard_cond[frame_idx]),
-            )
-        if mouse_cond is not None and frame_idx < len(mouse_cond):
-            # MG action convention: mouse[0]=pitch, mouse[1]=yaw.
-            pitch = float(mouse_cond[frame_idx, 0])
-            yaw = float(mouse_cond[frame_idx, 1])
-            draw_mouse_on_frame(frame, yaw=yaw, pitch=pitch)
-        processed_frames.append(frame)
-
-    return processed_frames
-
-
-def scale_keyboard_condition(
-    keyboard_condition: torch.Tensor,
-    scale: float,
-) -> torch.Tensor:
-    if float(scale) == 1.0:
-        return keyboard_condition
-    return keyboard_condition * float(scale)
-

 def expand_action_to_frames(action: dict, num_frames: int) -> tuple[torch.Tensor, torch.Tensor]:
    result = {}
@@ -467,18 +467,6 @@ class Qwen2_5_VisionTransformerPretrainedModel(nn.Module):
        return hidden_states


-def _compute_default_rope_parameters(config, device=None, seq_len=None, **kwargs):
-    # transformers>=5 removes the "default" entry from ROPE_INIT_FUNCTIONS and
-    # moves rope_theta inside rope_parameters; replicate the 4.x default init.
-    rope_params = getattr(config, "rope_parameters", None) or getattr(config, "rope_scaling", None) or {}
-    base = rope_params.get("rope_theta", getattr(config, "rope_theta", 10000.0))
-    head_dim = getattr(config, "head_dim", None) or config.hidden_size // config.num_attention_heads
-    partial_rotary_factor = getattr(config, "partial_rotary_factor", 1.0)
-    dim = int(head_dim * partial_rotary_factor)
-    inv_freq = 1.0 / (base**(torch.arange(0, dim, 2, dtype=torch.int64).float().to(device) / dim))
-    return inv_freq, 1.0
-
-
 class Qwen2_5_VLRotaryEmbedding(nn.Module):
    def __init__(self, config: Qwen2_5_VLConfig, device=None):
        super().__init__()
@@ -491,14 +479,7 @@ class Qwen2_5_VLRotaryEmbedding(nn.Module):
        self.original_max_seq_len = config.max_position_embeddings

        self.config = config
-        if self.rope_type in ROPE_INIT_FUNCTIONS:
-            self.rope_init_fn = ROPE_INIT_FUNCTIONS[self.rope_type]
-        elif self.rope_type == "default":
-            # transformers>=5 drops the "default" entry from ROPE_INIT_FUNCTIONS.
-            self.rope_init_fn = _compute_default_rope_parameters
-        else:
-            raise KeyError(f"Unsupported rope_type '{self.rope_type}'; available: "
-                           f"{['default', *ROPE_INIT_FUNCTIONS]}")
+        self.rope_init_fn = ROPE_INIT_FUNCTIONS[self.rope_type]

        inv_freq, self.attention_scaling = self.rope_init_fn(self.config, device)
        self.register_buffer("inv_freq", inv_freq, persistent=False)
@@ -967,16 +948,6 @@ QWEN2_5_VL_ATTENTION_CLASSES = {
 # If FlashAttention2 is not available, transparently fall back to SDPA.
 if not is_flash_attn_2_available():
    QWEN2_5_VL_ATTENTION_CLASSES["flash_attention_2"] = Qwen2_5_VLSdpaAttention
-else:
-    # transformers>=5 only resolves the flash-attn functions when the model
-    # preloads them via its attention interface; this module bypasses
-    # PreTrainedModel, so _flash_attention_forward(implementation=None) raises
-    # unless we preload here.
-    try:
-        from transformers.modeling_flash_attention_utils import lazy_import_flash_attention
-        lazy_import_flash_attention("flash_attention_2")
-    except (ImportError, ValueError):
-        QWEN2_5_VL_ATTENTION_CLASSES["flash_attention_2"] = Qwen2_5_VLSdpaAttention
    
 class Qwen2_5_VLDecoderLayer(nn.Module):
    def __init__(self, config: Qwen2_5_VLConfig, layer_idx: int):
@@ -1064,7 +1035,7 @@ class Qwen2_5_VLModel(nn.Module):
    def __init__(self, config: Qwen2_5_VLConfig):
        super().__init__()
        self.config = config
-        self.padding_idx = getattr(config, "pad_token_id", None)
+        self.padding_idx = config.pad_token_id
        self.vocab_size = config.vocab_size

        self.embed_tokens = nn.Embedding(config.vocab_size, config.hidden_size, self.padding_idx)
@@ -1437,18 +1408,6 @@ class Qwen2_5_VLCausalLMOutputWithPast(ModelOutput):
    rope_deltas: Optional[torch.LongTensor] = None


-def _flatten_text_config(config):
-    # transformers>=5 stops forwarding text-model attributes (hidden_size,
-    # vocab_size, rope_scaling, ...) from the composite Qwen2_5_VLConfig to
-    # config.text_config; this module reads them from the top level.
-    text_config = getattr(config, "text_config", None)
-    if text_config is not None:
-        for key, value in text_config.to_dict().items():
-            if not hasattr(config, key):
-                setattr(config, key, value)
-    return config
-
-
 class Qwen2_5_VLForConditionalGenerationSimple(nn.Module):
    _tied_weights_keys = ["lm_head.weight"]
    config_class = Qwen2_5_VLConfig
@@ -1456,7 +1415,6 @@ class Qwen2_5_VLForConditionalGenerationSimple(nn.Module):

    def __init__(self, config):
        super().__init__()
-        config = _flatten_text_config(config)
        self.config = config
        self.visual = Qwen2_5_VisionTransformerPretrainedModel(config.vision_config)

@@ -320,19 +320,6 @@ class TextEncoderLoader(ComponentLoader):
                f"text encoder index {idx} out of range for text_encoder_configs (len={len(encoder_configs)}), model_path={model_path}"
            )
        encoder_config = encoder_configs[idx]
-        if (
-            model_config.get("architectures") == ["CLIPModel"]
-            and isinstance(model_config.get("text_config"), dict)
-        ):
-            valid_arch_fields = {
-                f.name for f in dataclasses.fields(encoder_config.arch_config)
-            }
-            model_config = {
-                key: value
-                for key, value in deepcopy(model_config["text_config"]).items()
-                if key in valid_arch_fields
-            }
-            model_config["architectures"] = ["CLIPTextModel"]
        encoder_config.update_model_arch(model_config)
        if idx < 0 or idx >= len(encoder_precisions):
            raise IndexError(
@@ -417,9 +404,7 @@ class TextEncoderLoader(ComponentLoader):
            else:
                loaded_weights: set[str] = model.load_weights(
                    self._get_all_weights(
-                        model,
-                        model_path,
-                        to_cpu=fastvideo_args.text_encoder_cpu_offload,
+                        model, model_path, to_cpu=use_cpu_offload
                    )
                )  # type: ignore

@@ -1,9 +1,7 @@
 # SPDX-License-Identifier: Apache-2.0

-import io
 import os
 import tempfile
-import time
 from collections.abc import Callable
 from typing import Any
 from urllib.parse import unquote, urlparse
@@ -18,10 +16,6 @@ import torch.nn.functional as F
 import torchvision.transforms.functional as TF
 from packaging import version

-from fastvideo.logger import init_logger
-
-logger = init_logger(__name__)
-
 if version.parse(version.parse(
        PIL.__version__).base_version) >= version.parse("9.1.0"):
    PIL_INTERPOLATION = {
@@ -95,39 +89,6 @@ def normalize(images: np.ndarray | torch.Tensor) -> np.ndarray | torch.Tensor:
    return 2.0 * images - 1.0


-def _fetch_image_bytes(url: str,
-                       attempts: int = 3,
-                       timeout: float = 30.0) -> bytes:
-    """Download ``url`` fully, retrying transient network errors.
-
-    Reads the whole body via ``response.content`` instead of handing PIL a
-    ``.raw`` stream: a connection dropped mid-body (e.g. an HF-CDN
-    ``IncompleteRead``) then fails here, where it can be retried, instead of
-    surfacing as a truncated image inside PIL.
-    """
-    for attempt in range(attempts):
-        try:
-            response = requests.get(url, timeout=timeout)
-            response.raise_for_status()
-            return response.content
-        except requests.RequestException as e:
-            status = getattr(getattr(e, "response", None), "status_code",
-                             None)
-            # Permanent client errors (4xx except 408/429) won't heal on
-            # retry — fail fast.
-            if (status is not None and 400 <= status < 500
-                    and status not in (408, 429)):
-                raise
-            if attempt == attempts - 1:
-                raise
-            backoff = 2**attempt
-            logger.warning(
-                "Failed to download image %s (attempt %d/%d): %s. "
-                "Retrying in %ds.", url, attempt + 1, attempts, e, backoff)
-            time.sleep(backoff)
-    raise AssertionError("unreachable")
-
-
 # adapted from diffusers.utils import load_image
 def load_image(
    image: str | PIL.Image.Image,
@@ -149,7 +110,7 @@ def load_image(
    """
    if isinstance(image, str):
        if image.startswith("http://") or image.startswith("https://"):
-            image = PIL.Image.open(io.BytesIO(_fetch_image_bytes(image)))
+            image = PIL.Image.open(requests.get(image, stream=True).raw)
        elif os.path.isfile(image):
            image = PIL.Image.open(image)
        else:
@@ -86,32 +86,20 @@ def record_metadata(record: Record) -> Record:
    }


-def _cohort_metadata_value(value: Any) -> Any:
-    if value is None:
-        return ""
-    if isinstance(value, str) and not value.strip():
-        return ""
-    return value
-
-
-def _cohort_key_value(value: Any) -> str:
-    return str(_cohort_metadata_value(value))
-
-
 def record_comparison_metadata(record: Record) -> Record:
-    return {key: _cohort_metadata_value(record.get(key)) for key in COMPARISON_COHORT_KEYS}
+    return {key: record.get(key) or "" for key in COMPARISON_COHORT_KEYS}


 def comparison_cohort_key(record: Record) -> CohortKey:
    return (
        str(record.get("model_id") or "unknown"),
        str(record.get("gpu_type") or "unknown"),
-        _cohort_key_value(record.get("workload_id")),
-        _cohort_key_value(record.get("variant_id")),
-        _cohort_key_value(record.get("benchmark_version")),
-        _cohort_key_value(record.get("recipe_fingerprint")),
-        _cohort_key_value(record.get("hardware_profile_id")),
-        _cohort_key_value(record.get("software_profile_id")),
+        str(record.get("workload_id") or ""),
+        str(record.get("variant_id") or ""),
+        str(record.get("benchmark_version") or ""),
+        str(record.get("recipe_fingerprint") or ""),
+        str(record.get("hardware_profile_id") or ""),
+        str(record.get("software_profile_id") or ""),
    )


@@ -158,10 +146,9 @@ def build_latest_summary(records: list[Record],
            continue

        latest = latest_candidates[-1]
-        latest_index = next(index for index, record in enumerate(group) if record is latest)
        baseline_pool = [
-            record for record in group[:latest_index]
-            if record.get("success", True) and is_baseline_eligible_record(record)
+            record for record in group
+            if record is not latest and record.get("success", True) and is_baseline_eligible_record(record)
        ]
        baseline_records = baseline_pool[-baseline_window:]
        metric_policies = resolve_metric_policies(latest.get("regression_thresholds"))
@@ -1 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
@@ -1,89 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-
-from __future__ import annotations
-
-from fastvideo.fastvideo_args import FastVideoArgs
-from fastvideo.pipelines.composed_pipeline_base import ComposedPipelineBase
-from fastvideo.pipelines.stages.input_validation import InputValidationStage
-from fastvideo.pipelines.stages.kandinsky5 import (
-    Kandinsky5DecodingStage,
-    Kandinsky5DenoisingStage,
-    Kandinsky5ImageEncodingStage,
-    Kandinsky5LatentPreparationStage,
-    Kandinsky5NormalizationStage,
-)
-from fastvideo.pipelines.stages.text_encoding import TextEncodingStage
-from fastvideo.pipelines.stages.timestep_preparation import TimestepPreparationStage
-
-
-class Kandinsky5I2VPipeline(ComposedPipelineBase):
-    """Kandinsky-5.0 image-to-video pipeline."""
-
-    _required_config_modules = [
-        "scheduler",
-        "text_encoder",
-        "text_encoder_2",
-        "tokenizer",
-        "tokenizer_2",
-        "transformer",
-        "vae",
-    ]
-
-    def create_pipeline_stages(self, fastvideo_args: FastVideoArgs) -> None:
-        self.add_stage(stage_name="input_validation_stage", stage=InputValidationStage())
-
-        self.add_stage(
-            stage_name="text_encoding_stage",
-            stage=TextEncodingStage(
-                text_encoders=[
-                    self.get_module("text_encoder"),
-                    self.get_module("text_encoder_2"),
-                ],
-                tokenizers=[
-                    self.get_module("tokenizer"),
-                    self.get_module("tokenizer_2"),
-                ],
-            ),
-        )
-
-        self.add_stage(
-            stage_name="timestep_preparation_stage",
-            stage=TimestepPreparationStage(scheduler=self.get_module("scheduler")),
-        )
-
-        self.add_stage(
-            stage_name="latent_preparation_stage",
-            stage=Kandinsky5LatentPreparationStage(
-                scheduler=self.get_module("scheduler"),
-                transformer=self.get_module("transformer"),
-            ),
-        )
-
-        # Runs AFTER latent preparation so the initial noise is the seeded
-        # generator's first draw (official kandinsky-5 RNG order); this stage
-        # then samples the image latent and places it into the latents.
-        self.add_stage(
-            stage_name="image_encoding_stage",
-            stage=Kandinsky5ImageEncodingStage(vae=self.get_module("vae")),
-        )
-
-        self.add_stage(
-            stage_name="denoising_stage",
-            stage=Kandinsky5DenoisingStage(
-                transformer=self.get_module("transformer"),
-                scheduler=self.get_module("scheduler"),
-            ),
-        )
-
-        self.add_stage(
-            stage_name="normalization_stage",
-            stage=Kandinsky5NormalizationStage(),
-        )
-
-        self.add_stage(
-            stage_name="decoding_stage",
-            stage=Kandinsky5DecodingStage(vae=self.get_module("vae"), pipeline=self),
-        )
-
-
-EntryClass = Kandinsky5I2VPipeline
@@ -1,74 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-
-from __future__ import annotations
-
-from fastvideo.fastvideo_args import FastVideoArgs
-from fastvideo.pipelines.composed_pipeline_base import ComposedPipelineBase
-from fastvideo.pipelines.stages.input_validation import InputValidationStage
-from fastvideo.pipelines.stages.kandinsky5 import (
-    Kandinsky5DecodingStage,
-    Kandinsky5DenoisingStage,
-    Kandinsky5LatentPreparationStage,
-)
-from fastvideo.pipelines.stages.text_encoding import TextEncodingStage
-from fastvideo.pipelines.stages.timestep_preparation import TimestepPreparationStage
-
-
-class Kandinsky5T2VPipeline(ComposedPipelineBase):
-    """Kandinsky-5.0 Lite text-to-video pipeline."""
-
-    _required_config_modules = [
-        "scheduler",
-        "text_encoder",
-        "text_encoder_2",
-        "tokenizer",
-        "tokenizer_2",
-        "transformer",
-        "vae",
-    ]
-
-    def create_pipeline_stages(self, fastvideo_args: FastVideoArgs) -> None:
-        self.add_stage(stage_name="input_validation_stage", stage=InputValidationStage())
-
-        self.add_stage(
-            stage_name="text_encoding_stage",
-            stage=TextEncodingStage(
-                text_encoders=[
-                    self.get_module("text_encoder"),
-                    self.get_module("text_encoder_2"),
-                ],
-                tokenizers=[
-                    self.get_module("tokenizer"),
-                    self.get_module("tokenizer_2"),
-                ],
-            ),
-        )
-
-        self.add_stage(
-            stage_name="timestep_preparation_stage",
-            stage=TimestepPreparationStage(scheduler=self.get_module("scheduler")),
-        )
-
-        self.add_stage(
-            stage_name="latent_preparation_stage",
-            stage=Kandinsky5LatentPreparationStage(
-                scheduler=self.get_module("scheduler"),
-                transformer=self.get_module("transformer"),
-            ),
-        )
-
-        self.add_stage(
-            stage_name="denoising_stage",
-            stage=Kandinsky5DenoisingStage(
-                transformer=self.get_module("transformer"),
-                scheduler=self.get_module("scheduler"),
-            ),
-        )
-
-        self.add_stage(
-            stage_name="decoding_stage",
-            stage=Kandinsky5DecodingStage(vae=self.get_module("vae"), pipeline=self),
-        )
-
-
-EntryClass = Kandinsky5T2VPipeline
@@ -1,165 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-"""Kandinsky-5 model family pipeline presets."""
-
-from fastvideo.api.presets import InferencePreset, PresetStageSpec
-
-_NEGATIVE_PROMPT = ("Static, 2D cartoon, cartoon, 2d animation, paintings, images, worst quality, low quality, ugly, "
-                    "deformed, walking backwards")
-
-_DENOISE_STAGE = PresetStageSpec(
-    name="denoise",
-    kind="denoising",
-    description="Main Kandinsky-5 denoising pass",
-    allowed_overrides=frozenset({
-        "num_inference_steps",
-        "guidance_scale",
-    }),
-)
-
-KANDINSKY5_T2V_LITE_5S = InferencePreset(
-    name="kandinsky5_t2v_lite_5s",
-    version=1,
-    model_family="kandinsky5",
-    description="Kandinsky-5.0 Lite T2V 5s",
-    workload_type="t2v",
-    stage_schemas=(_DENOISE_STAGE, ),
-    defaults={
-        "height": 512,
-        "width": 768,
-        "num_frames": 121,
-        "fps": 24,
-        "guidance_scale": 5.0,
-        "num_inference_steps": 50,
-        "negative_prompt": _NEGATIVE_PROMPT,
-    },
-)
-
-KANDINSKY5_T2V_LITE_DISTILLED_5S = InferencePreset(
-    name="kandinsky5_t2v_lite_distilled_5s",
-    version=1,
-    model_family="kandinsky5",
-    description="Kandinsky-5.0 Lite T2V Distilled 5s",
-    workload_type="t2v",
-    stage_schemas=(_DENOISE_STAGE, ),
-    defaults={
-        "height": 512,
-        "width": 768,
-        "num_frames": 121,
-        "fps": 24,
-        "guidance_scale": 1.0,
-        "num_inference_steps": 16,
-        "negative_prompt": _NEGATIVE_PROMPT,
-    },
-)
-
-KANDINSKY5_T2V_PRO_5S = InferencePreset(
-    name="kandinsky5_t2v_pro_5s",
-    version=1,
-    model_family="kandinsky5",
-    description="Kandinsky-5.0 Pro T2V 5s",
-    workload_type="t2v",
-    stage_schemas=(_DENOISE_STAGE, ),
-    defaults={
-        "height": 512,
-        "width": 768,
-        "num_frames": 121,
-        "fps": 24,
-        "guidance_scale": 5.0,
-        "num_inference_steps": 50,
-        "negative_prompt": _NEGATIVE_PROMPT,
-    },
-)
-
-KANDINSKY5_T2V_PRO_DISTILLED_5S = InferencePreset(
-    name="kandinsky5_t2v_pro_distilled_5s",
-    version=1,
-    model_family="kandinsky5",
-    description="Kandinsky-5.0 Pro T2V Distilled 5s",
-    workload_type="t2v",
-    stage_schemas=(_DENOISE_STAGE, ),
-    defaults={
-        "height": 512,
-        "width": 768,
-        "num_frames": 121,
-        "fps": 24,
-        "guidance_scale": 1.0,
-        "num_inference_steps": 16,
-        "negative_prompt": _NEGATIVE_PROMPT,
-    },
-)
-
-KANDINSKY5_I2V_LITE_5S = InferencePreset(
-    name="kandinsky5_i2v_lite_5s",
-    version=1,
-    model_family="kandinsky5",
-    description="Kandinsky-5.0 Lite I2V 5s",
-    workload_type="i2v",
-    stage_schemas=(_DENOISE_STAGE, ),
-    defaults={
-        "height": 512,
-        "width": 768,
-        "num_frames": 121,
-        "fps": 24,
-        "guidance_scale": 5.0,
-        "num_inference_steps": 50,
-        "negative_prompt": _NEGATIVE_PROMPT,
-    },
-)
-
-KANDINSKY5_I2V_PRO_5S = InferencePreset(
-    name="kandinsky5_i2v_pro_5s",
-    version=1,
-    model_family="kandinsky5",
-    description="Kandinsky-5.0 Pro I2V 5s",
-    workload_type="i2v",
-    stage_schemas=(_DENOISE_STAGE, ),
-    defaults={
-        "height": 512,
-        "width": 768,
-        "num_frames": 121,
-        "fps": 24,
-        "guidance_scale": 5.0,
-        "num_inference_steps": 50,
-        "negative_prompt": _NEGATIVE_PROMPT,
-    },
-)
-
-KANDINSKY5_I2V_LITE_DISTILLED_5S = InferencePreset(
-    name="kandinsky5_i2v_lite_distilled_5s",
-    version=1,
-    model_family="kandinsky5",
-    description="Kandinsky-5.0 Lite I2V Distilled 5s",
-    workload_type="i2v",
-    stage_schemas=(_DENOISE_STAGE, ),
-    defaults={
-        "height": 512,
-        "width": 768,
-        "num_frames": 121,
-        "fps": 24,
-        "guidance_scale": 1.0,
-        "num_inference_steps": 16,
-        "negative_prompt": _NEGATIVE_PROMPT,
-    },
-)
-
-KANDINSKY5_I2V_PRO_DISTILLED_5S = InferencePreset(
-    name="kandinsky5_i2v_pro_distilled_5s",
-    version=1,
-    model_family="kandinsky5",
-    description="Kandinsky-5.0 Pro I2V Distilled 5s",
-    workload_type="i2v",
-    stage_schemas=(_DENOISE_STAGE, ),
-    defaults={
-        "height": 512,
-        "width": 768,
-        "num_frames": 121,
-        "fps": 24,
-        "guidance_scale": 1.0,
-        "num_inference_steps": 16,
-        "negative_prompt": _NEGATIVE_PROMPT,
-    },
-)
-
-ALL_PRESETS = (KANDINSKY5_T2V_LITE_5S, KANDINSKY5_T2V_LITE_DISTILLED_5S, KANDINSKY5_T2V_PRO_5S,
-               KANDINSKY5_T2V_PRO_DISTILLED_5S, KANDINSKY5_I2V_LITE_5S, KANDINSKY5_I2V_LITE_DISTILLED_5S,
-               KANDINSKY5_I2V_PRO_5S, KANDINSKY5_I2V_PRO_DISTILLED_5S)
@@ -19,39 +19,6 @@ from fastvideo.pipelines.stages import (DecodingStage, InputValidationStage, LTX
 logger = init_logger(__name__)


-def _resolve_refine_path(model_path: str, value: str | None) -> str | None:
-    """Resolve a refine component path, preferring paths inside the local
-    model snapshot when the value is relative."""
-    if value is None:
-        return None
-    if os.path.isabs(value):
-        return value
-    candidate = os.path.join(model_path, value)
-    if os.path.exists(candidate):
-        return candidate
-    return value
-
-
-def _resolve_refine_upsampler_path(model_path: str, model_index: dict[str, Any]) -> str | None:
-    """Resolve the refine upsampler directory for a local model snapshot.
-
-    model_index.json keys ("fastvideo_refine_upsampler_path", then
-    "spatial_upsampler") are the documented override and win when present.
-    Otherwise probe the snapshot root: published LTX-2 distilled checkpoints
-    bundle the upsampler weights on disk (spelled "spatial_upscaler")
-    without declaring them in model_index.json.
-    """
-    path = _resolve_refine_path(model_path, model_index.get("fastvideo_refine_upsampler_path"))
-    if path is None and "spatial_upsampler" in model_index:
-        path = _resolve_refine_path(model_path, "spatial_upsampler")
-    if path is None:
-        for dirname in ("spatial_upscaler", "spatial_upsampler"):
-            candidate = os.path.join(model_path, dirname)
-            if os.path.isdir(candidate):
-                return candidate
-    return path
-
-
 class LTX2Pipeline(LoRAPipeline):

    _required_config_modules = [
@@ -222,16 +189,28 @@ class LTX2Pipeline(LoRAPipeline):
        # Apply optional FastVideo-specific refine defaults embedded in
        # model_index.json. These are bundled with distilled checkpoints
        # so the pipeline can self-configure without explicit user kwargs.
+        def _resolve_refine_path(value: str | None) -> str | None:
+            if value is None:
+                return None
+            if os.path.isabs(value):
+                return value
+            candidate = os.path.join(self.model_path, value)
+            if os.path.exists(candidate):
+                return candidate
+            return value
+
        if (model_index.get("fastvideo_refine_enabled") is True and fastvideo_args.refine_enabled is None):
            fastvideo_args.ltx2_refine_enabled = True
        if (fastvideo_args.refine_upsampler_path is None and fastvideo_args.ltx2_refine_upsampler_path is None):
-            fastvideo_args.ltx2_refine_upsampler_path = (_resolve_refine_upsampler_path(self.model_path, model_index))
+            fastvideo_args.ltx2_refine_upsampler_path = _resolve_refine_path(
+                model_index.get("fastvideo_refine_upsampler_path"))
+            if (fastvideo_args.ltx2_refine_upsampler_path is None and "spatial_upsampler" in model_index):
+                fastvideo_args.ltx2_refine_upsampler_path = (_resolve_refine_path("spatial_upsampler"))
        if (fastvideo_args.refine_transformer_path is None and fastvideo_args.ltx2_refine_transformer_path is None):
            fastvideo_args.ltx2_refine_transformer_path = (_resolve_refine_path(
-                self.model_path, model_index.get("fastvideo_refine_transformer_path")))
+                model_index.get("fastvideo_refine_transformer_path")))
        if (fastvideo_args.refine_lora_path is None and fastvideo_args.ltx2_refine_lora_path is None):
-            fastvideo_args.ltx2_refine_lora_path = _resolve_refine_path(self.model_path,
-                                                                        model_index.get("fastvideo_refine_lora_path"))
+            fastvideo_args.ltx2_refine_lora_path = _resolve_refine_path(model_index.get("fastvideo_refine_lora_path"))
        if (fastvideo_args.refine_num_inference_steps is None
                and fastvideo_args.ltx2_refine_num_inference_steps == FastVideoArgs.ltx2_refine_num_inference_steps
                and model_index.get("fastvideo_refine_num_inference_steps") is not None):
@@ -247,11 +226,10 @@ class LTX2Pipeline(LoRAPipeline):
        if (fastvideo_args.refine_add_noise is None and model_index.get("fastvideo_refine_add_noise") is not None):
            fastvideo_args.ltx2_refine_add_noise = bool(model_index["fastvideo_refine_add_noise"])
        if (fastvideo_args.refine_noise_path is None and fastvideo_args.ltx2_refine_noise_path is None):
-            fastvideo_args.ltx2_refine_noise_path = _resolve_refine_path(self.model_path,
-                                                                         model_index.get("fastvideo_refine_noise_path"))
+            fastvideo_args.ltx2_refine_noise_path = _resolve_refine_path(model_index.get("fastvideo_refine_noise_path"))
        if (fastvideo_args.refine_audio_noise_path is None and fastvideo_args.ltx2_refine_audio_noise_path is None):
            fastvideo_args.ltx2_refine_audio_noise_path = (_resolve_refine_path(
-                self.model_path, model_index.get("fastvideo_refine_audio_noise_path")))
+                model_index.get("fastvideo_refine_audio_noise_path")))

        model_index.pop("_class_name")
        model_index.pop("_diffusers_version")
@@ -33,8 +33,6 @@ from fastvideo.pipelines.basic.ltx2.stages import (  # noqa: F401
 from fastvideo.pipelines.stages.matrixgame2_denoising import MatrixGame2CausalDenoisingStage
 from fastvideo.pipelines.stages.matrixgame3_denoising import MatrixGame3DenoisingStage
 from fastvideo.pipelines.stages.hyworld_denoising import HYWorldDenoisingStage
-from fastvideo.pipelines.stages.kandinsky5 import (Kandinsky5DecodingStage, Kandinsky5DenoisingStage,
-                                                   Kandinsky5LatentPreparationStage)
 from fastvideo.pipelines.stages.gamecraft_denoising import GameCraftDenoisingStage
 from fastvideo.pipelines.stages.gen3c_stages import (Gen3CCFGPolicyStage, Gen3CConditioningStage, Gen3CDenoisingStage,
                                                     Gen3CLatentPreparationStage)
@@ -67,9 +65,6 @@ __all__ = [
    "MatrixGame2CausalDenoisingStage",
    "MatrixGame3DenoisingStage",
    "HYWorldDenoisingStage",
-    "Kandinsky5DecodingStage",
-    "Kandinsky5DenoisingStage",
-    "Kandinsky5LatentPreparationStage",
    "GameCraftDenoisingStage",
    "Gen3CCFGPolicyStage",
    "Gen3CConditioningStage",
@@ -1,545 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-
-from __future__ import annotations
-
-import contextlib
-from typing import Any
-
-import PIL
-import torch
-from diffusers.utils.torch_utils import randn_tensor
-from tqdm.auto import tqdm
-
-from fastvideo.attention.backends.nabla import NablaAttentionMetadataBuilder
-from fastvideo.distributed import get_local_torch_device
-from fastvideo.fastvideo_args import FastVideoArgs
-from fastvideo.forward_context import set_forward_context
-from fastvideo.logger import init_logger
-from fastvideo.models.loader.component_loader import TransformerLoader, VAELoader
-from fastvideo.models.vaes.common import ParallelTiledVAE
-from fastvideo.models.vision_utils import normalize, numpy_to_pt, pil_to_numpy, resize
-from fastvideo.pipelines.pipeline_batch_info import ForwardBatch
-from fastvideo.pipelines.stages.base import PipelineStage
-from fastvideo.pipelines.stages.decoding import DecodingStage
-from fastvideo.pipelines.stages.encoding import EncodingStage
-from fastvideo.pipelines.stages.validators import StageValidators as V
-from fastvideo.pipelines.stages.validators import VerificationResult
-from fastvideo.utils import PRECISION_TO_TYPE
-
-logger = init_logger(__name__)
-
-
-class Kandinsky5LatentPreparationStage(PipelineStage):
-
-    def __init__(self, scheduler, transformer) -> None:
-        super().__init__()
-        self.scheduler = scheduler
-        self.transformer = transformer
-
-    def forward(self, batch: ForwardBatch, fastvideo_args: FastVideoArgs) -> ForwardBatch:
-        if batch.height is None or batch.width is None:
-            raise ValueError("height and width must be provided for Kandinsky5.")
-        height = int(batch.height)
-        width = int(batch.width)
-        num_frames = int(batch.num_frames)
-
-        temporal_ratio = fastvideo_args.pipeline_config.vae_config.arch_config.temporal_compression_ratio
-        spatial_ratio = fastvideo_args.pipeline_config.vae_config.arch_config.spatial_compression_ratio
-        patch_size = fastvideo_args.pipeline_config.dit_config.arch_config.patch_size
-
-        if num_frames % temporal_ratio != 1:
-            num_frames = num_frames // temporal_ratio * temporal_ratio + 1
-            batch.num_frames = num_frames
-
-        required_divisor_h = spatial_ratio * patch_size[1]
-        required_divisor_w = spatial_ratio * patch_size[2]
-        if height % required_divisor_h != 0 or width % required_divisor_w != 0:
-            raise ValueError(f"Kandinsky5 height must be divisible by {required_divisor_h} and width by "
-                             f"{required_divisor_w}; "
-                             f"got height={height}, width={width}.")
-
-        # NABLA sparse attention (Pro checkpoints) reshapes the post-patch grid
-        # into 8x8 blocks; validate here instead of crashing mid-denoise after
-        # all the encoding work is done.
-        arch_cfg = getattr(self.transformer, "config", None) or fastvideo_args.pipeline_config.dit_config.arch_config
-        if getattr(arch_cfg, "attention_type", "regular") == "nabla":
-            nabla_divisor_h = required_divisor_h * 8
-            nabla_divisor_w = required_divisor_w * 8
-            if height % nabla_divisor_h != 0 or width % nabla_divisor_w != 0:
-                raise ValueError(f"Kandinsky5 NABLA checkpoints require height divisible by {nabla_divisor_h} and "
-                                 f"width divisible by {nabla_divisor_w}; "
-                                 f"got height={height}, width={width}.")
-
-        if isinstance(batch.prompt, list):
-            batch_size = len(batch.prompt)
-        elif batch.prompt is not None:
-            batch_size = 1
-        else:
-            batch_size = batch.prompt_embeds[0].shape[0]
-        batch_size *= batch.num_videos_per_prompt
-
-        dtype = PRECISION_TO_TYPE[fastvideo_args.pipeline_config.dit_precision]
-        device = get_local_torch_device()
-        num_latent_frames = (num_frames - 1) // temporal_ratio + 1
-        num_channels = getattr(
-            self.transformer,
-            "in_visual_dim",
-            fastvideo_args.pipeline_config.dit_config.arch_config.in_visual_dim,
-        )
-        shape = (
-            batch_size,
-            num_latent_frames,
-            height // spatial_ratio,
-            width // spatial_ratio,
-            num_channels,
-        )
-
-        if isinstance(batch.generator, list) and len(batch.generator) != batch_size:
-            raise ValueError(f"generator list length {len(batch.generator)} does not match batch size {batch_size}.")
-
-        visual_cond = getattr(self.transformer, "visual_cond", False)
-
-        if batch.latents is None:
-            latents = randn_tensor(shape, generator=batch.generator, device=device, dtype=dtype)
-            if hasattr(self.scheduler, "init_noise_sigma"):
-                latents = latents * self.scheduler.init_noise_sigma
-        else:
-            valid_shapes = [shape]
-            if visual_cond:
-                valid_shapes.append((*shape[:-1], num_channels * 2 + 1))
-            if tuple(batch.latents.shape) not in valid_shapes:
-                raise ValueError(f"Provided latents shape {list(batch.latents.shape)} does not match expected "
-                                 f"Kandinsky5 latent shape(s): {[list(s) for s in valid_shapes]}.")
-            latents = batch.latents.to(device=device, dtype=dtype)
-
-        if visual_cond and latents.shape[-1] == num_channels:
-            cond = torch.zeros_like(latents)
-            cond_mask = torch.zeros(
-                (*latents.shape[:-1], 1),
-                device=latents.device,
-                dtype=latents.dtype,
-            )
-            latents = torch.cat([latents, cond, cond_mask], dim=-1)
-
-        # I2V image conditioning is placed by Kandinsky5ImageEncodingStage,
-        # which runs AFTER this stage so the initial noise is the generator's
-        # first draw (matching the official kandinskylab/kandinsky-5 order).
-        batch.latents = latents
-        batch.raw_latent_shape = (
-            batch_size,
-            num_channels,
-            num_latent_frames,
-            height // spatial_ratio,
-            width // spatial_ratio,
-        )
-        return batch
-
-    def verify_input(self, batch: ForwardBatch, fastvideo_args: FastVideoArgs) -> VerificationResult:
-        result = VerificationResult()
-        result.add_check("num_frames", batch.num_frames, V.positive_int)
-        result.add_check("height", batch.height, V.positive_int)
-        result.add_check("width", batch.width, V.positive_int)
-        result.add_check("latents", batch.latents, V.none_or_tensor)
-        return result
-
-    def verify_output(self, batch: ForwardBatch, fastvideo_args: FastVideoArgs) -> VerificationResult:
-        result = VerificationResult()
-        result.add_check("latents", batch.latents, [V.is_tensor, V.with_dims(5)])
-        return result
-
-
-class Kandinsky5DenoisingStage(PipelineStage):
-
-    def __init__(self, transformer, scheduler) -> None:
-        super().__init__()
-        self.transformer = transformer
-        self.scheduler = scheduler
-
-    @staticmethod
-    def _scale_factor(height: int, width: int) -> tuple[float, float, float]:
-        if 480 <= height <= 854 and 480 <= width <= 854:
-            return (1.0, 2.0, 2.0)
-        return (1.0, 3.16, 3.16)
-
-    @staticmethod
-    def _text_rope_pos(mask: torch.Tensor, device: torch.device) -> torch.Tensor:
-        seq_len = int(mask.sum(1).max().item())
-        return torch.arange(seq_len, device=device)
-
-    @staticmethod
-    def fast_sta_nabla(
-        T: int,
-        H: int,
-        W: int,
-        wT: int = 3,
-        wH: int = 3,
-        wW: int = 3,
-        device: torch.device | str = "cuda",
-    ) -> torch.Tensor:
-        """
-        Create a sparse temporal attention (STA) mask for efficient video generation.
-
-        This method generates a mask that limits attention to nearby frames and spatial positions, reducing
-        computational complexity for video generation.
-
-        Args:
-            T (int): Number of temporal frames
-            H (int): Height in latent space
-            W (int): Width in latent space
-            wT (int): Temporal attention window size
-            wH (int): Height attention window size
-            wW (int): Width attention window size
-            device (str): Device to create tensor on
-
-        Returns:
-            torch.Tensor: Sparse attention mask of shape (T*H*W, T*H*W)
-        """
-        max_extent = int(torch.tensor([T, H, W], device=device).amax().item())
-        r = torch.arange(0, max_extent, 1, dtype=torch.int16, device=device)
-        mat = (r.unsqueeze(1) - r.unsqueeze(0)).abs()
-        sta_t, sta_h, sta_w = (
-            mat[:T, :T].flatten(),
-            mat[:H, :H].flatten(),
-            mat[:W, :W].flatten(),
-        )
-        sta_t = sta_t <= wT // 2
-        sta_h = sta_h <= wH // 2
-        sta_w = sta_w <= wW // 2
-        sta_hw = (sta_h.unsqueeze(1) * sta_w.unsqueeze(0)).reshape(H, H, W, W).transpose(1, 2).flatten()
-        sta = (sta_t.unsqueeze(1) * sta_hw.unsqueeze(0)).reshape(T, T, H * W, H * W).transpose(1, 2)
-        return sta.reshape(T * H * W, T * H * W)
-
-    def get_sparse_params(self, sample: torch.Tensor, device: torch.device) -> dict[str, Any] | None:
-        """
-        Generate sparse attention parameters for the transformer based on sample dimensions.
-
-        This method computes the sparse attention configuration needed for efficient video processing in the
-        transformer model.
-
-        Args:
-            sample (torch.Tensor): Input sample tensor
-            device (torch.device): Device to place tensors on
-
-        Returns:
-            Dict: Dictionary containing sparse attention parameters
-        """
-        assert self.transformer.config.patch_size[0] == 1
-        _, T, H, W, _ = sample.shape
-        T, H, W = (
-            T // self.transformer.config.patch_size[0],
-            H // self.transformer.config.patch_size[1],
-            W // self.transformer.config.patch_size[2],
-        )
-        if self.transformer.config.attention_type == "nabla":
-            sta_mask = self.fast_sta_nabla(
-                T,
-                H // 8,
-                W // 8,
-                self.transformer.config.attention_wT,
-                self.transformer.config.attention_wH,
-                self.transformer.config.attention_wW,
-                device=device,
-            )
-
-            sparse_params = {
-                "sta_mask": sta_mask.unsqueeze_(0).unsqueeze_(0),
-                "attention_type": self.transformer.config.attention_type,
-                "to_fractal": True,
-                "P": self.transformer.config.attention_P,
-                "wT": self.transformer.config.attention_wT,
-                "wW": self.transformer.config.attention_wW,
-                "wH": self.transformer.config.attention_wH,
-                "add_sta": self.transformer.config.attention_add_sta,
-                "visual_shape": (T, H, W),
-                "method": self.transformer.config.attention_method,
-            }
-        else:
-            sparse_params = None
-
-        return sparse_params
-
-    def forward(self, batch: ForwardBatch, fastvideo_args: FastVideoArgs) -> ForwardBatch:
-        if batch.timesteps is None:
-            raise ValueError("timesteps must be prepared before Kandinsky5 denoising.")
-        if batch.latents is None:
-            raise ValueError("latents must be prepared before Kandinsky5 denoising.")
-        if not fastvideo_args.model_loaded["transformer"]:
-            loader = TransformerLoader()
-            self.transformer = loader.load(fastvideo_args.model_paths["transformer"], fastvideo_args)
-            fastvideo_args.model_loaded["transformer"] = True
-
-        device = get_local_torch_device()
-        target_dtype = PRECISION_TO_TYPE[fastvideo_args.pipeline_config.dit_precision]
-        autocast_enabled = target_dtype != torch.float32 and not fastvideo_args.disable_autocast
-        latents = batch.latents
-        num_channels = getattr(
-            self.transformer,
-            "in_visual_dim",
-            fastvideo_args.pipeline_config.dit_config.arch_config.in_visual_dim,
-        )
-
-        prompt_embeds = batch.prompt_embeds[0].to(device=device, dtype=target_dtype)
-        pooled = batch.prompt_embeds[1].to(device=device, dtype=target_dtype)
-        if batch.prompt_attention_mask is None or not batch.prompt_attention_mask:
-            raise ValueError("Kandinsky5 requires Qwen prompt attention masks.")
-        text_rope_pos = self._text_rope_pos(batch.prompt_attention_mask[0].to(device), device)
-
-        neg_prompt_embeds = None
-        neg_pooled = None
-        negative_text_rope_pos = None
-        if batch.do_classifier_free_guidance and batch.negative_prompt_embeds:
-            neg_prompt_embeds = batch.negative_prompt_embeds[0].to(device=device, dtype=target_dtype)
-            neg_pooled = batch.negative_prompt_embeds[1].to(device=device, dtype=target_dtype)
-            if batch.negative_attention_mask is None or not batch.negative_attention_mask:
-                raise ValueError("Kandinsky5 requires Qwen negative attention masks for CFG.")
-            negative_text_rope_pos = self._text_rope_pos(batch.negative_attention_mask[0].to(device), device)
-
-        height = int(batch.height)
-        width = int(batch.width)
-        temporal_ratio = fastvideo_args.pipeline_config.vae_config.arch_config.temporal_compression_ratio
-        spatial_ratio = fastvideo_args.pipeline_config.vae_config.arch_config.spatial_compression_ratio
-        num_latent_frames = (int(batch.num_frames) - 1) // temporal_ratio + 1
-        visual_rope_pos = [
-            torch.arange(num_latent_frames, device=device),
-            torch.arange(height // spatial_ratio // 2, device=device),
-            torch.arange(width // spatial_ratio // 2, device=device),
-        ]
-        scale_factor = self._scale_factor(height, width)
-
-        sparse_params = self.get_sparse_params(latents, device)
-
-        # I2V keeps the first (conditioning) frame fixed during denoising.
-        # Key off the actual image conditioning, not transformer.visual_cond:
-        # official T2V checkpoints also ship visual_cond=True, and skipping
-        # frame 0 for them leaves it as undenoised noise.
-        cond_frames = 1 if batch.image_latent is not None else 0
-
-        trajectory_timesteps: list[torch.Tensor] = []
-        trajectory_latents: list[torch.Tensor] = []
-
-        with tqdm(total=batch.num_inference_steps, desc="Kandinsky5 Denoising") as progress_bar:
-            for i, timestep in enumerate(batch.timesteps):
-                if hasattr(self, "interrupt") and self.interrupt:
-                    break
-
-                t_expand = timestep.unsqueeze(0).repeat(latents.shape[0]).to(device=device, dtype=target_dtype)
-                attn_metadata = None
-                if sparse_params is not None:
-                    attn_metadata = NablaAttentionMetadataBuilder().build(
-                        current_timestep=i,
-                        sta_mask=sparse_params["sta_mask"],
-                        P=sparse_params["P"],
-                        visual_shape=sparse_params["visual_shape"],
-                    )
-                autocast_ctx = (torch.autocast(device_type="cuda", dtype=target_dtype, enabled=autocast_enabled)
-                                if device.type == "cuda" else contextlib.nullcontext())
-                with set_forward_context(current_timestep=i, attn_metadata=attn_metadata,
-                                         forward_batch=batch), autocast_ctx:
-                    pred_velocity = self.transformer(
-                        hidden_states=latents.to(dtype=target_dtype),
-                        encoder_hidden_states=prompt_embeds,
-                        pooled_projections=pooled,
-                        timestep=t_expand,
-                        visual_rope_pos=visual_rope_pos,
-                        text_rope_pos=text_rope_pos,
-                        scale_factor=scale_factor,
-                        sparse_params=sparse_params,
-                        return_dict=True,
-                    ).sample
-
-                    if neg_prompt_embeds is not None and neg_pooled is not None:
-                        uncond_pred_velocity = self.transformer(
-                            hidden_states=latents.to(dtype=target_dtype),
-                            encoder_hidden_states=neg_prompt_embeds,
-                            pooled_projections=neg_pooled,
-                            timestep=t_expand,
-                            visual_rope_pos=visual_rope_pos,
-                            text_rope_pos=negative_text_rope_pos,
-                            scale_factor=scale_factor,
-                            sparse_params=sparse_params,
-                            return_dict=True,
-                        ).sample
-                        pred_velocity = uncond_pred_velocity + batch.guidance_scale * (pred_velocity -
-                                                                                       uncond_pred_velocity)
-
-                latents[:, cond_frames:, :, :, :num_channels] = self.scheduler.step(
-                    pred_velocity[:, cond_frames:],
-                    timestep,
-                    latents[:, cond_frames:, :, :, :num_channels],
-                    return_dict=False,
-                )[0]
-
-                if batch.return_trajectory_latents:
-                    trajectory_timesteps.append(timestep)
-                    # latents is mutated in place, so snapshot a channels-first copy.
-                    trajectory_latents.append(latents[..., :num_channels].permute(0, 4, 1, 2, 3).cpu())
-
-                if i == len(batch.timesteps) - 1 or (i + 1) % self.scheduler.order == 0:
-                    progress_bar.update()
-
-        if trajectory_latents:
-            batch.trajectory_latents = torch.stack(trajectory_latents, dim=1)
-            batch.trajectory_timesteps = torch.stack(trajectory_timesteps, dim=0).cpu()
-
-        batch.latents = latents[:, :, :, :, :num_channels]
-        return batch
-
-    def verify_input(self, batch: ForwardBatch, fastvideo_args: FastVideoArgs) -> VerificationResult:
-        result = VerificationResult()
-        result.add_check("latents", batch.latents, [V.is_tensor, V.with_dims(5)])
-        result.add_check("prompt_embeds", batch.prompt_embeds, V.min_list_length(2))
-        return result
-
-
-class Kandinsky5DecodingStage(DecodingStage):
-
-    def __init__(self, vae: ParallelTiledVAE, pipeline=None) -> None:
-        super().__init__(vae=vae, pipeline=pipeline)
-
-    def forward(self, batch: ForwardBatch, fastvideo_args: FastVideoArgs) -> ForwardBatch:
-        if batch.latents is None:
-            raise ValueError("latents must be available before Kandinsky5 decoding.")
-        # Kandinsky5 latents are channels-last [B, T, H, W, C]; the base stage
-        # (and the trajectory latents recorded by the denoising stage) work
-        # channels-first.
-        batch.latents = batch.latents.permute(0, 4, 1, 2, 3).contiguous()
-        return super().forward(batch, fastvideo_args)
-
-
-class Kandinsky5ImageEncodingStage(EncodingStage):
-    """Encode the conditioning image into a VAE latent for I2V."""
-
-    def __init__(self, vae: ParallelTiledVAE, pipeline=None) -> None:
-        super().__init__(vae=vae)
-
-    @staticmethod
-    def _preprocess(image, height: int, width: int) -> torch.Tensor:
-        if isinstance(image, PIL.Image.Image):
-            image = resize(image, height, width)
-            image = numpy_to_pt(pil_to_numpy(image))  # always lands in [0, 1]
-            return normalize(image)  # [0, 1] -> [-1, 1]
-        # Tensor input: no reliable way to tell [0, 1] from an already
-        # normalized [-1, 1] tensor whose values happen to be non-negative,
-        # so mirror diffusers' heuristic and say what we assumed.
-        if image.min() >= 0:
-            logger.warning("Kandinsky5 conditioning image tensor has no negative values; "
-                           "assuming range [0, 1] and normalizing to [-1, 1]. "
-                           "Pass a [-1, 1] tensor with negative values to skip normalization.")
-            image = normalize(image)  # [0, 1] -> [-1, 1]
-        if image.ndim == 3:
-            image = image.unsqueeze(0)
-        if image.shape[-2:] != (height, width):
-            image = torch.nn.functional.interpolate(image.float(),
-                                                    size=(height, width),
-                                                    mode="bilinear",
-                                                    antialias=True)
-        return image
-
-    @torch.no_grad()
-    def forward(self, batch: ForwardBatch, fastvideo_args: FastVideoArgs) -> ForwardBatch:
-        if batch.pil_image is None:
-            raise ValueError("Kandinsky5 I2V requires an input image.")
-
-        if not fastvideo_args.model_loaded["vae"]:
-            vae = getattr(self, "vae", None)
-            if vae is None:
-                loader = VAELoader()
-                vae = loader.load(fastvideo_args.model_paths["vae"], fastvideo_args)
-                self.vae = vae
-            fastvideo_args.model_loaded["vae"] = True
-
-        device = get_local_torch_device()
-        vae = self.vae.to(device)
-        self.vae = vae
-        vae_dtype = PRECISION_TO_TYPE[fastvideo_args.pipeline_config.vae_precision]
-        vae_autocast_enabled = vae_dtype != torch.float32 and not fastvideo_args.disable_autocast
-
-        # [B, C, H, W] -> [B, C, 1, H, W]
-        image = self._preprocess(batch.pil_image, int(batch.height), int(batch.width))
-        image = image.to(device=device, dtype=torch.float32).unsqueeze(2)
-
-        # Encode the single conditioning frame without tiling (matches diffusers).
-        # The untested causal-VAE spatial_tiled_encode path corrupts the latent.
-        prev_use_tiling = vae.use_tiling
-        vae.use_tiling = False
-        try:
-            with torch.autocast(device_type="cuda", dtype=vae_dtype, enabled=vae_autocast_enabled):
-                if not vae_autocast_enabled:
-                    image = image.to(vae_dtype)
-                # Sample with the batch generator (diffusers parity); mode()
-                # would make seed-for-seed reproduction of the reference
-                # pipeline impossible.
-                generator = batch.generator
-                if isinstance(generator, list) and len(generator) != image.shape[0]:
-                    generator = generator[0]
-                image_latent = vae.encode(image).sample(generator=generator)
-        finally:
-            vae.use_tiling = prev_use_tiling
-
-        image_latent = image_latent * vae.scaling_factor
-        # [B, C, 1, H, W] -> [B, 1, H, W, C] to match channels-last latents
-        batch.image_latent = image_latent.permute(0, 2, 3, 4, 1).contiguous()
-
-        # Place the conditioning latent into the prepared latents: frame 0 of
-        # the main channels, the visual_cond channel block, and the mask.
-        # NOTE: the official kandinsky-5 repo leaves the visual_cond block
-        # zeros (generation_utils.py generate()), while the diffusers port
-        # copies the image latent into it. A same-seed A/B on
-        # Kandinsky-5.0-I2V-Pro-distilled-5s-Diffusers showed the Diffusers
-        # export requires the copy: zeroing the block produces smeared faces
-        # mid-video. Keep the diffusers semantics for Diffusers-format
-        # checkpoints.
-        latents = batch.latents
-        image_latent = batch.image_latent.to(device=latents.device, dtype=latents.dtype)
-        num_channels = image_latent.shape[-1]
-        latents[:, 0:1, :, :, :num_channels] = image_latent
-        if latents.shape[-1] > num_channels:
-            latents[:, 0:1, :, :, num_channels:2 * num_channels] = image_latent
-            latents[:, 0:1, :, :, 2 * num_channels:] = 1.0
-        batch.latents = latents
-
-        if fastvideo_args.vae_cpu_offload:
-            vae.to("cpu")
-        return batch
-
-    def verify_input(self, batch: ForwardBatch, fastvideo_args: FastVideoArgs) -> VerificationResult:
-        result = VerificationResult()
-        result.add_check("pil_image", batch.pil_image, V.not_none)
-        result.add_check("height", batch.height, V.positive_int)
-        result.add_check("width", batch.width, V.positive_int)
-        # This stage runs after latent preparation and writes into its output.
-        result.add_check("latents", batch.latents, [V.is_tensor, V.with_dims(5)])
-        return result
-
-    def verify_output(self, batch: ForwardBatch, fastvideo_args: FastVideoArgs) -> VerificationResult:
-        result = VerificationResult()
-        result.add_check("image_latent", batch.image_latent, [V.is_tensor, V.with_dims(5)])
-        return result
-
-
-class Kandinsky5NormalizationStage(PipelineStage):
-    """Normalize the first latent frames to reduce I2V conditioning artifacts."""
-
-    COND_FRAMES = 4
-    REFERENCE_FRAMES = 5
-
-    @staticmethod
-    def _adaptive_mean_std(source: torch.Tensor, reference: torch.Tensor) -> torch.Tensor:
-        source_mean = source.mean(dim=(1, 2, 3, 4), keepdim=True)
-        source_std = source.std(dim=(1, 2, 3, 4), keepdim=True)
-        # Magic constants limit how far the first frames may drift.
-        ref_mean = torch.clamp(reference.mean(dim=(1, 2, 3, 4), keepdim=True), source_mean - 0.05, source_mean + 0.1)
-        ref_std = torch.clamp(reference.std(dim=(1, 2, 3, 4), keepdim=True), source_std - 0.1, source_std + 0.25)
-        normalized = (source - source_mean) / source_std
-        return normalized * ref_std + ref_mean
-
-    def forward(self, batch: ForwardBatch, fastvideo_args: FastVideoArgs) -> ForwardBatch:
-        latents = batch.latents
-        n = self.COND_FRAMES
-        if latents is None or latents.shape[1] <= n:
-            return batch
-
-        reference = latents[:, n:n + min(self.REFERENCE_FRAMES, latents.shape[1] - 1)]
-        latents[:, :n] = self._adaptive_mean_std(latents[:, :n].clone(), reference)
-        batch.latents = latents
-        return batch
@@ -8,8 +8,6 @@ This module contains implementations of prompt encoding stages for diffusion pip
 import torch
 from typing import Any

-from torch.distributed.tensor import DTensor
-
 from fastvideo.distributed import get_local_torch_device
 from fastvideo.fastvideo_args import FastVideoArgs
 from fastvideo.forward_context import set_forward_context
@@ -205,21 +203,6 @@ class TextEncodingStage(PipelineStage):
            encoder_config = encoder_cfgs[i]
            preprocess_func = preprocess_funcs[i]
            postprocess_func = postprocess_funcs[i]
-            # cpu_offload semantics: params rest on CPU between calls but the
-            # forward computes on GPU. FSDP2-wrapped encoders (CPUOffloadPolicy;
-            # DTensor params) stream themselves per-layer — leave inputs on the
-            # param device and let FSDP's root pre-forward move them. A plain
-            # module parked on CPU by text_encoder_cpu_offload is swapped to the
-            # target device for the forward and back afterwards, mirroring the
-            # image-encoder/VAE offload pattern.
-            first_param = next(text_encoder.parameters(), None)
-            encoder_device = first_param.device if first_param is not None else torch.device(target_device)
-            moved_for_forward = False
-            if (first_param is not None and not isinstance(first_param, DTensor)
-                    and encoder_device.type != torch.device(target_device).type):
-                text_encoder = text_encoder.to(target_device)
-                encoder_device = torch.device(target_device)
-                moved_for_forward = True

            tok_kwargs = dict(encoder_config.tokenizer_kwargs)
            if max_length is not None:
@@ -264,7 +247,7 @@ class TextEncodingStage(PipelineStage):
                    # pre-format prompts into message lists upstream and rely on
                    # the inner tokenizer + full tokenizer_kwargs (which include
                    # add_generation_prompt). Preserve that original path exactly.
-                    text_inputs = tok.apply_chat_template(processed_texts, **tok_kwargs).to(encoder_device)
+                    text_inputs = tok.apply_chat_template(processed_texts, **tok_kwargs).to(target_device)
                else:
                    # Two-step approach matching Diffusers: format with chat
                    # template first, then tokenize the resulting strings.
@@ -278,9 +261,9 @@ class TextEncodingStage(PipelineStage):
                            enable_thinking=False,
                        )
                        formatted_texts.append(formatted)
-                    text_inputs = tokenizer(formatted_texts, **tok_kwargs).to(encoder_device)
+                    text_inputs = tokenizer(formatted_texts, **tok_kwargs).to(target_device)
            else:
-                text_inputs = tok(processed_texts, **tok_kwargs).to(encoder_device)
+                text_inputs = tok(processed_texts, **tok_kwargs).to(target_device)

            input_ids = text_inputs["input_ids"]
            attention_mask = text_inputs["attention_mask"]
@@ -300,18 +283,15 @@ class TextEncodingStage(PipelineStage):
            except Exception:
                prompt_embeds, attention_mask = postprocess_func(outputs, attention_mask)
            if is_ltx2 and getattr(outputs, "hidden_states", None):
-                audio_embed = outputs.hidden_states[0].to(device=target_device)
+                audio_embed = outputs.hidden_states[0]
                if dtype is not None:
                    audio_embed = audio_embed.to(dtype=dtype)
                audio_embeds_list.append(audio_embed)
-            prompt_embeds = prompt_embeds.to(device=target_device)
            if dtype is not None:
                prompt_embeds = prompt_embeds.to(dtype=dtype)
            embeds_list.append(prompt_embeds)
            if return_attention_mask:
-                attn_masks_list.append(attention_mask.to(device=target_device))
-            if moved_for_forward and fastvideo_args.text_encoder_cpu_offload:
-                text_encoder.to("cpu")
+                attn_masks_list.append(attention_mask)
        self._last_audio_embeds = audio_embeds_list if is_ltx2 else None
        return self.return_embeds(embeds_list, attn_masks_list, return_type, return_attention_mask, indices)

@@ -219,16 +219,6 @@ class StageValidators:

        return validator

-    @staticmethod
-    def min_list_length(min_length: int) -> Callable[[Any], bool]:
-        """Return a validator that checks if a list has at least min_length items."""
-
-        def validator(value: Any) -> bool:
-            return StageValidators.list_min_length(value, min_length)
-
-        validator.__name__ = f"list_min_length_{min_length}"
-        return validator
-
    @staticmethod
    def min_dims(min_dims: int) -> Callable[[Any], bool]:
        """Return a validator that checks if tensor has at least min_dims dimensions and no NaN values."""
@@ -157,14 +157,6 @@ class CudaPlatformBase(Platform):
                "ATTN_QAT_TRAIN selected but fastvideo_kernel.triton_kernels.attn_qat_train is not built. "
                "Silent fallback would produce a non-QAT training run; refusing to proceed. "
                "Install the training kernel or pick a different FASTVIDEO_ATTENTION_BACKEND.")
-        elif selected_backend == AttentionBackendEnum.NABLA_ATTN:
-            from fastvideo.attention.backends.nabla import CAN_USE_FLEX_ATTN
-            if CAN_USE_FLEX_ATTN:
-                logger.info("Using NABLA block-sparse flex-attention backend.")
-                return "fastvideo.attention.backends.nabla.NablaAttentionBackend"
-            raise ImportError("NABLA_ATTN selected but torch.nn.attention.flex_attention is unavailable in this "
-                              "PyTorch build. Silent fallback to dense attention would be orders of magnitude "
-                              "slower and diverge from the reference; upgrade PyTorch or pick a different backend.")
        elif selected_backend == AttentionBackendEnum.VIDEO_SPARSE_ATTN:
            try:
                from fastvideo_kernel import video_sparse_attn  # noqa: F401
@@ -22,7 +22,6 @@ class AttentionBackendEnum(enum.Enum):
    VMOBA_ATTN = enum.auto()
    SLA_ATTN = enum.auto()
    SAGE_SLA_ATTN = enum.auto()
-    NABLA_ATTN = enum.auto()
    NO_ATTENTION = enum.auto()


@@ -28,7 +28,6 @@ from fastvideo.configs.pipelines.hunyuan15 import (Hunyuan15T2V480PConfig, Hunyu
                                                   Hunyuan15T2V720PConfig, Hunyuan15I2V720PConfig,
                                                   Hunyuan15SR1080PConfig)
 from fastvideo.configs.pipelines.hyworld import HYWorldConfig
-from fastvideo.configs.pipelines.kandinsky5 import Kandinsky5I2VConfig, Kandinsky5T2VConfig
 from fastvideo.configs.pipelines.lingbotworld import LingBotWorldI2V480PConfig
 from fastvideo.configs.pipelines.longcat import LongCatT2V480PConfig
 from fastvideo.pipelines.basic.ltx2.pipeline_configs import LTX2T2VConfig
@@ -119,10 +118,6 @@ class ConfigInfo:
    workload_types: tuple[WorkloadType, ...]
    model_family: str | None = None
    default_preset: str | None = None
-    # When set, overrides the model_index `_class_name` for pipeline resolution.
-    # Lets a model family map to a specific pipeline class by path/detector
-    # (e.g. a T2V and I2V checkpoint that share a `_class_name`).
-    pipeline_cls_name: str | None = None


 # The central registry mapping a model name to its configuration information
@@ -143,7 +138,6 @@ def register_configs(
    model_detectors: list[Callable[[str], bool]] | None = None,
    model_family: str | None = None,
    default_preset: str | None = None,
-    pipeline_cls_name: str | None = None,
 ) -> None:
    """Register config classes for a model family.

@@ -158,7 +152,6 @@ def register_configs(
        workload_types=workload_types,
        model_family=model_family,
        default_preset=default_preset,
-        pipeline_cls_name=pipeline_cls_name,
    )

    if hf_model_paths:
@@ -498,174 +491,18 @@ def _register_configs() -> None:
        default_preset="lingbotworld_i2v",
    )

-    def _kandinsky5_detector(require: tuple[str, ...] = (), exclude: tuple[str, ...] = ()) -> Callable[[str], bool]:
-
-        def detect(path: str) -> bool:
-            path_lower = path.lower()
-            if "kandinsky5" not in path_lower and "kandinsky-5" not in path_lower:
-                return False
-            return (all(token in path_lower for token in require) and not any(token in path_lower for token in exclude))
-
-        return detect
-
-    # t2v/i2v exclude each other so a checkpoint stored under a directory
-    # containing the other token (e.g. ~/i2v_experiments/kandinsky5-t2v-ft)
-    # falls through to the model_index _class_name fallback detectors below
-    # instead of being misrouted.
-    _is_kandinsky5_t2v = _kandinsky5_detector(require=("t2v", ), exclude=("i2v", ))
-    _is_kandinsky5_i2v = _kandinsky5_detector(require=("i2v", ), exclude=("t2v", ))
-    _is_kandinsky5_t2v_lite = _kandinsky5_detector(require=("t2v", "lite"), exclude=("i2v", "distilled"))
-    _is_kandinsky5_t2v_pro = _kandinsky5_detector(require=("t2v", "pro"), exclude=("i2v", "distilled"))
-    _is_kandinsky5_t2v_lite_distilled = _kandinsky5_detector(require=("t2v", "lite", "distilled"), exclude=("i2v", ))
-    _is_kandinsky5_t2v_pro_distilled = _kandinsky5_detector(require=("t2v", "pro", "distilled"), exclude=("i2v", ))
-    _is_kandinsky5_i2v_lite = _kandinsky5_detector(require=("i2v", "lite"), exclude=("t2v", "distilled"))
-    _is_kandinsky5_i2v_pro = _kandinsky5_detector(require=("i2v", "pro"), exclude=("t2v", "distilled"))
-    _is_kandinsky5_i2v_lite_distilled = _kandinsky5_detector(require=("i2v", "lite", "distilled"), exclude=("t2v", ))
-    _is_kandinsky5_i2v_pro_distilled = _kandinsky5_detector(require=("i2v", "pro", "distilled"), exclude=("t2v", ))
-
    # Kandinsky5 Lite T2V
    register_configs(
        sampling_param_cls=None,
-        pipeline_config_cls=Kandinsky5T2VConfig,
+        pipeline_config_cls=PipelineConfig,
        workload_types=(WorkloadType.T2V, ),
        hf_model_paths=[
            "kandinskylab/Kandinsky-5.0-T2V-Lite-sft-5s-Diffusers",
        ],
        model_detectors=[
-            _is_kandinsky5_t2v_lite,
+            lambda path: any(token in path.lower() for token in ("kandinsky5", "kandinsky-5")),
        ],
        model_family="kandinsky5",
-        default_preset="kandinsky5_t2v_lite_5s",
-        pipeline_cls_name="Kandinsky5T2VPipeline",
-    )
-
-    # Kandinsky5 Pro T2V
-    register_configs(
-        sampling_param_cls=None,
-        pipeline_config_cls=Kandinsky5T2VConfig,
-        workload_types=(WorkloadType.T2V, ),
-        hf_model_paths=[
-            "kandinskylab/Kandinsky-5.0-T2V-Pro-sft-5s-Diffusers",
-        ],
-        model_detectors=[
-            _is_kandinsky5_t2v_pro,
-        ],
-        model_family="kandinsky5",
-        default_preset="kandinsky5_t2v_pro_5s",
-    )
-
-    # Kandinsky5 Lite T2V Distilled
-    register_configs(
-        sampling_param_cls=None,
-        pipeline_config_cls=Kandinsky5T2VConfig,
-        workload_types=(WorkloadType.T2V, ),
-        hf_model_paths=[
-            "kandinskylab/Kandinsky-5.0-T2V-Lite-distilled16steps-5s-Diffusers",
-        ],
-        model_detectors=[
-            _is_kandinsky5_t2v_lite_distilled,
-        ],
-        model_family="kandinsky5",
-        default_preset="kandinsky5_t2v_lite_distilled_5s",
-    )
-
-    # Kandinsky5 Pro T2V Distilled
-    register_configs(
-        sampling_param_cls=None,
-        pipeline_config_cls=Kandinsky5T2VConfig,
-        workload_types=(WorkloadType.T2V, ),
-        hf_model_paths=[
-            "kandinskylab/Kandinsky-5.0-T2V-Pro-distilled-5s-Diffusers",
-        ],
-        model_detectors=[
-            _is_kandinsky5_t2v_pro_distilled,
-        ],
-        model_family="kandinsky5",
-        default_preset="kandinsky5_t2v_pro_distilled_5s",
-    )
-
-    # Kandinsky5 Lite I2V
-    register_configs(
-        sampling_param_cls=None,
-        pipeline_config_cls=Kandinsky5I2VConfig,
-        workload_types=(WorkloadType.I2V, ),
-        hf_model_paths=["kandinskylab/Kandinsky-5.0-I2V-Lite-5s-Diffusers"],
-        model_detectors=[
-            _is_kandinsky5_i2v_lite,
-        ],
-        model_family="kandinsky5",
-        default_preset="kandinsky5_i2v_lite_5s",
-        pipeline_cls_name="Kandinsky5I2VPipeline",
-    )
-
-    # Kandinsky5 Pro I2V
-    register_configs(
-        sampling_param_cls=None,
-        pipeline_config_cls=Kandinsky5I2VConfig,
-        workload_types=(WorkloadType.I2V, ),
-        hf_model_paths=["kandinskylab/Kandinsky-5.0-I2V-Pro-sft-5s-Diffusers"],
-        model_detectors=[
-            _is_kandinsky5_i2v_pro,
-        ],
-        model_family="kandinsky5",
-        default_preset="kandinsky5_i2v_pro_5s",
-    )
-
-    # Kandinsky5 Pro I2V Distilled
-    register_configs(
-        sampling_param_cls=None,
-        pipeline_config_cls=Kandinsky5I2VConfig,
-        workload_types=(WorkloadType.I2V, ),
-        hf_model_paths=["kandinskylab/Kandinsky-5.0-I2V-Pro-distilled-5s-Diffusers"],
-        model_detectors=[
-            _is_kandinsky5_i2v_pro_distilled,
-        ],
-        model_family="kandinsky5",
-        default_preset="kandinsky5_i2v_pro_distilled_5s",
-    )
-
-    # Kandinsky5 Lite I2V Distilled (no official hub repo yet; local
-    # conversions get distilled sampling defaults instead of the sft ones the
-    # fallback would apply).
-    register_configs(
-        sampling_param_cls=None,
-        pipeline_config_cls=Kandinsky5I2VConfig,
-        workload_types=(),
-        model_detectors=[
-            _is_kandinsky5_i2v_lite_distilled,
-        ],
-        model_family="kandinsky5",
-        default_preset="kandinsky5_i2v_lite_distilled_5s",
-        pipeline_cls_name="Kandinsky5I2VPipeline",
-    )
-
-    # Kandinsky5 fallbacks — registered AFTER the variant detectors so those
-    # win first-match. Catch checkpoints the variant detectors cannot resolve:
-    # token-less local paths matched via the model_index _class_name
-    # ("kandinsky5t2vpipeline" carries no lite/pro marker), variant combos
-    # without a dedicated entry (e.g. I2V Lite distilled), and t2v+i2v
-    # ambiguous paths resolved by the checkpoint's _class_name.
-    register_configs(
-        sampling_param_cls=None,
-        pipeline_config_cls=Kandinsky5T2VConfig,
-        workload_types=(),
-        model_detectors=[
-            _is_kandinsky5_t2v,
-        ],
-        model_family="kandinsky5",
-        default_preset="kandinsky5_t2v_lite_5s",
-        pipeline_cls_name="Kandinsky5T2VPipeline",
-    )
-    register_configs(
-        sampling_param_cls=None,
-        pipeline_config_cls=Kandinsky5I2VConfig,
-        workload_types=(),
-        model_detectors=[
-            _is_kandinsky5_i2v,
-        ],
-        model_family="kandinsky5",
-        default_preset="kandinsky5_i2v_lite_5s",
-        pipeline_cls_name="Kandinsky5I2VPipeline",
    )

    # LongCat (T2V, I2V, VC use same config; workload varies by path)
@@ -714,16 +551,10 @@ def _register_configs() -> None:
            "FastVideo/Matrix-Game-2.0-Base-Distilled-Diffusers",
            "FastVideo/Matrix-Game-2.0-GTA-Distilled-Diffusers",
            "FastVideo/Matrix-Game-2.0-TempleRun-Distilled-Diffusers",
-            # Legacy HF paths (kept for backward compat - pre-rename names):
+            # Legacy HF paths (kept for backward compat — pre-rename names):
            "FastVideo/Matrix-Game-2.0-Base-Diffusers",
            "FastVideo/Matrix-Game-2.0-GTA-Diffusers",
            "FastVideo/Matrix-Game-2.0-TempleRun-Diffusers",
-            # Zelda World Model
-            "mignonjia/mg_longtuning_distilled_zelda",  # distilled using streaming long tuning which init from mg_sf_distilled_zelda_1k_steps
-            "mignonjia/mg_sf_distilled_zelda_1k_steps",  # distilled using self forcing for 1k steps
-            "mignonjia/mg_sf_distilled_zelda",  # distilled using self forcing for 3k steps
-            "mignonjia/mg_causal_zelda",
-            "mignonjia/mg_bidirectional_zelda",
        ],
        model_detectors=[
            lambda path: any(token in path.lower() for token in (
@@ -1106,10 +937,7 @@ def get_model_info(
    assert config_info is not None, "config_info must be resolved"

    if override_pipeline_cls_name:
-        # Explicit override: skip config resolution entirely so checkpoints
-        # without a diffusers model_index.json keep working (and no download
-        # is triggered just to log the replaced name).
-        pipeline_name: str | None = override_pipeline_cls_name
+        pipeline_name = override_pipeline_cls_name
        logger.info("Using override pipeline class name %s", pipeline_name)
    else:
        if os.path.exists(model_path):
@@ -1118,12 +946,6 @@ def get_model_info(
            config = maybe_download_model_index(model_path)

        pipeline_name = config.get("_class_name")
-        if config_info.pipeline_cls_name is not None:
-            # The resolved (path/detector-based) config pins the pipeline class,
-            # e.g. an I2V checkpoint whose `_class_name` would otherwise resolve
-            # to the T2V pipeline.
-            logger.info("Pinning pipeline class name from %s to %s", pipeline_name, config_info.pipeline_cls_name)
-            pipeline_name = config_info.pipeline_cls_name

    if pipeline_name is None:
        raise ValueError("Model config does not contain a _class_name attribute. "
@@ -1176,8 +998,6 @@ def _register_presets() -> None:
        ALL_PRESETS as HUNYUAN15_PRESETS, )
    from fastvideo.pipelines.basic.hyworld.presets import (
        ALL_PRESETS as HYWORLD_PRESETS, )
-    from fastvideo.pipelines.basic.kandinsky5.presets import (
-        ALL_PRESETS as KANDINSKY5_PRESETS, )
    from fastvideo.pipelines.basic.lingbotworld.presets import (
        ALL_PRESETS as LINGBOTWORLD_PRESETS, )
    from fastvideo.pipelines.basic.longcat.presets import (
@@ -1208,7 +1028,6 @@ def _register_presets() -> None:
        HUNYUAN_PRESETS,
        HUNYUAN15_PRESETS,
        HYWORLD_PRESETS,
-        KANDINSKY5_PRESETS,
        LINGBOTWORLD_PRESETS,
        LONGCAT_PRESETS,
        LTX2_PRESETS,
@@ -1,43 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-"""CPU-only regression test for the SDPA metadata mask contract.
-
-SDPAMetadata is cross-backend: HYWorld and HunyuanVideo15 build it while the
-layer's attention selector may pick FLASH_ATTN, and the shared convention
-for padding masks is the tokenizer-style 2D [batch, key_len]. The builder
-must store 2D masks unchanged; only the torch-sdpa impl lifts them to 4D
-internally.
-
-Regression guard for the CI break where the builder lifted 2D -> 4D and the
-FLASH_ATTN equal-length branch padded ``attn_mask.shape[1]`` (== 1 for 4D)
-into a garbage-length mask (CUDA device-side assert, SIGABRT).
-"""
-
-from __future__ import annotations
-
-import torch
-
-from fastvideo.attention.backends.sdpa import (SDPAMetadataBuilder, _normalize_attn_mask_for_sdpa)
-
-
-def test_builder_keeps_2d_padding_mask_2d() -> None:
-    """A tokenizer-style 2D int mask must be stored as-is (cross-backend contract)."""
-    mask = torch.tensor([[1, 1, 0], [1, 0, 0]], dtype=torch.int64)
-    md = SDPAMetadataBuilder().build(current_timestep=0, attn_mask=mask)
-    assert md.attn_mask is not None
-    assert md.attn_mask.dim() == 2
-    assert md.attn_mask.shape == (2, 3)
-    assert torch.equal(md.attn_mask, mask)
-
-
-def test_normalize_lifts_2d_int_mask_to_4d_bool_for_torch_sdpa() -> None:
-    """The torch-sdpa consumer coerces int -> bool and lifts 2D -> [B,1,1,K]."""
-    batch, q_len, k_len, heads, head_dim = 2, 4, 3, 1, 8
-    query = torch.zeros(batch, heads, q_len, head_dim)
-    key = torch.zeros(batch, heads, k_len, head_dim)
-    mask = torch.tensor([[1, 1, 0], [1, 0, 0]], dtype=torch.int64)
-
-    out = _normalize_attn_mask_for_sdpa(mask, query, key)
-    assert out is not None
-    assert out.dtype == torch.bool
-    assert out.shape == (batch, 1, 1, k_len)
-    assert torch.equal(out[:, 0, 0, :], mask != 0)
@@ -1,80 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-"""CPU-only tests for load_image URL retry behavior.
-
-A HF-CDN IncompleteRead mid-body previously killed SSIM runs (build 4202,
-test_wan_i2v) because load_image handed PIL a partial ``.raw`` stream with no
-retry. These tests mock requests.get: a transient failure must be retried and
-a full-body success must yield a usable PIL image.
-"""
-import io
-from unittest import mock
-
-import PIL.Image
-import pytest
-import requests
-
-from fastvideo.models import vision_utils
-
-URL = "https://example.com/image.png"
-
-
-def _png_bytes() -> bytes:
-    buf = io.BytesIO()
-    PIL.Image.new("RGB", (4, 4), (255, 0, 0)).save(buf, format="PNG")
-    return buf.getvalue()
-
-
-def _good_response() -> mock.Mock:
-    response = mock.Mock()
-    response.content = _png_bytes()
-    response.raise_for_status = mock.Mock()
-    return response
-
-
-def test_load_image_retries_transient_error_then_succeeds(monkeypatch):
-    monkeypatch.setattr(vision_utils.time, "sleep", lambda _s: None)
-    get = mock.Mock(side_effect=[
-        # The shape that broke build 4202: connection dropped mid-body.
-        requests.exceptions.ChunkedEncodingError(
-            "IncompleteRead(1024 bytes read, 2048 more expected)"),
-        _good_response(),
-    ])
-    monkeypatch.setattr(vision_utils.requests, "get", get)
-
-    image = vision_utils.load_image(URL)
-
-    assert get.call_count == 2
-    assert get.call_args.kwargs["timeout"] == 30.0
-    assert isinstance(image, PIL.Image.Image)
-    assert image.size == (4, 4)
-    assert image.mode == "RGB"
-
-
-def test_load_image_raises_after_exhausting_retries(monkeypatch):
-    sleeps: list[float] = []
-    monkeypatch.setattr(vision_utils.time, "sleep", sleeps.append)
-    get = mock.Mock(
-        side_effect=requests.exceptions.ConnectionError("connection reset"))
-    monkeypatch.setattr(vision_utils.requests, "get", get)
-
-    with pytest.raises(requests.exceptions.ConnectionError):
-        vision_utils.load_image(URL)
-
-    assert get.call_count == 3
-    assert sleeps == [1, 2]
-
-
-def test_load_image_does_not_retry_on_client_error(monkeypatch):
-    sleeps: list[float] = []
-    monkeypatch.setattr(vision_utils.time, "sleep", sleeps.append)
-    response = mock.Mock(status_code=404)
-    error = requests.HTTPError("404 Client Error", response=response)
-    response.raise_for_status.side_effect = error
-    get = mock.Mock(return_value=response)
-    monkeypatch.setattr(vision_utils.requests, "get", get)
-
-    with pytest.raises(requests.HTTPError):
-        vision_utils.load_image("https://example.com/missing.png")
-
-    assert get.call_count == 1
-    assert sleeps == []
@@ -1,117 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-"""Unit tests for parquet map-style dataset path parsing."""
-
-from __future__ import annotations
-
-import pickle
-
-import pytest
-
-from fastvideo.dataset import parquet_dataset_map_style as parquet_dataset
-from fastvideo.dataset.parquet_dataset_map_style import _parse_data_path_specs
-
-
-def test_parse_data_path_specs_accepts_old_repeat_string() -> None:
-    # Dataset parsing keeps compatibility with the old "path:repeat" string
-    # form used by existing training configs.
-    assert _parse_data_path_specs("data/path1:2,data/path2:1") == [
-        ("data/path1", 2),
-        ("data/path2", 1),
-    ]
-
-
-def test_parse_data_path_specs_accepts_yaml_mapping() -> None:
-    # New YAML mapping form should reach the dataset layer as path -> repeat
-    # and parse to the same internal spec representation.
-    assert _parse_data_path_specs({
-        "data/path1": 1,
-        "data/path2": 2,
-    }) == [
-        ("data/path1", 1),
-        ("data/path2", 2),
-    ]
-
-
-def test_parse_data_path_specs_accepts_path_list() -> None:
-    assert _parse_data_path_specs(["data/a", "data/b"]) == [
-        ("data/a", 1),
-        ("data/b", 1),
-    ]
-
-
-def test_parse_data_path_specs_drops_non_positive_repeats() -> None:
-    assert _parse_data_path_specs({"data/a": 0, "data/b": -1, "data/c": 2}) == [
-        ("data/c", 2),
-    ]
-    assert _parse_data_path_specs("data/a:0,data/b:2") == [("data/b", 2)]
-
-
-def test_parse_data_path_specs_rejects_malformed_repeats() -> None:
-    # Repeat counts must parse as ints; anything else is an explicit error
-    # rather than a silently mis-weighted dataset.
-    with pytest.raises(ValueError):
-        _parse_data_path_specs("data/a:abc")
-    with pytest.raises(ValueError):
-        _parse_data_path_specs("data/a:1.5")
-    with pytest.raises(ValueError):
-        _parse_data_path_specs({"data/a": "abc"})  # type: ignore[dict-item]
-
-
-class _DummyWorldGroup:
-
-    def barrier(self) -> None:
-        return None
-
-
-def _write_root_cache(dataset_root, filename: str, length: int) -> str:
-    cache_dir = dataset_root / "map_style_cache"
-    cache_dir.mkdir(parents=True)
-    parquet_file = dataset_root / filename
-    parquet_file.touch()
-    with (cache_dir / "file_info.pkl").open("wb") as f:
-        pickle.dump(((str(parquet_file),), (length,)), f)
-    return str(parquet_file)
-
-
-def test_get_parquet_files_and_length_repeats_single_path(tmp_path, monkeypatch) -> None:
-    # get_parquet_files_and_length applies repeat counts after reading the
-    # per-root parquet cache, so a repeated root duplicates both names and rows.
-    dataset_root = tmp_path / "dataset"
-    parquet_file = _write_root_cache(dataset_root, "sample.parquet", 7)
-
-    monkeypatch.setattr(parquet_dataset, "get_world_rank", lambda: 0)
-    monkeypatch.setattr(parquet_dataset, "get_world_group", _DummyWorldGroup)
-
-    file_names, lengths = parquet_dataset.get_parquet_files_and_length({
-        str(dataset_root): 2,
-    })
-
-    assert file_names == (parquet_file, parquet_file)
-    assert lengths == (7, 7)
-
-
-def test_get_parquet_files_and_length_mixes_roots_and_resorts(tmp_path, monkeypatch) -> None:
-    # Multiple roots are expanded per repeat count and then globally re-sorted
-    # by filename, so the mix order is independent of the mapping order.
-    root_a = tmp_path / "dataset_a"
-    root_b = tmp_path / "dataset_b"
-    file_a = _write_root_cache(root_a, "a.parquet", 5)
-    file_b = _write_root_cache(root_b, "b.parquet", 9)
-
-    monkeypatch.setattr(parquet_dataset, "get_world_rank", lambda: 0)
-    monkeypatch.setattr(parquet_dataset, "get_world_group", _DummyWorldGroup)
-
-    file_names, lengths = parquet_dataset.get_parquet_files_and_length({
-        str(root_b): 1,
-        str(root_a): 2,
-    })
-
-    assert file_names == (file_a, file_a, file_b)
-    assert lengths == (5, 5, 9)
-
-
-def test_get_parquet_files_and_length_raises_when_all_repeats_dropped() -> None:
-    # Zero/negative repeats are dropped at parse time; if that leaves nothing
-    # to read, the mix branch fails loudly instead of yielding an empty dataset.
-    with pytest.raises(FileNotFoundError):
-        parquet_dataset.get_parquet_files_and_length({"data/a": 0})
@@ -12,7 +12,6 @@ from fastvideo.configs.pipelines import CosmosConfig, PipelineConfig, WanT2V480P
 from fastvideo.forward_context import set_forward_context
 from fastvideo.logger import init_logger
 from fastvideo.models.loader.component_loader import TextEncoderLoader
-from fastvideo.tests.utils import skip_if_gated_repo_inaccessible
 from fastvideo.utils import maybe_download_model, PRECISION_TO_TYPE
 from fastvideo.fastvideo_args import FastVideoArgs
 from fastvideo.configs.models.encoders import T5Config, T5LargeConfig
@@ -37,11 +36,9 @@ def t5_model_paths_and_config():
@pytest.fixture
 def t5_large_model_paths_and_config():
    base_model_path = "nvidia/Cosmos-Predict2-2B-Video2World"
-    local_dir = os.path.join('data', base_model_path)
-    skip_if_gated_repo_inaccessible(base_model_path,
-                                    local_path=local_dir,
-                                    test_name="Cosmos T5-large encoder test")
-    model_path = maybe_download_model(base_model_path, local_dir=local_dir)
+    model_path = maybe_download_model(base_model_path,
+                                      local_dir=os.path.join(
+                                          'data', base_model_path))
    text_encoder_path = os.path.join(model_path, "text_encoder")
    tokenizer_path = os.path.join(model_path, "tokenizer")
    return text_encoder_path, tokenizer_path, CosmosConfig()
@@ -30,15 +30,6 @@ print(f"Using image: {image_ref}")
 # the baked setting, and a caller override always wins.
 uv_torch_backend_override = resolve_uv_torch_backend(image_tag)

-# INVARIANT: this image definition must be byte-identical for every CI job at
-# a given base image digest -- one build, shared cache across all concurrent
-# lanes. Never put a per-job/per-commit value (BUILDKITE_*, TEST_SCOPE,
-# env-derived overrides) into the image via .env()/run_commands: it becomes an
-# image layer, so whenever the base digest changes every concurrent job
-# rebuilds its own image variant (~15-20 min each), blowing the Buildkite job
-# budget. `image_ref` is the only env-derived input allowed here, because it
-# *selects* the base digest. Per-job values arrive at runtime via
-# `ci_env_secret` below.
 image = (modal.Image.from_registry(
    image_ref, add_python="3.12"
 ).run_commands("rm -rf /FastVideo").apt_install(
@@ -46,42 +37,40 @@ image = (modal.Image.from_registry(
 ).run_commands(
    "curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y --default-toolchain stable"
 ).run_commands("echo 'source ~/.cargo/env' >> ~/.bashrc").env({
-    "PATH": "/root/.cargo/bin:$PATH",
-    "HF_REPO_ID": "FastVideo/performance-tracking",
-}))
-
-dreamverse_image = (image.run_commands(
-    "curl -fsSL https://deb.nodesource.com/setup_22.x | bash -"
-).apt_install("nodejs").run_commands("node --version && npm --version"))
-
-# Per-job/per-invocation values are injected into the container environment at
-# RUNTIME via this secret (attached to every function below), so the image
-# stays identical across jobs. Consumers (run_test_command's checkout,
-# fastvideo/tests/performance/{compare_baseline,identity}.py, the FA4
-# resolver, `uv pip install`) all read os.environ at runtime, so nothing else
-# changes.
-ci_env_secret = modal.Secret.from_dict({
-    "BUILDKITE_REPO": os.environ.get("BUILDKITE_REPO", ""),
-    "BUILDKITE_COMMIT": os.environ.get("BUILDKITE_COMMIT", ""),
-    "BUILDKITE_PULL_REQUEST": os.environ.get("BUILDKITE_PULL_REQUEST", ""),
-    "BUILDKITE_BRANCH": os.environ.get("BUILDKITE_BRANCH", ""),
-    "BUILDKITE_BUILD_URL": os.environ.get("BUILDKITE_BUILD_URL", ""),
-    "BUILDKITE_BUILD_ID": os.environ.get("BUILDKITE_BUILD_ID", ""),
-    "BUILDKITE_JOB_ID": os.environ.get("BUILDKITE_JOB_ID", ""),
-    "TEST_SCOPE": os.environ.get("TEST_SCOPE", ""),
-    "IMAGE_VERSION": image_version,
+    "PATH":
+    "/root/.cargo/bin:$PATH",
+    "BUILDKITE_REPO":
+    os.environ.get("BUILDKITE_REPO", ""),
+    "BUILDKITE_COMMIT":
+    os.environ.get("BUILDKITE_COMMIT", ""),
+    "BUILDKITE_PULL_REQUEST":
+    os.environ.get("BUILDKITE_PULL_REQUEST", ""),
+    "BUILDKITE_BRANCH":
+    os.environ.get("BUILDKITE_BRANCH", ""),
+    "BUILDKITE_BUILD_URL":
+    os.environ.get("BUILDKITE_BUILD_URL", ""),
+    "BUILDKITE_BUILD_ID":
+    os.environ.get("BUILDKITE_BUILD_ID", ""),
+    "BUILDKITE_JOB_ID":
+    os.environ.get("BUILDKITE_JOB_ID", ""),
+    "TEST_SCOPE":
+    os.environ.get("TEST_SCOPE", ""),
+    "IMAGE_VERSION":
+    image_version,
    **({
        "UV_TORCH_BACKEND": uv_torch_backend_override
    } if uv_torch_backend_override else {}),
    # FA4 is opt-in (FASTVIDEO_FA4); CI lanes keep it enabled to match the
    # SSIM/perf baselines. Caller override wins.
-    "FASTVIDEO_FA4": os.environ.get("FASTVIDEO_FA4", "1"),
-})
+    "FASTVIDEO_FA4":
+    os.environ.get("FASTVIDEO_FA4", "1"),
+    "HF_REPO_ID":
+    "FastVideo/performance-tracking",
+}))

-hf_secret = modal.Secret.from_dict(
-    {"HF_API_KEY": os.environ.get("HF_API_KEY", "")})
-wandb_secret = modal.Secret.from_dict(
-    {"WANDB_API_KEY": os.environ.get("WANDB_API_KEY", "")})
+dreamverse_image = (image.run_commands(
+    "curl -fsSL https://deb.nodesource.com/setup_22.x | bash -"
+).apt_install("nodejs").run_commands("node --version && npm --version"))


 def run_test(pytest_command: str):
@@ -158,7 +147,10 @@ def run_test_command(test_command: str,
@app.function(gpu="H100:1",
              image=image,
              timeout=1200,
-              secrets=[hf_secret, ci_env_secret],
+              secrets=[
+                  modal.Secret.from_dict(
+                      {"HF_API_KEY": os.environ.get("HF_API_KEY", "")})
+              ],
              volumes={"/root/data": model_vol})
 def run_encoder_tests():
    run_test(
@@ -169,7 +161,10 @@ def run_encoder_tests():
@app.function(gpu="L40S:1",
              image=image,
              timeout=1200,
-              secrets=[hf_secret, ci_env_secret],
+              secrets=[
+                  modal.Secret.from_dict(
+                      {"HF_API_KEY": os.environ.get("HF_API_KEY", "")})
+              ],
              volumes={"/root/data": model_vol})
 def run_vae_tests():
    run_test(
@@ -180,7 +175,10 @@ def run_vae_tests():
@app.function(gpu="L40S:1",
              image=image,
              timeout=900,
-              secrets=[hf_secret, ci_env_secret],
+              secrets=[
+                  modal.Secret.from_dict(
+                      {"HF_API_KEY": os.environ.get("HF_API_KEY", "")})
+              ],
              volumes={"/root/data": model_vol})
 def run_transformer_tests():
    run_test(
@@ -193,7 +191,10 @@ def run_transformer_tests():
              memory=32768,
              image=image,
              timeout=900,
-              secrets=[wandb_secret, ci_env_secret],
+              secrets=[
+                  modal.Secret.from_dict(
+                      {"WANDB_API_KEY": os.environ.get("WANDB_API_KEY", "")})
+              ],
              volumes={"/root/data": model_vol})
 def run_training_tests():
    run_test(
@@ -206,7 +207,10 @@ def run_training_tests():
              memory=32768,
              image=image,
              timeout=900,
-              secrets=[wandb_secret, ci_env_secret],
+              secrets=[
+                  modal.Secret.from_dict(
+                      {"WANDB_API_KEY": os.environ.get("WANDB_API_KEY", "")})
+              ],
              volumes={"/root/data": model_vol})
 def run_training_lora_tests():
    run_test(
@@ -217,41 +221,44 @@ def run_training_lora_tests():
@app.function(gpu="H100:2",
              image=image,
              timeout=900,
-              secrets=[wandb_secret, ci_env_secret])
+              secrets=[
+                  modal.Secret.from_dict(
+                      {"WANDB_API_KEY": os.environ.get("WANDB_API_KEY", "")})
+              ])
 def run_training_tests_VSA():
    run_test(
        "wandb login $WANDB_API_KEY && pytest ./fastvideo/tests/training/VSA -srP"
    )


-@app.function(gpu="H100:1", image=image, timeout=900, secrets=[ci_env_secret])
+@app.function(gpu="H100:1", image=image, timeout=900)
 def run_kernel_tests():
    run_test("pytest fastvideo-kernel/tests/ -vs")


-# @app.function(gpu="H100:1", image=image, timeout=900, secrets=[ci_env_secret])
+# @app.function(gpu="H100:1", image=image, timeout=900)
 # def run_precision_tests_VSA():
 #     # VSA correctness is covered by the same file now
 #     run_test("pytest fastvideo-kernel/tests/test_correctness.py")

-# @app.function(gpu="L40S:1", image=image, timeout=900, secrets=[ci_env_secret])
+# @app.function(gpu="L40S:1", image=image, timeout=900)
 # def run_precision_tests_vmoba():
 #     run_test("pytest fastvideo-kernel/tests/test_vmoba_correctness.py")


-@app.function(gpu="L40S:1", image=image, timeout=900, secrets=[ci_env_secret])
+@app.function(gpu="L40S:1", image=image, timeout=900)
 def run_inference_tests_vmoba():
    run_test('python fastvideo/tests/inference/vmoba/test_vmoba_inference.py')


-@app.function(gpu="L40S:1", image=image, timeout=1200, secrets=[ci_env_secret])
+@app.function(gpu="L40S:1", image=image, timeout=1200)
 def run_inference_lora_tests():
    run_test(
        "pytest ./fastvideo/tests/inference/lora/test_lora_inference_similarity.py -vs"
    )


-@app.function(gpu="L40S:2", image=image, timeout=900, secrets=[ci_env_secret])
+@app.function(gpu="L40S:2", image=image, timeout=900)
 def run_distill_dmd_tests():
    run_test(
        "pytest ./fastvideo/tests/training/distill/test_distill_dmd.py -vs")
@@ -260,25 +267,25 @@ def run_distill_dmd_tests():
@app.function(gpu="L40S:2",
              image=image,
              timeout=900,
-              secrets=[wandb_secret, ci_env_secret])
+              secrets=[
+                  modal.Secret.from_dict(
+                      {"WANDB_API_KEY": os.environ.get("WANDB_API_KEY", "")})
+              ])
 def run_self_forcing_tests():
    run_test(
        "wandb login $WANDB_API_KEY && pytest ./fastvideo/tests/training/self-forcing/test_self_forcing.py -vs"
    )


-@app.function(gpu="L40S:1", image=image, timeout=900, secrets=[ci_env_secret])
+@app.function(gpu="L40S:1", image=image, timeout=900)
 def run_unit_test():
    run_test(
-        "pytest ./fastvideo/tests/api/ ./fastvideo/tests/contract/ ./fastvideo/tests/dataset/ ./fastvideo/tests/workflow/ ./fastvideo/tests/entrypoints/ ./fastvideo/tests/train/ ./fastvideo/tests/stages/ ./fastvideo/tests/ops/ ./fastvideo/tests/training/test_trackers.py ./fastvideo/tests/attention/test_sdpa_metadata_mask_contract.py --ignore=./fastvideo/tests/entrypoints/test_openai_api_integration.py --ignore=./fastvideo/tests/train/models --ignore=./fastvideo/tests/train/methods -vs"
+        "pytest ./fastvideo/tests/api/ ./fastvideo/tests/contract/ ./fastvideo/tests/dataset/ ./fastvideo/tests/workflow/ ./fastvideo/tests/entrypoints/ ./fastvideo/tests/train/ ./fastvideo/tests/stages/ ./fastvideo/tests/ops/ ./fastvideo/tests/training/test_trackers.py --ignore=./fastvideo/tests/entrypoints/test_openai_api_integration.py --ignore=./fastvideo/tests/train/models --ignore=./fastvideo/tests/train/methods -vs"
    )


 # TODO: David: GPU only used to resolve import time requirement (not needed for this test). Maybe make those imports lazy?
-@app.function(gpu="L40S:1",
-              image=dreamverse_image,
-              timeout=1800,
-              secrets=[ci_env_secret])
+@app.function(gpu="L40S:1", image=dreamverse_image, timeout=1800)
 def run_dreamverse_app_tests():
    run_test_command(
        install_command="",
@@ -319,7 +326,10 @@ def run_dreamverse_app_tests():
              memory=32768,
              image=image,
              timeout=1800,
-              secrets=[hf_secret, ci_env_secret],
+              secrets=[
+                  modal.Secret.from_dict(
+                      {"HF_API_KEY": os.environ.get("HF_API_KEY", "")})
+              ],
              volumes={"/root/data": model_vol})
 def run_train_framework_tests():
    run_test(
@@ -330,7 +340,10 @@ def run_train_framework_tests():
@app.function(gpu="L40S:1",
              image=image,
              timeout=1800,
-              secrets=[hf_secret, ci_env_secret],
+              secrets=[
+                  modal.Secret.from_dict(
+                      {"HF_API_KEY": os.environ.get("HF_API_KEY", "")})
+              ],
              volumes={"/root/data": model_vol})
 def seed_grad_norm_references():
    """Record the per-method grad-norm reference for the **CI GPU (L40S only)**.
@@ -356,7 +369,10 @@ def seed_grad_norm_references():
@app.function(gpu="L40S:1",
              image=image,
              timeout=3600,
-              secrets=[hf_secret, ci_env_secret],
+              secrets=[
+                  modal.Secret.from_dict(
+                      {"HF_API_KEY": os.environ.get("HF_API_KEY", "")})
+              ],
              volumes={"/root/data": model_vol})
 def run_eval_tests():
    # Eval metric regression: drives the high-level fastvideo.eval API on a
@@ -379,7 +395,10 @@ def run_eval_tests():
@app.function(gpu="L40S:1",
              image=image,
              timeout=3600,
-              secrets=[hf_secret, ci_env_secret])
+              secrets=[
+                  modal.Secret.from_dict(
+                      {"HF_API_KEY": os.environ.get("HF_API_KEY", "")})
+              ])
 def run_lora_extraction_tests():
    run_test(
        "hf auth login --token $HF_API_KEY && pytest ./fastvideo/tests/lora_extraction/test_lora_extraction.py"
@@ -391,7 +410,10 @@ def run_lora_extraction_tests():
              memory=32768,
              image=image,
              timeout=1800,
-              secrets=[hf_secret, ci_env_secret],
+              secrets=[
+                  modal.Secret.from_dict(
+                      {"HF_API_KEY": os.environ.get("HF_API_KEY", "")})
+              ],
              volumes={"/root/data": model_vol})
 def run_performance_tests():
    # PR/direct records are uploaded only on pass; scheduled main uploads pass
@@ -433,7 +455,10 @@ def run_performance_tests():
@app.function(gpu="L40S:1",
              image=image,
              timeout=1800,
-              secrets=[hf_secret, ci_env_secret],
+              secrets=[
+                  modal.Secret.from_dict(
+                      {"HF_API_KEY": os.environ.get("HF_API_KEY", "")})
+              ],
              volumes={"/root/data": model_vol})
 def run_api_server_tests():
    run_test(
@@ -57,12 +57,10 @@ image = (
    .run_commands("echo 'source ~/.cargo/env' >> ~/.bashrc")
    .env(
        {
-            # INVARIANT: keep this image identical for every CI job at a given
-            # base digest -- per-job/per-commit values (BUILDKITE_*) must never
-            # be baked here as image layers or every job rebuilds its own image
-            # variant. repo/commit/PR already reach the container as
-            # run_ssim_partition() arguments.
            "PATH": "/root/.cargo/bin:$PATH",
+            "BUILDKITE_REPO": os.environ.get("BUILDKITE_REPO", ""),
+            "BUILDKITE_COMMIT": os.environ.get("BUILDKITE_COMMIT", ""),
+            "BUILDKITE_PULL_REQUEST": os.environ.get("BUILDKITE_PULL_REQUEST", ""),
            "IMAGE_VERSION": image_version,
            **({"UV_TORCH_BACKEND": uv_torch_backend_override} if uv_torch_backend_override else {}),
            # FA4 is opt-in (FASTVIDEO_FA4); the SSIM references were seeded
@@ -550,7 +548,6 @@ def _spawn_ssim_task(
    log_dir: str,
    task_index: int,
    pytest_extra_args: list[str],
-    hf_api_key: str,
 ) -> _RunningTask:
    import shlex

@@ -560,7 +557,6 @@ def _spawn_ssim_task(
    command = f"set -euo pipefail && source $HOME/.local/bin/env && source /opt/venv/bin/activate && {pytest_command}"
    env = os.environ.copy()
    env["HF_HOME"] = "/root/data/.cache"
-    env["HF_API_KEY"] = hf_api_key
    # MultiprocExecutor returns CUDA tensors through mp pipes (CUDA IPC).
    # On kernels without pidfd_open support, PyTorch fails when
    # expandable_segments=True. Force False for CI compatibility.
@@ -677,7 +673,6 @@ def _build_pytest_extra_args(
    ssim_full_quality: bool,
    ssim_reference_repo: str,
    skip_ssim_reference_download: bool,
-    ssim_bootstrap_mode: bool,
    pytest_k: str,
 ) -> list[str]:
    args = []
@@ -687,8 +682,6 @@ def _build_pytest_extra_args(
        args.extend(["--ssim-reference-repo", ssim_reference_repo.strip()])
    if skip_ssim_reference_download:
        args.append("--skip-ssim-reference-download")
-    if ssim_bootstrap_mode:
-        args.append("--ssim-bootstrap-mode")
    if pytest_k.strip():
        args.extend(["-k", pytest_k.strip()])
    return args
@@ -698,7 +691,6 @@ def _schedule_ssim_tasks(
    repo_root: str,
    tasks: list[SSIMTask],
    pytest_extra_args: list[str],
-    hf_api_key: str,
    fail_fast: bool = True,
 ) -> dict[int, _TaskResult]:
    import tempfile
@@ -741,7 +733,6 @@ def _schedule_ssim_tasks(
                log_dir=log_dir,
                task_index=task.task_id,
                pytest_extra_args=pytest_extra_args,
-                hf_api_key=hf_api_key,
            )
            print(f"Started {task.test_name} on GPUs {','.join(assigned_gpu_ids)}")
            running_tasks.append(running_task)
@@ -892,7 +883,6 @@ def run_ssim_partition(
    ssim_full_quality: bool = False,
    ssim_reference_repo: str = "",
    skip_ssim_reference_download: bool = False,
-    ssim_bootstrap_mode: bool = False,
    pytest_k: str = "",
    sync_generated_to_volume: bool = False,
    generated_volume_subdir: str = "",
@@ -921,14 +911,12 @@ def run_ssim_partition(
        ssim_full_quality=ssim_full_quality,
        ssim_reference_repo=ssim_reference_repo,
        skip_ssim_reference_download=skip_ssim_reference_download,
-        ssim_bootstrap_mode=ssim_bootstrap_mode,
        pytest_k=pytest_k,
    )
    results = _schedule_ssim_tasks(
        repo_root,
        partition,
        pytest_extra_args=pytest_extra_args,
-        hf_api_key=hf_api_key,
        fail_fast=fail_fast,
    )
    summaries = _collect_task_summaries(partition, results)
@@ -965,7 +953,6 @@ def run_ssim_tests(
    full_quality: bool = False,
    reference_repo: str = "",
    skip_reference_download: bool = False,
-    bootstrap_mode: bool = False,
    pytest_k: str = "",
    sync_generated_to_volume: bool = False,
    generated_volume_subdir: str = "",
@@ -986,24 +973,15 @@ def run_ssim_tests(
        print(f"Selected model ids: {model_ids}")
    if pytest_k.strip():
        print(f"Using pytest -k filter: {pytest_k}")
-    if bootstrap_mode:
-        print(
-            "SSIM bootstrap mode enabled: missing references will upload "
-            "draft artifacts and xfail."
-        )
    quality_tier = _resolve_output_quality_tier(full_quality)
    if sync_generated_to_volume:
        resolved_subdir = _resolve_generated_volume_subdir(
            generated_volume_subdir,
            resolved_git_commit,
        )
-        generated_volume_path = _build_generated_volume_relative_path(
-            generated_volume_subdir=resolved_subdir,
-            quality_tier=quality_tier,
-        )
        print(
            "Raw generated videos will be saved to Modal volume path: "
-            f"{generated_volume_path}"
+            f"{_build_generated_volume_relative_path(generated_volume_subdir=resolved_subdir, quality_tier=quality_tier)}"
        )
    else:
        resolved_subdir = ""
@@ -1018,7 +996,6 @@ def run_ssim_tests(
        ssim_full_quality=full_quality,
        ssim_reference_repo=reference_repo,
        skip_ssim_reference_download=skip_reference_download,
-        ssim_bootstrap_mode=bootstrap_mode,
        pytest_k=pytest_k,
        sync_generated_to_volume=sync_generated_to_volume,
        generated_volume_subdir=resolved_subdir,
@@ -1,101 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-
-from __future__ import annotations
-
-import importlib.util
-import sys
-import types
-from pathlib import Path
-
-
-class _FakeImage:
-
-    @classmethod
-    def from_registry(cls, *_args, **_kwargs):
-        return cls()
-
-    def apt_install(self, *_args, **_kwargs):
-        return self
-
-    def run_commands(self, *_args, **_kwargs):
-        return self
-
-    def env(self, *_args, **_kwargs):
-        return self
-
-
-class _FakeVolume:
-
-    @classmethod
-    def from_name(cls, *_args, **_kwargs):
-        return cls()
-
-
-class _FakeApp:
-
-    def function(self, *_args, **_kwargs):
-        def decorator(func):
-            return func
-
-        return decorator
-
-    def local_entrypoint(self, *_args, **_kwargs):
-        def decorator(func):
-            return func
-
-        return decorator
-
-
-def _load_ssim_test_module(monkeypatch):
-    fake_modal = types.SimpleNamespace(
-        App=lambda: _FakeApp(),
-        Image=_FakeImage,
-        Volume=_FakeVolume,
-    )
-    monkeypatch.setitem(sys.modules, "modal", fake_modal)
-    module_path = Path(__file__).with_name("ssim_test.py")
-    spec = importlib.util.spec_from_file_location("modal_ssim_test_under_test", module_path)
-    module = importlib.util.module_from_spec(spec)
-    assert spec.loader is not None
-    spec.loader.exec_module(module)
-    return module
-
-
-def test_spawn_ssim_task_passes_hf_api_key_to_pytest_env(monkeypatch, tmp_path):
-    module = _load_ssim_test_module(monkeypatch)
-    captured = {}
-
-    class FakeProcess:
-        pass
-
-    def fake_popen(*args, **kwargs):
-        captured["args"] = args
-        captured["kwargs"] = kwargs
-        return FakeProcess()
-
-    monkeypatch.setattr(module.subprocess, "Popen", fake_popen)
-
-    task = module.SSIMTask(
-        task_id=0,
-        test_file="fastvideo/tests/ssim/test_example.py",
-        required_gpus=1,
-        model_id="model-a",
-    )
-
-    running_task = module._spawn_ssim_task(
-        task=task,
-        repo_root=str(tmp_path),
-        assigned_gpu_ids=["2"],
-        log_dir=str(tmp_path),
-        task_index=0,
-        pytest_extra_args=["--ssim-bootstrap-mode"],
-        hf_api_key="hf_test_token",
-    )
-
-    env = captured["kwargs"]["env"]
-    assert env["HF_API_KEY"] == "hf_test_token"
-    assert env["HF_HOME"] == "/root/data/.cache"
-    assert env["CUDA_VISIBLE_DEVICES"] == "2"
-    assert env["FASTVIDEO_SSIM_MODEL_ID"] == "model-a"
-    assert running_task.process.__class__ is FakeProcess
-    running_task.log_handle.close()
@@ -63,30 +63,3 @@ def _raise_module_on_import(name: str) -> types.ModuleType:
            raise ImportError(f"No module named '{name}.{item}'")

    return _RaisingModule(name)
-
-
-def test_coerce_fp4_input_dtype_casts_and_rejects():
-    """The FP4 input-dtype coercion (CPU-only, no flashinfer/CUDA): bf16/fp16
-    pass through, other floats (the fp32 pre-attention norm in eager mode) are
-    cast to bf16, and non-floating inputs are rejected fast."""
-    import torch
-
-    from fastvideo.layers.quantization.nvfp4_config import (
-        _coerce_fp4_input_dtype)
-
-    # bf16 / fp16 pass through untouched.
-    bf16 = torch.zeros(4, 8, dtype=torch.bfloat16)
-    assert _coerce_fp4_input_dtype(bf16) is bf16
-    fp16 = torch.zeros(4, 8, dtype=torch.float16)
-    assert _coerce_fp4_input_dtype(fp16) is fp16
-
-    # Other floating dtypes (fp32 from an unfused norm, fp64) -> bf16.
-    assert _coerce_fp4_input_dtype(
-        torch.zeros(4, 8, dtype=torch.float32)).dtype is torch.bfloat16
-    assert _coerce_fp4_input_dtype(
-        torch.zeros(4, 8, dtype=torch.float64)).dtype is torch.bfloat16
-
-    # Non-floating inputs are a real error, not silently cast.
-    for bad in (torch.int32, torch.int64, torch.bool):
-        with pytest.raises(TypeError, match="floating-point"):
-            _coerce_fp4_input_dtype(torch.zeros(4, 8, dtype=bad))
@@ -66,7 +66,6 @@ UPLOAD_POLICY = os.environ.get("PERF_UPLOAD_POLICY", "never").strip().lower()
 VALID_UPLOAD_POLICIES = {"never", "pass", "always"}
 VALID_RUN_SOURCES = {"pr", "local", "scheduled_main", "unknown"}
 IDENTITY_KEYS = (
-    "result_schema_version",
    "workload_id",
    "variant_id",
    "benchmark_version",
@@ -78,8 +77,6 @@ IDENTITY_KEYS = (
    "software_profile_id",
    "environment_metadata",
    "environment_fingerprint",
-    "quality_metadata",
-    "variant_metadata",
 )
 COMPARISON_IDENTITY_KEYS = (
    "workload_id",
@@ -146,22 +143,18 @@ def _result_failed_static_thresholds() -> bool:


 def _record_metadata(run_source: str, result: dict[str, Any]) -> dict[str, Any]:
-    raw_run_source = str(result.get("run_source") or "").strip().lower()
-    if raw_run_source in VALID_RUN_SOURCES:
-        run_source = raw_run_source
-
    pr_number = result.get("pr_number") or os.environ.get("BUILDKITE_PULL_REQUEST", "")
    if not _truthy_pr_number(str(pr_number)):
        pr_number = ""
    return {
        "run_source": run_source,
        "baseline_eligible": False,
-        "branch": result.get("branch") or os.environ.get("BUILDKITE_BRANCH", ""),
+        "branch": os.environ.get("BUILDKITE_BRANCH", ""),
        "pr_number": pr_number,
-        "test_scope": result.get("test_scope") or os.environ.get("TEST_SCOPE", ""),
-        "build_url": result.get("build_url") or os.environ.get("BUILDKITE_BUILD_URL", ""),
-        "build_id": result.get("build_id") or os.environ.get("BUILDKITE_BUILD_ID", ""),
-        "job_id": result.get("job_id") or os.environ.get("BUILDKITE_JOB_ID", ""),
+        "test_scope": os.environ.get("TEST_SCOPE", ""),
+        "build_url": os.environ.get("BUILDKITE_BUILD_URL", ""),
+        "build_id": os.environ.get("BUILDKITE_BUILD_ID", ""),
+        "job_id": os.environ.get("BUILDKITE_JOB_ID", ""),
    }


@@ -185,6 +178,11 @@ def _comparison_identity_filters(record: dict[str, Any]) -> dict[str, str]:
        key for key in COMPARISON_IDENTITY_KEYS
        if key not in record or record[key] is None or (isinstance(record[key], str) and not record[key].strip())
    ]
+    if len(missing) == len(COMPARISON_IDENTITY_KEYS):
+        # Legacy v1 record: no identity fields at all. Keep the pre-v2
+        # (model_id, gpu_type) rolling-baseline comparison instead of
+        # crashing — v1 configs are documented as loadable.
+        return {}
    if missing:
        raise ValueError("Performance record missing required comparison identity fields: " + ", ".join(missing))
    return {
@@ -193,18 +191,6 @@ def _comparison_identity_filters(record: dict[str, Any]) -> dict[str, str]:
    }


-def _comparison_identity_filters_or_none(record: dict[str, Any]) -> dict[str, str] | None:
-    try:
-        return _comparison_identity_filters(record)
-    except ValueError as exc:
-        print("Skipping rolling baseline comparison for "
-              f"{record.get('model_id', 'unknown')} on "
-              f"{record.get('gpu_type', 'unknown')}: {exc}. "
-              "The normalized artifact will still be written, but this record "
-              "will not be baseline eligible.")
-        return None
-
-
 def _format_identity_filters(filters: dict[str, str]) -> str:
    if not filters:
        return ""
@@ -495,53 +481,43 @@ def main() -> int:
    for raw in current_results:
        record = _normalize_record(raw)
        metric_policies = resolve_metric_policies(record.get("regression_thresholds"))
-        identity_filters = _comparison_identity_filters_or_none(record)

-        baseline_records: list[dict[str, Any]] = []
-        if identity_filters is None:
-            # Records without the full v2 identity block skip rolling-baseline
-            # comparison entirely: only the static thresholds gate them and
-            # they never become baseline eligible.
-            record["baseline_status"] = "skipped_missing_identity"
+        baseline_records = load_records_for_model(
+            TRACKING_ROOT,
+            record["model_id"],
+            record["gpu_type"],
+            **_comparison_identity_filters(record),
+            last_n=5,
+            successful_only=True,
+            baseline_eligible_only=True,
+        )
+
+        if not baseline_records:
+            # A brand-new cohort has NO regression gating until history
+            # accumulates — make that loud and machine-readable instead of
+            # an indistinguishable pass, so a cohort shift (intended or
+            # accidental, e.g. an identity-field change) never silently
+            # blinds the comparison.
+            record["baseline_status"] = "initialized_new_cohort"
+            print("=" * 72)
+            print(f"WARNING: NO BASELINE — initializing a NEW cohort for "
+                  f"{record['model_id']} on {record['gpu_type']}"
+                  f"{_format_identity_filters(_comparison_identity_filters(record))}")
+            print("Regression gating is INACTIVE for this cohort until "
+                  "baseline history accumulates. If this cohort shift is "
+                  "unexpected, check the identity fields above.")
+            print("=" * 72)
            failures: list[str] = []
+            record["success"] = True
        else:
-            baseline_records = load_records_for_model(
-                TRACKING_ROOT,
-                record["model_id"],
-                record["gpu_type"],
-                **identity_filters,
-                last_n=5,
-                successful_only=True,
-                baseline_eligible_only=True,
-            )
-
-            if not baseline_records:
-                # A brand-new cohort has NO regression gating until history
-                # accumulates — make that loud and machine-readable instead of
-                # an indistinguishable pass, so a cohort shift (intended or
-                # accidental, e.g. an identity-field change) never silently
-                # blinds the comparison.
-                record["baseline_status"] = "initialized_new_cohort"
-                print("=" * 72)
-                print(f"WARNING: NO BASELINE — initializing a NEW cohort for "
-                      f"{record['model_id']} on {record['gpu_type']}"
-                      f"{_format_identity_filters(identity_filters)}")
-                print("Regression gating is INACTIVE for this cohort until "
-                      "baseline history accumulates. If this cohort shift is "
-                      "unexpected, check the identity fields above.")
-                print("=" * 72)
-                failures = []
-            else:
-                record["baseline_status"] = "compared"
-                failures = _check_regressions(record, baseline_records, metric_policies)
+            record["baseline_status"] = "compared"
+            failures = _check_regressions(record, baseline_records, metric_policies)
        if static_threshold_failed:
            failures.append(f"{record['model_id']} fixed-threshold phase failed "
                            f"(PERF_PYTEST_RC={os.environ.get('PERF_PYTEST_RC')})")

        record["success"] = not failures
-        record["baseline_eligible"] = (
-            identity_filters is not None and _is_baseline_eligible(record["run_source"], record["success"])
-        )
+        record["baseline_eligible"] = _is_baseline_eligible(record["run_source"], record["success"])
        all_failures.extend(failures)

        _write_normalized_artifact(record)
@@ -14,9 +14,9 @@ def _v2_config():
    return {
        "benchmark_id": "wan-t2v-1.3b-2gpu",
        "config_schema_version": 2,
-        "workload_id": "wan-t2v",
-        "variant_id": "1.3b-sp2",
-        "benchmark_version": 2,
+        "workload_id": "wan-t2v-1.3b",
+        "variant_id": "canonical",
+        "benchmark_version": 1,
    }


@@ -41,9 +41,9 @@ def test_v2_benchmark_config_identity_validates_and_is_preserved():
    assert _is_v2_config(cfg) is True
    assert _config_identity_metadata(cfg) == {
        "config_schema_version": 2,
-        "workload_id": "wan-t2v",
-        "variant_id": "1.3b-sp2",
-        "benchmark_version": 2,
+        "workload_id": "wan-t2v-1.3b",
+        "variant_id": "canonical",
+        "benchmark_version": 1,
        "quality_metadata": {"some": "data"},
    }

@@ -91,9 +91,9 @@ def test_v2_benchmark_config_rejects_invalid_benchmark_version_values(value):
 def test_partial_v2_identity_requires_schema_version():
    cfg = {
        "benchmark_id": "wan-t2v-1.3b-2gpu",
-        "workload_id": "wan-t2v",
-        "variant_id": "1.3b-sp2",
-        "benchmark_version": 2,
+        "workload_id": "wan-t2v-1.3b",
+        "variant_id": "canonical",
+        "benchmark_version": 1,
    }

    expected = "wan.json: v2 benchmark identity fields require config_schema_version=2"
@@ -105,9 +105,9 @@ def test_optional_v2_metadata_fields_must_be_objects():
    cfg = {
        "benchmark_id": "wan-t2v-1.3b-2gpu",
        "config_schema_version": 2,
-        "workload_id": "wan-t2v",
-        "variant_id": "1.3b-sp2",
-        "benchmark_version": 2,
+        "workload_id": "wan-t2v-1.3b",
+        "variant_id": "canonical",
+        "benchmark_version": 1,
        "quality_metadata": ["not", "an", "object"],
    }

@@ -1,7 +1,5 @@
 # SPDX-License-Identifier: Apache-2.0

-import json
-
 import pytest

 from fastvideo.tests.performance import compare_baseline
@@ -127,7 +125,6 @@ def test_normalized_record_preserves_identity_metadata(monkeypatch):
    monkeypatch.setenv("PERF_RUN_SOURCE", "pr")
    raw = _raw_result()
    raw.update({
-        "result_schema_version": 2,
        "workload_id": "wan-t2v",
        "variant_id": "1.3b-sp2",
        "benchmark_version": 2,
@@ -149,14 +146,10 @@ def test_normalized_record_preserves_identity_metadata(monkeypatch):
            },
        },
        "environment_fingerprint": "env-1",
-        "quality_metadata": {
-            "quality_status": "canonical",
-        },
    })

    record = compare_baseline.normalize_performance_result(raw)

-    assert record["result_schema_version"] == 2
    assert record["workload_id"] == "wan-t2v"
    assert record["variant_id"] == "1.3b-sp2"
    assert record["benchmark_version"] == 2
@@ -168,87 +161,6 @@ def test_normalized_record_preserves_identity_metadata(monkeypatch):
    assert record["software_profile_id"] == "sw-1"
    assert record["environment_metadata"] == {"env": {"IMAGE_VERSION": "latest"}}
    assert record["environment_fingerprint"] == "env-1"
-    assert record["quality_metadata"] == {"quality_status": "canonical"}
-
-
-def test_normalized_record_prefers_raw_v2_provenance(monkeypatch):
-    monkeypatch.setenv("PERF_RUN_SOURCE", "pr")
-    monkeypatch.setenv("BUILDKITE_BRANCH", "feature/from-env")
-    monkeypatch.setenv("TEST_SCOPE", "direct")
-    monkeypatch.setenv("BUILDKITE_BUILD_URL", "https://buildkite.example/env")
-    monkeypatch.setenv("BUILDKITE_BUILD_ID", "env-build")
-    monkeypatch.setenv("BUILDKITE_JOB_ID", "env-job")
-    raw = _raw_result()
-    raw.update({
-        "result_schema_version": 2,
-        "run_source": "scheduled_main",
-        "branch": "main",
-        "test_scope": "full",
-        "build_url": "https://buildkite.example/raw",
-        "build_id": "raw-build",
-        "job_id": "raw-job",
-        "pr_number": "false",
-    })
-
-    record = compare_baseline.normalize_performance_result(raw)
-
-    assert record["result_schema_version"] == 2
-    assert record["run_source"] == "scheduled_main"
-    assert record["branch"] == "main"
-    assert record["test_scope"] == "full"
-    assert record["build_url"] == "https://buildkite.example/raw"
-    assert record["build_id"] == "raw-build"
-    assert record["job_id"] == "raw-job"
-    assert record["pr_number"] == ""
-
-
-def test_v1_normalized_record_has_no_result_schema_version(monkeypatch):
-    monkeypatch.setenv("PERF_RUN_SOURCE", "pr")
-
-    record = compare_baseline.normalize_performance_result(_raw_result())
-
-    assert "result_schema_version" not in record
-
-
-def test_main_writes_v1_current_artifact_without_comparison_identity(monkeypatch, tmp_path, capsys):
-    results_dir = tmp_path / "results"
-    reports_dir = tmp_path / "reports"
-    tracking_root = tmp_path / "tracking"
-    results_dir.mkdir()
-    (results_dir / "perf_legacy.json").write_text(json.dumps(_raw_result()), encoding="utf-8")
-    uploaded_records = []
-
-    monkeypatch.setenv("PERF_RUN_SOURCE", "scheduled_main")
-    monkeypatch.delenv("PERF_PYTEST_RC", raising=False)
-    monkeypatch.setattr(compare_baseline, "RESULTS_DIR", str(results_dir))
-    monkeypatch.setattr(compare_baseline, "PERF_REPORTS_DIR", str(reports_dir))
-    monkeypatch.setattr(compare_baseline, "TRACKING_ROOT", str(tracking_root))
-    monkeypatch.setattr(compare_baseline, "UPLOAD_POLICY", "always")
-    monkeypatch.setattr(compare_baseline, "sync_from_hf", lambda local_dir, strict=False: local_dir)
-
-    def fail_load_records_for_model(*_args, **_kwargs):
-        raise AssertionError("legacy current records should skip v2 baseline lookup")
-
-    def fake_upload_record(_path, record, *, strict=False):
-        uploaded_records.append(record.copy())
-
-    monkeypatch.setattr(compare_baseline, "load_records_for_model", fail_load_records_for_model)
-    monkeypatch.setattr(compare_baseline, "upload_record", fake_upload_record)
-
-    assert compare_baseline.main() == 0
-
-    output = capsys.readouterr().out
-    normalized_files = list((reports_dir / "results").glob("normalized_perf_*.json"))
-    assert "Skipping rolling baseline comparison" in output
-    assert "workload_id" in output
-    assert len(normalized_files) == 1
-
-    normalized = json.loads(normalized_files[0].read_text(encoding="utf-8"))
-    assert "result_schema_version" not in normalized
-    assert normalized["success"] is True
-    assert normalized["baseline_eligible"] is False
-    assert len(uploaded_records) == 1
-    assert uploaded_records[0]["baseline_eligible"] is False


 def test_normalized_record_reads_identity_labels_from_recipe(monkeypatch):
@@ -154,8 +154,8 @@ def test_dashboard_endpoints_filter_and_return_run_source_metadata():
    assert summary["count"] == 1
    assert summary["rows"][0]["run_source"] == "pr"
    assert summary["rows"][0]["pr_number"] == "123"
-    assert summary["rows"][0]["baseline_n"] == 0
-    assert summary["rows"][0]["metrics"]["latency"]["baseline"] is None
+    assert summary["rows"][0]["baseline_n"] == 1
+    assert summary["rows"][0]["metrics"]["latency"]["baseline"] == 11.0
    assert summary["filters"]["run_source"] == "pr"
    assert trends["count"] == 1
    assert trends["groups"][0]["points"][0]["run_source"] == "pr"
@@ -142,47 +142,6 @@ def test_build_latest_summary_separates_informational_threshold_crossing():
    assert rows[0]["threshold_exceeded_metrics"] == ["latency"]
    assert rows[0]["failing_metrics"] == []
    assert rows[0]["computed_regression_status"] == "pass"
-
-
-def test_build_latest_summary_run_source_filter_excludes_future_baselines():
-    records = [
-        _record(
-            "2026-01-01T00:00:00+00:00",
-            "a" * 40,
-            10.0,
-            10.0,
-            run_source="scheduled_main",
-            baseline_eligible=True,
-        ),
-        _record(
-            "2026-01-02T00:00:00+00:00",
-            "b" * 40,
-            11.0,
-            9.0,
-            run_source="pr",
-            baseline_eligible=False,
-            pr_number="123",
-        ),
-        _record(
-            "2026-01-03T00:00:00+00:00",
-            "c" * 40,
-            30.0,
-            3.0,
-            run_source="scheduled_main",
-            baseline_eligible=True,
-        ),
-    ]
-
-    rows = build_latest_summary(records, run_source="pr")
-
-    assert len(rows) == 1
-    assert rows[0]["run_source"] == "pr"
-    assert rows[0]["baseline_n"] == 1
-    assert rows[0]["metrics"]["latency"]["baseline"] == 10.0
-    assert rows[0]["metrics"]["throughput"]["baseline"] == 10.0
-
-
-
 def test_build_latest_summary_keeps_identity_cohorts_separate():
    records = [
        _record(
@@ -290,58 +249,6 @@ def test_build_latest_summary_keeps_variant_versions_separate():
    assert version_2_row["metrics"]["latency"]["baseline"] == 20.0


-def test_dashboard_identity_preserves_zero_benchmark_version():
-    records = [
-        _record(
-            "2026-01-01T00:00:00+00:00",
-            "a" * 40,
-            10.0,
-            10.0,
-            workload_id="wan-t2v",
-            variant_id="1.3b-sp2",
-            benchmark_version=0,
-            recipe_fingerprint="recipe-a",
-            hardware_profile_id="hw-l40s",
-            software_profile_id="sw-cu130",
-            run_source="scheduled_main",
-            baseline_eligible=True,
-        ),
-        _record(
-            "2026-01-02T00:00:00+00:00",
-            "b" * 40,
-            11.0,
-            9.0,
-            workload_id="wan-t2v",
-            variant_id="1.3b-sp2",
-            benchmark_version=0,
-            recipe_fingerprint="recipe-a",
-            hardware_profile_id="hw-l40s",
-            software_profile_id="sw-cu130",
-        ),
-        _record(
-            "2026-01-03T00:00:00+00:00",
-            "c" * 40,
-            20.0,
-            5.0,
-        ),
-    ]
-
-    rows = build_latest_summary(records)
-    version_zero_row = next(row for row in rows if row["benchmark_version"] == 0)
-    legacy_row = next(row for row in rows if row["benchmark_version"] == "")
-    trends = build_trends(records)
-    version_zero_trend = next(trend for trend in trends if trend["benchmark_version"] == 0)
-    legacy_trend = next(trend for trend in trends if trend["benchmark_version"] == "")
-
-    assert len(rows) == 2
-    assert version_zero_row["baseline_n"] == 1
-    assert version_zero_row["metrics"]["latency"]["baseline"] == 10.0
-    assert legacy_row["baseline_n"] == 0
-    assert len(trends) == 2
-    assert version_zero_trend["points"][0]["benchmark_version"] == 0
-    assert legacy_trend["points"][0]["benchmark_version"] == ""
-
-
 def test_filter_records_and_trends_preserve_metric_points():
    records = [
        _record("2026-01-01T00:00:00+00:00", "a" * 40, 10.0, 10.0),
@@ -55,9 +55,6 @@ V2_OPTIONAL_METADATA_FIELDS = (
    "metric_threshold_policy",
    "quality_metadata",
 )
-RESULT_SCHEMA_VERSION = 2
-VALID_RUN_SOURCES = {"pr", "local", "scheduled_main", "unknown"}
-OPTIONAL_RESULT_METADATA_FIELDS = ("quality_metadata", "variant_metadata")

 # -- Config discovery -------------------------------------------------------

@@ -234,17 +231,6 @@ def _run_generation(generator, prompt, generation_kwargs):
    component_times = _extract_component_times(result)
    return elapsed, peak_memory_mb, component_times

-
-def _validate_run_counts(run_config: Mapping[str, Any], benchmark_id: str) -> tuple[int, int]:
-    num_warmup = run_config.get("num_warmup_runs", 1)
-    num_measure = run_config.get("num_measurement_runs", 3)
-    if isinstance(num_warmup, bool) or not isinstance(num_warmup, int) or num_warmup < 0:
-        raise ValueError(f"{benchmark_id}: run_config.num_warmup_runs must be a non-negative integer")
-    if isinstance(num_measure, bool) or not isinstance(num_measure, int) or num_measure < 1:
-        raise ValueError(f"{benchmark_id}: run_config.num_measurement_runs must be a positive integer")
-    return num_warmup, num_measure
-
-
 def _write_results(results):
    """Write JSON results to the results directory."""
    script_dir = os.path.dirname(os.path.abspath(__file__))
@@ -365,101 +351,6 @@ def _build_identity_fields(cfg, init_kwargs, prompt, runtime_identity):
    }


-def _truthy_pr_number(value: str | None) -> bool:
-    return bool(value and value not in {"false", "0", "None", "none"})
-
-
-def _detect_run_source() -> str:
-    explicit = os.environ.get("PERF_RUN_SOURCE", "").strip().lower()
-    if explicit in VALID_RUN_SOURCES:
-        return explicit
-    if _truthy_pr_number(os.environ.get("BUILDKITE_PULL_REQUEST")):
-        return "pr"
-    if os.environ.get("BUILDKITE_BRANCH") == "main" and os.environ.get("TEST_SCOPE") == "full":
-        return "scheduled_main"
-    if not os.environ.get("BUILDKITE_COMMIT"):
-        return "local"
-    return "unknown"
-
-
-def _ci_provenance_fields() -> dict[str, str]:
-    pr_number = os.environ.get("BUILDKITE_PULL_REQUEST", "")
-    if not _truthy_pr_number(pr_number):
-        pr_number = ""
-    return {
-        "run_source": _detect_run_source(),
-        "branch": os.environ.get("BUILDKITE_BRANCH", ""),
-        "pr_number": pr_number,
-        "test_scope": os.environ.get("TEST_SCOPE", ""),
-        "build_url": os.environ.get("BUILDKITE_BUILD_URL", ""),
-        "build_id": os.environ.get("BUILDKITE_BUILD_ID", ""),
-        "job_id": os.environ.get("BUILDKITE_JOB_ID", ""),
-    }
-
-
-def _configured_result_metadata(cfg: Mapping[str, Any]) -> dict[str, Any]:
-    return {
-        field: cfg[field]
-        for field in OPTIONAL_RESULT_METADATA_FIELDS
-        if field in cfg and cfg[field] is not None
-    }
-
-
-def _build_result_record(
-    *,
-    cfg: Mapping[str, Any],
-    model_info: Mapping[str, Any],
-    init_kwargs: Mapping[str, Any],
-    gen_kwargs: Mapping[str, Any],
-    num_warmup: int,
-    num_measure: int,
-    thresholds: Mapping[str, Any],
-    times: list[float],
-    peak_memories: list[float],
-    all_component_times: list[dict],
-    prompt: str,
-    runtime_identity: Mapping[str, Any],
-    device_name: str,
-    timestamp: str | None = None,
-) -> dict[str, Any]:
-    if not times or not peak_memories:
-        raise ValueError("Cannot build a performance result record without measurement runs")
-    avg_time = sum(times) / len(times)
-    max_peak_memory = max(peak_memories)
-    num_frames = gen_kwargs.get("num_frames")
-    throughput_fps = (1.0 / avg_time) if avg_time > 0 else None
-    if isinstance(num_frames, (int, float)) and avg_time > 0:
-        throughput_fps = num_frames / avg_time
-
-    return {
-        "benchmark_id": cfg["benchmark_id"],
-        "result_schema_version": RESULT_SCHEMA_VERSION,
-        "model_short_name": model_info.get("model_short_name", ""),
-        "device": device_name,
-        "num_gpus": init_kwargs.get("num_gpus", 1),
-        "num_warmup_runs": num_warmup,
-        "num_measurement_runs": num_measure,
-        "avg_generation_time_s": round(avg_time, 3),
-        "individual_times_s": [round(t, 3) for t in times],
-        "throughput_fps": round(throughput_fps, 3)
-        if throughput_fps is not None else None,
-        "max_peak_memory_mb": round(max_peak_memory, 1),
-        "individual_peak_memories_mb": [round(m, 1) for m in peak_memories],
-        "thresholds": dict(thresholds),
-        "regression_thresholds": cfg.get("regression_thresholds", {}),
-        "commit": os.environ.get("BUILDKITE_COMMIT", ""),
-        **_ci_provenance_fields(),
-        "timestamp": timestamp or datetime.now(timezone.utc).isoformat(),
-        **_configured_result_metadata(cfg),
-        "text_encoder_time_s": _avg_component(all_component_times,
-                                              "text_encoder_time_s"),
-        "dit_time_s": _avg_component(all_component_times, "dit_time_s"),
-        "vae_decode_time_s": _avg_component(all_component_times,
-                                            "vae_decode_time_s"),
-        **_build_identity_fields(cfg, init_kwargs, prompt, runtime_identity),
-    }
-
-
 # -- Test -------------------------------------------------------------------

 def _run_benchmark(cfg):
@@ -475,7 +366,8 @@ def _run_benchmark(cfg):
    prompts = cfg.get("test_prompts", ["A cinematic video."])
    prompt = prompts[0]

-    num_warmup, num_measure = _validate_run_counts(run_config, cfg["benchmark_id"])
+    num_warmup = run_config.get("num_warmup_runs", 1)
+    num_measure = run_config.get("num_measurement_runs", 3)
    thresholds = _get_thresholds(cfg)

    # Remap JSON keys to VideoGenerator kwargs
@@ -522,21 +414,37 @@ def _run_benchmark(cfg):
    avg_time = sum(times) / len(times)
    max_peak_memory = max(peak_memories)
    device_name = torch.cuda.get_device_name()
-    results = _build_result_record(
-        cfg=cfg,
-        model_info=model_info,
-        init_kwargs=init_kwargs,
-        gen_kwargs=gen_kwargs,
-        num_warmup=num_warmup,
-        num_measure=num_measure,
-        thresholds=thresholds,
-        times=times,
-        peak_memories=peak_memories,
-        all_component_times=all_component_times,
-        prompt=prompt,
-        runtime_identity=runtime_identity,
-        device_name=device_name,
-    )
+    num_frames = gen_kwargs.get("num_frames")
+    throughput_fps = (1.0 / avg_time) if avg_time > 0 else None
+    if isinstance(num_frames, (int, float)) and avg_time > 0:
+        throughput_fps = num_frames / avg_time
+
+    results = {
+        "benchmark_id": cfg["benchmark_id"],
+        **_config_identity_metadata(cfg),
+        "model_short_name": model_info.get("model_short_name", ""),
+        "device": device_name,
+        "num_gpus": init_kwargs.get("num_gpus", 1),
+        "num_warmup_runs": num_warmup,
+        "num_measurement_runs": num_measure,
+        "avg_generation_time_s": round(avg_time, 3),
+        "individual_times_s": [round(t, 3) for t in times],
+        "throughput_fps": round(throughput_fps, 3)
+        if throughput_fps is not None else None,
+        "max_peak_memory_mb": round(max_peak_memory, 1),
+        "individual_peak_memories_mb": [round(m, 1) for m in peak_memories],
+        "thresholds": thresholds,
+        "regression_thresholds": cfg.get("regression_thresholds", {}),
+        "commit": os.environ.get("BUILDKITE_COMMIT", ""),
+        "pr_number": os.environ.get("BUILDKITE_PULL_REQUEST", ""),
+        "timestamp": datetime.now(timezone.utc).isoformat(),
+        "text_encoder_time_s": _avg_component(all_component_times,
+                                              "text_encoder_time_s"),
+        "dit_time_s": _avg_component(all_component_times, "dit_time_s"),
+        "vae_decode_time_s": _avg_component(all_component_times,
+                                            "vae_decode_time_s"),
+        **_build_identity_fields(cfg, init_kwargs, prompt, runtime_identity),
+    }

    logger.info(
        "Performance results: avg_time=%.2fs, "
--- a/Show More
+++ b/Show More