# AdaLN Modulation Branch Inference Optimization
# ~13B of 33.1B total params belong to the AdaLN branch

class AdaLNOptimization:
    """
    The AdaLN modulation branch can be precomputed and cached
    during inference, avoiding recomputation at each forward pass.
    """
    total_params = 33.1e9       # Total parameter count
    adaln_params = 13e9         # AdaLN modulation branch params
    effective_inference = total_params - adaln_params  # ≈ 20B
    
    def precompute_adaln_curves(self, timestep_embed):
        """
        Precompute AdaLN curve tables stored in cache.
        At inference time, direct table lookup skips 13B param computation.
        """
        # Timestep embedding → AdaLN modulation parameters
        gamma, beta = self.adaln_mlp(timestep_embed)
        # Cache curve tables
        self.curve_cache = {gamma: gamma, beta: beta}
        return self.curve_cache

import torch
import math

class MMRoPE3D(torch.nn.Module):
    """
    3D Multimodal Rotary Position Embeddings (MM-RoPE)
    Assigns different positional encoding dimensions per modality:
    - Text tokens: 1D position
    - Visual tokens: 3D (T, H, W) position
    - Audio tokens: 1D temporal position
    """
    
    def __init__(self, dim: int, base: int = 10000):
        super().__init__()
        self.dim = dim
        self.base = base
        self.dim_per_modality = dim // 3
        
        inv_freq = 1.0 / (base ** (
            torch.arange(0, self.dim_per_modality, 2).float() / self.dim_per_modality
        ))
        self.register_buffer("inv_freq", inv_freq)
    
    def _compute_rope(self, positions: torch.Tensor) -> torch.Tensor:
        """Compute rotary position embeddings"""
        freqs = torch.einsum("i,j->ij", positions.float(), self.inv_freq)
        emb = torch.cat([freqs, freqs], dim=-1)
        return torch.stack([emb.cos(), emb.sin()], dim=-2)
    
    def forward(
        self,
        text_positions: torch.Tensor,      # (N_text,)
        visual_positions: torch.Tensor,     # (N_vis, 3) -> (T, H, W)
        audio_positions: torch.Tensor,      # (N_audio,)
    ) -> torch.Tensor:
        """
        Compute positional encodings separately for each modality and concatenate
        """
        # Text: 1D positional encoding
        text_rope = self._compute_rope(text_positions)
        
        # Visual: 3D positional encoding (temporal + height + width)
        vis_t = self._compute_rope(visual_positions[:, 0])
        vis_h = self._compute_rope(visual_positions[:, 1])
        vis_w = self._compute_rope(visual_positions[:, 2])
        visual_rope = torch.cat([vis_t, vis_h, vis_w], dim=-1)
        
        # Audio: 1D temporal positional encoding
        audio_rope = self._compute_rope(audio_positions)
        
        # Concatenate all modalities
        return torch.cat([text_rope, visual_rope, audio_rope], dim=0)

class TextEncoderWrapper:
    """
    Text encoder wrapper based on Qwen3-VL-32B.
    Extracts layer-50 hidden states as the conditioning signal.
    """
    
    def __init__(self, model_path: str = "MiniMaxAI/MiniMax-H3"):
        from transformers import AutoModel, AutoProcessor
        self.processor = AutoProcessor.from_pretrained(model_path)
        self.encoder = AutoModel.from_pretrained(
            model_path, 
            subfolder="text_encoder",
            torch_dtype=torch.bfloat16
        )
        self.extract_layer = 50  # Layer-50 hidden states
    
    def encode_text(self, text: str) -> torch.Tensor:
        """Encode text, returning layer-50 hidden states"""
        inputs = self.processor(text=text, return_tensors="pt")
        outputs = self.encoder(
            **inputs,
            output_hidden_states=True
        )
        hidden = outputs.hidden_states[self.extract_layer]
        return hidden  # shape: (batch, seq_len, hidden_dim)

