@pixerate/flair 0.28.0 → 0.30.0

package/dist/{chunk-VLQLRKGW.js → chunk-MAYKC3RF.js}

@@ -1,17 +1,18 @@
 import {
   ShaderFrames,
   ShaderRenderer
-} from "./chunk-H6VDFBIO.js";
+} from "./chunk-SMR2MJXB.js";
 import {
+  analyseAudioBuffer,
   seekVideo
-} from "./chunk-RDU63CDO.js";
+} from "./chunk-HDYBY3PQ.js";
 import {
   effectDefaults,
   effectInputs,
   getEffect,
   renderVectorEffect,
   textImage
-} from "./chunk-4LKAPRFM.js";
+} from "./chunk-UIODYJ6B.js";
 import {
   parseColor
 } from "./chunk-VYOMXE6I.js";
@@ -19,9 +20,15 @@ import {
   SvgPlayer,
   svgDuration,
   svgView
-} from "./chunk-PFGGPIMT.js";
+} from "./chunk-DA4UUSDO.js";
 
 // src/export/mp4mux.ts
+var AAC_RATES = [96e3, 88200, 64e3, 48e3, 44100, 32e3, 24e3, 22050, 16e3, 12e3, 11025, 8e3, 7350];
+function aacConfig(sampleRate, channels) {
+  const index = AAC_RATES.indexOf(sampleRate);
+  if (index < 0) throw new Error(`AAC has no standard rate of ${sampleRate} Hz; resample to 48000 or 44100.`);
+  return Uint8Array.of(2 << 3 | index >> 1, (index & 1) << 7 | channels << 3);
+}
 var MOVIE_TIMESCALE = 1e3;
 var UINT32 = 4294967296;
 var ascii = (s) => Uint8Array.from(s, (c) => c.charCodeAt(0));
@@ -98,19 +105,80 @@ function stts(ticks) {
     for (const [count, delta] of runs) w.u32(count).u32(delta);
   }));
 }
