rework the layout: two columns, no examples table, hardware notice

app.py

@@ -213,9 +213,7 @@ PROMPTS = {f"{p['idx']:>2} · {p['text']}": p["idx"] for p in INFO["prompts"]}
 WORLDS = {f"world {w['idx']} · {w['prompt'][:70]}": w["idx"] for w in INFO["worlds"]}
 WORLD_LABELS = list(WORLDS)
 PROMPT_LABELS = list(PROMPTS)
-# by bank index, so the examples below can name the prompt they mean
-P = {i: lbl for lbl, i in PROMPTS.items()}
-W = {i: lbl for lbl, i in WORLDS.items()}
+W = {i: lbl for lbl, i in WORLDS.items()}   # by world id, for the default
 print(f"[boot] ready: step {INFO['step']}, {len(PROMPTS)} prompts, "
       f"{len(WORLDS)} worlds", flush=True)
 
@@ -348,86 +346,94 @@ def run(world: str, steer_to: str, steer_text: str, steer_at: float,
 CSS = """
 #col-container { max-width: 1180px; margin: 0 auto; }
 .dark .gradio-container { color: var(--body-text-color); }
+#hw-note {
+  border: 1px solid var(--border-color-primary);
+  border-left: 4px solid var(--color-accent);
+  border-radius: 6px;
+  padding: 10px 14px;
+  margin-bottom: 4px;
+  font-size: 0.92em;
+  line-height: 1.5;
+}
+#hw-note p { margin: 0; }
 """
 
 INTRO = f"""# LiveWan
 
 **Streaming text-to-video you can steer while it runs.** A 1.3B student distilled
 from Wan2.1-T2V-14B that generates video continuously instead of as a fixed clip:
-750 ms of 640x368 at a time, extended block by block.
+750 ms of 640x368 at a time, extended block by block. Checkpoint step
+{INFO['step']}.
 
-Pick a world to open on, and optionally a prompt to swap to partway through. The
-swap keeps the K/V cache, so the scene *continues* rather than cutting. Checkpoint
-step {INFO['step']}.
+Open on a world, then optionally swap the prompt partway through. The swap keeps the
+K/V cache, so the scene *continues* rather than cutting.
 
 [Code]({GITHUB}) · [Weights](https://huggingface.co/{LIVEWAN_REPO})
 """
 
-NOTES = f"""
-- The live preview updates as each block lands, which is not the playback rate.
-  The **mp4 below it is the real 16 fps clip** — watch that one.
-- **This Space runs below real time: ~1.0 s of compute per 0.75 s of video (0.74x).**
-  Generation is fine (386 ms/block); decoding is the cost, 631 ms against 343 ms
-  locally, because `torch.compile` cannot run in a ZeroGPU worker and the VAE
-  decoder is the thing that is normally compiled. On a local GPU with the decoder
-  compiled the same checkpoint sustains about 2.7x real time.
-- Steer from the 96-prompt bank or from your own text. The bank is the conditioning
-  every published number in the repo refers to; free text is encoded here by
-  umt5-xxl and is **not** numerically comparable to it, because umt5 embeddings
-  differ slightly by hardware — the same string on the training box is a slightly
-  different tensor. It looks fine; it just is not the same conditioning.
-- **How far you steer matters.** Swapping to a nearby scene (waterfall to mountain
-  stream) continues cleanly, because the K/V cache the stream is conditioned on
-  still describes something like the new prompt. Swapping somewhere very different
-  (waterfall to an aurora at night) visibly falls apart over the following seconds.
-  Both are worth trying — the examples below include one of each.
-- One stream at a time: the engine holds a single K/V cache, so requests queue.
-- A stream cannot exceed 1024 latent frames (~4.3 min) — that is where `WanModel`'s
-  RoPE tables end. It stops itself and says so.
+HW_NOTE = """
+**This Space is on shared ZeroGPU hardware, which is not what the project's numbers
+were measured on.** It streams at roughly **0.7x real time** here; on a dedicated GPU
+the same checkpoint sustains about **2.7x**. The clip you get back is correct, it
+just takes longer to produce. Generation is not the bottleneck (about 470 ms per
+block) — decoding is, at about 640 ms against 343 ms, because `torch.compile` cannot
+run inside a ZeroGPU worker and the VAE decoder is what normally gets compiled.
+"""
+
+NOTES = """
+**How far you steer matters.** Swapping to a nearby scene (waterfall to mountain
+stream) continues cleanly, because the K/V cache the stream is conditioned on still
+describes something close to the new prompt. Swapping somewhere very different
+(waterfall to an aurora at night) visibly falls apart over the following seconds.
+Both are worth trying.
+
+**Bank prompts against free text.** The 96-prompt bank is the conditioning every
+published number in the repo refers to. Free text is encoded here by umt5-xxl and is
+not numerically comparable to it, because umt5 embeddings differ slightly by
+hardware, so the same string on the training box is a slightly different tensor. It
+looks fine, it just is not the same conditioning.
+
+**Steering is scheduled, not clicked.** A GPU worker is forked per request and cannot
+be reached from outside while it runs, so the swap is given up front. The swap itself
+is the live one: it replaces the cross-attention conditioning and leaves the cache
+alone.
+
+**Limits.** One stream at a time, since the engine holds a single K/V cache, so
+requests queue. A stream cannot pass 1024 latent frames (about 4.3 minutes), which is
+where `WanModel`'s RoPE tables end; it stops itself and says so.
 """
 
 with gr.Blocks(title="LiveWan") as demo:
     with gr.Column(elem_id="col-container"):
         gr.Markdown(INTRO)
-
-        with gr.Row():
-            world = gr.Dropdown(WORLD_LABELS, value=WORLD_LABELS[2],
-                                label="Open on world", scale=1)
-            steer_to = gr.Dropdown([NO_STEER] + PROMPT_LABELS, value=NO_STEER,
-                                   label="Steer to (prompt bank)", scale=1)
-        steer_text = gr.Textbox(
-            label="…or steer to your own text",
-            placeholder="A lighthouse in a storm",
-            info="Encoded here with umt5-xxl. Overrides the bank selection above.")
-        with gr.Row():
-            steer_at = gr.Slider(1, 25, value=6, step=0.5,
-                                 label="Steer at (seconds in)", scale=1)
-            seconds = gr.Slider(5, 30, value=15, step=1,
-                                label="Generate (seconds of video)", scale=1)
-            seed = gr.Number(value=0, precision=0, label="Seed", scale=0)
-        run_btn = gr.Button("Stream", variant="primary")
-
-        preview = gr.Image(label="Live preview, as each block lands", height=368)
-        stats = gr.Markdown()
-        video = gr.Video(label="The clip, at 16 fps", autoplay=True)
-
-        gr.Examples(
-            examples=[
-                # left alone, the waterfall holds for the full 20 s
-                [W[60], NO_STEER, "", 6, 20, 0],
-                # a near steer: waterfall -> mountain stream. The scene carries on
-                [W[60], P[57], "", 6, 18, 0],
-                # a far steer: waterfall -> aurora at night. This is where it breaks
-                [W[60], P[68], "", 6, 18, 0],
-                # the same idea in free text, which is what the box is for
-                [W[60], NO_STEER, "A lighthouse in a storm", 6, 18, 0],
-                # a person, steered to another person
-                [W[0], P[2], "", 7, 18, 0],
-            ],
-            inputs=[world, steer_to, steer_text, steer_at, seconds, seed],
-            label="Try one",
-        )
-        gr.Markdown(NOTES)
+        gr.Markdown(HW_NOTE, elem_id="hw-note")
+
+        with gr.Row(equal_height=False):
+            with gr.Column(scale=2):
+                world = gr.Dropdown(WORLD_LABELS, value=W[60],
+                                    label="Open on world")
+                steer_to = gr.Dropdown([NO_STEER] + PROMPT_LABELS, value=NO_STEER,
+                                       label="Steer to", info="From the prompt bank")
+                steer_text = gr.Textbox(
+                    label="Or steer to your own text", lines=2,
+                    placeholder="A lighthouse in a storm",
+                    info="Encoded with umt5-xxl. Overrides the selection above.")
+                steer_at = gr.Slider(1, 25, value=6, step=0.5,
+                                     label="Swap at (seconds in)")
+                seconds = gr.Slider(5, 30, value=15, step=1,
+                                    label="Generate (seconds of video)")
+                seed = gr.Number(value=0, precision=0, label="Seed")
+                run_btn = gr.Button("Stream", variant="primary", size="lg")
+
+            with gr.Column(scale=3):
+                video = gr.Video(label="The clip, at 16 fps", autoplay=True,
+                                 height=368)
+                preview = gr.Image(label="Live preview, as each block lands",
+                                   height=200)
+                stats = gr.Markdown()
+
+        with gr.Accordion("How to read this", open=False):
+            gr.Markdown(NOTES)
 
     run_btn.click(run, inputs=[world, steer_to, steer_text, steer_at, seconds, seed],
                   outputs=[preview, stats, video], concurrency_limit=1)