class H3VisualVAE:
    """
    H3-VisualVAE: Video Variational Autoencoder
    32× spatial compression, 4× temporal compression
    """
    
    def __init__(self, model_path: str):
        self.spatial_compression = 32   # Spatial sampling factor
        self.temporal_compression = 4   # Temporal sampling factor
    
    def encode(self, video_tensor: torch.Tensor) -> torch.Tensor:
        """
        Encode pixel-space video to latent-space representation
        Input:  (B, C, T, H, W) — pixel space
        Output: (B, C', T//4, H//32, W//32) — latent space
        """
        B, C, T, H, W = video_tensor.shape
        latent_T = T // self.temporal_compression
        latent_H = H // self.spatial_compression
        latent_W = W // self.spatial_compression
        
        compression_ratio = (
            self.temporal_compression * 
            self.spatial_compression ** 2
        )
        print(f"Pixel → Latent compression: {compression_ratio}× (volumetric)")
        print(f"Sequence length gain: 4× (temporal dimension)")
        
        return self.encoder(video_tensor)

"""
MiniMax H3 Text-to-Video Pipeline (diffusers)
Generate 768p video with native stereo audio from text description
"""
import torch
from diffusers import ModularPipeline
from diffusers.utils import encode_video

def text_to_video_audio(
    prompt: str,
    output_path: str = "output.mp4",
    num_frames: int = 124,
    height: int = 768,
    width: int = 1344,
    num_inference_steps: int = 30,
    seed: int = 42,
):
    """
    Text-to-Video-Audio Pipeline
    
    Args:
        prompt: Text description
        output_path: Output video path
        num_frames: Frame count (snapped to 17n+5)
        height: Height (short edge 768px)
        width: Width
        num_inference_steps: Denoising steps
        seed: Random seed
    """
    # 1. Load model
    pipe = ModularPipeline.from_pretrained("MiniMaxAI/MiniMax-H3")
    pipe.load_components(dtype=torch.bfloat16)
    pipe.to("cuda")
    
    # 2. Run inference
    state = pipe(
        prompt=prompt,
        num_frames=num_frames,  # snapped to 17n+5 at 24fps
        height=height,
        width=width,
        num_inference_steps=num_inference_steps,
        generator=torch.Generator("cpu").manual_seed(seed),
    )
    
    # 3. Encode output (video + audio muxed into one MP4)
    encode_video(
        state.get("videos")[0],
        fps=24,
        audio=state.get("audio")[0],
        audio_sample_rate=state.get("sampling_rate"),
        output_path=output_path,
    )
    
    print(f"✅ Video saved to: {output_path}")
    print(f"   Resolution: {width}x{height}")
    print(f"   Frames: {num_frames} ({num_frames/24:.1f}s)")
    print(f"   Audio: 32kHz stereo")
    
    return output_path

if __name__ == "__main__":
    text_to_video_audio(
        prompt="A red fox trotting through a snowy pine forest, snow crunching underfoot",
        output_path="fox.mp4",
        num_frames=124,
        height=768,
        width=1344,
    )

"""
MiniMax H3 Omni-Reference Pipeline
Joint generation using reference images, video, and audio
"""
import torch
from diffusers.modular_pipelines import MiniMaxH3Ref2VABlocks
from diffusers.modular_pipelines.minimax_h3 import MiniMaxH3Reference
from diffusers.utils import encode_video

def ref_to_video_audio(
    prompt: str,
    references: list,
    output_path: str = "ref_output.mp4",
    num_frames: int = 124,
    num_inference_steps: int = 30,
):
    """
    Omni-Reference Pipeline
    Supports up to 9 images + 3 videos + 3 audios, max 12 files total
    """
    pipe = MiniMaxH3Ref2VABlocks().init_pipeline("MiniMaxAI/MiniMax-H3")
    pipe.load_components(dtype=torch.bfloat16)
    pipe.to("cuda")
    
    state = pipe(
        prompt=prompt,
        references=references,
        num_frames=num_frames,
        num_inference_steps=num_inference_steps,
    )
    
    encode_video(
        state.get("videos")[0],
        fps=24,
        audio=state.get("audio")[0],
        audio_sample_rate=state.get("sampling_rate"),
        output_path=output_path,
    )
    print(f"✅ Reference-generated video saved: {output_path}")

if __name__ == "__main__":
    ref_to_video_audio(
        prompt="The subject walks toward camera, matching the reference video's shot rhythm",
        references=[
            MiniMaxH3Reference(video="motion_ref.mp4"),
            MiniMaxH3Reference(image="subject.jpg"),
            MiniMaxH3Reference(audio="voice.wav"),
        ],
        num_frames=124,
    )

#!/bin/bash
# MiniMax H3 SGLang Deployment (4 GPU parallel)

