test(engine): address review notes on volume-envelope baking

- WAV parser now scans chunks order-independently (no longer assumes `fmt `
  precedes `data`); added a data-before-fmt test to pin it.
- Assert the base-volume degradation backstop surfaces its reason instead of
  silently succeeding (directly tests layer 3).
- Reword preview/render parity claim: the bake reproduces the curve at the
  probe's 60 Hz resolution, not the continuous GSAP curve.

Author: miguel-heygen

packages/engine/src/services/audioMixer.test.ts

@@ -213,6 +213,8 @@ describe("processCompositionAudio", () => {
     expect(result.success).toBe(true);
     expect(result.tracksProcessed).toBe(1);
     expect(runFfmpegMock).toHaveBeenCalledTimes(3);
+    // Degradation is surfaced, not silent — the track rendered at base volume.
+    expect(result.error).toMatch(/base volume/i);
 
     // The fallback mix omits the automation expression (base volume only).
     const fallbackArgs = runFfmpegMock.mock.calls[2]?.[0];

packages/engine/src/services/audioVolumeEnvelope.test.ts

@@ -119,6 +119,32 @@ describe("applyVolumeEnvelopeToWav", () => {
     expect(applyVolumeEnvelopeToWav(path, keyframes, 0, 0)).toBe(true);
   });
 
+  it("parses chunks in any order (data before fmt)", () => {
+    const path = join(tmp(), "order.wav");
+    const frames = 4;
+    const dataSize = frames * CHANNELS * 2;
+    // Lay the data chunk before fmt to exercise order-independent scanning.
+    const buffer = Buffer.alloc(12 + (8 + dataSize) + (8 + 16));
+    buffer.write("RIFF", 0, "ascii");
+    buffer.writeUInt32LE(buffer.length - 8, 4);
+    buffer.write("WAVE", 8, "ascii");
+    let o = 12;
+    buffer.write("data", o, "ascii");
+    buffer.writeUInt32LE(dataSize, o + 4);
+    for (let i = 0; i < frames * CHANNELS; i += 1) buffer.writeInt16LE(10000, o + 8 + i * 2);
+    o += 8 + dataSize;
+    buffer.write("fmt ", o, "ascii");
+    buffer.writeUInt32LE(16, o + 4);
+    buffer.writeUInt16LE(1, o + 8);
+    buffer.writeUInt16LE(CHANNELS, o + 10);
+    buffer.writeUInt32LE(SAMPLE_RATE, o + 12);
+    buffer.writeUInt16LE(16, o + 22);
+    writeFileSync(path, buffer);
+
+    expect(applyVolumeEnvelopeToWav(path, [{ time: 0, volume: 0 }], 0, 0)).toBe(true);
+    expect(readFileSync(path).readInt16LE(12 + 8)).toBe(0); // first sample muted
+  });
+
   it("rejects non-16-bit PCM so the caller can fall back", () => {
     const path = join(tmp(), "e.wav");
     // 24-bit PCM header (bitsPerSample = 24); body contents are irrelevant.

packages/engine/src/services/audioVolumeEnvelope.ts

@@ -28,7 +28,14 @@ interface WavLayout {
   dataSize: number;
 }
 
-/** Locate the `fmt ` and `data` chunks and validate the format we know how to edit. */
+/**
+ * Locate the `fmt ` and `data` chunks and validate the format we know how to edit.
+ *
+ * Scans every chunk rather than assuming an ordering: the loop always advances
+ * past a chunk's body (using its declared size), so `data` may precede `fmt `
+ * and trailing chunks (LIST/fact/etc.) are skipped harmlessly. Returns null on
+ * anything unexpected so the caller falls back to the expression path.
+ */
 function parseWavLayout(buffer: Buffer): WavLayout | null {
   if (buffer.length < 12 || buffer.toString("ascii", 0, 4) !== "RIFF") return null;
   if (buffer.toString("ascii", 8, 12) !== "WAVE") return null;
@@ -50,7 +57,6 @@ function parseWavLayout(buffer: Buffer): WavLayout | null {
       };
     } else if (chunkId === "data") {
       data = { offset: body, size: Math.min(chunkSize, buffer.length - body) };
-      break; // sample data follows; no need to scan further
     }
     // Chunks are word-aligned: an odd size carries a trailing pad byte.
     offset = body + chunkSize + (chunkSize % 2);