pixi-effects 0.16.3 → 0.18.0

package/dist/index.d.cts

@@ -1,4 +1,4 @@
-export { A as AudioInspectOptions, a as AudioReport, b as AudioSourceReport, C as ContactSheetOptions, F as FrameEvent, I as InspectOptions, c as InspectReport, L as LayerInfo, d as LoaderOption, M as MotionBlurOptions, e as MotionBlurSpec, f as Movie, g as MovieErrorEvent, h as MovieOptions, P as ProgressEvent, R as RenderOptions, S as SnapshotOptions, i as SoundMeasure, j as StopEvent, k as StopImage, l as StopImagesOptions, T as TimelineData, m as TimelineHtmlOptions, n as TimelineRow, o as TimelineSvgOptions, p as TimelineTransition, V as VolumeEvent, q as dismissLoader, r as failLoader, s as resolveLoader } from './Movie-oA0SUAyb.cjs';
+export { A as AudioInspectOptions, a as AudioReport, b as AudioSourceReport, C as ContactSheetOptions, F as FontReport, c as FrameEvent, I as InspectOptions, d as InspectReport, e as IssueGroup, L as LayerInfo, f as LoaderOption, M as MotionBlurOptions, g as MotionBlurSpec, h as Movie, i as MovieErrorEvent, j as MovieOptions, O as OnionSkinOptions, P as ProgressEvent, R as RenderOptions, k as ReviewOptions, l as ReviewReport, S as SnapshotOptions, m as SoundMeasure, n as StopEvent, o as StopImage, p as StopImagesOptions, T as TimelineData, q as TimelineHtmlOptions, r as TimelineRow, s as TimelineSvgOptions, t as TimelineTransition, V as VolumeEvent, u as dismissLoader, v as failLoader, w as resolveLoader } from './Movie-K2YuVAdg.cjs';
 import { S as SequenceSpec, C as CompositionShape, I as ImageSequenceSpec, a as CameraSequenceSpec, K as Keyframe, T as TextSequenceSpec, M as MusicOptions, P as Props, b as TransitionSpec, c as CompositionSpec, d as SequenceCommon } from './types-SS51lP6O.cjs';
 export { A as ArcShapeSpec, e as AssetSpec, f as AudioAssetSpec, g as AudioMusicSpec, h as AudioSequenceSpec, i as AudioSfxSpec, j as ChromaKeyFilterSpec, k as CircleShapeSpec, l as CompositionSequenceSpec, m as CrossfadeTransition, n as CustomFilterSpec, D as DipTransition, o as DissolveTransition, E as EllipseShapeSpec, p as Expr, F as FilterSpec, G as GradientSpec, q as IrisTransition, L as LineShapeSpec, r as MusicDrum, s as MusicDrums, t as MusicInstrument, u as MusicLevel, v as MusicTrack, N as NullSequenceSpec, w as PathShapeSpec, x as PolygonShapeSpec, y as PropValue, R as RectShapeSpec, z as SfxKnobs, B as SfxOptions, H as SfxPreset, J as SfxVoice, O as ShapeSequenceSpec, Q as SlideTransition, U as Stop, V as StopSpec, W as TransitionCommon, X as VideoSequenceSpec, Y as WipeTransition, Z as ZoomTransition, _ as normalizeStops, $ as pictureStops } from './types-SS51lP6O.cjs';
 import { S as Sequence } from './Base-OHqp8qvX.cjs';

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { A as AudioInspectOptions, a as AudioReport, b as AudioSourceReport, C as ContactSheetOptions, F as FrameEvent, I as InspectOptions, c as InspectReport, L as LayerInfo, d as LoaderOption, M as MotionBlurOptions, e as MotionBlurSpec, f as Movie, g as MovieErrorEvent, h as MovieOptions, P as ProgressEvent, R as RenderOptions, S as SnapshotOptions, i as SoundMeasure, j as StopEvent, k as StopImage, l as StopImagesOptions, T as TimelineData, m as TimelineHtmlOptions, n as TimelineRow, o as TimelineSvgOptions, p as TimelineTransition, V as VolumeEvent, q as dismissLoader, r as failLoader, s as resolveLoader } from './Movie-DilBC348.js';
+export { A as AudioInspectOptions, a as AudioReport, b as AudioSourceReport, C as ContactSheetOptions, F as FontReport, c as FrameEvent, I as InspectOptions, d as InspectReport, e as IssueGroup, L as LayerInfo, f as LoaderOption, M as MotionBlurOptions, g as MotionBlurSpec, h as Movie, i as MovieErrorEvent, j as MovieOptions, O as OnionSkinOptions, P as ProgressEvent, R as RenderOptions, k as ReviewOptions, l as ReviewReport, S as SnapshotOptions, m as SoundMeasure, n as StopEvent, o as StopImage, p as StopImagesOptions, T as TimelineData, q as TimelineHtmlOptions, r as TimelineRow, s as TimelineSvgOptions, t as TimelineTransition, V as VolumeEvent, u as dismissLoader, v as failLoader, w as resolveLoader } from './Movie-DlHQ9C02.js';
 import { S as SequenceSpec, C as CompositionShape, I as ImageSequenceSpec, a as CameraSequenceSpec, K as Keyframe, T as TextSequenceSpec, M as MusicOptions, P as Props, b as TransitionSpec, c as CompositionSpec, d as SequenceCommon } from './types-SS51lP6O.js';
 export { A as ArcShapeSpec, e as AssetSpec, f as AudioAssetSpec, g as AudioMusicSpec, h as AudioSequenceSpec, i as AudioSfxSpec, j as ChromaKeyFilterSpec, k as CircleShapeSpec, l as CompositionSequenceSpec, m as CrossfadeTransition, n as CustomFilterSpec, D as DipTransition, o as DissolveTransition, E as EllipseShapeSpec, p as Expr, F as FilterSpec, G as GradientSpec, q as IrisTransition, L as LineShapeSpec, r as MusicDrum, s as MusicDrums, t as MusicInstrument, u as MusicLevel, v as MusicTrack, N as NullSequenceSpec, w as PathShapeSpec, x as PolygonShapeSpec, y as PropValue, R as RectShapeSpec, z as SfxKnobs, B as SfxOptions, H as SfxPreset, J as SfxVoice, O as ShapeSequenceSpec, Q as SlideTransition, U as Stop, V as StopSpec, W as TransitionCommon, X as VideoSequenceSpec, Y as WipeTransition, Z as ZoomTransition, _ as normalizeStops, $ as pictureStops } from './types-SS51lP6O.js';
 import { S as Sequence } from './Base-BQUodYZK.js';

package/dist/index.js

@@ -1,6 +1,6 @@
-import { CompositionSequence } from './chunk-XTIHKODH.js';
-import { ensureFilterLibrary, homeDistance, DEFAULT_FOV, random, noise, flattenSvgPath, rand, DEG, resolveAt, collectPropKeys } from './chunk-ZNKQH356.js';
-export { noise, rand, random, registerSequenceType } from './chunk-ZNKQH356.js';
+import { CompositionSequence } from './chunk-UXDR3ZDU.js';
+import { ensureFilterLibrary, homeDistance, DEFAULT_FOV, random, noise, flattenSvgPath, rand, DEG, resolveAt, checkEase, collectPropKeys } from './chunk-SG3Y66FN.js';
+export { noise, rand, random, registerSequenceType } from './chunk-SG3Y66FN.js';
 import { warnUnknownOptions, suggestName } from './chunk-DKGG7WD4.js';
 import * as PIXI from 'pixi.js';
 import { extensions, CullerPlugin, Application, Container, Rectangle, Culler, CanvasTextMetrics, TextStyle, Assets, ExtensionType, Filter, UniformGroup, GpuProgram, GlProgram, defaultFilterVert } from 'pixi.js';
@@ -183,6 +183,118 @@ function spectralCentroid(samples, sampleRate, from = 0, to = samples.length) {
   return den > 1e-9 ? Math.round(num3 / den / 10) * 10 : 0;
 }
 
+// src/audio/loudness.ts
+var LOUDNESS_NOTES = { quietBelow: -24, loudAbove: -9, headroomDb: -1 };
+function kWeighting(fs) {
+  const f0 = 1681.974450955533, G = 3.999843853973347, Q = 0.7071752369554196;
+  const K = Math.tan(Math.PI * f0 / fs), Vh = 10 ** (G / 20), Vb = Vh ** 0.4996667741545416;
+  const a0 = 1 + K / Q + K * K;
+  const shelf = {
+    b: [(Vh + Vb * K / Q + K * K) / a0, 2 * (K * K - Vh) / a0, (Vh - Vb * K / Q + K * K) / a0],
+    a: [1, 2 * (K * K - 1) / a0, (1 - K / Q + K * K) / a0]
+  };
+  const f1 = 38.13547087602444, Q1 = 0.5003270373238773, K1 = Math.tan(Math.PI * f1 / fs), a1 = 1 + K1 / Q1 + K1 * K1;
+  const high = { b: [1, -2, 1], a: [1, 2 * (K1 * K1 - 1) / a1, (1 - K1 / Q1 + K1 * K1) / a1] };
+  return [shelf, high];
+}
+function filter(x, stages) {
+  let cur = x;
+  for (const { b, a } of stages) {
+    const out = new Float32Array(cur.length);
+    let x1 = 0, x2 = 0, y1 = 0, y2 = 0;
+    for (let i = 0; i < cur.length; i++) {
+      const xi = cur[i], y = b[0] * xi + b[1] * x1 + b[2] * x2 - a[1] * y1 - a[2] * y2;
+      x2 = x1;
+      x1 = xi;
+      y2 = y1;
+      y1 = y;
+      out[i] = y;
+    }
+    cur = out;
+  }
+  return cur;
+}
+var toDb = (x) => Math.round(200 * Math.log10(Math.max(x, 1e-6))) / 10;
+var TP_HALF = 12;
+var TP_BLOCK = 32;
+var TP_KERNELS = [0.25, 0.5, 0.75].map((p) => Float64Array.from({ length: 2 * TP_HALF }, (_, j) => {
+  const k = j - TP_HALF + 1, x = k - p, s = x === 0 ? 1 : Math.sin(Math.PI * x) / (Math.PI * x);
+  return s * (0.5 + 0.5 * Math.cos(Math.PI * x / (TP_HALF + 1)));
+}));
+var TP_GAIN = Math.max(...TP_KERNELS.map((k) => k.reduce((a, v) => a + Math.abs(v), 0)));
+function truePeak(chans) {
+  let peak = 0;
+  for (const c of chans) {
+    const n = c.length;
+    const blocks = Math.ceil(n / TP_BLOCK), blockMax = new Float32Array(blocks + 2);
+    for (let i = 0; i < n; i++) {
+      const a = Math.abs(c[i]), b = (i / TP_BLOCK | 0) + 1;
+      if (a > blockMax[b]) blockMax[b] = a;
+      if (a > peak) peak = a;
+    }
+    const padded = new Float32Array(n + 2 * TP_HALF);
+    padded.set(c, TP_HALF);
+    for (let i = 0; i < n; i++) {
+      const b = (i / TP_BLOCK | 0) + 1;
+      const local = Math.max(blockMax[b - 1], blockMax[b], blockMax[b + 1]);
+      if (local * TP_GAIN <= peak) continue;
+      for (let pi = 0; pi < 3; pi++) {
+        const k = TP_KERNELS[pi];
+        let v = 0;
+        for (let j = 0; j < 2 * TP_HALF; j++) v += padded[i + 1 + j] * k[j];
+        const a = Math.abs(v);
+        if (a > peak) peak = a;
+      }
+    }
+  }
+  return peak;
+}
+function measureLoudness(channels, sampleRate, opts = {}) {
+  let samplePeak = 0, clipped = 0;
+  for (const c of channels) for (let i = 0; i < c.length; i++) {
+    const a = Math.abs(c[i]);
+    if (a > samplePeak) samplePeak = a;
+    if (a >= 1) clipped++;
+  }
+  const stages = kWeighting(sampleRate);
+  const weighted = channels.map((c) => filter(c, stages));
+  const block = Math.round(0.4 * sampleRate), hop = Math.round(0.1 * sampleRate);
+  const energies = [];
+  for (let s = 0; s + block <= (weighted[0]?.length ?? 0); s += hop) {
+    let sum = 0;
+    for (const w of weighted) {
+      let z = 0;
+      for (let i = s; i < s + block; i++) z += w[i] * w[i];
+      sum += z / block;
+    }
+    energies.push(sum);
+  }
+  const lufs = (e) => -0.691 + 10 * Math.log10(e);
+  const absolute = energies.filter((e) => e > 0 && lufs(e) > -70);
+  let integrated = null;
+  if (absolute.length) {
+    const relative = lufs(absolute.reduce((a, b) => a + b, 0) / absolute.length) - 10;
+    const gated = absolute.filter((e) => lufs(e) > relative);
+    if (gated.length) integrated = Math.round(10 * lufs(gated.reduce((a, b) => a + b, 0) / gated.length)) / 10;
+  }
+  return { integratedLufs: integrated, truePeakDb: opts.truePeak === false ? null : toDb(truePeak(channels)), samplePeakDb: toDb(samplePeak), clippedSamples: clipped };
+}
+function findSilences(channels, sampleRate, opts = {}) {
+  const min = Math.round((opts.minLength ?? 1) * sampleRate), limit = 10 ** ((opts.thresholdDb ?? -60) / 20);
+  const n = channels[0]?.length ?? 0, out = [];
+  let start = -1;
+  const quiet = (i) => channels.every((c) => Math.abs(c[i]) < limit);
+  for (let i = 0; i <= n; i++) {
+    const q = i < n && quiet(i);
+    if (q && start < 0) start = i;
+    if (!q && start >= 0) {
+      if (i - start >= min) out.push({ from: Math.round(start / sampleRate * 1e3) / 1e3, to: Math.round(i / sampleRate * 1e3) / 1e3 });
+      start = -1;
+    }
+  }
+  return out;
+}
+
 // src/core/inspectAudio.ts
 var INAUDIBLE_DB = -50;
 var db = (x) => Math.round(10 * Math.max(-120, 20 * Math.log10(x))) / 10;
@@ -208,7 +320,19 @@ function measure(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 })'] };
+    return {
+      duration: movieDuration,
+      sampleRate: 0,
+      peakDb: -120,
+      peakAt: 0,
+      sources: [],
+      windows: [],
+      loudness: { integratedLufs: null, truePeakDb: -120, clippedSamples: 0, silences: [] },
+      scenes: [],
+      cues: [],
+      notes: [],
+      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));
@@ -266,6 +390,24 @@ function analyzeAudio(mix, sources, stats, movieDuration, opts = {}) {
     }
     return { layer, source, start: s.start, end: s.end, peakDb, sound };
   });
+  const whole = measureLoudness(chans, sr);
+  const silences = findSilences(chans, sr, { minLength: 1 });
+  if (whole.clippedSamples > 0) issues.push(`${whole.clippedSamples} sample(s) of the mix are at full scale (clipped) \u2014 lower the volume of the layers that play loudest`);
+  if (whole.truePeakDb > 0) issues.push(`the mix's true peak is ${whole.truePeakDb} dBTP: it will distort when the video is encoded \u2014 lower the volume`);
+  const notes = [];
+  if (whole.integratedLufs !== null) {
+    if (whole.integratedLufs < LOUDNESS_NOTES.quietBelow) notes.push(`the mix is quiet for web video: ${whole.integratedLufs} LUFS (typical \u221214 to \u221216); raise the volume if that is not on purpose`);
+    else if (whole.integratedLufs > LOUDNESS_NOTES.loudAbove) notes.push(`the mix is loud: ${whole.integratedLufs} LUFS (typical web video \u221214 to \u221216)`);
+  }
+  if (whole.truePeakDb > LOUDNESS_NOTES.headroomDb && whole.truePeakDb <= 0) notes.push(`the true peak is ${whole.truePeakDb} dBTP: little headroom left for encoding (keep it below ${LOUDNESS_NOTES.headroomDb} dBTP)`);
+  for (const q of silences.slice(0, 3)) notes.push(`the mix is silent from ${q.from} s to ${q.to} s (${Math.round((q.to - q.from) * 10) / 10} s)`);
+  if (silences.length > 3) notes.push(`and ${silences.length - 3} more silent stretch(es) (loudness.silences lists them all)`);
+  const sceneList = (opts.scenes && opts.scenes.length ? opts.scenes : [{ name: "movie", start: 0, end: movieDuration }]).map((sc) => {
+    const a = Math.max(0, Math.round(sc.start * sr)), b = Math.min(mix.length, Math.round(sc.end * sr));
+    const part = chans.map((c) => c.subarray(a, Math.max(a, b)));
+    const m = measureLoudness(part, sr, { truePeak: false });
+    return { name: sc.name, from: sc.start, to: sc.end, lufs: m.integratedLufs, peakDb: m.samplePeakDb, silent: m.samplePeakDb < -60 };
+  });
   return {
     duration: movieDuration,
     sampleRate: sr,
@@ -273,8 +415,158 @@ function analyzeAudio(mix, sources, stats, movieDuration, opts = {}) {
     peakAt: stats?.peakAt ?? 0,
     sources: list,
     windows: windows2,
-    issues
+    issues,
+    loudness: { integratedLufs: whole.integratedLufs, truePeakDb: whole.truePeakDb ?? -120, clippedSamples: whole.clippedSamples, silences },
+    scenes: sceneList,
+    cues: list.map((s) => ({ t: s.start, name: `${s.layer} (${s.source})` })),
+    notes
+  };
+}
+
+// src/text/fonts.ts
+var GENERIC = /* @__PURE__ */ new Set(["serif", "sans-serif", "monospace", "cursive", "fantasy", "system-ui", "ui-serif", "ui-sans-serif", "ui-monospace", "ui-rounded", "emoji", "math", "fangsong", "-apple-system", "blinkmacsystemfont"]);
+function fontAvailable(family2) {
+  const f = family2.trim().replace(/^["']|["']$/g, "");
+  if (!f || GENERIC.has(f.toLowerCase())) return true;
+  const g = document.createElement("canvas").getContext("2d");
+  if (!g) return true;
+  const sample = "mmmmmmmmmmlliWWWW 0123 \u3042\u3044\u3046";
+  const width = (stack) => {
+    g.font = `72px ${stack}`;
+    return g.measureText(sample).width;
   };
+  const q = JSON.stringify(f);
+  return width(`${q}, monospace`) !== width("monospace") || width(`${q}, serif`) !== width("serif");
+}
+
+// src/core/inspectFonts.ts
+function inspectFonts(root) {
+  const failed = /* @__PURE__ */ new Set();
+  if (typeof document !== "undefined" && document.fonts) document.fonts.forEach((face) => {
+    if (face.status === "error") failed.add(face.family.replace(/^["']|["']$/g, ""));
+  });
+  const missing = [];
+  const used = /* @__PURE__ */ new Set();
+  const walk2 = (seq, index) => {
+    const spec = seq.spec;
+    if (spec.type === "text") {
+      const raw = spec.style?.fontFamily;
+      const family2 = Array.isArray(raw) ? raw.join(", ") : typeof raw === "string" ? raw : "";
+      const list = family2.split(",").map((f) => f.trim()).filter(Boolean);
+      for (const f of list) used.add(f.replace(/^["']|["']$/g, "").toLowerCase());
+      if (list.length && !list.some(fontAvailable) && !list.some((f) => failed.has(f.replace(/^["']|["']$/g, "")))) missing.push({ layer: spec.name ?? `text#${index}`, family: family2 });
+    }
+    if (seq.maskSequence) walk2(seq.maskSequence, index);
+    (seq._children ?? []).forEach((child, i) => walk2(child, i));
+  };
+  walk2(root, 0);
+  const all = [...failed];
+  return { missing, failed: all.filter((f) => used.has(f.toLowerCase())), failedUnused: all.filter((f) => !used.has(f.toLowerCase())) };
+}
+
+// src/core/scenes.ts
+function namedScenes(rows) {
+  return rows.filter((r) => r.depth === 0 && r.type === "composition" && !/[#×]/.test(r.name) && r.end - r.start >= 1).map((r) => ({ name: r.name, start: r.start, end: r.end }));
+}
+
+// src/core/review.ts
+function sampleFrames({ totalFrames, frameRate, scenes = [], step = 0.25, cap = 240 }) {
+  const last = totalFrames;
+  const clamp2 = (f) => Math.max(0, Math.min(last, Math.round(f)));
+  const edges = /* @__PURE__ */ new Set([0, last]);
+  for (const s of scenes) {
+    edges.add(clamp2(s.start * frameRate));
+    edges.add(clamp2(s.end * frameRate - 1));
+  }
+  const room = Math.max(0, cap - edges.size);
+  const seconds = totalFrames / frameRate;
+  const wanted = Math.floor(seconds / step) + 1;
+  const stride = wanted <= room ? step : seconds / Math.max(1, room);
+  const frames = new Set(edges);
+  for (let t = stride; frames.size < cap && t < seconds; t += stride) frames.add(clamp2(t * frameRate));
+  return [...frames].sort((a, b) => a - b);
+}
+var AT_HELP = "use seconds (3.5), a percentage (50%), a frame (f120) or a layer's start / mid / end (name@end)";
+function resolveAtList(list, ctx) {
+  const { frameRate: fps, totalFrames, duration, rows } = ctx;
+  const out = [], used = /* @__PURE__ */ new Set();
+  const named = rows.flatMap((r) => r.parts && r.partNames ? r.partNames.map((name, i) => ({ name, start: r.parts[i].start, end: r.parts[i].end })) : [r]);
+  for (const raw of String(list).split(",").map((s) => s.trim()).filter(Boolean)) {
+    let frame, label, m;
+    if (m = raw.match(/^(.+)@(start|mid|end)$/)) {
+      const row = named.find((r) => r.name === m[1]);
+      if (!row) throw new Error(`--at "${raw}": no layer named "${m[1]}" (names: ${named.slice(0, 40).map((r) => r.name).join(", ")}${named.length > 40 ? ", \u2026" : ""})`);
+      const t = m[2] === "start" ? row.start : m[2] === "mid" ? (row.start + row.end) / 2 : row.end - 1 / fps;
+      frame = Math.round(t * fps);
+      label = `${m[1]}-${m[2]}`;
+    } else if (m = raw.match(/^(\d+(?:\.\d+)?)%$/)) {
+      frame = Math.round(Number(m[1]) / 100 * totalFrames);
+      label = `${m[1]}pct`;
+    } else if (m = raw.match(/^f(\d+)$/i)) {
+      frame = Number(m[1]);
+      label = `f${m[1]}`;
+    } else if (/^\d+(\.\d+)?$/.test(raw)) {
+      frame = Math.round(Number(raw) * fps);
+      label = `${Number(raw).toFixed(2)}s`;
+    } else throw new Error(`--at: cannot read "${raw}": ${AT_HELP}`);
+    if (frame > totalFrames || frame < 0) throw new Error(`--at "${raw}" is past the end: the movie is ${duration} s (${totalFrames} frames)`);
+    label = label.replace(/[\\/:*?"<>|]+/g, "-");
+    let unique = label, n = 2;
+    while (used.has(unique)) unique = `${label}-${n++}`;
+    used.add(unique);
+    out.push({ label: unique, frame });
+  }
+  return out;
+}
+function groupIssues(perFrame) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const { frame, issues } of perFrame) {
+    for (const message of issues) {
+      const key = message.replace(/-?\d+(\.\d+)?/g, "#");
+      const g = groups.get(key);
+      if (g) {
+        g.count++;
+        g.lastFrame = frame;
+      } else groups.set(key, { message, count: 1, firstFrame: frame, lastFrame: frame });
+    }
+  }
+  return [...groups.values()];
+}
+function splitIssues(groups, strict = false) {
+  if (strict) return { problems: groups, review: [] };
+  const overlap = (g) => /\boverlap\b/.test(g.message);
+  return { problems: groups.filter((g) => !overlap(g)), review: groups.filter(overlap) };
+}
+async function reviewMovie(movie, opts = {}) {
+  const rows = movie.timelineData().rows;
+  const at = opts.at ? resolveAtList(opts.at, { frameRate: movie.frameRate, totalFrames: movie.totalFrames, duration: movie.duration, rows }) : [];
+  const frames = sampleFrames({ totalFrames: movie.totalFrames, frameRate: movie.frameRate, scenes: namedScenes(rows) });
+  const perFrame = [];
+  for (const frame of frames) {
+    const r = await movie.inspect(frame, { layers: "none" });
+    if (r.issues.length) perFrame.push({ frame, issues: r.issues });
+  }
+  const grouped = splitIssues(groupIssues(perFrame), !!opts.strict);
+  const fonts = movie.inspectFonts();
+  for (const f of fonts.failedUnused) grouped.review.push({ message: `web font "${f}" failed to load, but no text layer uses it (a broken or unused @font-face)`, count: 1, firstFrame: 0, lastFrame: 0 });
+  for (const m of fonts.missing) {
+    (opts.strict ? grouped.problems : grouped.review).push({ message: `layer "${m.layer}": none of the fonts "${m.family}" is available here (it is drawn in a fallback font)`, count: 1, firstFrame: 0, lastFrame: 0 });
+  }
+  return { frames: frames.length, problems: grouped.problems, review: grouped.review, fonts, audio: movie.audioBuffer ? movie.inspectAudio() : null, at };
+}
+
+// src/core/onion.ts
+function onionTimes(from, to, count) {
+  if (count <= 1) return [from];
+  return Array.from({ length: count }, (_, i) => Math.round((from + (to - from) * i / (count - 1)) * 1e6) / 1e6);
+}
+function onionAlphas(count, ramp = 0.25) {
+  const weights = Array.from({ length: count }, (_, i) => count === 1 ? 1 : ramp + (1 - ramp) * (i / (count - 1)));
+  let sum = 0;
+  return weights.map((w) => {
+    sum += w;
+    return w / sum;
+  });
 }
 
 // src/core/motionBlur.ts
@@ -293,6 +585,57 @@ function blurTimes(frame, frameRate, mb, duration) {
   return Array.from({ length: mb.samples }, (_, k) => Math.min(Math.max(t + ((k + 0.5) / mb.samples - 0.5) * width, 0), duration));
 }
 
+// src/core/renderRange.ts
+function resolveRange(range2, ctx) {
+  const { frameRate: fps, totalFrames, duration } = ctx;
+  if (range2 === void 0) return { fromFrame: 0, toFrame: totalFrames, fromSec: 0, toSec: duration, partial: false };
+  let from, to;
+  if (typeof range2 === "string") {
+    const rows = (ctx.rows ?? []).filter((r) => r.depth === 0).flatMap((r) => r.parts && r.partNames ? r.partNames.map((name, i) => ({ name, start: r.parts[i].start, end: r.parts[i].end })) : [r]);
+    const row = rows.find((r) => r.name === range2);
+    if (!row) throw new Error(`pixi-effects: render({ range: "${range2}" }): no layer named "${range2}" at the top level (names: ${rows.slice(0, 40).map((r) => r.name).join(", ") || "none"}${rows.length > 40 ? ", \u2026" : ""})`);
+    from = row.start;
+    to = row.end;
+  } else {
+    if (!Array.isArray(range2) || range2.length !== 2 || !range2.every((n) => typeof n === "number" && Number.isFinite(n))) {
+      throw new Error("pixi-effects: render({ range }) must be [from, to] in seconds (numbers) or the name of a top-level layer");
+    }
+    [from, to] = range2;
+  }
+  if (from < 0 || to <= from) throw new Error(`pixi-effects: render({ range: [${from}, ${to}] }): a range must start before it ends (from >= 0, from < to)`);
+  if (to > duration + 0.5 / fps) throw new Error(`pixi-effects: render({ range: [${from}, ${to}] }) goes past the end: the movie is ${duration} s long`);
+  const fromFrame = Math.round(from * fps);
+  const toFrame = Math.min(Math.round(to * fps), totalFrames);
+  if (toFrame <= fromFrame) throw new Error(`pixi-effects: render({ range: [${from}, ${to}] }) is shorter than one frame (${(1 / fps).toFixed(4)} s at ${fps} fps)`);
+  const partial = fromFrame > 0 || toFrame < totalFrames;
+  return { fromFrame, toFrame, fromSec: fromFrame / fps, toSec: toFrame / fps, partial };
+}
+function sliceChannels(channels, sampleRate, fromSec, toSec, opts = {}) {
+  const fade = Math.max(0, Math.round((opts.fade ?? 0.01) * sampleRate));
+  const from = Math.round(fromSec * sampleRate), len = Math.max(1, Math.round(toSec * sampleRate) - from);
+  return channels.map((src) => {
+    const out = new Float32Array(len);
+    for (let i = 0; i < len; i++) {
+      const j = from + i;
+      if (j >= 0 && j < src.length) out[i] = src[j];
+    }
+    const f = Math.min(fade, len >> 1);
+    if (opts.fadeIn !== false) for (let i = 0; i < f; i++) out[i] = out[i] * (i / f);
+    if (opts.fadeOut !== false) for (let i = 0; i < f; i++) out[len - 1 - i] = out[len - 1 - i] * (i / f);
+    return out;
+  });
+}
+function resolveRenderOptions(o) {
+  const draft = !!o.draft;
+  const scale = o.scale ?? (draft ? 0.5 : 1);
+  if (!(typeof scale === "number" && scale > 0 && scale <= 1)) throw new Error(`pixi-effects: render({ scale }): scale must be above 0 and at most 1 (got ${scale})`);
+  return {
+    scale,
+    bitrate: o.video?.bitrate ?? (draft ? "low" : void 0),
+    motionBlur: o.motionBlur !== void 0 ? o.motionBlur : draft ? false : void 0
+  };
+}
+
 // src/core/Renderer.ts
 var VIDEO_CODEC_BY_FORMAT = {
   mp4: "avc",
@@ -347,13 +690,22 @@ function makeOutputFormat(name) {
       return new MkvOutputFormat();
   }
 }
+function sliceAudio(buffer, fromSec, toSec, fadeIn, fadeOut) {
+  const channels = Array.from({ length: buffer.numberOfChannels }, (_, c) => buffer.getChannelData(c));
+  const cut = sliceChannels(channels, buffer.sampleRate, fromSec, toSec, { fadeIn, fadeOut });
+  const out = new AudioBuffer({ length: cut[0].length, numberOfChannels: cut.length, sampleRate: buffer.sampleRate });
+  cut.forEach((data, c) => out.copyToChannel(data, c));
+  return out;
+}
 async function exportFrames(movie, options = {}) {
   const fmt = options.format ?? "mp4";
+  const eff = resolveRenderOptions(options);
+  const range2 = resolveRange(options.range, { frameRate: movie.frameRate, totalFrames: movie.totalFrames, duration: movie.duration, rows: typeof options.range === "string" ? movie.timelineData().rows : void 0 });
   const opts = {
     format: fmt,
     video: {
       codec: options.video?.codec ?? VIDEO_CODEC_BY_FORMAT[fmt],
-      bitrate: qualityMap[options.video?.bitrate ?? "high"] ?? QUALITY_HIGH
+      bitrate: qualityMap[eff.bitrate ?? "high"] ?? QUALITY_HIGH
     },
     audio: {
       codec: options.audio?.codec ?? AUDIO_CODEC_BY_FORMAT[fmt],
@@ -361,27 +713,30 @@ async function exportFrames(movie, options = {}) {
     }
   };
   const container = makeOutputFormat(opts.format);
-  if (movie.audioBuffer) opts.audio.codec = await chooseAudioCodec(fmt, options.audio?.codec, container, movie.audioBuffer, opts.audio.bitrate);
+  const audio = movie.audioBuffer && range2.partial ? sliceAudio(movie.audioBuffer, range2.fromSec, range2.toSec, range2.fromFrame > 0, range2.toFrame < movie.totalFrames) : movie.audioBuffer;
+  if (audio) opts.audio.codec = await chooseAudioCodec(fmt, options.audio?.codec, container, audio, opts.audio.bitrate);
   const output = new Output({
     format: container,
     target: new BufferTarget()
   });
-  const mb = options.motionBlur !== void 0 ? resolveMotionBlur(options.motionBlur, "movie.render()") : movie.motionBlur ?? null;
+  const mb = eff.motionBlur !== void 0 ? resolveMotionBlur(eff.motionBlur, "movie.render()") : movie.motionBlur ?? null;
   const stage = movie.app.canvas;
   const blurCanvas = mb ? Object.assign(document.createElement("canvas"), { width: stage.width, height: stage.height }) : null;
-  const canvasSource = new CanvasSource(blurCanvas ?? stage, {
+  const small = eff.scale < 1 ? Object.assign(document.createElement("canvas"), { width: Math.max(2, Math.round(stage.width * eff.scale / 2) * 2), height: Math.max(2, Math.round(stage.height * eff.scale / 2) * 2) }) : null;
+  const smallCtx = small?.getContext("2d") ?? null;
+  const canvasSource = new CanvasSource(small ?? blurCanvas ?? stage, {
     codec: opts.video.codec,
     bitrate: opts.video.bitrate
   });
   output.addVideoTrack(canvasSource, { frameRate: movie.frameRate });
-  if (movie.audioBuffer) {
+  if (audio) {
     const audioSource = new AudioBufferSource({
       codec: opts.audio.codec,
       bitrate: opts.audio.bitrate
-    }, { startTimestamp: opts.audio.codec === "aac" ? -2112 / movie.audioBuffer.sampleRate : 0 });
+    }, { startTimestamp: opts.audio.codec === "aac" ? -2112 / audio.sampleRate : 0 });
     output.addAudioTrack(audioSource);
     await output.start();
-    await audioSource.add(movie.audioBuffer);
+    await audioSource.add(audio);
     await audioSource.close();
   } else {
     await output.start();
@@ -389,18 +744,21 @@ async function exportFrames(movie, options = {}) {
   movie.app.ticker.stop();
   const keyframeIntervalFrames = Math.max(1, Math.round(2 * movie.frameRate));
   try {
-    for (let frame = 0; frame <= movie.totalFrames; frame++) {
+    const count = Math.max(1, range2.toFrame - range2.fromFrame);
+    for (let frame = range2.fromFrame; frame <= range2.toFrame; frame++) {
       if (mb && blurCanvas) await movie._exposeFrame(frame, mb, blurCanvas, false);
       else await movie.gotoFrame(frame, true);
-      const isKey = frame === 0 || frame % keyframeIntervalFrames === 0;
+      if (small && smallCtx) smallCtx.drawImage(blurCanvas ?? stage, 0, 0, small.width, small.height);
+      const rel = frame - range2.fromFrame;
+      const isKey = rel === 0 || rel % keyframeIntervalFrames === 0;
       const addOpts = isKey ? { keyFrame: true } : void 0;
-      await canvasSource.add(frame / movie.frameRate, 1 / movie.frameRate, addOpts);
-      const progress = Math.floor(frame / movie.totalFrames * 100);
+      await canvasSource.add(rel / movie.frameRate, 1 / movie.frameRate, addOpts);
+      const progress = Math.floor(rel / count * 100);
       movie.emit("progress", { progress, frame, totalFrames: movie.totalFrames });
     }
     await canvasSource.close();
     await output.finalize();
-    if (mb) await movie.gotoFrame(movie.totalFrames, true);
+    if (mb) await movie.gotoFrame(range2.toFrame, true);
     return new Blob([output.target.buffer], { type: output.format.mimeType });
   } finally {
     movie.app.ticker.start();
@@ -1316,7 +1674,8 @@ function groupFamilies(entries) {
         start: Math.min(...members.map((x) => x.start)),
         end: Math.max(...members.map((x) => x.end)),
         keys: members.flatMap((x) => x.keys).sort((a, b) => a - b).slice(0, MAX_KEYS),
-        parts: members.map((x) => ({ start: x.start, end: x.end }))
+        parts: members.map((x) => ({ start: x.start, end: x.end })),
+        partNames: members.map((x) => x.name)
       });
     } else {
       out.push(e.row, ...e.inner);
@@ -2039,6 +2398,37 @@ var Movie = class {
     })));
     return new Blob([buildPdf(pages, { title: opts.title })], { type: "application/pdf" });
   }
+  async onionSkin(opts = {}) {
+    warnUnknownOptions("movie.onionSkin()", opts, ["from", "to", "count", "scale", "as", "motionBlur"]);
+    this._requireReady("onionSkin");
+    const from = opts.from ?? 0, to = opts.to ?? this.duration, count = opts.count ?? 8, scale = opts.scale ?? 1;
+    if (!(Number.isInteger(count) && count >= 1 && count <= 64)) throw new Error(`pixi-effects: movie.onionSkin(): count must be a whole number from 1 to 64, got ${count}`);
+    if (!(from >= 0 && to <= this.duration + 1e-9 && (count === 1 || from < to))) throw new Error(`pixi-effects: movie.onionSkin(): from must be before to, inside the movie (0 to ${this.duration} s), got ${from} to ${to}`);
+    if (!(scale > 0 && scale <= 4)) throw new Error(`pixi-effects: movie.onionSkin(): scale must be above 0 and at most 4, got ${scale}`);
+    const mb = this._blurFor(opts.motionBlur, "movie.onionSkin()");
+    const blurred = mb ? this._blurCanvas() : null;
+    const out = document.createElement("canvas");
+    out.width = Math.max(1, Math.round(this.width * scale));
+    out.height = Math.max(1, Math.round(this.height * scale));
+    const g = out.getContext("2d");
+    const alphas = onionAlphas(count);
+    const frames = onionTimes(from, to, count).map((t) => clampFrame(t * this.frameRate, this.totalFrames));
+    const back = this.currentFrame, wasAtPoster = this._atPoster;
+    try {
+      for (let i = 0; i < frames.length; i++) {
+        const f = frames[i];
+        if (mb && blurred) await this._quietly(() => this._exposeFrame(f, mb, blurred, true));
+        else await this._quietly(() => this.gotoFrame(f, true));
+        g.globalAlpha = alphas[i];
+        g.drawImage(blurred ?? this.app.canvas, 0, 0, out.width, out.height);
+      }
+    } finally {
+      g.globalAlpha = 1;
+      if (wasAtPoster) await this._showPoster();
+      else await this._quietly(() => this.gotoFrame(back, true));
+    }
+    return encodeCanvas(out, "image/png", opts.as ?? "blob");
+  }
   async contactSheet(opts = {}) {
     warnUnknownOptions("movie.contactSheet()", opts, ["frames", "times", "count", "columns", "cellWidth", "as", "motionBlur"]);
     this._requireReady("contactSheet");
@@ -2105,10 +2495,40 @@ var Movie = class {
    * 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.
    */
+  /** The pictures to look at for moments such as `3.5`, `50%`, `f120`, `title@end` (comma-separated). A mistake says what could not be read. */
+  resolveAt(list) {
+    this._requireReady("resolveAt");
+    return resolveAtList(list, { frameRate: this.frameRate, totalFrames: this.totalFrames, duration: this.duration, rows: this.timelineData().rows });
+  }
+  /**
+   * One call that looks at everything `pixi-effects-check` looks at inside the page: layout issues over the whole timeline (every
+   * scene's first and last frame and a frame every 0.25 s), fonts and the sound. See `ReviewReport`. Page warnings are in `window.__logs`. The movie is left as it was.
+   */
+  async review(opts = {}) {
+    warnUnknownOptions("movie.review()", opts, ["at", "strict"]);
+    this._requireReady("review");
+    const back = this.currentFrame, wasAtPoster = this._atPoster;
+    try {
+      return await reviewMovie(this, opts);
+    } finally {
+      this.currentFrame = back;
+      if (wasAtPoster) await this._showPoster();
+      else await this._quietly(() => this.gotoFrame(back, true));
+    }
+  }
+  /**
+   * The fonts of the text layers: `missing` lists layers none of whose `fontFamily` entries is available in this browser (they are
+   * drawn in a fallback font), `failed` lists web fonts (`@font-face`) whose file could not be loaded.
+   */
+  inspectFonts() {
+    this._requireReady("inspectFonts");
+    return inspectFonts(this._rootSequence);
+  }
   inspectAudio(opts = {}) {
-    warnUnknownOptions("movie.inspectAudio()", opts, ["window"]);
+    warnUnknownOptions("movie.inspectAudio()", opts, ["window", "scenes"]);
     this._requireReady("inspectAudio");
-    return analyzeAudio(this.audioBuffer, this._audioSources, this._mixStats, this.duration, opts);
+    const scenes = opts.scenes ?? namedScenes(this.timelineData().rows);
+    return analyzeAudio(this.audioBuffer, this._audioSources, this._mixStats, this.duration, { ...opts, scenes });
   }
   /**
    * Draw the stage now. PixiJS's CullerPlugin only culls inside `app.render()` (the ticker), and we render
@@ -2376,7 +2796,7 @@ var Movie = class {
     return this.muted;
   }
   async render(options) {
-    warnUnknownOptions("movie.render()", options, ["format", "video", "audio", "motionBlur"]);
+    warnUnknownOptions("movie.render()", options, ["format", "video", "audio", "motionBlur", "range", "scale", "draft"]);
     try {
       return await this._quietly(() => exportFrames(this, options));
     } catch (err) {
@@ -2587,6 +3007,7 @@ function clamp(v, lo, hi) {
   return Math.max(lo, Math.min(hi, v));
 }
 function parseEase(name) {
+  checkEase(name, "a preset");
   return gsap.parseEase(name);
 }