heygen-com
diff --git a/‎packages/core/package.json‎
Lines changed: 2 additions & 2 deletions b/‎packages/core/package.json‎
Lines changed: 2 additions & 2 deletions
diff --git a/‎packages/core/scripts/build-audio-fx-runtime.ts‎
Lines changed: 13 additions & 0 deletions b/‎packages/core/scripts/build-audio-fx-runtime.ts‎
Lines changed: 13 additions & 0 deletions
diff --git a/‎packages/core/scripts/build-inline-artifact.ts‎
Lines changed: 0 additions & 97 deletions b/‎packages/core/scripts/build-inline-artifact.ts‎
Lines changed: 0 additions & 97 deletions
diff --git a/‎packages/core/scripts/build-position-edits-render.ts‎
Lines changed: 13 additions & 0 deletions b/‎packages/core/scripts/build-position-edits-render.ts‎
Lines changed: 13 additions & 0 deletions
diff --git a/‎packages/core/scripts/buildInjectedArtifact.ts‎
Lines changed: 78 additions & 0 deletions b/‎packages/core/scripts/buildInjectedArtifact.ts‎
Lines changed: 78 additions & 0 deletions
diff --git a/‎packages/core/src/audio/audioFxGraph.test.ts‎
Lines changed: 107 additions & 15 deletions b/‎packages/core/src/audio/audioFxGraph.test.ts‎
Lines changed: 107 additions & 15 deletions
@@ -596,9 +596,9 @@
     "typecheck": "tsc --noEmit && bun run typecheck:runtime",
     "typecheck:runtime": "tsc --noEmit -p tsconfig.runtime.json",
     "lint:runtime-preview-guards": "bun scripts/lint-runtime-preview-guards.ts",
-    "build:audio-fx-runtime": "tsx scripts/build-inline-artifact.ts audio-fx",
+    "build:audio-fx-runtime": "tsx scripts/build-audio-fx-runtime.ts",
     "build:hyperframes-runtime": "tsx scripts/build-hyperframes-runtime-artifact.ts",
-    "build:position-edits-render": "tsx scripts/build-inline-artifact.ts position-edits",
+    "build:position-edits-render": "tsx scripts/build-position-edits-render.ts",
     "check:position-edits-render": "bun run build:position-edits-render && git diff --exit-code -- src/generated/position-edits-render-inline.ts",
     "build:hyperframes-runtime:modular": "SANDBOX_RUNTIME_VARIANT=modular tsx scripts/build-hyperframes-runtime-artifact.ts",
     "build:hyperframe-runtime": "tsx scripts/build-hyperframes-runtime-artifact.ts",
 
