@poe-platform/safe-bash 0.1.812 → 0.1.813

package/dist/audio-ast/index.js

@@ -74,6 +74,92 @@ function duration(samples, sampleRate) {
   return samples / sampleRate;
 }
 
+// packages/audio-ast/src/ogg-stream.ts
+function oggIdentification(head, size = head.length) {
+  const r = new Reader(head);
+  if (head.length >= 8 && r.text(0, 8) === "OpusHead") {
+    if (size < 19 || r.u8(8) > 15) throw new Error("Invalid Opus identification");
+    const channels = r.u8(9), preSkip = r.u16(10, true), mapping = r.u8(18);
+    if (mapping === 0 && channels > 2) throw new Error("Invalid Opus channels");
+    if (mapping !== 0) r.check(19, 2 + channels);
+    return { codec: "opus", sampleRate: 48e3, channels, preSkip };
+  }
+  if (head.length >= 7 && r.u8(0) === 1 && r.text(1, 6) === "vorbis") {
+    if (size !== 30 || r.u32(7, true) !== 0 || !(r.u8(29) & 1)) throw new Error("Invalid Vorbis identification");
+    return { codec: "vorbis", sampleRate: r.u32(12, true), channels: r.u8(11), preSkip: 0 };
+  }
+  throw new Error("Unsupported Ogg codec");
+}
+function oggStream(identification, final, size) {
+  const { codec, sampleRate, channels, preSkip } = identification;
+  if (!channels || !sampleRate) throw new Error("Invalid Ogg audio stream");
+  if (final > BigInt(Number.MAX_SAFE_INTEGER)) throw new Error("Ogg granule exceeds safe precision");
+  const samples = Math.max(0, Number(final) - preSkip), duration2 = samples / sampleRate;
+  return { codec, sampleRate, channels, samples, duration: duration2, bitrate: duration2 ? size * 8 / duration2 : 0 };
+}
+
+// packages/audio-ast/src/ogg-stream-source.ts
+async function probeOggStreamSource(input, options = {}) {
+  const check = (source, offset2, length) => {
+    options.signal?.throwIfAborted();
+    if (!Number.isSafeInteger(source.size) || source.size < 0 || offset2 < 0 || length < 0 || length > source.size - offset2)
+      throw new Error("Truncated or invalid audio structure");
+  };
+  const read = async (source, offset2, length) => {
+    check(source, offset2, length);
+    const bytes = new Uint8Array(length);
+    for (let at = 0; at < length; ) {
+      const part = await source.read(offset2 + at, length - at);
+      options.signal?.throwIfAborted();
+      if (!part.length || part.length > length - at) throw new Error("Truncated or invalid audio structure");
+      bytes.set(part, at);
+      at += part.length;
+    }
+    await options.checkpoint?.();
+    options.signal?.throwIfAborted();
+    return new Reader(bytes);
+  };
+  options.signal?.throwIfAborted();
+  if (!Number.isSafeInteger(input.size) || input.size < 0 || input.granule < 0n) throw new RangeError("Invalid Ogg stream size or granule");
+  check(input.head, 0, 0);
+  const identification = oggIdentification((await read(input.head, 0, Math.min(input.head.size, 276))).bytes, input.head.size);
+  const { comments } = input, opus = identification.codec === "opus", prefix = opus ? 8 : 7;
+  const missing = opus ? "Missing OpusTags" : "Missing Vorbis comments";
+  if (!comments) throw new Error(missing);
+  const marker = await read(comments, 0, prefix);
+  if (opus ? marker.text(0, 8) !== "OpusTags" : marker.u8(0) !== 3 || marker.text(1, 6) !== "vorbis") throw new Error(missing);
+  const vendorLength = (await read(comments, prefix, 4)).u32(0, true);
+  check(comments, prefix + 4, vendorLength);
+  let offset = prefix + 4 + vendorLength;
+  const count = (await read(comments, offset, 4)).u32(0, true);
+  offset += 4;
+  if (count > (comments.size - offset) / 4) throw new Error("Invalid Vorbis comment count");
+  const tags = {};
+  for (let i = 0; i < count; i++) {
+    const length = (await read(comments, offset, 4)).u32(0, true);
+    offset += 4;
+    check(comments, offset, length);
+    if (options.onComment) {
+      await options.onComment({ offset, length });
+      options.signal?.throwIfAborted();
+    } else {
+      const decoder = new TextDecoder();
+      let text2 = "";
+      for (let at = 0; at < length; at += 16384) text2 += decoder.decode((await read(comments, offset + at, Math.min(16384, length - at))).bytes, { stream: true });
+      text2 += decoder.decode();
+      const split = text2.indexOf("=");
+      if (split > 0) {
+        const key = text2.slice(0, split), value = text2.slice(split + 1);
+        tags[key] = tags[key] ? `${tags[key]};${value}` : value;
+      }
+    }
+    offset += length;
+  }
+  if (!opus && (offset === comments.size || !((await read(comments, offset, 1)).u8(0) & 1)))
+    throw new Error("Missing Vorbis comment framing bit");
+  return { tags, ...oggStream(identification, input.granule, input.size) };
+}
+
 // packages/audio-ast/src/vorbis.ts
 var names = {
   TITLE: "title",
@@ -168,94 +254,872 @@ function normalizeVorbisCommentKey(value) {
   return names[key] ?? key;
 }
 
-// packages/audio-ast/src/flac.ts
-function parseFlac(bytes) {
-  const r = new Reader(bytes), nodes = [], pictures = [];
-  const tags = {};
-  let offset = 4, last = false, stream;
-  while (!last) {
-    const header = r.u8(offset), type = header & 127, size = r.u24(offset + 1);
-    last = !!(header & 128);
-    const data = r.slice(offset + 4, size), node = {
-      type: [
-        "STREAMINFO",
-        "PADDING",
-        "APPLICATION",
-        "SEEKTABLE",
-        "VORBIS_COMMENT",
-        "CUESHEET",
-        "PICTURE"
-      ][type] ?? `BLOCK_${type}`,
-      offset,
-      size: size + 4,
-      data
-    };
-    nodes.push(node);
-    const block = new Reader(data);
-    if (type === 0) {
-      if (stream || offset !== 4 || size !== 34)
-        throw new Error("FLAC requires first unique STREAMINFO");
-      stream = flacStream(block, bytes.length);
-      const { sampleRate, channels, bitsPerSample, samples } = stream;
-      node.fields = {
-        minBlockSize: block.u16(0),
-        maxBlockSize: block.u16(2),
-        minFrameSize: block.u24(4),
-        maxFrameSize: block.u24(7),
-        sampleRate,
-        channels,
-        bitsPerSample,
-        totalSamples: samples,
-        md5: Array.from(block.slice(18, 16), (b) => b.toString(16).padStart(2, "0")).join("")
-      };
-    } else if (type === 4) {
-      const parsed = parseComments(data);
-      if (parsed.size !== size) throw new Error("Trailing Vorbis comment bytes");
-      Object.assign(tags, parsed.tags);
-      node.fields = { vendor: parsed.vendor, comments: parsed.comments };
-    } else if (type === 6) pictures.push(parsePicture(data));
-    else if (type === 3) {
-      if (size % 18) throw new Error("Invalid FLAC seek table");
-      const points = [];
-      for (let pos = 0; pos < size; pos += 18)
-        points.push({
-          sample: block.u64(pos),
-          offset: block.u64(pos + 8),
-          samples: block.u16(pos + 16)
-        });
-      node.fields = { points };
-    } else if (type === 127) throw new Error("Invalid FLAC metadata block");
-    offset += 4 + size;
+// packages/audio-ast/src/ogg.ts
+function oggCrc(bytes, crc = 0, pageOffset = 0) {
+  for (let i = 0; i < bytes.length; i++) {
+    const offset = pageOffset + i;
+    crc ^= (offset >= 22 && offset < 26 ? 0 : bytes[i]) << 24;
+    for (let bit = 0; bit < 8; bit++) crc = crc << 1 ^ (crc & 2147483648 ? 79764919 : 0);
   }
-  if (!stream) throw new Error("Missing FLAC STREAMINFO");
-  if (offset < bytes.length)
+  return crc >>> 0;
+}
+function readOgg(bytes) {
+  const r = new Reader(bytes), nodes = [], packets = [], logical = /* @__PURE__ */ new Map();
+  for (let offset = 0; offset < bytes.length; ) {
+    if (r.text(offset, 4) !== "OggS" || r.u8(offset + 4) !== 0) throw new Error("Invalid Ogg page");
+    const flags = r.u8(offset + 5), granule = r.u64(offset + 6, true), serial = r.u32(offset + 14, true), sequence = r.u32(offset + 18, true), count = r.u8(offset + 26), laces = r.slice(offset + 27, count);
+    if (flags & ~7) throw new Error("Invalid Ogg page flags");
+    const size = 27 + count + laces.reduce((sum, n) => sum + n, 0), page = r.slice(offset, size);
+    if (oggCrc(page) !== r.u32(offset + 22, true)) throw new Error("Ogg checksum mismatch");
+    let state = logical.get(serial);
+    if (!state) {
+      if (!(flags & 2) || sequence !== 0) throw new Error("Missing Ogg beginning-of-stream");
+      state = { packets: [], pending: [], sequence: -1, ended: false };
+      logical.set(serial, state);
+    }
+    if (state.ended || sequence !== state.sequence + 1 >>> 0 || !!(flags & 1) !== !!state.pending.length)
+      throw new Error("Invalid Ogg sequence/continuation");
+    state.sequence = sequence;
+    const completed = [];
+    let pos = offset + 27 + count;
+    for (const lace of laces) {
+      state.pending.push(r.slice(pos, lace));
+      pos += lace;
+      if (lace < 255) {
+        const packet = {
+          data: join(state.pending),
+          serial,
+          granule: 0xffffffffffffffffn,
+          bos: state.packets.length === 0,
+          eos: false
+        };
+        state.pending = [];
+        state.packets.push(packet);
+        packets.push(packet);
+        completed.push(packet);
+      }
+    }
+    if (completed.length) {
+      completed[completed.length - 1].granule = granule;
+      if (flags & 4) completed[completed.length - 1].eos = true;
+    }
+    if (flags & 4) {
+      if (state.pending.length) throw new Error("Incomplete final Ogg packet");
+      state.ended = true;
+    }
     nodes.push({
-      type: "FRAMES",
+      type: "OggS",
       offset,
-      size: bytes.length - offset,
-      data: r.slice(offset, bytes.length - offset)
+      size,
+      data: page,
+      fields: {
+        flags,
+        granule,
+        serial,
+        sequence,
+        checksum: r.u32(offset + 22, true),
+        lacing: laces
+      }
     });
+    offset += size;
+  }
+  if (!logical.size || Array.from(logical.values()).some((s) => s.pending.length || !s.ended))
+    throw new Error("Incomplete Ogg stream");
+  return { nodes, packets };
+}
+function encodeOgg(packets) {
+  const pages = [], sequences = /* @__PURE__ */ new Map(), pending = /* @__PURE__ */ new Map();
+  for (const packet of packets) {
+    const group = pending.get(packet.serial) ?? [];
+    group.push(packet);
+    pending.set(packet.serial, group);
+    if (packet.granule === 0xffffffffffffffffn && !packet.eos) continue;
+    const laces = [], granules = [], boundaries = /* @__PURE__ */ new Set();
+    for (const item of group) {
+      for (let j = 0; j < Math.floor(item.data.length / 255); j++) {
+        laces.push(255);
+        granules.push(0xffffffffffffffffn);
+      }
+      laces.push(item.data.length % 255);
+      granules.push(item.granule);
+      boundaries.add(laces.length);
+    }
+    const body = join(group.map((p) => p.data));
+    let offset = 0;
+    for (let start = 0; start < laces.length; start += 255) {
+      const part = laces.slice(start, start + 255), last = start + 255 >= laces.length, size = part.reduce((a, b) => a + b, 0), header = new Uint8Array(27 + part.length), v = new DataView(header.buffer);
+      header.set(ascii("OggS"));
+      header[5] = (start && !boundaries.has(start) ? 1 : 0) | (group[0].bos && start === 0 ? 2 : 0) | (packet.eos && last ? 4 : 0);
+      let granule = 0xffffffffffffffffn;
+      for (let i = start; i < start + part.length; i++)
+        if (laces[i] < 255) granule = granules[i] === 0xffffffffffffffffn ? 0n : granules[i];
+      v.setBigUint64(6, granule, true);
+      v.setUint32(14, packet.serial, true);
+      const sequence = sequences.get(packet.serial) ?? 0;
+      v.setUint32(18, sequence, true);
+      sequences.set(packet.serial, sequence + 1);
+      header[26] = part.length;
+      header.set(part, 27);
+      const page = join([header, body.subarray(offset, offset + size)]);
+      new DataView(page.buffer).setUint32(22, oggCrc(page), true);
+      pages.push(page);
+      offset += size;
+    }
+    pending.delete(packet.serial);
+  }
+  if (pending.size) throw new Error("Ogg packets lack a final page granule");
+  return join(pages);
+}
+function parseOgg(bytes) {
+  const { nodes, packets } = readOgg(bytes), streams = [], tags = {}, pictures = [];
+  const serials = [...new Set(packets.map((p) => p.serial))];
+  for (const serial of serials) {
+    const group = packets.filter((p) => p.serial === serial), identification = oggIdentification(group[0].data);
+    const comment = group[1]?.data;
+    let comments;
+    if (identification.codec === "opus") {
+      if (!comment || new Reader(comment).text(0, 8) !== "OpusTags") throw new Error("Missing OpusTags");
+      const parsed = parseComments(comment.subarray(8));
+      Object.assign(tags, parsed.tags);
+      comments = parsed.comments;
+    } else {
+      if (!comment || comment[0] !== 3 || new Reader(comment).text(1, 6) !== "vorbis") throw new Error("Missing Vorbis comments");
+      const parsed = parseComments(comment.subarray(7));
+      if (!(comment[7 + parsed.size] & 1)) throw new Error("Missing Vorbis comment framing bit");
+      Object.assign(tags, parsed.tags);
+      comments = parsed.comments;
+    }
+    const final = group.filter((p) => p.granule !== 0xffffffffffffffffn).at(-1)?.granule ?? 0n;
+    const size = nodes.filter((n) => n.fields?.serial === serial).reduce((sum, n) => sum + n.size, 0);
+    const streamTags = {};
+    for (const comment2 of comments) {
+      const split = comment2.indexOf("=");
+      if (split <= 0) continue;
+      const key = comment2.slice(0, split), value = comment2.slice(split + 1);
+      streamTags[key] = streamTags[key] ? `${streamTags[key]};${value}` : value;
+    }
+    streams.push({ tags: streamTags, ...oggStream(identification, final, size) });
+  }
+  for (const value of (tags.METADATA_BLOCK_PICTURE ?? "").split("\n").filter(Boolean)) {
+    pictures.push(parsePicture(Uint8Array.from(atob(value), (c) => c.charCodeAt(0))));
+  }
+  let duration2 = 0, groupDuration = 0;
+  const active = /* @__PURE__ */ new Set();
+  for (const node of nodes) {
+    const serial = node.fields.serial, flags = node.fields.flags;
+    if (flags & 2) {
+      if (!active.size) {
+        duration2 += groupDuration;
+        groupDuration = 0;
+      }
+      active.add(serial);
+      groupDuration = Math.max(groupDuration, streams[serials.indexOf(serial)].duration);
+    }
+    if (flags & 4) active.delete(serial);
+  }
+  duration2 += groupDuration;
   return {
-    format: "flac",
+    format: "ogg",
     data: bytes,
     nodes,
+    streams,
     tags,
     pictures,
-    streams: [stream],
-    duration: stream.duration,
-    bitrate: stream.bitrate
+    duration: duration2,
+    bitrate: duration2 ? bytes.length * 8 / duration2 : 0
   };
 }
-function flacStream(block, byteLength) {
-  const packed = block.u64(10), sampleRate = Number(packed >> 44n), channels = Number(packed >> 41n & 7n) + 1, bitsPerSample = Number(packed >> 36n & 31n) + 1, samples = Number(packed & 0xfffffffffn), seconds2 = duration(samples, sampleRate);
-  return { codec: "flac", sampleRate, channels, bitsPerSample, samples, duration: seconds2, bitrate: seconds2 ? byteLength * 8 / seconds2 : 0 };
-}
 
-// packages/audio-ast/src/flac-source.ts
-async function probeFlacSource(source, options = {}) {
-  const check = (offset2, length, end = source.size) => {
+// packages/audio-ast/src/ogg-source.ts
+async function* scanOggPages(source, options = {}) {
+  options.signal?.throwIfAborted();
+  const retained = "size" in source ? source : void 0;
+  if (retained && (!Number.isSafeInteger(retained.size) || retained.size < 0)) throw new RangeError("Invalid Ogg source size");
+  const iterator = !retained && Symbol.asyncIterator in source ? source[Symbol.asyncIterator]() : void 0;
+  let offset = 0, position = 0, done = false;
+  let pending = new Uint8Array(0);
+  const read = async (length, eof = false) => {
+    const out = new Uint8Array(length);
+    let used = 0;
+    while (used < length) {
+      options.signal?.throwIfAborted();
+      let chunk;
+      if (retained) {
+        if (offset === retained.size && eof && used === 0) return out.subarray(0, 0);
+        if (length - used > retained.size - offset) throw new Error("Truncated Ogg page");
+        chunk = await retained.read(offset, length - used);
+        options.signal?.throwIfAborted();
+        if (!chunk.length) throw new Error("Truncated Ogg page");
+        if (chunk.length > length - used) throw new Error("Ogg source returned more bytes than requested");
+      } else {
+        while (position === pending.length) {
+          const next = await iterator.next();
+          options.signal?.throwIfAborted();
+          if (next.done) {
+            done = true;
+            if (eof && used === 0) return out.subarray(0, 0);
+            throw new Error("Truncated Ogg page");
+          }
+          pending = next.value;
+          position = 0;
+          if (!pending.length) {
+            await options.checkpoint?.();
+            options.signal?.throwIfAborted();
+          }
+        }
+        const length2 = Math.min(out.length - used, pending.length - position);
+        chunk = pending.subarray(position, position + length2);
+        position += length2;
+      }
+      out.set(chunk, used);
+      used += chunk.length;
+      offset += chunk.length;
+      if (!Number.isSafeInteger(offset)) throw new RangeError("Invalid Ogg source size");
+    }
+    await options.checkpoint?.();
     options.signal?.throwIfAborted();
-    if (!Number.isSafeInteger(source.size) || !Number.isSafeInteger(offset2) || !Number.isSafeInteger(length) || offset2 < 0 || length < 0 || length > end - offset2)
+    return out;
+  };
+  let failed = false;
+  const retire = async () => {
+    if (iterator && !done) {
+      try {
+        await iterator.return?.();
+      } catch (error) {
+        if (!failed) throw error;
+      }
+    }
+  };
+  try {
+    for (; ; ) {
+      const start = offset, header = await read(27, true);
+      if (!header.length) return;
+      const r = new Reader(header);
+      if (r.text(0, 4) !== "OggS" || r.u8(4) !== 0) throw new Error("Invalid Ogg page");
+      const flags = r.u8(5);
+      if (flags & ~7) throw new Error("Invalid Ogg page flags");
+      const lacing = await read(r.u8(26)), payloadOffset = offset;
+      let crc = oggCrc(header);
+      crc = oggCrc(lacing, crc, 27);
+      let remaining = 0;
+      for (const length of lacing) remaining += length;
+      while (remaining) {
+        const pageOffset = offset - start, chunk = await read(Math.min(16384, remaining));
+        crc = oggCrc(chunk, crc, pageOffset);
+        remaining -= chunk.length;
+      }
+      const checksum = r.u32(22, true);
+      if (crc !== checksum) throw new Error("Ogg checksum mismatch");
+      yield {
+        offset: start,
+        size: offset - start,
+        payloadOffset,
+        flags,
+        granule: r.u64(6, true),
+        serial: r.u32(14, true),
+        sequence: r.u32(18, true),
+        checksum,
+        lacing
+      };
+    }
+  } catch (error) {
+    failed = true;
+    throw error;
+  } finally {
+    await retire();
+  }
+}
+
+// packages/audio-ast/src/id3.ts
+var names2 = {
+  TIT2: "title",
+  TPE1: "artist",
+  TPE2: "albumArtist",
+  TALB: "album",
+  TRCK: "track",
+  TPOS: "disc",
+  TCON: "genre",
+  TDRC: "date",
+  TYER: "date",
+  TCOP: "copyright",
+  TSSE: "encoder",
+  TT2: "title",
+  TP1: "artist",
+  TP2: "albumArtist",
+  TAL: "album",
+  TRK: "track",
+  TPA: "disc",
+  TCO: "genre",
+  TYE: "date",
+  TCR: "copyright",
+  TEN: "encoder"
+};
+function synchsafe(r, offset) {
+  let value = 0;
+  for (let i = 0; i < 4; i++) {
+    const b = r.u8(offset + i);
+    if (b & 128) throw new Error("Invalid ID3 synchsafe size");
+    value = value * 128 + b;
+  }
+  return value;
+}
+function unsync(bytes) {
+  const result = [];
+  for (let i = 0; i < bytes.length; i++) {
+    const b = bytes[i];
+    result.push(b);
+    if (b === 255 && bytes[i + 1] === 0) i++;
+  }
+  return Uint8Array.from(result);
+}
+function id3TagName(id) {
+  return names2[id] ?? id;
+}
+function id3TextEncoding(encoding, bytes) {
+  if (encoding === 0) return "latin1";
+  if (encoding === 3) return "utf-8";
+  if (encoding === 2) return "utf-16be";
+  if (encoding === 1) return bytes[0] === 254 && bytes[1] === 255 ? "utf-16be" : "utf-16le";
+  throw new Error("Invalid ID3 text encoding");
+}
+function text(bytes, encoding) {
+  return cleanText(new TextDecoder(id3TextEncoding(encoding, bytes)).decode(bytes));
+}
+function terminated(bytes, start, encoding) {
+  const width = encoding === 1 || encoding === 2 ? 2 : 1;
+  for (let i = start; i + width <= bytes.length; i += width)
+    if (bytes[i] === 0 && (width === 1 || bytes[i + 1] === 0)) return i;
+  throw new Error("Unterminated ID3 text field");
+}
+function parseId3(bytes) {
+  const input = new Reader(bytes), version = input.u8(3), flags = input.u8(5), length = synchsafe(input, 6);
+  if (![2, 3, 4].includes(version)) throw new Error("Unsupported ID3 version");
+  if (version === 2 && flags & 64) throw new Error("Compressed ID3v2.2 tag unsupported");
+  const footer = version === 4 && flags & 16 ? 10 : 0;
+  input.check(0, 10 + length + footer);
+  const payload = input.slice(10, length), r = new Reader(flags & 128 && version < 4 ? unsync(payload) : payload);
+  const nodes = [], tags = {}, pictures = [];
+  let pos = 0;
+  if (version >= 3 && flags & 64) {
+    const extended = version === 4 ? synchsafe(r, 0) : r.u32(0) + 4;
+    r.check(0, extended);
+    if (extended < (version === 3 ? 10 : 6)) throw new Error("Invalid ID3 extended header");
+    pos = extended;
+  }
+  while (pos < r.bytes.length && r.u8(pos) !== 0) {
+    const header = version === 2 ? 6 : 10, id = r.text(pos, version === 2 ? 3 : 4), size = version === 2 ? r.u24(pos + 3) : version === 4 ? synchsafe(r, pos + 4) : r.u32(pos + 4);
+    const frameFlags = version === 2 ? 0 : r.u16(pos + 8);
+    let data = r.slice(pos + header, size);
+    if (version === 4 && (flags & 128 || frameFlags & 2)) data = unsync(data);
+    const node = {
+      type: id,
+      offset: 10 + pos,
+      size: header + size,
+      data,
+      fields: { flags: frameFlags, version }
+    };
+    nodes.push(node);
+    const unsupported = version === 3 ? frameFlags & 192 : frameFlags & 12;
+    if (!unsupported && data.length) {
+      let prefix = 0;
+      if (version === 3 && frameFlags & 32) prefix++;
+      if (version === 4 && frameFlags & 64) prefix++;
+      if (version === 4 && frameFlags & 1) prefix += 4;
+      data = data.subarray(prefix);
+      if (id.startsWith("T") && id !== "TXXX" && id !== "TXX")
+        tags[id3TagName(id)] = text(data.subarray(1), data[0]);
+      else if (id === "COMM" || id === "COM") {
+        const encoding = data[0], end = terminated(data, 4, encoding), width = encoding === 1 || encoding === 2 ? 2 : 1;
+        tags.comment = text(data.subarray(end + width), encoding);
+      } else if (id === "APIC" || id === "PIC") {
+        const encoding = data[0], mimeEnd = id === "PIC" ? 4 : terminated(data, 1, 0);
+        const mime = id === "PIC" ? `image/${new Reader(data).text(1, 3) === "JPG" ? "jpeg" : new Reader(data).text(1, 3).toLowerCase()}` : text(data.subarray(1, mimeEnd), 0);
+        const typeOffset = id === "PIC" ? 4 : mimeEnd + 1, descriptionStart = typeOffset + 1, end = terminated(data, descriptionStart, encoding), width = encoding === 1 || encoding === 2 ? 2 : 1;
+        pictures.push({
+          type: data[typeOffset],
+          mime,
+          description: text(data.subarray(descriptionStart, end), encoding),
+          data: data.subarray(end + width)
+        });
+      }
+    }
+    pos += header + size;
+  }
+  if (footer && input.text(10 + length, 3) !== "3DI") throw new Error("Missing ID3 footer");
+  return { size: 10 + length + footer, nodes, tags, pictures, version };
+}
+function syncBytes(value) {
+  if (value > 268435455) throw new Error("ID3 tag too large");
+  return Uint8Array.from([
+    value >>> 21 & 127,
+    value >>> 14 & 127,
+    value >>> 7 & 127,
+    value & 127
+  ]);
+}
+function encodeId3(tags, retained = [], pictures = []) {
+  const frames = [];
+  function frame(id, data) {
+    frames.push(join([ascii(id), syncBytes(data.length), new Uint8Array(2), data]));
+  }
+  for (const node of retained) {
+    const flags = Number(node.fields?.flags ?? 0);
+    if (flags & (node.fields?.version === 3 ? 192 : 12)) {
+      throw new Error(`Cannot safely rewrite transformed ID3 frame ${node.type}`);
+    }
+    if (node.type === "APIC" || node.type === "PIC" || names2[node.type] || node.type.startsWith("T") && node.type !== "TXXX" && node.type !== "TXX" || node.type === "COMM" || node.type === "COM")
+      continue;
+    if (node.type.length === 4 && !node.fields?.flags) frame(node.type, node.data);
+    else throw new Error(`Cannot safely rewrite ID3 frame ${node.type}`);
+  }
+  for (const [name, value] of Object.entries(tags)) {
+    const id = Object.keys(names2).find((key) => key.length === 4 && names2[key] === name) ?? name;
+    if (name === "comment")
+      frame(
+        "COMM",
+        join([
+          new Uint8Array([3]),
+          ascii("eng"),
+          new Uint8Array(1),
+          new TextEncoder().encode(value)
+        ])
+      );
+    else {
+      if (id.length !== 4 || !id.startsWith("T")) throw new Error(`Unsupported ID3 tag ${name}`);
+      frame(id, join([new Uint8Array([3]), new TextEncoder().encode(value)]));
+    }
+  }
+  for (const picture of pictures)
+    frame(
+      "APIC",
+      join([
+        new Uint8Array([3]),
+        ascii(picture.mime),
+        new Uint8Array([0, picture.type]),
+        new TextEncoder().encode(picture.description),
+        new Uint8Array(1),
+        picture.data
+      ])
+    );
+  const body = join(frames);
+  return join([ascii("ID3"), new Uint8Array([4, 0, 0]), syncBytes(body.length), body]);
+}
+function parseId3v1(bytes) {
+  const r = new Reader(bytes), tags = {};
+  for (const [name, offset, size] of [
+    ["title", 3, 30],
+    ["artist", 33, 30],
+    ["album", 63, 30],
+    ["date", 93, 4],
+    ["comment", 97, 30]
+  ])
+    tags[name] = cleanText(r.text(offset, size));
+  if (r.u8(125) === 0 && r.u8(126) !== 0) {
+    tags.track = String(r.u8(126));
+    tags.comment = cleanText(r.text(97, 28));
+  }
+  tags.genre = String(r.u8(127));
+  return tags;
+}
+
+// packages/audio-ast/src/id3-source.ts
+var Cursor = class {
+  constructor(source, position, end, unsynchronized, options) {
+    this.source = source;
+    this.position = position;
+    this.end = end;
+    this.unsynchronized = unsynchronized;
+    this.options = options;
+    if (!Number.isSafeInteger(source.size) || source.size < 0 || !Number.isSafeInteger(position) || !Number.isSafeInteger(end) || position < 0 || end < position || end > source.size)
+      throw new Error("Truncated or invalid audio structure");
+  }
+  source;
+  position;
+  end;
+  unsynchronized;
+  options;
+  cache = new Uint8Array();
+  cacheOffset = 0;
+  async fill() {
+    this.options.signal?.throwIfAborted();
+    if (this.position >= this.end) throw new Error("Truncated or invalid audio structure");
+    if (this.position >= this.cacheOffset && this.position < this.cacheOffset + this.cache.length) return;
+    await this.options.checkpoint?.();
+    this.options.signal?.throwIfAborted();
+    const length = Math.min(16384, this.end - this.position);
+    const bytes = await this.source.read(this.position, length);
+    this.options.signal?.throwIfAborted();
+    if (bytes.length !== length) throw new Error("Truncated or invalid audio structure");
+    this.cache = bytes.slice();
+    this.cacheOffset = this.position;
+  }
+  async read(length, partial = false) {
+    if (!Number.isSafeInteger(length) || length < 0 || length > 16384) throw new Error("Invalid ID3 header read");
+    this.options.signal?.throwIfAborted();
+    const result = new Uint8Array(length);
+    let count = 0;
+    while (count < length && this.position < this.end) {
+      await this.fill();
+      if (!this.unsynchronized) {
+        const size = Math.min(length - count, this.cacheOffset + this.cache.length - this.position);
+        result.set(this.cache.subarray(this.position - this.cacheOffset, this.position - this.cacheOffset + size), count);
+        count += size;
+        this.position += size;
+      } else {
+        while (count < length && this.position < this.cacheOffset + this.cache.length) {
+          const byte = this.cache[this.position++ - this.cacheOffset];
+          result[count++] = byte;
+          if (byte === 255 && this.position < this.end) {
+            if (this.position === this.cacheOffset + this.cache.length) await this.fill();
+            if (this.cache[this.position - this.cacheOffset] === 0) this.position++;
+          }
+        }
+      }
+    }
+    if (!partial && count !== length) throw new Error("Truncated or invalid audio structure");
+    return result.subarray(0, count);
+  }
+  async skip(length, partial = false) {
+    this.options.signal?.throwIfAborted();
+    if (!Number.isSafeInteger(length) || length < 0) throw new Error("Truncated or invalid audio structure");
+    if (!this.unsynchronized) {
+      if (!partial && length > this.end - this.position) throw new Error("Truncated or invalid audio structure");
+      this.position += Math.min(length, this.end - this.position);
+      return;
+    }
+    while (length && this.position < this.end) {
+      const bytes = await this.read(Math.min(length, 16384), partial);
+      length -= bytes.length;
+    }
+    if (length && !partial) throw new Error("Truncated or invalid audio structure");
+  }
+  async terminated(start, encoding) {
+    const width = encoding === 1 || encoding === 2 ? 2 : 1;
+    await this.skip(start, true);
+    while (this.position < this.end) {
+      const bytes = await this.read(width, true);
+      if (bytes.length < width) break;
+      if (bytes[0] === 0 && (width === 1 || bytes[1] === 0)) return;
+    }
+    throw new Error("Unterminated ID3 text field");
+  }
+};
+async function* readId3Text(source, span, options = {}) {
+  const cursor = new Cursor(source, span.offset, span.offset + span.length, span.unsynchronized, options);
+  const first = await cursor.read(Math.min(2, span.length), true);
+  const decoder = new TextDecoder(id3TextEncoding(span.encoding, first));
+  yield decoder.decode(first, { stream: true });
+  while (cursor.position < cursor.end) yield decoder.decode(await cursor.read(16384, true), { stream: true });
+  options.signal?.throwIfAborted();
+  yield decoder.decode();
+}
+async function probeId3Source(source, options = {}) {
+  const input = new Cursor(source, 0, source.size, false, options), header = new Reader(await input.read(10));
+  const version = header.u8(3), flags = header.u8(5), length = synchsafe(header, 6);
+  if (![2, 3, 4].includes(version)) throw new Error("Unsupported ID3 version");
+  if (version === 2 && flags & 64) throw new Error("Compressed ID3v2.2 tag unsupported");
+  const footer = version === 4 && flags & 16 ? 10 : 0, size = 10 + length + footer;
+  if (size > source.size) throw new Error("Truncated or invalid audio structure");
+  const cursor = new Cursor(source, 10, 10 + length, !!(flags & 128 && version < 4), options), tags = {};
+  if (version >= 3 && flags & 64) {
+    const prefix = new Reader(await cursor.read(4)), extended = version === 4 ? synchsafe(prefix, 0) : prefix.u32(0) + 4;
+    if (extended >= 4) await cursor.skip(extended - 4);
+    if (extended < (version === 3 ? 10 : 6)) throw new Error("Invalid ID3 extended header");
+  }
+  while (cursor.position < cursor.end) {
+    options.signal?.throwIfAborted();
+    await options.checkpoint?.();
+    const first = await cursor.read(1);
+    if (first[0] === 0) break;
+    const headerSize = version === 2 ? 6 : 10, bytes = new Uint8Array(headerSize);
+    bytes.set(first);
+    bytes.set(await cursor.read(headerSize - 1), 1);
+    const r = new Reader(bytes), id = r.text(0, version === 2 ? 3 : 4);
+    const frameSize = version === 2 ? r.u24(3) : version === 4 ? synchsafe(r, 4) : r.u32(4), frameFlags = version === 2 ? 0 : r.u16(8);
+    const offset = cursor.position;
+    await cursor.skip(frameSize);
+    const frame = new Cursor(source, offset, cursor.position, cursor.unsynchronized || !!(version === 4 && (flags & 128 || frameFlags & 2)), options);
+    const unsupported = version === 3 ? frameFlags & 192 : frameFlags & 12;
+    if (unsupported || !frameSize) continue;
+    let prefix = 0;
+    if (version === 3 && frameFlags & 32) prefix++;
+    if (version === 4 && frameFlags & 64) prefix++;
+    if (version === 4 && frameFlags & 1) prefix += 4;
+    await frame.skip(prefix, true);
+    let key, encoding;
+    if (id.startsWith("T") && id !== "TXXX" && id !== "TXX") {
+      key = id3TagName(id);
+      encoding = (await frame.read(1, true))[0];
+    } else if (id === "COMM" || id === "COM") {
+      encoding = (await frame.read(1, true))[0];
+      await frame.terminated(3, encoding);
+      key = "comment";
+    } else if (id === "APIC" || id === "PIC") {
+      encoding = (await frame.read(1, true))[0];
+      if (id === "PIC") await frame.read(3);
+      else await frame.terminated(0, 0);
+      await frame.skip(1, true);
+      await frame.terminated(0, encoding);
+      id3TextEncoding(encoding, new Uint8Array());
+    }
+    if (key !== void 0) {
+      id3TextEncoding(encoding, new Uint8Array());
+      const span = { key, offset: frame.position, length: frame.end - frame.position, unsynchronized: frame.unsynchronized, encoding };
+      if (options.onTag) {
+        await options.onTag(span);
+        options.signal?.throwIfAborted();
+      } else {
+        let value = "";
+        for await (const text2 of readId3Text(source, span, options)) value += text2;
+        tags[key] = cleanText(value);
+      }
+    }
+  }
+  if (footer) {
+    const tail = new Cursor(source, 10 + length, size, false, options);
+    if (new Reader(await tail.read(3)).text(0, 3) !== "3DI") throw new Error("Missing ID3 footer");
+  }
+  options.signal?.throwIfAborted();
+  return { size, version, tags };
+}
+
+// packages/audio-ast/src/mpeg.ts
+function mpegFrame(header, offset, end) {
+  const versionBits = header >>> 19 & 3, layer = header >>> 17 & 3, bitrateIndex = header >>> 12 & 15, rateIndex = header >>> 10 & 3;
+  if (header >>> 21 !== 2047 || versionBits === 1 || layer !== 1 || !bitrateIndex || bitrateIndex === 15 || rateIndex === 3)
+    throw new Error(`Invalid MPEG Layer III frame at ${offset}`);
+  const version = versionBits === 3 ? 1 : versionBits === 2 ? 2 : 2.5;
+  const rate = [44100, 48e3, 32e3][rateIndex] / (version === 1 ? 1 : version === 2 ? 2 : 4);
+  const bitrate = (version === 1 ? [0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320] : [0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160])[bitrateIndex] * 1e3;
+  const count = version === 1 ? 1152 : 576, frameSize = Math.floor((version === 1 ? 144 : 72) * bitrate / rate) + (header >>> 9 & 1), ch = header >>> 6 & 3;
+  if (frameSize > end - offset) throw new Error("Truncated MPEG frame");
+  const channels = ch === 3 ? 1 : 2;
+  const fields = {
+    version,
+    layer: 3,
+    bitrate,
+    sampleRate: rate,
+    channels,
+    samples: count,
+    padding: header >>> 9 & 1
+  };
+  return { version, rate, count, frameSize, channels, fields };
+}
+function mpegVbr(r, offset, frameSize, header, fields) {
+  const version = Number(fields.version), channels = Number(fields.channels);
+  const side = version === 1 ? channels === 1 ? 17 : 32 : channels === 1 ? 9 : 17, crc = header & 65536 ? 0 : 2;
+  const xing = offset + 4 + crc + side;
+  if (xing + 8 <= offset + frameSize && ["Xing", "Info"].includes(r.text(xing, 4))) {
+    const flags = r.u32(xing + 4);
+    let pos = xing + 8;
+    const vbr = { type: r.text(xing, 4), flags };
+    if (flags & 1) {
+      vbr.frames = r.u32(pos);
+      pos += 4;
+    }
+    if (flags & 2) {
+      vbr.bytes = r.u32(pos);
+      pos += 4;
+    }
+    if (flags & 4) {
+      vbr.toc = r.slice(pos, 100);
+      pos += 100;
+    }
+    if (flags & 8) {
+      vbr.quality = r.u32(pos);
+      pos += 4;
+    }
+    if (pos > offset + frameSize) throw new Error("Xing header exceeds frame");
+    fields.vbr = vbr;
+    if (pos + 24 <= offset + frameSize && ["LAME", "Lavc", "Lavf"].includes(r.text(pos, 4))) {
+      const packed = r.u24(pos + 21);
+      fields.encoderDelay = packed >>> 12;
+      fields.encoderPadding = packed & 4095;
+    }
+  }
+  const vbri = offset + 36;
+  if (vbri + 26 <= offset + frameSize && r.text(vbri, 4) === "VBRI")
+    fields.vbr = {
+      type: "VBRI",
+      version: r.u16(vbri + 4),
+      delay: r.u16(vbri + 6),
+      quality: r.u16(vbri + 8),
+      bytes: r.u32(vbri + 10),
+      frames: r.u32(vbri + 14),
+      entries: r.u16(vbri + 18),
+      scale: r.u16(vbri + 20),
+      entryBytes: r.u16(vbri + 22),
+      framesPerEntry: r.u16(vbri + 24)
+    };
+}
+function mpegStream(state, first) {
+  let { samples, seconds: seconds2, audioBytes } = state;
+  const { sampleRate, channels, frames } = state;
+  if (!frames) throw new Error("MP3 contains no MPEG frames");
+  const vbr = first.fields?.vbr;
+  const declared = vbr?.frames;
+  if (typeof declared === "number" && declared > 0) {
+    if (declared !== frames && declared !== frames - 1)
+      throw new Error("MPEG VBR frame count mismatch");
+    const encodedSamples = declared * (sampleRate >= 32e3 ? 1152 : 576);
+    const delay = Number(first.fields?.encoderDelay ?? 0), padding = Number(first.fields?.encoderPadding ?? 0);
+    if (delay + padding > encodedSamples) throw new Error("Invalid MPEG encoder delay/padding");
+    samples = encodedSamples - delay - padding;
+    seconds2 = duration(samples, sampleRate);
+    if (declared === frames - 1) audioBytes -= first.size;
+    first.fields.encodedSamples = encodedSamples;
+  }
+  const encodedSeconds = duration(Number(first.fields?.encodedSamples ?? samples), sampleRate);
+  const bitrate = encodedSeconds ? audioBytes * 8 / encodedSeconds : 0;
+  return { codec: "mp3", sampleRate, channels, samples, duration: seconds2, bitrate };
+}
+
+// packages/audio-ast/src/mp3-source.ts
+async function probeMp3Source(source, options = {}) {
+  const read = async (offset2, length) => {
+    options.signal?.throwIfAborted();
+    if (!Number.isSafeInteger(source.size) || source.size < 0 || offset2 < 0 || length < 0 || length > source.size - offset2)
+      throw new Error("Truncated or invalid audio structure");
+    const bytes = await source.read(offset2, length);
+    options.signal?.throwIfAborted();
+    if (bytes.length !== length) throw new Error("Truncated or invalid audio structure");
+    return new Reader(bytes);
+  };
+  const marker = (await read(0, 3)).text(0, 3);
+  let end = source.size, offset = 0;
+  const tags = {};
+  if (end >= 128) {
+    const tail = await read(end - 128, 128);
+    if (tail.text(0, 3) === "TAG") {
+      const values = parseId3v1(tail.bytes);
+      end -= 128;
+      if (options.onTag) for (const [key, value] of Object.entries(values)) {
+        await options.onTag({ key, value });
+        options.signal?.throwIfAborted();
+      }
+      else Object.assign(tags, values);
+    }
+  }
+  if (marker === "ID3") {
+    const id3 = await probeId3Source(source, { ...options, ...options.onTag ? { onTag: options.onTag } : {} });
+    offset = id3.size;
+    Object.assign(tags, id3.tags);
+  }
+  let samples = 0, seconds2 = 0, audioBytes = 0, sampleRate = 0, channels = 0, frames = 0;
+  let firstOffset = 0;
+  let first = { size: 0, fields: {} };
+  while (offset < end) {
+    await options.checkpoint?.();
+    options.signal?.throwIfAborted();
+    const header = (await read(offset, 4)).u32(0), frame = mpegFrame(header, offset, end);
+    if (sampleRate && (sampleRate !== frame.rate || channels !== frame.channels)) throw new Error("Inconsistent MPEG stream");
+    sampleRate = frame.rate;
+    channels = frame.channels;
+    if (!frames) {
+      const metadata = await read(offset, Math.min(192, source.size - offset));
+      mpegVbr(new Reader(metadata.bytes.slice()), 0, frame.frameSize, header, frame.fields);
+      first = { size: frame.frameSize, fields: frame.fields };
+      firstOffset = offset;
+    }
+    samples += frame.count;
+    seconds2 += duration(frame.count, frame.rate);
+    audioBytes += frame.frameSize;
+    frames++;
+    offset += frame.frameSize;
+  }
+  options.signal?.throwIfAborted();
+  const stream = mpegStream({ samples, seconds: seconds2, audioBytes, sampleRate, channels, frames }, first);
+  return { format: "mp3", nodes: [{ type: "MPEG", offset: firstOffset, size: first.size, data: new Uint8Array(), fields: first.fields }], streams: [stream], tags, duration: stream.duration, bitrate: stream.duration ? source.size * 8 / stream.duration : 0 };
+}
+
+// packages/audio-ast/src/flac.ts
+function parseFlac(bytes) {
+  const r = new Reader(bytes), nodes = [], pictures = [];
+  const tags = {};
+  let offset = 4, last = false, stream;
+  while (!last) {
+    const header = r.u8(offset), type = header & 127, size = r.u24(offset + 1);
+    last = !!(header & 128);
+    const data = r.slice(offset + 4, size), node = {
+      type: [
+        "STREAMINFO",
+        "PADDING",
+        "APPLICATION",
+        "SEEKTABLE",
+        "VORBIS_COMMENT",
+        "CUESHEET",
+        "PICTURE"
+      ][type] ?? `BLOCK_${type}`,
+      offset,
+      size: size + 4,
+      data
+    };
+    nodes.push(node);
+    const block = new Reader(data);
+    if (type === 0) {
+      if (stream || offset !== 4 || size !== 34)
+        throw new Error("FLAC requires first unique STREAMINFO");
+      stream = flacStream(block, bytes.length);
+      const { sampleRate, channels, bitsPerSample, samples } = stream;
+      node.fields = {
+        minBlockSize: block.u16(0),
+        maxBlockSize: block.u16(2),
+        minFrameSize: block.u24(4),
+        maxFrameSize: block.u24(7),
+        sampleRate,
+        channels,
+        bitsPerSample,
+        totalSamples: samples,
+        md5: Array.from(block.slice(18, 16), (b) => b.toString(16).padStart(2, "0")).join("")
+      };
+    } else if (type === 4) {
+      const parsed = parseComments(data);
+      if (parsed.size !== size) throw new Error("Trailing Vorbis comment bytes");
+      Object.assign(tags, parsed.tags);
+      node.fields = { vendor: parsed.vendor, comments: parsed.comments };
+    } else if (type === 6) pictures.push(parsePicture(data));
+    else if (type === 3) {
+      if (size % 18) throw new Error("Invalid FLAC seek table");
+      const points = [];
+      for (let pos = 0; pos < size; pos += 18)
+        points.push({
+          sample: block.u64(pos),
+          offset: block.u64(pos + 8),
+          samples: block.u16(pos + 16)
+        });
+      node.fields = { points };
+    } else if (type === 127) throw new Error("Invalid FLAC metadata block");
+    offset += 4 + size;
+  }
+  if (!stream) throw new Error("Missing FLAC STREAMINFO");
+  if (offset < bytes.length)
+    nodes.push({
+      type: "FRAMES",
+      offset,
+      size: bytes.length - offset,
+      data: r.slice(offset, bytes.length - offset)
+    });
+  return {
+    format: "flac",
+    data: bytes,
+    nodes,
+    tags,
+    pictures,
+    streams: [stream],
+    duration: stream.duration,
+    bitrate: stream.bitrate
+  };
+}
+function flacStream(block, byteLength) {
+  const packed = block.u64(10), sampleRate = Number(packed >> 44n), channels = Number(packed >> 41n & 7n) + 1, bitsPerSample = Number(packed >> 36n & 31n) + 1, samples = Number(packed & 0xfffffffffn), seconds2 = duration(samples, sampleRate);
+  return { codec: "flac", sampleRate, channels, bitsPerSample, samples, duration: seconds2, bitrate: seconds2 ? byteLength * 8 / seconds2 : 0 };
+}
+
+// packages/audio-ast/src/flac-source.ts
+async function probeFlacSource(source, options = {}) {
+  const check = (offset2, length, end = source.size) => {
+    options.signal?.throwIfAborted();
+    if (!Number.isSafeInteger(source.size) || !Number.isSafeInteger(offset2) || !Number.isSafeInteger(length) || offset2 < 0 || length < 0 || length > end - offset2)
       throw new Error("Truncated or invalid audio structure");
   };
   const read = async (offset2, length, end = source.size) => {
@@ -743,239 +1607,50 @@ function resample(pcm, sampleRate, method = "sinc") {
         }
         let sum = 0, weight = 0;
         for (let j = Math.max(0, Math.ceil(position - radius)); j <= Math.min(frames - 1, Math.floor(position + radius)); j++) {
-          const distance = position - j, x = Math.PI * distance * cutoff;
-          const w = (x === 0 ? 1 : Math.sin(x) / x) * (0.5 + 0.5 * Math.cos(Math.PI * distance / radius));
-          sum += ch[j] * w;
-          weight += w;
-        }
-        return weight ? sum / weight : 0;
-      })
-    )
-  };
-}
-function transformAudio(pcm, effects) {
-  validatePcm(pcm);
-  let result = {
-    sampleRate: pcm.sampleRate,
-    channels: pcm.channels.map((ch) => ch.slice())
-  };
-  for (const effect of effects) {
-    switch (effect.type) {
-      case "trim":
-        result = trim(result, effect.startSec, effect.durationSec);
-        break;
-      case "pad":
-        result = pad(result, effect.leadSec, effect.trailSec);
-        break;
-      case "rate":
-        result = resample(result, effect.sampleRate, effect.method);
-        break;
-      case "channels":
-        result = remix(result, effect.channels, effect.matrix);
-        break;
-      case "extract":
-        result = extractChannels(result, effect.channels);
-        break;
-      case "normalize":
-        result = normalize(result, effect.targetDb);
-        break;
-      case "fade":
-        result = fade(result, effect.inSec, effect.outSec);
-        break;
-      default:
-        throw new Error("Unsupported audio effect");
-    }
-  }
-  return result;
-}
-
-// packages/audio-ast/src/id3.ts
-var names2 = {
-  TIT2: "title",
-  TPE1: "artist",
-  TPE2: "albumArtist",
-  TALB: "album",
-  TRCK: "track",
-  TPOS: "disc",
-  TCON: "genre",
-  TDRC: "date",
-  TYER: "date",
-  TCOP: "copyright",
-  TSSE: "encoder",
-  TT2: "title",
-  TP1: "artist",
-  TP2: "albumArtist",
-  TAL: "album",
-  TRK: "track",
-  TPA: "disc",
-  TCO: "genre",
-  TYE: "date",
-  TCR: "copyright",
-  TEN: "encoder"
-};
-function synchsafe(r, offset) {
-  let value = 0;
-  for (let i = 0; i < 4; i++) {
-    const b = r.u8(offset + i);
-    if (b & 128) throw new Error("Invalid ID3 synchsafe size");
-    value = value * 128 + b;
-  }
-  return value;
-}
-function unsync(bytes) {
-  const result = [];
-  for (let i = 0; i < bytes.length; i++) {
-    const b = bytes[i];
-    result.push(b);
-    if (b === 255 && bytes[i + 1] === 0) i++;
-  }
-  return Uint8Array.from(result);
-}
-function text(bytes, encoding) {
-  if (encoding === 0) return cleanText(new TextDecoder("latin1").decode(bytes));
-  if (encoding === 3) return cleanText(new TextDecoder().decode(bytes));
-  if (encoding === 2) return cleanText(new TextDecoder("utf-16be").decode(bytes));
-  if (encoding === 1)
-    return cleanText(
-      new TextDecoder(bytes[0] === 254 && bytes[1] === 255 ? "utf-16be" : "utf-16le").decode(bytes)
-    );
-  throw new Error("Invalid ID3 text encoding");
-}
-function terminated(bytes, start, encoding) {
-  const width = encoding === 1 || encoding === 2 ? 2 : 1;
-  for (let i = start; i + width <= bytes.length; i += width)
-    if (bytes[i] === 0 && (width === 1 || bytes[i + 1] === 0)) return i;
-  throw new Error("Unterminated ID3 text field");
-}
-function parseId3(bytes) {
-  const input = new Reader(bytes), version = input.u8(3), flags = input.u8(5), length = synchsafe(input, 6);
-  if (![2, 3, 4].includes(version)) throw new Error("Unsupported ID3 version");
-  if (version === 2 && flags & 64) throw new Error("Compressed ID3v2.2 tag unsupported");
-  const footer = version === 4 && flags & 16 ? 10 : 0;
-  input.check(0, 10 + length + footer);
-  const payload = input.slice(10, length), r = new Reader(flags & 128 && version < 4 ? unsync(payload) : payload);
-  const nodes = [], tags = {}, pictures = [];
-  let pos = 0;
-  if (version >= 3 && flags & 64) {
-    const extended = version === 4 ? synchsafe(r, 0) : r.u32(0) + 4;
-    r.check(0, extended);
-    if (extended < (version === 3 ? 10 : 6)) throw new Error("Invalid ID3 extended header");
-    pos = extended;
-  }
-  while (pos < r.bytes.length && r.u8(pos) !== 0) {
-    const header = version === 2 ? 6 : 10, id = r.text(pos, version === 2 ? 3 : 4), size = version === 2 ? r.u24(pos + 3) : version === 4 ? synchsafe(r, pos + 4) : r.u32(pos + 4);
-    const frameFlags = version === 2 ? 0 : r.u16(pos + 8);
-    let data = r.slice(pos + header, size);
-    if (version === 4 && (flags & 128 || frameFlags & 2)) data = unsync(data);
-    const node = {
-      type: id,
-      offset: 10 + pos,
-      size: header + size,
-      data,
-      fields: { flags: frameFlags, version }
-    };
-    nodes.push(node);
-    const unsupported = version === 3 ? frameFlags & 192 : frameFlags & 12;
-    if (!unsupported && data.length) {
-      let prefix = 0;
-      if (version === 3 && frameFlags & 32) prefix++;
-      if (version === 4 && frameFlags & 64) prefix++;
-      if (version === 4 && frameFlags & 1) prefix += 4;
-      data = data.subarray(prefix);
-      if (id.startsWith("T") && id !== "TXXX" && id !== "TXX")
-        tags[names2[id] ?? id] = text(data.subarray(1), data[0]);
-      else if (id === "COMM" || id === "COM") {
-        const encoding = data[0], end = terminated(data, 4, encoding), width = encoding === 1 || encoding === 2 ? 2 : 1;
-        tags.comment = text(data.subarray(end + width), encoding);
-      } else if (id === "APIC" || id === "PIC") {
-        const encoding = data[0], mimeEnd = id === "PIC" ? 4 : terminated(data, 1, 0);
-        const mime = id === "PIC" ? `image/${new Reader(data).text(1, 3) === "JPG" ? "jpeg" : new Reader(data).text(1, 3).toLowerCase()}` : text(data.subarray(1, mimeEnd), 0);
-        const typeOffset = id === "PIC" ? 4 : mimeEnd + 1, descriptionStart = typeOffset + 1, end = terminated(data, descriptionStart, encoding), width = encoding === 1 || encoding === 2 ? 2 : 1;
-        pictures.push({
-          type: data[typeOffset],
-          mime,
-          description: text(data.subarray(descriptionStart, end), encoding),
-          data: data.subarray(end + width)
-        });
-      }
-    }
-    pos += header + size;
-  }
-  if (footer && input.text(10 + length, 3) !== "3DI") throw new Error("Missing ID3 footer");
-  return { size: 10 + length + footer, nodes, tags, pictures, version };
-}
-function syncBytes(value) {
-  if (value > 268435455) throw new Error("ID3 tag too large");
-  return Uint8Array.from([
-    value >>> 21 & 127,
-    value >>> 14 & 127,
-    value >>> 7 & 127,
-    value & 127
-  ]);
-}
-function encodeId3(tags, retained = [], pictures = []) {
-  const frames = [];
-  function frame(id, data) {
-    frames.push(join([ascii(id), syncBytes(data.length), new Uint8Array(2), data]));
-  }
-  for (const node of retained) {
-    const flags = Number(node.fields?.flags ?? 0);
-    if (flags & (node.fields?.version === 3 ? 192 : 12)) {
-      throw new Error(`Cannot safely rewrite transformed ID3 frame ${node.type}`);
-    }
-    if (node.type === "APIC" || node.type === "PIC" || names2[node.type] || node.type.startsWith("T") && node.type !== "TXXX" && node.type !== "TXX" || node.type === "COMM" || node.type === "COM")
-      continue;
-    if (node.type.length === 4 && !node.fields?.flags) frame(node.type, node.data);
-    else throw new Error(`Cannot safely rewrite ID3 frame ${node.type}`);
-  }
-  for (const [name, value] of Object.entries(tags)) {
-    const id = Object.keys(names2).find((key) => key.length === 4 && names2[key] === name) ?? name;
-    if (name === "comment")
-      frame(
-        "COMM",
-        join([
-          new Uint8Array([3]),
-          ascii("eng"),
-          new Uint8Array(1),
-          new TextEncoder().encode(value)
-        ])
-      );
-    else {
-      if (id.length !== 4 || !id.startsWith("T")) throw new Error(`Unsupported ID3 tag ${name}`);
-      frame(id, join([new Uint8Array([3]), new TextEncoder().encode(value)]));
-    }
-  }
-  for (const picture of pictures)
-    frame(
-      "APIC",
-      join([
-        new Uint8Array([3]),
-        ascii(picture.mime),
-        new Uint8Array([0, picture.type]),
-        new TextEncoder().encode(picture.description),
-        new Uint8Array(1),
-        picture.data
-      ])
-    );
-  const body = join(frames);
-  return join([ascii("ID3"), new Uint8Array([4, 0, 0]), syncBytes(body.length), body]);
+          const distance = position - j, x = Math.PI * distance * cutoff;
+          const w = (x === 0 ? 1 : Math.sin(x) / x) * (0.5 + 0.5 * Math.cos(Math.PI * distance / radius));
+          sum += ch[j] * w;
+          weight += w;
+        }
+        return weight ? sum / weight : 0;
+      })
+    )
+  };
 }
