pixi-effects 0.3.0 → 0.5.0

package/dist/index.cjs

@@ -1,7 +1,8 @@
 'use strict';
 
-var chunkZL262ZRM_cjs = require('./chunk-ZL262ZRM.cjs');
-var chunkSIRVULFF_cjs = require('./chunk-SIRVULFF.cjs');
+var chunkUQBGW5DO_cjs = require('./chunk-UQBGW5DO.cjs');
+var chunk23M5QTWW_cjs = require('./chunk-23M5QTWW.cjs');
+var chunk2RR43OIN_cjs = require('./chunk-2RR43OIN.cjs');
 var PIXI = require('pixi.js');
 var gsap = require('gsap');
 var PixiPlugin = require('gsap/PixiPlugin');
@@ -88,21 +89,213 @@ async function loadAssetBundle(assets, audioContext) {
 async function mixdown(audios, totalDuration, sampleRate = 44100) {
   if (audios.length === 0) return null;
   const ctx = new OfflineAudioContext(2, Math.ceil(sampleRate * totalDuration), sampleRate);
+  const synthesised = /* @__PURE__ */ new Map();
+  const bufferOf = (a) => {
+    if (a.buffer) return a.buffer;
+    if (!a.synth) return null;
+    let buf = synthesised.get(a.synth.key);
+    if (!buf) {
+      const [left, right] = a.synth.render(sampleRate);
+      buf = ctx.createBuffer(2, left.length, sampleRate);
+      buf.getChannelData(0).set(left);
+      buf.getChannelData(1).set(right);
+      synthesised.set(a.synth.key, buf);
+    }
+    return buf;
+  };
   for (const a of audios) {
+    const buffer = bufferOf(a);
+    if (!buffer) continue;
+    const begin = Math.max(0, a.start);
+    const skipped = begin - a.start;
+    if (skipped > 0) {
+      console.warn(
+        `pixi-effects: ${a.layer ?? "an audio layer"} starts at ${a.start.toFixed(2)}s, before the movie starts, so its first ${skipped.toFixed(2)}s are cut off. Start it at 0 or later.`
+      );
+    }
     const src = ctx.createBufferSource();
-    src.buffer = a.buffer;
+    src.buffer = buffer;
     src.loop = !!a.loop;
     const gain = ctx.createGain();
-    gain.gain.setValueAtTime(a.initialVolume ?? 1, a.start);
+    gain.gain.setValueAtTime(a.initialVolume ?? 1, begin);
     for (const kf of a.volumeKeyframes ?? []) {
-      gain.gain.linearRampToValueAtTime(kf.value, kf.time);
+      gain.gain.linearRampToValueAtTime(kf.value, Math.max(0, kf.time));
     }
     src.connect(gain).connect(ctx.destination);
-    src.start(a.start);
-    src.stop(a.end);
+    src.start(begin, skipped);
+    src.stop(Math.max(begin, a.end));
   }
   return await ctx.startRendering();
 }
+var KNEE = 0.9;
+function limitMix(buffer, audios) {
+  let peak = 0;
+  let peakIndex = 0;
+  for (let ch = 0; ch < buffer.numberOfChannels; ch++) {
+    const d = buffer.getChannelData(ch);
+    for (let i = 0; i < d.length; i++) {
+      const x = Math.abs(d[i]);
+      if (x > peak) {
+        peak = x;
+        peakIndex = i;
+      }
+      if (x > KNEE) d[i] = Math.sign(d[i]) * (KNEE + (1 - KNEE) * Math.tanh((x - KNEE) / (1 - KNEE)));
+    }
+  }
+  const peakAt = peakIndex / buffer.sampleRate;
+  if (peak > 1) {
+    const playing = audios.filter((a) => a.start <= peakAt && peakAt < a.end).map((a) => a.layer ?? "an audio layer");
+    console.warn(
+      `pixi-effects: the audio mix peaks at ${peak.toFixed(2)} (${(20 * Math.log10(peak)).toFixed(1)} dBFS) at ${peakAt.toFixed(2)}s, so it was limited (it would distort). Playing there: ${[...new Set(playing)].join(", ")}. Lower their volume.`
+    );
+  }
+  return { peak, peakAt };
+}
+
+// src/core/spectrum.ts
+function fft(re, im) {
+  const n = re.length;
+  for (let i = 1, j = 0; i < n; i++) {
+    let bit = n >> 1;
+    for (; j & bit; bit >>= 1) j ^= bit;
+    j ^= bit;
+    if (i < j) {
+      [re[i], re[j]] = [re[j], re[i]];
+      [im[i], im[j]] = [im[j], im[i]];
+    }
+  }
+  for (let len = 2; len <= n; len <<= 1) {
+    const ang = -2 * Math.PI / len;
+    for (let i = 0; i < n; i += len) {
+      for (let k = 0; k < len / 2; k++) {
+        const wr = Math.cos(ang * k), wi = Math.sin(ang * k);
+        const a = i + k, b = a + len / 2;
+        const xr = re[b] * wr - im[b] * wi, xi = re[b] * wi + im[b] * wr;
+        re[b] = re[a] - xr;
+        im[b] = im[a] - xi;
+        re[a] = re[a] + xr;
+        im[a] = im[a] + xi;
+      }
+    }
+  }
+}
+var FRAME = 2048;
+function spectralCentroid(samples, sampleRate, from = 0, to = samples.length) {
+  let num = 0;
+  let den = 0;
+  const re = new Float64Array(FRAME);
+  const im = new Float64Array(FRAME);
+  const end = Math.min(to, samples.length);
+  for (let start = Math.max(0, from); start < end; start += FRAME / 2) {
+    for (let i = 0; i < FRAME; i++) {
+      const k = start + i;
+      const w = 0.5 - 0.5 * Math.cos(2 * Math.PI * i / (FRAME - 1));
+      re[i] = k < end ? samples[k] * w : 0;
+      im[i] = 0;
+    }
+    fft(re, im);
+    for (let b = 1; b < FRAME / 2; b++) {
+      const power = re[b] * re[b] + im[b] * im[b];
+      num += power * (b * sampleRate / FRAME);
+      den += power;
+    }
+  }
+  return den > 1e-9 ? Math.round(num / den / 10) * 10 : 0;
+}
+
+// src/core/inspectAudio.ts
+var INAUDIBLE_DB = -50;
+var db = (x) => Math.round(10 * Math.max(-120, 20 * Math.log10(x))) / 10;
+var mono = (chans) => {
+  if (chans.length === 1) return chans[0];
+  const out = new Float32Array(chans[0].length);
+  for (const d of chans) for (let i = 0; i < out.length; i++) out[i] = out[i] + d[i] / chans.length;
+  return out;
+};
+function measure(chans, sampleRate) {
+  let peak = 0;
+  let at = 0;
+  for (const d of chans) for (let i = 0; i < d.length; i++) if (Math.abs(d[i]) > peak) {
+    peak = Math.abs(d[i]);
+    at = i;
+  }
+  return {
+    length: Math.round(chans[0].length / sampleRate * 1e3) / 1e3,
+    peakDb: db(peak),
+    loudestAt: Math.round(at / sampleRate * 1e3) / 1e3,
+    brightnessHz: spectralCentroid(mono(chans), sampleRate)
+  };
+}
+function analyzeAudio(mix, sources, stats, movieDuration, opts = {}) {
+  if (!mix) {
+    return { duration: movieDuration, sampleRate: 0, peakDb: -120, peakAt: 0, sources: [], windows: [], issues: ['no audio: the movie has no audio layers (sound effects need no files: { type: "audio", sfx: "pop", at: 1 })'] };
+  }
+  const sr = mix.sampleRate;
+  const chans = Array.from({ length: mix.numberOfChannels }, (_, c) => mix.getChannelData(c));
+  const mixMono = mono(chans);
+  const peakIn = (t0, t1) => {
+    let p = 0;
+    const i1 = Math.min(mix.length, Math.ceil(t1 * sr));
+    for (const d of chans) for (let i = Math.max(0, Math.floor(t0 * sr)); i < i1; i++) p = Math.max(p, Math.abs(d[i]));
+    return p;
+  };
+  const win = opts.window && opts.window > 0 ? Math.max(0.01, opts.window) : 0.1;
+  const windows2 = [];
+  for (let t = 0; t < movieDuration - 1e-9; t += win) {
+    const i0 = Math.floor(t * sr);
+    const i1 = Math.min(mix.length, Math.floor((t + win) * sr));
+    let sum = 0;
+    let peak = 0;
+    for (const d of chans) {
+      for (let i = i0; i < i1; i++) {
+        sum += d[i] * d[i];
+        peak = Math.max(peak, Math.abs(d[i]));
+      }
+    }
+    const n = Math.max(1, (i1 - i0) * chans.length);
+    windows2.push({ t: Math.round(t * 1e3) / 1e3, rmsDb: db(Math.sqrt(sum / n)), peakDb: db(peak), brightnessHz: spectralCentroid(mixMono, sr, i0, i1) });
+  }
+  const issues = [];
+  if (stats && stats.peak > 1) {
+    issues.push(`the mix peaks at ${db(stats.peak)} dBFS at ${stats.peakAt.toFixed(2)}s and was limited \u2014 lower the volume of the layers playing there`);
+  }
+  const rendered = /* @__PURE__ */ new Map();
+  const soundOf = (s) => {
+    if (s.synth) {
+      let m = rendered.get(s.synth.key);
+      if (!m) rendered.set(s.synth.key, m = measure(s.synth.render(sr), sr));
+      return m;
+    }
+    const b = s.buffer;
+    return measure(Array.from({ length: b.numberOfChannels }, (_, c) => b.getChannelData(c)), b.sampleRate);
+  };
+  const list = [...sources].sort((a, b) => a.start - b.start).map((s) => {
+    const layer = s.layer ?? "an audio layer";
+    const source = s.source ?? "audio";
+    const peakDb = db(peakIn(s.start, Math.min(s.end, movieDuration)));
+    const sound = soundOf(s);
+    const topVolume = Math.max(s.initialVolume ?? 1, ...(s.volumeKeyframes ?? []).map((k) => k.value));
+    const ownDb = db(Math.pow(10, sound.peakDb / 20) * Math.max(0, topVolume));
+    if (s.start >= movieDuration) {
+      issues.push(`${layer} (${source}) starts at ${s.start.toFixed(2)}s, after the movie ends (${movieDuration}s)`);
+    } else if (ownDb < INAUDIBLE_DB || peakDb < INAUDIBLE_DB) {
+      issues.push(`${layer} (${source}) is inaudible from ${s.start.toFixed(2)}s to ${s.end.toFixed(2)}s (its own peak ${ownDb} dBFS at volume ${topVolume}; mix peak there ${peakDb} dBFS) \u2014 check its volume`);
+    }
+    if (s.synth && s.end > movieDuration + 1e-6 && s.start < movieDuration) {
+      issues.push(`${layer} (${source}) is cut off by the end of the movie at ${movieDuration}s (it runs to ${s.end.toFixed(2)}s)`);
+    }
+    return { layer, source, start: s.start, end: s.end, peakDb, sound };
+  });
+  return {
+    duration: movieDuration,
+    sampleRate: sr,
+    peakDb: db(stats?.peak ?? peakIn(0, movieDuration)),
+    peakAt: stats?.peakAt ?? 0,
+    sources: list,
+    windows: windows2,
+    issues
+  };
+}
 var VIDEO_CODEC_BY_FORMAT = {
   mp4: "avc",
   mov: "avc",
@@ -160,7 +353,7 @@ async function exportFrames(movie, options = {}) {
     const audioSource = new mediabunny.AudioBufferSource({
       codec: opts.audio.codec,
       bitrate: opts.audio.bitrate
-    });
+    }, { startTimestamp: opts.audio.codec === "aac" ? -2112 / movie.audioBuffer.sampleRate : 0 });
     output.addAudioTrack(audioSource);
     await output.start();
     await audioSource.add(movie.audioBuffer);
@@ -521,6 +714,15 @@ var TransitionMaskFilter = class extends PIXI.Filter {
 };
 
 // src/core/Transitions.ts
+var windows = /* @__PURE__ */ new WeakMap();
+function transitionWindowsOf(spec) {
+  return windows.get(spec) ?? [];
+}
+function carryTransitionWindows(from, to) {
+  const w = windows.get(from);
+  if (w) windows.set(to, w);
+  return to;
+}
 function expandTransitions(spec) {
   const out = {
     ...spec,
@@ -617,20 +819,23 @@ function expandTransitions(spec) {
     if (toUses > 1) {
       throw new Error(`pixi-effects: ${tag} sequence "${t.to}" is used as \`to\` in more than one transition`);
     }
-    const tStart = chunkSIRVULFF_cjs.resolveAt(t.at, parentDuration);
+    const tStart = chunk2RR43OIN_cjs.resolveAt(t.at, parentDuration);
     const tEnd = tStart + t.duration;
     const fromSeq = fromEntry.seq;
-    const fromStart = chunkSIRVULFF_cjs.resolveAt(fromSeq.at, parentDuration);
+    const fromStart = chunk2RR43OIN_cjs.resolveAt(fromSeq.at, parentDuration);
     const fromEnd = fromStart + (fromSeq.duration ?? parentDuration);
     if (tStart < fromStart || tEnd > fromEnd) {
       throw new Error(`pixi-effects: ${tag} window [${tStart}, ${tEnd}] is not covered by \`from\` "${t.from}" (lives [${fromStart}, ${fromEnd}], so it ends at ${fromEnd})`);
     }
     const toSeq = toEntry.seq;
-    const toStart = chunkSIRVULFF_cjs.resolveAt(toSeq.at, parentDuration);
+    const toStart = chunk2RR43OIN_cjs.resolveAt(toSeq.at, parentDuration);
     const toEnd = toStart + (toSeq.duration ?? parentDuration);
     if (tStart < toStart || tEnd > toEnd) {
       throw new Error(`pixi-effects: ${tag} window [${tStart}, ${tEnd}] is not covered by \`to\` "${t.to}" (lives [${toStart}, ${toEnd}], so it starts at ${toStart})`);
     }
+    const record = windows.get(out) ?? [];
+    record.push({ from: t.from, to: t.to, start: tStart, end: tEnd });
+    windows.set(out, record);
     const abs = { ...t, at: tStart };
     const nFrom = keyframeCount(fromEntry.seq);
     const nTo = keyframeCount(toEntry.seq);
@@ -924,10 +1129,26 @@ var intersection = (a, b) => {
   const h = Math.min(a.y + a.height, b.y + b.height) - Math.max(a.y, b.y);
   return w > 0 && h > 0 ? w * h : 0;
 };
+var clip = (a, b) => {
+  const x = Math.max(a.x, b.x), y = Math.max(a.y, b.y);
+  const w = Math.min(a.x + a.width, b.x + b.width) - x, h = Math.min(a.y + a.height, b.y + b.height) - y;
+  return w > 0 && h > 0 ? { x, y, width: w, height: h } : null;
+};
 function inspectScene(root, frame, time, canvas, opts = {}) {
   const layers = [];
   const view = { x: 0, y: 0, width: canvas.width, height: canvas.height };
-  const walk = (comp, prefix, insideThreeD, parentVisible) => {
+  const seen = /* @__PURE__ */ new Map();
+  const scene = /* @__PURE__ */ new Map();
+  const scaledToNothing = /* @__PURE__ */ new Set();
+  const walk = (comp, prefix, insideThreeD, parentVisible, parentScene, parentMoving = false, parentZero = false) => {
+    const blending = /* @__PURE__ */ new Set();
+    for (const w of transitionWindowsOf(comp.spec)) {
+      const start = (comp.absoluteStart ?? 0) + w.start, end = (comp.absoluteStart ?? 0) + w.end;
+      if (time >= start - 1e-9 && time <= end + 1e-9) {
+        blending.add(w.from);
+        blending.add(w.to);
+      }
+    }
     comp.layers().forEach(({ seq, display, threeD }, i) => {
       const t = seq.target;
       const name = seq.spec.name;
@@ -947,10 +1168,23 @@ function inspectScene(root, frame, time, canvas, opts = {}) {
         onCanvas = inter === 0 && area > 0 ? "none" : inter >= area - 1e-6 ? "full" : "partial";
         if (area === 0) onCanvas = "none";
       }
-      const keys = chunkSIRVULFF_cjs.collectPropKeys(seq.spec);
-      const moving = (seq.spec.keyframes ?? []).length > 0 && (keys.has("x") || keys.has("y"));
-      layers.push({ path: prefix + label, name, type: seq.spec.type, threeD, visible, alpha, moving, bounds, onCanvas });
-      if (seq instanceof chunkZL262ZRM_cjs.CompositionSequence) walk(seq, prefix + label + "/", insideThreeD || threeD, visible);
+      const keys = chunk2RR43OIN_cjs.collectPropKeys(seq.spec);
+      const moving = parentMoving || (seq.spec.keyframes ?? []).length > 0 && (keys.has("x") || keys.has("y"));
+      const scale = t?.scale;
+      const zero = parentZero || !!scale && (scale.x === 0 || scale.y === 0);
+      const info = { path: prefix + label, name, type: seq.spec.type, threeD, visible, alpha, moving, bounds, onCanvas };
+      layers.push(info);
+      let shown = bounds ? clip(bounds, view) : null;
+      const maskTarget = seq.maskSequence?.target;
+      if (shown && maskTarget && !seq.spec.maskInverted) {
+        const m = maskTarget.getBounds();
+        shown = clip(shown, { x: m.x, y: m.y, width: m.width, height: m.height });
+      }
+      seen.set(info, shown);
+      const group = parentScene ?? (name !== void 0 && blending.has(name) ? name : void 0);
+      if (group) scene.set(info, group);
+      if (zero) scaledToNothing.add(info);
+      if (seq instanceof chunk23M5QTWW_cjs.CompositionSequence) walk(seq, prefix + label + "/", insideThreeD || threeD, visible, group, moving, zero);
     });
   };
   walk(root, "", false, true);
@@ -960,8 +1194,9 @@ function inspectScene(root, frame, time, canvas, opts = {}) {
     const b = l.bounds;
     const who = `text layer "${l.path}"`;
     if (b.width < 1 || b.height < 1) {
+      if (scaledToNothing.has(l)) continue;
       issues.push(`${who} has no size (empty text, or not drawn yet)`);
-    } else if (l.moving) ; else if (l.onCanvas === "none") {
+    } else if (l.moving || scene.has(l)) ; else if (l.onCanvas === "none") {
       issues.push(`${who} is entirely outside the canvas (at ${Math.round(b.x)},${Math.round(b.y)}, ${Math.round(b.width)}\xD7${Math.round(b.height)})`);
     } else if (l.onCanvas === "partial") {
       const over = [];
@@ -974,7 +1209,10 @@ function inspectScene(root, frame, time, canvas, opts = {}) {
   }
   for (let i = 0; i < texts.length; i++) {
     for (let j = i + 1; j < texts.length; j++) {
-      const a = texts[i].bounds, b = texts[j].bounds;
+      const a = seen.get(texts[i]), b = seen.get(texts[j]);
+      if (!a || !b) continue;
+      const sa = scene.get(texts[i]), sb = scene.get(texts[j]);
+      if (sa && sb && sa !== sb) continue;
       const smaller = Math.min(a.width * a.height, b.width * b.height);
       if (smaller <= 0) continue;
       const share = intersection(a, b) / smaller;
@@ -1006,64 +1244,6 @@ function sheetLayout(n, columns, cellW, srcW, srcH, labelH) {
   return { cols, rows, cellW, cellH, width: cols * cellW, height: rows * (cellH + labelH), positions };
 }
 
-// src/core/options.ts
-function distance(a, b) {
-  const dp = Array.from({ length: a.length + 1 }, (_, i) => [i, ...Array(b.length).fill(0)]);
-  for (let j = 1; j <= b.length; j++) dp[0][j] = j;
-  for (let i = 1; i <= a.length; i++) {
-    for (let j = 1; j <= b.length; j++) {
-      dp[i][j] = Math.min(dp[i - 1][j] + 1, dp[i][j - 1] + 1, dp[i - 1][j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1));
-      if (i > 1 && j > 1 && a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1]) dp[i][j] = Math.min(dp[i][j], dp[i - 2][j - 2] + 1);
-    }
-  }
-  return dp[a.length][b.length];
-}
-var isSubsequence = (small, big) => {
-  let i = 0;
-  for (const ch of big) if (i < small.length && ch === small[i]) i++;
-  return i === small.length;
-};
-var COMMON_ALIASES = {
-  fps: "frameRate",
-  framerate: "frameRate",
-  frame_rate: "frameRate",
-  bg: "background",
-  backgroundcolor: "background",
-  bgcolor: "background",
-  seconds: "duration",
-  length: "duration",
-  time: "duration",
-  w: "width",
-  h: "height",
-  cols: "columns",
-  sweep: "degrees",
-  angle: "degrees"
-};
-function suggestName(name, valid) {
-  const n = name.toLowerCase();
-  const alias = COMMON_ALIASES[n];
-  if (alias && valid.includes(alias)) return alias;
-  let best = null;
-  for (const v of valid) {
-    const lv = v.toLowerCase();
-    const d = distance(n, lv);
-    const close = d <= Math.max(1, Math.floor(Math.min(n.length, lv.length) / 3));
-    const abbreviation = n.length >= 3 && isSubsequence(n, lv) || lv.length >= 2 && n.length > lv.length && n.includes(lv);
-    if (!close && !abbreviation) continue;
-    const score = close ? d : 3 + (lv.length - n.length) / 100;
-    if (!best || score < best.score) best = { v, score };
-  }
-  return best ? best.v : null;
-}
-function warnUnknownOptions(where, opts, valid) {
-  if (!opts || typeof opts !== "object") return;
-  for (const key of Object.keys(opts)) {
-    if (valid.includes(key)) continue;
-    const guess = suggestName(key, valid);
-    console.warn(`pixi-effects: ${where}: unknown option "${key}"${guess ? ` \u2014 did you mean "${guess}"?` : ""} (valid: ${valid.join(", ")})`);
-  }
-}
-
 // src/core/Movie.ts
 PIXI.extensions.add(PIXI.CullerPlugin);
 gsap.gsap.registerPlugin(PixiPlugin.PixiPlugin);
@@ -1090,6 +1270,9 @@ var Movie = class {
   _rootSequence = null;
   _rootContainer = null;
   _raf = null;
+  /** What went into the mix, and its peak before limiting — kept for inspectAudio(). */
+  _audioSources = [];
+  _mixStats = null;
   on(event, fn) {
     (this._events[event] ??= []).push(fn);
     if (event === "ready" && this._initState === "ready") {
@@ -1122,7 +1305,7 @@ var Movie = class {
     return this._audioContext;
   }
   async init(options = {}) {
-    warnUnknownOptions("movie.init()", options, ["width", "height", "duration", "frameRate", "background", "canvas", "assets", "composition"]);
+    chunkUQBGW5DO_cjs.warnUnknownOptions("movie.init()", options, ["width", "height", "duration", "frameRate", "background", "canvas", "assets", "composition"]);
     this._initState = "pending";
     try {
       this.width = options.width ?? 1920;
@@ -1174,7 +1357,8 @@ var Movie = class {
         duration: this.duration,
         ...userComposition
       };
-      const composition = new chunkZL262ZRM_cjs.CompositionSequence(rootSeqSpec, null, rootShape);
+      if (userComposition) carryTransitionWindows(userComposition, rootSeqSpec);
+      const composition = new chunk23M5QTWW_cjs.CompositionSequence(rootSeqSpec, null, rootShape);
       await composition.build();
       this._rootSequence = composition;
       if (composition.target) root.addChild(composition.target);
@@ -1183,7 +1367,9 @@ var Movie = class {
       composition.collectAudio(audios, 0);
       if (audios.length > 0) {
         this.audioBuffer = await mixdown(audios, this.duration, audioContext.sampleRate);
+        if (this.audioBuffer) this._mixStats = limitMix(this.audioBuffer, audios);
       }
+      this._audioSources = audios;
       this.timeline.progress(1).progress(0);
       await this._awaitVideoFrames();
       this._updateSpace();
@@ -1221,7 +1407,7 @@ var Movie = class {
     }));
   }
   async snapshot(frame = this.currentFrame, opts = {}) {
-    warnUnknownOptions("movie.snapshot()", opts, ["scale", "type", "as"]);
+    chunkUQBGW5DO_cjs.warnUnknownOptions("movie.snapshot()", opts, ["scale", "type", "as"]);
     this._requireReady("snapshot");
     await this.gotoFrame(clampFrame(frame, this.totalFrames), true);
     const scale = opts.scale ?? 1;
@@ -1232,7 +1418,7 @@ var Movie = class {
     return encodeCanvas(out, opts.type ?? "image/png", opts.as ?? "blob");
   }
   async contactSheet(opts = {}) {
-    warnUnknownOptions("movie.contactSheet()", opts, ["frames", "times", "count", "columns", "cellWidth", "as"]);
+    chunkUQBGW5DO_cjs.warnUnknownOptions("movie.contactSheet()", opts, ["frames", "times", "count", "columns", "cellWidth", "as"]);
     this._requireReady("contactSheet");
     const frames = (opts.frames ?? opts.times?.map((t) => Math.round(t * this.frameRate)) ?? pickFrames(this.totalFrames, opts.count ?? 6)).map((f) => clampFrame(f, this.totalFrames));
     const LABEL_H = 26;
@@ -1265,12 +1451,21 @@ var Movie = class {
    * the canvas, cut by an edge, empty, or overlapping other text. Seeks there and stays there.
    */
   async inspect(frame = this.currentFrame, opts = { layers: "visible" }) {
-    warnUnknownOptions("movie.inspect()", opts, ["layers"]);
+    chunkUQBGW5DO_cjs.warnUnknownOptions("movie.inspect()", opts, ["layers"]);
     this._requireReady("inspect");
     const f = clampFrame(frame, this.totalFrames);
     await this.gotoFrame(f, true);
     return inspectScene(this._rootSequence, f, f / this.frameRate, { width: this.width, height: this.height }, opts);
   }
+  /**
+   * The soundtrack, measured: when every audio layer plays, how loud the mix is over time, and `issues`
+   * (limiting, inaudible layers, sounds cut off by the end). Use it to CHECK sound you cannot hear.
+   */
+  inspectAudio(opts = {}) {
+    chunkUQBGW5DO_cjs.warnUnknownOptions("movie.inspectAudio()", opts, ["window"]);
+    this._requireReady("inspectAudio");
+    return analyzeAudio(this.audioBuffer, this._audioSources, this._mixStats, this.duration, opts);
+  }
   /**
    * Draw the stage now. PixiJS's CullerPlugin only culls inside `app.render()` (the ticker), and we render
    * by hand — while seeking and especially during `render()`, which stops the ticker — so without this the
@@ -1281,6 +1476,7 @@ var Movie = class {
   _renderNow() {
     const app = this.app;
     if (!app?.renderer) return;
+    this._rootSequence?.syncFrame();
     PIXI.Culler.shared.cull(app.stage, app.renderer.screen, false);
     app.renderer.render({ container: app.stage });
   }
@@ -1374,7 +1570,7 @@ var Movie = class {
     return this.muted;
   }
   async render(options) {
-    warnUnknownOptions("movie.render()", options, ["format", "video", "audio"]);
+    chunkUQBGW5DO_cjs.warnUnknownOptions("movie.render()", options, ["format", "video", "audio"]);
     return await exportFrames(this, options);
   }
   async destroy() {
@@ -1386,6 +1582,8 @@ var Movie = class {
     safeRun(() => this.app?.destroy(true, { children: true, texture: true }));
     this.app = null;
     this.audioBuffer = null;
+    this._audioSources = [];
+    this._mixStats = null;
     safeRun(() => this._audioContext?.close().catch(() => {
     }));
     this._audioContext = null;
@@ -1413,11 +1611,58 @@ function collectVideoSequences(seq, out) {
     collectVideoSequences(child, out);
   }
 }
+var BY = ["chars", "words", "lines"];
+var ALIGN = ["left", "center", "right"];
+var widthOf = (text, style) => PIXI.CanvasTextMetrics.measureText(text, style).width;
+function measureText(text, style = {}) {
+  const m = PIXI.CanvasTextMetrics.measureText(text, new PIXI.TextStyle(style));
+  return { width: m.width, height: m.height, lines: text.split("\n").length };
+}
+function splitText(text, style = {}, opts = {}) {
+  chunkUQBGW5DO_cjs.warnUnknownOptions("splitText()", opts, ["by", "x", "y", "align"]);
+  let by = opts.by ?? "chars";
+  if (!BY.includes(by)) {
+    const g = chunkUQBGW5DO_cjs.suggestName(String(by), BY);
+    console.warn(`pixi-effects: splitText(): by "${by}" is not one of ${BY.map((b) => `"${b}"`).join(", ")}${g ? ` \u2014 did you mean "${g}"?` : ""}; using "chars"`);
+    by = "chars";
+  }
+  let align = opts.align ?? "left";
+  if (!ALIGN.includes(align)) {
+    const g = chunkUQBGW5DO_cjs.suggestName(String(align), ALIGN);
+    console.warn(`pixi-effects: splitText(): align "${align}" is not one of ${ALIGN.join(", ")}${g ? ` \u2014 did you mean "${g}"?` : ""}; using "left"`);
+    align = "left";
+  }
+  const x0 = opts.x ?? 0, y0 = opts.y ?? 0;
+  if (text === "") return [];
+  const ts = new PIXI.TextStyle(style);
+  const lineHeight = PIXI.CanvasTextMetrics.measureText("M", ts).lineHeight ?? PIXI.CanvasTextMetrics.measureText("M", ts).height;
+  const sentinel = widthOf("|", ts);
+  const out = [];
+  text.split("\n").forEach((line, lineNo) => {
+    const lineWidth = widthOf(line, ts);
+    const left = align === "center" ? x0 - lineWidth / 2 : align === "right" ? x0 - lineWidth : x0;
+    const y = y0 + lineNo * lineHeight;
+    const advance = (upTo) => upTo === 0 ? 0 : widthOf(line.slice(0, upTo) + "|", ts) - sentinel;
+    const spans = [];
+    if (by === "lines") {
+      if (line.trim() !== "") spans.push([0, line.length]);
+    } else if (by === "words") {
+      for (const m of line.matchAll(/\S+/g)) spans.push([m.index, m.index + m[0].length]);
+    } else {
+      for (let i = 0; i < line.length; i++) if (!/\s/.test(line[i])) spans.push([i, i + 1]);
+    }
+    for (const [a, b] of spans) {
+      const piece = line.slice(a, b);
+      out.push({ text: piece, x: left + advance(a), y, width: widthOf(piece, ts), index: out.length, line: lineNo });
+    }
+  });
+  return out;
+}
 
 // src/presets/kenBurns.ts
 var KEN_BURNS_KEYS = ["asset", "name", "at", "duration", "fit", "ease", "motion", "origin", "zoom", "direction", "angle", "from", "to"];
 function kenBurns(opts) {
-  warnUnknownOptions("kenBurns()", opts, KEN_BURNS_KEYS);
+  chunkUQBGW5DO_cjs.warnUnknownOptions("kenBurns()", opts, KEN_BURNS_KEYS);
   const {
     asset,
     name,
@@ -1533,7 +1778,7 @@ function parseEase(name) {
 // src/presets/orbit.ts
 var ORBIT_KEYS = ["duration", "degrees", "start", "radius", "center", "width", "height", "fov", "ease", "dollyZoom", "at", "name", "stepsPerSecond"];
 function orbit(opts) {
-  warnUnknownOptions("orbit()", opts, ORBIT_KEYS);
+  chunkUQBGW5DO_cjs.warnUnknownOptions("orbit()", opts, ORBIT_KEYS);
   const {
     duration,
     degrees,
@@ -1549,17 +1794,17 @@ function orbit(opts) {
     throw new Error("pixi-effects: orbit() cannot combine `radius` with `dollyZoom` \u2014 the radius follows the animated fov");
   }
   const [cx, cy] = opts.center ?? [width / 2, height / 2];
-  const fixedR = opts.radius ?? chunkSIRVULFF_cjs.homeDistance(height, fov ?? chunkSIRVULFF_cjs.DEFAULT_FOV);
+  const fixedR = opts.radius ?? chunk2RR43OIN_cjs.homeDistance(height, fov ?? chunk2RR43OIN_cjs.DEFAULT_FOV);
   const start = opts.start ?? -degrees / 2;
   const steps = Math.max(1, Math.round(duration * stepsPerSecond));
   const easeFn = parseEase(ease);
   const dollyEase = dolly ? parseEase(dolly.ease ?? ease) : null;
   const pos = (i) => {
     const p = i / steps;
-    const a = (start + degrees * easeFn(p)) * chunkSIRVULFF_cjs.DEG;
+    const a = (start + degrees * easeFn(p)) * chunk2RR43OIN_cjs.DEG;
     if (!dolly) return { x: cx + fixedR * Math.sin(a), z: fixedR * Math.cos(a) };
     const f = dolly.from + (dolly.to - dolly.from) * dollyEase(p);
-    const R = chunkSIRVULFF_cjs.homeDistance(height, f);
+    const R = chunk2RR43OIN_cjs.homeDistance(height, f);
     return { x: cx + R * Math.sin(a), z: R * Math.cos(a), fov: f };
   };
   const keyframes = [];
@@ -1588,7 +1833,7 @@ function orbit(opts) {
 
 // src/transforms/withFade.ts
 function withFade(spec, opts) {
-  warnUnknownOptions("withFade()", opts, ["in", "out"]);
+  chunkUQBGW5DO_cjs.warnUnknownOptions("withFade()", opts, ["in", "out"]);
   if (opts.in != null && opts.in > 0) {
     spec.initial = { ...spec.initial ?? {}, alpha: 0 };
     const kf = { at: 0, to: { alpha: 1 }, duration: opts.in };
@@ -1608,11 +1853,13 @@ function withFade(spec, opts) {
 
 Object.defineProperty(exports, "registerSequenceType", {
   enumerable: true,
-  get: function () { return chunkSIRVULFF_cjs.registerSequenceType; }
+  get: function () { return chunk2RR43OIN_cjs.registerSequenceType; }
 });
 exports.Movie = Movie;
 exports.kenBurns = kenBurns;
+exports.measureText = measureText;
 exports.orbit = orbit;
+exports.splitText = splitText;
 exports.withFade = withFade;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map