<!-- Erstellt mit Qwirbel (KI-Assistent) am 27.08.2026 mit unbekanntem Modell ueber zai (Cloud-API) – KI-generierter Inhalt, Kennzeichnung nach Art. 50 EU-KI-VO. -->
# WAN-Video auf Vulkan — Bauplan (27.08.2026)

Ziel: `video.*`-Knoten (v.a. `video.animieren`, die Wan-Animate-Pipeline)
rechnen auf der RX 9060 XT (16 GB), statt vom Vulkan-Rechenwerk mit
`NOCH_NICHT` abgewiesen zu werden.

## Wo die Absage sitzt (gefunden 27.08.2026, 16:20 Uhr)

- `kern/rechenwerk/vulkan_gpu.py` Z.280: `NOCH_NICHT` enthaelt den
  PRAEFIX-Eintrag `"video."` → sperrt ALLE video.*-Knoten pauschal.
  Z.402: `for anfang, grund in self.NOCH_NICHT.items():` — die Schluessel
  sind Praefixe; ein Praefix trifft alles, was den Namen nur TEILT.
- Dieselbe Falle gab es bei `audio.` bis 24.08.2026 — dort geloest durch
  EINZEL-Eintraege pro Knoten (Kommentar in der Datei Z.283-288).
  Genauso ist `"video."` aufzuloesen, sobald einzelne Knoten wirklich
  laufen. Erst einzeln freischalten, dann den Praefix streichen.
- `kern/rechenwerk/torch_gpu.py` Z.72 (`NOCH_NICHT`), Z.124 (kann-Pruefung),
  Z.215: eigenes `NOCH_NICHT` — Video dort ebenfalls gesperrt
  (Diffusionsmodelle, Messstand 16.08.: torch kann 1/14 Nodes).

## Die Knoten (knoten/video.py, 716 Zeilen gesamt)

- `video.animieren` (Z.375): Motion Control nach WanAnimate-Art.
  MIT `modell`-Eingang: rechnet die Bewegung fertig → Ausgang `bilder`.
  OHNE Modell (Eingang freiwillig, Z.383-389): bereitet nur vor —
  Konditionierung, negative Konditionierung, passendes Latent — und ein
  SAMPLER dahinter rechnet (genau wie ComfyUIs `WanAnimateToVideo`, das
  gar keinen Modell-Eingang hat).
  Speicher-Hinweis im Knoten selbst: Modell + Referenzbild + ganze
  Bewegungsfolge gleichzeitig → auf 16 GB ist `bei_engpass: stueckeln`
  Normalfall, kein Notnagel.
- `video.pose_zeichnen` (~Z.270-316): Pose auf Zielfigur uebertragen
  (Eingaenge pose/zielfigur/modell, Schalter groesse_angleichen,
  boden_halten; Ausgang `pose`).
- `video.segmentieren` (Z.318): Bereich durch die ganze Folge verfolgen
  (SAM2-Art; freiwilliger `bereiche`-Eingang aus der Pose-Erkennung,
  21.08.2026 ergänzt, weil ein Ausgang sonst ins Leere lief).
- `video.maske_anwenden` (Z.353) und `video.teilen` (Z.365):
  `rechnet=False` — reine Bildfolgen-Operationen, KEIN Modell, KEIN VRAM.
  Das sind die ERSTEN Kandidaten zum Freischalten (Beweis, dass der
  Vulkan-Weg video.* ueberhaupt annimmt).
- `video.pose_erkennen`: existiert (dienste/import_comfy.py Z.544,
  tests/test_knoten.py Z.246), Definition steht weiter oben in
  knoten/video.py (noch nicht gelesen).

## Vorbild: die laufende Audio-Kette (ACE-Step, Stand 24.08.2026)

Musik laeuft auf Vulkan ALS KETTE, nicht im Buendel-Knoten:
`modell.unet_laden` (acestep_v1.5_xl_turbo) → `modell.text_encoder_laden`
(qwen_0.6b_ace15) → `text.kodieren_musik` → `audio.latent_leer` →
`sampler.ksampler` (ACE-DiT, 32 Bloecke, gegen NumPy-Nachbau geprueft) →
`audio.dekodieren` → `audio.speichern`.
→ Video ANALOG bauen: WAN-DiT (DiT mit 3D-RoPE) + umt5-xxl (Text) +
CLIP-Vision (Referenzbild) + Video-VAE (kausale 3D) + `sampler.ksampler`
auf Video-Latent + `video.speichern` (ffmpeg ist systemweit da).

## Modelle & Speicher (Messung 16.08.2026, WAN-i2v)