-function parseId3v1(bytes) {
-  const r = new Reader(bytes), tags = {};
-  for (const [name, offset, size] of [
-    ["title", 3, 30],
-    ["artist", 33, 30],
-    ["album", 63, 30],
-    ["date", 93, 4],
-    ["comment", 97, 30]
-  ])
-    tags[name] = cleanText(r.text(offset, size));
-  if (r.u8(125) === 0 && r.u8(126) !== 0) {
-    tags.track = String(r.u8(126));
-    tags.comment = cleanText(r.text(97, 28));
+function transformAudio(pcm, effects) {
+  validatePcm(pcm);
+  let result = {
+    sampleRate: pcm.sampleRate,
+    channels: pcm.channels.map((ch) => ch.slice())
+  };
+  for (const effect of effects) {
+    switch (effect.type) {
+      case "trim":
+        result = trim(result, effect.startSec, effect.durationSec);
+        break;
+      case "pad":
+        result = pad(result, effect.leadSec, effect.trailSec);
+        break;
+      case "rate":
+        result = resample(result, effect.sampleRate, effect.method);
+        break;
+      case "channels":
+        result = remix(result, effect.channels, effect.matrix);
+        break;
+      case "extract":
+        result = extractChannels(result, effect.channels);
+        break;
+      case "normalize":
+        result = normalize(result, effect.targetDb);
+        break;
+      case "fade":
+        result = fade(result, effect.inSec, effect.outSec);
+        break;
+      default:
+        throw new Error("Unsupported audio effect");
+    }
   }
-  tags.genre = String(r.u8(127));
-  return tags;
+  return result;
 }
 
 // packages/audio-ast/src/mp3.ts
@@ -1003,27 +1678,11 @@ function parseMp3(bytes) {
   }
   let samples = 0, seconds2 = 0, audioBytes = 0, sampleRate = 0, channels = 0, frames = 0;
   while (offset < end) {
-    const header = r.u32(offset), versionBits = header >>> 19 & 3, layer = header >>> 17 & 3, bitrateIndex = header >>> 12 & 15, rateIndex = header >>> 10 & 3;
-    if (header >>> 21 !== 2047 || versionBits === 1 || layer !== 1 || !bitrateIndex || bitrateIndex === 15 || rateIndex === 3)
-      throw new Error(`Invalid MPEG Layer III frame at ${offset}`);
-    const version = versionBits === 3 ? 1 : versionBits === 2 ? 2 : 2.5;
-    const rate = [44100, 48e3, 32e3][rateIndex] / (version === 1 ? 1 : version === 2 ? 2 : 4);
-    const bitrate2 = (version === 1 ? [0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320] : [0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160])[bitrateIndex] * 1e3;
-    const count = version === 1 ? 1152 : 576, frameSize = Math.floor((version === 1 ? 144 : 72) * bitrate2 / rate) + (header >>> 9 & 1), ch = header >>> 6 & 3;
-    if (frameSize > end - offset) throw new Error("Truncated MPEG frame");
-    if (sampleRate && (sampleRate !== rate || channels !== (ch === 3 ? 1 : 2)))
-      throw new Error("Inconsistent MPEG stream");
+    const header = r.u32(offset), frame = mpegFrame(header, offset, end);
+    const { rate, count, frameSize, fields } = frame;
+    if (sampleRate && (sampleRate !== rate || channels !== frame.channels)) throw new Error("Inconsistent MPEG stream");
     sampleRate = rate;
-    channels = ch === 3 ? 1 : 2;
-    const fields = {
-      version,
-      layer: 3,
-      bitrate: bitrate2,
-      sampleRate: rate,
-      channels,
-      samples: count,
-      padding: header >>> 9 & 1
-    };
+    channels = frame.channels;
     const node = {
       type: "MPEG",
       offset,
@@ -1032,288 +1691,24 @@ function parseMp3(bytes) {
       fields
     };
     nodes.push(node);
-    if (!frames) {
-      const side = version === 1 ? channels === 1 ? 17 : 32 : channels === 1 ? 9 : 17, crc = header & 65536 ? 0 : 2;
-      const xing = offset + 4 + crc + side;
-      if (xing + 8 <= offset + frameSize && ["Xing", "Info"].includes(r.text(xing, 4))) {
-        const flags = r.u32(xing + 4);
-        let pos = xing + 8;
-        const vbr2 = { type: r.text(xing, 4), flags };
-        if (flags & 1) {
-          vbr2.frames = r.u32(pos);
-          pos += 4;
-        }
-        if (flags & 2) {
-          vbr2.bytes = r.u32(pos);
-          pos += 4;
-        }
-        if (flags & 4) {
-          vbr2.toc = r.slice(pos, 100);
-          pos += 100;
-        }
-        if (flags & 8) {
-          vbr2.quality = r.u32(pos);
-          pos += 4;
-        }
-        if (pos > offset + frameSize) throw new Error("Xing header exceeds frame");
-        fields.vbr = vbr2;
-        if (pos + 24 <= offset + frameSize && ["LAME", "Lavc", "Lavf"].includes(r.text(pos, 4))) {
-          const packed = r.u24(pos + 21);
-          fields.encoderDelay = packed >>> 12;
-          fields.encoderPadding = packed & 4095;
-        }
-      }
-      const vbri = offset + 36;
-      if (vbri + 26 <= offset + frameSize && r.text(vbri, 4) === "VBRI")
-        fields.vbr = {
-          type: "VBRI",
-          version: r.u16(vbri + 4),
-          delay: r.u16(vbri + 6),
-          quality: r.u16(vbri + 8),
-          bytes: r.u32(vbri + 10),
-          frames: r.u32(vbri + 14),
-          entries: r.u16(vbri + 18),
-          scale: r.u16(vbri + 20),
-          entryBytes: r.u16(vbri + 22),
-          framesPerEntry: r.u16(vbri + 24)
-        };
-    }
+    if (!frames) mpegVbr(r, offset, frameSize, header, fields);
     samples += count;
     seconds2 += duration(count, rate);
     audioBytes += frameSize;
     frames++;
     offset += frameSize;
   }
-  if (!frames) throw new Error("MP3 contains no MPEG frames");
-  const first = nodes.find((n) => n.type === "MPEG"), vbr = first.fields?.vbr;
-  const declared = vbr?.frames;
-  if (typeof declared === "number" && declared > 0) {
-    if (declared !== frames && declared !== frames - 1)
-      throw new Error("MPEG VBR frame count mismatch");
-    const encodedSamples = declared * (sampleRate >= 32e3 ? 1152 : 576);
-    const delay = Number(first.fields?.encoderDelay ?? 0), padding = Number(first.fields?.encoderPadding ?? 0);
-    if (delay + padding > encodedSamples) throw new Error("Invalid MPEG encoder delay/padding");
-    samples = encodedSamples - delay - padding;
-    seconds2 = duration(samples, sampleRate);
-    if (declared === frames - 1) audioBytes -= first.size;
-    first.fields.encodedSamples = encodedSamples;
-  }
-  const encodedSeconds = duration(Number(first.fields?.encodedSamples ?? samples), sampleRate);
-  const bitrate = encodedSeconds ? audioBytes * 8 / encodedSeconds : 0;
+  const first = nodes.find((n) => n.type === "MPEG");
+  const stream = mpegStream({ samples, seconds: seconds2, audioBytes, sampleRate, channels, frames }, { size: first?.size ?? 0, fields: first?.fields ?? {} });
   return {
     format: "mp3",
     data: bytes,
     nodes,
     tags,
     pictures,
-    streams: [{ codec: "mp3", sampleRate, channels, samples, duration: seconds2, bitrate }],
-    duration: seconds2,
-    bitrate: seconds2 ? bytes.length * 8 / seconds2 : 0
-  };
-}
-
-// packages/audio-ast/src/ogg.ts
-function oggCrc(bytes) {
-  let crc = 0;
-  for (let i = 0; i < bytes.length; i++) {
-    crc ^= (i >= 22 && i < 26 ? 0 : bytes[i]) << 24;
-    for (let bit = 0; bit < 8; bit++) crc = crc << 1 ^ (crc & 2147483648 ? 79764919 : 0);
-  }
-  return crc >>> 0;
-}
-function readOgg(bytes) {
-  const r = new Reader(bytes), nodes = [], packets = [], logical = /* @__PURE__ */ new Map();
-  for (let offset = 0; offset < bytes.length; ) {
-    if (r.text(offset, 4) !== "OggS" || r.u8(offset + 4) !== 0) throw new Error("Invalid Ogg page");
-    const flags = r.u8(offset + 5), granule = r.u64(offset + 6, true), serial = r.u32(offset + 14, true), sequence = r.u32(offset + 18, true), count = r.u8(offset + 26), laces = r.slice(offset + 27, count);
-    if (flags & ~7) throw new Error("Invalid Ogg page flags");
-    const size = 27 + count + laces.reduce((sum, n) => sum + n, 0), page = r.slice(offset, size);
-    if (oggCrc(page) !== r.u32(offset + 22, true)) throw new Error("Ogg checksum mismatch");
-    let state = logical.get(serial);
-    if (!state) {
-      if (!(flags & 2) || sequence !== 0) throw new Error("Missing Ogg beginning-of-stream");
-      state = { packets: [], pending: [], sequence: -1, ended: false };
-      logical.set(serial, state);
-    }
-    if (state.ended || sequence !== state.sequence + 1 >>> 0 || !!(flags & 1) !== !!state.pending.length)
-      throw new Error("Invalid Ogg sequence/continuation");
-    state.sequence = sequence;
-    const completed = [];
-    let pos = offset + 27 + count;
-    for (const lace of laces) {
-      state.pending.push(r.slice(pos, lace));
-      pos += lace;
-      if (lace < 255) {
-        const packet = {
-          data: join(state.pending),
-          serial,
-          granule: 0xffffffffffffffffn,
-          bos: state.packets.length === 0,
-          eos: false
-        };
-        state.pending = [];
-        state.packets.push(packet);
-        packets.push(packet);
-        completed.push(packet);
-      }
-    }
-    if (completed.length) {
-      completed[completed.length - 1].granule = granule;
-      if (flags & 4) completed[completed.length - 1].eos = true;
-    }
-    if (flags & 4) {
-      if (state.pending.length) throw new Error("Incomplete final Ogg packet");
-      state.ended = true;
-    }
-    nodes.push({
-      type: "OggS",
-      offset,
-      size,
-      data: page,
-      fields: {
-        flags,
-        granule,
-        serial,
-        sequence,
-        checksum: r.u32(offset + 22, true),
-        lacing: laces
-      }
-    });
-    offset += size;
-  }
-  if (!logical.size || Array.from(logical.values()).some((s) => s.pending.length || !s.ended))
-    throw new Error("Incomplete Ogg stream");
-  return { nodes, packets };
-}
-function encodeOgg(packets) {
-  const pages = [], sequences = /* @__PURE__ */ new Map(), pending = /* @__PURE__ */ new Map();
-  for (const packet of packets) {
-    const group = pending.get(packet.serial) ?? [];
-    group.push(packet);
-    pending.set(packet.serial, group);
-    if (packet.granule === 0xffffffffffffffffn && !packet.eos) continue;
-    const laces = [], granules = [], boundaries = /* @__PURE__ */ new Set();
-    for (const item of group) {
-      for (let j = 0; j < Math.floor(item.data.length / 255); j++) {
-        laces.push(255);
-        granules.push(0xffffffffffffffffn);
-      }
-      laces.push(item.data.length % 255);
-      granules.push(item.granule);
-      boundaries.add(laces.length);
-    }
-    const body = join(group.map((p) => p.data));
-    let offset = 0;
-    for (let start = 0; start < laces.length; start += 255) {
-      const part = laces.slice(start, start + 255), last = start + 255 >= laces.length, size = part.reduce((a, b) => a + b, 0), header = new Uint8Array(27 + part.length), v = new DataView(header.buffer);
-      header.set(ascii("OggS"));
-      header[5] = (start && !boundaries.has(start) ? 1 : 0) | (group[0].bos && start === 0 ? 2 : 0) | (packet.eos && last ? 4 : 0);
-      let granule = 0xffffffffffffffffn;
-      for (let i = start; i < start + part.length; i++)
-        if (laces[i] < 255) granule = granules[i] === 0xffffffffffffffffn ? 0n : granules[i];
-      v.setBigUint64(6, granule, true);
-      v.setUint32(14, packet.serial, true);
-      const sequence = sequences.get(packet.serial) ?? 0;
-      v.setUint32(18, sequence, true);
-      sequences.set(packet.serial, sequence + 1);
-      header[26] = part.length;
-      header.set(part, 27);
-      const page = join([header, body.subarray(offset, offset + size)]);
-      new DataView(page.buffer).setUint32(22, oggCrc(page), true);
-      pages.push(page);
-      offset += size;
-    }
-    pending.delete(packet.serial);
-  }
-  if (pending.size) throw new Error("Ogg packets lack a final page granule");
-  return join(pages);
-}
-function parseOgg(bytes) {
-  const { nodes, packets } = readOgg(bytes), streams = [], tags = {}, pictures = [];
-  const serials = [...new Set(packets.map((p) => p.serial))];
-  for (const serial of serials) {
-    const group = packets.filter((p) => p.serial === serial), head = group[0].data, r = new Reader(head);
-    let codec, sampleRate, channels, preSkip = 0;
-    let comments;
-    if (head.length >= 8 && r.text(0, 8) === "OpusHead") {
-      if (head.length < 19 || r.u8(8) > 15) throw new Error("Invalid Opus identification");
-      codec = "opus";
-      sampleRate = 48e3;
-      channels = r.u8(9);
-      preSkip = r.u16(10, true);
-      const mapping = r.u8(18);
-      if (mapping === 0 && channels > 2) throw new Error("Invalid Opus channels");
-      if (mapping !== 0) r.check(19, 2 + channels);
-      const comment = group[1]?.data;
-      if (!comment || new Reader(comment).text(0, 8) !== "OpusTags")
-        throw new Error("Missing OpusTags");
-      const parsed = parseComments(comment.subarray(8));
-      Object.assign(tags, parsed.tags);
-      comments = parsed.comments;
-    } else if (head.length >= 7 && r.u8(0) === 1 && r.text(1, 6) === "vorbis") {
-      if (head.length !== 30 || r.u32(7, true) !== 0 || !(r.u8(29) & 1))
-        throw new Error("Invalid Vorbis identification");
-      codec = "vorbis";
-      channels = r.u8(11);
-      sampleRate = r.u32(12, true);
-      const comment = group[1]?.data;
-      if (!comment || comment[0] !== 3 || new Reader(comment).text(1, 6) !== "vorbis")
-        throw new Error("Missing Vorbis comments");
-      const parsed = parseComments(comment.subarray(7));
-      if (!(comment[7 + parsed.size] & 1)) throw new Error("Missing Vorbis comment framing bit");
-      Object.assign(tags, parsed.tags);
-      comments = parsed.comments;
-    } else throw new Error("Unsupported Ogg codec");
-    if (!channels || !sampleRate) throw new Error("Invalid Ogg audio stream");
-    const final = group.filter((p) => p.granule !== 0xffffffffffffffffn).at(-1)?.granule ?? 0n;
-    if (final > BigInt(Number.MAX_SAFE_INTEGER))
-      throw new Error("Ogg granule exceeds safe precision");
-    const samples = Math.max(0, Number(final) - preSkip), duration3 = samples / sampleRate;
-    const size = nodes.filter((n) => n.fields?.serial === serial).reduce((sum, n) => sum + n.size, 0);
-    const streamTags = {};
-    for (const comment of comments) {
-      const split = comment.indexOf("=");
-      if (split <= 0) continue;
-      const key = comment.slice(0, split), value = comment.slice(split + 1);
-      streamTags[key] = streamTags[key] ? `${streamTags[key]};${value}` : value;
-    }
-    streams.push({
-      tags: streamTags,
-      codec,
-      sampleRate,
-      channels,
-      samples,
-      duration: duration3,
-      bitrate: duration3 ? size * 8 / duration3 : 0
-    });
-  }
-  for (const value of (tags.METADATA_BLOCK_PICTURE ?? "").split("\n").filter(Boolean)) {
-    pictures.push(parsePicture(Uint8Array.from(atob(value), (c) => c.charCodeAt(0))));
-  }
-  let duration2 = 0, groupDuration = 0;
-  const active = /* @__PURE__ */ new Set();
-  for (const node of nodes) {
-    const serial = node.fields.serial, flags = node.fields.flags;
-    if (flags & 2) {
-      if (!active.size) {
-        duration2 += groupDuration;
-        groupDuration = 0;
-      }
-      active.add(serial);
-      groupDuration = Math.max(groupDuration, streams[serials.indexOf(serial)].duration);
-    }
-    if (flags & 4) active.delete(serial);
-  }
-  duration2 += groupDuration;
-  return {
-    format: "ogg",
-    data: bytes,
-    nodes,
-    streams,
-    tags,
-    pictures,
-    duration: duration2,
-    bitrate: duration2 ? bytes.length * 8 / duration2 : 0
+    streams: [stream],
+    duration: stream.duration,
+    bitrate: stream.duration ? bytes.length * 8 / stream.duration : 0
   };
 }
 
@@ -1703,9 +2098,14 @@ export {
   parseAudio,
   probeAudio,
   probeFlacSource,
+  probeId3Source,
+  probeMp3Source,
+  probeOggStreamSource,
   probeWavSource,
+  readId3Text,
   remix,
   resample,
+  scanOggPages,
   stats,
   transformAudio,
   trim,