Add regen debug logging + remove console.log noise

- Add [regen TARO/MMA/HF] print statements at every step of regen:
trigger received, early-exit reason, lock acquired, inference start/done, errors
- Remove all console.log/warn/error from waveform iframe JS
- Add per-slot threading.Lock to prevent concurrent regen race conditions
- Add regen loading indicator (_build_regen_pending_html)
- Replace gr.State with hidden gr.Textbox (JSON) to fix Gradio 5 SSR
'Too many arguments' in endpoint validation

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

app.py

@@ -1243,7 +1243,6 @@ def _build_waveform_html(audio_path: str, segments: list, slot_id: str,
     const dpr = window.devicePixelRatio || 1;
     const W   = wrap.getBoundingClientRect().width  || window.innerWidth || 600;
     const H   = 80;
-    console.log('[wf iframe {slot_id}] drawWaveform W='+W+' H='+H);
     cv.width  = W * dpr;  cv.height = H * dpr;
     const ctx = cv.getContext('2d');
     ctx.scale(dpr, dpr);
@@ -1340,34 +1339,27 @@ def _build_waveform_html(audio_path: str, segments: list, slot_id: str,
 
   // ── Decode audio ───────────────────────────────────────────────────
   const b64str = '{b64}';
-  console.log('[wf iframe {slot_id}] b64 len='+b64str.length);
   const bin = atob(b64str);
   const buf = new Uint8Array(bin.length);
   for (let i=0; i<bin.length; i++) buf[i]=bin.charCodeAt(i);
-  console.log('[wf iframe {slot_id}] raw bytes='+buf.byteLength);
 
   const AudioCtx = window.AudioContext || window.webkitAudioContext;
-  if (!AudioCtx) {{
-    console.warn('[wf iframe {slot_id}] No AudioContext');
-  }} else {{
+  if (AudioCtx) {{
     const tmpCtx = new AudioCtx({{sampleRate:44100}});
-    console.log('[wf iframe {slot_id}] calling decodeAudioData');
     try {{
       tmpCtx.decodeAudioData(buf.buffer.slice(0),
         function(ab) {{
-          console.log('[wf iframe {slot_id}] decoded OK duration='+ab.duration+'s');
           try {{ tmpCtx.close(); }} catch(e) {{}}
           function tryDraw() {{
             const W = wrap.getBoundingClientRect().width || window.innerWidth;
-            console.log('[wf iframe {slot_id}] tryDraw W='+W);
             if (W > 0) {{ drawWaveform(ab.getChannelData(0), ab.duration); }}
             else {{ setTimeout(tryDraw, 100); }}
           }}
           tryDraw();
         }},
-        function(err) {{ console.error('[wf iframe {slot_id}] decodeAudioData err:', err); }}
+        function(err) {{}}
       );
-    }} catch(e) {{ console.error('[wf iframe {slot_id}] decodeAudioData threw:', e); }}
+    }} catch(e) {{}}
   }}
 }})();
 </script>
@@ -1539,9 +1531,9 @@ _GLOBAL_JS = """
   function fireRegen(slot_id, idx) {
     const hidden_id = 'regen_trigger_' + slot_id;
     const el = document.getElementById(hidden_id);
-    if (!el) { console.warn('[wf global] regen el not found:', hidden_id); return; }
+    if (!el) return;
     const input = el.querySelector('input, textarea');
-    if (!input) { console.warn('[wf global] regen input not found in', hidden_id); return; }
+    if (!input) return;
     const desc = Object.getOwnPropertyDescriptor(HTMLInputElement.prototype, 'value')
               || Object.getOwnPropertyDescriptor(HTMLTextAreaElement.prototype, 'value');
     if (desc && desc.set) desc.set.call(input, slot_id + '|' + idx);
@@ -1649,26 +1641,35 @@ with gr.Blocks(title="Generate Audio for Video", css=_SLOT_CSS, js=_GLOBAL_JS) a
                 _slot_id = f"taro_{_i}"
                 def _make_taro_regen(_si, _sid):
                     def _do(trigger_val, video, seed, cfg, steps, mode, cf_dur, cf_db, state_json):
+                        print(f"[regen TARO] trigger_val={trigger_val!r} state_json_len={len(state_json) if state_json else 0} video={video!r}")
                         if not trigger_val or not state_json:
+                            print(f"[regen TARO] early-exit: trigger_val empty={not trigger_val} state empty={not state_json}")
                             return gr.update(), gr.update(), gr.update(value=""), gr.update()
                         parts = trigger_val.split("|")
                         if len(parts) != 2 or parts[0] != _sid:
+                            print(f"[regen TARO] early-exit: parts={parts} expected slot={_sid}")
                             return gr.update(), gr.update(), gr.update(value=""), gr.update()
                         seg_idx = int(parts[1])
-                        # Acquire per-slot lock so concurrent regens on the same slot
-                        # don't read stale state (second regen waits for first to finish).
+                        print(f"[regen TARO] slot={_sid} seg_idx={seg_idx} — acquiring lock")
                         lock = _get_slot_lock(_sid)
                         with lock:
+                            print(f"[regen TARO] slot={_sid} seg_idx={seg_idx} — lock acquired, showing spinner")
                             state   = json.loads(state_json)
                             pending_html = _build_regen_pending_html(
                                 state["segments"], seg_idx, _sid,
                                 f"regen_trigger_{_sid}"
                             )
                             yield gr.update(), gr.update(value=pending_html), gr.update(value=state_json), gr.update()
-                            vid, aud, new_meta_json, html = regen_taro_segment(
-                                video, seg_idx, state_json,
-                                seed, cfg, steps, mode, cf_dur, cf_db, _sid,
-                            )
+                            print(f"[regen TARO] slot={_sid} seg_idx={seg_idx} — calling regen_taro_segment")
+                            try:
+                                vid, aud, new_meta_json, html = regen_taro_segment(
+                                    video, seg_idx, state_json,
+                                    seed, cfg, steps, mode, cf_dur, cf_db, _sid,
+                                )
+                                print(f"[regen TARO] slot={_sid} seg_idx={seg_idx} — done, vid={vid!r}")
+                            except Exception as _e:
+                                print(f"[regen TARO] slot={_sid} seg_idx={seg_idx} — ERROR: {_e}")
+                                raise
                             yield gr.update(value=vid), gr.update(value=html), gr.update(value=new_meta_json), gr.update(value="")
                     return _do
                 _rtrig.change(
@@ -1731,24 +1732,35 @@ with gr.Blocks(title="Generate Audio for Video", css=_SLOT_CSS, js=_GLOBAL_JS) a
                 _slot_id = f"mma_{_i}"
                 def _make_mma_regen(_si, _sid):
                     def _do(trigger_val, video, prompt, neg, seed, cfg, steps, cf_dur, cf_db, state_json):
+                        print(f"[regen MMA] trigger_val={trigger_val!r} state_json_len={len(state_json) if state_json else 0} video={video!r}")
                         if not trigger_val or not state_json:
+                            print(f"[regen MMA] early-exit: trigger_val empty={not trigger_val} state empty={not state_json}")
                             return gr.update(), gr.update(), gr.update(value=""), gr.update()
                         parts = trigger_val.split("|")
                         if len(parts) != 2 or parts[0] != _sid:
+                            print(f"[regen MMA] early-exit: parts={parts} expected slot={_sid}")
                             return gr.update(), gr.update(), gr.update(value=""), gr.update()
                         seg_idx = int(parts[1])
+                        print(f"[regen MMA] slot={_sid} seg_idx={seg_idx} — acquiring lock")
                         lock = _get_slot_lock(_sid)
                         with lock:
+                            print(f"[regen MMA] slot={_sid} seg_idx={seg_idx} — lock acquired, showing spinner")
                             state   = json.loads(state_json)
                             pending_html = _build_regen_pending_html(
                                 state["segments"], seg_idx, _sid,
                                 f"regen_trigger_{_sid}"
                             )
                             yield gr.update(), gr.update(value=pending_html), gr.update(value=state_json), gr.update()
-                            vid, aud, new_meta_json, html = regen_mmaudio_segment(
-                                video, seg_idx, state_json,
-                                prompt, neg, seed, cfg, steps, cf_dur, cf_db, _sid,
-                            )
+                            print(f"[regen MMA] slot={_sid} seg_idx={seg_idx} — calling regen_mmaudio_segment")
+                            try:
+                                vid, aud, new_meta_json, html = regen_mmaudio_segment(
+                                    video, seg_idx, state_json,
+                                    prompt, neg, seed, cfg, steps, cf_dur, cf_db, _sid,
+                                )
+                                print(f"[regen MMA] slot={_sid} seg_idx={seg_idx} — done, vid={vid!r}")
+                            except Exception as _e:
+                                print(f"[regen MMA] slot={_sid} seg_idx={seg_idx} — ERROR: {_e}")
+                                raise
                             yield gr.update(value=vid), gr.update(value=html), gr.update(value=new_meta_json), gr.update(value="")
                     return _do
                 _rtrig.change(
@@ -1812,24 +1824,35 @@ with gr.Blocks(title="Generate Audio for Video", css=_SLOT_CSS, js=_GLOBAL_JS) a
                 _slot_id = f"hf_{_i}"
                 def _make_hf_regen(_si, _sid):
                     def _do(trigger_val, video, prompt, neg, seed, guidance, steps, size, cf_dur, cf_db, state_json):
+                        print(f"[regen HF] trigger_val={trigger_val!r} state_json_len={len(state_json) if state_json else 0} video={video!r}")
                         if not trigger_val or not state_json:
+                            print(f"[regen HF] early-exit: trigger_val empty={not trigger_val} state empty={not state_json}")
                             return gr.update(), gr.update(), gr.update(value=""), gr.update()
                         parts = trigger_val.split("|")
                         if len(parts) != 2 or parts[0] != _sid:
+                            print(f"[regen HF] early-exit: parts={parts} expected slot={_sid}")
                             return gr.update(), gr.update(), gr.update(value=""), gr.update()
                         seg_idx = int(parts[1])
+                        print(f"[regen HF] slot={_sid} seg_idx={seg_idx} — acquiring lock")
                         lock = _get_slot_lock(_sid)
                         with lock:
+                            print(f"[regen HF] slot={_sid} seg_idx={seg_idx} — lock acquired, showing spinner")
                             state   = json.loads(state_json)
                             pending_html = _build_regen_pending_html(
                                 state["segments"], seg_idx, _sid,
                                 f"regen_trigger_{_sid}"
                             )
                             yield gr.update(), gr.update(value=pending_html), gr.update(value=state_json), gr.update()
-                            vid, aud, new_meta_json, html = regen_hunyuan_segment(
-                                video, seg_idx, state_json,
-                                prompt, neg, seed, guidance, steps, size, cf_dur, cf_db, _sid,
-                            )
+                            print(f"[regen HF] slot={_sid} seg_idx={seg_idx} — calling regen_hunyuan_segment")
+                            try:
+                                vid, aud, new_meta_json, html = regen_hunyuan_segment(
+                                    video, seg_idx, state_json,
+                                    prompt, neg, seed, guidance, steps, size, cf_dur, cf_db, _sid,
+                                )
+                                print(f"[regen HF] slot={_sid} seg_idx={seg_idx} — done, vid={vid!r}")
+                            except Exception as _e:
+                                print(f"[regen HF] slot={_sid} seg_idx={seg_idx} — ERROR: {_e}")
+                                raise
                             yield gr.update(value=vid), gr.update(value=html), gr.update(value=new_meta_json), gr.update(value="")
                     return _do
                 _rtrig.change(