+var descriptor = (tag, ...content) => {
+  const body = fields((w) => content.forEach((c) => w.bytes(c)));
+  if (body.length > 127) throw new Error("An esds descriptor this long is not written here.");
+  return fields((w) => w.u8(tag).u8(body.length).bytes(body));
+};
+function oneChunk(samples, offset, wide) {
+  const stsz = fullBox("stsz", 0, 0, fields((w) => {
+    w.u32(0).u32(samples.length);
+    for (const s of samples) w.u32(s.data.length);
+  }));
+  const stsc = fullBox("stsc", 0, 0, fields((w) => samples.length ? w.u32(1).u32(1).u32(samples.length).u32(1) : w.u32(0)));
+  const stco = wide ? fullBox("co64", 0, 0, fields((w) => w.u32(1).u64(offset))) : fullBox("stco", 0, 0, fields((w) => w.u32(1).u32(offset)));
+  return [stsz, stsc, stco];
+}
+function audioTrak(audio, offset, wide) {
+  const timescale = audio.sampleRate;
+  const ticks = sampleTicks(audio.samples, timescale);
+  const trackTicks = ticks.reduce((a, b) => a + b, 0);
+  const movieTicks = Math.round(trackTicks * MOVIE_TIMESCALE / timescale);
+  const tkhd = fullBox("tkhd", 0, 3, fields(
+    (w) => w.u32(0).u32(0).u32(2).u32(0).u32(movieTicks).zeros(8).u16(0).u16(1).u16(256).u16(0).bytes(MATRIX).u32(0).u32(0)
+  ));
+  const mdhd = fullBox("mdhd", 0, 0, fields((w) => w.u32(0).u32(0).u32(timescale).u32(trackTicks).u16(21956).u16(0)));
+  const hdlr = fullBox("hdlr", 0, 0, fields((w) => w.u32(0).bytes(ascii("soun")).zeros(12).bytes(ascii("SoundHandler\0"))));
+  const smhd = fullBox("smhd", 0, 0, new Uint8Array(4));
+  const dinf = box("dinf", fullBox("dref", 0, 0, fields((w) => w.u32(1)), fullBox("url ", 0, 1)));
+  const bitrate = Math.round(audio.samples.reduce((n, s) => n + s.data.length, 0) * 8 / Math.max(1e-3, trackTicks / timescale));
+  const esds = fullBox(
+    "esds",
+    0,
+    0,
+    descriptor(
+      3,
+      // ES_Descriptor
+      fields((w) => w.u16(2).u8(0)),
+      // ES id, flags
+      descriptor(
+        4,
+        // DecoderConfigDescriptor
+        fields((w) => w.u8(64).u8(21).u8(0).u16(0).u32(bitrate).u32(bitrate)),
+        // MPEG-4 audio, audio stream, buffer size, bitrates
+        descriptor(5, audio.config ?? aacConfig(audio.sampleRate, audio.channels))
+        // DecoderSpecificInfo
+      ),
+      descriptor(6, Uint8Array.of(2))
+      // SLConfigDescriptor
+    )
+  );
+  const mp4a = box(
+    "mp4a",
+    fields((w) => w.zeros(6).u16(1).zeros(8).u16(audio.channels).u16(16).u16(0).u16(0).u32(Math.min(audio.sampleRate, 65535) * 65536)),
+    esds
+  );
+  const stsd = fullBox("stsd", 0, 0, fields((w) => w.u32(1)), mp4a);
+  const stbl = box("stbl", stsd, stts(ticks), ...oneChunk(audio.samples, offset, wide));
+  const trak = box("trak", tkhd, box("mdia", mdhd, hdlr, box("minf", smhd, dinf, stbl)));
+  return { trak, movieTicks };
+}
 function moov(options, ticks, dataOffset, wide) {
   const { width, height, avcC, samples } = options;
   const timescale = options.timescale ?? 9e4;
   const trackTicks = ticks.reduce((a, b) => a + b, 0);
-  const movieTicks = Math.round(trackTicks * MOVIE_TIMESCALE / timescale);
+  const videoTicks = Math.round(trackTicks * MOVIE_TIMESCALE / timescale);
+  const videoBytes = samples.reduce((n, s) => n + s.data.length, 0);
+  const sound = options.audio?.samples.length ? audioTrak(options.audio, dataOffset + videoBytes, wide) : void 0;
+  const movieTicks = Math.max(videoTicks, sound?.movieTicks ?? 0);
   const mvhd = fullBox("mvhd", 0, 0, fields(
-    (w) => w.u32(0).u32(0).u32(MOVIE_TIMESCALE).u32(movieTicks).u32(65536).u16(256).zeros(10).bytes(MATRIX).zeros(24).u32(2)
+    (w) => w.u32(0).u32(0).u32(MOVIE_TIMESCALE).u32(movieTicks).u32(65536).u16(256).zeros(10).bytes(MATRIX).zeros(24).u32(sound ? 3 : 2)
     // pre_defined, next track id
   ));
   const tkhd = fullBox("tkhd", 0, 3, fields(
     (w) => (
       // enabled, in the movie
-      w.u32(0).u32(0).u32(1).u32(0).u32(movieTicks).zeros(8).u16(0).u16(0).u16(0).u16(0).bytes(MATRIX).u32(width * 65536).u32(height * 65536)
+      w.u32(0).u32(0).u32(1).u32(0).u32(videoTicks).zeros(8).u16(0).u16(0).u16(0).u16(0).bytes(MATRIX).u32(width * 65536).u32(height * 65536)
     )
   ));
   const mdhd = fullBox("mdhd", 0, 0, fields((w) => w.u32(0).u32(0).u32(timescale).u32(trackTicks).u16(21956).u16(0)));
@@ -131,16 +199,10 @@ function moov(options, ticks, dataOffset, wide) {
     w.u32(keys.length);
     for (const k of keys) w.u32(k);
   }))];