@@ -0,0 +1,13 @@
+/** Build the injectable audio-FX runtime artifact from the canonical runtime. */
+
+import { buildInjectedArtifact } from "./buildInjectedArtifact.js";
+
+buildInjectedArtifact({
+  scriptUrl: import.meta.url,
+  entry: "stubs/audio-fx-runtime-entry.ts",
+  out: "audio-fx-runtime-inline.ts",
+  constName: "AUDIO_FX_RUNTIME_IIFE",
+  fnName: "getAudioFxRuntimeScript",
+  what: "audio-FX runtime IIFE",
+  event: "audio_fx_runtime_generated",
+});
@@ -0,0 +1,13 @@
+/** Build the injectable position-edits render artifact from the canonical runtime. */
+
+import { buildInjectedArtifact } from "./buildInjectedArtifact.js";
+
+buildInjectedArtifact({
+  scriptUrl: import.meta.url,
+  entry: "stubs/position-edits-render-entry.ts",
+  out: "position-edits-render-inline.ts",
+  constName: "POSITION_EDITS_RENDER_IIFE",
+  fnName: "getPositionEditsRenderScript",
+  what: "position-edits render IIFE",
+  event: "position_edits_render_generated",
+});
@@ -0,0 +1,78 @@
+/**
+ * Bundle a stub entry into an injectable IIFE, wrapped as a TypeScript constant.
+ *
+ * Two artifacts are built this way — the audio-FX runtime and the position-edits
+ * render — and the engine injects both into the headless browser as a script tag.
+ * They were two copies of this file differing in five names, which is a poor
+ * place for a divergence to hide: whichever copy stopped being edited would go on
+ * producing a subtly different artifact with nothing to say so.
+ */
+
+import { execFileSync } from "node:child_process";
+import { mkdirSync, writeFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { buildSync } from "esbuild";
+
+export interface InjectedArtifact {
+  /** The build script's own `import.meta.url`, so paths resolve beside it. */
+  scriptUrl: string;
+  /** Entry stub, relative to the package root. */
+  entry: string;
+  /** Output file name inside `src/generated`. */
+  out: string;
+  /** SCREAMING_CASE name for the string constant holding the IIFE. */
+  constName: string;
+  /** The accessor the rest of the codebase imports. */
+  fnName: string;
+  /** What that accessor returns, for its doc comment: "the pre-built X". */
+  what: string;
+  /** Structured log event name. */
+  event: string;
+}
+
+export function buildInjectedArtifact(spec: InjectedArtifact): void {
+  const scriptDir = dirname(fileURLToPath(spec.scriptUrl));
+  const scriptName = spec.scriptUrl.split("/").pop() ?? "";
+  const repoRoot = resolve(scriptDir, "..");
+  const entry = resolve(repoRoot, spec.entry);
+  const generatedDir = resolve(repoRoot, "src/generated");
+  const outPath = resolve(generatedDir, spec.out);
+
+  const result = buildSync({
+    entryPoints: [entry],
+    bundle: true,
+    write: false,
+    platform: "browser",
+    format: "iife",
+    target: ["es2020"],
+    minify: true,
+    legalComments: "none",
+  });
+  const iife = result.outputFiles[0]?.text ?? "";
+  if (!iife) throw new Error(`esbuild produced no output for ${spec.entry.split("/").pop()}`);
+
+  mkdirSync(generatedDir, { recursive: true });
+  writeFileSync(
+    outPath,
+    [
+      `// AUTO-GENERATED by scripts/${scriptName} - do not edit`,
+      `const ${spec.constName}: string = ${JSON.stringify(iife)};`,
+      "",
+      `/** Returns the pre-built ${spec.what} as a string constant. */`,
+      `export function ${spec.fnName}(): string {`,
+      `  return ${spec.constName};`,
+      "}",
+      "",
+    ].join("\n"),
+    "utf8",
+  );
+
+  try {
+    execFileSync("bun", ["x", "oxfmt", outPath], { stdio: "ignore" });
+  } catch {
+    // Formatting is best effort when the generator runs in a minimal environment.
+  }
+
+  console.log(JSON.stringify({ event: spec.event, outPath, bytes: iife.length }));
+}
@@ -25,13 +25,17 @@ class FakeNode {
   Q = new FakeParam();
   gain = new FakeParam();
   delayTime = new FakeParam();
+  playbackRate = new FakeParam();
+  loop = false;
   type = "";
   curve: Float32Array | null = null;
   oversample = "none";
-  buffer: unknown = null;
+  buffer: FakeBuffer | null = null;
   normalize = true;
   port = { postMessage: (m: unknown) => this.messages.push(m) };
   messages: unknown[] = [];
+  /** `start(when, offset)` — the offset is the LFO's phase, so it is asserted. */
+  startArgs: (number | undefined)[] | null = null;
   constructor(public kind: string) {}
   connect(next: FakeNode): FakeNode {
     this.connections.push(next);
@@ -40,10 +44,23 @@ class FakeNode {
   disconnect(): void {
     this.disconnected = true;
   }
-  start(): void {}
+  start(...args: (number | undefined)[]): void {
+    this.startArgs = args;
+  }
   stop(): void {}
 }
 
+/** One channel, kept across `getChannelData` calls so what is written can be read. */
+class FakeBuffer {
+  private data: Float32Array;
+  constructor(public length: number) {
+    this.data = new Float32Array(length);
+  }
+  getChannelData(): Float32Array {
+    return this.data;
+  }
+}
+
 class FakeCtx {
   sampleRate = 48000;
   created: FakeNode[] = [];
@@ -67,14 +84,17 @@ class FakeCtx {
   createOscillator() {
     return this.make("osc");
   }
+  createBufferSource() {
+    return this.make("bufferSource");
+  }
   createWaveShaper() {
     return this.make("waveshaper");
   }
   createConvolver() {
     return this.make("convolver");
   }
   createBuffer(_c: number, length: number) {
-    return { length, getChannelData: () => new Float32Array(length) };
+    return new FakeBuffer(length);
   }
 }
 
@@ -350,19 +370,91 @@ describe("levels and per-channel state", () => {
   });
 
   it("sets the phaser LFO waveform it declares", () => {
-    const ctx = new FakeCtx();
-    buildFxNode(ctx as unknown as BaseAudioContext, "phaser", {
-      ...defaultAudioFxParams("phaser"),
-      type: "0",
-    });
-    const osc = ctx.created.find((n) => n.kind === "osc");
-    expect(osc?.type).toBe("triangle");
-    const ctx2 = new FakeCtx();
-    buildFxNode(ctx2 as unknown as BaseAudioContext, "phaser", {
-      ...defaultAudioFxParams("phaser"),
-      type: "1",
+    // A quarter of the way through the cycle both waveforms peak at 1, so the
+    // eighth is where they part: a sine is at sin(π/4), a triangle halfway up.
+    const eighth = (c: FakeCtx): number => {
+      const buffer = c.created.find((n) => n.kind === "bufferSource")?.buffer;
+      if (!buffer) throw new Error("no LFO buffer");
+      return buffer.getChannelData()[Math.round(buffer.length / 8)] ?? 0;
+    };
+    const build = (type: string): FakeCtx => {
+      const c = new FakeCtx();
+      buildFxNode(c as unknown as BaseAudioContext, "phaser", {
+        ...defaultAudioFxParams("phaser"),
+        type,
+      });
+      return c;
+    };
+    expect(eighth(build("0"))).toBeCloseTo(0.5, 3);
+    expect(eighth(build("1"))).toBeCloseTo(Math.SQRT1_2, 3);
+  });
+
+  /**
+   * The waveform is baked into a buffer at construction, so pushing a type change
+   * into the running graph would be a no-op — preview would keep sweeping on a
+   * triangle while the render used the sine the attribute now says.
+   */
+  it("rebuilds a phaser when its LFO waveform changes", () => {
+    const phaser = (params: Record<string, number | string>): HfAudioFxChain => ({
+      version: 1,
+      nodes: [
+        {
+          type: "phaser",
+          enabled: true,
+          params: { ...defaultAudioFxParams("phaser"), type: "0", ...params },
+        },
+      ],
     });
-    expect(ctx2.created.find((n) => n.kind === "osc")?.type).toBe("sine");
+    const built = buildFxChain(asCtx(ctx()), phaser({}));
+    expect(built.update(phaser({ type: "1" }))).toBe(false);
+    // Everything else about a phaser still updates in place.
+    const other = buildFxChain(asCtx(ctx()), phaser({}));
+    expect(other.update(phaser({ speed: 2 }))).toBe(true);
+  });
+
+  /**
+   * An LFO's phase is the whole reason it is a looping buffer rather than an
+   * OscillatorNode, whose phase is zero at `start()` and cannot be set.
+   *
+   * Preview rebuilds the graph mid-play — a seek, a scrub, any structural edit —
+   * and an oscillator restarted there put the chorus at the top of its sweep
+   * wherever the playhead happened to be, so preview disagreed with the render
+   * and with itself across an edit.
+   */
+  it("starts a modulated effect's LFO at the phase the clip has reached", () => {
+    // 3.5 s at 2 Hz is seven whole cycles: back at phase zero.
+    const whole = ctx();
+    buildFxNode(asCtx(whole), "chorus", { ...defaultAudioFxParams("chorus"), speed: 2 }, 3.5);
+    expect(whole.created.find((n) => n.kind === "bufferSource")?.startArgs?.[1]).toBeCloseTo(0, 6);
+    // 3.6 s at 2 Hz is seven cycles and a fifth.
+    const part = ctx();
+    buildFxNode(asCtx(part), "chorus", { ...defaultAudioFxParams("chorus"), speed: 2 }, 3.6);
+    const src = part.created.find((n) => n.kind === "bufferSource");
+    expect(src?.startArgs?.[1]).toBeCloseTo(0.2, 6);
+    expect(src?.loop).toBe(true);
+    // One second of waveform: the rate reads in Hz, so a speed lane needs no map.
+    expect(src?.playbackRate.value).toBeCloseTo(2, 6);
+  });
+
+  /**
+   * A source node is not retired by disconnecting what it feeds. The chorus and
+   * phaser stopped their LFO and left it out of the nodes they disconnect, so
+   * every rebuild that dropped one left a modulator still wired to the delay or
+   * the allpass bank it had been driving.
+   */
+  it("unwires a modulated effect's LFO when the effect is disposed", () => {
+    for (const type of ["chorus", "phaser"]) {
+      const c = ctx();
+      buildFxNode(asCtx(c), type, defaultAudioFxParams(type)).dispose();
+      const lfo = c.created.find((node) => node.kind === "bufferSource");
+      expect(lfo?.disconnected, `${type} left its LFO connected`).toBe(true);
+    }
+  });
+
+  it("starts the LFO at zero for a render, which always begins at the clip's start", () => {
+    const c = ctx();
+    buildFxNode(asCtx(c), "phaser", defaultAudioFxParams("phaser"));
+    expect(c.created.find((n) => n.kind === "bufferSource")?.startArgs?.[1]).toBe(0);
   });
 
   it("rebuilds a one-pole filter when its cutoff moves", () => {