# FL2VA variant
python -m sglang.launch_server \
  --model-path MiniMaxAI/MiniMax-H3 \
  --num-gpus 4 \
  --ulysses-degree 4 \
  --performance-mode speed \
  --host 0.0.0.0 \
  --port 30011 \
  --model-variant fl2va

# Ref2VA variant
python -m sglang.launch_server \
  --model-path MiniMaxAI/MiniMax-H3 \
  --num-gpus 4 \
  --ulysses-degree 4 \
  --performance-mode speed \
  --host 0.0.0.0 \
  --port 30011 \
  --model-variant ref2va

package main

import (
	"bytes"
	"encoding/base64"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"os"
	"time"
)

// MiniMaxH3Pipeline Full 2K workflow pipeline
type MiniMaxH3Pipeline struct {
	SGLangEndpoint string
	APIBaseURL     string
	APIKey         string
}

// ContextIRRequest H3-Context-IR request
type ContextIRRequest struct {
	Text   string   `json:"text"`
	Images []string `json:"images,omitempty"`
	Videos []string `json:"videos,omitempty"`
	Audios []string `json:"audios,omitempty"`
}

// GenerationRequest H3-Base generation request
type GenerationRequest struct {
	Prompt    string `json:"prompt"`
	NumFrames int    `json:"num_frames"`
	Height    int    `json:"height"`
	Width     int    `json:"width"`
	NumSteps  int    `json:"num_inference_steps"`
	Seed      int    `json:"seed"`
}

// RegenerateRequest H3-Regenerate-2K request
type RegenerateRequest struct {
	BaseVideo  string   `json:"base_video"`
	Prompt     string   `json:"prompt"`
	Resolution string   `json:"resolution"`
	Images     []string `json:"images,omitempty"`
	Videos     []string `json:"videos,omitempty"`
	Audios     []string `json:"audios,omitempty"`
}

// NewPipeline creates a new H3 pipeline
func NewPipeline(sglangEndpoint, apiBaseURL, apiKey string) *MiniMaxH3Pipeline {
	return &MiniMaxH3Pipeline{
		SGLangEndpoint: sglangEndpoint,
		APIBaseURL:     apiBaseURL,
		APIKey:         apiKey,
	}
}

// Step1: Context-IR preprocessing
func (p *MiniMaxH3Pipeline) ContextIR(req ContextIRRequest) (string, error) {
	fmt.Println("📋 Step 1/3: H3-Context-IR multimodal understanding...")
	
	body, _ := json.Marshal(req)
	httpReq, _ := http.NewRequest("POST",
		p.APIBaseURL+"/v1/h3-context-ir", bytes.NewReader(body))
	httpReq.Header.Set("Authorization", "Bearer "+p.APIKey)
	httpReq.Header.Set("Content-Type", "application/json")
	
	client := &http.Client{Timeout: 120 * time.Second}
	resp, err := client.Do(httpReq)
	if err != nil {
		return "", fmt.Errorf("Context-IR request failed: %w", err)
	}
	defer resp.Body.Close()
	
	var result struct {
		EnhancedPrompt string `json:"enhanced_prompt"`
	}
	json.NewDecoder(resp.Body).Decode(&result)
	
	fmt.Printf("  ✅ Context-IR complete, prompt enhanced\n")
	fmt.Printf("  📝 Enhanced prompt length: %d chars\n", len(result.EnhancedPrompt))
	return result.EnhancedPrompt, nil
}

// Step2: H3-Base local 768p generation
func (p *MiniMaxH3Pipeline) Generate768p(prompt string) ([]byte, error) {
	fmt.Println("🎬 Step 2/3: H3-Base local 768p audio-video generation...")
	
	req := GenerationRequest{
		Prompt:    prompt,
		NumFrames: 124,
		Height:    768,
		Width:     1344,
		NumSteps:  30,
		Seed:      42,
	}
	
	body, _ := json.Marshal(req)
	httpReq, _ := http.NewRequest("POST",
		p.SGLangEndpoint+"/v1/videos", bytes.NewReader(body))
	httpReq.Header.Set("Content-Type", "application/json")
	
	client := &http.Client{Timeout: 600 * time.Second}
	resp, err := client.Do(httpReq)
	if err != nil {
		return nil, fmt.Errorf("H3-Base generation failed: %w", err)
	}
	defer resp.Body.Close()
	
	videoData, _ := io.ReadAll(resp.Body)
	fmt.Printf("  ✅ 768p video generated (%d bytes)\n", len(videoData))
	return videoData, nil
}

// Step3: Regenerate-2K
func (p *MiniMaxH3Pipeline) Regenerate2K(
	baseVideo []byte, prompt string, refs ContextIRRequest,
) error {
	fmt.Println("✨ Step 3/3: H3-Regenerate-2K regeneration to 2K...")
	
	b64 := base64.StdEncoding.EncodeToString(baseVideo)
	dataURL := "data:video/mp4;base64," + b64
	
	req := RegenerateRequest{
		BaseVideo:  dataURL,
		Prompt:     prompt,
		Resolution: "2k",
		Images:     refs.Images,
		Videos:     refs.Videos,
		Audios:     refs.Audios,
	}
	
	body, _ := json.Marshal(req)
	httpReq, _ := http.NewRequest("POST",
		p.APIBaseURL+"/v1/h3-regenerate-2k", bytes.NewReader(body))
	httpReq.Header.Set("Authorization", "Bearer "+p.APIKey)
	httpReq.Header.Set("Content-Type", "application/json")
	
	client := &http.Client{Timeout: 900 * time.Second}
	resp, err := client.Do(httpReq)
	if err != nil {
		return fmt.Errorf("Regenerate-2K failed: %w", err)
	}
	defer resp.Body.Close()
	
	outFile, _ := os.Create("output_2k.mp4")
	defer outFile.Close()
	io.Copy(outFile, resp.Body)
	
	fmt.Println("  ✅ 2K video saved: output_2k.mp4")
	return nil
}

// RunFullPipeline executes the complete 2K workflow
func (p *MiniMaxH3Pipeline) RunFullPipeline(userInput ContextIRRequest) error {
	fmt.Println("🚀 MiniMax H3 Full 2K Workflow initiated")
	fmt.Println("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━")
	
	enhancedPrompt, err := p.ContextIR(userInput)
	if err != nil {
		return err
	}
	
	video768p, err := p.Generate768p(enhancedPrompt)
	if err != nil {
		return err
	}
	
	err = p.Regenerate2K(video768p, enhancedPrompt, userInput)
	if err != nil {
		return err
	}
	
	fmt.Println("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━")
	fmt.Println("🎉 Full 2K workflow completed!")
	return nil
}

func main() {
	pipeline := NewPipeline(
		"http://localhost:30011",
		"https://api.minimaxi.com",
		os.Getenv("MINIMAX_API_KEY"),
	)
	
	userInput := ContextIRRequest{
		Text: "A red fox running through a pine forest, snow crunching underfoot",
	}
	
	if err := pipeline.RunFullPipeline(userInput); err != nil {
		fmt.Fprintf(os.Stderr, "❌ Workflow failed: %v\n", err)
		os.Exit(1)
	}
}

package main

import (
	"encoding/json"
	"fmt"
	"strings"
)

// MultiModalPreprocessor simulates core H3-Context-IR functionality
type MultiModalPreprocessor struct {
	maxImages int
	maxVideos int
	maxAudios int
	maxFiles  int
}

// MediaAsset represents a media input asset
type MediaAsset struct {
	Type     string  `json:"type"`
	Path     string  `json:"path"`
	Duration float64 `json:"duration"`
}

// StructuredPrompt represents the serialized intermediate representation
type StructuredPrompt struct {
	OriginalText  string       `json:"original_text"`
	EnhancedText  string       `json:"enhanced_text"`
	ContextAssets []MediaAsset `json:"context_assets"`
	TaskType      string       `json:"task_type"`
	TokenBudget   int          `json:"token_budget"`
}

// NewPreprocessor creates a new preprocessor with H3 constraints
func NewPreprocessor() *MultiModalPreprocessor {
	return &MultiModalPreprocessor{
		maxImages: 9,
		maxVideos: 3,
		maxAudios: 3,
		maxFiles:  12,
	}
}

