fix: remove hidden audio gain in renders

packages/engine/src/config.test.ts

@@ -29,6 +29,7 @@ describe("resolveConfig", () => {
     expect(config.quality).toBe("standard");
     expect(config.format).toBe("jpeg");
     expect(config.jpegQuality).toBe(80);
+    expect(config.audioGain).toBe(1);
     expect(config.debug).toBe(false);
   });
 

packages/engine/src/config.ts

@@ -105,7 +105,7 @@ export const DEFAULT_CONFIG: EngineConfig = {
   hdr: false,
   hdrAutoDetect: true,
 
-  audioGain: 1.35,
+  audioGain: 1,
   frameDataUriCacheLimit: 256,
 
   playerReadyTimeout: 45_000,

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

@@ -0,0 +1,67 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+const { runFfmpegMock } = vi.hoisted(() => ({
+  runFfmpegMock: vi.fn(async () => ({
+    success: true,
+    durationMs: 1,
+    stderr: "",
+    exitCode: 0,
+  })),
+}));
+
+vi.mock("../utils/runFfmpeg.js", () => ({
+  runFfmpeg: runFfmpegMock,
+}));
+
+import { processCompositionAudio } from "./audioMixer.js";
+
+describe("processCompositionAudio", () => {
+  const tempDirs: string[] = [];
+
+  afterEach(() => {
+    runFfmpegMock.mockClear();
+    for (const dir of tempDirs.splice(0)) {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  it("preserves muted tracks and uses unity master gain by default", async () => {
+    const baseDir = mkdtempSync(join(tmpdir(), "hf-audio-base-"));
+    const workDir = mkdtempSync(join(tmpdir(), "hf-audio-work-"));
+    tempDirs.push(baseDir, workDir);
+
+    writeFileSync(join(baseDir, "voice.wav"), "stub");
+
+    const result = await processCompositionAudio(
+      [
+        {
+          id: "voice",
+          src: "voice.wav",
+          start: 0,
+          end: 2,
+          mediaStart: 0,
+          layer: 0,
+          volume: 0,
+          type: "audio",
+        },
+      ],
+      baseDir,
+      workDir,
+      join(baseDir, "out.m4a"),
+      2,
+    );
+
+    expect(result.success).toBe(true);
+    expect(runFfmpegMock).toHaveBeenCalledTimes(2);
+
+    const mixArgs = runFfmpegMock.mock.calls[1]?.[0];
+    const filterIndex = mixArgs.indexOf("-filter_complex");
+    const filter = mixArgs[filterIndex + 1];
+
+    expect(filter).toContain("volume=0");
+    expect(filter).toContain("[mixed]volume=1[out]");
+  });
+});

packages/engine/src/services/audioMixer.ts

@@ -396,7 +396,7 @@ export async function processCompositionAudio(
           end: element.end,
           mediaStart: element.mediaStart,
           duration: element.end - element.start,
-          volume: element.volume || 1.0,
+          volume: element.volume ?? 1.0,
         });
       } catch (err: unknown) {
         errors.push(`Error: ${element.id} — ${err instanceof Error ? err.message : String(err)}`);

packages/producer/src/regression-harness.ts

@@ -18,6 +18,7 @@ import { createRenderJob, executeRenderJob } from "./services/renderOrchestrator
 import { compileForRender } from "./services/htmlCompiler.js";
 import { validateCompilation } from "./services/compilationTester.js";
 import { extractVideoMetadata } from "./utils/ffprobe.js";
+import { buildRmsEnvelope, compareAudioEnvelopes } from "./utils/audioRegression.js";
 
 // ── Types ────────────────────────────────────────────────────────────────────
 
@@ -348,66 +349,6 @@ function extractMonoPcm16(videoPath: string): Int16Array {
   }
 }
 
-function buildRmsEnvelope(samples: Int16Array, windowSize = 2048, hopSize = 1024): number[] {
-  if (samples.length < windowSize) return [];
-  const envelope: number[] = [];
-  for (let start = 0; start + windowSize <= samples.length; start += hopSize) {
-    let energy = 0;
-    for (let i = 0; i < windowSize; i += 1) {
-      const normalized = (samples[start + i] ?? 0) / 32768;
-      energy += normalized * normalized;
-    }
-    envelope.push(Math.sqrt(energy / windowSize));
-  }
-  return envelope;
-}
-
-function correlationAtLag(a: number[], b: number[], lag: number): number {
-  const startA = Math.max(0, lag);
-  const startB = Math.max(0, -lag);
-  const length = Math.min(a.length - startA, b.length - startB);
-  if (length <= 32) return -1;
-
-  let meanA = 0;
-  let meanB = 0;
-  for (let i = 0; i < length; i += 1) {
-    meanA += a[startA + i] ?? 0;
-    meanB += b[startB + i] ?? 0;
-  }
-  meanA /= length;
-  meanB /= length;
-
-  let numerator = 0;
-  let denA = 0;
-  let denB = 0;
-  for (let i = 0; i < length; i += 1) {
-    const da = (a[startA + i] ?? 0) - meanA;
-    const db = (b[startB + i] ?? 0) - meanB;
-    numerator += da * db;
-    denA += da * da;
-    denB += db * db;
-  }
-  if (denA <= 1e-12 || denB <= 1e-12) return -1;
-  return numerator / Math.sqrt(denA * denB);
-}
-
-function bestEnvelopeCorrelation(
-  rendered: number[],
-  snapshot: number[],
-  maxLagWindows: number,
-): { correlation: number; lagWindows: number } {
-  let best = -1;
-  let bestLag = 0;
-  for (let lag = -maxLagWindows; lag <= maxLagWindows; lag += 1) {
-    const corr = correlationAtLag(rendered, snapshot, lag);
-    if (corr > best) {
-      best = corr;
-      bestLag = lag;
-    }
-  }
-  return { correlation: best, lagWindows: bestLag };
-}
-
 // ── Failure Reporting ────────────────────────────────────────────────────────
 
 function saveFailureDetails(
@@ -751,7 +692,7 @@ async function runTestSuite(
     if (renderedAudio.length > 0 && snapshotAudio.length > 0) {
       const renderedEnvelope = buildRmsEnvelope(renderedAudio);
       const snapshotEnvelope = buildRmsEnvelope(snapshotAudio);
-      const audio = bestEnvelopeCorrelation(
+      const audio = compareAudioEnvelopes(
         renderedEnvelope,
         snapshotEnvelope,
         suite.meta.maxAudioLagWindows,

packages/producer/src/services/renderOrchestrator.test.ts

@@ -203,7 +203,7 @@ describe("applyRenderModeHints", () => {
       ffmpegEncodeTimeout: 600000,
       ffmpegProcessTimeout: 300000,
       ffmpegStreamingTimeout: 600000,
-      audioGain: 1.35,
+      audioGain: 1,
       frameDataUriCacheLimit: 256,
       playerReadyTimeout: 45000,
       renderReadyTimeout: 15000,

packages/producer/src/utils/audioRegression.test.ts

@@ -0,0 +1,16 @@
+import { describe, expect, it } from "vitest";
+import { buildRmsEnvelope, compareAudioEnvelopes } from "./audioRegression.js";
+
+describe("compareAudioEnvelopes", () => {
+  it("treats silent-vs-silent audio as a perfect match", () => {
+    const silentSamples = new Int16Array(4096);
+
+    const rendered = buildRmsEnvelope(silentSamples);
+    const snapshot = buildRmsEnvelope(silentSamples);
+
+    expect(compareAudioEnvelopes(rendered, snapshot, 120)).toEqual({
+      correlation: 1,
+      lagWindows: 0,
+    });
+  });
+});

packages/producer/src/utils/audioRegression.ts

@@ -0,0 +1,79 @@
+export function buildRmsEnvelope(samples: Int16Array, windowSize = 2048, hopSize = 1024): number[] {
+  if (samples.length < windowSize) return [];
+  const envelope: number[] = [];
+  for (let start = 0; start + windowSize <= samples.length; start += hopSize) {
+    let energy = 0;
+    for (let i = 0; i < windowSize; i += 1) {
+      const normalized = (samples[start + i] ?? 0) / 32768;
+      energy += normalized * normalized;
+    }
+    envelope.push(Math.sqrt(energy / windowSize));
+  }
+  return envelope;
+}
+
+function correlationAtLag(a: number[], b: number[], lag: number): number {
+  const startA = Math.max(0, lag);
+  const startB = Math.max(0, -lag);
+  const length = Math.min(a.length - startA, b.length - startB);
+  if (length <= 32) return -1;
+
+  let meanA = 0;
+  let meanB = 0;
+  for (let i = 0; i < length; i += 1) {
+    meanA += a[startA + i] ?? 0;
+    meanB += b[startB + i] ?? 0;
+  }
+  meanA /= length;
+  meanB /= length;
+
+  let numerator = 0;
+  let denA = 0;
+  let denB = 0;
+  for (let i = 0; i < length; i += 1) {
+    const da = (a[startA + i] ?? 0) - meanA;
+    const db = (b[startB + i] ?? 0) - meanB;
+    numerator += da * db;
+    denA += da * da;
+    denB += db * db;
+  }
+  if (denA <= 1e-12 || denB <= 1e-12) return -1;
+  return numerator / Math.sqrt(denA * denB);
+}
+
+function bestEnvelopeCorrelation(
+  rendered: number[],
+  snapshot: number[],
+  maxLagWindows: number,
+): { correlation: number; lagWindows: number } {
+  let best = -1;
+  let bestLag = 0;
+  for (let lag = -maxLagWindows; lag <= maxLagWindows; lag += 1) {
+    const corr = correlationAtLag(rendered, snapshot, lag);
+    if (corr > best) {
+      best = corr;
+      bestLag = lag;
+    }
+  }
+  return { correlation: best, lagWindows: bestLag };
+}
+
+function isSilentEnvelope(envelope: number[]): boolean {
+  return envelope.length > 0 && envelope.every((sample) => Math.abs(sample) <= 1e-9);
+}
+
+export function compareAudioEnvelopes(
+  rendered: number[],
+  snapshot: number[],
+  maxLagWindows: number,
+): { correlation: number; lagWindows: number } {
+  if (rendered.length === 0 || snapshot.length === 0) {
+    return { correlation: 1, lagWindows: 0 };
+  }
+
+  if (isSilentEnvelope(rendered) && isSilentEnvelope(snapshot)) {
+    return { correlation: 1, lagWindows: 0 };
+  }
+
+  return bestEnvelopeCorrelation(rendered, snapshot, maxLagWindows);
+}

packages/studio/tsconfig.json

@@ -16,6 +16,7 @@
     "declarationMap": true,
     "sourceMap": true,
     "outDir": "dist",
+    "rootDir": "..",
     "types": ["vite/client"],
     "lib": ["dom", "dom.iterable", "esnext"],
     "allowJs": true,