@@ -253,8 +253,10 @@ function onePoleBuilder(kind: "highpass" | "lowpass"): Builder {
 }
 
 function workletBuilder(processor: string, resettable = false): Builder {
-  return (ctx, p) => {
-    const node = new AudioWorkletNode(ctx, processor, { processorOptions: { ...p } });
+  return (ctx, p, elapsed) => {
+    const node = new AudioWorkletNode(ctx, processor, {
+      processorOptions: { ...p, __hfElapsed: elapsed },
+    });
     return {
       input: node,
       output: node,
 
@@ -1,5 +1,11 @@
 import { describe, expect, it } from "vitest";
-import { chainLatencySamples, chainTailSeconds, MAX_FX_TAIL_SECONDS } from "./audioFxTail.js";
+import {
+  chainLatencySamples,
+  chainTailSeconds,
+  delayTailSeconds,
+  MAX_FX_TAIL_SECONDS,
+  reverbRoomSeconds,
+} from "./audioFxTail.js";
 import { truePeakLatencySamples } from "./audioFxTruePeak.js";
 import { synthesizeReverbImpulse } from "./audioFxGraph.js";
 import type { HfAudioFxChain } from "../audioFx.js";
@@ -130,3 +136,15 @@ describe("chainLatencySamples", () => {
     );
   });
 });
+
+describe("tail helpers shared with the engine's window warm-up", () => {
+  it("counts a delay's repeats to -60 dB, uncapped", () => {
+    expect(delayTailSeconds(5000, 0.95)).toBeCloseTo(135 * 5, 5);
+    expect(delayTailSeconds(400, 0.5)).toBeCloseTo(10 * 0.4, 5);
+  });
+
+  it("is the reverb impulse's length", () => {
+    expect(reverbRoomSeconds(0.5)).toBeCloseTo(1.9, 5);
+    expect(reverbRoomSeconds(4)).toBeCloseTo(3.2, 5);
+  });
+});
@@ -56,7 +56,7 @@ function knobMax(node: HfAudioFxNode, key: string, automation?: HfAutomation): n
  * Repeats until a feedback loop falls under the floor, times the gap between
  * them. `feedback` is capped below 1 by the registry, so this terminates.
  */
-function delayTail(time: number, feedback: number): number {
+export function delayTailSeconds(time: number, feedback: number): number {
   const gap = Math.min(5, time / 1000);
   if (gap <= 0) return 0;
   const fb = Math.max(0, Math.min(0.999, feedback));
@@ -66,15 +66,19 @@ function delayTail(time: number, feedback: number): number {
 
 // Exactly the generated impulse's length — see synthesizeReverbImpulse, which
 // is the same expression. A convolution is as long as its impulse.
+export function reverbRoomSeconds(size: number): number {
+  return 0.6 + Math.max(0, Math.min(1, size)) * 2.6;
+}
+
 function reverbTail(node: HfAudioFxNode, automation?: HfAutomation): number {
   return knobMax(node, "wet", automation) > 0
-    ? 0.6 + Math.max(0, Math.min(1, knobMax(node, "size", automation))) * 2.6
+    ? reverbRoomSeconds(knobMax(node, "size", automation))
     : 0;
 }
 
 function delayNodeTail(node: HfAudioFxNode, automation?: HfAutomation): number {
   return knobMax(node, "mix", automation) > 0
-    ? delayTail(knobMax(node, "time", automation), knobMax(node, "feedback", automation))
+    ? delayTailSeconds(knobMax(node, "time", automation), knobMax(node, "feedback", automation))
     : 0;
 }
 
 
@@ -192,6 +192,7 @@ class HfBitcrush extends AudioWorkletProcessor {
     this.p = o.processorOptions || {};
     this.holds = [];
     this.held = [];
+    this.start = Math.round((this.p.__hfElapsed ?? 0) * sampleRate);
     this.port.onmessage = (e) => {
       if (e.data && e.data.__hfDispose) { this.dead = true; return; }
       this.p = { ...this.p, ...e.data };
@@ -208,7 +209,8 @@ class HfBitcrush extends AudioWorkletProcessor {
     for (let ch = 0; ch < i.length; ch++) {
       const inp = i[ch], out = o[ch];
       if (this.held[ch] === undefined) this.held[ch] = 0;
-      if (this.holds[ch] === undefined) this.holds[ch] = 0;
+      // The hold counter runs from the file's first sample, so a node built part-way in starts where it would be.
+      if (this.holds[ch] === undefined) this.holds[ch] = this.start % step;
       for (let n = 0; n < inp.length; n++) {
         // Per channel: advancing one shared counter only on the last channel
         // left every earlier channel either unheld or frozen for a whole
@@ -255,7 +257,11 @@ class HfPitchshift extends AudioWorkletProcessor {
     this.grain = Math.round(sampleRate * 0.1);
     this.buf = [];
     this.write = 0;
-    this.phase = 0;
+    // The taps sweep at a constant rate from the start of the file, so a node built
+    // part-way in joins the sweep where it would already be.
+    const ratio0 = Math.pow(2, Math.max(-12, Math.min(12, this.p.semitones ?? 0)) / 12);
+    const turns = (this.p.__hfElapsed ?? 0) * sampleRate * ((1 - ratio0) / this.grain);
+    this.phase = turns - Math.floor(turns);
     // Samples written so far, capped at one grain. The taps read up to a grain
     // behind the write head, so until this fills they would read the ring's
     // zeros, so the head of every clip came out attenuated or silent.
 
@@ -1,3 +1,4 @@
+import { parseHTML } from "linkedom";
 import { describe, expect, it } from "vitest";
 import { extractStandaloneEntryFromIndex } from "./standaloneEntry";
 
@@ -112,4 +113,77 @@ describe("extractStandaloneEntryFromIndex", () => {
     expect(extracted).toContain('data-duration="2"');
     expect(extracted).not.toContain('data-duration="12"');
   });
+  describe("master bus chain", () => {
+    const hostIndexHtml = `<!DOCTYPE html>
+<html>
+<body>
+  <div id="scene1" data-composition-id="scene1" data-composition-src="compositions/scene1.html" data-width="640" data-height="360" data-fx-chain="{&quot;version&quot;:1,&quot;nodes&quot;:[{&quot;type&quot;:&quot;truepeak&quot;,&quot;id&quot;:&quot;index&quot;}]}"></div>
+</body>
+</html>`;
+    const indexHtml = `<!DOCTYPE html>
+<html>
+<body>
+  <div data-composition-id="master" data-width="640" data-height="360" data-fx-chain="{&quot;version&quot;:1,&quot;nodes&quot;:[{&quot;type&quot;:&quot;truepeak&quot;,&quot;id&quot;:&quot;index&quot;}]}">
+    <div id="scene1" data-composition-id="scene1" data-composition-src="compositions/scene1.html" data-start="0"></div>
+  </div>
+</body>
+</html>`;
+    const chainOf = (html: string): string | null => {
+      const { document } = parseHTML(html);
+      const roots = Array.from(document.querySelectorAll("[data-composition-id]")) as Element[];
+      const top = roots.find((el) => !el.parentElement?.closest("[data-composition-id]"));
+      return top?.getAttribute("data-fx-chain") ?? null;
+    };
+
+    it("carries the scene's own chain, not the index's", () => {
+      const chain = '{"version":1,"nodes":[{"type":"truepeak","id":"scene"}]}';
+      const sceneHtml = `<template id="t"><div data-composition-id="scene1" data-width="640" data-height="360" data-fx-chain='${chain}'></div></template>`;
+
+      const extracted = extractStandaloneEntryFromIndex(
+        indexHtml,
+        "compositions/scene1.html",
+        sceneHtml,
+      );
+
+      expect(chainOf(extracted ?? "")).toBe(chain);
+    });
+
+    it("drops the index's chain when the scene declares none", () => {
+      const sceneHtml = `<template id="t"><div data-composition-id="scene1" data-width="640" data-height="360"></div></template>`;
+
+      const extracted = extractStandaloneEntryFromIndex(
+        indexHtml,
+        "compositions/scene1.html",
+        sceneHtml,
+      );
+
+      expect(chainOf(extracted ?? "")).toBeNull();
+    });
+
+    it("carries the scene's chain when the index's top-level root is the mount itself", () => {
+      const chain = '{"version":1,"nodes":[{"type":"truepeak","id":"scene"}]}';
+      const sceneHtml = `<template id="t"><div data-composition-id="scene1" data-width="640" data-height="360" data-fx-chain='${chain}'></div></template>`;
+
+      const extracted = extractStandaloneEntryFromIndex(
+        hostIndexHtml,
+        "compositions/scene1.html",
+        sceneHtml,
+      );
+
+      expect(chainOf(extracted ?? "")).toBe(chain);
+    });
+
+    it("drops the index's chain from a top-level mount when the scene declares none", () => {
+      const sceneHtml = `<template id="t"><div data-composition-id="scene1" data-width="640" data-height="360"></div></template>`;
+
+      const extracted = extractStandaloneEntryFromIndex(
+        hostIndexHtml,
+        "compositions/scene1.html",
+        sceneHtml,
+      );
+
+      expect(extracted).not.toBeNull();
+      expect(chainOf(extracted ?? "")).toBeNull();
+    });
+  });
 });
@@ -1,4 +1,5 @@
 import { parseHTML } from "linkedom";
+import { HF_AUDIO_FX_ATTR } from "../audioFx";
 
 export function isTemplateEntry(html: string): boolean {
   return html.trimStart().startsWith("<template");
@@ -9,24 +10,36 @@ function normalizeCompositionSrcPath(srcPath: string): string {
 }
 
 // linkedom has no inert <template> content, so the template's innerHTML is re-parsed.
-function readSceneRootDuration(entryHtml: string | undefined): string | null {
+function readSceneRoot(entryHtml: string | undefined): Element | null {
   if (!entryHtml) return null;
   const { document } = parseHTML(entryHtml);
   const template = document.querySelector("template");
   const scope = template ? parseHTML(template.innerHTML).document : document;
-  const root = scope.querySelector("[data-composition-id]") as Element | null;
-  return root?.getAttribute("data-duration") ?? null;
+  return scope.querySelector("[data-composition-id]") as Element | null;
+}
+
+// The scene's own chain replaces the index's, which belongs to the whole project.
+function setSceneFxChain(el: Element, sceneFxChain: string | null): void {
+  if (sceneFxChain) {
+    el.setAttribute(HF_AUDIO_FX_ATTR, sceneFxChain);
+  } else {
+    el.removeAttribute(HF_AUDIO_FX_ATTR);
+  }
 }
 
 function createStandaloneEntryRenderClone(
   root: Element,
   host: Element,
   sceneDuration: string | null,
+  sceneFxChain: string | null,
 ): Element {
   const hostClone = host.cloneNode(true) as Element;
   hostClone.setAttribute("data-start", "0");
 
-  if (root === host) return hostClone;
+  if (root === host) {
+    setSceneFxChain(hostClone, sceneFxChain);
+    return hostClone;
+  }
 
   const rootClone = root.cloneNode(false) as Element;
   // The wrapper takes the scene's length, not the whole project's; with none declared
@@ -36,6 +49,7 @@ function createStandaloneEntryRenderClone(
   } else {
     rootClone.removeAttribute("data-duration");
   }
+  setSceneFxChain(rootClone, sceneFxChain);
   rootClone.appendChild(hostClone);
   return rootClone;
 }
@@ -78,9 +92,12 @@ export function extractStandaloneEntryFromIndex(
   if (!root) return null;
 
   // The scene file owns its duration; the mount's window is the fallback.
-  const sceneDuration = readSceneRootDuration(entryHtml) ?? host.getAttribute("data-duration");
+  const sceneRoot = readSceneRoot(entryHtml);
+  const sceneDuration =
+    sceneRoot?.getAttribute("data-duration") ?? host.getAttribute("data-duration");
+  const sceneFxChain = sceneRoot?.getAttribute(HF_AUDIO_FX_ATTR) || null;
 
-  const renderClone = createStandaloneEntryRenderClone(root, host, sceneDuration);
+  const renderClone = createStandaloneEntryRenderClone(root, host, sceneDuration, sceneFxChain);
   replaceBodyWithRenderClone(body, renderClone);
 
   return document.toString();
 
@@ -7,7 +7,7 @@
  * ends share a single implementation rather than two that have to be kept in
  * agreement.
  *
- * Exposes `window.__HF_AUDIO_FX.render(pcm, sampleRate, chain, automation)`,
+ * Exposes `window.__HF_AUDIO_FX.render(pcm, sampleRate, chain, automation, elapsed)`,
  * which returns the processed samples.
  */
 
@@ -29,6 +29,7 @@ declare global {
         sampleRate: number,
         chainJson: string,
         automationJson?: string,
+        elapsed?: number,
       ): Promise<Float32Array[]>;
     };
   }
@@ -45,6 +46,9 @@ declare global {
  * comes from the settings (`chainTailSeconds`), capped, and the returned planes
  * are correspondingly longer than what came in — the mixer decides how much of
  * that it lets through past the clip's end.
+ *
+ * `elapsed` is where in the file `planes` begins, for a window cut from a longer
+ * input: modulated effects follow the file's clock, not the window's.
  */
 
 /** The clip's audio as an AudioBuffer, a plane per channel. */
@@ -77,6 +81,7 @@ async function render(
   sampleRate: number,
   chainJson: string,
   automationJson?: string,
+  elapsed = 0,
 ): Promise<Float32Array[]> {
   const chain: HfAudioFxChain = parseAudioFxChain(chainJson);
   const channels = Math.max(1, planes.length);
@@ -98,9 +103,11 @@ async function render(
   if (chainNeedsWorklets(chain)) await ensureAudioFxWorklets(ctx);
 
   const source = ctx.createBufferSource();
-  source.buffer = toBuffer(ctx, planes, channels, frames, sampleRate);
+  // Padded with silence by the limiter's lookahead: once a source ends its worklets stop being
+  // fed, so without it the last `latency` samples of the clip never leave the lookahead line.
+  source.buffer = toBuffer(ctx, planes, channels, frames + latency, sampleRate);
 
-  const fx = buildFxChain(ctx, chain);
+  const fx = buildFxChain(ctx, chain, elapsed);
 
   // The input WAV is the clip's own audio from its first sample, so clip-local
   // time is offline time — the envelope needs no offset here. Same scheduler as