// ValidateInputs validates multimodal inputs against H3 constraints
func (p *MultiModalPreprocessor) ValidateInputs(
	text string, images []MediaAsset, videos []MediaAsset, audios []MediaAsset,
) error {
	if len(images) > p.maxImages {
		return fmt.Errorf("image count %d exceeds max %d", len(images), p.maxImages)
	}
	if len(videos) > p.maxVideos {
		return fmt.Errorf("video count %d exceeds max %d", len(videos), p.maxVideos)
	}
	if len(audios) > p.maxAudios {
		return fmt.Errorf("audio count %d exceeds max %d", len(audios), p.maxAudios)
	}
	
	totalFiles := len(images) + len(videos) + len(audios)
	if totalFiles > p.maxFiles {
		return fmt.Errorf("total files %d exceeds max %d", totalFiles, p.maxFiles)
	}
	
	if len(audios) > 0 && len(images) == 0 && len(videos) == 0 {
		return fmt.Errorf("audio must accompany image or video input")
	}
	
	for i, v := range videos {
		if v.Duration < 2 || v.Duration > 15 {
			return fmt.Errorf("video %d duration %.1f outside [2,15] range", i, v.Duration)
		}
	}
	totalDuration := 0.0
	for _, v := range videos {
		totalDuration += v.Duration
	}
	if totalDuration > 15 {
		return fmt.Errorf("total video duration %.1fs exceeds 15s limit", totalDuration)
	}
	
	return nil
}

// DetermineTaskType determines the generation task type
func (p *MultiModalPreprocessor) DetermineTaskType(
	images []MediaAsset, videos []MediaAsset, audios []MediaAsset,
) string {
	if len(videos) > 0 || len(audios) > 0 || len(images) > 2 {
		return "ref2va"
	}
	return "fl2va"
}

// Process handles multimodal input, outputting structured representation
func (p *MultiModalPreprocessor) Process(
	text string, images []MediaAsset, videos []MediaAsset, audios []MediaAsset,
) (*StructuredPrompt, error) {
	if err := p.ValidateInputs(text, images, videos, audios); err != nil {
		return nil, fmt.Errorf("validation failed: %w", err)
	}
	
	taskType := p.DetermineTaskType(images, videos, audios)
	
	var assets []MediaAsset
	assets = append(assets, images...)
	assets = append(assets, videos...)
	assets = append(assets, audios...)
	
	enhanced := p.buildEnhancedPrompt(text, assets, taskType)
	
	return &StructuredPrompt{
		OriginalText:  text,
		EnhancedText:  enhanced,
		ContextAssets: assets,
		TaskType:      taskType,
		TokenBudget:   4096,
	}, nil
}

func (p *MultiModalPreprocessor) buildEnhancedPrompt(
	text string, assets []MediaAsset, taskType string,
) string {
	var parts []string
	parts = append(parts, fmt.Sprintf("[Task: %s]", taskType))
	parts = append(parts, text)
	
	for i, a := range assets {
		switch a.Type {
		case "image":
			parts = append(parts, fmt.Sprintf("[Ref image %d: %s]", i+1, a.Path))
		case "video":
			parts = append(parts, fmt.Sprintf("[Ref video %d: %s, %.1fs]", i+1, a.Path, a.Duration))
		case "audio":
			parts = append(parts, fmt.Sprintf("[Ref audio %d: %s, %.1fs]", i+1, a.Path, a.Duration))
		}
	}
	
	return strings.Join(parts, "\n")
}

func main() {
	proc := NewPreprocessor()
	
	images := []MediaAsset{
		{Type: "image", Path: "character.jpg"},
		{Type: "image", Path: "scene_bg.jpg"},
	}
	videos := []MediaAsset{
		{Type: "video", Path: "motion_ref.mp4", Duration: 5.0},
	}
	audios := []MediaAsset{
		{Type: "audio", Path: "voice_ref.wav", Duration: 3.0},
	}
	
	result, err := proc.Process(
		"Subject walks toward camera, motion ref video 1, voice timbre ref audio 1",
		images, videos, audios,
	)
	if err != nil {
		fmt.Printf("❌ Processing failed: %v\n", err)
		return
	}
	
	output, _ := json.MarshalIndent(result, "", "  ")
	fmt.Println("✅ Structured Prompt:")
	fmt.Println(string(output))
}

"""
MiniMax H3 Multi-GPU Inference Service Wrapper
Supports FL2VA and Ref2VA variants
"""
import subprocess
import time
import requests
import json
import base64
from typing import Optional, List, Dict, Any
from dataclasses import dataclass

@dataclass
class H3Config:
    """H3 deployment configuration"""
    model_path: str = "MiniMaxAI/MiniMax-H3"
    num_gpus: int = 4
    ulysses_degree: int = 4
    host: str = "0.0.0.0"
    port: int = 30011
    model_variant: str = "fl2va"
    performance_mode: str = "speed"

class H3Server:
    """H3 inference service manager"""
    
    def __init__(self, config: H3Config):
        self.config = config
        self.process = None
        self.base_url = f"http://{config.host}:{config.port}"
    
    def start(self):
        """Start SGLang inference service"""
        cmd = [
            "python", "-m", "sglang.launch_server",
            "--model-path", self.config.model_path,
            "--num-gpus", str(self.config.num_gpus),
            "--ulysses-degree", str(self.config.ulysses_degree),
            "--performance-mode", self.config.performance_mode,
            "--host", self.config.host,
            "--port", str(self.config.port),
            "--model-variant", self.config.model_variant,
        ]
        print(f"🚀 Starting H3 service ({self.config.model_variant})...")
        self.process = subprocess.Popen(cmd)
        self._wait_for_ready()
    
    def _wait_for_ready(self, timeout: int = 300):
        """Wait for service readiness"""
        start = time.time()
        while time.time() - start < timeout:
            try:
                resp = requests.get(f"{self.base_url}/health", timeout=5)
                if resp.status_code == 200:
                    print("✅ Service ready")
                    return
            except requests.ConnectionError:
                time.sleep(2)
        raise TimeoutError("Service startup timed out")
    
    def stop(self):
        """Stop the service"""
        if self.process:
            self.process.terminate()
            self.process.wait()
            print("🛑 Service stopped")
    
    def generate(
        self,
        prompt: str,
        num_frames: int = 124,
        height: int = 768,
        width: int = 1344,
        num_steps: int = 30,
        seed: int = 42,
    ) -> bytes:
        """Call the generation API"""
        payload = {
            "prompt": prompt,
            "num_frames": num_frames,
            "height": height,
            "width": width,
            "num_inference_steps": num_steps,
            "seed": seed,
        }
        resp = requests.post(
            f"{self.base_url}/v1/videos",
            json=payload,
            timeout=600,
        )
        resp.raise_for_status()
        return resp.content


class Full2KWorkflow:
    """Complete 2K workflow orchestrator"""
    
    def __init__(self, server: H3Server, api_base: str, api_key: str):
        self.server = server
        self.api_base = api_base
        self.api_key = api_key
    
    def context_ir(self, text: str, **kwargs) -> str:
        """Call H3-Context-IR API"""
        payload = {"text": text, **kwargs}
        resp = requests.post(
            f"{self.api_base}/v1/h3-context-ir",
            json=payload,
            headers={"Authorization": f"Bearer {self.api_key}"},
            timeout=120,
        )
        resp.raise_for_status()
        return resp.json()["enhanced_prompt"]
    
    def generate_768p(self, prompt: str) -> bytes:
        """Generate 768p via local H3-Base"""
        return self.server.generate(prompt=prompt)
    
    def regenerate_2k(self, video_data: bytes, prompt: str, **refs) -> bytes:
        """Call H3-Regenerate-2K API"""
        b64 = base64.b64encode(video_data).decode()
        payload = {
            "base_video": f"data:video/mp4;base64,{b64}",
            "prompt": prompt,
            "resolution": "2k",
            **refs,
        }
        resp = requests.post(
            f"{self.api_base}/v1/h3-regenerate-2k",
            json=payload,
            headers={"Authorization": f"Bearer {self.api_key}"},
            timeout=900,
        )
        resp.raise_for_status()
        return resp.content
    
    def run(self, text: str, **refs) -> bytes:
        """Execute the full 2K workflow"""
        # Step 1: Context-IR
        enhanced = self.context_ir(text, **refs)
        print(f"📋 Context-IR enhancement complete")
        
        # Step 2: 768p generation
        video_768p = self.generate_768p(enhanced)
        print(f"🎬 768p generation complete ({len(video_768p)} bytes)")
        
        # Step 3: 2K regeneration
        video_2k = self.regenerate_2k(video_768p, enhanced, **refs)
        print(f"✨ 2K regeneration complete ({len(video_2k)} bytes)")
        
        return video_2k


if __name__ == "__main__":
    config = H3Config(model_variant="fl2va", num_gpus=4)
    server = H3Server(config)
    server.start()
    
    workflow = Full2KWorkflow(
        server=server,
        api_base="https://api.minimaxi.com",
        api_key="your-api-key",
    )
    
    video_2k = workflow.run(text="A red fox running through a pine forest")
    
    with open("output_2k.mp4", "wb") as f:
        f.write(video_2k)
    print("✅ 2K video saved")