Collapse a dual-mono resample bake to one channel, like every other capture

prepareLanding takes the shared collapse on the staged buffer before the hash
and the channel-count read, so hash, entry and file all derive from one buffer.
A true-stereo bake stays byte-identical.

src/core/capture/wav_codec.cpp

@@ -6,6 +6,7 @@
 
 #include <cstdio>   // std::snprintf (hash hex render)
 #include <cstring>  // std::memcpy, std::memcmp
+#include <utility>  // std::move
 
 namespace reasampler::capture {
 
@@ -300,6 +301,23 @@ MonoCollapse collapseToMono(const std::vector<std::uint8_t>& bytes) {
     return out;
 }
 
+CollapsedWav applyMonoCollapse(std::vector<std::uint8_t> bytes) {
+    CollapsedWav out;
+    MonoCollapse collapse = collapseToMono(bytes);
+    if (collapse.collapsed) {
+        const WavLayout rebuilt = parseWavLayout(collapse.bytes);
+        if (rebuilt.valid) {
+            out.bytes = std::move(collapse.bytes);
+            out.layout = rebuilt;
+            out.collapsed = true;
+            return out;
+        }
+    }
+    out.bytes = std::move(bytes);
+    out.layout = parseWavLayout(out.bytes);
+    return out;
+}
+
 std::string monoCollapseSuffix(MonoCollapseOutcome outcome) {
     switch (outcome) {
         case MonoCollapseOutcome::Declined:  return {};

src/core/capture/wav_codec.h

@@ -117,6 +117,22 @@ struct MonoCollapse {
 // including the bext/source-position consequence beyond hashing.
 MonoCollapse collapseToMono(const std::vector<std::uint8_t>& bytes);
 
+// A buffer after the collapse has had its say, PAIRED with the parse of the bytes
+// actually returned — so a caller that hashes `bytes`, reads a channel count off
+// `layout` and then writes `bytes` cannot describe one buffer while writing another.
+struct CollapsedWav {
+    std::vector<std::uint8_t> bytes;  // the rebuilt 1-channel WAV, or the input verbatim
+    WavLayout layout;                 // the parse OF `bytes`
+    bool collapsed = false;
+};
+
+// `collapseToMono` over a whole buffer, for a caller that goes on to hash and measure
+// the result rather than rewrite a file (`shell/capture`'s collapseCapturedFileToMono is
+// the file-side path over the same predicate). Takes the buffer by value: a decline hands
+// those same bytes straight back. A rebuild that does not parse back is discarded rather
+// than returned, so an invalid `layout` can only ever mean the INPUT was not a usable WAV.
+CollapsedWav applyMonoCollapse(std::vector<std::uint8_t> bytes);
+
 // How applying the collapse to a captured FILE ended. `Declined` is collapseToMono's own
 // "nothing to do"; `Failed` is a read that never happened or a warranted rewrite that did
 // not land. The capture is intact and correctly measured in every case — only the report