[bugfix]: bound WanCausalModel num_frames_per_block override to <= 3

The constructor override only checked >= 1, bypassing the <= 3 limit the config path enforces in CausalWanTransformer3DModel. Apply the same upper bound with a clear error message.
[bugfix]: refuse teacher forcing with a local attention window
2026-07-05 15:01:25 -07:00 · 2026-07-05 15:01:09 -07:00 · 2026-07-05 15:00:47 -07:00 · 2026-07-05 15:00:27 -07:00 · 2026-07-05 14:56:08 -07:00 · 2026-07-05 14:56:08 -07:00
295 changed files with 1149 additions and 35696 deletions
@@ -1,9 +1,9 @@
 {
  "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,
  "description": "Wan2.1 T2V 1.3B inference performance",
  "model": {
    "model_path": "Wan-AI/Wan2.1-T2V-1.3B-Diffusers",
@@ -436,7 +436,7 @@ steps:
                - "pyproject.toml"
                - "docker/Dockerfile"
              config:
-                command: "timeout 25m .buildkite/scripts/pr_test.sh"
+                command: "timeout 15m .buildkite/scripts/pr_test.sh"
                label: ":test_tube: LoRA Training Tests"
                env:
                  - TEST_TYPE=training_lora
@@ -481,7 +481,6 @@ steps:
                - "fastvideo/layers/**"
                - "fastvideo/worker/**"
                - "fastvideo/entrypoints/**"
-                - "fastvideo/performance/**"
                - "fastvideo/tests/performance/**"
                - ".buildkite/performance-benchmarks/**"
                - "pyproject.toml"
@@ -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..."
@@ -1,133 +0,0 @@
-#!/usr/bin/env bash
-# Gate the expensive Buildkite full suite on the cheap GitHub checks.
-#
-# Polls the workflow runs for the PR head commit and only exits 0 once the
-# watched cheap workflows (pre-commit, docs build) have succeeded, so the
-# 'ready' label cannot burn ~20 GPU lanes on a head that a cheap check has
-# already doomed.
-#
-# Semantics:
-#   - watched run completed with a bad conclusion  -> exit 1 (fail CLOSED:
-#     no full suite; the next push re-arms via the 'synchronize' trigger)
-#   - watched run cancelled                         -> still pending: the docs
-#     workflow's repo-global 'pages' concurrency group cancels runs superseded
-#     by unrelated pushes, so 'cancelled' is not a verdict on this PR
-#   - watched runs pending                          -> poll until done
-#   - docs run absent                               -> not applicable after a
-#     short grace period ('Deploy Documentation' is path-filtered on PRs)
-#   - pre-commit run absent                         -> keep polling: pre-commit
-#     is never path-filtered, so its absence is always anomalous
-#   - 'ready' label removed while waiting           -> exit 1 (fail CLOSED:
-#     un-labeling is a deliberate maintainer action)
-#   - GitHub API unreachable or timeout             -> exit 0 (fail OPEN,
-#     loud warning: never brick CI on a GitHub outage)
-#
-# Required env: PR_SHA (PR head commit), PR_NUMBER, GITHUB_REPOSITORY, GH_TOKEN.
-set -euo pipefail
-
-: "${PR_SHA:?PR_SHA (PR head commit) is required}"
-: "${PR_NUMBER:?PR_NUMBER (pull request number) is required}"
-: "${GITHUB_REPOSITORY:?GITHUB_REPOSITORY is required}"
-
-# Workflow-level `name:` values that must be green before the full suite
-# may start. "Deploy Documentation" is path-filtered on PRs, so its run may
-# legitimately never exist; pre-commit always runs, so it must appear.
-WATCHED_NAMES='["pre-commit", "Deploy Documentation"]'
-WATCHED_REGEX='^(pre-commit|Deploy Documentation)$'
-POLL_SECS="${POLL_SECS:-20}"
-GRACE_SECS="${GRACE_SECS:-60}"
-MAX_WAIT_SECS="${MAX_WAIT_SECS:-1500}"
-
-# Bound each API call so a hung connection hits the 3-strike fail-open path
-# instead of pinning the loop until the job timeout (which would fail closed
-# on exactly the GitHub-outage case this script is meant to survive).
-if command -v timeout >/dev/null 2>&1; then
-  gh_api() { timeout 30 gh api "$@"; }
-else
-  gh_api() { gh api "$@"; }  # macOS dev boxes; CI always has coreutils timeout
-fi
-
-# The workflow checked the label before starting the gate, but the wait can
-# last ~25 min: re-check once before any exit 0 and fail closed if 'ready'
-# was removed in the meantime. An API error here proceeds (the label was
-# present when the gate started; never brick CI on an outage).
-recheck_ready_label() {
-  local pr_json
-  if pr_json=$(gh_api "repos/${GITHUB_REPOSITORY}/pulls/${PR_NUMBER}" 2>/dev/null); then
-    if ! jq -e '[.labels[]?.name] | index("ready")' <<<"$pr_json" >/dev/null 2>&1; then
-      echo "::error::PR #${PR_NUMBER} no longer has the 'ready' label —" \
-        "NOT triggering the Buildkite full suite. Re-add the label to re-arm."
-      exit 1
-    fi
-  else
-    echo "::warning::Could not re-check the 'ready' label on PR #${PR_NUMBER}; proceeding (it was present when the gate started)."
-  fi
-}
-
-start=$(date +%s)
-api_fails=0
-missing=""
-
-while true; do
-  elapsed=$(( $(date +%s) - start ))
-
-  if runs_json=$(gh_api "repos/${GITHUB_REPOSITORY}/actions/runs?head_sha=${PR_SHA}&per_page=100" 2>/dev/null) \
-     && state=$(jq --arg re "$WATCHED_REGEX" '
-          [.workflow_runs[]? | select(.name // "" | test($re))]
-          | group_by(.name) | map(max_by(.id))
-          | map({name, status, conclusion})' <<<"$runs_json" 2>/dev/null); then
-    api_fails=0
-    echo "t+${elapsed}s watched checks: $(jq -c . <<<"$state")"
-
-    failed=$(jq -r '[.[] | select(.status == "completed"
-          and (.conclusion | IN("success", "skipped", "neutral", "cancelled") | not))]
-        | map(.name) | join(", ")' <<<"$state")
-    if [ -n "$failed" ]; then
-      echo "::error::Cheap check(s) failed on ${PR_SHA}: ${failed}." \
-        "NOT triggering the Buildkite full suite. Push a fix (the 'ready'" \
-        "label re-arms on every push), or re-run the failed check and then" \
-        "re-run this workflow."
-      exit 1
-    fi
-
-    # 'cancelled' counts as pending: wait for a re-run to reach a real verdict
-    # (bounded by MAX_WAIT, then the fail-open below).
-    pending=$(jq '[.[] | select(.status != "completed" or .conclusion == "cancelled")] | length' <<<"$state")
-    missing=$(jq -r --argjson watched "$WATCHED_NAMES" '($watched - map(.name)) | join(", ")' <<<"$state")
-    if [ "$pending" -eq 0 ]; then
-      if [ -z "$missing" ]; then
-        recheck_ready_label
-        echo "All watched cheap checks are green — full suite may proceed."
-        exit 0
-      fi
-      case "$missing" in
-        *pre-commit*)
-          echo "pre-commit run not found for ${PR_SHA} yet; waiting (pre-commit is never path-filtered, so its absence is anomalous)."
-          ;;
-        *)
-          if [ "$elapsed" -ge "$GRACE_SECS" ]; then
-            recheck_ready_label
-            echo "::warning::Watched run(s) never appeared for ${PR_SHA}: ${missing} (path-filtered, likely not applicable). Proceeding on the checks that did run."
-            exit 0
-          fi
-          echo "Waiting up to ${GRACE_SECS}s grace for path-filtered run(s) to appear: ${missing}."
-          ;;
-      esac
-    fi
-  else
-    api_fails=$(( api_fails + 1 ))
-    echo "::warning::GitHub API error querying workflow runs for ${PR_SHA} (attempt ${api_fails}/3)."
-    if [ "$api_fails" -ge 3 ]; then
-      recheck_ready_label
-      echo "::warning::FAILING OPEN: cannot query GitHub check status — triggering the full suite WITHOUT the cheap-check gate."
-      exit 0
-    fi
-  fi
-
-  if [ "$elapsed" -ge "$MAX_WAIT_SECS" ]; then
-    recheck_ready_label
-    echo "::warning::FAILING OPEN: watched checks still pending after $(( MAX_WAIT_SECS / 60 )) min${missing:+ (never appeared: ${missing})} — triggering the full suite anyway."
-    exit 0
-  fi
-  sleep "$POLL_SECS"
-done
@@ -1,122 +0,0 @@
-#!/usr/bin/env bash
-# Self-test for gate_full_suite.sh using a mocked `gh`. No network, runs on
-# any dev box: bash .github/scripts/test_gate_full_suite.sh
-set -u
-here=$(cd "$(dirname "$0")" && pwd)
-tmp=$(mktemp -d)
-trap 'rm -rf "$tmp"' EXIT
-
-# Mock gh. Asserts the exact endpoint (including head_sha) it is called
-# with — an endpoint typo in the gate script fails the test rather than
-# silently serving canned data. On the runs endpoint it serves
-# $MOCK_DIR/response_<call#>.json, sticking on the highest existing file,
-# and exits 1 if none exist (simulates a GitHub API outage). On the pulls
-# endpoint it serves $MOCK_DIR/pr.json, defaulting to a 'ready'-labeled PR.
-cat > "$tmp/gh" <<'EOF'
-#!/usr/bin/env bash
-if [ "${1:-}" != "api" ]; then
-  echo "unexpected gh invocation: $*" >> "$MOCK_DIR/endpoint_error"
-  exit 2
-fi
-case "${2:-}" in
-  "repos/o/r/actions/runs?head_sha=deadbeef&per_page=100")
-    n=$(( $(cat "$MOCK_DIR/count" 2>/dev/null || echo 0) + 1 ))
-    echo "$n" > "$MOCK_DIR/count"
-    while [ "$n" -gt 0 ]; do
-      if [ -f "$MOCK_DIR/response_$n.json" ]; then
-        cat "$MOCK_DIR/response_$n.json"
-        exit 0
-      fi
-      n=$(( n - 1 ))
-    done
-    echo "api outage" >&2
-    exit 1
-    ;;
-  "repos/o/r/pulls/42")
-    if [ -f "$MOCK_DIR/pr.json" ]; then
-      cat "$MOCK_DIR/pr.json"
-    else
-      echo '{"labels": [{"name": "ready"}]}'
-    fi
-    ;;
-  *)
-    echo "unexpected gh endpoint: $2" >> "$MOCK_DIR/endpoint_error"
-    exit 2
-    ;;
-esac
-EOF
-chmod +x "$tmp/gh"
-
-PC_OK='{"name": "pre-commit", "id": 1, "status": "completed", "conclusion": "success"}'
-PC_BAD='{"name": "pre-commit", "id": 1, "status": "completed", "conclusion": "failure"}'
-PC_PENDING='{"name": "pre-commit", "id": 1, "status": "in_progress", "conclusion": null}'
-DOCS_OK='{"name": "Deploy Documentation", "id": 2, "status": "completed", "conclusion": "success"}'
-DOCS_BAD='{"name": "Deploy Documentation", "id": 2, "status": "completed", "conclusion": "failure"}'
-DOCS_CANCELLED='{"name": "Deploy Documentation", "id": 2, "status": "completed", "conclusion": "cancelled"}'
-OTHER='{"name": "Trigger Full Suite", "id": 3, "status": "in_progress", "conclusion": null}'
-NULL_NAME='{"name": null, "id": 4, "status": "completed", "conclusion": "failure"}'
-PC_OK_RERUN='{"name": "pre-commit", "id": 5, "status": "completed", "conclusion": "success"}'
-
-fails=0
-want_log=""  # optional: expect() also greps out.log for this regex, then resets
-pr_json=""   # optional: served for the pulls (label re-check) endpoint, then resets
-raw_body=""  # optional: serve responses verbatim instead of wrapping in workflow_runs
-expect() { # <name> <expected-exit> <response json>...
-  local name=$1 want=$2 dir i=1
-  shift 2
-  dir=$(mktemp -d "$tmp/test_XXXXXX")
-  for body in "$@"; do
-    if [ -n "$raw_body" ]; then
-      printf '%s' "$body" > "$dir/response_$i.json"
-    else
-      printf '{"workflow_runs": [%s]}' "$body" > "$dir/response_$i.json"
-    fi
-    i=$(( i + 1 ))
-  done
-  [ -n "$pr_json" ] && printf '%s' "$pr_json" > "$dir/pr.json"
-  ( export PATH="$tmp:$PATH" MOCK_DIR="$dir" PR_SHA=deadbeef PR_NUMBER=42 \
-      GITHUB_REPOSITORY=o/r POLL_SECS=0 GRACE_SECS=1 MAX_WAIT_SECS=3
-    bash "$here/gate_full_suite.sh" > "$dir/out.log" 2>&1 )
-  local rc=$?
-  if [ "$rc" -ne "$want" ]; then
-    echo "FAIL: $name (exit $rc, want $want)"
-    cat "$dir/out.log"
-    fails=1
-  elif [ -f "$dir/endpoint_error" ]; then
-    echo "FAIL: $name (mock gh got an unexpected call)"
-    cat "$dir/endpoint_error"
-    fails=1
-  elif [ -n "$want_log" ] && ! grep -Eq "$want_log" "$dir/out.log"; then
-    echo "FAIL: $name (log does not match: $want_log)"
-    cat "$dir/out.log"
-    fails=1
-  else
-    echo "ok: $name"
-  fi
-  want_log="" pr_json="" raw_body=""
-}
-
-expect "both green -> proceed" 0 "$PC_OK, $DOCS_OK, $OTHER, $NULL_NAME"
-expect "docs build failed -> blocked" 1 "$PC_OK, $DOCS_BAD"
-expect "pre-commit failed -> blocked" 1 "$PC_BAD"
-expect "pending then green -> proceed" 0 "$PC_PENDING" "$PC_OK, $DOCS_OK"
-want_log="never appeared.*Deploy Documentation"
-expect "docs run absent (path-filtered) -> proceed after grace" 0 "$PC_OK"
-expect "API outage -> fail open" 0
-want_log="FAILING OPEN"
-expect "pending past MAX_WAIT -> fail open" 0 "$PC_PENDING"
-want_log="FAILING OPEN"
-expect "unrelated runs only -> no grace, fail open at MAX_WAIT" 0 "$OTHER"
-expect "cancelled docs then green -> proceed" 0 \
-  "$PC_OK, $DOCS_CANCELLED" "$PC_OK, $DOCS_OK"
-want_log="FAILING OPEN"
-expect "cancelled docs forever -> fail open at MAX_WAIT" 0 "$PC_OK, $DOCS_CANCELLED"
-want_log="FAILING OPEN"
-expect "pre-commit absent -> no grace, fail open at MAX_WAIT" 0 "$DOCS_OK"
-expect "duplicate run names -> latest wins" 0 "$PC_BAD, $PC_OK_RERUN, $DOCS_OK"
-raw_body=1
-expect "garbage response body -> fail open" 0 "this is not json"
-pr_json='{"labels": [{"name": "other"}]}'
-expect "ready label removed mid-gate -> blocked" 1 "$PC_OK, $DOCS_OK"
-
-exit "$fails"
@@ -47,6 +47,3 @@ jobs:
    - uses: pre-commit/action@v3.0.1
      with:
        extra_args: --all-files --hook-stage manual
-    # After pre-commit so a self-test failure cannot mask lint failures.
-    - name: Full-suite gate self-test
-      run: bash .github/scripts/test_gate_full_suite.sh
@@ -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
+                }
+              }')"
@@ -7,7 +7,6 @@ on:
 permissions:
  contents: read
  pull-requests: read
-  actions: read

 concurrency:
  group: full-suite-${{ github.event.pull_request.number }}
@@ -19,8 +18,6 @@ jobs:
      (github.event.action == 'labeled' && github.event.label.name == 'ready')
      || github.event.action == 'synchronize'
    runs-on: ubuntu-latest
-    # Gate below may wait for cheap checks (up to MAX_WAIT_SECS = 25 min).
-    timeout-minutes: 35
    steps:
      - name: Check ready label
        id: check
@@ -52,20 +49,6 @@ jobs:
              "https://api.buildkite.com/v2/organizations/${{ vars.BUILDKITE_ORG_SLUG }}/pipelines/${{ vars.BUILDKITE_PIPELINE_SLUG }}/builds/${build_num}/cancel"
          done

-      # Checks out the BASE branch (default for pull_request_target), so PR
-      # authors cannot tamper with the gate script.
-      - name: Checkout gate script
-        if: steps.check.outputs.has_ready == 'true'
-        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
-
-      - name: Wait for pre-commit and docs build
-        if: steps.check.outputs.has_ready == 'true'
-        env:
-          GH_TOKEN: ${{ github.token }}
-          PR_SHA: ${{ github.event.pull_request.head.sha }}
-          PR_NUMBER: ${{ github.event.pull_request.number }}
-        run: bash .github/scripts/gate_full_suite.sh
-
      - name: Trigger Buildkite Full Suite
        if: steps.check.outputs.has_ready == 'true'
        env:
@@ -73,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: |
@@ -85,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,
@@ -97,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)
                }
              }')"
@@ -37,11 +37,6 @@ logs/
 official_weights/
 converted_weights/

-# Cosmos3 local parity assets (symlinked from main worktree)
-/official_weights/
-/converted_weights/
-/cosmos-framework
-
 # SSIM test outputs
 fastvideo/tests/ssim/generated_videos/
 **/.cache/**
@@ -77,7 +72,8 @@ docs/distillation/examples/
 # Python pickle files
 *.pkl

-# Reference videos (negations must come after the catch-all on line below)
+# Reference videos
+!fastvideo/tests/ssim/reference_videos/**/*.mp4

 # Static images
 !docs/assets/images/**/*.png
@@ -131,8 +127,6 @@ apps/dreamverse/web/.env.production.local
 .sisyphus/
 openspec/
 fastvideo/tests/ssim/reference_videos/**
-!fastvideo/tests/ssim/reference_videos/**/*.mp4
-!fastvideo/tests/ssim/reference_videos/**/*.png

 # Editor logs and local Python version pins (accidentally committed)
 *.nvimlog
@@ -1,7 +1,6 @@
 import { useEffect, useMemo, useState } from "react";

-import { fetchSummary, fetchTrends, refreshData } from "./api";
-import type { CohortValue, RunSource, SummaryResponse, TrendGroup, TrendPoint } from "./api";
+import { fetchSummary, fetchTrends, refreshData, RunSource, SummaryResponse, TrendGroup, TrendPoint } from "./api";

 const METRIC_KEYS = ["latency", "throughput", "memory", "text_encoder_time_s", "dit_time_s", "vae_decode_time_s"];
 const RUN_SOURCES: Array<{ value: "" | RunSource; label: string }> = [
@@ -110,61 +109,6 @@ function metricLabel(metricKey: string) {
  return METRIC_DEFINITIONS[metricKey]?.label ?? metricKey;
 }

-type CohortFields = {
-  model_id: string;
-  gpu_type: string;
-  workload_id: CohortValue;
-  variant_id: CohortValue;
-  benchmark_version: CohortValue;
-  recipe_fingerprint: CohortValue;
-  hardware_profile_id: CohortValue;
-  software_profile_id: CohortValue;
-};
-
-function cohortValue(value: CohortValue) {
-  if (value === null || value === undefined || value === "") {
-    return "legacy";
-  }
-  return String(value);
-}
-
-function shortCohortValue(value: CohortValue) {
-  const text = cohortValue(value);
-  if (text === "legacy" || text.length <= 14) {
-    return text;
-  }
-  return text.slice(0, 12);
-}
-
-function cohortKey(cohort: CohortFields) {
-  return [
-    cohort.model_id,
-    cohort.gpu_type,
-    cohortValue(cohort.workload_id),
-    cohortValue(cohort.variant_id),
-    cohortValue(cohort.benchmark_version),
-    cohortValue(cohort.recipe_fingerprint),
-    cohortValue(cohort.hardware_profile_id),
-    cohortValue(cohort.software_profile_id)
-  ].join("|");
-}
-
-function cohortTitle(cohort: CohortFields) {
-  const workload = cohortValue(cohort.workload_id);
-  const variant = cohortValue(cohort.variant_id);
-  const version = cohortValue(cohort.benchmark_version);
-  const versionLabel = version === "legacy" ? version : `v${version}`;
-  return `${workload} / ${variant} / ${versionLabel}`;
-}
-
-function cohortDetail(cohort: CohortFields) {
-  return [
-    `recipe ${shortCohortValue(cohort.recipe_fingerprint)}`,
-    shortCohortValue(cohort.hardware_profile_id),
-    shortCohortValue(cohort.software_profile_id)
-  ].join(" | ");
-}
-
 function formatMetricValue(metricKey: string, value: number | null | undefined, tooltip = false) {
  const definition = METRIC_DEFINITIONS[metricKey];
  if (!definition) {
@@ -227,9 +171,7 @@ function TrendChart({ group, metricKey }: { group: TrendGroup; metricKey: string
        top: `${(activePoint.y / height) * 100}%`
      }
    : undefined;
-  const ariaLabel = `${metricLabel(metricKey)} trend for ${group.model_id} on ${group.gpu_type}, ${cohortTitle(
-    group
-  )}`;
+  const ariaLabel = `${metricLabel(metricKey)} trend for ${group.model_id} on ${group.gpu_type}`;

  return (
    <div className="chart-shell">
@@ -477,7 +419,7 @@ export default function App() {
      <section className="panel">
        <div className="panel-header">
          <h2>Latest Status</h2>
-          <span>{latestRows.length} comparison cohorts</span>
+          <span>{latestRows.length} model/GPU groups</span>
        </div>
        {latestRows.length === 0 ? (
          <div className="empty">No records match the selected filters.</div>
@@ -490,7 +432,6 @@ export default function App() {
                  <th>Recomputed</th>
                  <th>Model</th>
                  <th>GPU</th>
-                  <th>Cohort</th>
                  <th>Commit</th>
                  <th>Source</th>
                  <th>Baseline</th>
@@ -505,7 +446,7 @@ export default function App() {
              </thead>
              <tbody>
                {latestRows.map((row) => (
-                  <tr key={cohortKey(row)}>
+                  <tr key={`${row.model_id}-${row.gpu_type}`}>
                    <td>
                      <span className={`badge ${row.status}`}>{row.status}</span>
                    </td>
@@ -516,12 +457,6 @@ export default function App() {
                    </td>
                    <td>{row.model_id}</td>
                    <td>{row.gpu_type}</td>
-                    <td>
-                      <div className="cohort-cell">
-                        <strong>{cohortTitle(row)}</strong>
-                        <span>{cohortDetail(row)}</span>
-                      </div>
-                    </td>
                    <td>{shortSha(row.commit_sha)}</td>
                    <td>
                      <span className={`source-badge source-${row.run_source}`}>{runSourceLabel(row.run_source)}</span>
@@ -560,13 +495,11 @@ export default function App() {
          ) : (
            trends.map((group) =>
              METRIC_KEYS.map((metricKey) => (
-                <article className="trend-card" key={`${cohortKey(group)}-${metricKey}`}>
+                <article className="trend-card" key={`${group.model_id}-${group.gpu_type}-${metricKey}`}>
                  <div>
                    <h3>{metricLabel(metricKey)}</h3>
                    <p>
                      {group.model_id} | {group.gpu_type}
-                      <span>{cohortTitle(group)}</span>
-                      <span>{cohortDetail(group)}</span>
                    </p>
                  </div>
                  <TrendChart group={group} metricKey={metricKey} />
@@ -13,17 +13,6 @@ export type MetricValue = {
  precision: number;
 };

-export type CohortValue = string | number | null;
-
-export type ComparisonCohort = {
-  workload_id: CohortValue;
-  variant_id: CohortValue;
-  benchmark_version: CohortValue;
-  recipe_fingerprint: CohortValue;
-  hardware_profile_id: CohortValue;
-  software_profile_id: CohortValue;
-};
-
 export type SummaryRow = {
  model_id: string;
  gpu_type: string;
@@ -45,7 +34,7 @@ export type SummaryRow = {
  build_id: string;
  job_id: string;
  metrics: Record<string, MetricValue>;
-} & ComparisonCohort;
+};

 export type RunSource = "pr" | "local" | "scheduled_main" | "unknown";

@@ -79,13 +68,13 @@ export type TrendPoint = {
  build_id: string;
  job_id: string;
  metrics: Record<string, number | null>;
-} & ComparisonCohort;
+};

 export type TrendGroup = {
  model_id: string;
  gpu_type: string;
  points: TrendPoint[];
-} & ComparisonCohort;
+};

 export type TrendsResponse = {
  groups: TrendGroup[];
@@ -149,11 +149,6 @@ h3 {
  font-size: 0.82rem;
 }

-.trend-card p {
-  display: grid;
-  gap: 2px;
-}
-
 .stat strong {
  display: block;
  margin-top: 8px;
@@ -191,7 +186,7 @@ h3 {

 table {
  width: 100%;
-  min-width: 1260px;
+  min-width: 1120px;
  border-collapse: collapse;
 }

@@ -214,25 +209,6 @@ td {
  font-size: 0.9rem;
 }

-.cohort-cell {
-  display: grid;
-  gap: 2px;
-}
-
-.cohort-cell strong,
-.trend-card p span {
-  color: #1b2836;
-  font-size: 0.78rem;
-  font-weight: 700;
-}
-
-.cohort-cell span,
-.trend-card p span + span {
-  color: #607080;
-  font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", monospace;
-  font-size: 0.72rem;
-}
-
 .badge {
  display: inline-flex;
  align-items: center;
@@ -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
-}
@@ -68,7 +68,7 @@ ARG FLASH_ATTN_WHEEL_RELEASE_ARM64=https://github.com/mjun0812/flash-attention-p
 # cutlass-4.4 `cute.core.ThrMma` API, which crashes on the cutlass-dsl 4.5 that
 # flashinfer/quack pull in. After the wheel install we overlay this cutlass-4.5-safe
 # upstream cute (flash-attn-4) so the image runs FA4 instead of the FA2 fallback.
-ARG FA4_CUTE_REF=82d6441eec5d4dfec120153db2c0145ae855a083
+ARG FA4_CUTE_REF=940cd9680f3315f2f06b43ab5bea2c2cf2d96806

 # Provided automatically by BuildKit/buildx (e.g. "amd64" / "arm64") and used to
 # select the prebuilt flash-attn wheel. Empty under a plain `docker build` without
@@ -161,7 +161,7 @@ RUN --mount=type=cache,target=/opt/uv/cache \
        uv pip install flash-attn==${FLASH_ATTN_VERSION} --no-build-isolation; \
    fi

-# Overlay the CuTe-DSL-4.6-compatible upstream FA4 cute (FA4_CUTE_REF) over the
+# Overlay the cutlass-4.5-safe upstream FA4 cute (FA4_CUTE_REF) over the
 # wheel/source one so the image runs FA4, not the FA2 fallback. This pulls the FA4
 # runtime stack (cutlass-dsl, quack-kernels, apache-tvm-ffi, torch-c-dlpack-ext) --
 # the same deps the [dreamverse] extra already installs in CI; the installed torch
@@ -99,13 +99,6 @@ status.
 Full Suite is also path-filtered. It validates broader behavior before Mergify
 can merge a PR.

-A `ready`-labeled PR does not hit Buildkite immediately:
-`ci-trigger-full-suite.yml` first runs `.github/scripts/gate_full_suite.sh`,
-which waits for the cheap Tier-1 checks (pre-commit, docs build) on the PR
-head. A red cheap check blocks the suite (fail closed; the next push re-arms
-it), while a GitHub outage or a >25 min wait lets it run anyway (fail open).
-`/test full` bypasses the gate.
-
 | Buildkite label | `TEST_TYPE` | Main watched paths |
 |---|---|---|
 | SSIM Tests | `ssim` | `fastvideo/**/*.py`, `pyproject.toml`, `docker/Dockerfile` |
@@ -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:

@@ -205,9 +201,9 @@ configs and remain loadable. New or migrated configs should use
 {
  "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
 }
 ```

@@ -218,27 +214,21 @@ metadata that make the measured workload explicit:

 | Field | Purpose |
 |---|---|
-| `workload_id` | Stable benchmark family, such as `wan-t2v`. |
-| `variant_id` | Intentional recipe family, including model size and parallelism config, such as `1.3b-sp2`. |
+| `workload_id` | Stable benchmark family, such as `wan-t2v-1.3b`. |
+| `variant_id` | Intentional recipe family, such as `canonical`. |
 | `benchmark_version` | Version of the measurement protocol and comparison policy. |

 If a config declares `config_schema_version: 2`, loading fails clearly when any
 required v2 identity field is missing. If v2 identity or metadata fields are
 added without `config_schema_version: 2`, loading also fails so partial
 migrations do not silently run as v1 configs. Optional v2 metadata fields
-reserved for follow-up work, such as `metric_threshold_policy` and
-`quality_metadata`, must be JSON objects when present. (`recipe` is emitted
-by the harness and is not config-declarable.)
+reserved for follow-up work, such as `recipe`, `metric_threshold_policy`, and
+`quality_metadata`, must be JSON objects when present.

 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
-threshold policies and promoted baselines remain separate follow-ups.
+comparison, metric-specific threshold policy behavior, promoted baselines, and
+dashboard regrouping are separate follow-up changes. Until those land, rolling
+baseline comparison remains keyed by `(model_id, gpu_type)`.

 ### Raw record (`results/perf_*.json`)

@@ -247,10 +237,10 @@ Written by `test_inference_performance.py`. One file per benchmark run.
 ```jsonc
 {
  "benchmark_id": "wan-t2v-1.3b-2gpu",
-  "result_schema_version": 2,
-  "workload_id": "wan-t2v",
-  "variant_id": "1.3b-sp2",
-  "benchmark_version": 2,
+  "config_schema_version": 2,
+  "workload_id": "wan-t2v-1.3b",
+  "variant_id": "canonical",
+  "benchmark_version": 1,
  "model_short_name": "Wan2.1-T2V-1.3B-Diffusers",
  "device": "NVIDIA L40S",
  "num_gpus": 2,
@@ -276,54 +266,11 @@ 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,
-  "recipe": {
-    "recipe_schema_version": 1,
-    "benchmark": {
-      "benchmark_id": "wan-t2v-1.3b-2gpu",
-      "workload_id": "wan-t2v",
-      "variant_id": "1.3b-sp2",
-      "benchmark_version": 2
-    },
-    "model": { "model_path": "Wan-AI/Wan2.1-T2V-1.3B-Diffusers" },
-    "init_kwargs": { "num_gpus": 2, "sp_size": 2, "tp_size": 1 },
-    "generation_kwargs": { "height": 480, "width": 832, "num_frames": 45 },
-    "inputs": { "prompt_count": 1, "prompt_sha256": ["<measured-prompt-sha256>"] },
-    "attention": { "requested_backend": "FLASH_ATTN", "resolved_backend": "FLASH_ATTN" }
-  },
-  "recipe_fingerprint": "<sha256>",
-  "hardware_profile": {
-    "device_type": "cuda",
-    "gpu_count": 2,
-    "gpus": [{ "name": "NVIDIA L40S", "memory_gb": 48, "compute_capability": "8.9" }],
-    "interconnect": "none_or_partial"
-  },
-  "hardware_profile_id": "hw-<sha256-prefix>",
-  "software_profile": {
-    "python": "3.12",
-    "pytorch": "2.12",
-    "cuda": "13.0",
-    "packages": {
-      "fastvideo_kernel": "0.3.2",
-      "flashinfer": "0.2.11",
-      "nvidia_cutlass_dsl": "4.5.0",
-      "triton": "3.4.1"
-    }
-  },
-  "software_profile_id": "sw-<sha256-prefix>",
-  "environment_metadata": { "env": { "IMAGE_VERSION": "py3.12-cuda13.0.0" } },
-  "environment_fingerprint": "env-<sha256-prefix>"
+  "vae_decode_time_s": 3.208
 }
 ```

@@ -335,10 +282,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,
  "timestamp": "2026-05-08T22:00:00+00:00",
  "commit_sha": "<full sha>",
  "gpu_type": "NVIDIA L40S",
@@ -355,46 +298,17 @@ result, used as the rolling-baseline source of truth.
      "gated": true
    }
  },
-  "recipe_fingerprint": "<sha256>",
-  "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.
-
-New records compare only against the same `model_id`, `gpu_type`,
-`workload_id`, `variant_id`, `benchmark_version`, `recipe_fingerprint`,
-`hardware_profile_id`, and `software_profile_id` cohort.
-`environment_metadata` and `environment_fingerprint` are audit data and are not
-part of the comparison key.
-The recipe prompt digests describe the prompts actually measured by the
-benchmark run; extra configured prompts are ignored unless the benchmark runner
-executes them.
-Software profile package cohorts keep exact versions for relevant
-attention/kernel packages, including FastVideo kernels, FlashAttention,
-FlashInfer, Cutlass DSL, SageAttention, Triton, and xFormers when installed.
+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.

 ## Environment variable reference

@@ -404,7 +318,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 +335,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 +347,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)
@@ -453,7 +364,7 @@ When the rolling-baseline phase runs, it emits:
     "benchmark_id": "<unique-id>",
     "config_schema_version": 2,
     "workload_id": "<stable-workload-id>",
-     "variant_id": "<variant, e.g. 1.3b-sp2>",
+     "variant_id": "canonical",
     "benchmark_version": 1,
     "model": { "model_path": "...", "model_short_name": "..." },
     "init_kwargs": { "num_gpus": 1, ... },
@@ -480,9 +391,7 @@ When the rolling-baseline phase runs, it emits:

   Legacy v1 configs without `config_schema_version` still load, but should not
   gain v2 identity or metadata fields until they are migrated to
-   `config_schema_version: 2`. For v2 configs, `workload_id`, `variant_id`,
-   and `benchmark_version` are part of the comparison key; benchmark runs
-   fail if any of these identity fields are missing.
+   `config_schema_version: 2`.

 2. The pytest test auto-discovers all configs — no test code needed. CI
   picks it up on the next `/test performance` run.
@@ -510,8 +419,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
@@ -191,9 +191,6 @@ surfaces:
        sources:
          - fastvideo.configs.pipelines.gen3c.Gen3CConfig
          - fastvideo.configs.pipelines.gen3c.Gen3CInferenceConfig
-      color_correction_strength:
-        sources:
-          - fastvideo.configs.pipelines.dreamx_world.DreamXWorld5BARPipelineConfig
      default_camera_rotation:
        sources:
          - fastvideo.configs.pipelines.gen3c.Gen3CConfig
@@ -458,8 +455,6 @@ surfaces:
      guidance_scale: request.sampling.guidance_scale
      guidance_scale_2: request.sampling.guidance_scale_2
      guidance_rescale: request.sampling.guidance_rescale
-      use_embedded_guidance: request.sampling.use_embedded_guidance
-      true_cfg_scale: request.sampling.true_cfg_scale
      boundary_ratio: request.sampling.boundary_ratio
      sigmas: request.sampling.sigmas
      enable_teacache: request.runtime.enable_teacache
@@ -1,116 +0,0 @@
-# 🌊 AnyFlow Any-Step Video Distillation
-
-**AnyFlow** ([paper](https://arxiv.org/abs/2605.13724), [project page](https://nvlabs.github.io/AnyFlow/), [official code](https://github.com/NVlabs/AnyFlow), [model weights](https://huggingface.co/collections/nvidia/anyflow)) is an any-step video diffusion framework built on flow maps. A single distilled checkpoint can be evaluated at NFE ∈ {1, 2, 4, 8, 16, 32} without retraining, and quality scales **monotonically** with steps — unlike consistency-based distillation, which often degrades as NFE grows.
-
-The student network ``u_θ(x_t, t, r)`` predicts the *average velocity* from time ``t`` back to time ``r``, so one Euler step is
-
-```
-x_r = x_t - ((t - r) / N) · u_θ(x_t, t, r)
-```
-
-for any ``t > r``.
-
-## 📊 Model Overview
-
-NVIDIA publishes four checkpoints under [`nvidia/anyflow`](https://huggingface.co/collections/nvidia/anyflow):
-
- `nvidia/AnyFlow-Wan2.1-T2V-1.3B-Diffusers` — bidirectional T2V, Wan2.1 1.3B base
- `nvidia/AnyFlow-Wan2.1-T2V-14B-Diffusers` — bidirectional T2V, Wan2.1 14B base
- `nvidia/AnyFlow-FAR-Wan2.1-1.3B-Diffusers` — frame-autoregressive variant, 1.3B
- `nvidia/AnyFlow-FAR-Wan2.1-14B-Diffusers` — frame-autoregressive variant, 14B
-
-FastVideo currently supports the bidirectional T2V variants for training; the FAR variants can be loaded for inference through the diffusers integration.
-
-## ⚙️ Inference
-
-For inference, load the published checkpoint directly through diffusers; FastVideo's training-side ``WanModel`` config maps the HF AnyFlow ``delta_embedder`` weights onto its internal layout via ``param_names_mapping`` so the same checkpoint can be used as the ``init_from`` for the on-policy YAML below.
-
-## 🧠 Algorithm
-
-Training runs in two stages. Both use the dual-timestep Wan backbone — enabled by ``pipeline.dit_config.r_embedder: true`` in the YAML, which allocates a sibling ``condition_embedder.delta_embedder`` and fuses its embedding with the standard timestep embedding via either an additive or a gated mixer.
-
-### Stage 1 — Pretrain (flow-map central-difference)
-
-Method: ``AnyFlowPretrainMethod`` (``fastvideo/train/methods/distribution_matching/anyflow_pretrain.py``)
-
-For each batch, sample ``(t, r) ∈ [0, 1]`` as ``(max, min)`` of two uniform draws, then:
-
- a ``diffusion_ratio`` fraction (default 0.5) gets ``r = t`` — recovers plain flow matching;
- a ``consistency_ratio`` fraction (default 0.25) gets ``r = 0`` — forces consistency to clean data;
- the remainder is free.
-
-The student forward at ``(t, r)`` is trained against the central-difference target
-
-```
-target = (eps - x_0) - (t - r) · dF/dt
-```
-
-where ``dF/dt`` is estimated from the student's own forward at ``(t ± δ, r)`` with the sample also moved along the flow trajectory by ``v_pred · (δ / N)``. Per-timestep weighting uses ``beta08`` (``w(t) = t · sqrt(1 - t)``, renormalized). A stop-gradient scale-balance keeps the non-diffusion branches' loss magnitude aligned with the diffusion branch.
-
-### Stage 2 — On-policy DMD
-
-Method: ``AnyFlowMethod`` (``fastvideo/train/methods/distribution_matching/anyflow.py``)
-
-Inherits ``DMD2Method``. The student is rolled out for ``student_sample_steps`` Euler-flow steps from pure noise; one randomly-chosen step is gradient-enabled (broadcast from rank 0 so every worker agrees), the rest run under ``torch.no_grad``. With ``use_mean_velocity: true`` (default) the rollout uses ``r = t_next`` at each step, matching AnyFlow's ``WanAnyFlowPipeline.training_rollout``.
-
-The inherited ``_dmd_loss`` (VSD with fake-score critic) consumes the rollout output and the teacher's CFG prediction. The optional pinned ``t_list_override`` lets configs reproduce the paper's hand-tuned 4-step schedule ``[999, 937, 833, 624, 0]``.
-
-## 🚀 Training Scripts
-
-### Stage 1 — pretrain
-
-```bash
-bash examples/train/run.sh \
-    examples/train/configs/distribution_matching/wan/anyflow_pretrain_t2v.yaml
-```
-
-**Key configuration** (in ``examples/train/configs/distribution_matching/wan/anyflow_pretrain_t2v.yaml``):
-
- Global batch size: 32 (8 GPUs × 4 per-GPU)
- Learning rate: 5e-5
- Flow shift: 5.0
- ``diffusion_ratio`` / ``consistency_ratio``: 0.5 / 0.25
- ``epsilon`` (finite-difference step): 5 (absolute train-timestep units)
- ``weight_type``: ``beta08``
- ``fuse_guidance_scale``: 3.0
- Training steps: 6000
-
-### Stage 2 — on-policy
-
-```bash
-bash examples/train/run.sh \
-    examples/train/configs/distribution_matching/wan/anyflow_onpolicy_t2v.yaml \
-    --models.student.init_from outputs/wan2.1_anyflow_pretrain/checkpoint-final
-```
-
-(Or point ``models.student.init_from`` directly at ``nvidia/AnyFlow-Wan2.1-T2V-1.3B-Diffusers`` to bootstrap from the paper weights and skip Stage 1.)
-
-**Key configuration**:
-
- Global batch size: 8 (8 GPUs × 1 per-GPU)
- Learning rate: 2e-6
- Flow shift: 5.0
- ``student_sample_steps``: 4
- ``t_list_override``: ``[999, 937, 833, 624, 0]``
- ``use_mean_velocity``: ``true`` (i.e. ``r = t_next`` during rollout)
- ``real_score_guidance_scale``: 3.0
- ``generator_update_interval``: 5 (DMD2 alternation)
- Training steps: 4000
-
-## 🔌 Loading published AnyFlow checkpoints
-
-The HF AnyFlow checkpoints expose ``condition_embedder.delta_embedder.*`` weights that FastVideo internally maps onto its ``condition_embedder.delta_embedder.mlp.*`` layout. This rename happens automatically through the regex in ``WanVideoArchConfig.param_names_mapping`` — no separate adapter is needed. The same regex is a no-op on plain Wan checkpoints (which don't contain any ``delta_embedder`` keys).
-
-Set the YAML's ``pipeline.dit_config.r_embedder: true`` to allocate the ``delta_embedder`` module on the FastVideo side; when initializing from a plain Wan checkpoint the delta weights are deep-copied from ``time_embedder`` (matching AnyFlow's ``setup_flowmap_model()`` behavior).
-
-## 🧭 Note on ``fuse_guidance_scale``
-
-Stage 1 optionally fuses classifier-free guidance into the training target so the resulting checkpoint can be sampled at ``guidance_scale=1.0`` (no extra forward pass at inference time). The transformation is
-
-```
-noise_pred ← (noise_pred - (1 - g) · noise_pred_uncond) / g
-```
-
-with ``g = fuse_guidance_scale``. The negative prompt embedding comes from ``WanModel``'s ``ensure_negative_conditioning()`` — i.e. the dataset's configured ``sampling_param.negative_prompt``. Setting ``fuse_guidance_scale: 1.0`` skips the extra unconditional forward entirely.
-
-The on-policy stage's ``real_score_guidance_scale`` (inherited from DMD2) follows the same parameterization conventions documented in [``dmd.md``](dmd.md#-note-on-real_score_guidance_scale).
@@ -58,8 +58,6 @@ pipeline initialization and sampling.
 | FastWan2.1 T2V 1.3B | `FastVideo/FastWan2.1-T2V-1.3B-Diffusers` | 480P | ⭕ | ⭕ | ⭕ | ✅ | ⭕ |
 | FastWan2.2 TI2V 5B Full Attn* | `FastVideo/FastWan2.2-TI2V-5B-FullAttn-Diffusers` | 720P | ⭕ | ⭕ | ⭕ | ✅ | ⭕ |
 | Wan2.2 TI2V 5B | `Wan-AI/Wan2.2-TI2V-5B-Diffusers` | 720P | ⭕ | ⭕ | ✅ | ⭕ | ⭕ |
-| DreamX-World 5B Cam | `FastVideo/DreamX-World-5B-Cam-Diffusers` | 480P | ⭕ | ⭕ | ⭕ | ⭕ | ⭕ |
-| DreamX-World 5B AR | `FastVideo/DreamX-World-5B-Diffusers` | 704px1280p | ⭕ | ⭕ | ⭕ | ⭕ | ⭕ |
 | Lucy Edit Dev 5B*** | `decart-ai/Lucy-Edit-Dev` | 480P | ⭕ | ⭕ | ⭕ | ⭕ | ⭕ |
 | Wan2.2 T2V A14B | `Wan-AI/Wan2.2-T2V-A14B-Diffusers` | 480P<br>720P | ❌ | ❌ | ✅ | ⭕ | ⭕ |
 | Wan2.2 I2V A14B | `Wan-AI/Wan2.2-I2V-A14B-Diffusers` | 480P<br>720P | ❌ | ❌ | ✅ | ⭕ | ⭕ |
@@ -1,91 +0,0 @@
-# Training Trackers
-
-FastVideo can send training metrics and validation media to Weights & Biases
-or SwanLab. Tracking runs only on global rank 0, and local tracker files are
-stored under `<output_dir>/tracker`.
-
-## Supported Trackers
-
-| Value | Backend | Installation |
-|-------|---------|--------------|
-| `wandb` | Weights & Biases | Included with FastVideo |
-| `swanlab` | SwanLab | Install the optional `swanlab` dependency |
-| `none` | Disable external tracking | No additional package |
-
-You can enable more than one backend, for example `trackers: [wandb, swanlab]`.
-Metrics and validation media are converted to the artifact type required by
-each backend.
-
-## Install SwanLab
-
-For a published FastVideo installation, install the SwanLab extra:
-
-```bash
-uv pip install "fastvideo[swanlab]"
-```
-
-For an editable source checkout, include the same extra during installation:
-
-```bash
-uv pip install -e ".[swanlab]"
-```
-
-If FastVideo is already installed, you can install the compatible SDK directly:
-
-```bash
-uv pip install "swanlab>=0.6.7"
-```
-
-Authenticate once before starting a training run:
-
-```bash
-swanlab login
-```
-
-See the [SwanLab login documentation](https://docs.swanlab.cn/en/api/cli-swanlab-login.html)
-for non-interactive and self-hosted setups.
-
-## Configure Tracking
-
-Select SwanLab in the YAML config used by the modular training framework:
-
-```yaml
-training:
-  checkpoint:
-    output_dir: outputs/my_run
-  tracker:
-    trackers: [swanlab]
-    project_name: my_project
-    run_name: my_run
-```
-
-To log to both supported services:
-
-```yaml
-training:
-  tracker:
-    trackers: [wandb, swanlab]
-    project_name: my_project
-    run_name: my_run
-```
-
-An empty or omitted `trackers` list selects W&B when `project_name` is set.
-Use an explicit `none` entry to disable external tracking:
-
-```yaml
-training:
-  tracker:
-    trackers: [none]
-```
-
-## Validation Videos
-
-SwanLab currently accepts GIF video artifacts. FastVideo converts validation
-MP4 files and in-memory video arrays to GIF automatically before logging them.
-For video files, FastVideo uses the sampling frame rate supplied by the caller,
-or the source file's frame rate when no value is supplied. In-memory arrays use
-the frame rate supplied by the caller. Both forms fall back to 16 FPS when no
-frame rate is available.
-
-For details about configuring validation callbacks, see
-[Training Infrastructure](train_infra.md#callbacks-pluggable-hooks).
@@ -161,21 +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.
-
 ### `callbacks` — Pluggable hooks

 Callbacks run at specific points in the training loop (before/after optimizer
@@ -338,40 +323,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,81 +0,0 @@
-import os
-import time
-
-from fastvideo import VideoGenerator
-from fastvideo.api import (
-    EngineConfig,
-    GenerationRequest,
-    GeneratorConfig,
-    InputConfig,
-    OffloadConfig,
-    OutputConfig,
-    SamplingConfig,
-)
-
-# NVIDIA Cosmos3-Nano omni world model — image-to-video (I2V) path through
-# FastVideo's native Cosmos3 pipeline. The input image conditions latent frame 0
-# (kept clean during denoising); the rest of the clip is generated to follow it.
-# Point COSMOS3_MODEL_PATH at a local diffusers checkpoint (e.g.
-# ``official_weights/cosmos3``) to skip the Hugging Face download.
-OUTPUT_PATH = "video_samples_cosmos3_i2v"
-
-
-def main():
-    model_name = os.environ.get("COSMOS3_MODEL_PATH", "nvidia/Cosmos3-Nano")
-    image_path = os.environ.get("COSMOS3_IMAGE_PATH", "assets/images/cyclist.jpg")
-
-    generator_config = GeneratorConfig(
-        model_path=model_name,
-        engine=EngineConfig(
-            num_gpus=1,
-            use_fsdp_inference=False,
-            offload=OffloadConfig(
-                text_encoder=True,
-                pin_cpu_memory=True,
-                dit=False,
-                vae=False,
-            ),
-        ),
-    )
-
-    load_start_time = time.perf_counter()
-    generator = VideoGenerator.from_config(generator_config)
-    load_time = time.perf_counter() - load_start_time
-
-    prompt = (
-        "A mountain biker rides forward along the sunlit forest trail, wheels "
-        "kicking up dust as trees and dappled light sweep past, smooth cinematic "
-        "tracking shot from behind."
-    )
-    request = GenerationRequest(
-        prompt=prompt,
-        inputs=InputConfig(image_path=image_path),
-        sampling=SamplingConfig(
-            # cosmos3_nano native defaults are 704x1280, 189 frames, 35 steps;
-            # overridable via env for quick smoke runs.
-            num_frames=int(os.environ.get("COSMOS3_NUM_FRAMES", "189")),
-            height=int(os.environ.get("COSMOS3_HEIGHT", "704")),
-            width=int(os.environ.get("COSMOS3_WIDTH", "1280")),
-            num_inference_steps=int(os.environ.get("COSMOS3_STEPS", "35")),
-            guidance_scale=6.0,
-            fps=24,
-            seed=1024,
-        ),
-        output=OutputConfig(
-            output_path=OUTPUT_PATH,
-            save_video=True,
-            return_frames=False,
-        ),
-    )
-
-    start_time = time.perf_counter()
-    result = generator.generate(request)
-    gen_time = time.perf_counter() - start_time
-
-    print(f"Time taken to load model: {load_time} seconds")
-    print(f"Time taken to generate video: {gen_time} seconds")
-    print(f"Output written to: {result.video_path}")
-
-
-if __name__ == "__main__":
-    main()
@@ -1,77 +0,0 @@
-import os
-import time
-
-from fastvideo import VideoGenerator
-from fastvideo.api import (
-    EngineConfig,
-    GenerationRequest,
-    GeneratorConfig,
-    OffloadConfig,
-    OutputConfig,
-    SamplingConfig,
-)
-
-# NVIDIA Cosmos3-Nano omni world model — this example exercises the
-# text-to-video (T2V) path through FastVideo's native Cosmos3 pipeline.
-# Point COSMOS3_MODEL_PATH at a local diffusers checkpoint (e.g.
-# ``official_weights/cosmos3``) to skip the Hugging Face download.
-OUTPUT_PATH = "video_samples_cosmos3"
-
-
-def main():
-    model_name = os.environ.get("COSMOS3_MODEL_PATH", "nvidia/Cosmos3-Nano")
-
-    generator_config = GeneratorConfig(
-        model_path=model_name,
-        engine=EngineConfig(
-            num_gpus=1,
-            use_fsdp_inference=False,
-            offload=OffloadConfig(
-                text_encoder=True,
-                pin_cpu_memory=True,
-                dit=False,
-                vae=False,
-            ),
-        ),
-    )
-
-    load_start_time = time.perf_counter()
-    generator = VideoGenerator.from_config(generator_config)
-    load_time = time.perf_counter() - load_start_time
-
-    prompt = (
-        "A golden retriever puppy runs across a sunlit meadow toward the camera, "
-        "ears flopping and wildflowers swaying in the breeze. Shallow depth of "
-        "field, warm afternoon light, smooth cinematic tracking shot."
-    )
-    request = GenerationRequest(
-        prompt=prompt,
-        sampling=SamplingConfig(
-            # cosmos3_nano native defaults are 704x1280, 189 frames, 35 steps;
-            # overridable via env for quick smoke runs.
-            num_frames=int(os.environ.get("COSMOS3_NUM_FRAMES", "189")),
-            height=int(os.environ.get("COSMOS3_HEIGHT", "704")),
-            width=int(os.environ.get("COSMOS3_WIDTH", "1280")),
-            num_inference_steps=int(os.environ.get("COSMOS3_STEPS", "35")),
-            guidance_scale=6.0,
-            fps=24,
-            seed=1024,
-        ),
-        output=OutputConfig(
-            output_path=OUTPUT_PATH,
-            save_video=True,
-            return_frames=False,
-        ),
-    )
-
-    start_time = time.perf_counter()
-    result = generator.generate(request)
-    gen_time = time.perf_counter() - start_time
-
-    print(f"Time taken to load model: {load_time} seconds")
-    print(f"Time taken to generate video: {gen_time} seconds")
-    print(f"Output written to: {result.video_path}")
-
-
-if __name__ == "__main__":
-    main()
@@ -1,78 +0,0 @@
-import os
-import time
-
-from fastvideo import VideoGenerator
-from fastvideo.api import (
-    EngineConfig,
-    GenerationRequest,
-    GeneratorConfig,
-    OffloadConfig,
-    OutputConfig,
-    SamplingConfig,
-)
-
-# NVIDIA Cosmos3-Nano omni world model — text-to-image (T2I) path through
-# FastVideo's native Cosmos3 pipeline. T2I is the single-frame case
-# (num_frames=1); the canonical Cosmos3 T2I resolution is 960x960 (the model's
-# "720" bucket, UniPC flow_shift=10.0). Point COSMOS3_MODEL_PATH at a local
-# diffusers checkpoint (e.g. ``official_weights/cosmos3``) to skip the download.
-OUTPUT_PATH = "video_samples_cosmos3_t2i"
-
-
-def main():
-    model_name = os.environ.get("COSMOS3_MODEL_PATH", "nvidia/Cosmos3-Nano")
-
-    generator_config = GeneratorConfig(
-        model_path=model_name,
-        engine=EngineConfig(
-            num_gpus=1,
-            use_fsdp_inference=False,
-            offload=OffloadConfig(
-                text_encoder=True,
-                pin_cpu_memory=True,
-                dit=False,
-                vae=False,
-            ),
-        ),
-    )
-
-    load_start_time = time.perf_counter()
-    generator = VideoGenerator.from_config(generator_config)
-    load_time = time.perf_counter() - load_start_time
-
-    prompt = (
-        "A photograph of a red panda sitting on a mossy log in a misty bamboo "
-        "forest, soft golden morning light filtering through the leaves, shallow "
-        "depth of field, crisp fur detail, serene atmosphere."
-    )
-    request = GenerationRequest(
-        prompt=prompt,
-        sampling=SamplingConfig(
-            # T2I is single-frame; canonical Cosmos3 T2I is 960x960. Overridable
-            # via env for quick smoke runs.
-            num_frames=1,
-            height=int(os.environ.get("COSMOS3_HEIGHT", "960")),
-            width=int(os.environ.get("COSMOS3_WIDTH", "960")),
-            num_inference_steps=int(os.environ.get("COSMOS3_STEPS", "35")),
-            guidance_scale=6.0,
-            fps=24,
-            seed=1024,
-        ),
-        output=OutputConfig(
-            output_path=OUTPUT_PATH,
-            save_video=True,
-            return_frames=False,
-        ),
-    )
-
-    start_time = time.perf_counter()
-    result = generator.generate(request)
-    gen_time = time.perf_counter() - start_time
-
-    print(f"Time taken to load model: {load_time} seconds")
-    print(f"Time taken to generate image: {gen_time} seconds")
-    print(f"Output written to: {result.video_path}")
-
-
-if __name__ == "__main__":
-    main()
@@ -1,67 +0,0 @@
-import os
-import time
-
-# t2vs (text -> video + sound). The Cosmos3 denoise stage generates a joint
-# [vision | sound] latent and AVAE-decodes the sound to a waveform muxed into the
-# mp4. The joint-sound path is gated on COSMOS3_T2VS (set here for the example).
-os.environ.setdefault("COSMOS3_T2VS", "1")
-
-from fastvideo import VideoGenerator  # noqa: E402
-from fastvideo.api import (  # noqa: E402
-    EngineConfig,
-    GenerationRequest,
-    GeneratorConfig,
-    OffloadConfig,
-    OutputConfig,
-    SamplingConfig,
-)
-
-OUTPUT_PATH = "video_samples_cosmos3_t2vs"
-
-
-def main():
-    model_name = os.environ.get("COSMOS3_MODEL_PATH", "nvidia/Cosmos3-Nano")
-
-    generator_config = GeneratorConfig(
-        model_path=model_name,
-        engine=EngineConfig(
-            num_gpus=1,
-            use_fsdp_inference=False,
-            offload=OffloadConfig(text_encoder=True, pin_cpu_memory=True, dit=False, vae=False),
-        ),
-    )
-
-    load_start = time.perf_counter()
-    generator = VideoGenerator.from_config(generator_config)
-    load_time = time.perf_counter() - load_start
-
-    prompt = (
-        "Ocean waves crash against a rocky shore at sunset, white foam spraying "
-        "into the air as seagulls wheel overhead. Golden light, cinematic wide "
-        "shot, the rhythmic roar of the surf."
-    )
-    request = GenerationRequest(
-        prompt=prompt,
-        sampling=SamplingConfig(
-            num_frames=int(os.environ.get("COSMOS3_NUM_FRAMES", "189")),
-            height=int(os.environ.get("COSMOS3_HEIGHT", "704")),
-            width=int(os.environ.get("COSMOS3_WIDTH", "1280")),
-            num_inference_steps=int(os.environ.get("COSMOS3_STEPS", "35")),
-            guidance_scale=6.0,
-            fps=24,
-            seed=1024,
-        ),
-        output=OutputConfig(output_path=OUTPUT_PATH, save_video=True, return_frames=False),
-    )
-
-    start = time.perf_counter()
-    result = generator.generate(request)
-    gen_time = time.perf_counter() - start
-
-    print(f"Time taken to load model: {load_time} seconds")
-    print(f"Time taken to generate video+sound: {gen_time} seconds")
-    print(f"Output written to: {result.video_path}")
-
-
-if __name__ == "__main__":
-    main()
@@ -1,64 +0,0 @@
-import os
-
-from fastvideo import VideoGenerator
-
-
-OUTPUT_PATH = os.getenv("DREAMX_WORLD_OUTPUT_PATH", "video_samples_dreamx_world")
-
-
-def _env_int(name: str, default: int) -> int:
-    return int(os.getenv(name, str(default)))
-
-
-def _env_float(name: str, default: float) -> float:
-    return float(os.getenv(name, str(default)))
-
-
-def main():
-    model_name = os.getenv("DREAMX_WORLD_MODEL_DIR", "FastVideo/DreamX-World-5B-Cam-Diffusers")
-    generator = VideoGenerator.from_pretrained(
-        model_name,
-        num_gpus=1,
-        use_fsdp_inference=False,
-        dit_cpu_offload=False,
-        vae_cpu_offload=True,
-        text_encoder_cpu_offload=True,
-        pin_cpu_memory=False,
-        override_pipeline_cls_name="DreamXWorldPipeline",
-    )
-
-    prompt = os.getenv(
-        "DREAMX_WORLD_PROMPT",
-        "A cinematic first-person drive through a futuristic coastal city at "
-        "sunrise, reflective glass towers, clean streets, soft volumetric light.",
-    )
-    image_path = os.getenv(
-        "DREAMX_WORLD_IMAGE_PATH",
-        "https://huggingface.co/datasets/YiYiXu/testing-images/resolve/main/wan_i2v_input.JPG",
-    )
-
-    kwargs = {
-        "output_path": OUTPUT_PATH,
-        "save_video": os.getenv("DREAMX_WORLD_SAVE_VIDEO", "1") != "0",
-        "height": _env_int("DREAMX_WORLD_HEIGHT", 480),
-        "width": _env_int("DREAMX_WORLD_WIDTH", 832),
-        "num_frames": _env_int("DREAMX_WORLD_NUM_FRAMES", 161),
-        "num_inference_steps": _env_int("DREAMX_WORLD_STEPS", 30),
-        "guidance_scale": _env_float("DREAMX_WORLD_GUIDANCE", 5.0),
-        "action_list": os.getenv("DREAMX_WORLD_ACTIONS", "w,d,w").split(","),
-        "action_speed_list": [
-            float(value)
-            for value in os.getenv("DREAMX_WORLD_ACTION_SPEEDS", "4.0,2.0,4.0").split(",")
-        ],
-    }
-    if image_path:
-        kwargs["image_path"] = image_path
-
-    try:
-        generator.generate_video(prompt, **kwargs)
-    finally:
-        generator.shutdown()
-
-
-if __name__ == "__main__":
-    main()
@@ -1,140 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-
-from __future__ import annotations
-
-import argparse
-import contextlib
-import os
-import re
-
-DEFAULT_PROMPTS = [
-    "a photo of a cat",
-    (
-        "a cinematic photo of a red panda wearing a tiny backpack, standing on a "
-        "rainy neon-lit street at night, shallow depth of field, sharp focus, "
-        "35mm, bokeh"
-    ),
-]
-
-
-def _safe_filename(text: str, max_len: int = 100) -> str:
-    """Make a stable, filesystem-friendly filename base."""
-    s = text[:max_len].strip()
-    s = s.replace(os.sep, "_")
-    if os.altsep:
-        s = s.replace(os.altsep, "_")
-    s = re.sub(r"\s+", " ", s)
-    s = re.sub(r"[^A-Za-z0-9 .,_-]", "_", s)
-    s = s.strip(" .")
-    return s or "prompt"
-
-
-def _remove_existing_outputs(out_dir: str, filename_base: str) -> None:
-    """Delete prior outputs so reruns do not get _1, _2 suffixes."""
-    if not os.path.isdir(out_dir):
-        return
-
-    pattern = re.compile(rf"^{re.escape(filename_base)}(_\d+)?\.(mp4|png)$")
-    for fn in os.listdir(out_dir):
-        if pattern.match(fn):
-            with contextlib.suppress(FileNotFoundError):
-                os.remove(os.path.join(out_dir, fn))
-
-
-def parse_args() -> argparse.Namespace:
-    p = argparse.ArgumentParser(
-        description="Run FLUX.1-dev text-to-image with FastVideo VideoGenerator.",
-    )
-    p.add_argument(
-        "--model-path",
-        default="official_weights/FLUX.1-dev",
-        help="Local Diffusers checkpoint dir or HF repo id.",
-    )
-    p.add_argument(
-        "--out-dir",
-        "--outdir",
-        default="outputs/flux_dev/samples",
-        help="Directory for saved PNG outputs.",
-    )
-    p.add_argument(
-        "--prompt",
-        action="append",
-        default=None,
-        help="Prompt. Repeat for multiple images.",
-    )
-    p.add_argument(
-        "--backend",
-        default=None,
-        help="Set FASTVIDEO_ATTENTION_BACKEND (e.g. TORCH_SDPA).",
-    )
-    p.add_argument("--seed", type=int, default=42, help="Base seed; each prompt uses seed + index.")
-    p.add_argument("--height", type=int, default=1024, help="Output height.")
-    p.add_argument("--width", type=int, default=1024, help="Output width.")
-    p.add_argument("--steps", type=int, default=28, help="Number of inference steps.")
-    p.add_argument("--guidance", type=float, default=3.5, help="Guidance scale.")
-    p.add_argument("--num-gpus", type=int, default=1, help="GPU count.")
-    return p.parse_args()
-
-
-def main() -> None:
-    args = parse_args()
-    prompts: list[str] = args.prompt if args.prompt else DEFAULT_PROMPTS
-
-    if args.backend:
-        os.environ["FASTVIDEO_ATTENTION_BACKEND"] = args.backend
-
-    from fastvideo import VideoGenerator
-
-    os.makedirs(args.out_dir, exist_ok=True)
-
-    init_kwargs = {
-        "num_gpus": args.num_gpus,
-        "workload_type": "t2i",
-        "sp_size": 1,
-        "tp_size": 1,
-        "dit_cpu_offload": False,
-        "dit_layerwise_offload": False,
-        "text_encoder_cpu_offload": False,
-        "vae_cpu_offload": False,
-        "image_encoder_cpu_offload": False,
-        "pin_cpu_memory": False,
-        "use_fsdp_inference": False,
-    }
-
-    generator = VideoGenerator.from_pretrained(
-        model_path=args.model_path,
-        **init_kwargs,
-    )
-    try:
-        for i, prompt in enumerate(prompts):
-            seed = args.seed + i
-            filename_base = (
-                f"flux_dev_{i:02d}_seed{seed}_{_safe_filename(prompt, max_len=80)}"
-            )
-            _remove_existing_outputs(args.out_dir, filename_base)
-            output_path = os.path.join(args.out_dir, f"{filename_base}.png")
-            print(f"[flux] prompt_idx={i} seed={seed} output_path={output_path}")
-
-            generation_kwargs = {
-                "output_path": output_path,
-                "height": args.height,
-                "width": args.width,
-                "num_frames": 1,
-                "fps": 1,
-                "num_inference_steps": args.steps,
-                "guidance_scale": args.guidance,
-                "use_embedded_guidance": True,
-                "true_cfg_scale": 1.0,
-                "seed": seed,
-                "save_video": True,
-            }
-
-            generator.generate_video(prompt, **generation_kwargs)
-
-        print(f"[flux] done. outputs written to: {args.out_dir}")
-    finally:
-        generator.shutdown()
-
-
-if __name__ == "__main__":
-    main()
@@ -1,107 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-"""Run GLM-Image text-to-image generation through FastVideo.
-
-User story:
-    "I have the HF `zai-org/GLM-Image` checkpoint and want a minimal
-    text-to-image generation command, saved as a PNG."
-"""
-import argparse
-from pathlib import Path
-
-from PIL import Image
-
-from fastvideo import VideoGenerator
-from fastvideo.api import (
-    EngineConfig,
-    GenerationRequest,
-    GeneratorConfig,
-    OutputConfig,
-    ParallelismConfig,
-    PipelineSelection,
-    SamplingConfig,
-)
-
-
-def parse_args() -> argparse.Namespace:
-    parser = argparse.ArgumentParser(description="Run GLM-Image text-to-image generation.")
-    parser.add_argument(
-        "--model-path",
-        default="zai-org/GLM-Image",
-        help="HF id or local diffusers-format GLM-Image weights directory.",
-    )
-    parser.add_argument(
-        "--output",
-        default="image_output/landscape.png",
-        help="Output PNG path.",
-    )
-    parser.add_argument(
-        "--prompt",
-        default=("A beautiful landscape photography with rolling hills, "
-                 "a winding river, and a vibrant sunset in the background. "
-                 "Warm golden light, photorealistic style."),
-        help="Text prompt.",
-    )
-    parser.add_argument("--height", type=int, default=1024)
-    parser.add_argument("--width", type=int, default=1024)
-    parser.add_argument("--steps", type=int, default=50)
-    parser.add_argument("--guidance-scale", type=float, default=1.5)
-    parser.add_argument("--seed", type=int, default=1024)
-    parser.add_argument("--num-gpus", type=int, default=1)
-    parser.add_argument("--tp-size", type=int, default=None)
-    parser.add_argument("--sp-size", type=int, default=None)
-    return parser.parse_args()
-
-
-def main() -> None:
-    args = parse_args()
-
-    output = Path(args.output)
-    output.parent.mkdir(parents=True, exist_ok=True)
-    tp_size = args.tp_size if args.tp_size is not None else (args.num_gpus if args.num_gpus > 1 else 1)
-    sp_size = args.sp_size if args.sp_size is not None else (1 if args.num_gpus > 1 else args.num_gpus)
-
-    # GLM-Image needs trust_remote_code for its AR encoder; offload and the
-    # pipeline class come from the model's registered defaults — don't override.
-    generator_config = GeneratorConfig(
-        model_path=args.model_path,
-        trust_remote_code=True,
-        engine=EngineConfig(
-            num_gpus=args.num_gpus,
-            parallelism=ParallelismConfig(tp_size=tp_size, sp_size=sp_size),
-        ),
-        pipeline=PipelineSelection(workload_type="t2i"),
-    )
-
-    generator = VideoGenerator.from_config(generator_config)
-    try:
-        request = GenerationRequest(
-            prompt=args.prompt,
-            sampling=SamplingConfig(
-                height=args.height,
-                width=args.width,
-                num_frames=1,
-                fps=1,
-                num_inference_steps=args.steps,
-                guidance_scale=args.guidance_scale,
-                seed=args.seed,
-            ),
-            output=OutputConfig(
-                output_path=str(output.parent),
-                save_video=False,
-                return_frames=True,
-            ),
-        )
-        result = generator.generate(request)
-        if isinstance(result, list):
-            result = result[0]
-
-        frames = result.frames
-        if frames is not None and len(frames):
-            Image.fromarray(frames[0]).save(output)
-            print(f"Saved image to {output}")
-    finally:
-        generator.shutdown()
-
-
-if __name__ == "__main__":
-    main()
@@ -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,120 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-"""Run GLM-Image image-to-image (edit) generation through FastVideo.
-
-User story:
-    "I have the HF `zai-org/GLM-Image` checkpoint and a condition image, and
-    want a minimal edit command (text + image -> edited image), saved as a PNG."
-
-GLM-Image is a single unified pipeline: passing a condition image switches it
-from text-to-image to the edit path (the condition enters the DiT via a KV-cache
-write pass), so the generator config is identical to `basic_glm_image.py` — the
-`inputs.pil_image` on the request is what selects the edit mode.
-"""
-import argparse
-from pathlib import Path
-
-from PIL import Image
-
-from fastvideo import VideoGenerator
-from fastvideo.api import (
-    EngineConfig,
-    GenerationRequest,
-    GeneratorConfig,
-    InputConfig,
-    OutputConfig,
-    ParallelismConfig,
-    PipelineSelection,
-    SamplingConfig,
-)
-
-
-def parse_args() -> argparse.Namespace:
-    parser = argparse.ArgumentParser(description="Run GLM-Image image-to-image (edit) generation.")
-    parser.add_argument(
-        "--model-path",
-        default="zai-org/GLM-Image",
-        help="HF id or local diffusers-format GLM-Image weights directory.",
-    )
-    parser.add_argument(
-        "--image",
-        default="assets/images/couple.jpg",
-        help="Condition image to edit.",
-    )
-    parser.add_argument(
-        "--output",
-        default="image_output/edited.png",
-        help="Output PNG path.",
-    )
-    parser.add_argument(
-        "--prompt",
-        default="Change the background to a snowy mountain landscape at golden hour.",
-        help="Edit instruction.",
-    )
-    parser.add_argument("--height", type=int, default=1024)
-    parser.add_argument("--width", type=int, default=1024)
-    parser.add_argument("--steps", type=int, default=50)
-    parser.add_argument("--guidance-scale", type=float, default=1.5)
-    parser.add_argument("--seed", type=int, default=1024)
-    parser.add_argument("--num-gpus", type=int, default=1)
-    parser.add_argument("--tp-size", type=int, default=None)
-    parser.add_argument("--sp-size", type=int, default=None)
-    return parser.parse_args()
-
-
-def main() -> None:
-    args = parse_args()
-
-    output = Path(args.output)
-    output.parent.mkdir(parents=True, exist_ok=True)
-    condition = Image.open(args.image).convert("RGB")
-    tp_size = args.tp_size if args.tp_size is not None else (args.num_gpus if args.num_gpus > 1 else 1)
-    sp_size = args.sp_size if args.sp_size is not None else (1 if args.num_gpus > 1 else args.num_gpus)
-
-    # GLM-Image needs trust_remote_code for its AR encoder; offload and the
-    # pipeline class come from the model's registered defaults — don't override.
-    # The pipeline is registered as t2i; passing inputs.pil_image below switches
-    # it to the edit path.
-    generator_config = GeneratorConfig(
-        model_path=args.model_path,
-        trust_remote_code=True,
-        engine=EngineConfig(
-            num_gpus=args.num_gpus,
-            parallelism=ParallelismConfig(tp_size=tp_size, sp_size=sp_size),
-        ),
-        pipeline=PipelineSelection(workload_type="t2i"),
-    )
-
-    generator = VideoGenerator.from_config(generator_config)
-    try:
-        request = GenerationRequest(
-            prompt=args.prompt,
-            inputs=InputConfig(pil_image=condition),
-            sampling=SamplingConfig(
-                height=args.height,
-                width=args.width,
-                num_frames=1,
-                fps=1,
-                num_inference_steps=args.steps,
-                guidance_scale=args.guidance_scale,
-                seed=args.seed,
-            ),
-            output=OutputConfig(
-                output_path=str(output.parent),
-                save_video=False,
-                return_frames=True,
-            ),
-        )
-        result = generator.generate(request)
-        if isinstance(result, list):
-            result = result[0]
-
-        frames = result.frames
-        if frames is not None and len(frames):
-            Image.fromarray(frames[0]).save(output)
-            print(f"Saved image to {output}")
-    finally:
-        generator.shutdown()
-
-
-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
@@ -1,105 +0,0 @@
-# AnyFlow on-policy DMD — Wan 2.1 T2V 1.3B.
-#
-# Stage 2 of the AnyFlow two-stage recipe. Continues from the pretrain
-# checkpoint; refines the student via DMD2 with a multi-step Euler-flow
-# rollout from pure noise. Teacher provides the real score, critic
-# learns the fake score; both inherited from DMD2Method.
-#
-# Replace <PATH_TO_PRETRAIN_CKPT> with the output of the pretrain stage,
-# or with the NVIDIA-released checkpoint
-# nvidia/AnyFlow-Wan2.1-T2V-1.3B-Diffusers to bootstrap directly from
-# the paper weights (the delta_embedder rename is handled by the
-# param_names_mapping in WanVideoArchConfig).
-
-models:
-  student:
-    _target_: fastvideo.train.models.wan.WanModel
-    init_from: <PATH_TO_PRETRAIN_CKPT>
-    trainable: true
-  teacher:
-    _target_: fastvideo.train.models.wan.WanModel
-    init_from: Wan-AI/Wan2.1-T2V-14B-Diffusers
-    trainable: false
-    disable_custom_init_weights: true
-  critic:
-    _target_: fastvideo.train.models.wan.WanModel
-    init_from: Wan-AI/Wan2.1-T2V-1.3B-Diffusers
-    trainable: true
-    disable_custom_init_weights: true
-
-method:
-  _target_: fastvideo.train.methods.distribution_matching.anyflow.AnyFlowMethod
-  rollout_mode: simulate
-  generator_update_interval: 5
-  real_score_guidance_scale: 3.0
-  dmd_denoising_steps: [999, 937, 833, 624]
-  warp_denoising_step: false
-
-  # AnyFlow rollout knobs.
-  student_sample_steps: 4
-  use_mean_velocity: true
-  t_list_override: [999.0, 937.0, 833.0, 624.0, 0.0]
-  dmd_score_r_value: 0.0  # DMD scoring conditioning is at r=0 (consistency target).
-
-  # Critic optimizer (DMD2 inherited).
-  fake_score_learning_rate: 8.0e-6
-  fake_score_betas: [0.0, 0.999]
-  fake_score_lr_scheduler: constant
-
-  attn_kind: vsa
-
-training:
-  distributed:
-    num_gpus: 8
-    sp_size: 1
-    tp_size: 1
-    hsdp_replicate_dim: 1
-    hsdp_shard_dim: 8
-
-  data:
-    data_path: data/preprocessed
-    dataloader_num_workers: 4
-    train_batch_size: 1
-    training_cfg_rate: 0.0
-    seed: 1000
-    num_latent_t: 21
-    num_height: 480
-    num_width: 832
-    num_frames: 81
-
-  optimizer:
-    learning_rate: 2.0e-6
-    betas: [0.0, 0.999]
-    weight_decay: 0.01
-    lr_scheduler: constant
-    lr_warmup_steps: 0
-
-  loop:
-    max_train_steps: 4000
-    gradient_accumulation_steps: 1
-
-  checkpoint:
-    output_dir: outputs/wan2.1_anyflow_onpolicy
-    training_state_checkpointing_steps: 500
-    checkpoints_total_limit: 3
-    resume_from_checkpoint: latest
-
-  tracker:
-    project_name: anyflow-wan
-    run_name: wan2.1_t2v_anyflow_onpolicy
-
-  model:
-    enable_gradient_checkpointing_type: full
-
-callbacks:
-  grad_clip:
-    _target_: fastvideo.train.callbacks.grad_clip.GradNormClipCallback
-    max_grad_norm: 1.0
-
-pipeline:
-  flow_shift: 5.0
-  dit_config:
-    r_embedder: true
-    r_embedder_fusion: gated
-    r_embedder_gate_value: 0.25
-    r_embedder_deltatime_type: r
@@ -1,83 +0,0 @@
-# AnyFlow pretrain (flow-map central-difference) — Wan 2.1 T2V 1.3B.
-#
-# Stage 1 of the AnyFlow two-stage recipe. Trains the dual-timestep
-# u_θ(x_t, t, r) on the central-difference target so the same checkpoint
-# can be sampled at arbitrary NFE in the on-policy stage.
-#
-# Initialize from base Wan 2.1 T2V 1.3B. No teacher or critic at this
-# stage; AnyFlowPretrainMethod owns a single student + one optimizer.
-
-models:
-  student:
-    _target_: fastvideo.train.models.wan.WanModel
-    init_from: Wan-AI/Wan2.1-T2V-1.3B-Diffusers
-    trainable: true
-
-method:
-  _target_: fastvideo.train.methods.distribution_matching.anyflow_pretrain.AnyFlowPretrainMethod
-  diffusion_ratio: 0.5
-  consistency_ratio: 0.25
-  epsilon: 5            # finite-difference step in absolute train-timestep units
-  weight_type: beta08   # per-timestep loss weight = t * sqrt(1 - t), renormalized
-  fuse_guidance_scale: 3.0
-  # shift is taken from pipeline.flow_shift below.
-
-training:
-  distributed:
-    num_gpus: 8
-    sp_size: 1
-    tp_size: 1
-    hsdp_replicate_dim: 1
-    hsdp_shard_dim: 8
-
-  data:
-    data_path: data/preprocessed
-    dataloader_num_workers: 4
-    train_batch_size: 4
-    training_cfg_rate: 0.0
-    seed: 1000
-    num_latent_t: 21
-    num_height: 480
-    num_width: 832
-    num_frames: 81
-
-  optimizer:
-    learning_rate: 5.0e-5
-    betas: [0.9, 0.999]
-    weight_decay: 0.0
-    lr_scheduler: constant
-    lr_warmup_steps: 0
-
-  loop:
-    max_train_steps: 6000
-    gradient_accumulation_steps: 1
-
-  checkpoint:
-    output_dir: outputs/wan2.1_anyflow_pretrain
-    training_state_checkpointing_steps: 500
-    checkpoints_total_limit: 3
-    resume_from_checkpoint: latest
-
-  tracker:
-    project_name: anyflow-wan
-    run_name: wan2.1_t2v_anyflow_pretrain
-
-  model:
-    enable_gradient_checkpointing_type: full
-
-callbacks:
-  grad_clip:
-    _target_: fastvideo.train.callbacks.grad_clip.GradNormClipCallback
-    max_grad_norm: 1.0
-
-pipeline:
-  flow_shift: 5.0
-  dit_config:
-    # Enable AnyFlow dual-timestep conditioning. The student loads from
-    # base Wan 2.1 — its checkpoint has no delta_embedder weights, so they
-    # get initialized identically to time_embedder via deep-copy in
-    # WanTimeTextImageEmbedding.__init__.
-    r_embedder: true
-    r_embedder_fusion: gated
-    r_embedder_gate_value: 0.25
-    r_embedder_deltatime_type: r
@@ -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,27 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-
-from __future__ import annotations
-
-from dataclasses import dataclass
-
-from fastvideo.api.sampling_param import SamplingParam
-
-
-@dataclass
-class FluxSamplingParam(SamplingParam):
-
-    prompt: str | None = "a photo of a cat"
-    negative_prompt: str = ""
-
-    num_videos_per_prompt: int = 1
-    seed: int = 0
-
-    num_frames: int = 1
-    height: int = 1024
-    width: int = 1024
-    fps: int = 1
-
-    num_inference_steps: int = 28
-    guidance_scale: float = 3.5
-    use_embedded_guidance: bool = True
-    true_cfg_scale: float = 1.0
@@ -90,10 +90,6 @@ class SamplingParam:
    num_inference_steps_sr: int = 50
    guidance_scale: float = 1.0
    guidance_scale_2: float | None = None
-    # Embedded guidance (FLUX): do not treat ``guidance_scale > 1`` as classic CFG.
-    use_embedded_guidance: bool = False
-    # Diffusers-style true CFG for FLUX when > 1 (requires negative prompt encoding).
-    true_cfg_scale: float = 1.0
    guidance_rescale: float = 0.0
    boundary_ratio: float | None = None
    sigmas: list[float] | None = None
@@ -329,18 +325,6 @@ class SamplingParam:
            default=SamplingParam.guidance_rescale,
            help="Guidance rescale factor",
        )
-        parser.add_argument(
-            "--use-embedded-guidance",
-            action="store_true",
-            default=SamplingParam.use_embedded_guidance,
-            help="Use embedded guidance scale (FLUX-style) instead of classic CFG",
-        )
-        parser.add_argument(
-            "--true-cfg-scale",
-            type=float,
-            default=SamplingParam.true_cfg_scale,
-            help="True CFG scale for FLUX when > 1 (requires negative prompt encoding)",
-        )
        parser.add_argument(
            "--boundary-ratio",
            type=float,
@@ -150,7 +150,6 @@ class SamplingConfig:
    guidance_scale_2: float | None = None
    guidance_rescale: float = 0.0
    true_cfg_scale: float | None = None
-    use_embedded_guidance: bool | None = None
    boundary_ratio: float | None = None
    sigmas: list[float] | None = None

@@ -1,15 +1,13 @@
 # SPDX-License-Identifier: Apache-2.0

+import importlib.util
 import os
+
 import torch
 import torch.nn.functional as F
 from dataclasses import dataclass

-from fastvideo.attention.utils.flash_attn_default import (
-    fa_version,
-    flash_attn_func_compilable,
-)
-
+from fastvideo import envs
 from fastvideo.attention.backends.abstract import (
    AttentionBackend,
    AttentionImpl,
@@ -19,6 +17,119 @@ from fastvideo.attention.backends.abstract import (
 from fastvideo.logger import init_logger

 logger = init_logger(__name__)
+
+# FA4 (flash_attn.cute) is explicit opt-in via FASTVIDEO_FA4=1, mirroring the
+# kernel package's FASTVIDEO_VSA_CUTEDSL: its CuTeDSL kernels JIT-compile per
+# shape family and can fail at runtime on some arch/shape combinations, so it
+# is never auto-selected just because it is installed. Below sm90 a capability
+# gate in flash_attn_cute routes to FA2 the calls FA4 cannot serve there:
+# grad-enabled (its backward asserts sm90+) and GQA (pack_gqa fails CuTeDSL
+# JIT, observed on sm_89).
+if envs.FASTVIDEO_FA4:
+    try:
+        from fastvideo.attention.utils.flash_attn_cute import flash_attn_func
+    except ImportError as e:
+        raise RuntimeError(f"FASTVIDEO_FA4=1 but flash_attn.cute (FA4) is not usable ({e}); "
+                           "fix the FA4 install (see the flash-attn-4 pin in pyproject.toml) "
+                           "or unset FASTVIDEO_FA4.") from e
+    fa_version = "4"
+else:
+    try:
+        from flash_attn_interface import flash_attn_func as flash_attn_3_func
+
+        # flash_attn 3 no longer have a different API, see following commit:
+        # https://github.com/Dao-AILab/flash-attention/commit/ed209409acedbb2379f870bbd03abce31a7a51b7
+        flash_attn_func = flash_attn_3_func
+        fa_version = "3"
+    except ImportError:
+        from flash_attn import flash_attn_func as flash_attn_2_func
+        flash_attn_func = flash_attn_2_func
+        fa_version = "2"
+    try:
+        if importlib.util.find_spec("flash_attn.cute") is not None:
+            logger.info("flash_attn.cute (FA4) is installed but not enabled; "
+                        "set FASTVIDEO_FA4=1 to use it for inference.")
+    except ImportError:
+        pass
+
+# torch.compile traceability: the FA4/cute path (fa_version=="4") is
+# already a registered torch.library custom op, so dynamo treats it as a
+# graph node. The external FA2/FA3 `flash_attn_func` is NOT — dynamo
+# breaks the graph at the call site (observed: wanvideo.py self-attn,
+# once per layer every step), which fragments the compiled region and
+# blocks CUDA-graph capture. Wrap the FA2/FA3 default call in a custom
+# op (mirrors the FP4 `flash_attn_cute` template) so it becomes an
+# opaque-but-traceable node. The kernel still runs eager inside the op
+# (correct — flash-attn must run eager); only dynamo's treatment of the
+# boundary changes, so numerics are unchanged (SSIM-gate to confirm).
+if fa_version in ("2", "3"):
+    _fa_default = flash_attn_func
+
+    # Scope: this op covers exactly the q/k/v + softmax_scale + causal
+    # call shape used by FlashAttentionImpl.forward's default branch
+    # (see `flash_attn_func_compilable(...)` call site below). The
+    # masked/no-pad and varlen / cross-attn paths use different
+    # entry points (`flash_attn_no_pad`, `flash_attn_varlen_*`) which
+    # are intentionally out of scope for this PR — wrapping them is a
+    # natural follow-up. The wrapper's signature is the contract: any
+    # extra kwarg (dropout_p, window_size, alibi_slopes, deterministic,
+    # return_attn_probs, ...) raises TypeError at the call site, so
+    # silent loss of kwargs is not a failure mode.
+    @torch.library.custom_op(
+        "fastvideo::_flash_attn_default_forward",
+        mutates_args=(),
+        device_types="cuda",
+    )
+    def _flash_attn_default_forward(
+        q: torch.Tensor,
+        k: torch.Tensor,
+        v: torch.Tensor,
+        softmax_scale: float | None,
+        causal: bool,
+    ) -> torch.Tensor:
+        return _fa_default(q, k, v, softmax_scale=softmax_scale, causal=causal)
+
+    @torch.library.register_fake("fastvideo::_flash_attn_default_forward")
+    def _flash_attn_default_forward_fake(
+        q: torch.Tensor,
+        k: torch.Tensor,
+        v: torch.Tensor,
+        softmax_scale: float | None,
+        causal: bool,
+    ) -> torch.Tensor:
+        del softmax_scale, causal
+        # FA2/FA3 default path: [batch, seqlen_q, nheads, head_dim_v],
+        # same dtype/device as q (head dim taken from v).
+        return q.new_empty(q.shape[0], q.shape[1], q.shape[2], v.shape[-1])
+
+    def flash_attn_func_compilable(q, k, v, softmax_scale=None, causal=False):
+        # Autograd carve-out. The custom op above registers a forward + fake
+        # kernel but NO backward (register_autograd), so it is opaque to
+        # autograd. Inference runs under no_grad / inference_mode and routes
+        # through the traceable custom op — that is the torch.compile win, and
+        # the only path this PR claims. Training backprops through attention,
+        # so route grad-enabled calls to the original FA2/FA3 `flash_attn_func`
+        # (itself an autograd.Function, so backward is correct) at the cost of a
+        # dynamo graph break on the training path — i.e. pre-PR behavior, no
+        # regression. Full autograd parity for the custom op (mirroring the FP4
+        # cute template) is a tracked follow-up.
+        if torch.is_grad_enabled() and (q.requires_grad or k.requires_grad or v.requires_grad):
+            return _fa_default(q, k, v, softmax_scale=softmax_scale, causal=causal)
+        return torch.ops.fastvideo._flash_attn_default_forward(q, k, v, softmax_scale, causal)
+elif fa_version == "4":
+    # FA4 path: `flash_attn_func` (from `flash_attn_cute`) goes through a
+    # registered torch.library custom op (with an FA4 backward on sm90+;
+    # grad-enabled and GQA calls below sm90 route to FA2), so a passthrough
+    # is enough — no extra registration needed.
+    def flash_attn_func_compilable(q, k, v, softmax_scale=None, causal=False):
+        return flash_attn_func(q, k, v, softmax_scale=softmax_scale, causal=causal)
+else:
+    # Defensive: the probe above only ever sets fa_version to "2", "3",
+    # or "4"; an unexpected value means an import/probe regression and
+    # we want a loud error at import, not a silent NameError later.
+    raise RuntimeError(f"Unsupported FlashAttention version: {fa_version!r} — expected "
+                       f"'2', '3', or '4' from the import probe above.")
+
 logger.info("Using FlashAttention-%s backend", fa_version)

 # FP4 FA4 support: quantize Q/K to NVFP4 E2M1 for block-scaled MMA on Blackwell.
@@ -198,17 +309,9 @@ class FlashAttentionImpl(AttentionImpl):
        attn_metadata: FlashAttnMetadata,
    ):
        if (attn_metadata is not None and hasattr(attn_metadata, "attn_mask") and attn_metadata.attn_mask is not None):
-            # Route through the *_compilable wrappers so dynamo sees one
-            # traceable node for each masked entry point (the unpad/pad
-            # bookkeeping runs eager inside the custom op). On FA2 these
-            # wrappers go through ops with full register_autograd, so
-            # training also backprops through the op (no graph break on
-            # the training path); on FA3/FA4 they carve out to the
-            # autograd.Function for grad-enabled calls — see
-            # fastvideo/attention/utils/flash_attn_no_pad.py.
            from fastvideo.attention.utils.flash_attn_no_pad import (
-                flash_attn_no_pad_compilable as flash_attn_no_pad,
-                flash_attn_varlen_qk_no_pad_compilable as flash_attn_varlen_qk_no_pad,
+                flash_attn_no_pad,
+                flash_attn_varlen_qk_no_pad,
            )

            attn_mask = attn_metadata.attn_mask
@@ -235,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

@@ -1,251 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-"""torch.compile-traceable wrapper for the FA2/FA3/FA4 default attention path.
-
-The FA4/cute path (`fa_version == "4"`) is already a registered
-`torch.library.custom_op` in `fastvideo.attention.utils.flash_attn_cute`, so
-dynamo treats it as a graph node. The external FA2/FA3 ``flash_attn_func`` is
-NOT — dynamo breaks the graph at the call site (observed: wanvideo.py
-self-attn, once per layer every step), which fragments the compiled region
-and blocks CUDA-graph capture. Wrap the FA2/FA3 default call in a custom op
-(mirrors the FP4 `flash_attn_cute` template) so it becomes an
-opaque-but-traceable node. The kernel still runs eager inside the op
-(correct — flash-attn must run eager); only dynamo's treatment of the
-boundary changes, so numerics are unchanged (SSIM-gated).
-
-Autograd: FA2 has full ``register_autograd`` parity — the custom op's
-backward calls flash_attn's ``_flash_attn_backward`` directly, so training
-backprops *through* the op (no graph break on the training path either).
-FA3 currently keeps the no-backward + carve-out pattern from PR #1373
-because FA3's private backward signature wants validation on a real Hopper
-box (gated on Kuan-Hao's Modal FA3 setup PR). Once that lands the FA3 path
-can mirror FA2.
-
-Lives in `attention/utils/` (sibling of `flash_attn_cute.py` and
-`flash_attn_no_pad.py`) so it can be imported by any backend that wants the
-traceable FA default call without pulling in backend dispatch logic. The
-backend (`attention/backends/flash_attn.py`) just imports
-`flash_attn_func_compilable` and `fa_version` from here.
-"""
-
-import importlib.util
-
-import torch
-
-from fastvideo import envs
-from fastvideo.logger import init_logger
-
-logger = init_logger(__name__)
-
-# Pick the same backend the rest of FastVideo picked for `flash_attn_func`
-# (FA4/cute → FA3 → FA2). Mirror the precedence used in
-# `attention/utils/flash_attn_no_pad.py` so the two probes always agree.
-#
-# FA4 (flash_attn.cute) is explicit opt-in via FASTVIDEO_FA4=1: its CuTeDSL
-# kernels JIT-compile per shape family and can fail at runtime on some
-# arch/shape combinations, so it is never auto-selected just because it is
-# installed.
-if envs.FASTVIDEO_FA4:
-    try:
-        from fastvideo.attention.utils.flash_attn_cute import flash_attn_func
-    except ImportError as e:
-        raise RuntimeError(f"FASTVIDEO_FA4=1 but flash_attn.cute (FA4) is not usable ({e}); "
-                           "fix the FA4 install (see the flash-attn-4 pin in pyproject.toml) "
-                           "or unset FASTVIDEO_FA4.") from e
-    fa_version = "4"
-else:
-    try:
-        from flash_attn_interface import flash_attn_func as flash_attn_3_func
-
-        # flash_attn 3 no longer has a different API, see following commit:
-        # https://github.com/Dao-AILab/flash-attention/commit/ed209409acedbb2379f870bbd03abce31a7a51b7
-        flash_attn_func = flash_attn_3_func
-        fa_version = "3"
-    except ImportError:
-        from flash_attn import flash_attn_func as flash_attn_2_func
-        flash_attn_func = flash_attn_2_func
-        fa_version = "2"
-    try:
-        if importlib.util.find_spec("flash_attn.cute") is not None:
-            logger.info("flash_attn.cute (FA4) is installed but not enabled; "
-                        "set FASTVIDEO_FA4=1 to use it for inference.")
-    except ImportError:
-        pass
-
-if fa_version == "2":
-    # Scope: this op covers exactly the q/k/v + softmax_scale + causal call
-    # shape used by FlashAttentionImpl.forward's default branch (see
-    # `flash_attn_func_compilable(...)` call site in
-    # `attention/backends/flash_attn.py`). The masked/no-pad and varlen /
-    # cross-attn paths use different entry points
-    # (`flash_attn_no_pad`, `flash_attn_varlen_*`) which live in
-    # `attention/utils/flash_attn_no_pad.py`. The wrapper's signature is the
-    # contract: any extra kwarg (dropout_p, window_size, alibi_slopes,
-    # deterministic, return_attn_probs, ...) raises TypeError at the call
-    # site, so silent loss of kwargs is not a failure mode.
-    from flash_attn.flash_attn_interface import _flash_attn_backward as _fa2_backward
-    _fa_default = flash_attn_func
-
-    @torch.library.custom_op(
-        "fastvideo::_flash_attn_default_forward",
-        mutates_args=(),
-        device_types="cuda",
-    )
-    def _flash_attn_default_forward(
-        q: torch.Tensor,
-        k: torch.Tensor,
-        v: torch.Tensor,
-        softmax_scale: float | None,
-        causal: bool,
-    ) -> tuple[torch.Tensor, torch.Tensor]:
-        # `return_attn_probs=True` asks FA2 to also return softmax_lse +
-        # S_dmask. We need softmax_lse to feed the backward; S_dmask is the
-        # dropout mask (always None here since dropout_p is fixed at 0).
-        out, softmax_lse, _ = _fa_default(q, k, v, softmax_scale=softmax_scale, causal=causal, return_attn_probs=True)
-        return out, softmax_lse
-
-    @torch.library.register_fake("fastvideo::_flash_attn_default_forward")
-    def _flash_attn_default_forward_fake(
-        q: torch.Tensor,
-        k: torch.Tensor,
-        v: torch.Tensor,
-        softmax_scale: float | None,
-        causal: bool,
-    ) -> tuple[torch.Tensor, torch.Tensor]:
-        del softmax_scale, causal
-        # FA2 default path: out = [batch, seqlen_q, nheads, head_dim_v],
-        # softmax_lse = [batch, nheads, seqlen_q], fp32 regardless of q dtype.
-        b, sq, hq = q.shape[0], q.shape[1], q.shape[2]
-        out = q.new_empty(b, sq, hq, v.shape[-1])
-        lse = q.new_empty(b, hq, sq, dtype=torch.float32)
-        return out, lse
-
-    def _flash_attn_default_setup_context(ctx, inputs, output):
-        q, k, v, softmax_scale, causal = inputs
-        out, lse = output
-        ctx.save_for_backward(q, k, v, out, lse)
-        # `lse` is an auxiliary output we save to feed FA2's backward; nobody
-        # should differentiate through it. Mark it non-differentiable so
-        # autograd errors loudly if a caller wires it into a loss, rather
-        # than silently producing zero/None grads through the `del grad_lse`
-        # in our backward.
-        ctx.mark_non_differentiable(lse)
-        # FA2's *forward* substitutes `1 / sqrt(head_dim)` for `softmax_scale=None`
-        # internally; FA2's *backward* (`_flash_attn_backward`) demands a concrete
-        # float in its C++ schema and rejects None at the binding boundary. Resolve
-        # the default here so the value saved on ctx (and passed to backward) is
-        # always a real float — matches what FA2's own autograd.Function does.
-        if softmax_scale is None:
-            softmax_scale = q.shape[-1]**-0.5
-        ctx.softmax_scale = softmax_scale
-        ctx.causal = causal
-
-    def _flash_attn_default_backward(ctx, grad_out, grad_lse):
-        # We only differentiate `out`; softmax_lse is saved-for-backward, not
-        # a real differentiable output. (Mirrors the FP4 cute template.)
-        del grad_lse
-        q, k, v, out, lse = ctx.saved_tensors
-        dq = torch.empty_like(q)
-        dk = torch.empty_like(k)
-        dv = torch.empty_like(v)
-        # FA2's `_flash_attn_backward` writes into dq/dk/dv in place. The
-        # extra kwargs (window_size_*, softcap, alibi_slopes, deterministic,
-        # rng_state) are pinned to the same defaults the forward wrapper
-        # uses — flash-attn==2.8.1 (the version FastVideo pins) requires
-        # all of them explicitly. `rng_state=None` is correct for our
-        # `dropout_p=0` configuration.
-        _fa2_backward(
-            grad_out,
-            q,
-            k,
-            v,
-            out,
-            lse,
-            dq,
-            dk,
-            dv,
-            dropout_p=0.0,
-            softmax_scale=ctx.softmax_scale,
-            causal=ctx.causal,
-            window_size_left=-1,
-            window_size_right=-1,
-            softcap=0.0,
-            alibi_slopes=None,
-            deterministic=False,
-            rng_state=None,
-        )
-        return dq, dk, dv, None, None
-
-    torch.library.register_autograd(
-        "fastvideo::_flash_attn_default_forward",
-        _flash_attn_default_backward,
-        setup_context=_flash_attn_default_setup_context,
-    )
-
-    def flash_attn_func_compilable(q, k, v, softmax_scale=None, causal=False):
-        # Backward is registered: autograd flows through the op (training
-        # path is also traceable; no carve-out needed). Public API matches
-        # `flash_attn_func` — returns just `out`; we drop the saved-for-
-        # backward `lse` here so callers see the original single-tensor
-        # contract.
-        out, _ = torch.ops.fastvideo._flash_attn_default_forward(q, k, v, softmax_scale, causal)
-        return out
-elif fa_version == "3":
-    # FA3 path: same forward+fake custom op as the original PR #1373, with
-    # the autograd carve-out kept. The full backward (mirroring the FA2 leg
-    # above) wants a Hopper box for grad-check validation, which we don't
-    # have until Kuan-Hao's Modal FA3 setup PR lands. Until then this keeps
-    # inference traceable + training correct (via the original
-    # autograd.Function path + a pre-PR-style graph break on training).
-    _fa_default = flash_attn_func
-
-    @torch.library.custom_op(
-        "fastvideo::_flash_attn_default_forward",
-        mutates_args=(),
-        device_types="cuda",
-    )
-    def _flash_attn_default_forward(
-        q: torch.Tensor,
-        k: torch.Tensor,
-        v: torch.Tensor,
-        softmax_scale: float | None,
-        causal: bool,
-    ) -> torch.Tensor:
-        return _fa_default(q, k, v, softmax_scale=softmax_scale, causal=causal)
-
-    @torch.library.register_fake("fastvideo::_flash_attn_default_forward")
-    def _flash_attn_default_forward_fake(
-        q: torch.Tensor,
-        k: torch.Tensor,
-        v: torch.Tensor,
-        softmax_scale: float | None,
-        causal: bool,
-    ) -> torch.Tensor:
-        del softmax_scale, causal
-        return q.new_empty(q.shape[0], q.shape[1], q.shape[2], v.shape[-1])
-
-    def flash_attn_func_compilable(q, k, v, softmax_scale=None, causal=False):
-        # Autograd carve-out. The custom op above registers a forward + fake
-        # kernel but NO backward (register_autograd), so it is opaque to
-        # autograd. Inference runs under no_grad / inference_mode and routes
-        # through the traceable custom op — that is the torch.compile win, and
-        # the only path this PR claims. Training backprops through attention,
-        # so route grad-enabled calls to the original FA2/FA3 `flash_attn_func`
-        # (itself an autograd.Function, so backward is correct) at the cost of a
-        # dynamo graph break on the training path — i.e. pre-PR behavior, no
-        # regression. Full autograd parity for the custom op (mirroring the FP4
-        # cute template) is a tracked follow-up.
-        if torch.is_grad_enabled() and (q.requires_grad or k.requires_grad or v.requires_grad):
-            return _fa_default(q, k, v, softmax_scale=softmax_scale, causal=causal)
-        return torch.ops.fastvideo._flash_attn_default_forward(q, k, v, softmax_scale, causal)
-elif fa_version == "4":
-    # FA4 path: `flash_attn_func` is already a torch.library custom op
-    # (registered in `fastvideo.attention.utils.flash_attn_cute`), so a
-    # passthrough is enough — no extra registration needed.
-    def flash_attn_func_compilable(q, k, v, softmax_scale=None, causal=False):
-        return flash_attn_func(q, k, v, softmax_scale=softmax_scale, causal=causal)
-else:
-    # Defensive: the probe above only ever sets fa_version to "2", "3",
-    # or "4"; an unexpected value means an import/probe regression and
-    # we want a loud error at import, not a silent NameError later.
-    raise RuntimeError(f"Unsupported FlashAttention version: {fa_version!r} — expected "
-                       f"'2', '3', or '4' from the import probe above.")
@@ -24,7 +24,7 @@ from flash_attn.bert_padding import pad_input, unpad_input
 from fastvideo import envs


-def _resolve_flash_attn_varlen_func() -> tuple[Any, str]:
+def _resolve_flash_attn_varlen_func() -> Any:
    if envs.FASTVIDEO_FA4:
        # FA4 cute is explicit opt-in (see fastvideo/attention/backends/
        # flash_attn.py); with FASTVIDEO_FA4=1 an unimportable FA4 build must
@@ -39,28 +39,20 @@ def _resolve_flash_attn_varlen_func() -> tuple[Any, str]:
                               "fix the FA4 install (see the flash-attn-4 pin in pyproject.toml) "
                               "or unset FASTVIDEO_FA4.") from e

-        return flash_attn_varlen_func_cute, "4"
+        return flash_attn_varlen_func_cute
    try:
        from flash_attn_interface import (
            flash_attn_varlen_func as flash_attn_varlen_func_interface, )

-        return flash_attn_varlen_func_interface, "3"
+        return flash_attn_varlen_func_interface
    except ImportError:
        from flash_attn import (
            flash_attn_varlen_func as flash_attn_varlen_func_flash, )

-        return flash_attn_varlen_func_flash, "2"
+        return flash_attn_varlen_func_flash


-flash_attn_varlen_func_impl, _FA_VARLEN_VERSION = _resolve_flash_attn_varlen_func()
-
-# FA2-only: the private varlen backward we register against the custom ops
-# below. FA3 / FA4 have different private signatures and validation paths
-# (Hopper / Blackwell boxes) — those legs keep the autograd carve-out
-# pattern from PR #1373 until their setup PRs land.
-if _FA_VARLEN_VERSION == "2":
-    from flash_attn.flash_attn_interface import (
-        _flash_attn_varlen_backward as _fa2_varlen_backward, )
+flash_attn_varlen_func_impl = _resolve_flash_attn_varlen_func()


 def flash_attn_no_pad(
@@ -199,473 +191,3 @@ def flash_attn_varlen_qk_no_pad(
        h=nheads,
    )
    return output
-
-
-# ---------------------------------------------------------------------------
-# torch.compile traceability + register_autograd parity for the masked /
-# varlen attention paths.
-#
-# Wraps the two entry points `FlashAttentionImpl.forward` calls
-# (`flash_attn_no_pad`, `flash_attn_varlen_qk_no_pad`) as
-# `torch.library.custom_op`s so dynamo sees one traceable node — the
-# internal unpad / pad bookkeeping (data-dependent `nnz` shapes) runs
-# eager inside the op, and the op's outputs are the statically-shaped
-# padded tensors. This mirrors the FA2 default-path wrapper in
-# `fastvideo/attention/backends/flash_attn.py`.
-#
-# Autograd: on FA2 we register a real backward (`register_autograd`)
-# that calls FA2's `_flash_attn_varlen_backward` on the unpadded form
-# — re-unpadding the saved padded tensors using the saved mask. The
-# `softmax_lse` from the varlen forward is naturally unpadded
-# (`[nheads, total_q]`); we pad it to `[batch, nheads, seqlen]` on
-# the way out (statically shaped) and re-unpad in backward. So
-# training backprops *through* the op (no graph break on the training
-# path either).
-#
-# FA3 / FA4 keep the autograd carve-out pattern from PR #1373: the
-# custom op has forward + fake only, and `*_compilable` falls back to
-# the original autograd.Function for grad-enabled calls. Those legs
-# are gated on Hopper-class / Blackwell-class boxes for backward
-# validation and ship as separate follow-ups.
-
-if _FA_VARLEN_VERSION == "2":
-    # ---------- masked self-attention: flash_attn_no_pad (FA2) ----------
-
-    @torch.library.custom_op(
-        "fastvideo::_flash_attn_no_pad_forward",
-        mutates_args=(),
-        device_types="cuda",
-    )
-    def _flash_attn_no_pad_forward(
-        qkv: torch.Tensor,
-        key_padding_mask: torch.Tensor,
-        causal: bool,
-        dropout_p: float,
-        softmax_scale: float | None,
-        deterministic: bool,
-    ) -> tuple[torch.Tensor, torch.Tensor]:
-        b, s, _three, h, d = qkv.shape
-        x = rearrange(qkv, "b s three h d -> b s (three h d)")
-        x_unpad, indices, cu_seqlens, max_s, _ = unpad_input(x, key_padding_mask)
-        x_unpad = rearrange(x_unpad, "nnz (three h d) -> nnz three h d", three=3, h=h)
-        out_unpad, lse_unpad, _ = flash_attn_varlen_qkvpacked_func(x_unpad,
-                                                                   cu_seqlens,
-                                                                   max_s,
-                                                                   dropout_p,
-                                                                   softmax_scale=softmax_scale,
-                                                                   causal=causal,
-                                                                   deterministic=deterministic,
-                                                                   return_attn_probs=True)
-        # Pad out: [nnz, h, d] -> [b, s, h, d]
-        out_padded = rearrange(pad_input(rearrange(out_unpad, "nnz h d -> nnz (h d)"), indices, b, s),
-                               "b s (h d) -> b s h d",
-                               h=h)
-        # Pad lse: FA2 varlen returns [nheads, total_q]. Transpose to [total_q,
-        # nheads], pad to [b, s, nheads], permute to [b, nheads, s] — statically
-        # shaped so register_fake matches.
-        lse_padded = pad_input(lse_unpad.t().contiguous(), indices, b, s).permute(0, 2, 1).contiguous()
-        return out_padded, lse_padded
-
-    @torch.library.register_fake("fastvideo::_flash_attn_no_pad_forward")
-    def _flash_attn_no_pad_forward_fake(
-        qkv: torch.Tensor,
-        key_padding_mask: torch.Tensor,
-        causal: bool,
-        dropout_p: float,
-        softmax_scale: float | None,
-        deterministic: bool,
-    ) -> tuple[torch.Tensor, torch.Tensor]:
-        del key_padding_mask, causal, dropout_p, softmax_scale, deterministic
-        b, s, _three, h, d = qkv.shape
-        out = qkv.new_empty(b, s, h, d)
-        lse = qkv.new_empty(b, h, s, dtype=torch.float32)
-        return out, lse
-
-    def _flash_attn_no_pad_setup_context(ctx, inputs, output):
-        qkv, key_padding_mask, causal, dropout_p, softmax_scale, deterministic = inputs
-        out, lse = output
-        ctx.save_for_backward(qkv, out, lse, key_padding_mask)
-        # Auxiliary output, not differentiable — see default-path note.
-        ctx.mark_non_differentiable(lse)
-        # FA2's varlen backward requires a concrete float for softmax_scale.
-        if softmax_scale is None:
-            softmax_scale = qkv.shape[-1]**-0.5  # head_dim from qkv's last dim
-        ctx.softmax_scale = softmax_scale
-        ctx.causal = causal
-        ctx.dropout_p = dropout_p
-        ctx.deterministic = deterministic
-
-    def _flash_attn_no_pad_backward(ctx, grad_out, grad_lse):
-        # lse is saved-for-backward, not differentiated.
-        del grad_lse
-        qkv, out_padded, lse_padded, key_padding_mask = ctx.saved_tensors
-        b, s, _three, h, d = qkv.shape
-
-        # One `unpad_input` call (on qkv) gives us indices + cu_seqlens + max_s;
-        # reuse those for out / dout / lse below via direct indexing instead
-        # of redundant `unpad_input` calls (each of which would re-run
-        # `nonzero` + `cumsum` + a `.max().item()` GPU→CPU sync).
-        x = rearrange(qkv, "b s three h d -> b s (three h d)")
-        x_unpad, indices, cu_seqlens, max_s, _ = unpad_input(x, key_padding_mask)
-        x_unpad = rearrange(x_unpad, "nnz (three h d) -> nnz three h d", three=3, h=h)
-        q_unpad, k_unpad, v_unpad = (t.contiguous() for t in x_unpad.unbind(dim=1))
-
-        # Direct-index variants reuse `indices` (computed above).
-        out_unpad = out_padded.flatten(0, 1)[indices].view(-1, h, d).contiguous()
-        dout_unpad = grad_out.flatten(0, 1)[indices].view(-1, h, d).contiguous()
-        # lse_padded [b, h, s] -> [b, s, h] -> [nnz, h] -> [h, nnz].
-        lse_unpad = lse_padded.permute(0, 2, 1).contiguous().flatten(0, 1)[indices].t().contiguous()
-
-        dq_unpad = torch.empty_like(q_unpad)
-        dk_unpad = torch.empty_like(k_unpad)
-        dv_unpad = torch.empty_like(v_unpad)
-        _fa2_varlen_backward(
-            dout_unpad,
-            q_unpad,
-            k_unpad,
-            v_unpad,
-            out_unpad,
-            lse_unpad,
-            dq_unpad,
-            dk_unpad,
-            dv_unpad,
-            cu_seqlens_q=cu_seqlens,
-            cu_seqlens_k=cu_seqlens,
-            max_seqlen_q=max_s,
-            max_seqlen_k=max_s,
-            dropout_p=ctx.dropout_p,
-            softmax_scale=ctx.softmax_scale,
-            causal=ctx.causal,
-            window_size_left=-1,
-            window_size_right=-1,
-            softcap=0.0,
-            alibi_slopes=None,
-            deterministic=ctx.deterministic,
-            rng_state=None,
-        )
-
-        # Re-pad each grad and stack into dqkv.
-        def _repad(dt_unpad: torch.Tensor) -> torch.Tensor:
-            padded = pad_input(rearrange(dt_unpad, "nnz h d -> nnz (h d)"), indices, b, s)
-            return rearrange(padded, "b s (h d) -> b s h d", h=h)
-
-        dqkv = torch.stack([_repad(dq_unpad), _repad(dk_unpad), _repad(dv_unpad)], dim=2)
-        # 6 inputs total: qkv, key_padding_mask, causal, dropout_p, softmax_scale, deterministic.
-        return dqkv, None, None, None, None, None
-
-    torch.library.register_autograd(
-        "fastvideo::_flash_attn_no_pad_forward",
-        _flash_attn_no_pad_backward,
-        setup_context=_flash_attn_no_pad_setup_context,
-    )
-
-    # ---------- cross-attention: flash_attn_varlen_qk_no_pad (FA2) ----------
-
-    @torch.library.custom_op(
-        "fastvideo::_flash_attn_varlen_qk_no_pad_forward",
-        mutates_args=(),
-        device_types="cuda",
-    )
-    def _flash_attn_varlen_qk_no_pad_forward(
-        query: torch.Tensor,
-        key: torch.Tensor,
-        value: torch.Tensor,
-        query_padding_mask: torch.Tensor,
-        key_padding_mask: torch.Tensor,
-        causal: bool,
-        dropout_p: float,
-        softmax_scale: float | None,
-        deterministic: bool,
-    ) -> tuple[torch.Tensor, torch.Tensor]:
-        b, sq, h, d = query.shape
-        q_unpad, q_indices, cu_seqlens_q, max_seqlen_q, _ = unpad_input(rearrange(query, "b s h d -> b s (h d)"),
-                                                                        query_padding_mask)
-        k_unpad, _, cu_seqlens_k, max_seqlen_k, _ = unpad_input(rearrange(key, "b s h d -> b s (h d)"),
-                                                                key_padding_mask)
-        v_unpad, _, _, _, _ = unpad_input(rearrange(value, "b s h d -> b s (h d)"), key_padding_mask)
-        q_unpad = rearrange(q_unpad, "nnz (h d) -> nnz h d", h=h)
-        k_unpad = rearrange(k_unpad, "nnz (h d) -> nnz h d", h=h)
-        v_unpad = rearrange(v_unpad, "nnz (h d) -> nnz h d", h=h)
-        out_unpad, lse_unpad, _ = flash_attn_varlen_func_impl(q_unpad,
-                                                              k_unpad,
-                                                              v_unpad,
-                                                              cu_seqlens_q,
-                                                              cu_seqlens_k,
-                                                              max_seqlen_q,
-                                                              max_seqlen_k,
-                                                              dropout_p=dropout_p,
-                                                              softmax_scale=softmax_scale,
-                                                              causal=causal,
-                                                              deterministic=deterministic,
-                                                              return_attn_probs=True)
-        # Pad out: [nnz_q, h, d] -> [b, sq, h, d]
-        out_padded = rearrange(pad_input(rearrange(out_unpad, "nnz h d -> nnz (h d)"), q_indices, b, sq),
-                               "b s (h d) -> b s h d",
-                               h=h)
-        # Pad lse: [h, nnz_q] -> [b, h, sq]
-        lse_padded = pad_input(lse_unpad.t().contiguous(), q_indices, b, sq).permute(0, 2, 1).contiguous()
-        return out_padded, lse_padded
-
-    @torch.library.register_fake("fastvideo::_flash_attn_varlen_qk_no_pad_forward")
-    def _flash_attn_varlen_qk_no_pad_forward_fake(
-        query: torch.Tensor,
-        key: torch.Tensor,
-        value: torch.Tensor,
-        query_padding_mask: torch.Tensor,
-        key_padding_mask: torch.Tensor,
-        causal: bool,
-        dropout_p: float,
-        softmax_scale: float | None,
-        deterministic: bool,
-    ) -> tuple[torch.Tensor, torch.Tensor]:
-        del key, query_padding_mask, key_padding_mask
-        del causal, dropout_p, softmax_scale, deterministic
-        b, sq, h, _ = query.shape
-        # `out`'s head_dim comes from value (d_v), matching the real forward's
-        # out_padded ([b, sq, h, d_v]); it can differ from query's d_q.
-        out = query.new_empty(b, sq, h, value.shape[-1])
-        lse = query.new_empty(b, h, sq, dtype=torch.float32)
-        return out, lse
-
-    def _flash_attn_varlen_qk_no_pad_setup_context(ctx, inputs, output):
-        (query, key, value, query_padding_mask, key_padding_mask, causal, dropout_p, softmax_scale,
-         deterministic) = inputs
-        out, lse = output
-        ctx.save_for_backward(query, key, value, out, lse, query_padding_mask, key_padding_mask)
-        # Auxiliary output, not differentiable — see default-path note.
-        ctx.mark_non_differentiable(lse)
-        if softmax_scale is None:
-            softmax_scale = query.shape[-1]**-0.5
-        ctx.softmax_scale = softmax_scale
-        ctx.causal = causal
-        ctx.dropout_p = dropout_p
-        ctx.deterministic = deterministic
-
-    def _flash_attn_varlen_qk_no_pad_backward(ctx, grad_out, grad_lse):
-        del grad_lse
-        (query, key, value, out_padded, lse_padded, query_padding_mask, key_padding_mask) = ctx.saved_tensors
-        b, sq, h, d = query.shape
-        sk = key.shape[1]
-
-        # One `unpad_input` call per distinct mask; reuse the returned
-        # indices via direct indexing for everything else that shares
-        # the same mask (v with k_mask; out/dout/lse with q_mask; the
-        # final repad of dk/dv also reuses k_indices). Avoids ~4
-        # redundant `unpad_input` calls + their GPU→CPU `.max().item()`
-        # syncs.
-        q_unpad, q_indices, cu_seqlens_q, max_seqlen_q, _ = unpad_input(rearrange(query, "b s h d -> b s (h d)"),
-                                                                        query_padding_mask)
-        k_unpad, k_indices, cu_seqlens_k, max_seqlen_k, _ = unpad_input(rearrange(key, "b s h d -> b s (h d)"),
-                                                                        key_padding_mask)
-        q_unpad = rearrange(q_unpad, "nnz (h d) -> nnz h d", h=h).contiguous()
-        k_unpad = rearrange(k_unpad, "nnz (h d) -> nnz h d", h=h).contiguous()
-        v_unpad = value.flatten(0, 1)[k_indices].view(-1, h, d).contiguous()
-
-        # out / dout / lse follow q's shape, so index with q_indices.
-        out_unpad = out_padded.flatten(0, 1)[q_indices].view(-1, h, d).contiguous()
-        dout_unpad = grad_out.flatten(0, 1)[q_indices].view(-1, h, d).contiguous()
-        lse_unpad = lse_padded.permute(0, 2, 1).contiguous().flatten(0, 1)[q_indices].t().contiguous()
-
-        dq_unpad = torch.empty_like(q_unpad)
-        dk_unpad = torch.empty_like(k_unpad)
-        dv_unpad = torch.empty_like(v_unpad)
-        _fa2_varlen_backward(
-            dout_unpad,
-            q_unpad,
-            k_unpad,
-            v_unpad,
-            out_unpad,
-            lse_unpad,
-            dq_unpad,
-            dk_unpad,
-            dv_unpad,
-            cu_seqlens_q=cu_seqlens_q,
-            cu_seqlens_k=cu_seqlens_k,
-            max_seqlen_q=max_seqlen_q,
-            max_seqlen_k=max_seqlen_k,
-            dropout_p=ctx.dropout_p,
-            softmax_scale=ctx.softmax_scale,
-            causal=ctx.causal,
-            window_size_left=-1,
-            window_size_right=-1,
-            softcap=0.0,
-            alibi_slopes=None,
-            deterministic=ctx.deterministic,
-            rng_state=None,
-        )
-
-        # k_indices is already available from the unpad_input above —
-        # no need to recompute it for the dk/dv repad.
-        def _repad(dt_unpad: torch.Tensor, indices: torch.Tensor, batch: int, seqlen: int) -> torch.Tensor:
-            padded = pad_input(rearrange(dt_unpad, "nnz h d -> nnz (h d)"), indices, batch, seqlen)
-            return rearrange(padded, "b s (h d) -> b s h d", h=h)
-
-        dq_padded = _repad(dq_unpad, q_indices, b, sq)
-        dk_padded = _repad(dk_unpad, k_indices, b, sk)
-        dv_padded = _repad(dv_unpad, k_indices, b, sk)
-        # 9 inputs total: query, key, value, q_mask, k_mask, causal, dropout_p,
-        # softmax_scale, deterministic.
-        return dq_padded, dk_padded, dv_padded, None, None, None, None, None, None
-
-    torch.library.register_autograd(
-        "fastvideo::_flash_attn_varlen_qk_no_pad_forward",
-        _flash_attn_varlen_qk_no_pad_backward,
-        setup_context=_flash_attn_varlen_qk_no_pad_setup_context,
-    )
-
-    # ---------- public dispatchers (FA2: autograd flows through the op) -----
-
-
-    def flash_attn_no_pad_compilable(qkv,
-                                     key_padding_mask,
-                                     causal=False,
-                                     dropout_p=0.0,
-                                     softmax_scale=None,
-                                     deterministic=False):
-        """dynamo-traceable wrapper around ``flash_attn_no_pad`` (registered op,
-        full register_autograd on FA2 — both inference and training go through
-        the op, no graph break on either)."""
-        out, _ = torch.ops.fastvideo._flash_attn_no_pad_forward(qkv, key_padding_mask, causal, dropout_p, softmax_scale,
-                                                                deterministic)
-        return out
-
-    def flash_attn_varlen_qk_no_pad_compilable(query,
-                                               key,
-                                               value,
-                                               query_padding_mask,
-                                               key_padding_mask,
-                                               causal=False,
-                                               dropout_p=0.0,
-                                               softmax_scale=None,
-                                               deterministic=False):
-        """dynamo-traceable wrapper around ``flash_attn_varlen_qk_no_pad`` (registered
-        op, full register_autograd on FA2)."""
-        out, _ = torch.ops.fastvideo._flash_attn_varlen_qk_no_pad_forward(query, key, value, query_padding_mask,
-                                                                          key_padding_mask, causal, dropout_p,
-                                                                          softmax_scale, deterministic)
-        return out
-
-else:
-    # ---------- FA3 / FA4: carve-out (forward+fake only, no real backward) ---
-    # Same pattern as the parked varlen-extension and the FA3 default leg in
-    # `fastvideo/attention/backends/flash_attn.py`. Real backward for these
-    # versions is a follow-up gated on Hopper / Blackwell box validation.
-
-    @torch.library.custom_op(
-        "fastvideo::_flash_attn_no_pad_forward",
-        mutates_args=(),
-        device_types="cuda",
-    )
-    def _flash_attn_no_pad_forward(
-        qkv: torch.Tensor,
-        key_padding_mask: torch.Tensor,
-        causal: bool,
-        dropout_p: float,
-        softmax_scale: float | None,
-        deterministic: bool,
-    ) -> torch.Tensor:
-        return flash_attn_no_pad(  # type: ignore[no-untyped-call]
-            qkv,
-            key_padding_mask,
-            causal=causal,
-            dropout_p=dropout_p,
-            softmax_scale=softmax_scale,
-            deterministic=deterministic)
-
-    @torch.library.register_fake("fastvideo::_flash_attn_no_pad_forward")
-    def _flash_attn_no_pad_forward_fake(
-        qkv: torch.Tensor,
-        key_padding_mask: torch.Tensor,
-        causal: bool,
-        dropout_p: float,
-        softmax_scale: float | None,
-        deterministic: bool,
-    ) -> torch.Tensor:
-        del key_padding_mask, causal, dropout_p, softmax_scale, deterministic
-        b, s, _three, h, d = qkv.shape
-        return qkv.new_empty(b, s, h, d)
-
-    @torch.library.custom_op(
-        "fastvideo::_flash_attn_varlen_qk_no_pad_forward",
-        mutates_args=(),
-        device_types="cuda",
-    )
-    def _flash_attn_varlen_qk_no_pad_forward(
-        query: torch.Tensor,
-        key: torch.Tensor,
-        value: torch.Tensor,
-        query_padding_mask: torch.Tensor,
-        key_padding_mask: torch.Tensor,
-        causal: bool,
-        dropout_p: float,
-        softmax_scale: float | None,
-        deterministic: bool,
-    ) -> torch.Tensor:
-        return flash_attn_varlen_qk_no_pad(  # type: ignore[no-untyped-call]
-            query,
-            key,
-            value,
-            query_padding_mask=query_padding_mask,
-            key_padding_mask=key_padding_mask,
-            causal=causal,
-            dropout_p=dropout_p,
-            softmax_scale=softmax_scale,
-            deterministic=deterministic)
-
-    @torch.library.register_fake("fastvideo::_flash_attn_varlen_qk_no_pad_forward")
-    def _flash_attn_varlen_qk_no_pad_forward_fake(
-        query: torch.Tensor,
-        key: torch.Tensor,
-        value: torch.Tensor,
-        query_padding_mask: torch.Tensor,
-        key_padding_mask: torch.Tensor,
-        causal: bool,
-        dropout_p: float,
-        softmax_scale: float | None,
-        deterministic: bool,
-    ) -> torch.Tensor:
-        del key, query_padding_mask, key_padding_mask
-        del causal, dropout_p, softmax_scale, deterministic
-        b, sq, h, _ = query.shape
-        # `out`'s head_dim comes from value (d_v), matching the real forward's
-        # output ([b, sq, h, d_v]); it can differ from query's d_q.
-        return query.new_empty(b, sq, h, value.shape[-1])
-
-    def flash_attn_no_pad_compilable(qkv,
-                                     key_padding_mask,
-                                     causal=False,
-                                     dropout_p=0.0,
-                                     softmax_scale=None,
-                                     deterministic=False):
-        if torch.is_grad_enabled() and qkv.requires_grad:
-            return flash_attn_no_pad(qkv,
-                                     key_padding_mask,
-                                     causal=causal,
-                                     dropout_p=dropout_p,
-                                     softmax_scale=softmax_scale,
-                                     deterministic=deterministic)
-        return torch.ops.fastvideo._flash_attn_no_pad_forward(qkv, key_padding_mask, causal, dropout_p, softmax_scale,
-                                                              deterministic)
-
-    def flash_attn_varlen_qk_no_pad_compilable(query,
-                                               key,
-                                               value,
-                                               query_padding_mask,
-                                               key_padding_mask,
-                                               causal=False,
-                                               dropout_p=0.0,
-                                               softmax_scale=None,
-                                               deterministic=False):
-        if torch.is_grad_enabled() and (query.requires_grad or key.requires_grad or value.requires_grad):
-            return flash_attn_varlen_qk_no_pad(query,
-                                               key,
-                                               value,
-                                               query_padding_mask=query_padding_mask,
-                                               key_padding_mask=key_padding_mask,
-                                               causal=causal,
-                                               dropout_p=dropout_p,
-                                               softmax_scale=softmax_scale,
-                                               deterministic=deterministic)
-        return torch.ops.fastvideo._flash_attn_varlen_qk_no_pad_forward(query, key, value, query_padding_mask,
-                                                                        key_padding_mask, causal, dropout_p,
-                                                                        softmax_scale, deterministic)
@@ -1,9 +1,6 @@
 from fastvideo.configs.models.dits.cosmos import CosmosVideoConfig
 from fastvideo.configs.models.dits.cosmos2_5 import Cosmos25VideoConfig
-from fastvideo.configs.models.dits.dreamx_world import DreamXWorldARConfig, DreamXWorldConfig
-from fastvideo.configs.models.dits.flux import FluxDiTConfig
 from fastvideo.configs.models.dits.flux_2 import Flux2Config
-from fastvideo.configs.models.dits.glm_image import GlmImageDiTConfig
 from fastvideo.configs.models.dits.hunyuangamecraft import HunyuanGameCraftConfig
 from fastvideo.configs.models.dits.hunyuanvideo import HunyuanVideoConfig
 from fastvideo.configs.models.dits.hunyuanvideo15 import HunyuanVideo15Config
@@ -16,8 +13,7 @@ from fastvideo.configs.models.dits.hyworld import HYWorldConfig
 from fastvideo.configs.models.dits.kandinsky5 import Kandinsky5VideoConfig

 __all__ = [
-    "HunyuanVideoConfig", "HunyuanVideo15Config", "HunyuanGameCraftConfig", "WanVideoConfig", "DreamXWorldConfig",
-    "DreamXWorldARConfig", "CosmosVideoConfig", "Cosmos25VideoConfig", "FluxDiTConfig", "Flux2Config",
-    "LongCatVideoConfig", "LTX2VideoConfig", "HYWorldConfig", "Kandinsky5VideoConfig", "MagiHumanVideoConfig",
-    "StableAudioConfig", "GlmImageDiTConfig"
+    "HunyuanVideoConfig", "HunyuanVideo15Config", "HunyuanGameCraftConfig", "WanVideoConfig", "CosmosVideoConfig",
+    "Cosmos25VideoConfig", "LongCatVideoConfig", "LTX2VideoConfig", "HYWorldConfig", "Kandinsky5VideoConfig",
+    "MagiHumanVideoConfig", "StableAudioConfig", "Flux2Config"
 ]
@@ -1,119 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-"""Cosmos3 VFM Transformer FastVideo dataclass configs.
-
-Architecture is 1:1 with the published ``nvidia/Cosmos3-Nano`` checkpoint
-(``transformer/config.json``; class ``Cosmos3OmniTransformer`` / framework
-``Cosmos3VFMNetwork``). Field values match that config so the FastVideo native
-DiT builds a parameter tree matching the checkpoint's state-dict surface
-(814 tensors / 44 patterns, validated 2026-06-06).
-
-Reference of record: ``cosmos-framework`` (NVIDIA). The checkpoint is a single
-``layers`` ModuleList of dual-pathway (understanding/text + generation/vision)
-decoder blocks; per layer: ``self_attn`` with und (``to_{q,k,v}``/``to_out``)
-and gen (``add_{q,k,v}_proj``/``to_add_out``) projections + QK-norms, plus
-``mlp`` (und) and ``mlp_moe_gen`` (gen), and four RMSNorms. Top level adds
-``embed_tokens``/``norm``/``norm_moe_gen``/``lm_head``/``proj_in``/``proj_out``/
-``time_embedder`` and dormant ``action_*``/``audio_*`` heads. The checkpoint
-remap lives in ``scripts/checkpoint_conversion/cosmos3_convert.py``.
-"""
-from __future__ import annotations
-
-from dataclasses import dataclass, field
-
-from fastvideo.configs.models.dits.base import DiTArchConfig, DiTConfig
-
-
-def is_cosmos3_transformer_block(name: str, module) -> bool:
-    """FSDP shard boundary: the dual-pathway decoder blocks ``layers.{i}``."""
-    del module
-    parts = name.split(".")
-    return "layers" in parts and parts[-1].isdigit()
-
-
-@dataclass
-class Cosmos3ArchConfig(DiTArchConfig):
-    """Architecture config for the Cosmos3 omni DiT (Cosmos3-Nano).
-
-    1:1 with ``transformer/config.json``. The action/sound heads ship in the
-    checkpoint, so they are constructed for strict-load parity even though the
-    PR1 video path (T2V/I2V/T2I) leaves them dormant.
-    """
-
-    _fsdp_shard_conditions: list = field(default_factory=lambda: [is_cosmos3_transformer_block])
-
-    # Conversion is owned by scripts/checkpoint_conversion/cosmos3_convert.py;
-    # the native module tree is the source of truth for parameter names.
-    param_names_mapping: dict = field(default_factory=dict)
-
-    # ---- Backbone (Qwen3-VL-text) ----
-    hidden_size: int = 4096
-    num_hidden_layers: int = 36
-    num_attention_heads: int = 32
-    num_key_value_heads: int = 8  # GQA (4 query groups)
-    head_dim: int = 128
-    intermediate_size: int = 12288
-    hidden_act: str = "silu"
-    vocab_size: int = 151936
-    rms_norm_eps: float = 1e-6
-    attention_bias: bool = False
-    qk_norm_for_diffusion: bool = True
-    qk_norm_for_text: bool = True
-    use_moe: bool = True  # dual-pathway weights; sparse routing unused
-    joint_attn_implementation: str = "two_way"
-    freeze_und: bool = False
-
-    # ---- Position embedding (unified 3D MRoPE) ----
-    position_embedding_type: str = "unified_3d_mrope"
-    rope_theta: float = 5_000_000.0
-    max_position_embeddings: int = 262144
-    mrope_section: list[int] = field(default_factory=lambda: [24, 20, 20])
-    mrope_interleaved: bool = True
-    unified_3d_mrope_reset_spatial_ids: bool = True
-    temporal_modality_margin: int = 15000  # unified_3d_mrope_temporal_modality_margin
-
-    # ---- VAE / patch geometry ----
-    latent_patch_size: int = 2
-    latent_channel: int = 48
-    patch_latent_dim: int = 192  # latent_patch_size**2 * latent_channel
-
-    # ---- Diffusion conditioning ----
-    timestep_scale: float = 0.001
-
-    # ---- Temporal / FPS modulation ----
-    base_fps: float = 24.0
-    temporal_compression_factor: int = 4
-    enable_fps_modulation: bool = True
-    video_temporal_causal: bool = False
-
-    # ---- Action generation head (dormant in PR1 video path) ----
-    action_gen: bool = True
-    action_dim: int = 64
-    max_action_dim: int = 64
-    num_embodiment_domains: int = 32
-
-    # ---- Sound generation head (dormant in PR1 video path) ----
-    sound_gen: bool = True
-    sound_dim: int = 64
-    sound_latent_fps: float = 25.0
-    temporal_compression_factor_sound: int = 1
-
-    # ---- BaseDiT bookkeeping ----
-    in_channels: int = 48
-    out_channels: int = 48
-
-    def __post_init__(self) -> None:
-        super().__post_init__()
-        # Video DiT contract: latent channels == VAE z_dim.
-        self.num_channels_latents = self.latent_channel
-        if not self.out_channels:
-            self.out_channels = self.in_channels
-        # Derived: patchify packs latent_patch_size**2 spatial patches * channels.
-        self.patch_latent_dim = self.latent_patch_size**2 * self.latent_channel
-
-
-@dataclass
-class Cosmos3VideoConfig(DiTConfig):
-    """Pipeline-level Cosmos3 DiT config (T2V / I2V / T2I share this surface)."""
-
-    arch_config: DiTArchConfig = field(default_factory=Cosmos3ArchConfig)
-    prefix: str = "Cosmos3"
@@ -1,71 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-from dataclasses import dataclass, field
-
-from fastvideo.configs.models.dits.base import DiTArchConfig, DiTConfig
-from fastvideo.configs.models.dits.wanvideo import WanVideoArchConfig
-
-
-@dataclass
-class DreamXWorldArchConfig(WanVideoArchConfig):
-    """DreamX-World DiT config with camera PRoPE control fields."""
-
-    add_control_adapter: bool = True
-    cam_method: str | None = "prope"
-    attn_compress: int = 1
-    cam_self_attn_layers: tuple[int, ...] | None = None
-
-
-@dataclass
-class DreamXWorldConfig(DiTConfig):
-    arch_config: DiTArchConfig = field(default_factory=DreamXWorldArchConfig)
-
-    prefix: str = "Wan"
-
-
-@dataclass
-class DreamXWorldARArchConfig(DreamXWorldArchConfig):
-    """DreamX-World-5B autoregressive causal DiT config."""
-
-    model_type: str = "ti2v"
-    patch_size: tuple[int, int, int] = (1, 2, 2)
-    text_len: int = 512
-    text_dim: int = 4096
-    freq_dim: int = 256
-    attn_compress: int = 4
-    cam_self_attn_layers: tuple[int, ...] | None = tuple(range(30))
-    local_attn_size: int = 12
-    sink_size: int = 3
-    num_frames_per_block: int = 3
-    rope_cache_policy: str = "block_relativistic"
-    # The official AR checkpoint (AMAP-ML/DreamX-World ``model.safetensors``)
-    # already uses FastVideo's native key names and the converter copies the
-    # tensors verbatim, so every rule is an identity. The rules enumerate the
-    # full state-dict surface of ``DreamXWorldARTransformer3DModel`` (norm1 /
-    # norm2 / head.norm are affine-free and have no parameters).
-    param_names_mapping: dict = field(
-        default_factory=lambda: {
-            r"^patch_embedding\.(.*)$": r"patch_embedding.\1",
-            r"^text_embedding\.([02])\.(.*)$": r"text_embedding.\1.\2",
-            r"^time_embedding\.([02])\.(.*)$": r"time_embedding.\1.\2",
-            r"^time_projection\.1\.(.*)$": r"time_projection.1.\1",
-            r"^blocks\.(\d+)\.self_attn\.(q|k|v|o)\.(.*)$": r"blocks.\1.self_attn.\2.\3",
-            r"^blocks\.(\d+)\.self_attn\.norm_(q|k)\.weight$": r"blocks.\1.self_attn.norm_\2.weight",
-            r"^blocks\.(\d+)\.cross_attn\.(q|k|v|o)\.(.*)$": r"blocks.\1.cross_attn.\2.\3",
-            r"^blocks\.(\d+)\.cross_attn\.norm_(q|k)\.weight$": r"blocks.\1.cross_attn.norm_\2.weight",
-            r"^blocks\.(\d+)\.cam_self_attn\.(q_proj|k_proj|v_proj|out_proj)\.(.*)$": r"blocks.\1.cam_self_attn.\2.\3",
-            r"^blocks\.(\d+)\.cam_self_attn\.norm_(q|k)\.weight$": r"blocks.\1.cam_self_attn.norm_\2.weight",
-            r"^blocks\.(\d+)\.norm3\.(.*)$": r"blocks.\1.norm3.\2",
-            r"^blocks\.(\d+)\.ffn\.([02])\.(.*)$": r"blocks.\1.ffn.\2.\3",
-            r"^blocks\.(\d+)\.modulation$": r"blocks.\1.modulation",
-            r"^head\.head\.(.*)$": r"head.head.\1",
-            r"^head\.modulation$": r"head.modulation",
-        })
-    reverse_param_names_mapping: dict = field(default_factory=dict)
-    lora_param_names_mapping: dict = field(default_factory=dict)
-
-
-@dataclass
-class DreamXWorldARConfig(DreamXWorldConfig):
-    arch_config: DiTArchConfig = field(default_factory=DreamXWorldARArchConfig)
-
-    prefix: str = "Wan"
@@ -1,27 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-
-from dataclasses import dataclass, field
-
-from fastvideo.configs.models.dits.base import DiTArchConfig, DiTConfig
-
-
-@dataclass
-class FluxTransformer2DArchConfig(DiTArchConfig):
-
-    patch_size: int = 1
-    in_channels: int = 64
-    out_channels: int | None = None
-    num_layers: int = 19
-    num_single_layers: int = 38
-    attention_head_dim: int = 128
-    num_attention_heads: int = 24
-    joint_attention_dim: int = 4096
-    pooled_projection_dim: int = 768
-    guidance_embeds: bool = True
-    axes_dims_rope: tuple[int, int, int] = (16, 56, 56)
-
-
-@dataclass
-class FluxDiTConfig(DiTConfig):
-    arch_config: DiTArchConfig = field(default_factory=FluxTransformer2DArchConfig)
-    prefix: str = "flux"
@@ -1,61 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-from dataclasses import dataclass, field
-
-from fastvideo.configs.models.dits.base import DiTArchConfig, DiTConfig
-
-
-def is_blocks(n: str, m) -> bool:
-    return "transformer_blocks" in n and str.isdigit(n.split(".")[-1])
-
-
-@dataclass
-class GlmImageDiTArchConfig(DiTArchConfig):
-
-    _fsdp_shard_conditions: list = field(default_factory=lambda: [is_blocks])
-
-    hidden_size: int = 4096
-    num_attention_heads: int = 32
-    attention_head_dim: int = 128
-    in_channels: int = 16
-    out_channels: int = 16
-    num_layers: int = 30
-
-    text_embed_dim: int = 1472
-    time_embed_dim: int = 512
-    condition_dim: int = 256
-
-    prior_vq_quantizer_codebook_size: int = 16384
-
-    patch_size: int = 2
-
-    max_height: int = 2048
-    max_width: int = 2048
-
-    qk_norm: str = "layer_norm"
-    eps: float = 1e-5
-
-    exclude_lora_layers: list[str] = field(
-        default_factory=lambda: ["image_projector", "glyph_projector", "prior_token_embedding"])
-
-    param_names_mapping: dict = field(
-        default_factory=lambda: {
-            r"^glyph_projector\.net\.0\.proj\.(.*)$": r"glyph_projector.fc_in.\1",
-            r"^glyph_projector\.net\.2\.(.*)$": r"glyph_projector.fc_out.\1",
-            r"^prior_projector\.net\.0\.proj\.(.*)$": r"prior_projector.fc_in.\1",
-            r"^prior_projector\.net\.2\.(.*)$": r"prior_projector.fc_out.\1",
-            r"^transformer_blocks\.(\d+)\.ff\.net\.0\.proj\.(.*)$": r"transformer_blocks.\1.ff.fc_in.\2",
-            r"^transformer_blocks\.(\d+)\.ff\.net\.2\.(.*)$": r"transformer_blocks.\1.ff.fc_out.\2",
-        })
-
-    reverse_param_names_mapping: dict = field(default_factory=dict)
-    lora_param_names_mapping: dict = field(default_factory=dict)
-
-    def __post_init__(self):
-        super().__post_init__()
-        self.num_channels_latents = self.out_channels
-
-
-@dataclass
-class GlmImageDiTConfig(DiTConfig):
-    arch_config: DiTArchConfig = field(default_factory=GlmImageDiTArchConfig)
-    prefix: str = "GlmImage"
@@ -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
@@ -1,6 +1,5 @@
 # SPDX-License-Identifier: Apache-2.0
 from dataclasses import dataclass, field
-from typing import Literal

 from fastvideo.configs.models.dits.base import DiTArchConfig, DiTConfig

@@ -20,11 +19,6 @@ class WanVideoArchConfig(DiTArchConfig):
            r"^condition_embedder\.text_embedder\.linear_2\.(.*)$": r"condition_embedder.text_embedder.fc_out.\1",
            r"^condition_embedder\.time_embedder\.linear_1\.(.*)$": r"condition_embedder.time_embedder.mlp.fc_in.\1",
            r"^condition_embedder\.time_embedder\.linear_2\.(.*)$": r"condition_embedder.time_embedder.mlp.fc_out.\1",
-            # AnyFlow dual-timestep checkpoints expose delta_embedder weights with the
-            # same internal layout as time_embedder. The regex is harmless on plain
-            # Wan checkpoints (no delta_embedder keys to match).
-            r"^condition_embedder\.delta_embedder\.linear_1\.(.*)$": r"condition_embedder.delta_embedder.mlp.fc_in.\1",
-            r"^condition_embedder\.delta_embedder\.linear_2\.(.*)$": r"condition_embedder.delta_embedder.mlp.fc_out.\1",
            r"^condition_embedder\.time_proj\.(.*)$": r"condition_embedder.time_modulation.linear.\1",
            r"^condition_embedder\.image_embedder\.ff\.net\.0\.proj\.(.*)$":
            r"condition_embedder.image_embedder.ff.fc_in.\1",
@@ -92,14 +86,6 @@ class WanVideoArchConfig(DiTArchConfig):
    # "relativistic" keeps long rollouts in-distribution; a no-op unless sink_size > 0 and local_attn_size > 0.
    rope_cache_policy: str = "absolute"

-    # AnyFlow dual-timestep conditioning. Defaults preserve bit-identity with
-    # the legacy single-timestep forward (no delta_embedder allocated, no
-    # extra computation on the embedder forward path).
-    r_embedder: bool = False
-    r_embedder_fusion: Literal["additive", "gated"] = "additive"
-    r_embedder_gate_value: float = 0.25
-    r_embedder_deltatime_type: Literal["r", "t-r"] = "r"
-
    def __post_init__(self):
        super().__post_init__()
        self.out_channels = self.out_channels or self.in_channels
@@ -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
@@ -1,9 +1,7 @@
 from fastvideo.configs.models.vaes.cosmosvae import CosmosVAEConfig
 from fastvideo.configs.models.vaes.cosmos2_5vae import Cosmos25VAEConfig
-from fastvideo.configs.models.vaes.cosmos3vae import Cosmos3VAEConfig
 from fastvideo.configs.models.vaes.gamecraftvae import GameCraftVAEConfig
 from fastvideo.configs.models.vaes.gen3cvae import Gen3CVAEConfig
-from fastvideo.configs.models.vaes.glm_image import GlmImageVAEConfig
 from fastvideo.configs.models.vaes.hunyuanvae import HunyuanVAEConfig
 from fastvideo.configs.models.vaes.hunyuan15vae import Hunyuan15VAEConfig
 from fastvideo.configs.models.vaes.ltx2vae import LTX2VAEConfig
@@ -17,12 +15,10 @@ __all__ = [
    "WanVAEConfig",
    "CosmosVAEConfig",
    "Cosmos25VAEConfig",
-    "Cosmos3VAEConfig",
    "Gen3CVAEConfig",
    "Hunyuan15VAEConfig",
    "LTX2VAEConfig",
    "OobleckVAEArchConfig",
    "OobleckVAEConfig",
    "Flux2VAEConfig",
-    "GlmImageVAEConfig",
 ]
@@ -1,277 +0,0 @@
-"""Cosmos3 (Wan2.2-TI2V-5B) VAE config and checkpoint-key mapping.
-
-The Cosmos3 checkpoint VAE is literally ``Wan-AI/Wan2.2-TI2V-5B-Diffusers``
-(diffusers ``AutoencoderKLWan``), so this config locks the Wan2.2 geometry:
-residual down/up blocks, ``patch_size=2``, ``z_dim=48``, ``base_dim=160``,
-``decoder_base_dim=256``, and ``scale_factor_spatial=16``. The 48-dim
-``latents_mean``/``latents_std`` are taken verbatim from the Cosmos3
-checkpoint's ``vae/config.json`` (identical to the canonical Wan2.2-TI2V-5B
-statistics).
-
-Mirrors the :class:`Cosmos25VAEArchConfig` pattern. ``param_names_mapping`` /
-``map_official_key`` translate the *official* Wan2.2 VAE state-dict keys
-(nested-residual naming, e.g. ``encoder.downsamples.{b}.downsamples.{j}`` and
-``decoder.upsamples.{b}.upsamples.{j}``) into FastVideo's ``AutoencoderKLWan``
-key space. The standard diffusers checkpoint already ships native FastVideo
-keys, so these helpers exist for parity tooling and official ``.pth`` loading.
-"""
-
-from __future__ import annotations
-
-import re
-from dataclasses import dataclass, field
-
-from fastvideo.configs.models.vaes.wanvae import WanVAEArchConfig, WanVAEConfig
-
-
-@dataclass
-class Cosmos3VAEArchConfig(WanVAEArchConfig):
-    # Wan2.2-TI2V-5B geometry (differs from the Wan2.1 WanVAEArchConfig
-    # defaults: residual blocks, patch_size=2, z_dim=48, base_dim=160,
-    # decoder_base_dim=256, scale_factor_spatial=16, 12 patch channels).
-    _name_or_path: str = "Wan-AI/Wan2.2-TI2V-5B-Diffusers"
-    base_dim: int = 160
-    decoder_base_dim: int | None = 256
-    z_dim: int = 48
-    dim_mult: tuple[int, ...] = (1, 2, 4, 4)
-    num_res_blocks: int = 2
-    attn_scales: tuple[float, ...] = ()
-    temperal_downsample: tuple[bool, ...] = (False, True, True)
-    dropout: float = 0.0
-    is_residual: bool = True
-    in_channels: int = 12
-    out_channels: int = 12
-    patch_size: int | None = 2
-    scale_factor_temporal: int = 4
-    scale_factor_spatial: int = 16
-    clip_output: bool = False
-
-    # 48-dim statistics copied verbatim from the Cosmos3 checkpoint
-    # (official_weights/cosmos3/vae/config.json).
-    latents_mean: tuple[float, ...] = (
-        -0.2289,
-        -0.0052,
-        -0.1323,
-        -0.2339,
-        -0.2799,
-        0.0174,
-        0.1838,
-        0.1557,
-        -0.1382,
-        0.0542,
-        0.2813,
-        0.0891,
-        0.157,
-        -0.0098,
-        0.0375,
-        -0.1825,
-        -0.2246,
-        -0.1207,
-        -0.0698,
-        0.5109,
-        0.2665,
-        -0.2108,
-        -0.2158,
-        0.2502,
-        -0.2055,
-        -0.0322,
-        0.1109,
-        0.1567,
-        -0.0729,
-        0.0899,
-        -0.2799,
-        -0.123,
-        -0.0313,
-        -0.1649,
-        0.0117,
-        0.0723,
-        -0.2839,
-        -0.2083,
-        -0.052,
-        0.3748,
-        0.0152,
-        0.1957,
-        0.1433,
-        -0.2944,
-        0.3573,
-        -0.0548,
-        -0.1681,
-        -0.0667,
-    )
-    latents_std: tuple[float, ...] = (
-        0.4765,
-        1.0364,
-        0.4514,
-        1.1677,
-        0.5313,
-        0.499,
-        0.4818,
-        0.5013,
-        0.8158,
-        1.0344,
-        0.5894,
-        1.0901,
-        0.6885,
-        0.6165,
-        0.8454,
-        0.4978,
-        0.5759,
-        0.3523,
-        0.7135,
-        0.6804,
-        0.5833,
-        1.4146,
-        0.8986,
-        0.5659,
-        0.7069,
-        0.5338,
-        0.4889,
-        0.4917,
-        0.4069,
-        0.4999,
-        0.6866,
-        0.4093,
-        0.5709,
-        0.6065,
-        0.6415,
-        0.4944,
-        0.5726,
-        1.2042,
-        0.5458,
-        1.6887,
-        0.3971,
-        1.06,
-        0.3943,
-        0.5537,
-        0.5444,
-        0.4089,
-        0.7468,
-        0.7744,
-    )
-
-    # Simple 1:1 renames. The nested-residual block remapping (encoder
-    # downsamples / decoder upsamples / middle / head) is handled by
-    # ``map_official_key()``.
-    param_names_mapping: dict[str, str] = field(
-        default_factory=lambda: {
-            r"^conv1\.(.*)$": r"quant_conv.\1",
-            r"^conv2\.(.*)$": r"post_quant_conv.\1",
-            r"^encoder\.conv1\.(.*)$": r"encoder.conv_in.\1",
-            r"^decoder\.conv1\.(.*)$": r"decoder.conv_in.\1",
-            r"^encoder\.head\.0\.gamma$": r"encoder.norm_out.gamma",
-            r"^encoder\.head\.2\.(.*)$": r"encoder.conv_out.\1",
-            r"^decoder\.head\.0\.gamma$": r"decoder.norm_out.gamma",
-            r"^decoder\.head\.2\.(.*)$": r"decoder.conv_out.\1",
-        })
-
-    @staticmethod
-    def map_official_key(key: str) -> str | None:
-        """Map a single official Wan2.2 VAE key into FastVideo key space.
-
-        Handles the residual (Wan2.2) module layout where each down/up block
-        is a nested ``Sequential`` (``downsamples.{b}.downsamples.{j}`` /
-        ``upsamples.{b}.upsamples.{j}``) rather than the flat Wan2.1 indexing.
-        Returns ``None`` for keys with no FastVideo counterpart.
-        """
-
-        def map_residual_subkey(prefix: str, sub: str) -> str | None:
-            if re.match(r"^residual\.0\.gamma$", sub):
-                return f"{prefix}.norm1.gamma"
-            m = re.match(r"^residual\.2\.(weight|bias)$", sub)
-            if m:
-                return f"{prefix}.conv1.{m.group(1)}"
-            if re.match(r"^residual\.3\.gamma$", sub):
-                return f"{prefix}.norm2.gamma"
-            m = re.match(r"^residual\.6\.(weight|bias)$", sub)
-            if m:
-                return f"{prefix}.conv2.{m.group(1)}"
-            m = re.match(r"^shortcut\.(weight|bias)$", sub)
-            if m:
-                return f"{prefix}.conv_shortcut.{m.group(1)}"
-            return None
-
-        def map_attn_subkey(prefix: str, sub: str) -> str | None:
-            if re.match(r"^norm\.gamma$", sub):
-                return f"{prefix}.norm.gamma"
-            m = re.match(r"^to_qkv\.(weight|bias)$", sub)
-            if m:
-                return f"{prefix}.to_qkv.{m.group(1)}"
-            m = re.match(r"^proj\.(weight|bias)$", sub)
-            if m:
-                return f"{prefix}.proj.{m.group(1)}"
-            return None
-
-        def map_resample_subkey(prefix: str, sub: str) -> str | None:
-            m = re.match(r"^resample\.1\.(weight|bias)$", sub)
-            if m:
-                return f"{prefix}.resample.1.{m.group(1)}"
-            m = re.match(r"^time_conv\.(weight|bias)$", sub)
-            if m:
-                return f"{prefix}.time_conv.{m.group(1)}"
-            return None
-
-        m = re.match(r"^conv1\.(weight|bias)$", key)
-        if m:
-            return f"quant_conv.{m.group(1)}"
-        m = re.match(r"^conv2\.(weight|bias)$", key)
-        if m:
-            return f"post_quant_conv.{m.group(1)}"
-        m = re.match(r"^(encoder|decoder)\.conv1\.(weight|bias)$", key)
-        if m:
-            return f"{m.group(1)}.conv_in.{m.group(2)}"
-        m = re.match(r"^(encoder|decoder)\.head\.0\.gamma$", key)
-        if m:
-            return f"{m.group(1)}.norm_out.gamma"
-        m = re.match(r"^(encoder|decoder)\.head\.2\.(weight|bias)$", key)
-        if m:
-            return f"{m.group(1)}.conv_out.{m.group(2)}"
-
-        m = re.match(r"^(encoder|decoder)\.middle\.0\.(.*)$", key)
-        if m:
-            return map_residual_subkey(f"{m.group(1)}.mid_block.resnets.0", m.group(2))
-        m = re.match(r"^(encoder|decoder)\.middle\.1\.(.*)$", key)
-        if m:
-            return map_attn_subkey(f"{m.group(1)}.mid_block.attentions.0", m.group(2))
-        m = re.match(r"^(encoder|decoder)\.middle\.2\.(.*)$", key)
-        if m:
-            return map_residual_subkey(f"{m.group(1)}.mid_block.resnets.1", m.group(2))
-
-        # Encoder: downsamples.{block}.downsamples.{j}.* (nested residual layout)
-        m = re.match(r"^encoder\.downsamples\.(\d+)\.downsamples\.(\d+)\.(.*)$", key)
-        if m:
-            block_i, res_i, sub = int(m.group(1)), int(m.group(2)), m.group(3)
-            if sub.startswith("resample.") or sub.startswith("time_conv."):
-                return map_resample_subkey(f"encoder.down_blocks.{block_i}.downsampler", sub)
-            return map_residual_subkey(f"encoder.down_blocks.{block_i}.resnets.{res_i}", sub)
-
-        # Decoder: upsamples.{block}.upsamples.{j}.* (nested residual layout)
-        m = re.match(r"^decoder\.upsamples\.(\d+)\.upsamples\.(\d+)\.(.*)$", key)
-        if m:
-            block_i, res_i, sub = int(m.group(1)), int(m.group(2)), m.group(3)
-            if sub.startswith("resample.") or sub.startswith("time_conv."):
-                return map_resample_subkey(f"decoder.up_blocks.{block_i}.upsampler", sub)
-            return map_residual_subkey(f"decoder.up_blocks.{block_i}.resnets.{res_i}", sub)
-
-        return None
-
-    # ``__post_init__`` (scaling_factor / shift_factor / compression ratios) is
-    # inherited unchanged from ``WanVAEArchConfig``.
-
-
-@dataclass
-class Cosmos3VAEConfig(WanVAEConfig):
-    """Cosmos3 VAE config (reuses FastVideo's Wan2.2 ``AutoencoderKLWan``).
-
-    Subclasses :class:`WanVAEConfig` so the model reads the same runtime flags
-    (``use_feature_cache``, ``use_light_vae``, tiling) and only swaps in the
-    Cosmos3 = Wan2.2 ``arch_config``.
-    """
-
-    arch_config: Cosmos3VAEArchConfig = field(default_factory=Cosmos3VAEArchConfig)
-
-    use_feature_cache: bool = True
-    use_tiling: bool = False
-    use_temporal_tiling: bool = False
-    use_parallel_tiling: bool = False
-
-    # ``__post_init__`` (blend_num_frames) is inherited from ``WanVAEConfig``.
@@ -1,95 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-from __future__ import annotations
-
-from dataclasses import dataclass, field
-
-from fastvideo.configs.models.vaes.autoencoder_kl import (AutoencoderKLArchConfig, AutoencoderKLVAEConfig)
-
-_GLM_IMAGE_LATENTS_MEAN: tuple[float, ...] = (
-    -0.2080078125,
-    1.875,
-    -0.470703125,
-    -1.265625,
-    -1.421875,
-    0.77734375,
-    -0.3671875,
-    -0.9453125,
-    0.318359375,
-    0.7734375,
-    -0.1884765625,
-    -0.022216796875,
-    -0.220703125,
-    -1.59375,
-    -0.81640625,
-    -0.255859375,
-)
-_GLM_IMAGE_LATENTS_STD: tuple[float, ...] = (
-    3.0625,
-    2.203125,
-    2.265625,
-    4.84375,
-    2.5,
-    3.9375,
-    2.203125,
-    3.03125,
-    2.1875,
-    2.046875,
-    2.71875,
-    2.390625,
-    2.390625,
-    2.453125,
-    2.25,
-    2.15625,
-)
-
-
-@dataclass
-class GlmImageVAEArchConfig(AutoencoderKLArchConfig):
-    act_fn: str = "silu"
-    block_out_channels: tuple[int, ...] = (128, 512, 1024, 1024)
-    down_block_types: tuple[str, ...] = (
-        "DownEncoderBlock2D",
-        "DownEncoderBlock2D",
-        "DownEncoderBlock2D",
-        "DownEncoderBlock2D",
-    )
-    up_block_types: tuple[str, ...] = (
-        "UpDecoderBlock2D",
-        "UpDecoderBlock2D",
-        "UpDecoderBlock2D",
-        "UpDecoderBlock2D",
-    )
-    force_upcast: bool = True
-    in_channels: int = 3
-    out_channels: int = 3
-    latent_channels: int = 16
-    latents_mean: tuple[float, ...] = _GLM_IMAGE_LATENTS_MEAN
-    latents_std: tuple[float, ...] = _GLM_IMAGE_LATENTS_STD
-    layers_per_block: int = 3
-    mid_block_add_attention: bool = False
-    norm_num_groups: int = 32
-    sample_size: int = 1024
-    scaling_factor: float = 0.18215
-    shift_factor: float | None = None
-    use_quant_conv: bool = False
-    use_post_quant_conv: bool = False
-
-    temporal_compression_ratio: int = 1
-    spatial_compression_ratio: int = 8
-
-
-@dataclass
-class GlmImageVAEConfig(AutoencoderKLVAEConfig):
-    arch_config: GlmImageVAEArchConfig = field(default_factory=GlmImageVAEArchConfig)
-
-    use_tiling: bool = True
-    use_temporal_tiling: bool = False
-    use_parallel_tiling: bool = False
-
-    tile_sample_min_height: int = 512
-    tile_sample_min_width: int = 512
-    tile_sample_stride_height: int = 384
-    tile_sample_stride_width: int = 384
-
-    load_encoder: bool = True
-    load_decoder: bool = True
@@ -1,12 +1,10 @@
 from fastvideo.configs.pipelines.base import PipelineConfig
 from fastvideo.configs.pipelines.cosmos import CosmosConfig
 from fastvideo.configs.pipelines.cosmos2_5 import Cosmos25Config
-from fastvideo.configs.pipelines.dreamx_world import DreamXWorld5BARPipelineConfig, DreamXWorld5BCamPipelineConfig
 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 +16,5 @@ __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"
+    "HYWorldConfig", "MatrixGame2I2V480PConfig", "MatrixGame3I2V720PConfig", "get_pipeline_config_cls_from_name"
 ]
@@ -1,69 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-"""Cosmos3 pipeline configuration.
-
-Reference of record: the official ``cosmos-framework`` / ``nvidia/Cosmos3-Nano``
-checkpoint (``model_index.json``). Cosmos3 is structurally different from
-Cosmos 2.5:
-
- Dual-pathway (UND + GEN) DiT lives entirely inside ``Cosmos3VFMTransformer``
-  (``Cosmos3VideoConfig``).
- No separate text encoder — the Qwen3-VL-text backbone is inside the DiT, so
-  ``text_encoder_configs`` is the empty tuple. The Qwen2 tokenizer is loaded as
-  the ``text_tokenizer`` checkpoint module by the component loader.
- VAE is Wan2.2 ``AutoencoderKLWan`` (z_dim=48, scale_factor_spatial=16),
-  configured by ``Cosmos3VAEConfig`` (the checkpoint's exact latents_mean/std).
- Scheduler is FastVideo-native ``UniPCMultistepScheduler`` configured for
-  pure flow matching (flow_prediction, use_flow_sigmas), equivalent to the
-  framework's ``FlowUniPCMultistepScheduler``. The checkpoint's diffusers-style
-  scheduler config (karras/sigma_min/max) is coerced to the flow setup in
-  ``Cosmos3OmniDiffusersPipeline.initialize_pipeline``.
- T2I default ``flow_shift`` is 3.0 (set per-request by ``_set_flow_shift``);
-  T2V/I2V use the engine-init default of 1.0 baked into this config.
-"""
-from collections.abc import Callable
-from dataclasses import dataclass, field
-
-import torch
-
-from fastvideo.configs.models import DiTConfig, EncoderConfig, VAEConfig
-from fastvideo.configs.models.dits.cosmos3 import (Cosmos3ArchConfig, Cosmos3VideoConfig)
-from fastvideo.configs.models.encoders import BaseEncoderOutput
-from fastvideo.configs.models.vaes import Cosmos3VAEConfig  # Wan2.2 AutoencoderKLWan
-from fastvideo.configs.pipelines.base import PipelineConfig
-
-
-@dataclass
-class Cosmos3Config(PipelineConfig):
-    """Configuration for the Cosmos3 video generation pipeline (T2V/I2V/T2I).
-
-    Wires the framework-parity-verified Cosmos3 components: the native
-    ``Cosmos3VideoConfig`` DiT, the Wan2.2 ``Cosmos3VAEConfig`` VAE, the Qwen2
-    tokenizer (loaded as ``text_tokenizer``), and the UniPC scheduler.
-    """
-
-    dit_config: DiTConfig = field(default_factory=lambda: Cosmos3VideoConfig(arch_config=Cosmos3ArchConfig()))
-
-    vae_config: VAEConfig = field(default_factory=Cosmos3VAEConfig)
-
-    # No separate text encoder: the Qwen3-VL-text backbone lives inside the DiT
-    # and the pipeline tokenizes in Cosmos3DenoisingStage, so all three
-    # text-encoder lists are empty (the generic text-encode stage is not used).
-    text_encoder_configs: tuple[EncoderConfig, ...] = field(default_factory=tuple)
-    preprocess_text_funcs: tuple[Callable[[str], str], ...] = field(default_factory=tuple)
-    postprocess_text_funcs: tuple[Callable[[BaseEncoderOutput], torch.Tensor], ...] = field(default_factory=tuple)
-
-    dit_precision: str = "bf16"
-    vae_precision: str = "bf16"
-    text_encoder_precisions: tuple[str, ...] = field(default_factory=tuple)
-
-    embedded_cfg_scale: float = 0.0
-    # T2V/I2V engine-init flow_shift (framework text2video/image2video default);
-    # T2I overrides to 3.0 per request via Cosmos3DenoisingStage._set_flow_shift.
-    flow_shift: float = 10.0
-
-    vae_tiling: bool = False
-    vae_sp: bool = False
-
-    def __post_init__(self):
-        self.vae_config.load_encoder = True
-        self.vae_config.load_decoder = True
@@ -1,127 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-"""DreamX-World-5B-Cam FastVideo model configuration helpers."""
-
-from collections.abc import Callable
-from dataclasses import dataclass, field
-
-import torch
-
-from fastvideo.configs.models import DiTConfig, EncoderConfig, VAEConfig
-from fastvideo.configs.models.dits.dreamx_world import (DreamXWorldARArchConfig, DreamXWorldARConfig,
-                                                        DreamXWorldArchConfig, DreamXWorldConfig)
-from fastvideo.configs.models.encoders import BaseEncoderOutput, T5Config
-from fastvideo.configs.models.encoders.t5 import T5ArchConfig
-from fastvideo.configs.models.vaes import WanVAEConfig
-from fastvideo.configs.pipelines.base import PipelineConfig
-from fastvideo.configs.pipelines.wan import LucyEditDevConfig, t5_postprocess_text
-
-
-def make_dreamx_world_5b_cam_dit_config() -> DreamXWorldConfig:
-    """Return the DreamX-World DiT config matching DreamX-World-5B-Cam."""
-    return DreamXWorldConfig(arch_config=DreamXWorldArchConfig(
-        num_attention_heads=24,
-        attention_head_dim=128,
-        in_channels=48,
-        out_channels=48,
-        ffn_dim=14336,
-        num_layers=30,
-        cross_attn_norm=True,
-        qk_norm="rms_norm_across_heads",
-        add_control_adapter=True,
-        cam_method="prope",
-        attn_compress=1,
-        cam_self_attn_layers=None,
-    ))
-
-
-def make_dreamx_world_5b_ar_dit_config() -> DreamXWorldARConfig:
-    """Return the DreamX-World-5B autoregressive causal DiT config."""
-    return DreamXWorldARConfig(arch_config=DreamXWorldARArchConfig(
-        model_type="ti2v",
-        num_attention_heads=24,
-        attention_head_dim=128,
-        in_channels=48,
-        out_channels=48,
-        ffn_dim=14336,
-        num_layers=30,
-        cross_attn_norm=True,
-        qk_norm=True,
-        add_control_adapter=True,
-        cam_method="prope",
-        attn_compress=4,
-        cam_self_attn_layers=tuple(range(30)),
-        local_attn_size=12,
-        sink_size=3,
-        num_frames_per_block=3,
-    ))
-
-
-def make_dreamx_world_5b_cam_vae_config() -> WanVAEConfig:
-    """Return the Wan2.2 48-channel VAE config used by DreamX-World-5B-Cam."""
-    return LucyEditDevConfig().vae_config
-
-
-def make_dreamx_world_5b_cam_text_encoder_config() -> T5Config:
-    """Return the UMT5-XXL text encoder config used by DreamX-World-5B-Cam."""
-    return T5Config(
-        arch_config=T5ArchConfig(
-            vocab_size=256384,
-            d_model=4096,
-            d_kv=64,
-            d_ff=10240,
-            num_layers=24,
-            num_decoder_layers=None,
-            num_heads=64,
-            relative_attention_num_buckets=32,
-            dropout_rate=0.0,
-            text_len=512,
-            feed_forward_proj="gelu",
-            is_encoder_decoder=False,
-        ),
-        prefix="umt5",
-    )
-
-
-@dataclass
-class DreamXWorld5BCamPipelineConfig(PipelineConfig):
-    """Pipeline config for the first-scope DreamX-World-5B-Cam mode."""
-
-    dit_config: DiTConfig = field(default_factory=make_dreamx_world_5b_cam_dit_config)
-    vae_config: VAEConfig = field(default_factory=make_dreamx_world_5b_cam_vae_config)
-    text_encoder_configs: tuple[EncoderConfig,
-                                ...] = field(default_factory=lambda: (make_dreamx_world_5b_cam_text_encoder_config(), ))
-    postprocess_text_funcs: tuple[Callable[[BaseEncoderOutput], torch.Tensor],
-                                  ...] = field(default_factory=lambda: (t5_postprocess_text, ))
-    text_encoder_precisions: tuple[str, ...] = field(default_factory=lambda: ("bf16", ))
-    flow_shift: float | None = 3.0
-    ti2v_task: bool = True
-    expand_timesteps: bool = True
-    vae_tiling: bool = False
-    vae_sp: bool = False
-    vae_precision: str = "fp32"
-    vae_decode_precision: str | None = "bf16"
-    dit_precision: str = "bf16"
-
-    def __post_init__(self) -> None:
-        self.vae_config.load_encoder = True
-        self.vae_config.load_decoder = True
-        self.dit_config.expand_timesteps = self.expand_timesteps
-
-
-@dataclass
-class DreamXWorld5BARPipelineConfig(DreamXWorld5BCamPipelineConfig):
-    """Pipeline config for DreamX-World-5B autoregressive forcing."""
-
-    dit_config: DiTConfig = field(default_factory=make_dreamx_world_5b_ar_dit_config)
-    flow_shift: float | None = 5.0
-    ti2v_task: bool = True
-    is_causal: bool = True
-    dmd_denoising_steps: tuple[int, ...] = (1000, 750, 500, 250)
-    warp_denoising_step: bool = True
-    context_noise: float = 0.1
-    num_frames_per_block: int = 3
-    color_correction_strength: float = 1.0
-
-    def __post_init__(self) -> None:
-        super().__post_init__()
-        self.dit_config.expand_timesteps = True
@@ -1,74 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-
-from __future__ import annotations
-
-from collections.abc import Callable
-from dataclasses import dataclass, field
-
-import torch
-
-from fastvideo.configs.models import EncoderConfig
-from fastvideo.configs.models.dits.flux import FluxDiTConfig
-from fastvideo.configs.models.encoders import (
-    BaseEncoderOutput,
-    CLIPTextConfig,
-    T5LargeConfig,
-)
-from fastvideo.configs.models.vaes.autoencoder_kl import AutoencoderKLVAEConfig
-from fastvideo.configs.pipelines.base import PipelineConfig, preprocess_text
-
-
-def _flux_clip_pooled_postprocess(outputs: BaseEncoderOutput) -> torch.Tensor:
-    """CLIP branch for FLUX: Diffusers uses pooled prompt embeddings only."""
-    if outputs.pooler_output is None:
-        raise RuntimeError(
-            "FLUX CLIP conditioning requires pooler_output. Ensure the CLIP text encoder returns pooled features.")
-    return outputs.pooler_output
-
-
-def _flux_t5_sequence_postprocess(outputs: BaseEncoderOutput) -> torch.Tensor:
-    if outputs.last_hidden_state is None:
-        raise RuntimeError("FLUX T5 conditioning requires last_hidden_state.")
-    return outputs.last_hidden_state
-
-
-@dataclass
-class FluxPipelineConfig(PipelineConfig):
-    """Pipeline layout for Diffusers FLUX.1-dev (CLIP + T5 + packed DiT + FlowMatch)."""
-
-    scheduler_arch: str = "FlowMatchEulerDiscreteScheduler"
-    transformer_arch: str = "FluxTransformer2DModel"
-    vae_arch: str = "AutoencoderKL"
-    text_encoder_archs: tuple[str, ...] = ("CLIPTextModel", "T5EncoderModel")
-    tokenizer_archs: tuple[str, ...] = ("CLIPTokenizer", "T5TokenizerFast")
-
-    dit_config: FluxDiTConfig = field(default_factory=FluxDiTConfig)
-    vae_config: AutoencoderKLVAEConfig = field(default_factory=AutoencoderKLVAEConfig)
-
-    embedded_cfg_scale: float = 3.5
-    flow_shift: float | None = None
-
-    text_encoder_configs: tuple[EncoderConfig, ...] = field(default_factory=lambda: (CLIPTextConfig(), T5LargeConfig()))
-    preprocess_text_funcs: tuple[Callable[[str], str],
-                                 ...] = field(default_factory=lambda: (preprocess_text, preprocess_text))
-    postprocess_text_funcs: tuple[Callable[[BaseEncoderOutput], torch.Tensor], ...] = field(
-        default_factory=lambda: (_flux_clip_pooled_postprocess, _flux_t5_sequence_postprocess))
-
-    dit_precision: str = "bf16"
-    vae_precision: str = "fp32"
-    text_encoder_precisions: tuple[str, ...] = field(default_factory=lambda: ("fp32", "bf16"))
-
-    def __post_init__(self) -> None:
-        te_cfgs = list(self.text_encoder_configs)
-        if len(te_cfgs) >= 1:
-            te_cfgs[0].tokenizer_kwargs.setdefault("padding", "max_length")
-            te_cfgs[0].tokenizer_kwargs.setdefault("max_length", 77)
-            te_cfgs[0].tokenizer_kwargs.setdefault("truncation", True)
-            te_cfgs[0].tokenizer_kwargs.setdefault("return_tensors", "pt")
-        if len(te_cfgs) >= 2:
-            cap = 512
-            te_cfgs[1].tokenizer_kwargs["max_length"] = min(int(te_cfgs[1].tokenizer_kwargs.get("max_length", cap)),
-                                                            cap)
-            te_cfgs[1].tokenizer_kwargs.setdefault("padding", "max_length")
-            te_cfgs[1].tokenizer_kwargs.setdefault("truncation", True)
-            te_cfgs[1].tokenizer_kwargs.setdefault("return_tensors", "pt")
@@ -1,46 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-from collections.abc import Callable
-from dataclasses import dataclass, field
-
-import torch
-
-from fastvideo.configs.models import DiTConfig, EncoderConfig, VAEConfig
-from fastvideo.configs.models.dits.glm_image import GlmImageDiTConfig
-from fastvideo.configs.models.encoders import BaseEncoderOutput, T5Config
-from fastvideo.configs.models.vaes.glm_image import GlmImageVAEConfig
-from fastvideo.configs.pipelines.base import PipelineConfig
-
-
-def glm_image_t5_postprocess(outputs: BaseEncoderOutput) -> torch.Tensor:
-    mask: torch.Tensor = outputs.attention_mask
-    hidden_state: torch.Tensor = outputs.last_hidden_state
-    seq_lens = mask.gt(0).sum(dim=1).long()
-
-    assert torch.isnan(hidden_state).sum() == 0, "T5 hidden states contain NaN"
-
-    max_len = 512
-    prompt_embeds = [u[:min(v, max_len)] for u, v in zip(hidden_state, seq_lens, strict=True)]
-    prompt_embeds_tensor: torch.Tensor = torch.stack(
-        [torch.cat([u, u.new_zeros(max_len - u.size(0), u.size(1))]) for u in prompt_embeds], dim=0)
-
-    return prompt_embeds_tensor
-
-
-@dataclass
-class GlmImageConfig(PipelineConfig):
-
-    dit_config: DiTConfig = field(default_factory=GlmImageDiTConfig)
-    dit_precision: str = "bf16"
-
-    vae_config: VAEConfig = field(default_factory=GlmImageVAEConfig)
-    vae_precision: str = "fp32"
-    vae_tiling: bool = True
-    vae_sp: bool = False
-
-    text_encoder_configs: tuple[EncoderConfig, ...] = field(default_factory=lambda: (T5Config(), ))
-    text_encoder_precisions: tuple[str, ...] = field(default_factory=lambda: ("fp32", ))
-    postprocess_text_funcs: tuple[Callable[[BaseEncoderOutput], torch.Tensor],
-                                  ...] = field(default_factory=lambda: (glm_image_t5_postprocess, ))
-
-    flow_shift: float | None = 1.0
-    embedded_cfg_scale: float = 7.5
@@ -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
 # ────────────────────────────────────────────────────────────────────────────
@@ -23,7 +23,6 @@ If you only need to use the distributed environment without model parallelism,
 you can skip the model parallel initialization and destruction steps.
 """
 import contextlib
-import gc
 import os
 import pickle
 import weakref
@@ -1007,13 +1006,6 @@ def cleanup_dist_env_and_memory(shutdown_ray: bool = False):
    if shutdown_ray:
        import ray  # Lazy import Ray
        ray.shutdown()
-    # Actually free GPU memory, as the name promises. FSDP-wrapped modules sit
-    # in reference cycles (module <-> FSDP state <-> hooks), so dropping the
-    # last user reference does not free their parameters until a gc pass runs.
-    # Without this, back-to-back model-load tests in one pytest session OOM.
-    gc.collect()
-    if torch.cuda.is_available():
-        torch.cuda.empty_cache()


 def get_same_node_ranks(pg: ProcessGroup | StatelessProcessGroup, source_rank: int = 0) -> list[int]:
@@ -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(
@@ -295,7 +295,6 @@ def get_1d_rotary_pos_embed(
    interpolation_factor: float = 1.0,
    dtype: torch.dtype = torch.float32,
    use_real: bool = True,
-    freqs_dtype: torch.dtype | None = None,
 ) -> tuple[torch.Tensor, torch.Tensor]:
    """
    Precompute the frequency tensor for complex exponential (cis) with given dimensions.
@@ -320,16 +319,12 @@ def get_1d_rotary_pos_embed(
    if isinstance(pos, int):
        pos = torch.arange(pos).float()

-    # freqs_dtype is an alias for dtype (Diffusers-compatible calling convention).
-    if freqs_dtype is not None:
-        dtype = freqs_dtype
-
    # proposed by reddit user bloc97, to rescale rotary embeddings to longer sequence length without fine-tuning
    # has some connection to NTK literature
    if theta_rescale_factor != 1.0:
        theta *= theta_rescale_factor**(dim / (dim - 2))

-    freqs = 1.0 / (theta**(torch.arange(0, dim, 2, device=pos.device)[:(dim // 2)].to(dtype) / dim))  # [D/2]
+    freqs = 1.0 / (theta**(torch.arange(0, dim, 2)[:(dim // 2)].to(dtype) / dim))  # [D/2]
    freqs = torch.outer(pos * interpolation_factor, freqs)  # [S, D/2]
    freqs_cos = freqs.cos()  # [S, D/2]
    freqs_sin = freqs.sin()  # [S, D/2]
@@ -450,21 +445,6 @@ def get_nd_rotary_pos_embed(
    return cos, sin


-_ROTARY_POS_EMBED_CACHE: dict[tuple, tuple[torch.Tensor, torch.Tensor]] = {}
-# Bound the table cache so long-running servers / causal models (which vary
-# start_frame per frame) cannot grow it without limit; entries are large float64
-# tensors. Least-recently-used eviction keeps the active resolution(s) hot while
-# capping memory.
-_ROTARY_POS_EMBED_CACHE_MAXSIZE = 16
-
-
-def _hashable(value: Any) -> Any:
-    """Return a hashable view of a scalar or sequence for use in a cache key."""
-    if isinstance(value, list | tuple):
-        return tuple(value)
-    return value
-
-
 def get_rotary_pos_embed(
    rope_sizes,
    hidden_size,
@@ -515,31 +495,6 @@ def get_rotary_pos_embed(
        sp_rank = 0
        sp_world_size = 1

-    # Memoize on every output-affecting argument; the table is constant across
-    # denoising steps, so this avoids recomputing the float64 cos/sin tables.
-    cache_key = (
-        _hashable(rope_sizes),
-        tuple(rope_dim_list),
-        rope_theta,
-        _hashable(theta_rescale_factor),
-        _hashable(interpolation_factor),
-        shard_dim,
-        sp_rank,
-        sp_world_size,
-        dtype,
-        start_frame,
-        use_real,
-    )
-    cached = _ROTARY_POS_EMBED_CACHE.get(cache_key)
-    if cached is not None:
-        # Move to most-recently-used position so the active table is not evicted
-        # when several resolutions / buckets share the process (LRU recency).
-        # Pop with a default: a concurrent eviction between the get() above and
-        # here would otherwise raise KeyError on the hit path.
-        if _ROTARY_POS_EMBED_CACHE.pop(cache_key, None) is not None:
-            _ROTARY_POS_EMBED_CACHE[cache_key] = cached
-        return cached
-
    freqs_cos, freqs_sin = get_nd_rotary_pos_embed(
        rope_dim_list,
        rope_sizes,
@@ -553,14 +508,6 @@ def get_rotary_pos_embed(
        start_frame=start_frame,
        use_real=use_real,
    )
-    # The returned tensors are shared cache entries: callers must never mutate
-    # them in place. Note .to(device) is an identity alias when the tensor is
-    # already on the target device (e.g. CPU runs), so it does NOT guarantee a
-    # copy — treat the tables as read-only and copy before any in-place op.
-    # Reached only on a miss, so evict the least-recently-used entry at capacity.
-    if len(_ROTARY_POS_EMBED_CACHE) >= _ROTARY_POS_EMBED_CACHE_MAXSIZE:
-        _ROTARY_POS_EMBED_CACHE.pop(next(iter(_ROTARY_POS_EMBED_CACHE)))
-    _ROTARY_POS_EMBED_CACHE[cache_key] = (freqs_cos, freqs_sin)
    return freqs_cos, freqs_sin


@@ -1,133 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-"""Cosmos3 sound tokenizer (AVAE) — decode path.
-
-The Cosmos3 ``sound_tokenizer`` is an AVAE (audio VAE). Its shipped diffusers
-checkpoint is **decoder-only** (``decoder.*``) in ``AutoencoderOobleck`` naming
-with SnakeBeta activations and ``weight_g``/``weight_v`` weight-norm — exactly
-FastVideo's native :class:`~fastvideo.models.vaes.oobleck.OobleckDecoder`
-(verified bit-exact vs the framework in ``test_cosmos3_avae_parity``). Text-to-
-video+sound (t2vs) only needs DECODE: the DiT generates the sound latent and
-this module decodes it to a waveform, so only the decoder is ported (the
-SpectrogramConvNeXt encoder is not exported in the checkpoint).
-
-Mirrors the framework ``AVAEModel.decode``: run the Oobleck decoder, then clamp
-to [-1, 1]. The VAE bottleneck's decode is the identity (the DiT already emits
-the post-bottleneck latent), so there is no bottleneck step here.
-"""
-from __future__ import annotations
-
-import json
-import os
-from dataclasses import dataclass, field
-
-import numpy as np
-import torch
-import torch.nn as nn
-
-from fastvideo.logger import init_logger
-from fastvideo.models.vaes.oobleck import OobleckDecoder
-
-logger = init_logger(__name__)
-
-
-@dataclass
-class Cosmos3SoundVAEArchConfig:
-    """Cosmos3 AVAE decoder constants (from ``sound_tokenizer/config.json``)."""
-
-    dec_dim: int = 320  # decoder base channels
-    vocoder_input_dim: int = 64  # latent channels in
-    dec_c_mults: list[int] = field(default_factory=lambda: [1, 2, 4, 8, 16])
-    dec_strides: list[int] = field(default_factory=lambda: [2, 4, 5, 6, 8])
-    audio_channels: int = 2  # stereo
-    sampling_rate: int = 48000
-
-    @property
-    def hop_size(self) -> int:
-        return int(np.prod(self.dec_strides))  # 1920
-
-
-class Cosmos3SoundVAE(nn.Module):
-    """Decoder-only Cosmos3 AVAE: latent ``[B, z, T]`` -> waveform ``[B, C, N]``."""
-
-    def __init__(self, arch: Cosmos3SoundVAEArchConfig | None = None) -> None:
-        super().__init__()
-        self.arch = arch or Cosmos3SoundVAEArchConfig()
-        self.decoder = OobleckDecoder(
-            channels=self.arch.dec_dim,
-            input_channels=self.arch.vocoder_input_dim,
-            audio_channels=self.arch.audio_channels,
-            # The framework builds decoder blocks from ``reversed(dec_strides)``
-            # (deepest first), so block strides are e.g. [8,6,5,4,2].
-            upsampling_ratios=list(reversed(self.arch.dec_strides)),
-            channel_multiples=list(self.arch.dec_c_mults),
-        )
-
-    @property
-    def sample_rate(self) -> int:
-        return self.arch.sampling_rate
-
-    @property
-    def audio_channels(self) -> int:
-        return self.arch.audio_channels
-
-    @property
-    def hop_size(self) -> int:
-        return self.arch.hop_size
-
-    def get_latent_num_samples(self, num_audio_samples: int) -> int:
-        """Latent length for a given audio length (``AVAEInterface``: ``N // hop``)."""
-        return int(num_audio_samples) // self.arch.hop_size
-
-    @torch.no_grad()
-    def decode(self, latent: torch.Tensor) -> torch.Tensor:
-        """Decode normalized latent ``[B, z, T]`` to waveform ``[B, C, N]`` in [-1, 1].
-
-        Matches ``AVAEModel.decode``: Oobleck decoder then clamp to [-1, 1] (the
-        VAE bottleneck decode is identity).
-        """
-        audio = self.decoder(latent)  # [B, C, N]
-        return audio.clamp(-1.0, 1.0)
-
-    @classmethod
-    def from_pretrained(
-        cls,
-        model_path: str,
-        *,
-        torch_dtype: torch.dtype | None = None,
-    ) -> "Cosmos3SoundVAE":
-        """Build + load the decoder from a ``sound_tokenizer`` directory.
-
-        Reads ``config.json`` (``dec_dim`` / ``vocoder_input_dim`` /
-        ``dec_c_mults`` / ``dec_strides`` / ``sampling_rate`` / ``stereo``) and
-        loads the ``decoder.*`` weights (the checkpoint is decoder-only).
-        """
-        from safetensors.torch import load_file
-
-        cfg_path = os.path.join(model_path, "config.json")
-        with open(cfg_path) as f:
-            cfg = json.load(f)
-        arch = Cosmos3SoundVAEArchConfig(
-            dec_dim=int(cfg["dec_dim"]),
-            vocoder_input_dim=int(cfg["vocoder_input_dim"]),
-            dec_c_mults=list(cfg["dec_c_mults"]),
-            dec_strides=list(cfg["dec_strides"]),
-            audio_channels=2 if cfg.get("stereo", True) else 1,
-            sampling_rate=int(cfg.get("sampling_rate", 48000)),
-        )
-        model = cls(arch)
-
-        weights_path = os.path.join(model_path, "diffusion_pytorch_model.safetensors")
-        state = load_file(weights_path)
-        # Decoder-only checkpoint: strip the ``decoder.`` prefix.
-        dec_state = {k[len("decoder."):]: v for k, v in state.items() if k.startswith("decoder.")}
-        model.decoder.load_state_dict(dec_state, strict=True)
-        logger.info("Loaded Cosmos3 sound AVAE decoder (%d params) from %s",
-                    sum(p.numel() for p in model.parameters()), model_path)
-
-        if torch_dtype is not None:
-            model = model.to(dtype=torch_dtype)
-        model.eval()
-        return model
-
-
-EntryClass = Cosmos3SoundVAE
@@ -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,
@@ -1,511 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-
-import math
-from typing import Any
-
-import torch
-import torch.nn as nn
-
-from fastvideo.configs.models.dits.dreamx_world import DreamXWorldConfig
-from fastvideo.distributed.communication_op import (
-    sequence_model_parallel_all_gather_with_unpad,
-    sequence_model_parallel_shard)
-from fastvideo.distributed.parallel_state import get_sp_world_size
-from fastvideo.layers.layernorm import RMSNorm
-from fastvideo.layers.linear import ReplicatedLinear
-from fastvideo.layers.rotary_embedding import get_rotary_pos_embed
-from fastvideo.models.dits.wanvideo import (LayerNormScaleShift,
-                                            PatchEmbed,
-                                            WanTimeTextImageEmbedding,
-                                            WanTransformer3DModel,
-                                            WanTransformerBlock)
-from fastvideo.platforms import AttentionBackendEnum, current_platform
-from fastvideo.attention import LocalAttention
-from fastvideo.distributed.parallel_state import get_sp_world_size
-from fastvideo.layers.quantization import QuantizationConfig
-from fastvideo.models.dits.base import BaseDiT
-
-
-def _dreamx_invert_se3(transforms: torch.Tensor) -> torch.Tensor:
-    assert transforms.shape[-2:] == (4, 4)
-    rot_inv = transforms[..., :3, :3].transpose(-1, -2)
-    out = torch.zeros_like(transforms)
-    out[..., :3, :3] = rot_inv
-    out[..., :3, 3] = -torch.einsum("...ij,...j->...i", rot_inv,
-                                    transforms[..., :3, 3])
-    out[..., 3, 3] = 1.0
-    return out.to(dtype=transforms.dtype)
-
-
-def _dreamx_lift_k(intrinsics: torch.Tensor) -> torch.Tensor:
-    assert intrinsics.shape[-2:] == (3, 3)
-    out = torch.zeros(intrinsics.shape[:-2] + (4, 4),
-                      device=intrinsics.device,
-                      dtype=intrinsics.dtype)
-    out[..., :3, :3] = intrinsics
-    out[..., 3, 3] = 1.0
-    return out
-
-
-def _dreamx_invert_k(intrinsics: torch.Tensor) -> torch.Tensor:
-    assert intrinsics.shape[-2:] == (3, 3)
-    out = torch.zeros_like(intrinsics)
-    out[..., 0, 0] = 1.0 / intrinsics[..., 0, 0]
-    out[..., 1, 1] = 1.0 / intrinsics[..., 1, 1]
-    out[..., 0, 2] = -intrinsics[..., 0, 2] / intrinsics[..., 0, 0]
-    out[..., 1, 2] = -intrinsics[..., 1, 2] / intrinsics[..., 1, 1]
-    out[..., 2, 2] = 1.0
-    return out.to(dtype=intrinsics.dtype)
-
-
-def _dreamx_apply_tiled_projmat(feats: torch.Tensor,
-                                matrix: torch.Tensor) -> torch.Tensor:
-    batch, num_heads, seq_len, feat_dim = feats.shape
-    proj_dim = matrix.shape[-1]
-    assert feat_dim % proj_dim == 0
-
-    if matrix.shape[1] == seq_len:
-        feats = feats.view(batch, num_heads, seq_len, feat_dim // proj_dim,
-                           proj_dim)
-        out = torch.einsum("btij,bntpj->bntpi", matrix, feats)
-        return out.reshape(batch, num_heads, seq_len, feat_dim)
-
-    cameras = matrix.shape[1]
-    assert seq_len > cameras and seq_len % cameras == 0
-    feats = feats.reshape(batch, num_heads, cameras, -1,
-                          feat_dim // proj_dim, proj_dim)
-    out = torch.einsum("bcij,bncpkj->bncpki", matrix, feats)
-    return out.reshape(batch, num_heads, seq_len, feat_dim)
-
-
-def _dreamx_prope_qkv(q: torch.Tensor, k: torch.Tensor, v: torch.Tensor,
-                      viewmats: torch.Tensor, intrinsics: torch.Tensor):
-    batch, num_heads, seq_len, head_dim = q.shape
-    cameras = viewmats.shape[1]
-    assert q.shape == k.shape == v.shape
-    assert viewmats.shape == (batch, cameras, 4, 4)
-    assert intrinsics.shape == (batch, cameras, 3, 3)
-    assert head_dim % 4 == 0
-
-    intrinsics_norm = torch.zeros_like(intrinsics)
-    intrinsics_norm[..., 0, 0] = intrinsics[..., 0, 0]
-    intrinsics_norm[..., 1, 1] = intrinsics[..., 1, 1]
-    intrinsics_norm[..., 2, 2] = 1.0
-
-    proj = torch.einsum("...ij,...jk->...ik",
-                        _dreamx_lift_k(intrinsics_norm), viewmats)
-    proj_t = proj.transpose(-1, -2).to(dtype=viewmats.dtype)
-    proj_inv = torch.einsum(
-        "...ij,...jk->...ik",
-        _dreamx_invert_se3(viewmats),
-        _dreamx_lift_k(_dreamx_invert_k(intrinsics_norm)),
-    ).to(dtype=viewmats.dtype)
-
-    q = _dreamx_apply_tiled_projmat(q, proj_t)
-    k = _dreamx_apply_tiled_projmat(k, proj_inv)
-    v = _dreamx_apply_tiled_projmat(v, proj_inv)
-    return q, k, v, proj
-
-
-class DreamXPropeSelfAttention(nn.Module):
-    """DreamX-World parallel PRoPE camera self-attention branch."""
-
-    def __init__(self,
-                 dim: int,
-                 attn_dim: int,
-                 num_heads: int,
-                 qk_norm: str | bool = True,
-                 eps: float = 1e-6,
-                 quant_config: QuantizationConfig | None = None,
-                 prefix: str = ""):
-        super().__init__()
-        assert attn_dim % num_heads == 0
-        self.attn_dim = attn_dim
-        self.num_heads = num_heads
-        self.head_dim = attn_dim // num_heads
-        self.qk_norm = qk_norm
-
-        self.q_proj = ReplicatedLinear(dim,
-                                       attn_dim,
-                                       quant_config=quant_config,
-                                       prefix=f"{prefix}.q_proj")
-        self.k_proj = ReplicatedLinear(dim,
-                                       attn_dim,
-                                       quant_config=quant_config,
-                                       prefix=f"{prefix}.k_proj")
-        self.v_proj = ReplicatedLinear(dim,
-                                       attn_dim,
-                                       quant_config=quant_config,
-                                       prefix=f"{prefix}.v_proj")
-        self.out_proj = ReplicatedLinear(attn_dim,
-                                         dim,
-                                         quant_config=quant_config,
-                                         prefix=f"{prefix}.out_proj")
-
-        if qk_norm == "rms_norm":
-            self.norm_q = RMSNorm(self.head_dim, eps=eps)
-            self.norm_k = RMSNorm(self.head_dim, eps=eps)
-        elif qk_norm in (True, "rms_norm_across_heads"):
-            self.norm_q = RMSNorm(attn_dim, eps=eps)
-            self.norm_k = RMSNorm(attn_dim, eps=eps)
-        elif qk_norm is False:
-            self.norm_q = nn.Identity()
-            self.norm_k = nn.Identity()
-        else:
-            raise ValueError(f"Unsupported qk_norm for DreamX PRoPE: {qk_norm}")
-
-        nn.init.zeros_(self.out_proj.weight)
-        if self.out_proj.bias is not None:
-            nn.init.zeros_(self.out_proj.bias)
-
-        self.attn = LocalAttention(
-            num_heads=num_heads,
-            head_size=self.head_dim,
-            dropout_rate=0,
-            softmax_scale=None,
-            causal=False,
-            supported_attention_backends=(AttentionBackendEnum.FLASH_ATTN,
-                                          AttentionBackendEnum.TORCH_SDPA))
-
-    def forward(self, hidden_states: torch.Tensor,
-                y_camera: dict[str, torch.Tensor]) -> torch.Tensor:
-        if get_sp_world_size() > 1:
-            # The transformer shards the sequence before the block loop and
-            # this branch uses LocalAttention (no all-to-all): under
-            # sequence parallelism each rank would attend only within its
-            # own shard — silently wrong output. Fail loudly until this
-            # path is ported to DistributedAttention and validated.
-            raise NotImplementedError(
-                "DreamXPropeSelfAttention does not support sequence "
-                "parallelism yet (LocalAttention on a sharded sequence "
-                "corrupts output). Run with sp_size=1.")
-        batch_size, seq_len, _ = hidden_states.shape
-
-        query, _ = self.q_proj(hidden_states)
-        key, _ = self.k_proj(hidden_states)
-        value, _ = self.v_proj(hidden_states)
-
-        if self.qk_norm == "rms_norm":
-            query = query.view(batch_size, seq_len, self.num_heads,
-                               self.head_dim)
-            key = key.view(batch_size, seq_len, self.num_heads, self.head_dim)
-            query = self.norm_q(query)
-            key = self.norm_k(key)
-        else:
-            query = self.norm_q(query).view(batch_size, seq_len,
-                                            self.num_heads, self.head_dim)
-            key = self.norm_k(key).view(batch_size, seq_len, self.num_heads,
-                                        self.head_dim)
-
-        value = value.view(batch_size, seq_len, self.num_heads, self.head_dim)
-        query = query.transpose(1, 2)
-        key = key.transpose(1, 2)
-        value = value.transpose(1, 2)
-
-        query, key, value, output_projection = _dreamx_prope_qkv(
-            query,
-            key,
-            value,
-            viewmats=y_camera["viewmats"],
-            intrinsics=y_camera["K"],
-        )
-
-        out = self.attn(query.transpose(1, 2), key.transpose(1, 2),
-                        value.transpose(1, 2))
-        out = _dreamx_apply_tiled_projmat(out.transpose(1, 2),
-                                          output_projection).transpose(1, 2)
-        out = out.flatten(2)
-        out, _ = self.out_proj(out)
-        return out
-
-
-class DreamXWorldTransformerBlock(WanTransformerBlock):
-
-    def __init__(self,
-                 dim: int,
-                 ffn_dim: int,
-                 num_heads: int,
-                 qk_norm: str = "rms_norm_across_heads",
-                 cross_attn_norm: bool = False,
-                 eps: float = 1e-6,
-                 added_kv_proj_dim: int | None = None,
-                 supported_attention_backends: tuple[AttentionBackendEnum, ...]
-                 | None = None,
-                 quant_config: QuantizationConfig | None = None,
-                 prefix: str = "",
-                 add_control_adapter: bool = True,
-                 cam_method: str | None = "prope",
-                 attn_compress: int = 1,
-                 cam_self_attn_layers: tuple[int, ...] | None = None,
-                 layer_idx: int | None = None):
-        super().__init__(dim, ffn_dim, num_heads, qk_norm, cross_attn_norm,
-                         eps, added_kv_proj_dim,
-                         supported_attention_backends, quant_config, prefix)
-        self.cam_self_attn = None
-        add_cam_attn = add_control_adapter and cam_method == "prope"
-        if add_cam_attn and cam_self_attn_layers is not None:
-            add_cam_attn = layer_idx in cam_self_attn_layers
-        if add_cam_attn:
-            if num_heads % attn_compress != 0 or dim % attn_compress != 0:
-                raise ValueError("DreamX attn_compress must divide dim and num_heads")
-            self.cam_self_attn = DreamXPropeSelfAttention(
-                dim,
-                dim // attn_compress,
-                num_heads // attn_compress,
-                qk_norm=qk_norm,
-                eps=eps,
-                quant_config=quant_config,
-                prefix=f"{prefix}.cam_self_attn")
-
-    def forward(
-        self,
-        hidden_states: torch.Tensor,
-        encoder_hidden_states: torch.Tensor,
-        temb: torch.Tensor,
-        freqs_cis: tuple[torch.Tensor, torch.Tensor],
-        original_seq_len: int,
-        y_camera: dict[str, torch.Tensor] | None = None,
-    ) -> torch.Tensor:
-        if hidden_states.dim() == 4:
-            hidden_states = hidden_states.squeeze(1)
-        orig_dtype = hidden_states.dtype
-
-        if temb.dim() == 4:
-            shift_msa, scale_msa, gate_msa, c_shift_msa, c_scale_msa, c_gate_msa = (
-                self.scale_shift_table.unsqueeze(0) + temb.float()).chunk(
-                    6, dim=2)
-            shift_msa = shift_msa.squeeze(2)
-            scale_msa = scale_msa.squeeze(2)
-            gate_msa = gate_msa.squeeze(2)
-            c_shift_msa = c_shift_msa.squeeze(2)
-            c_scale_msa = c_scale_msa.squeeze(2)
-            c_gate_msa = c_gate_msa.squeeze(2)
-        else:
-            e = self.scale_shift_table + temb.float()
-            shift_msa, scale_msa, gate_msa, c_shift_msa, c_scale_msa, c_gate_msa = e.chunk(
-                6, dim=1)
-        assert shift_msa.dtype == torch.float32
-
-        norm_hidden_states = (self.norm1(hidden_states.float()) *
-                              (1 + scale_msa) + shift_msa).to(orig_dtype)
-        query, _ = self.to_q(norm_hidden_states)
-        key, _ = self.to_k(norm_hidden_states)
-        value, _ = self.to_v(norm_hidden_states)
-
-        if self.norm_q is not None:
-            query = self.norm_q(query)
-        if self.norm_k is not None:
-            key = self.norm_k(key)
-
-        query = query.squeeze(1).unflatten(2, (self.num_attention_heads, -1))
-        key = key.squeeze(1).unflatten(2, (self.num_attention_heads, -1))
-        value = value.squeeze(1).unflatten(2, (self.num_attention_heads, -1))
-
-        attn_output, _ = self.attn1(
-            query,
-            key,
-            value,
-            original_seq_len,
-            freqs_cis=freqs_cis,
-        )
-        attn_output = attn_output.flatten(2)
-        attn_output, _ = self.to_out(attn_output)
-        attn_output = attn_output.squeeze(1)
-        if self.cam_self_attn is not None and y_camera is not None:
-            attn_output = attn_output + self.cam_self_attn(
-                norm_hidden_states, y_camera)
-
-        null_shift = null_scale = torch.tensor([0], device=hidden_states.device)
-        norm_hidden_states, hidden_states = self.self_attn_residual_norm(
-            hidden_states, attn_output, gate_msa, null_shift, null_scale)
-        norm_hidden_states, hidden_states = norm_hidden_states.to(
-            orig_dtype), hidden_states.to(orig_dtype)
-
-        attn_output = self.attn2(norm_hidden_states,
-                                 context=encoder_hidden_states,
-                                 context_lens=None)
-        norm_hidden_states, hidden_states = self.cross_attn_residual_norm(
-            hidden_states, attn_output, 1, c_shift_msa, c_scale_msa)
-        norm_hidden_states, hidden_states = norm_hidden_states.to(
-            orig_dtype), hidden_states.to(orig_dtype)
-
-        ff_output = self.ffn(norm_hidden_states)
-        hidden_states = self.mlp_residual(hidden_states, ff_output, c_gate_msa)
-        hidden_states = hidden_states.to(orig_dtype)
-
-        return hidden_states
-
-
-class DreamXWorldTransformer3DModel(WanTransformer3DModel):
-    _fsdp_shard_conditions = DreamXWorldConfig()._fsdp_shard_conditions
-    _compile_conditions = DreamXWorldConfig()._compile_conditions
-    _supported_attention_backends = DreamXWorldConfig(
-    )._supported_attention_backends
-    param_names_mapping = DreamXWorldConfig().param_names_mapping
-    reverse_param_names_mapping = DreamXWorldConfig().reverse_param_names_mapping
-    lora_param_names_mapping = DreamXWorldConfig().lora_param_names_mapping
-
-    def __init__(self, config: DreamXWorldConfig, hf_config: dict[str,
-                                                                  Any]) -> None:
-        BaseDiT.__init__(self, config=config, hf_config=hf_config)
-        self.quant_config = config.quant_config
-
-        inner_dim = config.num_attention_heads * config.attention_head_dim
-        self.hidden_size = config.hidden_size
-        self.num_attention_heads = config.num_attention_heads
-        self.in_channels = config.in_channels
-        self.out_channels = config.out_channels
-        self.num_channels_latents = config.num_channels_latents
-        self.patch_size = config.patch_size
-        self.text_len = config.text_len
-
-        assert config.num_attention_heads % get_sp_world_size() == 0, f"The number of attention heads ({config.num_attention_heads}) must be divisible by the sequence parallel size ({get_sp_world_size()})"
-
-        self.patch_embedding = PatchEmbed(in_chans=config.in_channels,
-                                          embed_dim=inner_dim,
-                                          patch_size=config.patch_size,
-                                          flatten=False)
-        self.condition_embedder = WanTimeTextImageEmbedding(
-            dim=inner_dim,
-            time_freq_dim=config.freq_dim,
-            text_embed_dim=config.text_dim,
-            image_embed_dim=config.image_dim,
-        )
-        self.blocks = nn.ModuleList([
-            DreamXWorldTransformerBlock(
-                inner_dim,
-                config.ffn_dim,
-                config.num_attention_heads,
-                config.qk_norm,
-                config.cross_attn_norm,
-                config.eps,
-                config.added_kv_proj_dim,
-                self._supported_attention_backends,
-                quant_config=config.quant_config,
-                prefix=f"{config.prefix}.blocks.{i}",
-                add_control_adapter=config.add_control_adapter,
-                cam_method=config.cam_method,
-                attn_compress=config.attn_compress,
-                cam_self_attn_layers=config.cam_self_attn_layers,
-                layer_idx=i)
-            for i in range(config.num_layers)
-        ])
-        self.norm_out = LayerNormScaleShift(inner_dim,
-                                            norm_type="layer",
-                                            eps=config.eps,
-                                            elementwise_affine=False,
-                                            dtype=torch.float32,
-                                            compute_dtype=torch.float32)
-        self.proj_out = nn.Linear(
-            inner_dim, config.out_channels * math.prod(config.patch_size))
-        self.scale_shift_table = nn.Parameter(
-            torch.randn(1, 2, inner_dim) / inner_dim**0.5)
-        self.gradient_checkpointing = False
-        self.__post_init__()
-
-    def forward(self,
-                hidden_states: torch.Tensor,
-                encoder_hidden_states: torch.Tensor | list[torch.Tensor],
-                timestep: torch.LongTensor,
-                encoder_hidden_states_image: torch.Tensor | list[torch.Tensor]
-                | None = None,
-                guidance=None,
-                y_camera: dict[str, torch.Tensor] | None = None,
-                **kwargs) -> torch.Tensor:
-        orig_dtype = hidden_states.dtype
-        if encoder_hidden_states is not None and not isinstance(
-                encoder_hidden_states, torch.Tensor):
-            encoder_hidden_states = encoder_hidden_states[0]
-        if isinstance(encoder_hidden_states_image,
-                      list) and len(encoder_hidden_states_image) > 0:
-            encoder_hidden_states_image = encoder_hidden_states_image[0]
-        else:
-            encoder_hidden_states_image = None
-
-        batch_size, _, num_frames, height, width = hidden_states.shape
-        p_t, p_h, p_w = self.patch_size
-        post_patch_num_frames = num_frames // p_t
-        post_patch_height = height // p_h
-        post_patch_width = width // p_w
-
-        d = self.hidden_size // self.num_attention_heads
-        rope_dim_list = [d - 4 * (d // 6), 2 * (d // 6), 2 * (d // 6)]
-        freqs_cos, freqs_sin = get_rotary_pos_embed(
-            (post_patch_num_frames, post_patch_height, post_patch_width),
-            self.hidden_size,
-            self.num_attention_heads,
-            rope_dim_list,
-            dtype=torch.float32 if current_platform.is_mps() else torch.float64,
-            rope_theta=10000)
-        freqs_cis = (freqs_cos.to(hidden_states.device).float(),
-                     freqs_sin.to(hidden_states.device).float())
-
-        hidden_states = self.patch_embedding(hidden_states)
-        hidden_states = hidden_states.flatten(2).transpose(1, 2)
-        hidden_states, original_seq_len = sequence_model_parallel_shard(
-            hidden_states, dim=1)
-
-        if timestep.dim() == 2:
-            ts_seq_len = timestep.shape[1]
-            timestep = timestep.flatten()
-        else:
-            ts_seq_len = None
-
-        temb, timestep_proj, encoder_hidden_states, encoder_hidden_states_image = self.condition_embedder(
-            timestep,
-            encoder_hidden_states,
-            encoder_hidden_states_image,
-            timestep_seq_len=ts_seq_len)
-        if ts_seq_len is not None:
-            timestep_proj = timestep_proj.unflatten(2, (6, -1))
-        else:
-            timestep_proj = timestep_proj.unflatten(1, (6, -1))
-
-        if encoder_hidden_states_image is not None:
-            if encoder_hidden_states is not None:
-                encoder_hidden_states = torch.concat(
-                    [encoder_hidden_states_image, encoder_hidden_states], dim=1)
-            else:
-                encoder_hidden_states = encoder_hidden_states_image
-
-        if current_platform.is_mps() or current_platform.is_npu():
-            encoder_hidden_states = encoder_hidden_states.to(orig_dtype)
-
-        assert encoder_hidden_states.dtype == orig_dtype
-
-        if torch.is_grad_enabled() and self.gradient_checkpointing:
-            for block in self.blocks:
-                hidden_states = self._gradient_checkpointing_func(
-                    block, hidden_states, encoder_hidden_states,
-                    timestep_proj, freqs_cis, original_seq_len, y_camera)
-        else:
-            for block in self.blocks:
-                hidden_states = block(hidden_states, encoder_hidden_states,
-                                      timestep_proj, freqs_cis, original_seq_len,
-                                      y_camera=y_camera)
-
-        if temb.dim() == 3:
-            shift, scale = (self.scale_shift_table.unsqueeze(0) +
-                            temb.unsqueeze(2)).chunk(2, dim=2)
-            shift = shift.squeeze(2)
-            scale = scale.squeeze(2)
-        else:
-            shift, scale = (self.scale_shift_table +
-                            temb.unsqueeze(1)).chunk(2, dim=1)
-
-        hidden_states = self.norm_out(hidden_states, shift, scale)
-        hidden_states = sequence_model_parallel_all_gather_with_unpad(
-            hidden_states, original_seq_len, dim=1)
-        hidden_states = self.proj_out(hidden_states)
-
-        hidden_states = hidden_states.reshape(batch_size, post_patch_num_frames,
-                                              post_patch_height,
-                                              post_patch_width, p_t, p_h, p_w,
-                                              -1)
-        hidden_states = hidden_states.permute(0, 7, 1, 4, 2, 5, 3, 6)
-        output = hidden_states.flatten(6, 7).flatten(4, 5).flatten(2, 3)
-
-        return output
-
-
-EntryClass = DreamXWorldTransformer3DModel
@@ -1,920 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-"""DreamX-World autoregressive causal DiT.
-
-Adapted from DreamX-World's Apache-2.0
-``wan/modules/causal_camera_model_2_2_prope_infinity.py``. The implementation is
-kept native to FastVideo: no production import from DreamX, Diffusers, or
-Transformers is required.
-"""
-
-from typing import Any
-
-import math
-
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-
-from fastvideo.configs.models.dits.dreamx_world import DreamXWorldARConfig
-from fastvideo.layers.linear import ReplicatedLinear
-from fastvideo.models.dits.base import BaseDiT
-from fastvideo.models.dits.dreamx_world import (_dreamx_apply_tiled_projmat,
-                                               _dreamx_prope_qkv)
-
-
-def attention(q: torch.Tensor, k: torch.Tensor, v: torch.Tensor) -> torch.Tensor:
-    # Deliberately raw SDPA rather than fastvideo.attention.LocalAttention:
-    # (1) LocalAttention dispatches through the attention-backend registry, so
-    #     FLASH_ATTN could be selected and its kernel is not bit-identical to
-    #     torch SDPA — the AR KV-cache rollout must stay numerically frozen;
-    # (2) LocalAttention requires an active ForwardContext, which direct
-    #     transformer invocations (parity tests) do not set;
-    # (3) the sibling causal model keeps raw SDPA in the same KV-cache window
-    #     path (matrixgame2/causal_model.py).
-    # Sequence-parallel gap: this model never shards the sequence; run with
-    # sp_size=1 (see fastvideo/layers/AGENTS.md on documenting raw SDPA).
-    q_bhld = q.transpose(1, 2)
-    k_bhld = k.transpose(1, 2)
-    v_bhld = v.transpose(1, 2)
-    out = F.scaled_dot_product_attention(q_bhld, k_bhld, v_bhld, dropout_p=0.0)
-    return out.transpose(1, 2)
-
-
-def prope_qkv(q: torch.Tensor, k: torch.Tensor, v: torch.Tensor,
-              viewmats: torch.Tensor, Ks: torch.Tensor):
-    q, k, v, output_projection = _dreamx_prope_qkv(q, k, v, viewmats, Ks)
-
-    def apply_fn_o(x: torch.Tensor) -> torch.Tensor:
-        return _dreamx_apply_tiled_projmat(x, output_projection)
-
-    return q, k, v, apply_fn_o
-
-
-def sinusoidal_embedding_1d(dim, position):
-    assert dim % 2 == 0
-    half = dim // 2
-    position = position.type(torch.float64)
-    sinusoid = torch.outer(
-        position, torch.pow(10000, -torch.arange(half).to(position).div(half)))
-    return torch.cat([torch.cos(sinusoid), torch.sin(sinusoid)], dim=1)
-
-
-def rope_params(max_seq_len, dim, theta=10000):
-    assert dim % 2 == 0
-    freqs = torch.outer(
-        torch.arange(max_seq_len),
-        1.0 / torch.pow(theta,
-                        torch.arange(0, dim, 2).to(torch.float64).div(dim)))
-    return torch.polar(torch.ones_like(freqs), freqs)
-
-
-class WanRMSNorm(nn.Module):
-    """Kept private instead of fastvideo.layers.layernorm.RMSNorm.
-
-    The official DreamX-World ``model_2_2.py`` computes the RMS statistics in
-    the *input* dtype — the upstream code has the fp32 upcast explicitly
-    commented out (``# return self._norm(x.float())...``). FastVideo's RMSNorm
-    always normalizes in fp32, which is not bit-identical under bf16, so the
-    verbatim implementation stays.
-    """
-
-    def __init__(self, dim, eps=1e-5):
-        super().__init__()
-        self.dim = dim
-        self.eps = eps
-        self.weight = nn.Parameter(torch.ones(dim))
-
-    def forward(self, x):
-        return self._norm(x).type_as(x) * self.weight
-
-    def _norm(self, x):
-        return x * torch.rsqrt(x.pow(2).mean(dim=-1, keepdim=True) + self.eps)
-
-
-class WanLayerNorm(nn.LayerNorm):
-    """Kept private instead of fastvideo.layers.layernorm.FP32LayerNorm.
-
-    The official DreamX-World ``model_2_2.py`` normalizes in the *input* dtype
-    (no ``x.float()`` upcast, unlike Wan2.1). FP32LayerNorm casts input and
-    affine params to fp32, which is not bit-identical under bf16, so the
-    verbatim implementation stays.
-    """
-
-    def __init__(self, dim, eps=1e-6, elementwise_affine=False):
-        super().__init__(dim, elementwise_affine=elementwise_affine, eps=eps)
-
-    def forward(self, x):
-        return super().forward(x).type_as(x)
-
-
-class WanCrossAttention(nn.Module):
-    def __init__(self, dim, num_heads, window_size=(-1, -1), qk_norm=True, eps=1e-6):
-        super().__init__()
-        self.num_heads = num_heads
-        self.head_dim = dim // num_heads
-        self.q = ReplicatedLinear(dim, dim)
-        self.k = ReplicatedLinear(dim, dim)
-        self.v = ReplicatedLinear(dim, dim)
-        self.o = ReplicatedLinear(dim, dim)
-        self.norm_q = WanRMSNorm(dim, eps=eps) if qk_norm else nn.Identity()
-        self.norm_k = WanRMSNorm(dim, eps=eps) if qk_norm else nn.Identity()
-
-    def _kv(self, context, b, n, d):
-        k, _ = self.k(context)
-        k = self.norm_k(k).view(b, -1, n, d)
-        v, _ = self.v(context)
-        v = v.view(b, -1, n, d)
-        return k, v
-
-    def forward(self, x, context, context_lens, crossattn_cache=None):
-        b, n, d = x.size(0), self.num_heads, self.head_dim
-        q, _ = self.q(x)
-        q = self.norm_q(q).view(b, -1, n, d)
-
-        if crossattn_cache is not None:
-            if not crossattn_cache["is_init"]:
-                crossattn_cache["is_init"] = True
-                k, v = self._kv(context, b, n, d)
-                crossattn_cache["k"] = k
-                crossattn_cache["v"] = v
-            else:
-                k = crossattn_cache["k"]
-                v = crossattn_cache["v"]
-        else:
-            k, v = self._kv(context, b, n, d)
-
-        x = attention(q, k, v)
-        x = x.flatten(2)
-        out, _ = self.o(x)
-        return out
-
-
-def block_relativistic_rope(x, grid_sizes, freqs, start_frame=0, relative_frame_indices=None):
-    """
-    Apply Block-Relativistic RoPE to input tensor.
-    Adapted from Infinity-RoPE (https://arxiv.org/abs/2511.20649).
-
-    Args:
-        x: Input tensor [B, L, num_heads, head_dim]
-        grid_sizes: Tensor [B, 3] containing (F, H, W)
-        freqs: RoPE frequencies
-        start_frame: Starting frame index for sequential RoPE
-        relative_frame_indices: Optional tensor [F] specifying explicit frame indices
-                               for Block-Relativistic RoPE. Overrides start_frame if provided.
-    """
-    n, c = x.size(2), x.size(3) // 2
-    freqs = freqs.split([c - 2 * (c // 3), c // 3, c // 3], dim=1)
-
-    output = []
-    for i, (f, h, w) in enumerate(grid_sizes.tolist()):
-        seq_len = f * h * w
-        x_i = torch.view_as_complex(x[i, :seq_len].to(torch.float64).reshape(
-            seq_len, n, -1, 2))
-
-        if relative_frame_indices is not None:
-            frame_indices = relative_frame_indices.long()
-            freqs_temporal = freqs[0][frame_indices].view(f, 1, 1, -1).expand(f, h, w, -1)
-        else:
-            freqs_temporal = freqs[0][start_frame:start_frame + f].view(f, 1, 1, -1).expand(f, h, w, -1)
-
-        freqs_i = torch.cat([
-            freqs_temporal,
-            freqs[1][:h].view(1, h, 1, -1).expand(f, h, w, -1),
-            freqs[2][:w].view(1, 1, w, -1).expand(f, h, w, -1)
-        ], dim=-1).reshape(seq_len, 1, -1)
-
-        x_i = torch.view_as_real(x_i * freqs_i).flatten(2)
-        x_i = torch.cat([x_i, x[i, seq_len:]])
-        output.append(x_i)
-
-    return torch.stack(output).type_as(x)
-
-
-class CausalWanSelfAttention(nn.Module):
-    """Self-attention with KV cache and Block-Relativistic RoPE for causal inference."""
-
-    def __init__(self, dim, num_heads, local_attn_size=6, sink_size=1,
-                 qk_norm=True, eps=1e-6):
-        assert dim % num_heads == 0
-        super().__init__()
-        self.dim = dim
-        self.num_heads = num_heads
-        self.head_dim = dim // num_heads
-        self.local_attn_size = local_attn_size
-        self.sink_size = sink_size
-        self.qk_norm = qk_norm
-        self.eps = eps
-        self.max_attention_size = 39600 if local_attn_size == -1 else local_attn_size * 880
-
-        self.q = ReplicatedLinear(dim, dim)
-        self.k = ReplicatedLinear(dim, dim)
-        self.v = ReplicatedLinear(dim, dim)
-        self.o = ReplicatedLinear(dim, dim)
-        self.norm_q = WanRMSNorm(dim, eps=eps) if qk_norm else nn.Identity()
-        self.norm_k = WanRMSNorm(dim, eps=eps) if qk_norm else nn.Identity()
-
-    def forward(self, x, seq_lens, grid_sizes, freqs, kv_cache,
-                current_start=0, cache_start=None, sink_recache_after_switch=False):
-        """
-        Args:
-            x: Shape [B, L, C]
-            seq_lens: Shape [B]
-            grid_sizes: Shape [B, 3] containing (F, H, W)
-            freqs: RoPE frequencies [1024, head_dim / 2]
-            kv_cache: Dict with 'k', 'v', 'global_end_index', 'local_end_index'
-            current_start: Current position in the global token sequence
-        """
-        b, s, n, d = *x.shape[:2], self.num_heads, self.head_dim
-        if cache_start is None:
-            cache_start = current_start
-
-        q, _ = self.q(x)
-        q = self.norm_q(q).view(b, s, n, d)
-        k, _ = self.k(x)
-        k = self.norm_k(k).view(b, s, n, d)
-        v, _ = self.v(x)
-        v = v.view(b, s, n, d)
-
-        frame_seqlen = math.prod(grid_sizes[0][1:]).item()
-        num_new_frames = grid_sizes[0][0].item()
-        current_end = current_start + q.shape[1]
-        sink_tokens = self.sink_size * frame_seqlen
-        kv_cache_size = kv_cache["k"].shape[1]
-        num_new_tokens = q.shape[1]
-
-        cache_update_info = None
-        is_recompute = current_end <= kv_cache["global_end_index"].item() and current_start > 0
-
-        if self.local_attn_size != -1 and (current_end > kv_cache["global_end_index"].item()) and (
-                num_new_tokens + kv_cache["local_end_index"].item() > kv_cache_size):
-            # === ROLLING MODE: cache full, evict oldest non-sink tokens ===
-            num_evicted_tokens = num_new_tokens + kv_cache["local_end_index"].item() - kv_cache_size
-            num_rolled_tokens = kv_cache["local_end_index"].item() - num_evicted_tokens - sink_tokens
-            local_end_index = kv_cache["local_end_index"].item() + current_end - \
-                kv_cache["global_end_index"].item() - num_evicted_tokens
-            local_start_index = local_end_index - num_new_tokens
-
-            temp_k = kv_cache["k"].detach().clone()
-            temp_v = kv_cache["v"].detach().clone()
-            temp_k[:, sink_tokens:sink_tokens + num_rolled_tokens] = \
-                temp_k[:, sink_tokens + num_evicted_tokens:sink_tokens + num_evicted_tokens + num_rolled_tokens].clone()
-            temp_v[:, sink_tokens:sink_tokens + num_rolled_tokens] = \
-                temp_v[:, sink_tokens + num_evicted_tokens:sink_tokens + num_evicted_tokens + num_rolled_tokens].clone()
-
-            write_start_index = max(local_start_index, sink_tokens) if is_recompute else local_start_index
-            roped_offset = max(0, write_start_index - local_start_index)
-            write_len = max(0, local_end_index - write_start_index)
-            if write_len > 0:
-                temp_k[:, write_start_index:local_end_index] = k[:, roped_offset:roped_offset + write_len]
-                temp_v[:, write_start_index:local_end_index] = v[:, roped_offset:roped_offset + write_len]
-
-            # Block-Relativistic RoPE: query uses window-relative indices
-            query_relative_indices = torch.arange(
-                self.local_attn_size - num_new_frames, self.local_attn_size, device=q.device)
-            roped_query = block_relativistic_rope(
-                q, grid_sizes, freqs, relative_frame_indices=query_relative_indices).type_as(v)
-
-            # Block-Relativistic RoPE: cached K uses position-in-window indices
-            num_cache_frames = local_end_index // frame_seqlen
-            cache_relative_indices = torch.arange(0, num_cache_frames, device=k.device)
-            cache_grid_sizes = grid_sizes.clone()
-            cache_grid_sizes[0, 0] = num_cache_frames
-            roped_temp_k = block_relativistic_rope(
-                temp_k[:, :local_end_index].view(b, num_cache_frames, frame_seqlen, n, d).flatten(1, 2),
-                cache_grid_sizes, freqs, relative_frame_indices=cache_relative_indices).type_as(v)
-
-            cache_update_info = {
-                "action": "roll_and_insert",
-                "sink_tokens": sink_tokens,
-                "num_rolled_tokens": num_rolled_tokens,
-                "num_evicted_tokens": num_evicted_tokens,
-                "local_start_index": local_start_index,
-                "local_end_index": local_end_index,
-                "write_start_index": write_start_index,
-                "write_end_index": local_end_index,
-                "new_k": k[:, roped_offset:roped_offset + write_len],
-                "new_v": v[:, roped_offset:roped_offset + write_len],
-                "current_end": current_end,
-                "is_recompute": is_recompute
-            }
-        else:
-            # === DIRECT INSERT MODE: cache not yet full ===
-            local_end_index = kv_cache["local_end_index"].item() + current_end - kv_cache["global_end_index"].item()
-            local_start_index = local_end_index - num_new_tokens
-
-            temp_k = kv_cache["k"].detach().clone()
-            temp_v = kv_cache["v"].detach().clone()
-
-            write_start_index = max(local_start_index, sink_tokens) if is_recompute else local_start_index
-            if sink_recache_after_switch:
-                write_start_index = local_start_index
-            roped_offset = max(0, write_start_index - local_start_index)
-            write_len = max(0, local_end_index - write_start_index)
-            if write_len > 0:
-                temp_k[:, write_start_index:local_end_index] = k[:, roped_offset:roped_offset + write_len]
-                temp_v[:, write_start_index:local_end_index] = v[:, roped_offset:roped_offset + write_len]
-
-            # RoPE with relative indices (growing sequentially before cache fills)
-            current_frame_in_window = local_start_index // frame_seqlen
-            query_relative_indices = torch.arange(
-                current_frame_in_window, current_frame_in_window + num_new_frames, device=q.device)
-            roped_query = block_relativistic_rope(
-                q, grid_sizes, freqs, relative_frame_indices=query_relative_indices).type_as(v)
-
-            num_cache_frames = local_end_index // frame_seqlen
-            cache_relative_indices = torch.arange(0, num_cache_frames, device=k.device)
-            cache_grid_sizes = grid_sizes.clone()
-            cache_grid_sizes[0, 0] = num_cache_frames
-            roped_temp_k = block_relativistic_rope(
-                temp_k[:, :local_end_index].view(b, num_cache_frames, frame_seqlen, n, d).flatten(1, 2),
-                cache_grid_sizes, freqs, relative_frame_indices=cache_relative_indices).type_as(v)
-
-            cache_update_info = {
-                "action": "direct_insert",
-                "local_start_index": local_start_index,
-                "local_end_index": local_end_index,
-                "write_start_index": write_start_index,
-                "write_end_index": local_end_index,
-                "new_k": k[:, roped_offset:roped_offset + write_len],
-                "new_v": v[:, roped_offset:roped_offset + write_len],
-                "current_end": current_end,
-                "is_recompute": is_recompute
-            }
-
-        # Attention: sink tokens + local window
-        if sink_tokens > 0:
-            local_budget = self.max_attention_size - sink_tokens
-            k_sink = roped_temp_k[:, :sink_tokens]
-            v_sink = temp_v[:, :sink_tokens]
-            if local_budget > 0:
-                local_start_for_window = max(sink_tokens, local_end_index - local_budget)
-                k_local = roped_temp_k[:, local_start_for_window:local_end_index]
-                v_local = temp_v[:, local_start_for_window:local_end_index]
-                k_cat = torch.cat([k_sink, k_local], dim=1)
-                v_cat = torch.cat([v_sink, v_local], dim=1)
-            else:
-                k_cat = k_sink
-                v_cat = v_sink
-            x = attention(roped_query, k_cat, v_cat)
-        else:
-            window_start = max(0, local_end_index - self.max_attention_size)
-            x = attention(
-                roped_query,
-                roped_temp_k[:, window_start:local_end_index],
-                temp_v[:, window_start:local_end_index])
-
-        x = x.flatten(2)
-        x, _ = self.o(x)
-        return x, (current_end, local_end_index, cache_update_info)
-
-
-class CausalPropeSelfAttention(nn.Module):
-    """PRoPE self-attention with optional KV cache for camera-controlled inference."""
-
-    def __init__(self, dim, attn_dim, num_heads, window_size=(-1, -1),
-                 local_attn_size=-1, sink_size=0, qk_norm=True, eps=1e-6):
-        assert dim % num_heads == 0
-        assert attn_dim % num_heads == 0
-        super().__init__()
-        self.dim = dim
-        self.attn_dim = attn_dim
-        self.num_heads = num_heads
-        self.head_dim = attn_dim // num_heads
-        self.local_attn_size = local_attn_size
-        self.sink_size = sink_size
-        self.qk_norm = qk_norm
-        self.eps = eps
-        self.window_size = window_size
-        self.max_attention_size = 39600 if local_attn_size == -1 else local_attn_size * 880
-
-        self.q_proj = ReplicatedLinear(dim, attn_dim)
-        self.k_proj = ReplicatedLinear(dim, attn_dim)
-        self.v_proj = ReplicatedLinear(dim, attn_dim)
-        self.out_proj = ReplicatedLinear(attn_dim, dim)
-
-        self.norm_q = WanRMSNorm(attn_dim, eps=eps) if qk_norm else nn.Identity()
-        self.norm_k = WanRMSNorm(attn_dim, eps=eps) if qk_norm else nn.Identity()
-
-        nn.init.zeros_(self.out_proj.weight)
-        nn.init.zeros_(self.out_proj.bias)
-
-    def forward(self, x, cam_viewmats, cam_K, seq_lens, grid_sizes, freqs,
-                kv_cache=None, current_start=0, cache_start=None,
-                sink_recache_after_switch=False, cache_update_policy="commit_detached"):
-        """
-        Args:
-            x: Shape [B, L, C]
-            cam_viewmats: Camera view matrices
-            cam_K: Camera intrinsics
-            kv_cache: Optional KV cache dict. When None, runs full attention over current chunk.
-        """
-        b, s, n, d = *x.shape[:2], self.num_heads, self.head_dim
-        if cache_start is None:
-            cache_start = current_start
-
-        q, _ = self.q_proj(x)
-        q = self.norm_q(q).view(b, s, n, d)
-        k, _ = self.k_proj(x)
-        k = self.norm_k(k).view(b, s, n, d)
-        v, _ = self.v_proj(x)
-        v = v.view(b, s, n, d)
-
-        # Apply PRoPE (Positional Rotary Position Embedding from camera parameters)
-        q_t, k_t, v_t, apply_fn_o = prope_qkv(
-            q.transpose(1, 2), k.transpose(1, 2), v.transpose(1, 2),
-            viewmats=cam_viewmats, Ks=cam_K)
-        proped_q = q_t.transpose(1, 2)
-        proped_k = k_t.transpose(1, 2)
-        proped_v = v_t.transpose(1, 2)
-
-        if kv_cache is None:
-            # No cache: full attention over current chunk
-            x_out = attention(proped_q, proped_k, proped_v)
-        else:
-            # KV cache mode with rolling cache support
-            frame_seqlen = math.prod(grid_sizes[0][1:]).item()
-            num_new_tokens = s
-            current_end = current_start + num_new_tokens
-            sink_tokens = self.sink_size * frame_seqlen
-            kv_cache_size = kv_cache["k"].shape[1]
-            is_recompute = (current_end <= kv_cache["global_end_index"].item()) and (current_start > 0)
-
-            if self.local_attn_size != -1 and (current_end > kv_cache["global_end_index"].item()) and (
-                    num_new_tokens + kv_cache["local_end_index"].item() > kv_cache_size):
-                # === ROLLING MODE ===
-                num_evicted_tokens = num_new_tokens + kv_cache["local_end_index"].item() - kv_cache_size
-                num_rolled_tokens = kv_cache["local_end_index"].item() - num_evicted_tokens - sink_tokens
-                local_end_index = kv_cache["local_end_index"].item() + current_end - \
-                    kv_cache["global_end_index"].item() - num_evicted_tokens
-                local_start_index = local_end_index - num_new_tokens
-
-                if cache_update_policy != "none":
-                    with torch.no_grad():
-                        kv_cache["k"][:, sink_tokens:sink_tokens + num_rolled_tokens] = \
-                            kv_cache["k"][:, sink_tokens + num_evicted_tokens:sink_tokens + num_evicted_tokens + num_rolled_tokens].clone()
-                        kv_cache["v"][:, sink_tokens:sink_tokens + num_rolled_tokens] = \
-                            kv_cache["v"][:, sink_tokens + num_evicted_tokens:sink_tokens + num_evicted_tokens + num_rolled_tokens].clone()
-
-                    write_start_index = max(local_start_index, sink_tokens) if is_recompute else local_start_index
-                    roped_offset = max(0, write_start_index - local_start_index)
-                    write_len = max(0, local_end_index - write_start_index)
-                    if write_len > 0:
-                        with torch.no_grad():
-                            kv_cache["k"][:, write_start_index:local_end_index] = proped_k[:, roped_offset:roped_offset + write_len].detach()
-                            kv_cache["v"][:, write_start_index:local_end_index] = proped_v[:, roped_offset:roped_offset + write_len].detach()
-            else:
-                # === DIRECT INSERT MODE ===
-                local_end_index = kv_cache["local_end_index"].item() + current_end - kv_cache["global_end_index"].item()
-                local_start_index = local_end_index - num_new_tokens
-
-                if cache_update_policy != "none":
-                    write_start_index = max(local_start_index, sink_tokens) if is_recompute else local_start_index
-                    if sink_recache_after_switch:
-                        write_start_index = local_start_index
-                    roped_offset = max(0, write_start_index - local_start_index)
-                    write_len = max(0, local_end_index - write_start_index)
-                    if write_len > 0:
-                        with torch.no_grad():
-                            kv_cache["k"][:, write_start_index:local_end_index] = proped_k[:, roped_offset:roped_offset + write_len].detach()
-                            kv_cache["v"][:, write_start_index:local_end_index] = proped_v[:, roped_offset:roped_offset + write_len].detach()
-
-            # Attention: sink tokens + local window
-            if sink_tokens > 0:
-                local_budget = self.max_attention_size - sink_tokens
-                k_sink = kv_cache["k"][:, :sink_tokens].detach()
-                v_sink = kv_cache["v"][:, :sink_tokens].detach()
-                if local_budget > 0:
-                    local_start_for_window = max(sink_tokens, local_end_index - local_budget)
-                    k_local = kv_cache["k"][:, local_start_for_window:local_end_index].detach()
-                    v_local = kv_cache["v"][:, local_start_for_window:local_end_index].detach()
-                    k_cat = torch.cat([k_sink, k_local], dim=1)
-                    v_cat = torch.cat([v_sink, v_local], dim=1)
-                else:
-                    k_cat = k_sink
-                    v_cat = v_sink
-                x_out = attention(proped_q, k_cat, v_cat)
-            else:
-                window_start = max(0, local_end_index - self.max_attention_size)
-                x_out = attention(
-                    proped_q,
-                    kv_cache["k"][:, window_start:local_end_index].detach(),
-                    kv_cache["v"][:, window_start:local_end_index].detach())
-
-            if not is_recompute and cache_update_policy != "none":
-                kv_cache["global_end_index"].fill_(current_end)
-                kv_cache["local_end_index"].fill_(local_end_index)
-
-        # Apply inverse PRoPE
-        x = apply_fn_o(x_out.transpose(1, 2)).transpose(1, 2)
-        x = x.flatten(2)
-        x, _ = self.out_proj(x)
-        return x
-
-
-class CausalWanAttentionBlock(nn.Module):
-
-    def __init__(self, dim, ffn_dim, num_heads, local_attn_size=-1, sink_size=0,
-                 qk_norm=True, cross_attn_norm=False, eps=1e-6, **kwargs):
-        super().__init__()
-        self.dim = dim
-        self.ffn_dim = ffn_dim
-        self.num_heads = num_heads
-        self.local_attn_size = local_attn_size
-        self.qk_norm = qk_norm
-        self.cross_attn_norm = cross_attn_norm
-        self.eps = eps
-
-        self.add_control_adapter = kwargs.get('add_control_adapter', False)
-        self.cam_method = kwargs.get('cam_method')
-        self.attn_compress = kwargs.get('attn_compress', 1)
-        self.layer_idx = kwargs.get('layer_idx')
-        cam_self_attn_layers = kwargs.get('cam_self_attn_layers')
-
-        # layers
-        self.norm1 = WanLayerNorm(dim, eps)
-        self.self_attn = CausalWanSelfAttention(
-            dim, num_heads, local_attn_size, sink_size, qk_norm, eps)
-        self.norm3 = WanLayerNorm(
-            dim, eps, elementwise_affine=True) if cross_attn_norm else nn.Identity()
-        self.cross_attn = WanCrossAttention(dim, num_heads, (-1, -1), qk_norm, eps)
-        self.norm2 = WanLayerNorm(dim, eps)
-        # nn.Linear (not ReplicatedLinear) on purpose: the official checkpoint
-        # stores these as positional Sequential keys (ffn.0 / ffn.2) that the
-        # copy-only converter and the strict-load tests require verbatim, and
-        # ReplicatedLinear's (out, bias) tuple return cannot compose inside
-        # nn.Sequential without renaming the state-dict surface.
-        self.ffn = nn.Sequential(
-            nn.Linear(dim, ffn_dim), nn.GELU(approximate='tanh'),
-            nn.Linear(ffn_dim, dim))
-
-        # PRoPE self-attention branch for camera control
-        add_cam_attn = self.add_control_adapter and self.cam_method == 'prope'
-        if add_cam_attn and cam_self_attn_layers is not None:
-            add_cam_attn = self.layer_idx in cam_self_attn_layers
-        if add_cam_attn:
-            self.cam_self_attn = CausalPropeSelfAttention(
-                dim, dim // self.attn_compress, num_heads,
-                local_attn_size=local_attn_size, sink_size=sink_size,
-                qk_norm=qk_norm, eps=eps)
-
-        # modulation
-        self.modulation = nn.Parameter(torch.randn(1, 6, dim) / dim**0.5)
-
-    def forward(self, x, e, seq_lens, grid_sizes, freqs, context, context_lens,
-                kv_cache, crossattn_cache=None, current_start=0, cache_start=None,
-                cam_viewmats=None, cam_K=None, sink_recache_after_switch=False,
-                cache_update_policy="commit_detached"):
-        num_frames, frame_seqlen = e.shape[1], x.shape[1] // e.shape[1]
-        e = (self.modulation.unsqueeze(1) + e).chunk(6, dim=2)
-
-        # self-attention
-        attn_input = (self.norm1(x).unflatten(
-            dim=1, sizes=(num_frames, frame_seqlen)) * (1 + e[1]) + e[0]).flatten(1, 2)
-        y, cache_update_info = self.self_attn(
-            attn_input, seq_lens, grid_sizes, freqs, kv_cache,
-            current_start, cache_start, sink_recache_after_switch)
-
-        # PRoPE camera attention (parallel branch)
-        if hasattr(self, 'cam_self_attn') and cam_viewmats is not None and cam_K is not None:
-            prope_kv_cache = None
-            if kv_cache is not None and "prope_k" in kv_cache:
-                prope_kv_cache = {
-                    "k": kv_cache["prope_k"],
-                    "v": kv_cache["prope_v"],
-                    "global_end_index": kv_cache["prope_global_end_index"],
-                    "local_end_index": kv_cache["prope_local_end_index"],
-                }
-            y = y + self.cam_self_attn(
-                attn_input, cam_viewmats, cam_K, seq_lens, grid_sizes, freqs,
-                kv_cache=prope_kv_cache, current_start=current_start,
-                cache_start=cache_start, cache_update_policy=cache_update_policy)
-
-        x = x + (y.unflatten(dim=1, sizes=(num_frames, frame_seqlen)) * e[2]).flatten(1, 2)
-
-        # cross-attention & FFN
-        x = x + self.cross_attn(self.norm3(x), context, context_lens,
-                                crossattn_cache=crossattn_cache)
-        y = self.ffn(
-            (self.norm2(x).unflatten(dim=1, sizes=(num_frames, frame_seqlen))
-             * (1 + e[4]) + e[3]).flatten(1, 2))
-        x = x + (y.unflatten(dim=1, sizes=(num_frames, frame_seqlen)) * e[5]).flatten(1, 2)
-
-        return x, cache_update_info
-
-
-class CausalHead(nn.Module):
-
-    def __init__(self, dim, out_dim, patch_size, eps=1e-6):
-        super().__init__()
-        self.dim = dim
-        self.out_dim = out_dim
-        self.patch_size = patch_size
-        self.eps = eps
-
-        out_dim = math.prod(patch_size) * out_dim
-        self.norm = WanLayerNorm(dim, eps)
-        self.head = ReplicatedLinear(dim, out_dim)
-        self.modulation = nn.Parameter(torch.randn(1, 2, dim) / dim**0.5)
-
-    def forward(self, x, e):
-        num_frames, frame_seqlen = e.shape[1], x.shape[1] // e.shape[1]
-        e = (self.modulation.unsqueeze(1) + e).chunk(2, dim=2)
-        x, _ = self.head(
-            self.norm(x).unflatten(dim=1, sizes=(num_frames, frame_seqlen))
-            * (1 + e[1]) + e[0])
-        return x
-
-
-class DreamXWorldARTransformer3DModel(BaseDiT):
-    """DreamX-World-5B autoregressive causal transformer."""
-
-    _fsdp_shard_conditions = DreamXWorldARConfig()._fsdp_shard_conditions
-    _compile_conditions = DreamXWorldARConfig()._compile_conditions
-    _supported_attention_backends = DreamXWorldARConfig()._supported_attention_backends
-    param_names_mapping = DreamXWorldARConfig().param_names_mapping
-    reverse_param_names_mapping = DreamXWorldARConfig().reverse_param_names_mapping
-    lora_param_names_mapping = DreamXWorldARConfig().lora_param_names_mapping
-    _no_split_modules = ["CausalWanAttentionBlock"]
-
-    def __init__(self, config: DreamXWorldARConfig, hf_config: dict[str, Any]) -> None:
-        super().__init__(config=config, hf_config=hf_config)
-
-        model_type = config.model_type
-        patch_size = config.patch_size
-        text_len = config.text_len
-        in_dim = config.in_channels
-        dim = config.hidden_size
-        ffn_dim = config.ffn_dim
-        freq_dim = config.freq_dim
-        text_dim = config.text_dim
-        out_dim = config.out_channels
-        num_heads = config.num_attention_heads
-        num_layers = config.num_layers
-        local_attn_size = config.local_attn_size
-        sink_size = config.sink_size
-        qk_norm = bool(config.qk_norm)
-        cross_attn_norm = config.cross_attn_norm
-        eps = config.eps
-        add_control_adapter = config.add_control_adapter
-        cam_method = config.cam_method
-        attn_compress = config.attn_compress
-        cam_self_attn_layers = config.cam_self_attn_layers
-
-        assert model_type in ['t2v', 'i2v', 'ti2v']
-        self.model_type = model_type
-        self.patch_size = patch_size
-        self.text_len = text_len
-        self.in_dim = in_dim
-        self.dim = dim
-        self.ffn_dim = ffn_dim
-        self.freq_dim = freq_dim
-        self.text_dim = text_dim
-        self.out_dim = out_dim
-        self.num_heads = num_heads
-        self.num_layers = num_layers
-        self.local_attn_size = local_attn_size
-        self.qk_norm = qk_norm
-        self.cross_attn_norm = cross_attn_norm
-        self.eps = eps
-
-        # embeddings — nn.Linear inside nn.Sequential on purpose: the official
-        # checkpoint keys are positional (text_embedding.0/.2, time_embedding.0/.2,
-        # time_projection.1) and must load verbatim (see ffn comment above).
-        self.patch_embedding = nn.Conv3d(
-            in_dim, dim, kernel_size=patch_size, stride=patch_size)
-        self.text_embedding = nn.Sequential(
-            nn.Linear(text_dim, dim), nn.GELU(approximate='tanh'),
-            nn.Linear(dim, dim))
-        self.time_embedding = nn.Sequential(
-            nn.Linear(freq_dim, dim), nn.SiLU(), nn.Linear(dim, dim))
-        self.time_projection = nn.Sequential(
-            nn.SiLU(), nn.Linear(dim, dim * 6))
-
-        # transformer blocks
-        self.blocks = nn.ModuleList([
-            CausalWanAttentionBlock(
-                dim, ffn_dim, num_heads, local_attn_size, sink_size,
-                qk_norm, cross_attn_norm, eps,
-                add_control_adapter=add_control_adapter,
-                cam_method=cam_method,
-                attn_compress=attn_compress,
-                layer_idx=layer_idx,
-                cam_self_attn_layers=cam_self_attn_layers)
-            for layer_idx in range(num_layers)
-        ])
-        for layer_idx, block in enumerate(self.blocks):
-            block.self_attn.layer_idx = layer_idx
-            block.self_attn.num_layers = self.num_layers
-
-        # head
-        self.head = CausalHead(dim, out_dim, patch_size, eps)
-
-        # RoPE frequencies
-        assert (dim % num_heads) == 0 and (dim // num_heads) % 2 == 0
-        d = dim // num_heads
-        self.freqs = torch.cat([
-            rope_params(1024, d - 4 * (d // 6)),
-            rope_params(1024, 2 * (d // 6)),
-            rope_params(1024, 2 * (d // 6))
-        ], dim=1)
-
-        self.num_attention_heads = num_heads
-        self.attention_head_dim = dim // num_heads
-        self.hidden_size = dim
-        self.in_channels = in_dim
-        self.out_channels = out_dim
-        self.num_channels_latents = out_dim
-        self.init_weights()
-        self.num_frame_per_block = config.arch_config.num_frames_per_block
-        self.__post_init__()
-
-    def forward(self, x=None, t=None, context=None, seq_len=None, y=None, y_camera=None,
-                kv_cache=None, crossattn_cache=None, current_start=0,
-                cache_start=0, cache_update_policy="commit_detached",
-                hidden_states=None, encoder_hidden_states=None, timestep=None, **kwargs):
-        """
-        Causal inference with KV caching.
-        See Algorithm 2 of CausVid (https://arxiv.org/abs/2412.07772).
-
-        Args:
-            x: List of input video tensors [C_in, F, H, W]
-            t: Timestep tensor [B, L]
-            context: List of text embeddings [L, C]
-            seq_len: Maximum sequence length for positional encoding
-            y: Optional conditional video inputs (I2V mode)
-            y_camera: Camera parameters dict {'viewmats': ..., 'K': ...}
-            kv_cache: List of KV cache dicts per transformer block
-            crossattn_cache: List of cross-attention cache dicts
-            current_start: Current position in global token sequence
-            cache_start: Cache start position
-            cache_update_policy: Cache update strategy ('commit_detached' or 'none')
-
-        Returns:
-            Stacked output tensors [B, C_out, F, H/8, W/8]
-        """
-        if x is None and hidden_states is not None:
-            x = [sample for sample in hidden_states]
-        if t is None and timestep is not None:
-            t = timestep
-        if context is None and encoder_hidden_states is not None:
-            if isinstance(encoder_hidden_states, torch.Tensor):
-                context = [sample for sample in encoder_hidden_states]
-            else:
-                context = encoder_hidden_states
-        if seq_len is None:
-            if torch.is_tensor(t):
-                seq_len = int(t.shape[1]) if t.dim() > 1 else int(t.numel())
-            elif x is not None:
-                sample = x[0]
-                seq_len = (sample.shape[1] // self.patch_size[0]) * (sample.shape[2] // self.patch_size[1]) * (sample.shape[3] // self.patch_size[2])
-        if x is None or t is None or context is None or seq_len is None:
-            raise ValueError("DreamXWorldARTransformer3DModel requires x/t/context/seq_len or FastVideo aliases")
-
-        device = self.patch_embedding.weight.device
-        if self.freqs.is_meta or self.freqs.device != device:
-            d = self.dim // self.num_heads
-            self.freqs = torch.cat([
-                rope_params(1024, d - 4 * (d // 6)),
-                rope_params(1024, 2 * (d // 6)),
-                rope_params(1024, 2 * (d // 6)),
-            ], dim=1).to(device)
-
-        if y is not None:
-            x = [torch.cat([u, v], dim=0) for u, v in zip(x, y, strict=True)]
-
-        # patch embedding
-        x = [self.patch_embedding(u.unsqueeze(0)) for u in x]
-        grid_sizes = torch.stack(
-            [torch.tensor(u.shape[2:], dtype=torch.long) for u in x])
-        x = [u.flatten(2).transpose(1, 2) for u in x]
-        seq_lens = torch.tensor([u.size(1) for u in x], dtype=torch.long)
-        assert seq_lens.max() <= seq_len
-        x = torch.cat(x)
-
-        # time embedding
-        e = self.time_embedding(
-            sinusoidal_embedding_1d(self.freq_dim, t.flatten()).type_as(x))
-        e0 = self.time_projection(e).unflatten(
-            1, (6, self.dim)).unflatten(dim=0, sizes=t.shape)
-
-        # text embedding
-        context_lens = None
-        context = self.text_embedding(
-            torch.stack([
-                torch.cat(
-                    [u, u.new_zeros(self.text_len - u.size(0), u.size(1))])
-                for u in context
-            ]))
-
-        # camera parameters
-        if y_camera is not None and isinstance(y_camera, dict):
-            cam_viewmats = y_camera['viewmats']
-            cam_K = y_camera['K']
-        else:
-            cam_viewmats = None
-            cam_K = None
-
-        block_kwargs = dict(
-            e=e0, seq_lens=seq_lens, grid_sizes=grid_sizes, freqs=self.freqs,
-            context=context, context_lens=context_lens,
-            cam_viewmats=cam_viewmats, cam_K=cam_K,
-            cache_update_policy=cache_update_policy,
-        )
-
-        cache_update_infos = []
-        for block_index, block in enumerate(self.blocks):
-            block_kwargs.update({
-                "kv_cache": kv_cache[block_index] if kv_cache is not None else None,
-                "crossattn_cache": crossattn_cache[block_index] if crossattn_cache is not None else None,
-                "current_start": current_start,
-                "cache_start": cache_start,
-            })
-            x, block_cache_update_info = block(x, **block_kwargs)
-            if kv_cache is not None:
-                cache_update_infos.append((block_index, block_cache_update_info))
-
-        # Apply deferred cache updates
-        if kv_cache is not None and cache_update_infos and cache_update_policy != "none":
-            self._apply_cache_updates(kv_cache, cache_update_infos)
-
-        # head & unpatchify
-        x = self.head(x, e.unflatten(dim=0, sizes=t.shape).unsqueeze(2))
-        x = self.unpatchify(x, grid_sizes)
-        return torch.stack(x)
-
-    def _apply_cache_updates(self, kv_cache, cache_update_infos):
-        """Apply deferred cache updates collected from all transformer blocks.
-
-        For Block-Relativistic RoPE, this stores un-roped K values in the cache.
-        RoPE is applied dynamically during attention based on each token's current
-        relative position in the sliding window.
-        """
-        with torch.no_grad():
-            for block_index, (current_end, local_end_index, update_info) in cache_update_infos:
-                if update_info is not None:
-                    cache = kv_cache[block_index]
-
-                    if update_info["action"] == "roll_and_insert":
-                        sink_tokens = update_info["sink_tokens"]
-                        num_rolled_tokens = update_info["num_rolled_tokens"]
-                        num_evicted_tokens = update_info["num_evicted_tokens"]
-                        write_start_index = update_info.get("write_start_index", update_info["local_start_index"])
-                        write_end_index = update_info.get("write_end_index", update_info["local_end_index"])
-                        new_k = update_info["new_k"].detach()
-                        new_v = update_info["new_v"].detach()
-
-                        cache["k"][:, sink_tokens:sink_tokens + num_rolled_tokens] = \
-                            cache["k"][:, sink_tokens + num_evicted_tokens:sink_tokens + num_evicted_tokens + num_rolled_tokens].clone()
-                        cache["v"][:, sink_tokens:sink_tokens + num_rolled_tokens] = \
-                            cache["v"][:, sink_tokens + num_evicted_tokens:sink_tokens + num_evicted_tokens + num_rolled_tokens].clone()
-
-                        if write_end_index > write_start_index and new_k.shape[1] == (write_end_index - write_start_index):
-                            cache["k"][:, write_start_index:write_end_index] = new_k
-                            cache["v"][:, write_start_index:write_end_index] = new_v
-
-                    elif update_info["action"] == "direct_insert":
-                        write_start_index = update_info.get("write_start_index", update_info["local_start_index"])
-                        write_end_index = update_info.get("write_end_index", update_info["local_end_index"])
-                        new_k = update_info["new_k"].detach()
-                        new_v = update_info["new_v"].detach()
-
-                        if write_end_index > write_start_index and new_k.shape[1] == (write_end_index - write_start_index):
-                            cache["k"][:, write_start_index:write_end_index] = new_k
-                            cache["v"][:, write_start_index:write_end_index] = new_v
-
-                is_recompute = False if update_info is None else update_info.get("is_recompute", False)
-                if not is_recompute:
-                    kv_cache[block_index]["global_end_index"].fill_(current_end)
-                    kv_cache[block_index]["local_end_index"].fill_(local_end_index)
-
-    def unpatchify(self, x, grid_sizes):
-        """Reconstruct video tensors from patch embeddings."""
-        c = self.out_dim
-        out = []
-        for u, v in zip(x, grid_sizes.tolist(), strict=True):
-            u = u[:math.prod(v)].view(*v, *self.patch_size, c)
-            u = torch.einsum('fhwpqrc->cfphqwr', u)
-            u = u.reshape(c, *[i * j for i, j in zip(v, self.patch_size, strict=True)])
-            out.append(u)
-        return out
-
-    def init_weights(self):
-        """Initialize model parameters using Xavier initialization."""
-        for m in self.modules():
-            if isinstance(m, (nn.Linear, ReplicatedLinear)):
-                nn.init.xavier_uniform_(m.weight)
-                if m.bias is not None:
-                    nn.init.zeros_(m.bias)
-
-        nn.init.xavier_uniform_(self.patch_embedding.weight.flatten(1))
-        for m in self.text_embedding.modules():
-            if isinstance(m, nn.Linear):
-                nn.init.normal_(m.weight, std=.02)
-        for m in self.time_embedding.modules():
-            if isinstance(m, nn.Linear):
-                nn.init.normal_(m.weight, std=.02)
-
-        nn.init.zeros_(self.head.head.weight)
-
-
-EntryClass = DreamXWorldARTransformer3DModel
@@ -1,578 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-
-from __future__ import annotations
-
-from contextlib import nullcontext
-from dataclasses import dataclass
-import math
-from typing import Any
-
-import torch
-import torch.nn as nn
-
-from fastvideo.layers.rotary_embedding import apply_rotary_emb, get_1d_rotary_pos_embed
-
-from fastvideo.attention import DistributedAttention
-from fastvideo.configs.models import DiTConfig
-from fastvideo.forward_context import get_forward_context, set_forward_context
-from fastvideo.layers.linear import ReplicatedLinear
-from fastvideo.layers.visual_embedding import Timesteps
-from fastvideo.models.dits.base import BaseDiT
-from fastvideo.models.dits.sd3 import (
-    CombinedTimestepTextProjEmbeddings,
-    SD3AdaLayerNormContinuous,
-    SD3AdaLayerNormZero,
-    SD3FeedForward,
-    SD3TextProjection,
-    SD3TimestepEmbedding,
-)
-from fastvideo.platforms import AttentionBackendEnum
-
-
-@dataclass
-class FluxTransformer2DModelOutput:
-    sample: torch.Tensor
-
-
-class FluxPosEmbed(nn.Module):
-    """1D RoPE axes concatenated per Diffusers `FluxPosEmbed`."""
-
-    def __init__(self, theta: int, axes_dim: list[int]) -> None:
-        super().__init__()
-        self.theta = theta
-        self.axes_dim = axes_dim
-
-    def forward(self, ids: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]:
-        n_axes = ids.shape[-1]
-        cos_out: list[torch.Tensor] = []
-        sin_out: list[torch.Tensor] = []
-        pos = ids.float()
-        is_mps = ids.device.type == "mps"
-        is_npu = ids.device.type == "npu"
-        freqs_dtype = torch.float32 if (is_mps or is_npu) else torch.float64
-        for i in range(n_axes):
-            cos, sin = get_1d_rotary_pos_embed(
-                self.axes_dim[i],
-                pos[:, i],
-                theta=self.theta,
-                use_real=True,
-                freqs_dtype=freqs_dtype,
-            )
-            cos_out.append(cos)
-            sin_out.append(sin)
-        freqs_cos = torch.cat(cos_out, dim=-1).to(ids.device)
-        freqs_sin = torch.cat(sin_out, dim=-1).to(ids.device)
-        return freqs_cos, freqs_sin
-
-
-class FluxCombinedTimestepGuidanceTextProjEmbeddings(nn.Module):
-    def __init__(self, embedding_dim: int, pooled_projection_dim: int) -> None:
-        super().__init__()
-        self.time_proj = Timesteps(
-            num_channels=256,
-            flip_sin_to_cos=True,
-            downscale_freq_shift=0,
-        )
-        self.timestep_embedder = SD3TimestepEmbedding(
-            in_channels=256,
-            time_embed_dim=embedding_dim,
-            act_fn="silu",
-        )
-        self.guidance_embedder = SD3TimestepEmbedding(
-            in_channels=256,
-            time_embed_dim=embedding_dim,
-            act_fn="silu",
-        )
-        self.text_embedder = SD3TextProjection(
-            pooled_projection_dim,
-            embedding_dim,
-            act_fn="silu",
-        )
-
-    def forward(
-        self,
-        timestep: torch.Tensor,
-        guidance: torch.Tensor,
-        pooled_projection: torch.Tensor,
-    ) -> torch.Tensor:
-        timesteps_proj = self.time_proj(timestep)
-        timesteps_emb = self.timestep_embedder(timesteps_proj.to(dtype=pooled_projection.dtype))
-        guidance_proj = self.time_proj(guidance)
-        guidance_emb = self.guidance_embedder(guidance_proj.to(dtype=pooled_projection.dtype))
-        time_guidance_emb = timesteps_emb + guidance_emb
-        pooled_projections = self.text_embedder(pooled_projection)
-        return time_guidance_emb + pooled_projections
-
-
-class FluxAdaLayerNormZeroSingle(nn.Module):
-    def __init__(self, embedding_dim: int, bias: bool = True) -> None:
-        super().__init__()
-        self.silu = nn.SiLU()
-        self.linear = ReplicatedLinear(embedding_dim, 3 * embedding_dim, bias=bias)
-        self.norm = nn.LayerNorm(embedding_dim, elementwise_affine=False, eps=1e-6)
-
-    def forward(
-        self,
-        x: torch.Tensor,
-        emb: torch.Tensor,
-    ) -> tuple[torch.Tensor, torch.Tensor]:
-        emb, _ = self.linear(self.silu(emb))
-        shift_msa, scale_msa, gate_msa = emb.chunk(3, dim=1)
-        x = self.norm(x) * (1 + scale_msa[:, None]) + shift_msa[:, None]
-        return x, gate_msa
-
-
-class FluxJointAttention(nn.Module):
-    """Joint attention: text tokens precede image tokens (Diffusers order)."""
-
-    def __init__(
-        self,
-        dim: int,
-        num_attention_heads: int,
-        attention_head_dim: int,
-        supported_attention_backends: tuple[AttentionBackendEnum, ...] | None = None,
-    ) -> None:
-        super().__init__()
-        self.heads = num_attention_heads
-        self.head_dim = attention_head_dim
-        self.inner_dim = num_attention_heads * attention_head_dim
-
-        self.norm_q = nn.RMSNorm(attention_head_dim, eps=1e-6)
-        self.norm_k = nn.RMSNorm(attention_head_dim, eps=1e-6)
-        self.norm_added_q = nn.RMSNorm(attention_head_dim, eps=1e-6)
-        self.norm_added_k = nn.RMSNorm(attention_head_dim, eps=1e-6)
-
-        self.to_q = ReplicatedLinear(dim, self.inner_dim, bias=True)
-        self.to_k = ReplicatedLinear(dim, self.inner_dim, bias=True)
-        self.to_v = ReplicatedLinear(dim, self.inner_dim, bias=True)
-        self.add_q_proj = ReplicatedLinear(dim, self.inner_dim, bias=True)
-        self.add_k_proj = ReplicatedLinear(dim, self.inner_dim, bias=True)
-        self.add_v_proj = ReplicatedLinear(dim, self.inner_dim, bias=True)
-
-        self.to_out = nn.ModuleList(
-            [
-                ReplicatedLinear(self.inner_dim, dim, bias=True),
-                nn.Dropout(0.0),
-            ]
-        )
-        self.to_add_out = ReplicatedLinear(self.inner_dim, dim, bias=True)
-
-        self.attn = DistributedAttention(
-            num_heads=num_attention_heads,
-            head_size=attention_head_dim,
-            causal=False,
-            supported_attention_backends=supported_attention_backends,
-        )
-
-    def forward(
-        self,
-        hidden_states: torch.Tensor,
-        encoder_hidden_states: torch.Tensor,
-        image_rotary_emb: tuple[torch.Tensor, torch.Tensor],
-    ) -> tuple[torch.Tensor, torch.Tensor]:
-        batch_size = hidden_states.shape[0]
-        text_seq_len = encoder_hidden_states.shape[1]
-        img_seq_len = hidden_states.shape[1]
-
-        q, _ = self.to_q(hidden_states)
-        k, _ = self.to_k(hidden_states)
-        v, _ = self.to_v(hidden_states)
-        q = q.view(batch_size, img_seq_len, self.heads, self.head_dim)
-        k = k.view(batch_size, img_seq_len, self.heads, self.head_dim)
-        v = v.view(batch_size, img_seq_len, self.heads, self.head_dim)
-        q = self.norm_q(q)
-        k = self.norm_k(k)
-
-        enc_q, _ = self.add_q_proj(encoder_hidden_states)
-        enc_k, _ = self.add_k_proj(encoder_hidden_states)
-        enc_v, _ = self.add_v_proj(encoder_hidden_states)
-        enc_q = enc_q.view(batch_size, text_seq_len, self.heads, self.head_dim)
-        enc_k = enc_k.view(batch_size, text_seq_len, self.heads, self.head_dim)
-        enc_v = enc_v.view(batch_size, text_seq_len, self.heads, self.head_dim)
-        enc_q = self.norm_added_q(enc_q)
-        enc_k = self.norm_added_k(enc_k)
-
-        q = torch.cat([enc_q, q], dim=1)
-        k = torch.cat([enc_k, k], dim=1)
-        v = torch.cat([enc_v, v], dim=1)
-
-        q = apply_rotary_emb(q, image_rotary_emb, sequence_dim=1)
-        k = apply_rotary_emb(k, image_rotary_emb, sequence_dim=1)
-
-        joint_out, _ = self.attn(q, k, v)
-        joint_out = joint_out.reshape(batch_size, text_seq_len + img_seq_len, self.inner_dim)
-
-        enc_out = joint_out[:, :text_seq_len]
-        img_out = joint_out[:, text_seq_len:]
-
-        img_out, _ = self.to_out[0](img_out)
-        img_out = self.to_out[1](img_out)
-        enc_out, _ = self.to_add_out(enc_out)
-        return img_out, enc_out
-
-
-class FluxSingleStreamAttention(nn.Module):
-    """Self-attention on concatenated text+image sequence (single blocks)."""
-
-    def __init__(
-        self,
-        dim: int,
-        num_attention_heads: int,
-        attention_head_dim: int,
-        supported_attention_backends: tuple[AttentionBackendEnum, ...] | None = None,
-    ) -> None:
-        super().__init__()
-        self.heads = num_attention_heads
-        self.head_dim = attention_head_dim
-        self.inner_dim = num_attention_heads * attention_head_dim
-
-        self.norm_q = nn.RMSNorm(attention_head_dim, eps=1e-6)
-        self.norm_k = nn.RMSNorm(attention_head_dim, eps=1e-6)
-        self.to_q = ReplicatedLinear(dim, self.inner_dim, bias=True)
-        self.to_k = ReplicatedLinear(dim, self.inner_dim, bias=True)
-        self.to_v = ReplicatedLinear(dim, self.inner_dim, bias=True)
-        self.attn = DistributedAttention(
-            num_heads=num_attention_heads,
-            head_size=attention_head_dim,
-            causal=False,
-            supported_attention_backends=supported_attention_backends,
-        )
-
-    def forward(
-        self,
-        hidden_states: torch.Tensor,
-        image_rotary_emb: tuple[torch.Tensor, torch.Tensor],
-    ) -> torch.Tensor:
-        batch_size, seq_len, _ = hidden_states.shape
-        q, _ = self.to_q(hidden_states)
-        k, _ = self.to_k(hidden_states)
-        v, _ = self.to_v(hidden_states)
-        q = q.view(batch_size, seq_len, self.heads, self.head_dim)
-        k = k.view(batch_size, seq_len, self.heads, self.head_dim)
-        v = v.view(batch_size, seq_len, self.heads, self.head_dim)
-        q = self.norm_q(q)
-        k = self.norm_k(k)
-        q = apply_rotary_emb(q, image_rotary_emb, sequence_dim=1)
-        k = apply_rotary_emb(k, image_rotary_emb, sequence_dim=1)
-        out, _ = self.attn(q, k, v)
-        return out.reshape(batch_size, seq_len, self.inner_dim)
-
-
-class FluxTransformerBlock(nn.Module):
-    def __init__(
-        self,
-        dim: int,
-        num_attention_heads: int,
-        attention_head_dim: int,
-        supported_attention_backends: tuple[AttentionBackendEnum, ...] | None = None,
-    ) -> None:
-        super().__init__()
-        self.norm1 = SD3AdaLayerNormZero(dim)
-        self.norm1_context = SD3AdaLayerNormZero(dim)
-        self.attn = FluxJointAttention(
-            dim=dim,
-            num_attention_heads=num_attention_heads,
-            attention_head_dim=attention_head_dim,
-            supported_attention_backends=supported_attention_backends,
-        )
-        self.norm2 = nn.LayerNorm(dim, elementwise_affine=False, eps=1e-6)
-        self.ff = SD3FeedForward(
-            dim=dim,
-            dim_out=dim,
-            activation_fn="gelu-approximate",
-        )
-        self.norm2_context = nn.LayerNorm(dim, elementwise_affine=False, eps=1e-6)
-        self.ff_context = SD3FeedForward(
-            dim=dim,
-            dim_out=dim,
-            activation_fn="gelu-approximate",
-        )
-
-    def forward(
-        self,
-        hidden_states: torch.Tensor,
-        encoder_hidden_states: torch.Tensor,
-        temb: torch.Tensor,
-        image_rotary_emb: tuple[torch.Tensor, torch.Tensor],
-        joint_attention_kwargs: dict[str, Any] | None = None,
-    ) -> tuple[torch.Tensor, torch.Tensor]:
-        del joint_attention_kwargs
-        norm_hidden_states, gate_msa, shift_mlp, scale_mlp, gate_mlp = self.norm1(hidden_states, emb=temb)
-        (norm_encoder_hidden_states, c_gate_msa, c_shift_mlp, c_scale_mlp, c_gate_mlp) = self.norm1_context(
-            encoder_hidden_states, emb=temb
-        )
-
-        attn_output, context_attn_output = self.attn(
-            hidden_states=norm_hidden_states,
-            encoder_hidden_states=norm_encoder_hidden_states,
-            image_rotary_emb=image_rotary_emb,
-        )
-
-        attn_output = gate_msa.unsqueeze(1) * attn_output
-        hidden_states = hidden_states + attn_output
-
-        norm_hidden_states = self.norm2(hidden_states)
-        norm_hidden_states = norm_hidden_states * (1 + scale_mlp[:, None]) + shift_mlp[:, None]
-        ff_output = self.ff(norm_hidden_states)
-        hidden_states = hidden_states + gate_mlp.unsqueeze(1) * ff_output
-
-        context_attn_output = c_gate_msa.unsqueeze(1) * context_attn_output
-        encoder_hidden_states = encoder_hidden_states + context_attn_output
-
-        norm_encoder_hidden_states = self.norm2_context(encoder_hidden_states)
-        norm_encoder_hidden_states = norm_encoder_hidden_states * (1 + c_scale_mlp[:, None]) + c_shift_mlp[:, None]
-        context_ff_output = self.ff_context(norm_encoder_hidden_states)
-        encoder_hidden_states = encoder_hidden_states + (c_gate_mlp.unsqueeze(1) * context_ff_output)
-        if encoder_hidden_states.dtype == torch.float16:
-            encoder_hidden_states = encoder_hidden_states.clip(-65504, 65504)
-
-        return encoder_hidden_states, hidden_states
-
-
-class FluxSingleTransformerBlock(nn.Module):
-    def __init__(
-        self,
-        dim: int,
-        num_attention_heads: int,
-        attention_head_dim: int,
-        mlp_ratio: float = 4.0,
-        supported_attention_backends: tuple[AttentionBackendEnum, ...] | None = None,
-    ) -> None:
-        super().__init__()
-        mlp_hidden_dim = int(dim * mlp_ratio)
-        self.norm = FluxAdaLayerNormZeroSingle(dim)
-        self.proj_mlp = ReplicatedLinear(dim, mlp_hidden_dim, bias=True)
-        self.act_mlp = nn.GELU(approximate="tanh")
-        self.proj_out = ReplicatedLinear(dim + mlp_hidden_dim, dim, bias=True)
-        self.attn = FluxSingleStreamAttention(
-            dim=dim,
-            num_attention_heads=num_attention_heads,
-            attention_head_dim=attention_head_dim,
-            supported_attention_backends=supported_attention_backends,
-        )
-
-    def forward(
-        self,
-        hidden_states: torch.Tensor,
-        encoder_hidden_states: torch.Tensor,
-        temb: torch.Tensor,
-        image_rotary_emb: tuple[torch.Tensor, torch.Tensor],
-        joint_attention_kwargs: dict[str, Any] | None = None,
-    ) -> tuple[torch.Tensor, torch.Tensor]:
-        del joint_attention_kwargs
-        text_seq_len = encoder_hidden_states.shape[1]
-        hidden_states = torch.cat([encoder_hidden_states, hidden_states], dim=1)
-        residual = hidden_states
-        norm_hidden_states, gate = self.norm(hidden_states, emb=temb)
-        mlp_hidden_states = self.act_mlp(self.proj_mlp(norm_hidden_states)[0])
-        attn_output = self.attn(
-            hidden_states=norm_hidden_states,
-            image_rotary_emb=image_rotary_emb,
-        )
-        hidden_states = torch.cat([attn_output, mlp_hidden_states], dim=2)
-        gate = gate.unsqueeze(1)
-        hidden_states = gate * self.proj_out(hidden_states)[0]
-        hidden_states = residual + hidden_states
-        if hidden_states.dtype == torch.float16:
-            hidden_states = hidden_states.clip(-65504, 65504)
-        encoder_hidden_states = hidden_states[:, :text_seq_len]
-        hidden_states = hidden_states[:, text_seq_len:]
-        return encoder_hidden_states, hidden_states
-
-
-class FluxTransformer2DModel(BaseDiT):
-    """FastVideo FLUX transformer; load Diffusers FLUX safetensors 1:1."""
-
-    _fsdp_shard_conditions = [
-        lambda n, m: (n.startswith("transformer_blocks.") or n.startswith("single_transformer_blocks."))
-        and n.split(".")[-1].isdigit(),
-    ]
-    _compile_conditions = _fsdp_shard_conditions
-    # HF weight names already match this module layout (cf. SGLang regex maps).
-    param_names_mapping: dict[str, Any] = {}
-    reverse_param_names_mapping: dict[str, Any] = {}
-    lora_param_names_mapping: dict[str, Any] = {}
-    _supported_attention_backends = (
-        AttentionBackendEnum.FLASH_ATTN,
-        AttentionBackendEnum.TORCH_SDPA,
-    )
-
-    def __init__(self, config: DiTConfig, hf_config: dict[str, Any], **kwargs) -> None:
-        del kwargs
-        super().__init__(config=config, hf_config=hf_config)
-        self.fastvideo_config = config
-        self.hf_config = hf_config
-        arch = config.arch_config
-
-        out_ch = arch.out_channels
-        self.out_channels = out_ch if out_ch is not None else arch.in_channels
-        self.inner_dim = arch.num_attention_heads * arch.attention_head_dim
-        self.hidden_size = self.inner_dim
-        self.num_attention_heads = arch.num_attention_heads
-        self.num_channels_latents = arch.in_channels
-
-        axes_list = list(arch.axes_dims_rope)
-        self.pos_embed = FluxPosEmbed(theta=10000, axes_dim=axes_list)
-        if arch.guidance_embeds:
-            self.time_text_embed = FluxCombinedTimestepGuidanceTextProjEmbeddings(
-                embedding_dim=self.inner_dim,
-                pooled_projection_dim=arch.pooled_projection_dim,
-            )
-        else:
-            self.time_text_embed = CombinedTimestepTextProjEmbeddings(
-                embedding_dim=self.inner_dim,
-                pooled_projection_dim=arch.pooled_projection_dim,
-            )
-        self.context_embedder = ReplicatedLinear(arch.joint_attention_dim, self.inner_dim)
-        self.x_embedder = ReplicatedLinear(arch.in_channels, self.inner_dim)
-
-        self.transformer_blocks = nn.ModuleList(
-            [
-                FluxTransformerBlock(
-                    dim=self.inner_dim,
-                    num_attention_heads=arch.num_attention_heads,
-                    attention_head_dim=arch.attention_head_dim,
-                    supported_attention_backends=self._supported_attention_backends,
-                )
-                for _ in range(arch.num_layers)
-            ]
-        )
-        self.single_transformer_blocks = nn.ModuleList(
-            [
-                FluxSingleTransformerBlock(
-                    dim=self.inner_dim,
-                    num_attention_heads=arch.num_attention_heads,
-                    attention_head_dim=arch.attention_head_dim,
-                    supported_attention_backends=self._supported_attention_backends,
-                )
-                for _ in range(arch.num_single_layers)
-            ]
-        )
-
-        self.norm_out = SD3AdaLayerNormContinuous(
-            self.inner_dim,
-            self.inner_dim,
-            elementwise_affine=False,
-            eps=1e-6,
-            bias=True,
-            norm_type="layer_norm",
-        )
-        self.proj_out = ReplicatedLinear(
-            self.inner_dim,
-            arch.patch_size * arch.patch_size * self.out_channels,
-            bias=True,
-        )
-        self.gradient_checkpointing = False
-        self.__post_init__()
-
-    def forward(
-        self,
-        hidden_states: torch.Tensor,
-        encoder_hidden_states: torch.Tensor | None = None,
-        pooled_projections: torch.Tensor | None = None,
-        timestep: torch.LongTensor | torch.Tensor | None = None,
-        img_ids: torch.Tensor | None = None,
-        txt_ids: torch.Tensor | None = None,
-        guidance: torch.Tensor | None = None,
-        joint_attention_kwargs: dict[str, Any] | None = None,
-        return_dict: bool = True,
-        controlnet_block_samples: Any | None = None,
-        controlnet_single_block_samples: Any | None = None,
-        controlnet_blocks_repeat: bool = False,
-        **kwargs: Any,
-    ) -> FluxTransformer2DModelOutput | tuple[torch.Tensor, ...]:
-        del kwargs
-        if encoder_hidden_states is None:
-            raise ValueError("encoder_hidden_states must be provided")
-        if pooled_projections is None:
-            raise ValueError("pooled_projections must be provided")
-        if timestep is None:
-            raise ValueError("timestep must be provided")
-        if img_ids is None or txt_ids is None:
-            raise ValueError("img_ids and txt_ids must be provided")
-
-        arch = self.fastvideo_config.arch_config
-        if arch.guidance_embeds and guidance is None:
-            raise ValueError("guidance must be provided when guidance_embeds=True")
-
-        if timestep.dim() == 0:
-            timestep = timestep[None]
-        if timestep.dim() > 1:
-            timestep = timestep.reshape(-1)
-        if timestep.shape[0] == 1 and hidden_states.shape[0] > 1:
-            timestep = timestep.expand(hidden_states.shape[0])
-
-        try:
-            get_forward_context()
-            forward_context = nullcontext()
-        except AssertionError:
-            if timestep.numel() == 0:
-                ts0 = 0
-            elif torch.is_floating_point(timestep):
-                ts0 = int(round(timestep[0].item() * 1000))
-            else:
-                ts0 = int(timestep[0].item())
-            forward_context = set_forward_context(current_timestep=ts0, attn_metadata=None)
-
-        with forward_context:
-            hidden_states, _ = self.x_embedder(hidden_states)
-
-            ts = timestep.to(hidden_states.dtype) * 1000
-            g = None if guidance is None else guidance.to(hidden_states.dtype) * 1000
-
-            if arch.guidance_embeds:
-                assert g is not None
-                temb = self.time_text_embed(ts, g, pooled_projections)
-            else:
-                temb = self.time_text_embed(timestep=ts, pooled_projection=pooled_projections)
-
-            encoder_hidden_states, _ = self.context_embedder(encoder_hidden_states)
-
-            if txt_ids.ndim == 3:
-                txt_ids = txt_ids[0]
-            if img_ids.ndim == 3:
-                img_ids = img_ids[0]
-
-            ids = torch.cat((txt_ids, img_ids), dim=0)
-            image_rotary_emb = self.pos_embed(ids)
-
-            jkwargs = joint_attention_kwargs or {}
-
-            for idx, block in enumerate(self.transformer_blocks):
-                encoder_hidden_states, hidden_states = block(
-                    hidden_states=hidden_states,
-                    encoder_hidden_states=encoder_hidden_states,
-                    temb=temb,
-                    image_rotary_emb=image_rotary_emb,
-                    joint_attention_kwargs=jkwargs,
-                )
-                if controlnet_block_samples:
-                    interval = len(self.transformer_blocks) / len(controlnet_block_samples)
-                    interval = int(math.ceil(interval))
-                    if controlnet_blocks_repeat:
-                        hidden_states = hidden_states + controlnet_block_samples[idx % len(controlnet_block_samples)]
-                    else:
-                        hidden_states = hidden_states + controlnet_block_samples[idx // interval]
-
-            for idx, block in enumerate(self.single_transformer_blocks):
-                encoder_hidden_states, hidden_states = block(
-                    hidden_states=hidden_states,
-                    encoder_hidden_states=encoder_hidden_states,
-                    temb=temb,
-                    image_rotary_emb=image_rotary_emb,
-                    joint_attention_kwargs=jkwargs,
-                )
-                if controlnet_single_block_samples:
-                    interval = len(self.single_transformer_blocks) / len(controlnet_single_block_samples)
-                    interval = int(math.ceil(interval))
-                    hidden_states = hidden_states + controlnet_single_block_samples[idx // interval]
-
-            hidden_states = self.norm_out(hidden_states, temb)
-            output, _ = self.proj_out(hidden_states)
-
-            if not return_dict:
-                return (output,)
-            return FluxTransformer2DModelOutput(sample=output)
-
-
-EntryClass = FluxTransformer2DModel
@@ -1,776 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-from typing import Any, Dict, List, Optional, Tuple, Union
-
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-from fastvideo.layers.mlp import MLP
-
-from fastvideo.attention import LocalAttention
-from fastvideo.configs.models.dits.glm_image import GlmImageDiTConfig
-from fastvideo.layers.layernorm import ScaleResidualLayerNormScaleShift
-from fastvideo.layers.linear import ReplicatedLinear
-from fastvideo.layers.rotary_embedding import _apply_rotary_emb
-from fastvideo.layers.visual_embedding import Timesteps
-from fastvideo.models.dits.base import BaseDiT
-from fastvideo.platforms import AttentionBackendEnum
-
-
-class GlmImageLayerKVCache:
-
-    def __init__(self):
-        self.k_cache = None
-        self.v_cache = None
-        self.mode: Optional[str] = None
-
-    def store(self, k: torch.Tensor, v: torch.Tensor):
-        # Append along seq (dim=1).
-        if self.k_cache is None:
-            self.k_cache = k
-            self.v_cache = v
-        else:
-            self.k_cache = torch.cat([self.k_cache, k], dim=1)
-            self.v_cache = torch.cat([self.v_cache, v], dim=1)
-
-    def get(self):
-        return self.k_cache, self.v_cache
-
-    def clear(self):
-        self.k_cache = None
-        self.v_cache = None
-        self.mode = None
-
-
-class GlmImageKVCache:
-
-    def __init__(self, num_layers: int):
-        self.num_layers = num_layers
-        self.caches = [GlmImageLayerKVCache() for _ in range(num_layers)]
-
-    def __getitem__(self, layer_idx: int) -> GlmImageLayerKVCache:
-        return self.caches[layer_idx]
-
-    def set_mode(self, mode: Optional[str]):
-        if mode is not None and mode not in ["write", "read", "skip"]:
-            raise ValueError(
-                f"Invalid mode: {mode}, must be one of 'write', 'read', 'skip'"
-            )
-        for cache in self.caches:
-            cache.mode = mode
-
-    def clear(self):
-        for cache in self.caches:
-            cache.clear()
-
-
-# =============================================================================
-# Timestep and Text Projection
-# =============================================================================
-class GlmImageTimestepEmbedding(nn.Module):
-
-    def __init__(
-        self,
-        in_channels: int,
-        time_embed_dim: int,
-        act_fn: str = "silu",
-        out_dim: int = None,
-    ):
-        super().__init__()
-        if out_dim is None:
-            out_dim = time_embed_dim
-        self.linear_1 = ReplicatedLinear(in_channels, time_embed_dim, bias=True)
-        if act_fn == "silu":
-            self.act = nn.SiLU()
-        elif act_fn == "gelu":
-            self.act = nn.GELU(approximate="tanh")
-        else:
-            self.act = nn.SiLU()
-        self.linear_2 = ReplicatedLinear(time_embed_dim, out_dim, bias=True)
-
-    def forward(self, sample: torch.Tensor) -> torch.Tensor:
-        sample, _ = self.linear_1(sample)
-        sample = self.act(sample)
-        sample, _ = self.linear_2(sample)
-        return sample
-
-
-class GlmImageTextProjection(nn.Module):
-
-    def __init__(
-        self,
-        in_features: int,
-        hidden_size: int,
-        out_features: int = None,
-        act_fn: str = "silu",
-    ):
-        super().__init__()
-        if out_features is None:
-            out_features = hidden_size
-        self.linear_1 = ReplicatedLinear(in_features, hidden_size, bias=True)
-        if act_fn == "silu":
-            self.act_1 = nn.SiLU()
-        elif act_fn == "gelu_tanh":
-            self.act_1 = nn.GELU(approximate="tanh")
-        else:
-            self.act_1 = nn.SiLU()
-        self.linear_2 = ReplicatedLinear(hidden_size, out_features, bias=True)
-
-    def forward(self, caption: torch.Tensor) -> torch.Tensor:
-        hidden_states, _ = self.linear_1(caption)
-        hidden_states = self.act_1(hidden_states)
-        hidden_states, _ = self.linear_2(hidden_states)
-        return hidden_states
-
-
-class GlmImageCombinedTimestepSizeEmbeddings(nn.Module):
-
-    def __init__(
-        self,
-        embedding_dim: int,
-        condition_dim: int,
-        pooled_projection_dim: int,
-        timesteps_dim: int = 256,
-    ):
-        super().__init__()
-
-        self.time_proj = Timesteps(
-            num_channels=timesteps_dim, flip_sin_to_cos=True, downscale_freq_shift=0
-        )
-        self.condition_proj = Timesteps(
-            num_channels=condition_dim, flip_sin_to_cos=True, downscale_freq_shift=0
-        )
-        self.timestep_embedder = GlmImageTimestepEmbedding(
-            in_channels=timesteps_dim, time_embed_dim=embedding_dim
-        )
-        self.condition_embedder = GlmImageTextProjection(
-            pooled_projection_dim, embedding_dim, act_fn="silu"
-        )
-
-    def forward(
-        self,
-        timestep: torch.Tensor,
-        target_size: torch.Tensor,
-        crop_coords: torch.Tensor,
-        hidden_dtype: torch.dtype,
-    ) -> torch.Tensor:
-        timesteps_proj = self.time_proj(timestep)
-
-        crop_coords_proj = self.condition_proj(crop_coords.flatten()).view(
-            crop_coords.size(0), -1
-        )
-        target_size_proj = self.condition_proj(target_size.flatten()).view(
-            target_size.size(0), -1
-        )
-
-        condition_proj = torch.cat([crop_coords_proj, target_size_proj], dim=1)
-
-        timesteps_emb = self.timestep_embedder(
-            timesteps_proj.to(dtype=hidden_dtype)
-        )
-        condition_emb = self.condition_embedder(
-            condition_proj.to(dtype=hidden_dtype)
-        )
-
-        conditioning = timesteps_emb + condition_emb
-        return conditioning
-
-
-# =============================================================================
-# Image Projector
-# =============================================================================
-class GlmImageImageProjector(nn.Module):
-
-    def __init__(
-        self,
-        in_channels: int = 16,
-        hidden_size: int = 2560,
-        patch_size: int = 2,
-    ):
-        super().__init__()
-        self.patch_size = patch_size
-        self.proj = nn.Linear(in_channels * patch_size**2, hidden_size)
-
-    def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
-        batch_size, channel, height, width = hidden_states.shape
-        post_patch_height = height // self.patch_size
-        post_patch_width = width // self.patch_size
-
-        hidden_states = hidden_states.reshape(
-            batch_size,
-            channel,
-            post_patch_height,
-            self.patch_size,
-            post_patch_width,
-            self.patch_size,
-        )
-        hidden_states = (
-            hidden_states.permute(0, 2, 4, 1, 3, 5).flatten(3, 5).flatten(1, 2)
-        )
-        hidden_states = self.proj(hidden_states)
-
-        return hidden_states
-
-
-# =============================================================================
-# AdaLayerNorm
-# =============================================================================
-class GlmImageAdaLayerNormZero(nn.Module):
-
-    def __init__(self, embedding_dim: int, dim: int) -> None:
-        super().__init__()
-
-        self.norm = nn.LayerNorm(dim, elementwise_affine=False, eps=1e-5)
-        self.norm_context = nn.LayerNorm(dim, elementwise_affine=False, eps=1e-5)
-        self.linear = ReplicatedLinear(embedding_dim, 12 * dim, bias=True)
-
-    def forward(
-        self,
-        hidden_states: torch.Tensor,
-        encoder_hidden_states: torch.Tensor,
-        temb: torch.Tensor,
-    ) -> Tuple[torch.Tensor, ...]:
-        dtype = hidden_states.dtype
-        norm_hidden_states = self.norm(hidden_states).to(dtype=dtype)
-        norm_encoder_hidden_states = self.norm_context(encoder_hidden_states).to(
-            dtype=dtype
-        )
-
-        emb, _ = self.linear(temb)
-        (
-            shift_msa,
-            c_shift_msa,
-            scale_msa,
-            c_scale_msa,
-            gate_msa,
-            c_gate_msa,
-            shift_mlp,
-            c_shift_mlp,
-            scale_mlp,
-            c_scale_mlp,
-            gate_mlp,
-            c_gate_mlp,
-        ) = emb.chunk(12, dim=1)
-
-        hidden_states = norm_hidden_states * (
-            1 + scale_msa.unsqueeze(1)
-        ) + shift_msa.unsqueeze(1)
-        encoder_hidden_states = norm_encoder_hidden_states * (
-            1 + c_scale_msa.unsqueeze(1)
-        ) + c_shift_msa.unsqueeze(1)
-
-        return (
-            hidden_states,
-            gate_msa,
-            shift_mlp,
-            scale_mlp,
-            gate_mlp,
-            encoder_hidden_states,
-            c_gate_msa,
-            c_shift_mlp,
-            c_scale_mlp,
-            c_gate_mlp,
-        )
-
-
-# =============================================================================
-# Attention
-# =============================================================================
-class GlmImageAttention(nn.Module):
-
-    def __init__(
-        self,
-        query_dim: int,
-        heads: int,
-        dim_head: int,
-        out_dim: int,
-        bias: bool = True,
-        qk_norm: str = "layer_norm",
-        elementwise_affine: bool = False,
-        eps: float = 1e-5,
-        supported_attention_backends: set[AttentionBackendEnum] | None = None,
-        prefix: str = "",
-    ):
-        super().__init__()
-
-        self.heads = out_dim // dim_head if out_dim is not None else heads
-        self.num_kv_heads = self.heads
-        self.dim_head = dim_head
-        self.inner_dim = out_dim if out_dim is not None else dim_head * heads
-        self.inner_kv_dim = self.inner_dim
-        self.out_dim = out_dim if out_dim is not None else query_dim
-
-        self.to_q = ReplicatedLinear(query_dim, self.inner_dim, bias=bias)
-        self.to_k = ReplicatedLinear(query_dim, self.inner_kv_dim, bias=bias)
-        self.to_v = ReplicatedLinear(query_dim, self.inner_kv_dim, bias=bias)
-
-        self.to_out = nn.ModuleList(
-            [ReplicatedLinear(self.inner_dim, self.out_dim, bias=True)]
-        )
-
-        if qk_norm is None:
-            self.norm_q = None
-            self.norm_k = None
-        elif qk_norm == "layer_norm":
-            self.norm_q = nn.LayerNorm(
-                dim_head, eps=eps, elementwise_affine=elementwise_affine
-            )
-            self.norm_k = nn.LayerNorm(
-                dim_head, eps=eps, elementwise_affine=elementwise_affine
-            )
-        else:
-            raise ValueError(f"unknown qk_norm: {qk_norm}")
-
-        self.attn = LocalAttention(
-            num_heads=self.heads,
-            head_size=dim_head,
-            num_kv_heads=self.heads,
-            softmax_scale=None,
-            causal=False,
-            supported_attention_backends=supported_attention_backends,
-        )
-
-    def forward(
-        self,
-        hidden_states: torch.Tensor,
-        encoder_hidden_states: torch.Tensor,
-        image_rotary_emb: Optional[Tuple[torch.Tensor, torch.Tensor]] = None,
-        kv_cache: Optional[GlmImageLayerKVCache] = None,
-    ) -> Tuple[torch.Tensor, torch.Tensor]:
-        dtype = encoder_hidden_states.dtype
-
-        batch_size, text_seq_length, embed_dim = encoder_hidden_states.shape
-        batch_size, image_seq_length, embed_dim = hidden_states.shape
-        hidden_states = torch.cat([encoder_hidden_states, hidden_states], dim=1)
-
-        # 1. QKV projections
-        query, _ = self.to_q(hidden_states)
-        key, _ = self.to_k(hidden_states)
-        value, _ = self.to_v(hidden_states)
-
-        query = query.unflatten(2, (self.heads, -1))
-        key = key.unflatten(2, (self.heads, -1))
-        value = value.unflatten(2, (self.heads, -1))
-
-        # 2. QK normalization
-        if self.norm_q is not None:
-            query = self.norm_q(query).to(dtype=dtype)
-        if self.norm_k is not None:
-            key = self.norm_k(key).to(dtype=dtype)
-
-        # 3. Rotational positional embeddings applied to latent stream
-        if image_rotary_emb is not None:
-            cos, sin = image_rotary_emb
-
-            query[:, text_seq_length:, :, :] = _apply_rotary_emb(
-                query[:, text_seq_length:, :, :], cos, sin, is_neox_style=True
-            )
-            key[:, text_seq_length:, :, :] = _apply_rotary_emb(
-                key[:, text_seq_length:, :, :], cos, sin, is_neox_style=True
-            )
-
-        # 4. KV Cache handling
-        if kv_cache is not None:
-            if kv_cache.mode == "write":
-                kv_cache.store(key, value)
-            elif kv_cache.mode == "read":
-                # Prepend cached condition k/v along seq (dim=1).
-                k_cache, v_cache = kv_cache.get()
-                key = torch.cat([k_cache, key], dim=1) if k_cache is not None else key
-                value = (
-                    torch.cat([v_cache, value], dim=1) if v_cache is not None else value
-                )
-            elif kv_cache.mode == "skip":
-                pass
-
-        hidden_states = self.attn(query, key, value)
-        hidden_states = hidden_states.flatten(2, 3)
-        hidden_states = hidden_states.to(query.dtype)
-
-        # 6. Output projection
-        hidden_states, _ = self.to_out[0](hidden_states)
-
-        encoder_hidden_states, hidden_states = hidden_states.split(
-            [text_seq_length, hidden_states.size(1) - text_seq_length], dim=1
-        )
-        return hidden_states, encoder_hidden_states
-
-
-# =============================================================================
-# Transformer Block
-# =============================================================================
-class GlmImageTransformerBlock(nn.Module):
-
-    def __init__(
-        self,
-        dim: int = 2560,
-        num_attention_heads: int = 64,
-        attention_head_dim: int = 40,
-        time_embed_dim: int = 512,
-        supported_attention_backends: set[AttentionBackendEnum] | None = None,
-        prefix: str = "",
-    ) -> None:
-        super().__init__()
-
-        # 1. Attention
-        self.norm1 = GlmImageAdaLayerNormZero(time_embed_dim, dim)
-
-        self.attn1 = GlmImageAttention(
-            query_dim=dim,
-            heads=num_attention_heads,
-            dim_head=attention_head_dim,
-            out_dim=dim,
-            bias=True,
-            qk_norm="layer_norm",
-            elementwise_affine=False,
-            eps=1e-5,
-            supported_attention_backends=supported_attention_backends,
-            prefix=f"{prefix}.attn1",
-        )
-
-        # 2. Feedforward with fused ScaleResidualLayerNorm
-        self.norm2 = ScaleResidualLayerNormScaleShift(
-            dim, norm_type="layer", eps=1e-5, elementwise_affine=False
-        )
-        self.norm2_context = ScaleResidualLayerNormScaleShift(
-            dim, norm_type="layer", eps=1e-5, elementwise_affine=False
-        )
-        self.ff = MLP(input_dim=dim, mlp_hidden_dim=dim * 4, output_dim=dim, act_type="gelu_pytorch_tanh")
-
-    def forward(
-        self,
-        hidden_states: torch.Tensor,
-        encoder_hidden_states: torch.Tensor,
-        temb: Optional[torch.Tensor] = None,
-        image_rotary_emb: Optional[
-            Union[
-                Tuple[torch.Tensor, torch.Tensor],
-                List[Tuple[torch.Tensor, torch.Tensor]],
-            ]
-        ] = None,
-        attention_kwargs: Optional[Dict[str, Any]] = None,
-        kv_cache: Optional[GlmImageLayerKVCache] = None,
-    ) -> Tuple[torch.Tensor, torch.Tensor]:
-        # 1. Timestep conditioning
-        (
-            norm_hidden_states,
-            gate_msa,
-            shift_mlp,
-            scale_mlp,
-            gate_mlp,
-            norm_encoder_hidden_states,
-            c_gate_msa,
-            c_shift_mlp,
-            c_scale_mlp,
-            c_gate_mlp,
-        ) = self.norm1(hidden_states, encoder_hidden_states, temb)
-
-        # 2. Attention
-        if attention_kwargs is None:
-            attention_kwargs = {}
-
-        attn_hidden_states, attn_encoder_hidden_states = self.attn1(
-            hidden_states=norm_hidden_states,
-            encoder_hidden_states=norm_encoder_hidden_states,
-            image_rotary_emb=image_rotary_emb,
-            kv_cache=kv_cache,
-            **attention_kwargs,
-        )
-
-        # 3. Feedforward (fused residual + norm + scale/shift)
-        norm_hidden_states, hidden_states = self.norm2(
-            hidden_states,
-            attn_hidden_states,
-            gate_msa.unsqueeze(1),
-            shift_mlp.unsqueeze(1),
-            scale_mlp.unsqueeze(1),
-        )
-        norm_encoder_hidden_states, encoder_hidden_states = self.norm2_context(
-            encoder_hidden_states,
-            attn_encoder_hidden_states,
-            c_gate_msa.unsqueeze(1),
-            c_shift_mlp.unsqueeze(1),
-            c_scale_mlp.unsqueeze(1),
-        )
-
-        ff_output = self.ff(norm_hidden_states)
-        ff_output_context = self.ff(norm_encoder_hidden_states)
-        hidden_states = hidden_states + ff_output * gate_mlp.unsqueeze(1)
-        encoder_hidden_states = (
-            encoder_hidden_states + ff_output_context * c_gate_mlp.unsqueeze(1)
-        )
-
-        return hidden_states, encoder_hidden_states
-
-
-# =============================================================================
-# Rotary Positional Embedding
-# =============================================================================
-class GlmImageRotaryPosEmbed(nn.Module):
-
-    def __init__(self, dim: int, patch_size: int, theta: float = 10000.0) -> None:
-        super().__init__()
-        self.dim = dim
-        self.patch_size = patch_size
-        self.theta = theta
-        self._cache_key: tuple | None = None
-        self._cache_value: tuple[torch.Tensor, torch.Tensor] | None = None
-
-    def forward(self, hidden_states: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:
-        _, _, raw_h, raw_w = hidden_states.shape
-        height = raw_h // self.patch_size
-        width = raw_w // self.patch_size
-        device = hidden_states.device
-
-        cache_key = (height, width, device.type,
-                     device.index if device.index is not None else -1)
-        if self._cache_key == cache_key and self._cache_value is not None:
-            return self._cache_value
-
-        dim_h, dim_w = self.dim // 2, self.dim // 2
-        h_inv_freq = 1.0 / (
-            self.theta
-            ** (
-                torch.arange(0, dim_h, 2, dtype=torch.float32, device=device)[
-                    : (dim_h // 2)
-                ]
-                / dim_h
-            )
-        )
-        w_inv_freq = 1.0 / (
-            self.theta
-            ** (
-                torch.arange(0, dim_w, 2, dtype=torch.float32, device=device)[
-                    : (dim_w // 2)
-                ]
-                / dim_w
-            )
-        )
-        h_seq = torch.arange(height, device=device)
-        w_seq = torch.arange(width, device=device)
-        freqs_h = torch.outer(h_seq, h_inv_freq).unsqueeze(1).expand(height, width, -1)
-        freqs_w = torch.outer(w_seq, w_inv_freq).unsqueeze(0).expand(height, width, -1)
-
-        freqs = torch.cat([freqs_h, freqs_w], dim=-1).reshape(height * width, -1)
-        result = (freqs.cos(), freqs.sin())
-        self._cache_key = cache_key
-        self._cache_value = result
-        return result
-
-
-# =============================================================================
-# Final AdaLayerNorm
-# =============================================================================
-class GlmImageAdaLayerNormContinuous(nn.Module):
-
-    def __init__(
-        self,
-        embedding_dim: int,
-        conditioning_embedding_dim: int,
-        elementwise_affine: bool = True,
-        eps: float = 1e-5,
-        bias: bool = True,
-        norm_type: str = "layer_norm",
-    ):
-        super().__init__()
-        self.linear = nn.Linear(
-            conditioning_embedding_dim, embedding_dim * 2, bias=bias
-        )
-        if norm_type == "layer_norm":
-            self.norm = nn.LayerNorm(embedding_dim, eps, elementwise_affine, bias)
-        elif norm_type == "rms_norm":
-            self.norm = nn.RMSNorm(embedding_dim, eps, elementwise_affine)
-        else:
-            raise ValueError(f"unknown norm_type {norm_type}")
-
-    def forward(
-        self, x: torch.Tensor, conditioning_embedding: torch.Tensor
-    ) -> torch.Tensor:
-        emb = self.linear(conditioning_embedding.to(x.dtype))
-        scale, shift = torch.chunk(emb, 2, dim=1)
-        x = self.norm(x) * (1 + scale)[:, None, :] + shift[:, None, :]
-        return x
-
-
-# =============================================================================
-# Main Model
-# =============================================================================
-class GlmImageTransformer2DModel(BaseDiT):
-
-    _fsdp_shard_conditions = GlmImageDiTConfig().arch_config._fsdp_shard_conditions
-    _compile_conditions = GlmImageDiTConfig().arch_config._compile_conditions
-    _supported_attention_backends = (
-        AttentionBackendEnum.FLASH_ATTN,
-        AttentionBackendEnum.TORCH_SDPA,
-    )
-
-    param_names_mapping = GlmImageDiTConfig().arch_config.param_names_mapping
-    reverse_param_names_mapping = {}
-    lora_param_names_mapping = {}
-
-    def __init__(
-        self,
-        config: GlmImageDiTConfig,
-        hf_config: dict[str, Any],
-    ):
-        super().__init__(config=config, hf_config=hf_config)
-
-        arch_config = config.arch_config
-
-        self.in_channels = arch_config.in_channels
-        self.out_channels = arch_config.out_channels
-        self.patch_size = arch_config.patch_size
-        self.num_layers = arch_config.num_layers
-        self.attention_head_dim = arch_config.attention_head_dim
-        self.num_attention_heads = arch_config.num_attention_heads
-        self.text_embed_dim = arch_config.text_embed_dim
-        self.time_embed_dim = arch_config.time_embed_dim
-
-        # GlmImage uses 2 additional SDXL-like conditions - target_size, crop_coords
-        # Each of these are sincos embeddings of shape 2 * condition_dim
-        pooled_projection_dim = 2 * 2 * arch_config.condition_dim
-        inner_dim = arch_config.num_attention_heads * arch_config.attention_head_dim
-
-        self.hidden_size = inner_dim
-        self.num_channels_latents = arch_config.out_channels
-
-        # 1. RoPE
-        self.rotary_emb = GlmImageRotaryPosEmbed(
-            arch_config.attention_head_dim, arch_config.patch_size, theta=10000.0
-        )
-
-        # 2. Patch & Text-timestep embedding
-        self.image_projector = GlmImageImageProjector(
-            arch_config.in_channels, inner_dim, arch_config.patch_size
-        )
-        self.glyph_projector = MLP(
-            input_dim=arch_config.text_embed_dim,
-            mlp_hidden_dim=inner_dim,
-            output_dim=inner_dim,
-            act_type="gelu",
-        )
-        self.prior_token_embedding = nn.Embedding(
-            arch_config.prior_vq_quantizer_codebook_size, inner_dim
-        )
-        self.prior_projector = MLP(
-            input_dim=inner_dim,
-            mlp_hidden_dim=inner_dim,
-            output_dim=inner_dim,
-            act_type="silu",
-        )
-
-        self.time_condition_embed = GlmImageCombinedTimestepSizeEmbeddings(
-            embedding_dim=arch_config.time_embed_dim,
-            condition_dim=arch_config.condition_dim,
-            pooled_projection_dim=pooled_projection_dim,
-            timesteps_dim=arch_config.time_embed_dim,
-        )
-
-        # 3. Transformer blocks
-        self.transformer_blocks = nn.ModuleList(
-            [
-                GlmImageTransformerBlock(
-                    inner_dim,
-                    arch_config.num_attention_heads,
-                    arch_config.attention_head_dim,
-                    arch_config.time_embed_dim,
-                    supported_attention_backends=self._supported_attention_backends,
-                    prefix=f"transformer_blocks.{i}",
-                )
-                for i in range(arch_config.num_layers)
-            ]
-        )
-
-        # 4. Output projection
-        self.norm_out = GlmImageAdaLayerNormContinuous(
-            inner_dim, arch_config.time_embed_dim, elementwise_affine=False
-        )
-        self.proj_out = nn.Linear(
-            inner_dim,
-            arch_config.patch_size * arch_config.patch_size * arch_config.out_channels,
-            bias=True,
-        )
-
-        self.gradient_checkpointing = False
-
-        self.__post_init__()
-
-    def forward(
-        self,
-        hidden_states: torch.Tensor,
-        encoder_hidden_states: torch.Tensor,
-        prior_token_id: torch.Tensor,
-        prior_token_drop: torch.Tensor,
-        timestep: torch.LongTensor,
-        target_size: torch.Tensor,
-        crop_coords: torch.Tensor,
-        attention_kwargs: Optional[Dict[str, Any]] = None,
-        kv_caches: Optional[GlmImageKVCache] = None,
-        kv_caches_mode: Optional[str] = None,
-        freqs_cis: Optional[
-            Union[
-                Tuple[torch.Tensor, torch.Tensor],
-                List[Tuple[torch.Tensor, torch.Tensor]],
-            ]
-        ] = None,
-        guidance: torch.Tensor = None,
-        **kwargs,
-    ) -> torch.Tensor:
-        if kv_caches is not None:
-            kv_caches.set_mode(kv_caches_mode)
-
-        batch_size, num_channels, height, width = hidden_states.shape
-
-        if isinstance(encoder_hidden_states, list):
-            encoder_hidden_states = encoder_hidden_states[0]
-
-        # 1. RoPE
-        image_rotary_emb = freqs_cis
-        if image_rotary_emb is None:
-            image_rotary_emb = self.rotary_emb(hidden_states)
-
-        # 2. Patch & Timestep embeddings
-        p = self.patch_size
-        post_patch_height = height // p
-        post_patch_width = width // p
-
-        hidden_states = self.image_projector(hidden_states)
-        encoder_hidden_states = self.glyph_projector(encoder_hidden_states)
-        prior_embedding = self.prior_token_embedding(prior_token_id)
-        # Zero dropped priors by multiply: boolean indexing + .any() syncs each step.
-        keep = (~prior_token_drop).to(device=prior_embedding.device, dtype=prior_embedding.dtype)
-        while keep.dim() < prior_embedding.dim():
-            keep = keep.unsqueeze(-1)
-        prior_embedding = prior_embedding * keep
-        prior_hidden_states = self.prior_projector(prior_embedding)
-        hidden_states = hidden_states + prior_hidden_states
-
-        temb = self.time_condition_embed(
-            timestep, target_size, crop_coords, hidden_states.dtype
-        )
-        temb = F.silu(temb)
-
-        # 3. Transformer blocks
-        for idx, block in enumerate(self.transformer_blocks):
-            hidden_states, encoder_hidden_states = block(
-                hidden_states,
-                encoder_hidden_states,
-                temb,
-                image_rotary_emb,
-                attention_kwargs,
-                kv_cache=kv_caches[idx] if kv_caches is not None else None,
-            )
-
-        # 4. Output norm & projection
-        hidden_states = self.norm_out(hidden_states, temb)
-        hidden_states = self.proj_out(hidden_states)
-
-        # 5. Unpatchify
-        hidden_states = hidden_states.reshape(
-            batch_size, post_patch_height, post_patch_width, -1, p, p
-        )
-        output = hidden_states.permute(0, 3, 1, 4, 2, 5).flatten(4, 5).flatten(2, 3)
-
-        return output.float()
-
-
-EntryClass = GlmImageTransformer2DModel
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
SolitaryThinker	4d8713f6e4	[bugfix]: bound WanCausalModel num_frames_per_block override to <= 3 The constructor override only checked >= 1, bypassing the <= 3 limit the config path enforces in CausalWanTransformer3DModel. Apply the same upper bound with a clear error message.	2026-07-05 15:01:25 -07:00
SolitaryThinker	fda43fc610	[bugfix]: refuse teacher forcing with a local attention window _prepare_teacher_forcing_mask silently ignored local_attn_size while the block-wise causal mask honors it, so a configured attention window was dropped on the teacher-forcing path. Raise NotImplementedError instead of training with a mask that contradicts the config.	2026-07-05 15:01:09 -07:00
SolitaryThinker	5a8329ddf6	[bugfix]: set causal-CD timesteps before the teacher CFG forwards training_batch.timesteps was assigned t_pf only after the two teacher CFG passes, so their set_forward_context(current_timestep=...) carried the stale random timesteps from prepare_batch — wrong VSA sparsity gating when attn_kind == "vsa". Assign before any forward.	2026-07-05 15:00:47 -07:00
SolitaryThinker	fcb5b465c5	[bugfix]: checkpoint causal-CD EMA consistency target on save/resume The base TrainingMethod.checkpoint_state() only persists trainable roles, so CausalConsistencyDistillationMethod's EMA target (frozen but mutated by _update_ema every step) was never saved; a resume reloaded it from init_from, snapping the consistency target back to the base checkpoint. Persist roles.ema.transformer via the same full-state DCP wrapper DiffusionNFT already uses for its frozen 'old' role, moving _FullModelState into fastvideo/train/utils/checkpoint.py so both methods share it.	2026-07-05 15:00:27 -07:00
H1yori233	4f13fb0fee	fix	2026-07-05 14:56:08 -07:00
H1yori233	d96ec99b4b	fix	2026-07-05 14:56:08 -07:00
H1yori233	2555f25cce	fix scheduler	2026-07-05 14:56:08 -07:00
H1yori233	fbe56fce8d	update scheduler and ema	2026-07-05 14:56:08 -07:00
H1yori233	5064bcdc47	cleanup	2026-07-05 14:56:08 -07:00
H1yori233	2aa824b615	cleanup	2026-07-05 14:56:08 -07:00
H1yori233	f934efc58d	add cf	2026-07-05 14:56:08 -07:00