-  const stsz = fullBox("stsz", 0, 0, fields((w) => {
-    w.u32(0).u32(samples.length);
-    for (const s of samples) w.u32(s.data.length);
-  }));
-  const stsc = fullBox("stsc", 0, 0, fields((w) => samples.length ? w.u32(1).u32(1).u32(samples.length).u32(1) : w.u32(0)));
-  const stco = wide ? fullBox("co64", 0, 0, fields((w) => w.u32(1).u64(dataOffset))) : fullBox("stco", 0, 0, fields((w) => w.u32(1).u32(dataOffset)));
-  const stbl = box("stbl", stsd, stts(ticks), ...stss, stsz, stsc, stco);
+  const stbl = box("stbl", stsd, stts(ticks), ...stss, ...oneChunk(samples, dataOffset, wide));
   const minf = box("minf", vmhd, dinf, stbl);
   const trak = box("trak", tkhd, box("mdia", mdhd, hdlr, minf));
-  return box("moov", mvhd, trak);
+  return box("moov", mvhd, trak, ...sound ? [sound.trak] : []);
 }
 function muxMp4(options) {
   const { samples } = options;
@@ -148,7 +210,8 @@ function muxMp4(options) {
   if (!samples[0].key) throw new Error("An MP4's first frame must be a keyframe.");
   const ftyp = box("ftyp", ascii("isom"), fields((w) => w.u32(512)), ascii("isomiso2avc1mp41"));
   const ticks = sampleTicks(samples, options.timescale ?? 9e4);
-  const payload = samples.reduce((n, s) => n + s.data.length, 0);
+  const all = [...samples, ...options.audio?.samples ?? []];
+  const payload = all.reduce((n, s) => n + s.data.length, 0);
   const large = payload + 8 >= UINT32;
   const mdatHeader = large ? 16 : 8;
   const wide = ftyp.length + moov(options, ticks, 0, large).length + mdatHeader + payload >= UINT32;
@@ -162,7 +225,7 @@ function muxMp4(options) {
   const out = new Uint8Array(head.length + payload);
   out.set(head);
   let at = head.length;
-  for (const s of samples) {
+  for (const s of all) {
     out.set(s.data, at);
     at += s.data.length;
   }
@@ -170,6 +233,16 @@ function muxMp4(options) {
 }
 
 // src/export/webmmux.ts
+function opusHead(sampleRate, channels, preSkip = 312) {
+  const b = new Uint8Array(19);
+  b.set(new TextEncoder().encode("OpusHead"));
+  const v = new DataView(b.buffer);
+  v.setUint8(8, 1);
+  v.setUint8(9, channels);
+  v.setUint16(10, preSkip, true);
+  v.setUint32(12, sampleRate, true);
+  return b;
+}
 var ID = {
   EBML: 440786851,
   EBMLVersion: 17030,
@@ -193,6 +266,12 @@ var ID = {
   FlagLacing: 156,
   CodecID: 134,
   DefaultDuration: 2352003,
+  CodecPrivate: 25506,
+  CodecDelay: 22186,
+  SeekPreRoll: 22203,
+  Audio: 225,
+  SamplingFrequency: 181,
+  Channels: 159,
   MaxBlockAdditionID: 21998,
   Video: 224,
   PixelWidth: 176,
@@ -255,9 +334,9 @@ var float = (id, n) => {
   return el(id, b);
 };
 var str = (id, s) => el(id, new TextEncoder().encode(s));
-function blockHeader(offset, flags) {
+function blockHeader(offset, flags, track = 1) {
   const b = new Uint8Array(4);
-  b[0] = 129;
+  b[0] = 128 | track;
   new DataView(b.buffer).setInt16(1, offset);
   b[3] = flags;
   return b;
@@ -267,6 +346,7 @@ function muxWebm(options) {
   if (!frames.length) throw new Error("A WebM needs at least one frame.");
   if (!frames[0].key) throw new Error("A WebM's first frame must be a keyframe.");
   const alpha = frames.some((f) => f.alpha);
+  const sound = options.audio?.packets.length ? options.audio : void 0;
   const ms = (us) => Math.round(us / 1e3);
   const last = frames[frames.length - 1];
   const frameUs = fps ? 1e6 / fps : frames.length > 1 ? (last.timestamp - frames[0].timestamp) / (frames.length - 1) : 1e6 / 30;
@@ -302,7 +382,8 @@ function muxWebm(options) {
       ...fps ? [uint(ID.DefaultDuration, Math.round(1e9 / fps))] : [],
       ...alpha ? [uint(ID.MaxBlockAdditionID, 1)] : [],
       el(ID.Video, uint(ID.PixelWidth, width), uint(ID.PixelHeight, height), ...alpha ? [uint(ID.AlphaMode, 1)] : [])
-    )
+    ),
+    ...sound ? [soundTrack(sound)] : []
   );
   const clusters = [];
   let blocks = [];
@@ -312,11 +393,26 @@ function muxWebm(options) {
     if (blocks.length) clusters.push(el(ID.Cluster, uint(ID.Timestamp, clusterMs), ...blocks));
     blocks = [];
   };
-  frames.forEach((frame, i) => {
-    const at = ms(frame.timestamp);
-    if (i === 0 || frame.key || at - clusterMs > MAX_OFFSET) {
+  const items = [...frames.map((frame) => ({ frame })), ...(sound?.packets ?? []).map((packet) => ({ packet }))];
+  const timeOf = (item) => (item.frame ?? item.packet).timestamp;
+  items.sort((a, b) => timeOf(a) - timeOf(b) || (a.frame ? -1 : 0) - (b.frame ? -1 : 0));
+  let started = false;
+  for (const item of items) {
+    const at = ms(timeOf(item));
+    const frame = item.frame;
+    if (!frame) {
+      if (!started || at - clusterMs > MAX_OFFSET) {
+        close();
+        clusterMs = at;
+        started = true;
+      }
+      blocks.push(el(ID.SimpleBlock, blockHeader(at - clusterMs, 128, 2), item.packet.data));
+      continue;
+    }
+    if (!started || frame.key || at - clusterMs > MAX_OFFSET) {
       close();
       clusterMs = at;
+      started = true;
     }
     const offset = at - clusterMs;
     if (frame.alpha) {
@@ -332,11 +428,28 @@ function muxWebm(options) {
       blocks.push(el(ID.SimpleBlock, blockHeader(offset, frame.key ? 128 : 0), frame.data));
     }
     previousMs = at;
-  });
+  }
   close();
   const segment = el(ID.Segment, info, tracks, ...clusters);
   return concat([header, segment]);
 }
+function soundTrack(sound) {
+  const head = sound.codecPrivate?.length ? sound.codecPrivate : opusHead(sound.sampleRate, sound.channels);
+  const preSkip = head.length >= 12 ? head[10] | head[11] << 8 : 312;
+  return el(
+    ID.TrackEntry,
+    uint(ID.TrackNumber, 2),
+    uint(ID.TrackUID, 2),
+    uint(ID.TrackType, 2),
+    // audio
+    uint(ID.FlagLacing, 0),
+    str(ID.CodecID, "A_OPUS"),
+    el(ID.CodecPrivate, head),
+    uint(ID.CodecDelay, Math.round(preSkip * 1e9 / 48e3)),
+    uint(ID.SeekPreRoll, 8e7),
+    el(ID.Audio, float(ID.SamplingFrequency, sound.sampleRate), uint(ID.Channels, sound.channels))
+  );
+}
 function signed(n) {
   for (let len = 1; len <= 8; len++) {
     if (n >= -(2 ** (8 * len - 1)) && n < 2 ** (8 * len - 1)) {
@@ -423,6 +536,16 @@ function zipStore(entries) {
 }
 
 // src/embed/record.ts
+var AUDIO_RATE = 48e3;
+async function audioConfig(format) {
+  if (typeof AudioEncoder === "undefined" || typeof AudioData === "undefined") return void 0;
+  const config = { codec: format === "mp4" ? "mp4a.40.2" : "opus", sampleRate: AUDIO_RATE, numberOfChannels: 2, bitrate: 128e3 };
+  try {
+    return (await AudioEncoder.isConfigSupported(config)).supported ? config : void 0;
+  } catch {
+    return void 0;
+  }
+}
 var DEFAULT_SECONDS = 4;
 var yieldToBrowser = () => new Promise((resolve) => setTimeout(resolve, 0));
 var formats = (list) => list.map((f) => `"${f}"`).join(", ").replace(/, ([^,]*)$/, " or $1");
@@ -538,7 +661,24 @@ async function recordingPlan(effect, options = {}) {
     width = w;
     height = h;
   }
-  return { effect: def, format, width, height, fps, duration, start, frames: Math.max(1, Math.round(duration * fps)), alpha, ...encoder ? { encoder } : {} };
+  let audioEncoder;
+  if (options.audio !== void 0 && options.audioTrack !== false && (format === "mp4" || format === "webm")) {
+    audioEncoder = await audioConfig(format);
+    if (!audioEncoder && format === "mp4" && !options.format) {
+      const webm = await videoConfig("webm", width, height, fps, encoder.bitrate ?? Math.round(width * height * fps * 0.15));
+      const opus = webm && await audioConfig("webm");
+      if (webm && opus) {
+        format = "webm";
+        encoder = webm;
+        audioEncoder = opus;
+      }
+    }
+    if (!audioEncoder) {
+      const codec = format === "mp4" ? "AAC" : "Opus";
+      throw new Error(`This browser cannot encode ${codec} audio, so it cannot put the sound in ${format === "mp4" ? "an mp4" : "a webm"}; ${format === "mp4" ? 'record "webm" (Opus), or ' : ""}pass audioTrack: false to record the picture alone (the sound still drives it).`);
+    }
+  }
+  return { effect: def, format, width, height, fps, duration, start, frames: Math.max(1, Math.round(duration * fps)), alpha, ...encoder ? { encoder } : {}, ...audioEncoder ? { audioEncoder } : {} };
 }
 function defaultDuration(def, options) {
   if (def.kind === "shader") return def.loop ?? DEFAULT_SECONDS;
@@ -551,7 +691,7 @@ function effectValues(def, options) {
   const s = subjectValues(def, options.subject);
   return { values: { ...values, ...s.values }, live: s.live };
 }
-function shaderSource(plan, values, live, options) {
+function shaderSource(plan, values, live, options, sound) {
   const def = plan.effect;
   const frames = new ShaderFrames({ source: def.source, values, width: plan.width, height: plan.height, alpha: plan.alpha || Boolean(def.transparent) });
   const videos = [];
@@ -569,7 +709,7 @@ function shaderSource(plan, values, live, options) {
       await options.beforeFrame?.(time, index);
       await frames.ready();
       const pointer = typeof script === "function" ? script(time) : script;
-      frames.render(time, { frame: index, delta: 1 / plan.fps, ...pointer });
+      frames.render(time, { frame: index, delta: 1 / plan.fps, ...pointer, ...sound ? { audio: sound.at(time) } : {} });
       frames.readPixels(out);
     },
     dispose() {
@@ -682,7 +822,64 @@ function collector(config, fail) {
   out.encoder.configure(config);
   return out;
 }
-function videoEncoder(plan) {
+async function decodeAudio(url) {
+  if (typeof OfflineAudioContext === "undefined") throw new Error("This browser has no Web Audio (OfflineAudioContext), so it cannot decode the audio.");
+  let bytes;
+  try {
+    const response = await fetch(url);
+    if (!response.ok) throw new Error(`HTTP ${response.status}`);
+    bytes = await response.arrayBuffer();
+  } catch (e) {
+    throw new Error(`The audio at ${url} could not be loaded (${e.message}); a file from another site needs CORS.`, { cause: e });
+  }
+  try {
+    return await new OfflineAudioContext(2, 1, AUDIO_RATE).decodeAudioData(bytes);
+  } catch (e) {
+    throw new Error(`The audio at ${url} could not be decoded; give it an mp3, AAC, Ogg, Opus, FLAC or WAV file the browser plays.`, { cause: e });
+  }
+}
+async function encodeSound(buffer, plan) {
+  const config = plan.audioEncoder;
+  const channels = config.numberOfChannels;
+  const length = Math.max(1, Math.round(plan.duration * AUDIO_RATE));
+  const offline = new OfflineAudioContext(channels, length, AUDIO_RATE);
+  const node = offline.createBufferSource();
+  node.buffer = buffer;
+  node.connect(offline.destination);
+  node.start(0, Math.min(plan.start, buffer.duration));
+  const rendered = await offline.startRendering();
+  const out = { codec: config.codec === "opus" ? "opus" : "aac", sampleRate: AUDIO_RATE, channels, chunks: [] };
+  let failure;
+  const encoder = new AudioEncoder({
+    output(chunk, metadata) {
+      const data = new Uint8Array(chunk.byteLength);
+      chunk.copyTo(data);
+      const desc = metadata?.decoderConfig?.description;
+      if (desc && !out.description) out.description = bytesOf(desc);
+      out.chunks.push({ data, timestamp: chunk.timestamp, ...chunk.duration ? { duration: chunk.duration } : {}, key: true });
+    },
+    error: (e) => failure ??= new Error(`The audio encoder failed: ${e.message}`, { cause: e })
+  });
+  encoder.configure(config);
+  const block = 4800;
+  for (let at = 0; at < length; at += block) {
+    const n = Math.min(block, length - at);
+    const planes = new Float32Array(n * channels);
+    for (let c = 0; c < channels; c++) planes.set(rendered.getChannelData(c).subarray(at, at + n), c * n);
+    const data = new AudioData({ format: "f32-planar", sampleRate: AUDIO_RATE, numberOfFrames: n, numberOfChannels: channels, timestamp: Math.round(at * 1e6 / AUDIO_RATE), data: planes });
+    try {
+      encoder.encode(data);
+    } finally {
+      data.close();
+    }
+  }
+  await encoder.flush();
+  encoder.close();
+  if (failure) throw failure;
+  out.chunks.sort((a, b) => a.timestamp - b.timestamp);
+  return out;
+}
+function videoEncoder(plan, sound) {
   const config = plan.encoder;
   let failure;
   const fail = (e) => failure ??= e;
@@ -721,9 +918,16 @@ function videoEncoder(plan) {
       for (const e of encoders) e.close();
       const byTime = (a, b) => a.timestamp - b.timestamp;
       const chunks = color.chunks.sort(byTime);
+      const audio = await sound;
       if (plan.format === "mp4") {
         if (!color.description) throw new Error("The H.264 encoder gave no decoder configuration (avcC), so the mp4 cannot be written.");
-        const file2 = muxMp4({ width, height, avcC: color.description, samples: chunks });
+        const file2 = muxMp4({
+          width,
+          height,
+          avcC: color.description,
+          samples: chunks,
+          ...audio ? { audio: { sampleRate: audio.sampleRate, channels: audio.channels, ...audio.description ? { config: audio.description } : {}, samples: audio.chunks } } : {}
+        });
         return new Blob([file2], { type: "video/mp4" });
       }
       const alphas = new Map(alpha?.chunks.map((c) => [c.timestamp, c.data]));
@@ -733,7 +937,15 @@ function videoEncoder(plan) {
         return { ...c, ...a ? { alpha: a } : {} };
       });
       const codec = config.codec.startsWith("vp8") ? "vp8" : "vp9";
-      const file = muxWebm({ codec, width, height, frames, duration: plan.frames * frameUs, fps: plan.fps });
+      const file = muxWebm({
+        codec,
+        width,
+        height,
+        frames,
+        duration: plan.frames * frameUs,
+        fps: plan.fps,
+        ...audio ? { audio: { sampleRate: audio.sampleRate, channels: audio.channels, ...audio.description ? { codecPrivate: audio.description } : {}, packets: audio.chunks } } : {}
+      });
       return new Blob([file], { type: "video/webm" });
     },
     close() {
@@ -746,10 +958,14 @@ async function recordEffect(effect, options = {}) {
   const { signal, onProgress } = options;
   const { values, live } = effectValues(plan.effect, options);
   const background = (parseColor(options.background ?? (plan.effect.kind === "shader" ? "#000000" : "#ffffff")) ?? [0, 0, 0]).map((c) => Math.round(c * 255));
-  const source = plan.effect.kind === "shader" ? shaderSource(plan, values, live, options) : vectorSource(plan, values, options);
+  const buffer = options.audio === void 0 ? void 0 : typeof options.audio === "string" ? await decodeAudio(options.audio) : options.audio;
+  const sound = buffer && plan.effect.kind === "shader" && effectInputs(plan.effect).accepts.includes("audio") ? analyseAudioBuffer(buffer) : void 0;
+  const track = buffer && plan.audioEncoder ? encodeSound(buffer, plan) : void 0;
+  track?.catch(() => void 0);
+  const source = plan.effect.kind === "shader" ? shaderSource(plan, values, live, options, sound) : vectorSource(plan, values, options);
   let encoder;
   try {
-    encoder = plan.format === "gif" ? await gifEncoder(plan) : plan.format === "png" ? pngEncoder(plan) : videoEncoder(plan);
+    encoder = plan.format === "gif" ? await gifEncoder(plan) : plan.format === "png" ? pngEncoder(plan) : videoEncoder(plan, track);
     const rgba = new Uint8ClampedArray(plan.width * plan.height * 4);
     for (let i = 0; i < plan.frames; i++) {
       if (signal?.aborted) throw new DOMException("Cancelled", "AbortError");
@@ -792,6 +1008,12 @@ function subjectValues(effect, subject, slot) {
   for (const s of Array.isArray(subject) ? subject : [subject]) {
     const kind = kindOf(s);
     const free = (slots) => slots.filter((x) => !used.has(x.name));
+    if (kind === "audio") {
+      if (!inputs.accepts.includes("audio"))
+        throw new Error(`"${effect.id}" does not react to sound; findEffects({ accepts: ["audio"] }) lists the effects that do.`);
+      out.audio = s.audio;
+      continue;
+    }
     if (kind === "path" || kind === "text" && effect.kind === "vector") {
       const holds = kind === "path" ? "path" : "copy";
       const text = pick(free(inputs.texts), (t) => t.holds === holds, slot, effect, kind === "path" ? "path data" : "text");
@@ -819,11 +1041,13 @@ function mountEffect(host, effect, options = {}) {
   if (!def) throw new Error(`There is no effect "${String(effect)}" in the catalog; findEffects() lists them.`);
   let values = { ...effectDefaults(def, { ...options.preset ? { preset: options.preset } : {}, ...options.values ? { values: options.values } : {} }) };
   let live = {};
+  let audio;
   const apply = (subject) => {
     if (!subject) return;
     const s = subjectValues(def, subject);
     values = { ...values, ...s.values };
     live = s.live;
+    audio = s.audio;
   };
   apply(options.subject);
   if (def.kind === "shader") {
@@ -840,15 +1064,18 @@ function mountEffect(host, effect, options = {}) {
       for (const [name, source] of Object.entries(live)) renderer.setLiveSource(name, source);
     };
     setLive({});
+    if (audio) renderer.setAudioSource(audio);
     return {
       effect: def,
       element: renderer.canvas,
       renderer,
       setSubject(subject) {
         const before = live;
+        const heard = audio;
         apply(subject);
         renderer.setValues(values);
         setLive(before);
+        if (audio !== heard) renderer.setAudioSource(audio ?? null);
       },
       setValues(next) {
         values = { ...values, ...next };
@@ -899,4 +1126,4 @@ export {
   subjectValues,
   mountEffect
 };
-//# sourceMappingURL=chunk-VLQLRKGW.js.map
+//# sourceMappingURL=chunk-MAYKC3RF.js.map