Make Generate always run live, never serve the precomputed cache

Previously an exact spec match on the Generate button would replay the
cached result instead of running the model, including for the default
configuration each tab opens on. That's fine for passive browsing (still
handled by _sync_results/_fp_sync_results and the page-load prefill,
unchanged) but meant the one deliberate action a visitor takes -- pressing
Generate -- could be a replay rather than a real run, undermining
replicability. run_demo_stream and run_future_demo no longer check the
cache at all; only browsing stays free, the click itself always costs GPU
time now. Drops the now-dead _cached_arm_updates helper and
CACHE_HIT_DELAY constant, and updates both precompute scripts' docstrings
to stop claiming Generate is ever free.

app.py

@@ -171,9 +171,6 @@ TEXT_OUTPUT_LINES = 6
 # default configuration of each tab ships pre-generated -- but a visitor must
 # always be able to tell which is which.
 CACHED_BADGE = "cached"
-# Cache hits are effectively instant; a beat of delay is what makes the click
-# read as "it did something" rather than "the button is broken".
-CACHE_HIT_DELAY = 0.35
 
 
 def _save_to_mp4(video_array):
@@ -542,23 +539,6 @@ def _cleared_frame_updates():
     return updates
 
 
-def _cached_arm_updates(seed_value):
-    """Arming frame for a cache hit. Deliberately NOT _loading_state_html --
-    its "Inference has started — the first run can take an extra 1-2 minutes
-    while tokenizers load" copy would
-    be a lie here. The pause that follows is a button-press acknowledgement,
-    not a fake generation: an instantaneous flip reads as a dead button."""
-    updates = _reset_frame_updates(seed_value)
-    updates[IDX_STATUS] = gr.update(value=_status_html("loading precomputed result"))
-    updates[IDX_EMPTY] = gr.update(visible=True, value=(
-        '<div class="empty-state loading-state">'
-        f'<p class="mono" style="margin-bottom:6px;color:var(--text-2)">precomputed · seed {seed_value}</p>'
-        "<p>Loading a saved result — no GPU time used.</p></div>"
-    ))
-    updates[IDX_BTN] = gr.update(value="Loading…", interactive=False)
-    return updates
-
-
 def _frame(updates):
     out = [gr.skip()] * N_STREAM_OUTPUTS
     for idx, upd in updates.items():
@@ -1803,11 +1783,17 @@ with gr.Blocks(title="A2A-Video: Any-to-All Video Generation", theme=_THEME, css
 
             def run_demo_stream(src_mode, example_stem, upload_path, caption_text, abs_mod,
                                 chain, seed_value, top_p, top_k, *hyperparam_values):
-                """Undecorated on purpose. Validation and the cache lookup run
-                here, on CPU; only a genuine miss reaches the GPU. That also
-                means a validation error surfaces with its real message --
-                spaces' worker wrapper replaces exception messages with a bare
-                "ZeroGPU worker error"."""
+                """Undecorated on purpose. Validation runs here, on CPU. That
+                also means a validation error surfaces with its real message
+                -- spaces' worker wrapper replaces exception messages with a
+                bare "ZeroGPU worker error".
+
+                Deliberately does NOT serve the precomputed cache, even on an
+                exact spec match: pressing Generate is the one action that
+                should always be a real, replicable run of the model, not a
+                replay -- the cache still fronts every other configuration
+                (see _sync_results/the page-load prefill), so browsing stays
+                free; only the click itself always costs GPU time."""
                 try:
                     req = resolve_a2a(src_mode, example_stem, upload_path, caption_text,
                                       abs_mod, chain, seed_value, top_p, top_k,
@@ -1815,14 +1801,7 @@ with gr.Blocks(title="A2A-Video: Any-to-All Video Generation", theme=_THEME, css
                 except ValueError as e:
                     raise gr.Error(str(e))
 
-                entry = _CACHE.lookup(req.spec)
-                if entry is not None:
-                    yield _frame(_cached_arm_updates(req.seed))
-                    time.sleep(CACHE_HIT_DELAY)
-                    yield _cached_a2a_frames(req, entry)
-                    return
-
-                # Miss. Arm the UI before asking for a GPU, so the spinner is
+                # Arm the UI before asking for a GPU, so the spinner is
                 # already up during the ZeroGPU queue wait.
                 yield _frame(_reset_frame_updates(req.seed))
                 yield from _run_demo_stream_gpu(req.input_modality, req.chain, req.gen_kwargs,
@@ -2300,8 +2279,9 @@ with gr.Blocks(title="A2A-Video: Any-to-All Video Generation", theme=_THEME, css
 
             def run_future_demo(example_stem, obs_mod, seed_tokens, cond_mode, cond_mod, steer_text, targets,
                                 seed_value, top_p, top_k, complete_seed, *hyperparam_values):
-                """Undecorated: validation and cache lookup on CPU, GPU only on
-                a miss (see run_demo_stream)."""
+                """Undecorated: validation on CPU, GPU always follows (see
+                run_demo_stream -- pressing Generate never serves the cache,
+                on purpose)."""
                 try:
                     req = resolve_fp(example_stem, obs_mod, seed_tokens, cond_mode, cond_mod,
                                      steer_text, targets, seed_value, top_p, top_k,
@@ -2310,23 +2290,6 @@ with gr.Blocks(title="A2A-Video: Any-to-All Video Generation", theme=_THEME, css
                 except ValueError as e:
                     raise gr.Error(str(e))
 
-                entry = _CACHE.lookup(req.spec)
-                if entry is not None:
-                    yield _fp_frame(_fp_arm_updates(
-                        req.seed, "loading precomputed result",
-                        '<div class="empty-state loading-state">'
-                        f'<p class="mono" style="margin-bottom:6px;color:var(--text-2)">precomputed · seed {req.seed}</p>'
-                        "<p>Loading a saved result — no GPU time used.</p></div>",
-                        "Loading…",
-                    ))
-                    time.sleep(CACHE_HIT_DELAY)
-                    results = _CACHE.resolve_results(entry)
-                    cards = _fp_cards(req.obs_mod, req.extra, req.chain, req.seed_tokens,
-                                      results, req.steer_text, complete_seed=req.complete_seed)
-                    yield _fp_frame(_fp_final_updates(
-                        cards, f"precomputed · seed {req.seed}", "Predict again", CACHED_BADGE))
-                    return
-
                 yield _fp_frame(_fp_arm_updates(
                     req.seed, f"warming up · seed {req.seed}",
                     _loading_state_html(req.seed), "Predicting…"))

scripts/upload_precomputed_to_hub.py

@@ -6,8 +6,11 @@ scripts/precompute_demo_outputs.py, which produces the folder this uploads).
 Why precompute at all: ZeroGPU gives free-tier Space visitors a few minutes of
 GPU per day, and load_pipeline's ~37.5 GB of checkpoints is loaded from inside
 that allocation. Shipping the default configuration of each tab pre-generated
-means the demo shows real predictions the moment it opens, and clicking
-Generate without changing anything costs no quota.
+means the demo shows real predictions the moment it opens, and browsing any
+other precomputed clip/chain/modality shows its result instantly too, at no
+GPU cost. Pressing Generate always runs live regardless -- the app never
+serves this cache from the Generate button itself, only from passively
+switching between configurations.
 
 The folder is uploaded VERBATIM under the `precomputed/` prefix of the same
 dataset repo that already holds the example tokens and previews: