pixi-effects 0.38.1 → 0.39.0

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Changelog
 
+## 0.39.0
+
+**The tools tell the truth, and a file can be checked against what it must be**
+
+- **`probe` names the colour tags, and `--expect` can ask for them (`matrix=bt709`, `transfer=…`).** The plain report says `colour bt709 (transfer iec61966-2-1, limited range)` and `--json` has `video[].color`. The files `render()` writes carry the Rec.709 primaries and matrix, limited range and the **sRGB transfer** (`iec61966-2-1`); it was listed as a defect to change to `bt709`, and it is left: the pixels are drawn as sRGB, so that is the true tag (rewriting it would mean patching the container and the H.264 bitstream to say something less exact; editors and players read it as Rec.709 in practice). A platform that asks for Rec.709 is answered by `probe file --expect matrix=bt709`.
+- **New: `grain` has `loop: seconds`, so a clip made to loop has the same grain at its seam.** `{ type: 'grain', loop: 10 }` repeats the pattern every 10 s (the grain frame is taken modulo `loop × fps`): the frame after the last is the first again. `loop × fps` must be a whole number of grain frames (10 s at 24 fps is 240); anything else, and a `loop` that is not above 0, warns and says what to change. The library's grain had no period, so two stock-clip agents wrote their own grain inside a shader to close a loop. Tests: the grain frame at the seam, the warnings, and a living filter's `loop`.
+- **New: `check --seam` tells whether a movie made to loop closes without a jump.** In the page it takes the last frame against the first (`seam`) and nine ordinary neighbouring pairs (`steps`, the two next to the seam among them) on pictures a quarter of the size, as the mean absolute difference of the colour channels. A seam up to 1.5 times the largest ordinary step (or under 0.001) prints `seam  the loop closes: …`; more prints `seam  JUMP: … 8.1× the largest ordinary step …`, is a problem and exits 1. `report.json` has `seam: { seam, median, max, ratio, ok, frames }`. The movie is its own measure (no stored picture). Found by stock-clip agents, who measured the seam by hand with ImageMagick (`compare -metric MAE`, the last frame against the first). New export: `seamVerdict` (check.mjs); test pages `examples/_checks/seam-loop.html` and `seam-jump.html`.
+- **New: `probe file --expect "size=3840x2160 fps=30 frames=300 bitrate>=35M audio=none"` checks a file against what it must be.** One line each (`ok` / `FAIL`, the number the file has and the one wanted), `RESULT: …`, exit 1 when one fails, `--json` adds an `expect` list. The numbers are measured over every packet of the file (the new `frames`, and the bitrate of the whole file), not over the first 300 like the plain report. Words: `size width height fps frames duration bitrate video audio container`; operators `= != >= <= > <`; a misspelt word gets `did you mean`; a bad expectation is a usage error before the file is read. `docs/media.md`, the skill and `help media` carry it; the docs test now runs example commands with quoted arguments.
+- **Docs: `bitrate` is a ceiling, not a target (pitfall 119), measured.** A constant bitrate mode (`bitrateMode: 'constant'`) reaches the encoder and still writes 0.1 Mbps for a black frame with a circle (H.264, HEVC and VP9: no encoder pads), so there is no option to add: read the real rate (`render` prints it, `probe --expect` checks it) and, when a minimum is needed, raise it with what the picture really has (seeded film grain).
+- **Changed (breaking, small): an export is exactly `duration × frameRate` frames, not one more.** `render()` wrote the frames 0 … `totalFrames` inclusive, so a 10 s movie at 30 fps was 301 frames and 10.033 s while `check` said 300; the moment `duration` is now not a frame (it belongs to the next one), so the file is 300 frames and 10.000 s, a clip made to loop has no repeated frame at its seam, and the picture and the sound have the same length. A `range` is `[from, to)`: `1:2` is 30 frames at 30 fps (it was 31). The progress events count the frames, then one `100` when the file is finished; the stage is left on the last exported frame. What you may have done to get 300 frames (`duration: 10 - 1/30`) now gives 299: write the plain `duration: 10`. Seeking to the end moment (`gotoFrame(totalFrames)`) and the last-frame check are unchanged. Found by agents making stock clips, which all had to know the trick. Tests: `renderRange.test.ts` counts the packets of the real file; the Renderer unit tests and two browser tests that assumed the extra frame were rewritten (the stage's last frame, the progress events, a reversed loop's first instant).
+- **Fixed: the guide's demo pages scrolled a little inside their frame.** Every generated demo (`examples/_guide/*.html`) had `body { padding: 16px }` and a picture that sits on a text line, so each was 20 px taller than the 16:9 frame the guide gives it and could be scrolled (measured: 20 px at 880 px and at 360 px wide, in all 17 pages). The pages now fill the frame exactly (no padding, `line-height: 0`, no scrolling), and `first-video.html` (which the reader also copies) has the same CSS. Test: `tests/tools/guideDemoFit.test.ts` loads every demo at both widths and fails if one scrolls or does not fill its frame.
+- **`render` and `check` say more about the file they wrote.** `render --help` now lists every option (`--video-bitrate` and `--video-codec` were missing, so an agent could not find them). A command whose stderr is not a terminal (an agent, a script, CI) used to print no progress at all, so a render of many minutes looked hung: it now prints a line at once and one every 15 s (`rendering 40% (47 s)`; `--quiet` still prints none). The result line gives the real bitrate (`· 17.8 Mbps ·`), and when `--video-bitrate` asked for more than twice what the encoder spent (55M gave 17.8 Mbps on a mostly black picture) a note says so and to read the real rate with `probe`. `check`'s own export line gives its bitrate and says it is for looking at, not the file to deliver (`render` is). New exports: `makeProgress`, `bitrateLine` (render.mjs), `exportLine` (check.mjs).
+- **Fixed: `frames --at f1` gave frame 0 (and `f4` gave 3, `f7` gave 6 at 30 fps).** A frame number was turned into seconds and rounded DOWN to four decimals (1/30 s became 0.0333, which is before frame 1), so a third of the frames of a 30 fps file came back as the one before. A time asked for a frame (`fN`, `start`, `end`) now rounds up, so it lands on that frame (`end` was also a frame early for some lengths, such as 4.2 s at 29.97 fps); a time asked in seconds is still the instant asked for. Found by an agent measuring a loop's seam with `f0` and `f1`, which were the same picture. Tests: every frame number of 8 frame rates, and the real command on `colors.mp4`.
+- **A start of `check`, `render` and the media commands sweeps the headless Chromes that an earlier run left behind.** On 2026-10-14 264 of them (5.7 GB, up to 7 hours old) piled up in one working day from runs that were cut off (a timeout, a harness that ended) whose watchman never got to stop them; the cause was not proven, so the fix does not depend on it. Every private profile folder (`pixi-effects-*` in the temp folder) now holds `pixi-owner.pid`, the process that started the browser; the next `launchChrome` (new export `reapStaleChrome(tmp?)`) stops, by process id and without `pkill`, everything started with a profile whose owner is gone and removes the folder. A profile whose owner is alive (another tool running now), one with no owner file and any other folder are left alone; it never throws. Tests: `tests/tools/chromeReap.test.ts` (stand-in processes, mutation-checked, and a real-Chrome case).
+- **The release gate is shorter when only documents changed.** `npm run release:check` compares the tree with the last `v*` tag (`scripts/release-scope.mjs`): when every changed file is a document (the changelog, README, AGENTS, SKILL.md, `docs/*.md`, the generated llms files) or a bump of this package's own version (the old number turned into the new one, and in the manifests only the `"version"` key), it runs the unit and document tests and leaves out the real-browser ones (about 4 of the 5 minutes) and says so; anything else, a file added or deleted outside the documents, no tag, or any doubt is a full run. `--scope` says the decision and why without running anything, `--full` forces everything; the stamp that `npm publish` checks records the mode. Tested on real git repositories and with the mutations that must fail (a site file counted as a document, a dependency bump taken for a version bump, a pure reordering taken for a bump, an empty change taken for docs-only).
+- **CI had been red since 0.38.0, and it is fixed (tests only, nothing in the package).** A test of the media commands ran `frames` with a `PATH` of only node's folder: on Linux `google-chrome` is a shell script that needs `dirname`, so Chrome exited with code 127, and the test also ignored `SKIP_BROWSER_TESTS`, which CI sets. The browser parts of that test, and of the docs example runner, now run only where browser tests run, and the PATH keeps the basic system folders (the test first proves ffmpeg is not in them). The two pushes (0.38.0, 0.38.1) were made without looking at CI: the red mail came from the maintainer.
+
 ## 0.38.1
 
 **Docs, and 21 pieces leave the gallery (64 → 43)**

package/README.md

@@ -1,6 +1,6 @@
 # pixi-effects
 
-> **Status**: experimental — current release `0.38.1`. The API may still change between minor versions; see the [CHANGELOG](./CHANGELOG.md) for what each release changed.
+> **Status**: experimental — current release `0.39.0`. The API may still change between minor versions; see the [CHANGELOG](./CHANGELOG.md) for what each release changed.
 
 **[Guide →](https://yjmtmtk.github.io/pixi-effects/guide/)** · **[Gallery →](https://yjmtmtk.github.io/pixi-effects/examples/gallery/)** · 52 portfolio pieces written as plain data by AI models · **[Examples →](https://yjmtmtk.github.io/pixi-effects/examples/)** · 15 numbered examples, a music lab + an in-browser playground.
 
@@ -49,8 +49,8 @@ Drop the imports into an [importmap](https://developer.mozilla.org/docs/Web/HTML
   "imports": {
     "pixi.js":                 "https://esm.sh/pixi.js@8.22.0?bundle-deps",
     "mediabunny":              "https://esm.sh/mediabunny",
-    "pixi-effects":            "https://cdn.jsdelivr.net/npm/pixi-effects@0.38.1/dist/index.js",
-    "pixi-effects/controller": "https://cdn.jsdelivr.net/npm/pixi-effects@0.38.1/dist/Controller.js"
+    "pixi-effects":            "https://cdn.jsdelivr.net/npm/pixi-effects@0.39.0/dist/index.js",
+    "pixi-effects/controller": "https://cdn.jsdelivr.net/npm/pixi-effects@0.39.0/dist/Controller.js"
   }
 }
 </script>
@@ -61,7 +61,7 @@ Drop the imports into an [importmap](https://developer.mozilla.org/docs/Web/HTML
 </script>
 ```
 
-Load the `dist/` files **as they are** (jsDelivr's `/npm/…/dist/…`, or unpkg's `https://unpkg.com/pixi-effects@0.38.1/dist/index.js`) rather than a CDN-rebundled build such as `esm.sh/pixi-effects` or jsDelivr's `+esm`: the entries (`pixi-effects`, `…/controller`, `…/three`) share internal chunks, which only works when each file is served untouched.
+Load the `dist/` files **as they are** (jsDelivr's `/npm/…/dist/…`, or unpkg's `https://unpkg.com/pixi-effects@0.39.0/dist/index.js`) rather than a CDN-rebundled build such as `esm.sh/pixi-effects` or jsDelivr's `+esm`: the entries (`pixi-effects`, `…/controller`, `…/three`) share internal chunks, which only works when each file is served untouched.
 
 > **Using three.js?** Add two more entries (`three` and `pixi-effects/three`) to this importmap — see [Adding three.js](#adding-threejs-optional) below.
 >
@@ -77,7 +77,7 @@ Add two more entries to the importmap above: three.js itself, and the `pixi-effe
   "imports": {
     "...":                     "(everything from the importmap above)",
     "three":                   "https://esm.sh/three@0.178.0",
-    "pixi-effects/three":      "https://cdn.jsdelivr.net/npm/pixi-effects@0.38.1/dist/three.js"
+    "pixi-effects/three":      "https://cdn.jsdelivr.net/npm/pixi-effects@0.39.0/dist/three.js"
   }
 }
 </script>

package/ai/chat-template.html

@@ -59,9 +59,9 @@
     "imports": {
       "pixi.js":                 "https://cdn.jsdelivr.net/npm/pixi.js@8.22.0/dist/pixi.min.mjs",
       "mediabunny":              "https://cdn.jsdelivr.net/npm/mediabunny@1.61.3/+esm",
-      "pixi-effects":            "https://cdn.jsdelivr.net/npm/pixi-effects@0.38.1/dist/index.js",
-      "pixi-effects/controller": "https://cdn.jsdelivr.net/npm/pixi-effects@0.38.1/dist/Controller.js",
-      "pixi-effects/present":  "https://cdn.jsdelivr.net/npm/pixi-effects@0.38.1/dist/present.js"
+      "pixi-effects":            "https://cdn.jsdelivr.net/npm/pixi-effects@0.39.0/dist/index.js",
+      "pixi-effects/controller": "https://cdn.jsdelivr.net/npm/pixi-effects@0.39.0/dist/Controller.js",
+      "pixi-effects/present":  "https://cdn.jsdelivr.net/npm/pixi-effects@0.39.0/dist/present.js"
     }
   }
   </script>

package/ai/tools/check.mjs

@@ -17,6 +17,7 @@
  *          --query "a=1&b=2" (added to the page address: for a page that reads it, such as one video of a batch) ·
  *          --crop X,Y,W,H (with --at: each picture is that part of the canvas, in canvas pixels, enlarged up to 4x so a small figure can be judged) ·
  *          --onion A:B (one picture of the movement between A and B seconds, frames overlaid: onion.png) ·
+ *          --seam (a movie made to loop: the last frame to the first is compared with the steps between ordinary neighbouring frames; a jump is a problem) ·
  *          --strict (text overlaps and stops where the picture is still changing fail the check; by default they are only listed for review) · --out DIR · --frames N (contact sheet tiles, default 12) · --formats mp4,webm (default mp4) · --no-export ·
  *          --timeout SECONDS (default 240) · --root DIR (static server root; default: the nearest folder above the page with dist/) · --chrome PATH
  */
@@ -80,10 +81,10 @@ export function findChrome(env = process.env, exists = fs.existsSync, platform =
   return candidates.find(c => c && exists(c)) ?? null;
 }
 
-export const USAGE = 'usage: node ai/tools/check.mjs <page.html> [--out DIR] [--frames N] [--formats mp4,webm] [--no-export] [--draft] [--at 3.5,title@end] [--crop X,Y,W,H] [--onion 1:3] [--query a=1&b=2] [--var name=value] [--size 1920x1080,1080x1920] [--timeout S] [--root DIR] [--chrome PATH] [--strict] [--help]\n(the header of ai/tools/check.mjs explains each option)';
+export const USAGE = 'usage: node ai/tools/check.mjs <page.html> [--out DIR] [--frames N] [--formats mp4,webm] [--no-export] [--draft] [--at 3.5,title@end] [--crop X,Y,W,H] [--onion 1:3] [--seam] [--query a=1&b=2] [--var name=value] [--size 1920x1080,1080x1920] [--timeout S] [--root DIR] [--chrome PATH] [--strict] [--help]\n(the header of ai/tools/check.mjs explains each option)';
 
 export function parseArgs(argv) {
-  const o = { page: null, out: null, frames: 12, formats: ['mp4'], export: true, timeout: 240, root: null, chrome: null, strict: false, at: null, crop: null, draft: false, onion: null, query: null, vars: [], sizes: [], help: false };
+  const o = { page: null, out: null, frames: 12, formats: ['mp4'], export: true, timeout: 240, root: null, chrome: null, strict: false, at: null, crop: null, draft: false, onion: null, seam: false, query: null, vars: [], sizes: [], help: false };
   const need = (i, name) => { if (i + 1 >= argv.length) throw new Error(`${name} needs a value`); return argv[i + 1]; };
   for (let i = 0; i < argv.length; i++) {
     const a = argv[i];
@@ -103,6 +104,7 @@ export function parseArgs(argv) {
     }
     else if (a === '--var') o.vars.push(parseVar(need(i++, a)));
     else if (a === '--size') o.sizes.push(...parseSizes(need(i++, a)));
+    else if (a === '--seam') o.seam = true;
     else if (a === '--onion') {
       const m = need(i++, a).match(/^(\d+(?:\.\d+)?):(\d+(?:\.\d+)?)$/);
       if (!m || !(Number(m[1]) < Number(m[2]))) throw new Error(`--onion must look like 1:3 (seconds, from before to), got "${argv[i]}"`);
@@ -186,8 +188,50 @@ export class Cdp {
   }
 }
 
+/** The file in a private profile folder that names the process that started the browser: the next tool start can tell a profile that is still in use from one whose owner is gone. */
+export const OWNER_FILE = 'pixi-owner.pid';
+
+/**
+ * Sweep what a dead owner left: every `pixi-effects-*` folder in `tmp` whose owner file names a process that no longer exists has everything that was
+ * started with it stopped (found with `ps`, stopped by process id: no pkill, which a sandbox may refuse) and is removed. A profile whose owner is alive
+ * (another tool running right now), one with no owner file (a tool that is just starting) and any folder that is not ours are left alone.
+ * Never throws: a launch must not fail because of a cleanup. Returns `{ removed: [folders], stopped: number }`. (POSIX only; nothing to do elsewhere.)
+ */
+export function reapStaleChrome(tmp = os.tmpdir()) {
+  const result = { removed: [], stopped: 0 };
+  if (process.platform === 'win32') return result;
+  try {
+    const alive = pid => { try { process.kill(pid, 0); return true; } catch (e) { return e.code === 'EPERM'; } };
+    let stale = [];
+    for (const name of fs.readdirSync(tmp)) {
+      if (!name.startsWith('pixi-effects-')) continue;
+      const dir = path.join(tmp, name);
+      let owner;
+      try { owner = Number(fs.readFileSync(path.join(dir, OWNER_FILE), 'utf8').trim()); } catch { continue; }       // no owner file: not ours to take yet
+      if (Number.isInteger(owner) && owner > 0 && !alive(owner)) stale.push(dir);
+    }
+    if (!stale.length) return result;
+    const ps = spawnSync('ps', ['-axo', 'pid=,command='], { encoding: 'utf8', maxBuffer: 64 * 1024 * 1024 });
+    const lines = ps.status === 0 ? ps.stdout.split('\n') : [];
+    for (const dir of stale) {
+      const flag = `--user-data-dir=${dir}`;
+      for (const line of lines) {
+        const at = line.indexOf(flag);
+        if (at < 0 || (line[at + flag.length] !== undefined && line[at + flag.length] !== ' ')) continue;       // the whole folder name, not one that only starts like it
+        const pid = Number(line.trim().split(/\s+/, 1)[0]);
+        if (!Number.isInteger(pid) || pid === process.pid) continue;
+        try { process.kill(pid, 'SIGKILL'); result.stopped++; } catch { /* already gone */ }
+      }
+      try { fs.rmSync(dir, { recursive: true, force: true }); result.removed.push(dir); } catch { /* held a moment longer: the next start takes it */ }
+    }
+  } catch { /* a cleanup never stops a launch */ }
+  return result;
+}
+
 /** Start a private headless Chrome. `extraArgs`: more command-line flags (the tests use it for `--enable-features=WebMCP`). */
 export async function launchChrome(chrome, userDataDir, extraArgs = []) {
+  reapStaleChrome();                                                           // what an earlier run left behind (its owner is gone) goes first
+  try { fs.writeFileSync(path.join(userDataDir, OWNER_FILE), String(process.pid)); } catch { /* a profile that cannot be marked is simply never swept */ }
   const args = [
     '--headless=new', '--remote-debugging-port=0', `--user-data-dir=${userDataDir}`, '--no-first-run', '--no-default-browser-check',
     '--autoplay-policy=no-user-gesture-required', '--mute-audio', '--disable-audio-output', '--ignore-gpu-blocklist', '--enable-unsafe-swiftshader', '--window-size=1400,900', ...extraArgs, 'about:blank',
@@ -446,6 +490,16 @@ export async function runCheck(opts, log = console.log) {
       report.files.onion = shown(onionFile);
     }
 
+    // --seam: a movie made to loop must not jump where it starts again
+    if (opts.seam) {
+      const m = await cdp.eval(SEAM_SCRIPT);
+      if (m.error) report.problems.push(`--seam: ${m.error}`);
+      else {
+        report.seam = { ...seamVerdict(m), frames: m.frames };
+        if (!report.seam.ok) report.problems.push(`the loop jumps at its seam: the last frame to the first differs by ${report.seam.seam}, ${report.seam.ratio}× the largest ordinary step (${report.seam.max})`);
+      }
+    }
+
     // a presentation (composition.stops): one picture of every stop, in order, so the pages and steps can be read at a glance
     const stops = await cdp.eval(`(() => { const s = movie.stops || []; return s.length ? { count: s.length, pages: new Set(s.map(x => x.pageIndex)).size, items: s.map(x => ({ at: Math.round(x.at * 100) / 100, frame: x.frame, page: x.page, pageStart: x.pageStart, notes: !!x.notes, pdf: x.pdf })) } : null; })()`).catch(() => null);
     if (stops) {
@@ -564,6 +618,50 @@ export async function runCheck(opts, log = console.log) {
   }
 }
 
+/**
+ * `check --seam`: does a movie made to loop close without a jump? `seam` is how much the last frame differs from the first (mean absolute difference of the colour
+ * channels, 0 to 1), `steps` are the same number for ordinary neighbouring frames of the movie, so the movie is its own measure. A seam up to 1.5 times the largest
+ * ordinary step (or under the noise floor of 0.001) closes; more is a jump.
+ */
+export function seamVerdict({ seam, steps }) {
+  const sorted = [...steps].sort((a, b) => a - b);
+  const median = sorted.length ? sorted[sorted.length >> 1] : 0, max = sorted.length ? sorted[sorted.length - 1] : 0;
+  const ok = seam <= Math.max(max * 1.5, 0.001);
+  const ratio = max > 0 ? seam / max : (seam > 0 ? Infinity : 0);
+  const n = x => (x < 0.1 ? x.toFixed(4) : x.toFixed(3));
+  const line = ok
+    ? `  seam      the loop closes: the last frame to the first differs by ${n(seam)}, an ordinary step by ${n(median)} (largest ${n(max)})`
+    : `  seam      JUMP: the last frame to the first differs by ${n(seam)}, ${Number.isFinite(ratio) ? `${(Math.round(ratio * 10) / 10).toFixed(1)}×` : 'against nothing'} the largest ordinary step (${n(max)}): the picture jumps when the movie loops (make every motion periodic over the duration)`;
+  return { seam: Math.round(seam * 1e6) / 1e6, median: Math.round(median * 1e6) / 1e6, max: Math.round(max * 1e6) / 1e6, ratio: Number.isFinite(ratio) ? Math.round(ratio * 100) / 100 : null, ok, line };
+}
+
+/** In the page: the seam (last frame against the first) and nine ordinary steps (the first and the last of them next to the seam), on pictures a quarter of the size. */
+const SEAM_SCRIPT = `(async () => {
+  const total = movie.totalFrames;
+  if (total < 4) return { error: 'a movie of fewer than 4 frames has no loop to measure' };
+  const cache = new Map();
+  const grab = async f => { if (!cache.has(f)) cache.set(f, (await movie.snapshot(f, { as: 'imageData', scale: 0.25, motionBlur: false })).data); return cache.get(f); };
+  const mae = (a, b) => { let s = 0; for (let i = 0; i < a.length; i += 4) s += Math.abs(a[i] - b[i]) + Math.abs(a[i + 1] - b[i + 1]) + Math.abs(a[i + 2] - b[i + 2]); return s / (a.length / 4 * 3) / 255; };
+  const picks = new Set([0, total - 2]);
+  for (let k = 1; k <= 7; k++) picks.add(Math.round((total - 2) * k / 8));
+  const steps = [];
+  for (const k of [...picks].sort((a, b) => a - b)) steps.push(mae(await grab(k), await grab(k + 1)));
+  return { seam: mae(await grab(total - 1), await grab(0)), steps, frames: total };
+})()`;
+
+/**
+ * The line `check` prints for its own export. That export is made to see that the movie can be written and read back, at a low bitrate and with no way to
+ * ask for another: it is not the file to deliver (`render` is: `--video-bitrate`), and the line says so, with the real bitrate so nobody mistakes it for one.
+ */
+export function exportLine(ex) {
+  if (ex.error) return `  export    ${ex.format}: FAILED — ${ex.error}`;
+  const v = ex.video?.error ? `video: ${ex.video.error}` : `video ${ex.video.duration.toFixed(2)} s ${ex.video.width}×${ex.video.height}`;
+  const au = ex.audio ? (ex.audio.error ? `audio: ${ex.audio.error}` : `audio ${ex.audio.duration} s, peak ${ex.audio.peakDb} dBFS, rms/s [${ex.audio.rmsDbPerSecond.join(' ')}]`) : 'no audio track';
+  const seconds = ex.video && !ex.video.error ? ex.video.duration : 0;
+  const rate = seconds > 0 ? ` · ${Math.round(ex.bytes * 8 / seconds / 1e5) / 10} Mbps (for looking at; \`render\` writes the file to deliver)` : '';
+  return `  export    ${ex.format}${ex.draft ? ' (draft)' : ''} ok · ${kb(ex.bytes)}${rate} · ${v} · ${au}`;
+}
+
 function finish(report, outDir, log) {
   const reportFile = path.join(outDir, 'report.json');
   report.files.report = shown(reportFile);
@@ -626,12 +724,8 @@ function finish(report, outDir, log) {
     for (const l of formatMusic(a?.sources)) L.push(l);
     for (const n of a?.notes ?? []) L.push(`  note      ${n}`);
   }
-  for (const ex of report.exports ?? []) {
-    if (ex.error) { L.push(`  export    ${ex.format}: FAILED — ${ex.error}`); continue; }
-    const v = ex.video?.error ? `video: ${ex.video.error}` : `video ${ex.video.duration.toFixed(2)} s ${ex.video.width}×${ex.video.height}`;
-    const au = ex.audio ? (ex.audio.error ? `audio: ${ex.audio.error}` : `audio ${ex.audio.duration} s, peak ${ex.audio.peakDb} dBFS, rms/s [${ex.audio.rmsDbPerSecond.join(' ')}]`) : 'no audio track';
-    L.push(`  export    ${ex.format}${ex.draft ? ' (draft)' : ''} ok · ${kb(ex.bytes)} · ${v} · ${au}`);
-  }
+  if (report.seam) L.push(report.seam.line);
+  for (const ex of report.exports ?? []) L.push(exportLine(ex));
   L.push(`  files     ${Object.values(report.files).join('  ')}`);
   L.push(report.problems.length ? `RESULT: ${report.problems.length} PROBLEM(S)\n  - ${report.problems.join('\n  - ')}` : 'RESULT: OK — nothing to fix. Look at the contact sheet before you call it done.');
   log(L.join('\n'));

package/ai/tools/media.mjs

@@ -38,7 +38,7 @@ export const USAGE = `usage:
 
 /** How each command reads its command line: the positional words, and each option with the kind of value it takes. */
 const COMMANDS = {
-  probe:  { positional: ['file'], flags: { '--keyframes': 'bool', '--json': 'bool' } },
+  probe:  { positional: ['file'], flags: { '--keyframes': 'bool', '--expect': 'str', '--json': 'bool' } },
   trim:   { positional: ['file', 'start', 'end'], flags: { '-o': 'str', '--out': 'str', '--exact': 'bool', '--force': 'bool', '--json': 'bool', '--chrome': 'str' } },
   audio:  { positional: ['file'], flags: { '-o': 'str', '--out': 'str', '--force': 'bool', '--json': 'bool' } },
   concat: { positional: ['file', 'file'], variadic: true, flags: { '-o': 'str', '--out': 'str', '--force': 'bool', '--json': 'bool' } },
@@ -157,7 +157,7 @@ async function openInput(file) {
 }
 
 /** What is in a file: container, duration, size, one row per track, key packet times with `keyframes`, and notes about what an author would trip on. */
-export async function probeFile(file, { keyframes = false } = {}) {
+export async function probeFile(file, { keyframes = false, exact = false } = {}) {
   const { mb, input, format } = await openInput(file);
   const notes = [];
   let duration;
@@ -184,6 +184,13 @@ export async function probeFile(file, { keyframes = false } = {}) {
         first: round(first, 4), end: round(end, 6), frameGap: round(median, 6),
         stored: { width: await track.getCodedWidth(), height: await track.getCodedHeight() },
       });
+      const cs = await track.getColorSpace().catch(() => null);                                              // what the file says about its colours (a decoder reads this, not the encoder's intent)
+      if (cs && (cs.primaries || cs.transfer || cs.matrix)) video[video.length - 1].color = { primaries: cs.primaries ?? null, transfer: cs.transfer ?? null, matrix: cs.matrix ?? null, fullRange: !!cs.fullRange };
+      if (exact) {                                                                                           // every packet, not the first 300: the real frame count and the bitrate of the whole file
+        const all = await track.computePacketStats(Infinity);
+        video[video.length - 1].frames = all.packetCount;
+        video[video.length - 1].bitrateAll = Math.round(all.averageBitrate);
+      }
       if (first > 0.05) notes.push(`the video starts at ${round(first, 3)} s (its first frame is not at 0, so the sound can start before the picture; frames before ${round(first, 3)} s show the first frame)`);
       if (rotation) notes.push(`rotated ${rotation}° clockwise: stored ${await track.getCodedWidth()}×${await track.getCodedHeight()}, shown ${await track.getDisplayWidth()}×${await track.getDisplayHeight()} (frames and anything that places the picture use the shown size; whether the picture then reads upright depends on how the file was made, so look at a frame)`);
       if (fpsVaries) notes.push(`variable frame rate (the gaps between frames range from ${round(gaps[0] * 1000, 1)} to ${round(gaps[gaps.length - 1] * 1000, 1)} ms): a clip from a phone or a screen recording; cut and sample by time, not by frame number`);
@@ -209,17 +216,119 @@ const kb = (n) => (n >= 1048576 ? `${(n / 1048576).toFixed(2)} MB` : `${Math.max
 
 function probeText(r, keyframes) {
   const L = [`${r.file}`, `  ${r.container} · ${r.duration} s${r.bytes != null ? ` · ${kb(r.bytes)}` : ''}`];
-  for (const v of r.video) L.push(`  video  ${v.codec} ${v.width}×${v.height}${v.rotation ? ` shown (stored ${v.stored.width}×${v.stored.height}, turned ${v.rotation}° clockwise)` : ''} · ${v.fps}${v.fpsVaries ? ' (varies)' : ''} fps${v.bitrate ? ` · ${Math.round(v.bitrate / 1000)} kb/s` : ''}`);
+  for (const v of r.video) L.push(`  video  ${v.codec} ${v.width}×${v.height}${v.rotation ? ` shown (stored ${v.stored.width}×${v.stored.height}, turned ${v.rotation}° clockwise)` : ''} · ${v.fps}${v.fpsVaries ? ' (varies)' : ''} fps${v.bitrate ? ` · ${Math.round(v.bitrate / 1000)} kb/s` : ''}${v.color ? ` · colour ${v.color.matrix ?? '?'} (transfer ${v.color.transfer ?? '?'}, ${v.color.fullRange ? 'full' : 'limited'} range)` : ''}`);
   for (const a of r.audio) L.push(`  audio  ${a.codec} ${a.sampleRate} Hz · ${a.channels} ch${a.bitrate ? ` · ${Math.round(a.bitrate / 1000)} kb/s` : ''}`);
   if (keyframes && r.video.length) L.push(`  key packets at: ${r.keyframes.slice(0, 12).join(', ')}${r.keyframes.length > 12 ? `, … (${r.keyframes.length})` : ''} s`);
   for (const n of r.notes) L.push(`  note   ${n}`);
   return L.join('\n');
 }
 
+// ───────────────────────────── probe --expect ─────────────────────────────
+
+const EXPECT_KEYS = ['size', 'width', 'height', 'fps', 'frames', 'duration', 'bitrate', 'video', 'audio', 'container', 'matrix', 'transfer'];
+const EXPECT_NUMERIC = ['width', 'height', 'fps', 'frames', 'duration', 'bitrate'];
+
+/**
+ * `size=3840x2160 fps=30 frames=300 bitrate>=35M duration<=60s audio=none video=avc container=mp4` → [{ key, op, raw }].
+ * Words are separated by spaces or commas; the operators are = != >= <= > <; a bitrate may end in k or M, a duration in s.
+ */
+export function parseExpect(text) {
+  const items = [];
+  for (const word of String(text ?? '').split(/[\s,]+/).filter(Boolean)) {
+    const m = word.match(/^([A-Za-z]+)(>=|<=|!=|=|>|<)(.*)$/);
+    if (!m) {
+      const name = word.match(/^[A-Za-z]+/)?.[0];
+      if (name && EXPECT_KEYS.includes(name.toLowerCase())) throw new UsageError(`probe --expect: ${name}: write a comparison such as ${name}=30 or ${name}>=30 (words: ${EXPECT_KEYS.join(' ')})`);
+      throw new UsageError(`probe --expect: cannot read "${word}": write name, operator and value, for example frames=300 or bitrate>=35M (words: ${EXPECT_KEYS.join(' ')})`);
+    }
+    const key = m[1].toLowerCase(), op = m[2], raw = m[3];
+    if (!EXPECT_KEYS.includes(key)) {
+      const guess = nearest(key, EXPECT_KEYS);
+      throw new UsageError(`probe --expect: unknown "${m[1]}"${guess ? `; did you mean "${guess}"?` : ''} (words: ${EXPECT_KEYS.join(' ')})`);
+    }
+    if (!raw) throw new UsageError(`probe --expect: ${key}${op} needs a value`);
+    if (!EXPECT_NUMERIC.includes(key) && op !== '=' && op !== '!=') throw new UsageError(`probe --expect: ${key} takes only = or != (got ${op})`);
+    if (EXPECT_NUMERIC.includes(key) && !Number.isFinite(expectNumber(key, raw))) throw new UsageError(`probe --expect: ${key} wants a number${key === 'bitrate' ? ' (35M, 800k or bits a second)' : key === 'duration' ? ' of seconds (10 or 10s)' : ''}, got "${raw}"`);
+    items.push({ key, op, raw });
+  }
+  if (!items.length) throw new UsageError(`probe --expect: nothing to check: write what the file should be, for example size=3840x2160 fps=30 frames=300 (words: ${EXPECT_KEYS.join(' ')})`);
+  return items;
+}
+
+/** The number of an expectation's value: bits a second for a bitrate (k, M), seconds for a duration (an s is allowed). */
+function expectNumber(key, raw) {
+  const m = String(raw).trim().match(/^(\d+(?:\.\d+)?|\.\d+)\s*([kKmM]?)\s*(?:s)?$/);
+  if (!m) return NaN;
+  const unit = m[2].toLowerCase();
+  if (unit && key !== 'bitrate') return NaN;
+  return Number(m[1]) * (unit === 'k' ? 1e3 : unit === 'm' ? 1e6 : 1);
+}
+
+const compare = (got, op, want, tol = 0) => {
+  switch (op) {
+    case '=': return Math.abs(got - want) <= tol;
+    case '!=': return Math.abs(got - want) > tol;
+    case '>': return got > want + tol;
+    case '<': return got < want - tol;
+    case '>=': return got >= want - tol;
+    case '<=': return got <= want + tol;
+  }
+  return false;
+};
+
+/** Each expectation against the numbers of a `probeFile(file, { exact: true })` report: [{ key, op, want, got, ok, line }]. */
+export function checkExpect(report, items) {
+  const v = report.video?.[0], a = report.audio?.[0];
+  const mbps = n => `${Math.round(n / 1e5) / 10} Mbps`;
+  return items.map(({ key, op, raw }) => {
+    let got, ok, shown;
+    if (['size', 'width', 'height', 'fps', 'frames', 'duration', 'bitrate', 'video', 'matrix', 'transfer'].includes(key) && !v) {
+      got = null; ok = false; shown = 'no video';
+    } else if (key === 'size') {
+      got = `${v.width}x${v.height}`; ok = (got === raw.toLowerCase().replace('×', 'x')) === (op === '='); shown = got;
+    } else if (key === 'width' || key === 'height' || key === 'frames') {
+      got = v[key]; if (got === undefined) { ok = false; shown = 'not measured'; } else { ok = compare(got, op, expectNumber(key, raw)); shown = String(got); }
+    } else if (key === 'fps') {
+      got = v.fps; ok = compare(got, op, expectNumber(key, raw), 0.01); shown = `${got}`;
+    } else if (key === 'duration') {
+      const frame = v.frameGap || 1 / (v.fps || 30);
+      got = v.end; ok = compare(got, op, expectNumber(key, raw), frame / 2); shown = `${got} s`;
+    } else if (key === 'bitrate') {
+      got = v.bitrateAll ?? v.bitrate; ok = compare(got, op, expectNumber(key, raw)); shown = mbps(got);
+    } else if (key === 'video') {
+      got = v.codec; ok = (String(got).toLowerCase() === raw.toLowerCase()) === (op === '='); shown = String(got);
+    } else if (key === 'matrix' || key === 'transfer') {
+      got = v.color?.[key] ?? null; shown = got ?? 'not tagged'; ok = got !== null && ((String(got).toLowerCase() === raw.toLowerCase()) === (op === '='));
+    } else if (key === 'audio') {
+      const r = raw.toLowerCase();
+      got = a ? a.codec : 'none';
+      ok = (r === 'none' ? !a : r === 'any' ? !!a : !!a && String(a.codec).toLowerCase() === r) === (op === '=');
+      shown = a ? String(a.codec) : 'none';
+    } else {
+      got = String(report.container ?? '').toLowerCase(); ok = (got === raw.toLowerCase()) === (op === '='); shown = got;
+    }
+    return { key, op, want: raw, got, ok, line: `  ${ok ? 'ok  ' : 'FAIL'}  ${key.padEnd(9)} ${shown}  (wanted ${key === 'bitrate' ? bitrateWanted(op, raw) : `${op}${raw}`})` };
+  });
+}
+
+function bitrateWanted(op, raw) { const n = expectNumber('bitrate', raw); return `${op}${Math.round(n / 1e5) / 10} Mbps`; }
+
 commands.probe = async ({ file, opts }, io) => {
-  const r = await probeFile(file, { keyframes: !!opts.keyframes });
-  io.log(opts.json ? JSON.stringify(r, null, 2) : probeText(r, !!opts.keyframes));
-  return 0;
+  const items = opts.expect !== undefined ? parseExpect(opts.expect) : null;                      // a bad expectation is a usage error before any file is read
+  const r = await probeFile(file, { keyframes: !!opts.keyframes, exact: !!items });
+  const results = items ? checkExpect(r, items) : null;
+  if (results) r.expect = results.map(({ line, ...rest }) => rest);
+  if (opts.json) io.log(JSON.stringify(r, null, 2));
+  else {
+    const L = [probeText(r, !!opts.keyframes)];
+    if (results) {
+      L.push('', ...results.map(x => x.line));
+      const bad = results.filter(x => !x.ok).length;
+      L.push(bad ? `RESULT: ${bad} of ${results.length} expectations do not hold` : `RESULT: all ${results.length} expectations hold`);
+    }
+    io.log(L.join('\n'));
+  }
+  return results && results.some(x => !x.ok) ? 1 : 0;
 };
 
 const OUTPUT_FORMATS = { '.mp4': 'Mp4OutputFormat', '.m4v': 'Mp4OutputFormat', '.m4a': 'Mp4OutputFormat', '.mov': 'MovOutputFormat', '.webm': 'WebMOutputFormat', '.mkv': 'MkvOutputFormat', '.mka': 'MkvOutputFormat' };
@@ -470,6 +579,9 @@ const AT_HELP = 'use seconds (3.5), a percentage (50%), a frame (f120), start, e
  */
 export function parseTimes(list, { duration, fps, first = 0, last: lastFrame }) {
   const out = [], seen = new Set(), last = Math.max(first, lastFrame ?? duration - 1 / fps);
+  // A frame is shown from its own time until the next frame's: a time asked for a FRAME (f12, start, end) rounds UP to four decimals, never down (1/30 s as 0.0333 is
+  // before frame 1 and gives frame 0). A time asked in seconds is the instant asked for, and keeps the plain rounding.
+  const onFrame = t => Math.ceil(t * 1e4 - 1e-7) / 1e4 + 0;                  // + 0: Math.ceil(-0.00000001) is -0
   const add = (t, label) => { if (!seen.has(label)) { seen.add(label); out.push({ t, label }); } };
   const inside = (t, raw) => { if (t > duration + 1e-6) throw new Error(`${raw} s is past the end of the file (${round(duration, 3)} s)`); return Math.min(t, last > t ? t : Math.max(t, 0)); };
   for (const raw of String(list).split(',').map(x => x.trim()).filter(Boolean)) {
@@ -480,12 +592,12 @@ export function parseTimes(list, { duration, fps, first = 0, last: lastFrame })
       const n = Math.ceil(duration / step);
       if (n > MAX_FRAMES) throw new Error(`--at "${raw}": that is ${n} frames of a ${round(duration, 1)} s file, too many (at most ${MAX_FRAMES}): a larger step, or a range of times`);
       for (let k = 0; k * step < duration - 1e-6; k++) add(round(k * step, 4), `${round(k * step, 2).toFixed(2)}s`);
-    } else if (/^start$/i.test(raw)) add(round(first, 4), 'start');
-    else if (/^end$/i.test(raw)) add(round(last, 4), 'end');
+    } else if (/^start$/i.test(raw)) add(onFrame(first), 'start');
+    else if (/^end$/i.test(raw)) add(onFrame(last), 'end');
     else if ((m = raw.match(/^(\d+(?:\.\d+)?)%$/))) {
       if (Number(m[1]) > 100) throw new Error(`--at "${raw}": a percentage is 0–100`);
       add(round(Math.min(last, duration * Number(m[1]) / 100), 4), `${m[1]}pct`);
-    } else if ((m = raw.match(/^f(\d+)$/i))) add(round(inside(Number(m[1]) / fps, `frame ${m[1]} is ${round(Number(m[1]) / fps, 3)}`), 4), `f${m[1]}`);
+    } else if ((m = raw.match(/^f(\d+)$/i))) add(onFrame(inside(Number(m[1]) / fps, `frame ${m[1]} is ${round(Number(m[1]) / fps, 3)}`)), `f${m[1]}`);
     else if (/^\d+(\.\d+)?$/.test(raw)) add(round(inside(Number(raw), raw), 4), `${Number(raw).toFixed(2)}s`);
     else throw new Error(`--at: cannot read "${raw}": ${AT_HELP}`);
   }

package/ai/tools/render.mjs

@@ -44,7 +44,7 @@ export function defaultOutput(page, format) {
   return path.resolve(path.basename(page).replace(/\.[^.]+$/, '') + '.' + format);
 }
 
-export const USAGE = 'usage: node ai/tools/render.mjs <page.html> [-o out.mp4] [--format mp4|webm|mov|mkv|pdf] [--range A:B | --scene NAME] [--scale S] [--draft] [--quality very-low|low|medium|high|very-high] [--query a=1] [--var name=value] [--size 1080x1920] [--strict] [--quiet] [--timeout S] [--root DIR] [--chrome PATH]';
+export const USAGE = 'usage: node ai/tools/render.mjs <page.html> [-o out.mp4] [--format mp4|webm|mov|mkv|wav|ogg|pdf] [--range A:B | --scene NAME] [--scale S] [--draft] [--quality very-low|low|medium|high|very-high] [--video-codec avc|hevc|vp9|av1|vp8] [--video-bitrate 8M|high] [--audio-codec C] [--motion-blur SAMPLES] [--shutter FRACTION] [--all-stops] [--query a=1] [--var name=value] [--size 1080x1920] [--strict] [--quiet] [--timeout S] [--root DIR] [--chrome PATH] [--help]\n(the header of ai/tools/render.mjs explains each option)';
 
 export function parseRenderArgs(argv) {
   const o = { range: null, scene: null, scale: null, draft: false, qualityGiven: false, page: null, out: null, format: null, quality: 'high', videoCodec: null, videoBitrate: null, audioCodec: null, allStops: false, motionBlur: null, shutter: null, query: null, vars: [], size: null, strict: false, quiet: false, timeout: 900, root: null, chrome: null };
@@ -146,6 +146,34 @@ export function fileSeconds(r, opts) {
   return r.duration;
 }
 
+/**
+ * The progress of a render. A terminal gets one line that is rewritten; a command whose stderr is not a terminal (an agent, a script, CI) used to get NOTHING,
+ * so a render that took minutes (a heavy shader, a busy GPU) looked hung: it gets a line at once and then one every `every` ms. `--quiet` gets none.
+ */
+export function makeProgress({ quiet = false, isTTY = false, write, now = Date.now, every = 15000 }) {
+  if (quiet) return () => {};
+  let last = -1, start = null, lastAt = 0;
+  return p => {
+    const pct = Math.min(100, Math.round(p));
+    if (isTTY) { if (pct !== last) { last = pct; write(`\rrendering ${pct}%`); } return; }
+    const t = now();
+    if (start === null) { start = t; lastAt = t; write(`rendering ${pct}%\n`); return; }
+    if (t - lastAt >= every) { lastAt = t; write(`rendering ${pct}% (${Math.round((t - start) / 1000)} s)\n`); }
+  };
+}
+
+/** The real bitrate of a written file, and a sentence when `--video-bitrate` asked for far more than the encoder spent (55M gave 17.8 Mbps on a mostly black picture: it is not a target). */
+export function bitrateLine(bytes, seconds, asked) {
+  const mbps = seconds > 0 ? Math.round(bytes * 8 / seconds / 1e5) / 10 : null;
+  let note = '';
+  const m = typeof asked === 'string' ? asked.trim().match(/^(\d+(?:\.\d+)?)\s*([kKmM]?)$/) : null;
+  if (m && mbps !== null) {
+    const askedMbps = Number(m[1]) * ({ k: 1e3, m: 1e6 }[m[2].toLowerCase()] ?? 1) / 1e6;
+    if (askedMbps > 0 && mbps < askedMbps * 0.5) note = `asked ${asked}, got ${mbps} Mbps: the encoder used fewer bits than asked (a quiet or mostly black picture needs fewer; grain and fine detail need more). Read the real rate with probe, and ask for more if a platform needs it`;
+  }
+  return { mbps, note };
+}
+
 export async function runRender(opts, log = console.log, progress = () => {}) {
   const pagePath = path.resolve(opts.page);
   if (!fs.existsSync(pagePath)) throw new Error(`page not found: ${opts.page}`);
@@ -248,12 +276,7 @@ if (process.argv[1] && import.meta.url === pathToFileURL(fs.realpathSync(process
       console.error(USAGE);
       process.exit(2);
     }
-    let last = -1;
-    const progress = p => {
-      if (opts.quiet || !process.stderr.isTTY) return;
-      const pct = Math.min(100, Math.round(p));
-      if (pct !== last) { last = pct; process.stderr.write(`\rrendering ${pct}%`); }
-    };
+    const progress = makeProgress({ quiet: opts.quiet, isTTY: !!process.stderr.isTTY, write: s => process.stderr.write(s) });
     const r = await runRender(opts, console.log, progress);
     if (!opts.quiet && process.stderr.isTTY) process.stderr.write('\r              \r');
     for (const w of r.logs) console.error(`page: ${w.length > 300 ? w.slice(0, 297) + '…' : w}`);
@@ -261,7 +284,10 @@ if (process.argv[1] && import.meta.url === pathToFileURL(fs.realpathSync(process
       console.error(`pixi-effects render failed: ${r.problems.join('; ') || 'no file written'}`);
       process.exit(1);
     }
-    console.log(`${shown(r.file)}  ${kb(r.bytes)} · ${fileSeconds(r, opts)} s · ${SOUND_ONLY.includes(opts.format) ? 'sound only' : `${r.width}×${r.height} @ ${r.frameRate} fps`} · ${opts.format} · rendered in ${r.seconds} s`);
+    const picture = !SOUND_ONLY.includes(opts.format) && opts.format !== 'pdf';
+    const rate = picture ? bitrateLine(r.bytes, fileSeconds(r, opts), opts.videoBitrate) : { mbps: null, note: '' };
+    console.log(`${shown(r.file)}  ${kb(r.bytes)} · ${fileSeconds(r, opts)} s${rate.mbps !== null ? ` · ${rate.mbps} Mbps` : ''} · ${SOUND_ONLY.includes(opts.format) ? 'sound only' : `${r.width}×${r.height} @ ${r.frameRate} fps`} · ${opts.format} · rendered in ${r.seconds} s`);
+    if (rate.note) console.error(`note: ${rate.note}`);
     process.exit(opts.strict && r.logs.length ? 1 : 0);
   } catch (e) {
     console.error(`pixi-effects render failed: ${e.message}`);

package/dist/Composition-3MNLNT2E.cjs

@@ -0,0 +1,16 @@
+'use strict';
+
+var chunkSJFDSHBP_cjs = require('./chunk-SJFDSHBP.cjs');
+require('./chunk-HX73S7FD.cjs');
+require('./chunk-JN7JHNZR.cjs');
+require('./chunk-3SAS3ZE5.cjs');
+require('./chunk-TWZNOUM7.cjs');
+
+
+
+Object.defineProperty(exports, "CompositionSequence", {
+  enumerable: true,
+  get: function () { return chunkSJFDSHBP_cjs.CompositionSequence; }
+});
+//# sourceMappingURL=Composition-3MNLNT2E.cjs.map
+//# sourceMappingURL=Composition-3MNLNT2E.cjs.map

package/dist/{Composition-23KGIJX4.cjs.map → Composition-3MNLNT2E.cjs.map}

@@ -1 +1 @@
-{"version":3,"sources":[],"names":[],"mappings":"","file":"Composition-23KGIJX4.cjs"}
+{"version":3,"sources":[],"names":[],"mappings":"","file":"Composition-3MNLNT2E.cjs"}

package/dist/Composition-P37AD4GN.js

@@ -0,0 +1,7 @@
+export { CompositionSequence } from './chunk-UHCVO5TH.js';
+import './chunk-JCPZJJNW.js';
+import './chunk-VNP7QCJE.js';
+import './chunk-32MMNDDN.js';
+import './chunk-BXOCEZ4U.js';
+//# sourceMappingURL=Composition-P37AD4GN.js.map
+//# sourceMappingURL=Composition-P37AD4GN.js.map

package/dist/{Composition-5SQXSZNA.js.map → Composition-P37AD4GN.js.map}

@@ -1 +1 @@
-{"version":3,"sources":[],"names":[],"mappings":"","file":"Composition-5SQXSZNA.js"}
+{"version":3,"sources":[],"names":[],"mappings":"","file":"Composition-P37AD4GN.js"}

package/dist/{Spans-WJFPHMSQ.cjs → Spans-F6FBBCD3.cjs}

@@ -1,7 +1,7 @@
 'use strict';
 
-var chunkFE42PKHP_cjs = require('./chunk-FE42PKHP.cjs');
-var chunk7NXKBRT7_cjs = require('./chunk-7NXKBRT7.cjs');
+var chunkSJFDSHBP_cjs = require('./chunk-SJFDSHBP.cjs');
+var chunkHX73S7FD_cjs = require('./chunk-HX73S7FD.cjs');
 require('./chunk-JN7JHNZR.cjs');
 require('./chunk-3SAS3ZE5.cjs');
 require('./chunk-TWZNOUM7.cjs');
@@ -12,12 +12,12 @@ var strip = (props) => {
   const { visibleChars: _gone, ...rest } = props;
   return rest;
 };
-var SpansSequence = class extends chunkFE42PKHP_cjs.CompositionSequence {
+var SpansSequence = class extends chunkSJFDSHBP_cjs.CompositionSequence {
   _meta;
   _count = { value: 0, visibleChars: 0 };
   constructor(spec, parent, root) {
     super(spec, parent, root);
-    this._meta = chunk7NXKBRT7_cjs.spansMeta.get(spec);
+    this._meta = chunkHX73S7FD_cjs.spansMeta.get(spec);
   }
   /** `visibleChars` is the group's own counter, not a property to write on the container. */
   displayProps() {
@@ -33,8 +33,8 @@ var SpansSequence = class extends chunkFE42PKHP_cjs.CompositionSequence {
     if (!this._meta?.typed) return;
     const scope = this.scope();
     const first = this.spec.initial?.visibleChars;
-    this._count.visibleChars = first === void 0 ? 0 : chunk7NXKBRT7_cjs.resolveNumber(first, scope);
-    chunk7NXKBRT7_cjs.bindCounterKeyframes(timeline, this._count, "visibleChars", () => this._distribute(), this.spec.keyframes ?? [], this.duration, offset + this.at, scope);
+    this._count.visibleChars = first === void 0 ? 0 : chunkHX73S7FD_cjs.resolveNumber(first, scope);
+    chunkHX73S7FD_cjs.bindCounterKeyframes(timeline, this._count, "visibleChars", () => this._distribute(), this.spec.keyframes ?? [], this.duration, offset + this.at, scope);
     this._distribute();
   }
   /** Every piece shows its part of the first N characters of the whole text. */
@@ -43,7 +43,7 @@ var SpansSequence = class extends chunkFE42PKHP_cjs.CompositionSequence {
     const total = Math.max(0, Math.floor(this._count.visibleChars));
     let i = 0;
     for (const child of this._children) {
-      if (!(child instanceof chunk7NXKBRT7_cjs.TextSequence)) continue;
+      if (!(child instanceof chunkHX73S7FD_cjs.TextSequence)) continue;
       const p = pieces[i++];
       if (p) child.setVisibleChars(Math.min(p.length, Math.max(0, total - p.start)));
     }
@@ -51,5 +51,5 @@ var SpansSequence = class extends chunkFE42PKHP_cjs.CompositionSequence {
 };
 
 exports.SpansSequence = SpansSequence;
-//# sourceMappingURL=Spans-WJFPHMSQ.cjs.map
-//# sourceMappingURL=Spans-WJFPHMSQ.cjs.map
+//# sourceMappingURL=Spans-F6FBBCD3.cjs.map
+//# sourceMappingURL=Spans-F6FBBCD3.cjs.map