Refuse a take shorter than the chain, and delete a digest nobody called

Two findings from reading v1.1..v2, both in audio_lock's neighbourhood.

_prepare_master_audio loaded the take, printed its duration, and nothing ever
compared it to the chain. A take shorter than the render runs the last hops
past its end, fit_samples zero-pads them, and those hops come back MUTE --
found after paying for the render. Every other duration in this pack is
validated on the queue.

That is the third defect the review of the contributed patch listed --
"master_audio_secs is computed, printed, and never used again" -- and
rebuilding the feature from its prose reproduced it faithfully. It was also
hit during this project's own GPU testing and worked around by hand, which is
the clearest argument a check could have.

It raises rather than warns. Trailing silence is expressible by padding the
take; a mute final hop nobody asked for is not worth the minutes it costs to
discover. A take LONGER than the chain just notes how much goes unused.

recording_digest is deleted. It was defined in audio_lock, asserted in
check_audio_lock, and called by nothing -- h3_ref_chain digests the loaded
waveform through _store.audio_digest. Its docstring argued for size+mtime
"because the take is minutes long and this runs on every queue", a performance
case for a function nobody ran, while the path that does run hashes the
samples and is the better one anyway.

Its assertions went with it. A checker asserting the behaviour of dead code is
the fixture-versus-production problem from sections 63 and 68 in a third
costume: not a fixture that fails to match production, but an assertion about
something that is not production at all.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01RVz8qNGn2NhrP3KG2Lh5yT

audio_lock.py

@@ -38,7 +38,6 @@ tone, regenerable):
 """
 from __future__ import annotations
 
-import hashlib
 import math
 import os
 
@@ -160,36 +159,6 @@ def grid_samples(audio_latent_length, sr=VAE_SR, audio_hz=AUDIO_HZ):
     return int(math.ceil(int(audio_latent_length) / float(audio_hz) * int(sr)))
 
 
-def recording_digest(path):
-    """Identity of the take for the hop-cache key.
-
-    Empty / missing -> None, so `master_audio_file=""` does not move a
-    key. Size + mtime + basename, not a full-file hash: the take is
-    minutes long and this runs on every queue.
-    """
-    path = str(path or "").strip()
-    if not path:
-        return None
-    try:
-        st = os.stat(path)
-    except OSError:
-        # The file will fail to load later with a readable error. A missing
-        # file must still change the key, or a render against a now-gone
-        # take could be served from cache.
-        h = hashlib.sha256()
-        h.update(b"missing:")
-        h.update(path.encode("utf-8", "replace"))
-        return h.hexdigest()[:16]
-    h = hashlib.sha256()
-    h.update(os.path.basename(path).encode("utf-8", "replace"))
-    h.update(b":")
-    h.update(str(int(st.st_size)).encode())
-    h.update(b":")
-    h.update(str(int(st.st_mtime_ns if hasattr(st, "st_mtime_ns")
-                     else st.st_mtime)).encode())
-    return h.hexdigest()[:16]
-
-
 def force_stereo(wav):
     """wav is [C, T] or [B, C, T]. Mono is duplicated. Returns [C, T] C=2."""
     import torch

h3_ref_chain.py

@@ -2909,6 +2909,39 @@ class HandTieClips:
                   f"old formula would have been "
                   f"{sum(lengths) - overlap_n * (n - 1)}f)",
                   flush=True)
+        # Is the take long enough for the chain it is locked to?
+        #
+        # Every other duration in this pack is validated on the queue, and this
+        # one was not. `_prepare_master_audio` loads the file, prints how long
+        # it is, and nothing ever compares that to the chain. A take shorter
+        # than the render runs the last hops past its end, `fit_samples`
+        # zero-pads them, and those hops come back MUTE -- discovered after
+        # paying for the render.
+        #
+        # It is the defect the review of the contributed patch listed third
+        # ("`master_audio_secs` is computed, printed, and never used again"),
+        # and rebuilding that feature from its prose reproduced it faithfully.
+        # It was also hit during this project's own GPU testing and worked
+        # around by hand, which is the clearest possible argument for a check.
+        #
+        # Raises rather than warns. Trailing silence is expressible -- pad the
+        # take file -- but a mute final hop that nobody asked for is not worth
+        # the minutes it costs to find out about.
+        if locked is not None:
+            take_s = float(locked["wav"].shape[-1]) / float(locked["sr"])
+            need_s = float(total_frames) / FPS
+            if take_s + 1.0 / FPS < need_s:
+                raise ValueError(
+                    f"{TAG}: master_audio_file is {take_s:.2f}s but this chain "
+                    f"is {need_s:.2f}s ({total_frames}f at {FPS:g} fps). The "
+                    f"last {need_s - take_s:.2f}s would be locked to silence "
+                    f"the take does not contain. Shorten the chain, or pad the "
+                    f"recording to at least {need_s:.2f}s.")
+            if take_s > need_s + 1.0:
+                print(f"[{TAG}] master_audio_file is {take_s:.2f}s for a "
+                      f"{need_s:.2f}s chain; the last {take_s - need_s:.2f}s "
+                      f"is not used", flush=True)
+
         # A dry run must not allocate the master. At 8 x 15 s and 1280x736 that
         # is 2742 full float frames -- ~31 GB -- for a feature whose entire
         # point is that it costs seconds.

tools/check_audio_lock.py

@@ -155,10 +155,15 @@ def main():
     ck("nine hops 0..8 cover the 64.67 s tester chain",
        abs(L.hop_audio_window_s(8, 192, 22, 24.0)[1] - 64.666666) < 1e-4)
 
-    print("digest: empty is None, so it cannot move a cache key")
-    ck("empty string digests to None", L.recording_digest("") is None)
-    ck("whitespace digests to None", L.recording_digest("  ") is None)
-
+    # No assertions for `recording_digest` here any more: the function is gone.
+    # It was defined, tested, and called by nothing -- h3_ref_chain digests the
+    # loaded waveform through _store.audio_digest instead. Its docstring argued
+    # for size+mtime "because the take is minutes long and this runs on every
+    # queue", a performance case for a function nobody ran, while the path that
+    # does run hashes the samples. A checker asserting the behaviour of dead
+    # code is the same fixture-versus-production problem as sections 63 and 68
+    # in a third costume: not a fixture that fails to match production, but an
+    # assertion about something that is not production at all.
     print("mask polarity: 1 on video, 0 on audio")
     v = torch.ones((1, 1, 4, 2, 2))
     a = torch.zeros((1, 1, 4, 2))
@@ -221,6 +226,23 @@ def main():
        "_batch_wav(left)" in src and "_batch_wav(right)" in src)
 
     print()
+    # The take-length pre-flight. A take shorter than the chain runs the last
+    # hops past its end, fit_samples zero-pads them, and those hops come back
+    # mute -- after the render is paid for. Asserted on the source, because
+    # driving run() to the point where `locked` and `total_frames` both exist
+    # needs a model.
+    print(chr(10) + "take length is checked on the queue")
+    with open(os.path.join(HERE, "h3_ref_chain.py"), encoding="utf-8") as _fh:
+        src = _fh.read()
+    ck("run() compares the take against the chain",
+       "master_audio_file is" in src and "is not used" in src,
+       "both the refusal and the unused-tail note")
+    ck("the refusal names both durations",
+       "but this chain" in src and "{total_frames}f" in src)
+    ck("it raises rather than warning",
+       "raise ValueError(" in src.split("master_audio_file is")[0][-400:],
+       "a mute final hop nobody asked for is not a warning")
+
     splice_checks(ck, sys.modules["htcpack.h3_ref_chain"], torch)
 
     if FAIL: