@popcraft/kit 0.31.0 → 0.32.0

package/dist/chunks/chunk-MNVIAHOR.js

@@ -0,0 +1,632 @@
+import { createRequire as __popcraftRequire } from 'node:module';
+import { fileURLToPath as __popcraftPath } from 'node:url';
+import { dirname as __popcraftDirname } from 'node:path';
+const require = __popcraftRequire(import.meta.url);
+const __filename = __popcraftPath(import.meta.url);
+const __dirname = __popcraftDirname(__filename);
+import {
+  renderFrames,
+  throwIfAborted
+} from "./chunk-URTSA2C4.js";
+import {
+  targetMix
+} from "./chunk-ZGDPBI6J.js";
+import {
+  AudioSample,
+  AudioSampleSource,
+  Mp4OutputFormat,
+  Output,
+  Quality,
+  StreamTarget,
+  VideoSample,
+  VideoSampleSource,
+  WebMOutputFormat,
+  canEncodeAudio,
+  getFirstEncodableVideoCodec
+} from "./chunk-YSNU3DDN.js";
+import {
+  Zip,
+  ZipPassThrough
+} from "./chunk-IEGVTRIS.js";
+import {
+  require_gifenc
+} from "./chunk-3PLIWIWJ.js";
+import {
+  appender,
+  memoryDestination
+} from "./chunk-K2PZVX43.js";
+import {
+  FORMAT_MIME,
+  evenSize,
+  exportAudioRange,
+  videoBitrate
+} from "./chunk-6CE3I35W.js";
+import {
+  encodePng
+} from "./chunk-NL4IY2P4.js";
+import {
+  packRows,
+  premultiply,
+  unpremultiply
+} from "./chunk-AYS2PW7E.js";
+import {
+  init_define_POPCRAFT_COMPONENT_IDS
+} from "./chunk-FFS4SO7R.js";
+import {
+  __toESM
+} from "./chunk-LJSVREWM.js";
+
+// lib/io/video/index.ts
+init_define_POPCRAFT_COMPONENT_IDS();
+
+// lib/io/gif-export.ts
+init_define_POPCRAFT_COMPONENT_IDS();
+var import_gifenc = __toESM(require_gifenc());
+var key = (r, g, b) => r >> 3 << 10 | g >> 3 << 5 | b >> 3;
+var unkey = (k) => [(k >> 10 & 31) << 3, (k >> 5 & 31) << 3, (k & 31) << 3];
+var PaletteCounter = class {
+  constructor() {
+    this.counts = /* @__PURE__ */ new Map();
+  }
+  add(rgba) {
+    for (let i = 0; i < rgba.length; i += 4) {
+      if (rgba[i + 3] < 128) continue;
+      const k = key(rgba[i], rgba[i + 1], rgba[i + 2]);
+      this.counts.set(k, (this.counts.get(k) || 0) + 1);
+    }
+  }
+  /** The 255 commonest colours after index 0 (transparent). */
+  palette() {
+    const kept = [...this.counts.entries()].sort((a, b) => b[1] - a[1] || a[0] - b[0]).slice(0, 255).map((e) => e[0]);
+    return new GifPalette(kept);
+  }
+};
+var GifPalette = class {
+  constructor(keys) {
+    this.index = /* @__PURE__ */ new Map();
+    this.colors = [[0, 0, 0], ...keys.map(unkey)];
+    keys.forEach((k, i) => this.index.set(k, i + 1));
+  }
+  nearest(k) {
+    const hit = this.index.get(k);
+    if (hit !== void 0) return hit;
+    const [r, g, b] = unkey(k);
+    let best = 1, bd = Infinity;
+    for (let i = 1; i < this.colors.length; i++) {
+      const p = this.colors[i];
+      const d = (p[0] - r) ** 2 + (p[1] - g) ** 2 + (p[2] - b) ** 2;
+      if (d < bd) {
+        bd = d;
+        best = i;
+      }
+    }
+    this.index.set(k, best);
+    return best;
+  }
+};
+var BAYER = [0, 8, 2, 10, 12, 4, 14, 6, 3, 11, 1, 9, 15, 7, 13, 5].map((v) => ((v + 0.5) / 16 - 0.5) * 16);
+var clamp8 = (v) => v < 0 ? 0 : v > 255 ? 255 : v;
+function indexFrame(rgba, width, palette, dither) {
+  const idx = new Uint8Array(rgba.length / 4);
+  for (let i = 0, j = 0; i < rgba.length; i += 4, j++) {
+    if (rgba[i + 3] < 128) continue;
+    if (dither === "ordered") {
+      const d = BAYER[(Math.floor(j / width) & 3) << 2 | j % width & 3];
+      idx[j] = palette.nearest(key(clamp8(rgba[i] + d), clamp8(rgba[i + 1] + d), clamp8(rgba[i + 2] + d)));
+    } else {
+      idx[j] = palette.nearest(key(rgba[i], rgba[i + 1], rgba[i + 2]));
+    }
+  }
+  return idx;
+}
+function changedBox(a, b, width) {
+  let x0 = width, y0 = -1, x1 = -1, y1 = -1;
+  for (let i = 0; i < a.length; i++) {
+    if (a[i] === b[i]) continue;
+    const x = i % width, y = (i - x) / width;
+    if (y0 < 0) y0 = y;
+    y1 = y;
+    if (x < x0) x0 = x;
+    if (x > x1) x1 = x;
+  }
+  return y0 < 0 ? null : { x: x0, y: y0, w: x1 - x0 + 1, h: y1 - y0 + 1 };
+}
+function createGifEncoder(width, height, opts, shared) {
+  const gif = (0, import_gifenc.GIFEncoder)();
+  const mode = opts.palette ?? "global";
+  const dither = opts.dither ?? "none";
+  const incremental = mode === "global" && !!shared;
+  let n = 0;
+  let pending = null;
+  let canvas = null;
+  let opaque = false;
+  const take = () => {
+    const out = gif.bytes();
+    gif.stream.reset();
+    return out;
+  };
+  const flush = (keep) => {
+    const p = pending;
+    if (!p) return new Uint8Array(0);
+    const own = mode === "per-frame" || n === 0;
+    gif.writeFrame(p.idx, p.w, p.h, {
+      palette: own ? p.palette.colors : void 0,
+      delay: p.delay,
+      transparent: true,
+      transparentIndex: 0,
+      repeat: n === 0 ? opts.loop === false ? -1 : 0 : void 0,
+      dispose: keep ? 1 : 2
+    });
+    const out = take();
+    if (n > 0 && (p.x || p.y)) {
+      out[9] = p.x & 255;
+      out[10] = p.x >> 8;
+      out[11] = p.y & 255;
+      out[12] = p.y >> 8;
+    }
+    n++;
+    return out;
+  };
+  return {
+    frame(rgba, delay) {
+      let palette = shared;
+      if (mode === "per-frame" || !palette) {
+        const c = new PaletteCounter();
+        c.add(rgba);
+        palette = c.palette();
+      }
+      const idx = indexFrame(rgba, width, palette, dither);
+      const solid = !idx.includes(0);
+      if (incremental && pending && canvas) {
+        const box = changedBox(canvas, idx, width);
+        if (!box) {
+          pending.delay += delay;
+          return new Uint8Array(0);
+        }
+        if (solid && opaque) {
+          const sub = new Uint8Array(box.w * box.h);
+          for (let y = 0; y < box.h; y++) {
+            const row = (box.y + y) * width + box.x;
+            for (let x = 0; x < box.w; x++) {
+              const v = idx[row + x];
+              sub[y * box.w + x] = v === canvas[row + x] ? 0 : v;
+            }
+          }
+          const out2 = flush(true);
+          pending = { idx: sub, ...box, delay, palette };
+          canvas = idx;
+          return out2;
+        }
+      }
+      const out = flush(false);
+      pending = { idx, x: 0, y: 0, w: width, h: height, delay, palette };
+      canvas = incremental ? idx : null;
+      opaque = solid;
+      return out;
+    },
+    finish() {
+      const last = flush(false);
+      gif.finish();
+      const tail = take();
+      const out = new Uint8Array(last.length + tail.length);
+      out.set(last);
+      out.set(tail, last.length);
+      return out;
+    }
+  };
+}
+function gifDelay(i, fps) {
+  const cs = (k) => Math.round(k * 100 / fps);
+  return (cs(i + 1) - cs(i)) * 10;
+}
+function encodeGifFrames(width, height, frames, opts = {}) {
+  const counter = new PaletteCounter();
+  if ((opts.palette ?? "global") === "global") for (const f of frames) counter.add(f.rgba);
+  const enc = createGifEncoder(width, height, opts, (opts.palette ?? "global") === "global" ? counter.palette() : null);
+  const parts = [...frames.map((f) => enc.frame(f.rgba, f.delay)), enc.finish()];
+  const out = new Uint8Array(parts.reduce((a, p) => a + p.length, 0));
+  let at = 0;
+  for (const p of parts) {
+    out.set(p, at);
+    at += p.length;
+  }
+  return out;
+}
+
+// lib/io/video/encode.ts
+init_define_POPCRAFT_COMPONENT_IDS();
+
+// lib/io/video/audio-delay.ts
+init_define_POPCRAFT_COMPONENT_IDS();
+function bestLag(reference, decoded, maxLag) {
+  let best = 0, bestScore = -Infinity;
+  const n = reference.length;
+  for (let lag = 0; lag <= maxLag; lag++) {
+    let s = 0;
+    const end = Math.min(n, decoded.length - lag);
+    for (let i = 0; i < end; i++) s += reference[i] * decoded[i + lag];
+    if (s > bestScore) {
+      bestScore = s;
+      best = lag;
+    }
+  }
+  return best;
+}
+function probeNoise(n, amp = 0.5) {
+  const out = new Float32Array(n);
+  let s = 625341585;
+  for (let i = 0; i < n; i++) {
+    s = Math.imul(s, 1664525) + 1013904223 >>> 0;
+    out[i] = (s / 2 ** 31 - 1) * amp;
+  }
+  return out;
+}
+var CODEC_STRING = { aac: "mp4a.40.2" };
+var PROBE = 8192;
+var MAX_LAG = 4096;
+var measured = /* @__PURE__ */ new Map();
+function encoderDelay(codec, sampleRate, numberOfChannels) {
+  if (codec !== "aac" || typeof AudioEncoder === "undefined" || typeof AudioDecoder === "undefined") return Promise.resolve(0);
+  const key2 = `${codec}|${sampleRate}|${numberOfChannels}`;
+  let p = measured.get(key2);
+  if (!p) {
+    p = measure(CODEC_STRING.aac, sampleRate, numberOfChannels).catch(() => 0);
+    measured.set(key2, p);
+  }
+  return p;
+}
+async function measure(codec, sampleRate, numberOfChannels) {
+  const signal = probeNoise(PROBE);
+  const chunks = [];
+  let config;
+  let failed = null;
+  const enc = new AudioEncoder({ output: (c, meta) => {
+    chunks.push(c);
+    if (meta?.decoderConfig) config = meta.decoderConfig;
+  }, error: (e) => {
+    failed = e;
+  } });
+  enc.configure({ codec, sampleRate, numberOfChannels, bitrate: 128e3 });
+  const total = PROBE + MAX_LAG + 2048;
+  const data = new Float32Array(total * numberOfChannels);
+  for (let ch = 0; ch < numberOfChannels; ch++) data.set(signal, ch * total);
+  const frame = new AudioData({ format: "f32-planar", sampleRate, numberOfFrames: total, numberOfChannels, timestamp: 0, data });
+  enc.encode(frame);
+  frame.close();
+  await enc.flush();
+  enc.close();
+  if (failed || !config) throw failed ?? new Error("no decoder config");
+  const pcm = [];
+  const dec = new AudioDecoder({ output: (d) => {
+    const a = new Float32Array(d.numberOfFrames);
+    d.copyTo(a, { planeIndex: 0, format: "f32-planar" });
+    pcm.push(a);
+    d.close();
+  }, error: (e) => {
+    failed = e;
+  } });
+  dec.configure(config);
+  for (const c of chunks) dec.decode(c);
+  await dec.flush();
+  dec.close();
+  if (failed) throw failed;
+  const out = new Float32Array(pcm.reduce((n, a) => n + a.length, 0));
+  let at = 0;
+  for (const a of pcm) {
+    out.set(a, at);
+    at += a.length;
+  }
+  return bestLag(signal, out, MAX_LAG);
+}
+
+// lib/io/video/encode.ts
+var CONTAINER_CODECS = { mp4: ["avc"], webm: ["vp9", "av1", "vp8"] };
+var CONTAINER_AUDIO_CODECS = { mp4: ["aac", "opus"], webm: ["opus", "vorbis"] };
+var AVC_LEVELS = [
+  { level: 30, maxFs: 1620, maxMbps: 40500 },
+  { level: 31, maxFs: 3600, maxMbps: 108e3 },
+  { level: 32, maxFs: 5120, maxMbps: 216e3 },
+  { level: 40, maxFs: 8192, maxMbps: 245760 },
+  { level: 42, maxFs: 8704, maxMbps: 522240 },
+  { level: 50, maxFs: 22080, maxMbps: 589824 },
+  { level: 51, maxFs: 36864, maxMbps: 983040 },
+  { level: 52, maxFs: 36864, maxMbps: 2073600 },
+  { level: 60, maxFs: 139264, maxMbps: 4177920 },
+  { level: 61, maxFs: 139264, maxMbps: 8355840 },
+  { level: 62, maxFs: 139264, maxMbps: 16711680 }
+];
+function avcCodecString(width, height, fps) {
+  const mbs = Math.ceil(width / 16) * Math.ceil(height / 16);
+  const side = Math.max(Math.ceil(width / 16), Math.ceil(height / 16));
+  const fit = AVC_LEVELS.find((l) => mbs <= l.maxFs && mbs * fps <= l.maxMbps && side * side <= 8 * l.maxFs) ?? AVC_LEVELS[AVC_LEVELS.length - 1];
+  return `avc1.6400${fit.level.toString(16).padStart(2, "0")}`;
+}
+function encoderConfig(s, codec) {
+  return {
+    codec,
+    bitrate: new Quality({ bitrate: videoBitrate(s, codec), bitrateMode: "variable" }),
+    keyFrameInterval: 2,
+    latencyMode: "quality",
+    ...codec === "avc" ? { fullCodecString: avcCodecString(s.width, s.height, s.fps) } : {}
+  };
+}
+function unsupportedReason(s) {
+  if (typeof VideoEncoder === "undefined" || typeof VideoFrame === "undefined") {
+    return `${s.container.toUpperCase()} export needs WebCodecs (VideoEncoder), which this browser does not provide \u2014 export a GIF or a PNG sequence instead.`;
+  }
+  return null;
+}
+async function pickVideoCodec(s) {
+  const reason = unsupportedReason(s);
+  if (reason) throw new Error(reason);
+  const codec = await getFirstEncodableVideoCodec(CONTAINER_CODECS[s.container], { width: s.width, height: s.height, frameRate: s.fps, bitrate: videoBitrate(s) });
+  if (!codec) {
+    const names = s.container === "mp4" ? "H.264" : "VP9, AV1 or VP8";
+    throw new Error(`This browser cannot encode ${names} video at ${s.width}\xD7${s.height} ${s.fps} fps. Try a smaller size${s.container === "mp4" ? ", WebM" : ", MP4"}, or a GIF.`);
+  }
+  return codec;
+}
+function planarChunk(c) {
+  const len = c.data[0]?.length ?? 0;
+  const out = new Float32Array(len * c.data.length);
+  c.data.forEach((ch, i) => {
+    if (ch.length !== len) throw new Error("Audio chunk channels differ in length.");
+    out.set(ch, i * len);
+  });
+  return out;
+}
+function readbackFrame(p, timestampUs, durationUs) {
+  return new VideoFrame(p.data, {
+    format: p.format === "bgra" ? "BGRX" : "RGBX",
+    codedWidth: p.width,
+    codedHeight: p.height,
+    layout: [{ offset: 0, stride: p.bytesPerRow }],
+    timestamp: timestampUs,
+    duration: durationUs
+  });
+}
+function audioUnsupportedMessage(container) {
+  const other = container === "mp4" ? "WebM" : "MP4";
+  return `This browser cannot encode sound for ${container.toUpperCase()} (${CONTAINER_AUDIO_CODECS[container].map((c) => AUDIO_CODEC_NAMES[c] ?? c).join(" or ")}). Export ${other} instead, or turn the sound off to export the picture alone.`;
+}
+var AUDIO_CODEC_NAMES = { aac: "AAC", opus: "Opus", vorbis: "Vorbis" };
+async function pickAudioCodec(container, o) {
+  for (const codec of CONTAINER_AUDIO_CODECS[container]) {
+    if (await canEncodeAudio(codec, o).catch(() => false)) return codec;
+  }
+  throw new Error(audioUnsupportedMessage(container));
+}
+async function createVideoWriter(dest, s, opts = {}) {
+  const codec = await pickVideoCodec(s);
+  const config = encoderConfig(s, codec);
+  const audioCodec = opts.audio ? await pickAudioCodec(s.container, opts.audio) : null;
+  const audioLead = opts.audio && audioCodec ? await encoderDelay(audioCodec, opts.audio.sampleRate, opts.audio.numberOfChannels) : 0;
+  const output = new Output({
+    format: s.container === "mp4" ? new Mp4OutputFormat({ fastStart: false }) : new WebMOutputFormat(),
+    target: new StreamTarget(dest.writable, { chunked: true, chunkSize: 4 * 1024 * 1024 })
+  });
+  let codecString = config.fullCodecString ?? codec;
+  const video = new VideoSampleSource({ ...config, onEncoderConfig: (c) => {
+    codecString = c.codec;
+  } });
+  output.addVideoTrack(video, { frameRate: s.fps });
+  const audio = opts.audio && audioCodec ? new AudioSampleSource({ codec: audioCodec, quality: new Quality("high") }) : null;
+  if (audio) output.addAudioTrack(audio);
+  await output.start();
+  const audioDone = (async () => {
+    if (!audio || !opts.audio) return;
+    const { numberOfChannels, sampleRate } = opts.audio;
+    for await (const c of opts.audio.chunks) {
+      if (c.data.length !== numberOfChannels) throw new Error(`Audio chunk has ${c.data.length} channels, not ${numberOfChannels}.`);
+      const sample = new AudioSample({ data: planarChunk(c), format: "f32-planar", numberOfChannels, sampleRate, timestamp: (c.timestampSamples - audioLead) / sampleRate });
+      try {
+        await audio.add(sample);
+      } finally {
+        sample.close();
+      }
+    }
+    audio.close();
+  })();
+  return {
+    codec,
+    audioCodec,
+    get codecString() {
+      return codecString;
+    },
+    bitrate: videoBitrate(s, codec),
+    add: async (pixels, timestampUs, durationUs) => {
+      const sample = new VideoSample(readbackFrame(pixels, timestampUs, durationUs));
+      try {
+        await video.add(sample);
+      } finally {
+        sample.close();
+      }
+    },
+    finish: async () => {
+      video.close();
+      await audioDone;
+      await output.finalize();
+    },
+    cancel: async () => {
+      await output.cancel();
+      await audioDone.catch(() => {
+      });
+    }
+  };
+}
+
+// lib/io/video/png-sequence.ts
+init_define_POPCRAFT_COMPONENT_IDS();
+var ZIP_EPOCH = new Date(1980, 0, 1);
+var sequenceFrameName = (i) => `frame_${String(i).padStart(6, "0")}.png`;
+function createPngSequenceWriter(dest, width, height) {
+  const out = appender(dest);
+  let pending = Promise.resolve();
+  let failure = null;
+  const zip = new Zip((err, data) => {
+    if (err) {
+      failure = err;
+      return;
+    }
+    const bytes = data;
+    pending = pending.then(() => out.write(bytes));
+  });
+  const check = () => {
+    if (failure) throw failure;
+  };
+  return {
+    add: async (index, rgba) => {
+      const png = await encodePng(width, height, rgba);
+      const entry = new ZipPassThrough(sequenceFrameName(index));
+      entry.mtime = ZIP_EPOCH;
+      zip.add(entry);
+      entry.push(png, true);
+      check();
+      await pending;
+    },
+    finish: async () => {
+      zip.end();
+      check();
+      await pending;
+      await out.close();
+    }
+  };
+}
+
+// lib/io/video/index.ts
+var GIF_PALETTE_SAMPLES = 16;
+function heapUsed() {
+  const mem = performance.memory;
+  return mem ? mem.usedJSHeapSize : null;
+}
+function sampleIndices(count, n) {
+  if (count <= n) return Array.from({ length: count }, (_, i) => i);
+  return Array.from({ length: n }, (_, k) => Math.round(k * (count - 1) / (n - 1)));
+}
+async function exportAnimation(renderer, doc, spec, dest, opts = {}) {
+  const { signal, onProgress } = opts;
+  const { range, width, height } = spec;
+  const started = performance.now();
+  const heap0 = heapUsed();
+  let peak = heap0 ?? 0;
+  const noteHeap = () => {
+    const h = heapUsed();
+    if (h !== null && h > peak) peak = h;
+  };
+  const watermark = !!spec.watermark && spec.format !== "png";
+  const frames = (indices) => renderFrames(renderer, doc, spec.target, { range, width, height, indices, signal, watermark });
+  const scratch = new Uint8Array(width * height * 4);
+  const rgba = (p) => unpremultiply(packRows(p.data, p.bytesPerRow, p.width, p.height, p.format === "bgra", scratch));
+  const progress = (phase, done, total) => onProgress?.({ phase, done, total });
+  let codec, bitrate;
+  let audioStats;
+  try {
+    if (spec.format === "mp4" || spec.format === "webm") {
+      const mix = spec.audio ? await targetMix(doc, spec.target, exportAudioRange(range)) : null;
+      const writer = await createVideoWriter(dest, { container: spec.format, width, height, fps: range.fps, quality: spec.quality, bitrate: spec.bitrate }, mix ? { audio: mix } : {});
+      try {
+        for await (const f of frames()) {
+          await writer.add(f.pixels, f.timestampUs, f.durationUs);
+          noteHeap();
+          progress("frames", f.index + 1, f.count);
+        }
+        throwIfAborted(signal);
+        progress("finishing", range.count, range.count);
+        await writer.finish();
+      } catch (e) {
+        await writer.cancel().catch(() => {
+        });
+        throw e;
+      }
+      codec = writer.codecString;
+      bitrate = writer.bitrate;
+      if (mix && writer.audioCodec) audioStats = { codec: writer.audioCodec, sampleRate: mix.sampleRate, channels: mix.numberOfChannels, clipped: mix.clipped() };
+    } else if (spec.format === "gif") {
+      const gif = spec.gif ?? {};
+      let palette = null;
+      if ((gif.palette ?? "global") === "global") {
+        const counter = new PaletteCounter();
+        const picks = sampleIndices(range.count, GIF_PALETTE_SAMPLES);
+        let n = 0;
+        for await (const f of frames(picks)) {
+          counter.add(rgba(f.pixels));
+          progress("palette", ++n, picks.length);
+        }
+        palette = counter.palette();
+      }
+      const enc = createGifEncoder(width, height, gif, palette);
+      const out = appender(dest);
+      for await (const f of frames()) {
+        await out.write(enc.frame(rgba(f.pixels), gifDelay(f.index, range.fps)));
+        noteHeap();
+        progress("frames", f.index + 1, f.count);
+      }
+      throwIfAborted(signal);
+      progress("finishing", range.count, range.count);
+      await out.write(enc.finish());
+      await out.close();
+    } else {
+      const writer = createPngSequenceWriter(dest, width, height);
+      for await (const f of frames()) {
+        await writer.add(f.index, rgba(f.pixels));
+        noteHeap();
+        progress("frames", f.index + 1, f.count);
+      }
+      throwIfAborted(signal);
+      progress("finishing", range.count, range.count);
+      await writer.finish();
+    }
+  } catch (e) {
+    await dest.abort().catch(() => {
+    });
+    throw e;
+  }
+  const ms = performance.now() - started;
+  const heap1 = heapUsed();
+  return {
+    frames: range.count,
+    width,
+    height,
+    fps: range.fps,
+    bytes: dest.size(),
+    ms,
+    msPerFrame: ms / range.count,
+    codec,
+    bitrate,
+    ...audioStats ? { audio: audioStats } : {},
+    ...heap0 !== null && heap1 !== null ? { heap: { start: heap0, peak: Math.max(peak, heap1), end: heap1 } } : {}
+  };
+}
+var canWrite = (format) => format === "gif" || typeof VideoEncoder !== "undefined" && typeof VideoFrame !== "undefined";
+var pickPreviewFormat = (formats) => formats.find(canWrite) ?? "gif";
+async function encodeFrames(format, width, height, frames, fps) {
+  if (format === "gif") return encodeGifFrames(width, height, [...frames]);
+  const w = evenSize(width), h = evenSize(height);
+  const dest = memoryDestination(`preview.${format}`, FORMAT_MIME[format]);
+  const writer = await createVideoWriter(dest, { container: format, width: w, height: h, fps, quality: "high" });
+  let at = 0;
+  const over = new Uint8Array(width * h * 4);
+  try {
+    for (const f of frames) {
+      const us = Math.max(1, Math.round(f.delay * 1e3));
+      premultiply(f.rgba.subarray(0, width * h * 4), over);
+      await writer.add({ width: w, height: h, bytesPerRow: width * 4, format: "rgba", data: over, release: () => {
+      } }, at, us);
+      at += us;
+    }
+    await writer.finish();
+  } catch (e) {
+    await writer.cancel().catch(() => {
+    });
+    throw e;
+  }
+  return new Uint8Array(await (await dest.close()).arrayBuffer());
+}
+
+export {
+  sampleIndices,
+  exportAnimation,
+  canWrite,
+  pickPreviewFormat,
+  encodeFrames
+};