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.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