UNet/WAN-DiT Q3_K_M 9,2 GB · umt5-xxl 3,3 GB · CLIP-Vision 1,2 GB ·
Video-VAE 0,24 GB — laut Speicherplan zusammen auf 15,92 GB VRAM
machbar, 0 Raeumungen. `grafen/wan_i2v.json` ist valide (0 Fehler),
ABER kein Rechenwerk kann den Graph ausfuehren: vulkan kann() 6/14
Knoten, torch 1/14.

## Noch NICHT gelesen — ZUERST das hier

1. Wie verteilt vulkan_gpu.py Knotentypen auf Code (Dispatch/Tabelle)?
   Was enthaelt `KANN` fuer video.*? (ab Z.345; code_suchen `_video` und
   `def kann`).
2. API von `kern/vulkan/netz.py`, `geraet.py`, `gewichte.py` (GGUF-Laden,
   Q3_K-Matmul, Auslagern). Vorbild-Implementierungen: `lumina2.py`
   (Bild-DiT z-image), `acestep.py` (Audio-DiT), `ace_vae.py` (Decoder
   mit NumPy-Gegenpruefung).
3. Kann `kern/vulkan/sampler.py` auf Video-Latent arbeiten (3D, Zeitachse,
   Temporal-RoPE), oder braucht es einen Video-Sampler-Zweig?

## Reihenfolge (jeder Schritt mit Gegenprobe)

1. Dispatch + KANN lesen → verstehen, wie ein Knoten bei Vulkan
   ueberhaupt "laeuft".
2. Praefix `"video."` in EINZEL-Eintraege aufspalten (Muster wie audio
   24.08.); zuerst `video.maske_anwenden` + `video.teilen` zum Laufen
   bringen (kein Modell) — Gegenprobe: kann() liefert True dafuer.
3. Video-VAE (kleinstes Modell, 0,24 GB) in kern/vulkan/ bauen, gegen
   NumPy-Nachbau pruefen (ace_vae-Prezedenz).
4. umt5-xxl als Textencoder (Vorbild: Encoder im Bild-Weg, qwen/gemma).
5. WAN-DiT als kern/vulkan/wan.py mit 3D-RoPE; Matmul aus gewichte.py,
   Q3_K; 16-GB-Plan mit stueckeln von Anfang an einbauen.
6. `video.animieren` OHNE modell (Vorbereiten-Modus) verkabeln, dann MIT
   modell; pose-Kodierung + Referenzbild (CLIP-Vision).
7. `grafen/wan_i2v.json` komplett durchmessen (Ziel: kann() 14/14) und
   einen echten Lauf als Gegenprobe; Ergebnis nach messungen/.

Fund-Herkunft: code_suchen + datei_ausschnitt am 27.08.2026 16:20
(vulkan_gpu.py Z.260-345, knoten/video.py Z.300-470), Alt-Wissen aus
PROJEKT/Wissen vom 16./24.08.2026.

## Fortschritt (27.08.2026, ~16:45)

- Schritt 2 ERFUELLT: Der Praefix `"video."` in `NOCH_NICHT`
  (kern/rechenwerk/vulkan_gpu.py) ist in EINZEL-Eintraege aufgeloest
  (animieren, pose_erkennen, pose_zeichnen, segmentieren, dekodieren) plus
  Auffang-Praefix als LETZTER Eintrag — `_ablehnen` nimmt den ERSTEN
  startswith-Treffer, dicts laufen in Einfuegereihenfolge. Die geerbten
  modellfreien video.*-Knoten (teilen, maske_anwenden, speichern,
  ueberblenden …) rechnen weiter.
- Schritt 6 (vorgezogen) ERFUELLT — `video.animieren` im
  VORBEREITUNGS-MODUS: `video.animieren` steht in VULKAN_KANN, Methode
  `_video_animieren` gebaut. OHNE modell-Eingang: kond-dict
  (art 'wan_animate': text, figur, pose, frames, breite, hoehe,
  hintergrund, hintergrund_bilder, treue, schritte, seed) + Latent in
  Wan-Form (1, 16, (frames-1)//4+1, H/8, B/8) + negativ / trim_latent /
  trim_bild / versatz. MIT modell: klare Absage mit Verweis auf Schritt 5.
  Gegenprobe am echten Werk (python): kann()=True, Probelauf 64x64/5 Frames
  → Latent (1,16,2,8,8), Meldung 'vorbereitet'.
- OFFEN in Reihenfolge: Schritt 3 Video-VAE (→ video.dekodieren),
  Schritt 4 umt5-xxl, Schritt 5 WAN-DiT (kern/vulkan/wan.py),
  pose_erkennen/pose_zeichnen/segmentieren, Schritt 7 Messlauf
  grafen/wan_i2v.json (Ziel 14/14) mit Ergebnis nach messungen/.
