taglib-wasm 2.2.3 → 2.3.0

package/dist/index.browser.js

@@ -157,6 +157,11 @@ var init_types2 = __esm({
 });
 
 // src/bwf/bext.ts
+var bext_exports = {};
+__export(bext_exports, {
+  decodeBext: () => decodeBext,
+  encodeBext: () => encodeBext
+});
 function readFixedString(bytes, offset, len) {
   let end = offset;
   const max = Math.min(offset + len, bytes.length);
@@ -293,11 +298,29 @@ var init_base = __esm({
     "use strict";
     SUPPORTED_FORMATS = [
       "MP3",
+      "AAC",
       "MP4",
       "M4A",
       "FLAC",
       "OGG",
+      "OPUS",
+      "OggFLAC",
+      "SPEEX",
       "WAV",
+      "AIFF",
+      "ASF",
+      "APE",
+      "DSF",
+      "DSDIFF",
+      "WV",
+      "MPC",
+      "TTA",
+      "SHN",
+      "MOD",
+      "S3M",
+      "IT",
+      "XM",
+      "MATROSKA",
       "MKA"
     ];
     TagLibError = class _TagLibError extends Error {
@@ -1943,6 +1966,463 @@ var init_audio_file_base = __esm({
   }
 });
 
+// src/taglib/metadata-extent.ts
+function be32(b, offset) {
+  return (b[offset] << 24 | b[offset + 1] << 16 | b[offset + 2] << 8 | b[offset + 3]) >>> 0;
+}
+function startsWith(bytes, magic, at = 0) {
+  if (bytes.length < at + magic.length) return false;
+  for (let i = 0; i < magic.length; i++) {
+    if (bytes[at + i] !== magic.charCodeAt(i)) return false;
+  }
+  return true;
+}
+function id3v2End(bytes) {
+  if (!startsWith(bytes, "ID3") || bytes.length < 10) return void 0;
+  const size = bytes[6] << 21 | bytes[7] << 14 | bytes[8] << 7 | bytes[9];
+  const hasFooter = (bytes[5] & 16) !== 0;
+  return 10 + size + (hasFooter ? 10 : 0);
+}
+function flacEnd(bytes, limit, start) {
+  let offset = start + 4;
+  for (; ; ) {
+    if (offset + 4 > bytes.length) return void 0;
+    const isLast = (bytes[offset] & 128) !== 0;
+    const length = bytes[offset + 1] << 16 | bytes[offset + 2] << 8 | bytes[offset + 3];
+    offset += 4 + length;
+    if (offset > limit) return offset;
+    if (isLast) return offset;
+  }
+}
+function flacMarkerOffset(bytes) {
+  const at = startsWith(bytes, "ID3") ? id3v2End(bytes) : 0;
+  if (at === void 0) return void 0;
+  return startsWith(bytes, "fLaC", at) ? at : void 0;
+}
+function flacAudioStart(bytes) {
+  const at = flacMarkerOffset(bytes);
+  if (at === void 0) return void 0;
+  return flacEnd(bytes, bytes.length, at);
+}
+function mp4MoovEnd(bytes, limit, start) {
+  let offset = start;
+  const readable = Math.min(bytes.length, limit);
+  while (offset + 8 <= readable) {
+    const size = be32(bytes, offset);
+    const type = String.fromCharCode(
+      bytes[offset + 4],
+      bytes[offset + 5],
+      bytes[offset + 6],
+      bytes[offset + 7]
+    );
+    if (size < 8) return void 0;
+    if (type === "moov") return offset + size;
+    offset += size;
+  }
+  return void 0;
+}
+function oggMetadataEnd(bytes, limit, start) {
+  let offset = start;
+  let packetsCompleted = 0;
+  let first = true;
+  for (; ; ) {
+    if (offset + 27 > bytes.length || !startsWith(bytes, "OggS", offset)) {
+      return void 0;
+    }
+    const segmentCount = bytes[offset + 26];
+    const tableStart = offset + 27;
+    if (tableStart + segmentCount > bytes.length) return void 0;
+    let payload = 0;
+    for (let i = 0; i < segmentCount; i++) {
+      const segment = bytes[tableStart + i];
+      payload += segment;
+      if (segment < 255) packetsCompleted++;
+    }
+    if (first) {
+      const payloadStart = tableStart + segmentCount;
+      if (payloadStart + 5 > bytes.length) return void 0;
+      if (bytes[payloadStart] === 127 && startsWith(bytes, "FLAC", payloadStart + 1)) {
+        return void 0;
+      }
+      first = false;
+    }
+    offset = tableStart + segmentCount + payload;
+    if (packetsCompleted >= 2 || offset > limit) return offset;
+  }
+}
+function mpegFrameLength(bytes, at) {
+  if (bytes.length < at + 4) return 0;
+  if (bytes[at] !== 255 || (bytes[at + 1] & 224) !== 224) return 0;
+  const version = bytes[at + 1] >> 3 & 3;
+  const layer = bytes[at + 1] >> 1 & 3;
+  if (version === 1 || layer === 0) return 0;
+  const bitrateIndex = bytes[at + 2] >> 4 & 15;
+  const sampleRateIndex = bytes[at + 2] >> 2 & 3;
+  if (bitrateIndex === 0 || bitrateIndex === 15 || sampleRateIndex === 3) {
+    return 0;
+  }
+  const mpeg1 = version === 3;
+  const layerIndex = layer ^ 3;
+  const bitrate = MPEG_BITRATES[mpeg1 ? 0 : 1][layerIndex][bitrateIndex];
+  const sampleRateTable = mpeg1 ? 0 : version === 2 ? 1 : 2;
+  const sampleRate = MPEG_SAMPLE_RATES[sampleRateTable][sampleRateIndex];
+  const samplesPerFrame = layerIndex === 2 ? mpeg1 ? 1152 : 576 : layerIndex === 1 ? 1152 : 384;
+  let frameLength = Math.floor(samplesPerFrame * bitrate * 125 / sampleRate);
+  if ((bytes[at + 2] & 2) !== 0) frameLength += layerIndex === 0 ? 4 : 1;
+  return frameLength === 0 ? 0 : frameLength;
+}
+function isMpegFrameSync(bytes, at = 0) {
+  const frameLength = mpegFrameLength(bytes, at);
+  if (frameLength === 0) return false;
+  const next = at + frameLength;
+  if (bytes.length < next + 4) return false;
+  const mask = 4294839296;
+  const header = ((bytes[at] << 24 | bytes[at + 1] << 16 | bytes[at + 2] << 8 | bytes[at + 3]) >>> 0 & mask) >>> 0;
+  const nextHeader = ((bytes[next] << 24 | bytes[next + 1] << 16 | bytes[next + 2] << 8 | bytes[next + 3]) >>> 0 & mask) >>> 0;
+  return header === nextHeader;
+}
+function containerEnd(bytes, at, limit) {
+  if (at >= bytes.length) return bytes.length < limit ? null : void 0;
+  if (at + 8 > bytes.length) return void 0;
+  if (startsWith(bytes, "fLaC", at)) return flacEnd(bytes, limit, at);
+  if (startsWith(bytes, "ftyp", at + 4)) return mp4MoovEnd(bytes, limit, at);
+  if (startsWith(bytes, "OggS", at)) return oggMetadataEnd(bytes, limit, at);
+  return null;
+}
+function metadataFitsInHeader(header, limit) {
+  let end;
+  if (startsWith(header, "ID3")) {
+    const tagEnd = id3v2End(header);
+    if (tagEnd === void 0) return false;
+    end = tagEnd;
+    if (tagEnd <= limit) {
+      const behind = containerEnd(header, tagEnd, limit);
+      if (behind === void 0) return false;
+      if (behind !== null) end = behind;
+    }
+  } else {
+    const container = containerEnd(header, 0, limit);
+    if (container === null) {
+      end = isMpegFrameSync(header) ? 0 : void 0;
+    } else {
+      end = container;
+    }
+  }
+  if (end === void 0 || end > header.length) return false;
+  return end <= limit;
+}
+function trailerFitsInFooter(tail, footerSize) {
+  if (tail.length < Math.min(footerSize, 32)) return false;
+  for (const offsetFromEnd of [32, 32 + 128]) {
+    const at = tail.length - offsetFromEnd;
+    if (at < 0 || !startsWith(tail, "APETAGEX", at)) continue;
+    const size = (tail[at + 12] | tail[at + 13] << 8 | tail[at + 14] << 16 | tail[at + 15] << 24) >>> 0;
+    const trailing = offsetFromEnd === 32 ? 0 : 128;
+    if (size + 32 + trailing > footerSize) return false;
+  }
+  return true;
+}
+var MPEG_BITRATES, MPEG_SAMPLE_RATES;
+var init_metadata_extent = __esm({
+  "src/taglib/metadata-extent.ts"() {
+    "use strict";
+    MPEG_BITRATES = [
+      [
+        [0, 32, 64, 96, 128, 160, 192, 224, 256, 288, 320, 352, 384, 416, 448, 0],
+        // Layer I
+        [0, 32, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384, 0],
+        // Layer II
+        [0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 0]
+        // Layer III
+      ],
+      [
+        [0, 32, 48, 56, 64, 80, 96, 112, 128, 144, 160, 176, 192, 224, 256, 0],
+        // Layer I
+        [0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160, 0],
+        // Layer II
+        [0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160, 0]
+        // Layer III
+      ]
+    ];
+    MPEG_SAMPLE_RATES = [
+      [44100, 48e3, 32e3],
+      // MPEG-1
+      [22050, 24e3, 16e3],
+      // MPEG-2
+      [11025, 12e3, 8e3]
+      // MPEG-2.5
+    ];
+  }
+});
+
+// src/taglib/media-ranges.ts
+function adtsFrameLength(bytes, at) {
+  if (bytes.length < at + 7) return 0;
+  if (bytes[at] !== 255 || (bytes[at + 1] & 246) !== 240) return 0;
+  const length = (bytes[at + 3] & 3) << 11 | bytes[at + 4] << 3 | bytes[at + 5] >> 5;
+  return length >= 7 ? length : 0;
+}
+function trailingTagStart(bytes, end = bytes.length) {
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  let at = Math.max(0, Math.min(end, bytes.length));
+  for (; ; ) {
+    if (at >= 128 && text(bytes, at - 128, 3) === "TAG") {
+      at -= 128;
+      continue;
+    }
+    if (at >= 32 && text(bytes, at - 32, 8) === "APETAGEX") {
+      const size = view.getUint32(at - 32 + 12, true);
+      const flags = view.getUint32(at - 32 + 20, true);
+      const start = at - size - ((flags & 2147483648) !== 0 ? 32 : 0);
+      if (start < 0 || start >= at) return at;
+      at = start;
+      continue;
+    }
+    return at;
+  }
+}
+function firstFrame(bytes) {
+  const from = id3v2End(bytes) ?? 0;
+  const limit = Math.min(bytes.length - 6, from + MPEG_SCAN_LIMIT);
+  for (let o = from; o < limit; o++) {
+    const len = frameLengthAt(bytes, o);
+    if (len > 0 && frameLengthAt(bytes, o + len) > 0) return o;
+  }
+  return -1;
+}
+function forwardLastFrame(bytes, from, end) {
+  let o = from;
+  let start = -1;
+  let length = 0;
+  let frames = 0;
+  while (o + 6 <= end) {
+    const len = frameLengthAt(bytes, o);
+    if (len === 0 || o + len > end) break;
+    start = o;
+    length = len;
+    frames++;
+    o += len;
+  }
+  return { start, length, frames };
+}
+function walkMpeg(bytes) {
+  const from = firstFrame(bytes);
+  if (from < 0) return fallback("no valid first frame");
+  const end = trailingTagStart(bytes);
+  const last = forwardLastFrame(bytes, from, end);
+  if (last.start < 0) return fallback("no valid frames");
+  return {
+    kind: "ranges",
+    ranges: [{ offset: from, length: last.start + last.length - from }],
+    detail: `first=${from} last=${last.start}+${last.length} frames=${last.frames}`
+  };
+}
+function flacStreamInfoMd5(bytes) {
+  const marker = flacMarkerOffset(bytes);
+  if (marker === void 0) return void 0;
+  const header = marker + 4;
+  if (header + 4 > bytes.length) return void 0;
+  if ((bytes[header] & 127) !== 0) return void 0;
+  const blockLength = bytes[header + 1] << 16 | bytes[header + 2] << 8 | bytes[header + 3];
+  if (blockLength < 34) return void 0;
+  const payload = header + 4;
+  if (payload + 34 > bytes.length) return void 0;
+  let hex = "";
+  for (const byte of bytes.subarray(payload + 18, payload + 34)) {
+    hex += byte.toString(16).padStart(2, "0");
+  }
+  return hex;
+}
+function walkFlac(bytes) {
+  const start = flacAudioStart(bytes);
+  if (start === void 0) return fallback("no fLaC marker");
+  const end = trailingTagStart(bytes);
+  if (end <= start) return fallback("no audio bytes");
+  return {
+    kind: "ranges",
+    ranges: [{ offset: start, length: end - start }],
+    detail: `audioStart=${start} end=${end}`
+  };
+}
+function atomLength(bytes, view, o) {
+  const size = view.getUint32(o, false);
+  if (size === 0) return { length: bytes.length - o, headerSize: 8 };
+  if (size === 1) {
+    if (o + 16 > bytes.length) return void 0;
+    const big = view.getBigUint64(o + 8, false);
+    if (big > BigInt(Number.MAX_SAFE_INTEGER)) return void 0;
+    return { length: Number(big), headerSize: 16 };
+  }
+  return { length: size, headerSize: 8 };
+}
+function walkMp4(bytes) {
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const ranges = [];
+  let o = 0;
+  while (o + 8 <= bytes.length) {
+    const type = text(bytes, o + 4, 4);
+    const atom = atomLength(bytes, view, o);
+    if (atom === void 0) return fallback(`malformed ${type} size`);
+    if (atom.length < atom.headerSize) {
+      return fallback(`malformed ${type} size`);
+    }
+    if (o + atom.length > bytes.length) return fallback(`oversized ${type}`);
+    if (type === "mdat" && atom.length > atom.headerSize) {
+      ranges.push({
+        offset: o + atom.headerSize,
+        length: atom.length - atom.headerSize
+      });
+    }
+    o += atom.length;
+  }
+  if (o !== bytes.length) return fallback("trailing bytes after the last atom");
+  if (ranges.length === 0) return fallback("no non-empty mdat");
+  return { kind: "ranges", ranges, detail: `${ranges.length} mdat(s)` };
+}
+function walkWav(bytes) {
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  if (text(bytes, 0, 4) !== "RIFF") return fallback("not RIFF");
+  if (text(bytes, 8, 4) !== "WAVE") return fallback("not WAVE");
+  const ranges = [];
+  let o = 12;
+  while (o + 8 <= bytes.length) {
+    const id = text(bytes, o, 4);
+    const size = view.getUint32(o + 4, true);
+    const dataStart = o + 8;
+    if (dataStart + size > bytes.length) return fallback(`truncated ${id}`);
+    if (id === "data" && size > 0) {
+      ranges.push({ offset: dataStart, length: size });
+    }
+    o = dataStart + size + size % 2;
+  }
+  if (ranges.length === 0) return fallback("no data chunk");
+  return { kind: "ranges", ranges, detail: `${ranges.length} data chunk(s)` };
+}
+function mediaRanges(format, bytes) {
+  const walked = (() => {
+    switch (format.toUpperCase()) {
+      case "MP3":
+      case "AAC":
+        return walkMpeg(bytes);
+      case "FLAC":
+        return walkFlac(bytes);
+      case "MP4":
+      case "M4A":
+        return walkMp4(bytes);
+      case "WAV":
+        return walkWav(bytes);
+      default:
+        return { kind: "fallback", ranges: [], detail: "format not covered" };
+    }
+  })();
+  if (walked.kind === "fallback") {
+    return {
+      kind: "fallback",
+      ranges: [{ offset: 0, length: bytes.length }],
+      detail: `${walked.detail} \u2192 whole file`
+    };
+  }
+  return walked;
+}
+var decoder, text, fallback, frameLengthAt, MPEG_SCAN_LIMIT;
+var init_media_ranges = __esm({
+  "src/taglib/media-ranges.ts"() {
+    "use strict";
+    init_metadata_extent();
+    decoder = new TextDecoder();
+    text = (b, o, n) => decoder.decode(b.subarray(o, o + n));
+    fallback = (detail) => ({
+      kind: "fallback",
+      ranges: [],
+      detail
+    });
+    frameLengthAt = (bytes, at) => mpegFrameLength(bytes, at) || adtsFrameLength(bytes, at);
+    MPEG_SCAN_LIMIT = 65536;
+  }
+});
+
+// src/taglib/audio-file-checksum.ts
+async function fileBytes(source, io) {
+  if (source.path) return await io.readFile(source.path);
+  if (source.blob) return new Uint8Array(await source.blob.arrayBuffer());
+  if (!source.partiallyLoaded && source.bytes.length > 0) return source.bytes;
+  throw new MetadataError(
+    "read",
+    "the handle holds no file bytes and has no readable source; a partial handle that has been saved drops its source \u2014 checksum the saved path instead"
+  );
+}
+function joinRanges(bytes, ranges) {
+  const total = ranges.reduce((n, r) => n + r.length, 0);
+  const overrun = ranges.find((r) => r.offset + r.length > bytes.length);
+  if (overrun || total > bytes.length) {
+    throw new MetadataError(
+      "read",
+      `range walk overran the buffer (${overrun ? `range ${overrun.offset}+${overrun.length}` : `${total} bytes`} past the ${bytes.length}-byte buffer)`
+    );
+  }
+  if (ranges.length === 1) {
+    const only = ranges[0];
+    const view = bytes.subarray(only.offset, only.offset + only.length);
+    return view.buffer instanceof ArrayBuffer ? view : new Uint8Array(view);
+  }
+  const out = new Uint8Array(total);
+  let at = 0;
+  for (const r of ranges) {
+    out.set(bytes.subarray(r.offset, r.offset + r.length), at);
+    at += r.length;
+  }
+  return out;
+}
+async function mediaChecksum(source, format, io, options = {}) {
+  if (options.basis === "pcm") {
+    if (format.toUpperCase() !== "FLAC") {
+      throw new UnsupportedFormatError(format, ["FLAC"], {
+        operation: "media checksum (basis: pcm)"
+      });
+    }
+    const windowed = source.bytes.length > 0 ? source.bytes : source.path && io.readPartial ? await io.readPartial(source.path, STREAMINFO_WINDOW, 0) : void 0;
+    let md5 = windowed === void 0 ? void 0 : flacStreamInfoMd5(windowed);
+    if (md5 === void 0 && windowed !== source.bytes) {
+      md5 = flacStreamInfoMd5(await fileBytes(source, io));
+    }
+    if (md5 === void 0) {
+      throw new MetadataError(
+        "read",
+        "STREAMINFO digest unavailable"
+      );
+    }
+    return {
+      source: "flac-streaminfo-md5",
+      algorithm: "md5",
+      hex: md5,
+      bytesHashed: 16
+    };
+  }
+  const bytes = await fileBytes(source, io);
+  const walk = mediaRanges(format, bytes);
+  const payload = joinRanges(bytes, walk.ranges);
+  const digest = new Uint8Array(
+    await crypto.subtle.digest("SHA-256", payload)
+  );
+  let hex = "";
+  for (const byte of digest) hex += byte.toString(16).padStart(2, "0");
+  return {
+    source: walk.kind === "ranges" ? "audio-payload" : "file",
+    algorithm: "sha256",
+    hex,
+    bytesHashed: payload.length
+  };
+}
+var STREAMINFO_WINDOW;
+var init_audio_file_checksum = __esm({
+  "src/taglib/audio-file-checksum.ts"() {
+    "use strict";
+    init_media_ranges();
+    init_errors2();
+    STREAMINFO_WINDOW = 65536;
+  }
+});
+
 // src/utils/file.ts
 async function readFileData(file) {
   if (file instanceof Uint8Array) return file;
@@ -2050,8 +2530,8 @@ function wrapEmbindHandle(raw) {
     // Text only — language/description are not surfaced by the PropertyMap.
     getLyrics() {
       const props = raw.getProperties();
-      return (props["LYRICS"] ?? []).map((text) => ({
-        text,
+      return (props["LYRICS"] ?? []).map((text2) => ({
+        text: text2,
         description: "",
         language: ""
       }));
@@ -2304,6 +2784,8 @@ var init_audio_file_impl = __esm({
     init_rating();
     init_detector();
     init_audio_file_base();
+    init_audio_file_checksum();
+    init_platform_io_browser_stub();
     init_save_reconstruct();
     AudioFileImpl = class extends BaseAudioFileImpl {
       constructor(module, fileHandle, sourcePath, originalSource, isPartiallyLoaded = false, partialLoadOptions) {
@@ -2316,6 +2798,9 @@ var init_audio_file_impl = __esm({
           partialLoadOptions
         );
         __publicField(this, "pathModeBuffer", null);
+        /** How the handle was loaded — `isPartiallyLoaded` is mutated by saveToFile(). */
+        __publicField(this, "partiallyLoadedAtConstruction");
+        this.partiallyLoadedAtConstruction = isPartiallyLoaded;
       }
       save() {
         if (this.isPartiallyLoaded && this.originalSource) {
@@ -2351,6 +2836,31 @@ var init_audio_file_impl = __esm({
           "No file data available: in-memory buffer is empty and no source path is set"
         );
       }
+      mediaChecksum(options) {
+        return mediaChecksum(
+          {
+            // The cheap, no-IO accessor — `getFileBuffer()` would read the whole
+            // file from disk in path mode (and cache it), which the source rule is
+            // about to read for itself.
+            bytes: this.handle.getBuffer(),
+            // empty in path mode: the data is on disk
+            // Both optional fields are conditional: they are `undefined` far more
+            // often than not, and `exactOptionalPropertyTypes` refuses an explicit
+            // `undefined` on an optional property.
+            ...this.sourcePath !== void 0 ? { path: this.sourcePath } : {},
+            // originalSource is the File when the caller passed one. A partial File
+            // has no path, so this is the only way back to the real bytes.
+            ...this.originalSource instanceof Blob ? { blob: this.originalSource } : {},
+            // Captured at construction, NOT this.isPartiallyLoaded: saveToFile() sets
+            // that flag false (and clears originalSource) while the handle still holds
+            // the spliced image, which would make the source rule hash the image.
+            partiallyLoaded: this.partiallyLoadedAtConstruction
+          },
+          this.getFormat(),
+          getPlatformIO(),
+          options
+        );
+      }
       async saveToFile(path) {
         const targetPath = path ?? this.sourcePath;
         if (!targetPath) {
@@ -2548,181 +3058,6 @@ var init_audio_file_impl = __esm({
   }
 });
 
-// src/taglib/metadata-extent.ts
-function be32(b, offset) {
-  return (b[offset] << 24 | b[offset + 1] << 16 | b[offset + 2] << 8 | b[offset + 3]) >>> 0;
-}
-function startsWith(bytes, magic, at = 0) {
-  if (bytes.length < at + magic.length) return false;
-  for (let i = 0; i < magic.length; i++) {
-    if (bytes[at + i] !== magic.charCodeAt(i)) return false;
-  }
-  return true;
-}
-function id3v2End(bytes) {
-  if (bytes.length < 10) return void 0;
-  const size = bytes[6] << 21 | bytes[7] << 14 | bytes[8] << 7 | bytes[9];
-  const hasFooter = (bytes[5] & 16) !== 0;
-  return 10 + size + (hasFooter ? 10 : 0);
-}
-function flacEnd(bytes, limit, start) {
-  let offset = start + 4;
-  for (; ; ) {
-    if (offset + 4 > bytes.length) return void 0;
-    const isLast = (bytes[offset] & 128) !== 0;
-    const length = bytes[offset + 1] << 16 | bytes[offset + 2] << 8 | bytes[offset + 3];
-    offset += 4 + length;
-    if (offset > limit) return offset;
-    if (isLast) return offset;
-  }
-}
-function mp4MoovEnd(bytes, limit, start) {
-  let offset = start;
-  const readable = Math.min(bytes.length, limit);
-  while (offset + 8 <= readable) {
-    const size = be32(bytes, offset);
-    const type = String.fromCharCode(
-      bytes[offset + 4],
-      bytes[offset + 5],
-      bytes[offset + 6],
-      bytes[offset + 7]
-    );
-    if (size < 8) return void 0;
-    if (type === "moov") return offset + size;
-    offset += size;
-  }
-  return void 0;
-}
-function oggMetadataEnd(bytes, limit, start) {
-  let offset = start;
-  let packetsCompleted = 0;
-  let first = true;
-  for (; ; ) {
-    if (offset + 27 > bytes.length || !startsWith(bytes, "OggS", offset)) {
-      return void 0;
-    }
-    const segmentCount = bytes[offset + 26];
-    const tableStart = offset + 27;
-    if (tableStart + segmentCount > bytes.length) return void 0;
-    let payload = 0;
-    for (let i = 0; i < segmentCount; i++) {
-      const segment = bytes[tableStart + i];
-      payload += segment;
-      if (segment < 255) packetsCompleted++;
-    }
-    if (first) {
-      const payloadStart = tableStart + segmentCount;
-      if (payloadStart + 5 > bytes.length) return void 0;
-      if (bytes[payloadStart] === 127 && startsWith(bytes, "FLAC", payloadStart + 1)) {
-        return void 0;
-      }
-      first = false;
-    }
-    offset = tableStart + segmentCount + payload;
-    if (packetsCompleted >= 2 || offset > limit) return offset;
-  }
-}
-function isMpegFrameSync(bytes, at = 0) {
-  if (bytes.length < at + 4) return false;
-  if (bytes[at] !== 255 || (bytes[at + 1] & 224) !== 224) return false;
-  const version = bytes[at + 1] >> 3 & 3;
-  const layer = bytes[at + 1] >> 1 & 3;
-  if (version === 1 || layer === 0) return false;
-  const bitrateIndex = bytes[at + 2] >> 4 & 15;
-  const sampleRateIndex = bytes[at + 2] >> 2 & 3;
-  if (bitrateIndex === 0 || bitrateIndex === 15 || sampleRateIndex === 3) {
-    return false;
-  }
-  const mpeg1 = version === 3;
-  const layerIndex = layer ^ 3;
-  const bitrate = MPEG_BITRATES[mpeg1 ? 0 : 1][layerIndex][bitrateIndex];
-  const sampleRateTable = mpeg1 ? 0 : version === 2 ? 1 : 2;
-  const sampleRate = MPEG_SAMPLE_RATES[sampleRateTable][sampleRateIndex];
-  const samplesPerFrame = layerIndex === 2 ? mpeg1 ? 1152 : 576 : layerIndex === 1 ? 1152 : 384;
-  let frameLength = Math.floor(samplesPerFrame * bitrate * 125 / sampleRate);
-  if ((bytes[at + 2] & 2) !== 0) frameLength += layerIndex === 0 ? 4 : 1;
-  if (frameLength === 0) return false;
-  const next = at + frameLength;
-  if (bytes.length < next + 4) return false;
-  const mask = 4294839296;
-  const header = ((bytes[at] << 24 | bytes[at + 1] << 16 | bytes[at + 2] << 8 | bytes[at + 3]) >>> 0 & mask) >>> 0;
-  const nextHeader = ((bytes[next] << 24 | bytes[next + 1] << 16 | bytes[next + 2] << 8 | bytes[next + 3]) >>> 0 & mask) >>> 0;
-  return header === nextHeader;
-}
-function containerEnd(bytes, at, limit) {
-  if (at >= bytes.length) return bytes.length < limit ? null : void 0;
-  if (at + 8 > bytes.length) return void 0;
-  if (startsWith(bytes, "fLaC", at)) return flacEnd(bytes, limit, at);
-  if (startsWith(bytes, "ftyp", at + 4)) return mp4MoovEnd(bytes, limit, at);
-  if (startsWith(bytes, "OggS", at)) return oggMetadataEnd(bytes, limit, at);
-  return null;
-}
-function metadataFitsInHeader(header, limit) {
-  let end;
-  if (startsWith(header, "ID3")) {
-    const tagEnd = id3v2End(header);
-    if (tagEnd === void 0) return false;
-    end = tagEnd;
-    if (tagEnd <= limit) {
-      const behind = containerEnd(header, tagEnd, limit);
-      if (behind === void 0) return false;
-      if (behind !== null) end = behind;
-    }
-  } else {
-    const container = containerEnd(header, 0, limit);
-    if (container === null) {
-      end = isMpegFrameSync(header) ? 0 : void 0;
-    } else {
-      end = container;
-    }
-  }
-  if (end === void 0 || end > header.length) return false;
-  return end <= limit;
-}
-function trailerFitsInFooter(tail, footerSize) {
-  if (tail.length < Math.min(footerSize, 32)) return false;
-  for (const offsetFromEnd of [32, 32 + 128]) {
-    const at = tail.length - offsetFromEnd;
-    if (at < 0 || !startsWith(tail, "APETAGEX", at)) continue;
-    const size = (tail[at + 12] | tail[at + 13] << 8 | tail[at + 14] << 16 | tail[at + 15] << 24) >>> 0;
-    const trailing = offsetFromEnd === 32 ? 0 : 128;
-    if (size + 32 + trailing > footerSize) return false;
-  }
-  return true;
-}
-var MPEG_BITRATES, MPEG_SAMPLE_RATES;
-var init_metadata_extent = __esm({
-  "src/taglib/metadata-extent.ts"() {
-    "use strict";
-    MPEG_BITRATES = [
-      [
-        [0, 32, 64, 96, 128, 160, 192, 224, 256, 288, 320, 352, 384, 416, 448, 0],
-        // Layer I
-        [0, 32, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384, 0],
-        // Layer II
-        [0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 0]
-        // Layer III
-      ],
-      [
-        [0, 32, 48, 56, 64, 80, 96, 112, 128, 144, 160, 176, 192, 224, 256, 0],
-        // Layer I
-        [0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160, 0],
-        // Layer II
-        [0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160, 0]
-        // Layer III
-      ]
-    ];
-    MPEG_SAMPLE_RATES = [
-      [44100, 48e3, 32e3],
-      // MPEG-1
-      [22050, 24e3, 16e3],
-      // MPEG-2
-      [11025, 12e3, 8e3]
-      // MPEG-2.5
-    ];
-  }
-});
-
 // src/taglib/load-audio-data.ts
 async function loadAudioData(input, opts) {
   if (opts.partial && typeof File !== "undefined" && input instanceof File) {
@@ -3009,7 +3344,7 @@ var VERSION;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    VERSION = "2.2.3";
+    VERSION = "2.3.0";
   }
 });
 
@@ -3132,30 +3467,19 @@ var init_taglib_class = __esm({
         const actualInput = isNamedAudioInput(input) ? input.data : input;
         const sourcePath = typeof actualInput === "string" ? actualInput : void 0;
         if (typeof actualInput === "string" && this.module.isWasi) {
-          const fileHandle2 = this.module.createFileHandle();
-          try {
-            const fh = fileHandle2;
-            if (fh.loadFromPath) {
-              const wasiPath = toWasiPath(actualInput);
-              const success = fh.loadFromPath(wasiPath);
-              if (!success) {
-                throw new InvalidFormatError(
-                  `Failed to load audio file. Path: ${actualInput}`
-                );
-              }
-              return new AudioFileImpl(
-                this.module,
-                fileHandle2,
-                sourcePath,
-                actualInput,
-                false
-              );
-            }
-          } catch (error) {
-            if (typeof fileHandle2.destroy === "function") {
-              fileHandle2.destroy();
-            }
-            throw error;
+          const wasiPath = toWasiPath(actualInput);
+          if (this.module.loadAudioPath) {
+            const fileHandle2 = await this.module.loadAudioPath(
+              wasiPath,
+              actualInput
+            );
+            return new AudioFileImpl(
+              this.module,
+              fileHandle2,
+              sourcePath,
+              actualInput,
+              false
+            );
           }
         }
         const opts = {
@@ -3308,6 +3632,11 @@ init_taglib2();
 init_audio_formats();
 init_errors2();
 
+// src/runtime/deno-detect.ts
+function isDenoCompiled() {
+  return typeof Deno !== "undefined" && typeof Deno.mainModule === "string" && Deno.mainModule.includes("deno-compile://");
+}
+
 // src/simple/config.ts
 var cachedTagLib = null;
 var bufferModeEnabled = false;
@@ -3499,7 +3828,6 @@ async function readPictureMetadata(file) {
 // src/simple/batch-operations.ts
 init_audio_formats();
 init_errors2();
-init_properties();
 init_tag_mapping();
 async function executeBatch(files, options, processor) {
   if (files.length === 0) return { items: [], duration: 0 };
@@ -3618,11 +3946,10 @@ async function readMetadataBatch(files, options = {}) {
   });
 }
 
-// src/simple/index.ts
-init_types2();
-
-// src/constants/index.ts
-init_properties();
+// src/simple/checksum-operations.ts
+async function readMediaChecksum(file, options) {
+  return withAudioFile(file, (audioFile) => audioFile.mediaChecksum(options));
+}
 
 // src/constants/format-mappings.ts
 var FormatMappings = {
@@ -3703,6 +4030,588 @@ function propertyValue(props, key) {
   return props[key]?.[0];
 }
 
+// src/folder-api/folder-disc.ts
+function dirname(path) {
+  const i = Math.max(path.lastIndexOf("/"), path.lastIndexOf("\\"));
+  return i === -1 ? path : path.slice(0, i);
+}
+var UNCONDITIONAL_MARKERS = [
+  "cd",
+  "disc",
+  "disk",
+  "dvd",
+  "sacd",
+  "blu-ray",
+  "bd",
+  "digital media"
+];
+var GATED_MARKERS = ["tape", "vinyl", "cassette", "lp", "record"];
+var MARKERS = [...UNCONDITIONAL_MARKERS, ...GATED_MARKERS];
+var GATED_MARKER_SET = new Set(GATED_MARKERS);
+var WORD_NUMBERS = {
+  one: 1,
+  two: 2,
+  three: 3,
+  four: 4,
+  five: 5,
+  six: 6,
+  seven: 7,
+  eight: 8,
+  nine: 9,
+  ten: 10,
+  eleven: 11,
+  twelve: 12
+};
+function romanToInt(s) {
+  const values = {
+    i: 1,
+    v: 5,
+    x: 10,
+    l: 50,
+    c: 100,
+    d: 500,
+    m: 1e3
+  };
+  let total = 0;
+  let prev = 0;
+  for (let i = s.length - 1; i >= 0; i--) {
+    const v = values[s[i]];
+    if (v === void 0) return NaN;
+    total += v < prev ? -v : v;
+    prev = v;
+  }
+  return total;
+}
+function parseNumberToken(token) {
+  if (/^\d+$/.test(token)) return parseInt(token, 10);
+  const word = WORD_NUMBERS[token.toLowerCase()];
+  if (word) return word;
+  const roman = romanToInt(token.toLowerCase());
+  return Number.isFinite(roman) ? roman : void 0;
+}
+var SEP = String.raw`[\s._#-]*`;
+var NUM = String.raw`(?:\d+|(?:[ivxlcdm]+|one|two|three|four|five|six|seven|eight|nine|ten|eleven|twelve|[a-z])(?![a-z]))`;
+function parseDiscName(name) {
+  const trimmed = name.trim();
+  if (/^(?:extras?|bonus)$/i.test(trimmed)) return void 0;
+  for (const marker of MARKERS) {
+    const left = String.raw`(?:^|[^a-z0-9])`;
+    const esc = marker.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const re = new RegExp(
+      left + String.raw`(${esc})(?![a-z])${SEP}(${NUM})`,
+      "i"
+    );
+    const m = trimmed.match(re);
+    if (!m) continue;
+    const sideLetter = /^[a-z]$/i.test(m[2]);
+    const number = sideLetter ? void 0 : parseNumberToken(m[2]);
+    if (number === void 0 && !sideLetter) continue;
+    if (!sideLetter && /^[ivxlcdm]{2,}$/i.test(m[2]) && (number ?? 0) > 100) continue;
+    const isGated = GATED_MARKER_SET.has(marker.toLowerCase()) || sideLetter;
+    const markerStart = m.index + m[1].length - marker.length;
+    const rawPrefix = trimmed.slice(0, markerStart).trim();
+    const title = rawPrefix.replace(/[()[\]]/g, "").replace(/[\s._#-]+$/, "") || void 0;
+    const isExact = title === void 0;
+    const after = trimmed.slice(m.index + m[0].length).trim();
+    const discTitle = after.replace(/^[()[\],:;\-–—\s]+/, "").replace(/[)\]\[,:;\-–—\s]+$/, "").trim() || void 0;
+    const ofMatch = after.trim().match(/^of\s+(\d+)\b/i);
+    const total = ofMatch ? parseInt(ofMatch[1], 10) : void 0;
+    return {
+      kind: isExact ? "exact" : "embedded",
+      number: sideLetter ? void 0 : number,
+      total,
+      title,
+      discTitle,
+      gated: isGated,
+      sideLetter,
+      digit: /^\d+$/.test(m[2])
+    };
+  }
+  const volume = trimmed.match(
+    /^(?:volume|vol\.?|part|pt\.?)\s*(\d+)(?:\s*of\s*(\d+))?$/i
+  );
+  if (volume) {
+    return {
+      kind: "volume",
+      number: parseInt(volume[1], 10),
+      total: volume[2] ? parseInt(volume[2], 10) : void 0,
+      title: void 0,
+      discTitle: void 0,
+      gated: false,
+      sideLetter: false,
+      digit: true
+    };
+  }
+  if (/^bonus\s+disc$/i.test(trimmed)) {
+    return {
+      kind: "bonus",
+      number: void 0,
+      total: void 0,
+      title: void 0,
+      discTitle: void 0,
+      gated: true,
+      sideLetter: false,
+      digit: false
+    };
+  }
+  if (/^(?:\d+|v\d+|p\d+|[ab])$/i.test(trimmed)) {
+    return {
+      kind: "bare",
+      number: /^\d+$/i.test(trimmed) ? parseInt(trimmed, 10) : void 0,
+      total: void 0,
+      title: void 0,
+      discTitle: void 0,
+      gated: true,
+      sideLetter: false,
+      digit: false
+    };
+  }
+  return void 0;
+}
+function baseConfidence(parse) {
+  switch (parse.kind) {
+    case "exact":
+      return parse.digit ? "high" : "low";
+    case "embedded":
+      return "medium";
+    case "volume":
+      return "medium";
+    case "bonus":
+    case "bare":
+      return "low";
+  }
+}
+function discFolderInfo(name) {
+  const parse = parseDiscName(name);
+  if (!parse) return void 0;
+  return {
+    kind: parse.kind,
+    gated: parse.gated,
+    number: parse.number,
+    total: parse.total,
+    title: parse.title,
+    discTitle: parse.discTitle,
+    confidence: parse.gated ? "low" : baseConfidence(parse)
+  };
+}
+
+// src/utils/path.ts
+function basename(path) {
+  const i = Math.max(path.lastIndexOf("/"), path.lastIndexOf("\\"));
+  return i === -1 ? path : path.slice(i + 1);
+}
+
+// src/folder-api/album-corroborate.ts
+var CONFIDENCE_RANK = {
+  low: 0,
+  medium: 1,
+  high: 2
+};
+function corroborated(parse, siblings) {
+  if (!parse.gated && parse.kind === "exact") return true;
+  if (siblings.length === 0) return false;
+  const siblingParses = siblings.map((s) => parseDiscName(basename(s))).filter((p) => p !== void 0);
+  const hasExactSibling = siblingParses.some(
+    (p) => !p.gated && p.kind === "exact"
+  );
+  const hasNumberedSibling = siblingParses.some(
+    (p) => p.number !== void 0
+  );
+  if (parse.number !== void 0 && hasNumberedSibling) return true;
+  if (!parse.gated && parse.kind === "embedded" && hasExactSibling) return true;
+  if (!parse.gated && parse.kind === "volume" && hasNumberedSibling) {
+    return true;
+  }
+  if (parse.sideLetter) {
+    return siblingParses.some((p) => p.sideLetter);
+  }
+  if (parse.kind === "bonus" || parse.kind === "bare") {
+    const numberedCount = siblingParses.filter((p) => p.number !== void 0).length;
+    if (numberedCount >= 2) return true;
+    if (parse.number !== void 0 && hasNumberedSibling) return true;
+  }
+  return false;
+}
+
+// src/folder-api/album-identity.ts
+function normalizeKey(s) {
+  return s.trim().toLowerCase().replace(/\s+/g, " ");
+}
+function isGenericAlbumArtist(albumArtist) {
+  if (!albumArtist || albumArtist.trim() === "") return true;
+  const n = normalizeKey(albumArtist);
+  return n === "various artists" || n === "va";
+}
+function evidenceFor(item, confirmedDiscs, flatSubdivisions2) {
+  const dir = dirname(item.path);
+  const own = confirmedDiscs.get(dir);
+  if (own) {
+    return {
+      folderDiscNumber: own.parse.number,
+      total: own.parse.total,
+      folderDiscTitle: own.parse.discTitle,
+      confidence: own.confidence,
+      albumDir: dirname(dir)
+    };
+  }
+  let cursor = dirname(dir);
+  while (cursor !== void 0) {
+    const entry = confirmedDiscs.get(cursor);
+    if (entry) {
+      return {
+        folderDiscNumber: entry.parse.number,
+        total: entry.parse.total,
+        folderDiscTitle: entry.parse.discTitle,
+        confidence: entry.confidence,
+        albumDir: dirname(cursor)
+      };
+    }
+    const parent = dirname(cursor);
+    if (parent === cursor) break;
+    cursor = parent;
+  }
+  const flat = flatSubdivisions2.get(dir)?.get(item.path);
+  if (flat !== void 0) {
+    return {
+      folderDiscNumber: flat,
+      total: void 0,
+      folderDiscTitle: void 0,
+      confidence: "medium",
+      albumDir: dir
+    };
+  }
+  return void 0;
+}
+function folderIdentity(dir, confirmedDiscs, scanRoot) {
+  const own = confirmedDiscs.get(dir);
+  if (!own) {
+    const title2 = basename(dir);
+    return title2 ? { title: title2, titleSource: dir } : void 0;
+  }
+  if (own.parse.title !== void 0) {
+    return { title: own.parse.title, titleSource: dirname(dir) };
+  }
+  const source = dirname(dir);
+  if (source === scanRoot || source === dir) return void 0;
+  const title = basename(source);
+  return title ? { title, titleSource: source } : void 0;
+}
+function buildAlbumIdentity(okItems, confirmedDiscs, flatSubdivisions2, options) {
+  const albums = /* @__PURE__ */ new Map();
+  const unmatched = [];
+  for (const item of okItems) {
+    const dir = dirname(item.path);
+    const albumTag = item.tags.album?.[0]?.trim();
+    const albumArtistTag = item.tags.albumArtist?.[0]?.trim();
+    if (albumTag) {
+      const artistPart = isGenericAlbumArtist(albumArtistTag) ? "" : normalizeKey(albumArtistTag ?? "");
+      const key2 = `${artistPart}::${normalizeKey(albumTag)}`;
+      let acc2 = albums.get(key2);
+      if (!acc2) {
+        acc2 = {
+          key: key2,
+          album: albumTag,
+          albumArtist: isGenericAlbumArtist(albumArtistTag) ? void 0 : albumArtistTag,
+          source: "tags",
+          directory: void 0,
+          items: [],
+          evidence: /* @__PURE__ */ new Map()
+        };
+        albums.set(key2, acc2);
+      }
+      const evidence2 = evidenceFor(item, confirmedDiscs, flatSubdivisions2);
+      acc2.evidence.set(item.path, evidence2);
+      acc2.items.push({
+        ...item.metadata,
+        albumDir: evidence2?.albumDir ?? dir,
+        discNumber: evidence2?.folderDiscNumber
+      });
+      continue;
+    }
+    if (!options.useFolderFallback) {
+      unmatched.push(item.metadata);
+      continue;
+    }
+    const identity = folderIdentity(dir, confirmedDiscs, options.scanRoot);
+    if (!identity) {
+      unmatched.push(item.metadata);
+      continue;
+    }
+    const key = `${identity.titleSource}::${normalizeKey(identity.title)}`;
+    let acc = albums.get(key);
+    if (!acc) {
+      acc = {
+        key,
+        album: identity.title,
+        albumArtist: void 0,
+        source: "folder",
+        directory: identity.titleSource,
+        items: [],
+        evidence: /* @__PURE__ */ new Map()
+      };
+      albums.set(key, acc);
+    }
+    const evidence = evidenceFor(item, confirmedDiscs, flatSubdivisions2);
+    acc.evidence.set(item.path, evidence);
+    acc.items.push({
+      ...item.metadata,
+      albumDir: evidence?.albumDir ?? dir,
+      discNumber: evidence?.folderDiscNumber
+    });
+  }
+  for (const [key, acc] of [...albums]) {
+    if (acc.source === "tags") continue;
+    for (const other of albums.values()) {
+      if (other === acc || other.source !== "tags") continue;
+      if (normalizeKey(other.album) !== normalizeKey(acc.album)) continue;
+      const albumDir = acc.directory;
+      const sharesChain = albumDir !== void 0 && other.items.some((o) => {
+        const od = dirname(o.path);
+        return od === albumDir || od.startsWith(albumDir + "/");
+      });
+      if (!sharesChain) continue;
+      for (const item of acc.items) {
+        other.items.push(item);
+        other.evidence.set(item.path, acc.evidence.get(item.path));
+      }
+      albums.delete(key);
+      break;
+    }
+  }
+  return { albums, unmatched };
+}
+
+// src/folder-api/album-discs.ts
+function assembleDiscs(albums) {
+  const groups = [];
+  for (const acc of albums.values()) {
+    const dirTagCommon = /* @__PURE__ */ new Map();
+    const resolvedByFile = /* @__PURE__ */ new Map();
+    for (const item of acc.items) {
+      const dir = dirname(item.path);
+      if (!dirTagCommon.has(dir)) {
+        const tagged = acc.items.filter((i) => dirname(i.path) === dir).map((i) => i.tags.discNumber).filter((d) => d !== void 0 && d > 0);
+        dirTagCommon.set(
+          dir,
+          tagged.length > 0 && tagged.every((d) => d === tagged[0]) ? tagged[0] : void 0
+        );
+      }
+      const evidence = acc.evidence.get(item.path);
+      const tagCommon = dirTagCommon.get(dir);
+      resolvedByFile.set(
+        item.path,
+        tagCommon ?? evidence?.folderDiscNumber
+      );
+    }
+    const discs = /* @__PURE__ */ new Map();
+    const order = [];
+    const noEvidenceItems = [];
+    for (const item of acc.items) {
+      const evidence = acc.evidence.get(item.path);
+      if (evidence === void 0) {
+        noEvidenceItems.push(item);
+        continue;
+      }
+      const resolved = resolvedByFile.get(item.path);
+      const discKey = resolved === void 0 ? `dir:${dirname(item.path)}` : String(resolved);
+      let disc = discs.get(discKey);
+      if (!disc) {
+        disc = {
+          discNumber: resolved,
+          totalDiscs: evidence.total,
+          folderDiscNumber: evidence.folderDiscNumber,
+          folderDiscTitle: evidence.folderDiscTitle,
+          tagDiscNumber: void 0,
+          confidence: evidence.confidence,
+          items: []
+        };
+        discs.set(discKey, disc);
+        order.push(discKey);
+      }
+      disc.items.push(item);
+    }
+    if (noEvidenceItems.length > 0) {
+      const numbered = [...discs.values()].filter((d) => d.folderDiscNumber !== void 0).sort((a, b) => a.folderDiscNumber - b.folderDiscNumber);
+      if (numbered.length > 0) {
+        numbered[0].items.push(...noEvidenceItems);
+      } else {
+        const key = "dir:__none__";
+        let disc = discs.get(key);
+        if (!disc) {
+          disc = {
+            discNumber: void 0,
+            totalDiscs: void 0,
+            folderDiscNumber: void 0,
+            folderDiscTitle: void 0,
+            tagDiscNumber: void 0,
+            confidence: "high",
+            items: []
+          };
+          discs.set(key, disc);
+          order.push(key);
+        }
+        disc.items.push(...noEvidenceItems);
+      }
+    }
+    for (const disc of discs.values()) {
+      const tagged = disc.items.map((i) => i.tags.discNumber).filter((d) => d !== void 0 && d > 0);
+      const common = tagged.length > 0 && tagged.every((d) => d === tagged[0]) ? tagged[0] : void 0;
+      disc.tagDiscNumber = common;
+      disc.discNumber = common ?? disc.folderDiscNumber;
+      for (const item of disc.items) item.discNumber = disc.discNumber;
+    }
+    const albumTaggedTotals = acc.items.map((i) => i.tags.totalDiscs).filter((t) => t !== void 0 && t > 0);
+    const commonTotal = albumTaggedTotals.length > 0 && albumTaggedTotals.every((t) => t === albumTaggedTotals[0]) ? albumTaggedTotals[0] : void 0;
+    const ofN = [...discs.values()].map((d) => d.totalDiscs).find(
+      (t) => t !== void 0
+    );
+    const maxSibling = [...discs.values()].map((d) => d.discNumber).filter((n) => n !== void 0).reduce((a, b) => Math.max(a, b), 0) || void 0;
+    for (const disc of discs.values()) {
+      disc.totalDiscs = commonTotal ?? ofN ?? maxSibling;
+    }
+    const sortedDiscs = [...discs.values()].sort((a, b) => {
+      const an = a.discNumber === void 0 ? -1 : a.discNumber;
+      const bn = b.discNumber === void 0 ? -1 : b.discNumber;
+      if (an !== bn) return an - bn;
+      return (a.folderDiscTitle ?? "").localeCompare(b.folderDiscTitle ?? "");
+    });
+    for (const disc of sortedDiscs) {
+      disc.items.sort((a, b) => {
+        const at = a.tags.track ?? Infinity;
+        const bt = b.tags.track ?? Infinity;
+        if (at !== bt) return at - bt;
+        return a.path.localeCompare(b.path);
+      });
+    }
+    const flags = acc.items.map((i) => i.tags.compilation).filter((c) => c !== void 0);
+    const compilation = flags.length > 0 && flags.every((f) => f === flags[0]) ? flags[0] : void 0;
+    const albumDirs = new Set(acc.items.map((i) => i.albumDir));
+    const directory = albumDirs.size === 1 ? [...albumDirs][0] : acc.directory;
+    groups.push({
+      key: acc.key,
+      albumArtist: acc.albumArtist,
+      album: acc.album,
+      source: acc.source,
+      compilation,
+      directory,
+      discs: sortedDiscs,
+      items: sortedDiscs.flatMap((d) => d.items)
+    });
+  }
+  return groups;
+}
+
+// src/folder-api/album-grouping.ts
+function flatPrefix(filename) {
+  const separated = filename.match(/^(\d{1,2})[\s._-](\d{1,2})/);
+  if (separated) return { disc: parseInt(separated[1], 10), form: "separated" };
+  const compact = filename.match(/^(\d)(\d{2})(?:\D|$)/);
+  if (compact) return { disc: parseInt(compact[1], 10), form: "compact" };
+  return void 0;
+}
+function normalizeOk(result) {
+  const okItems = [];
+  const errors = [];
+  for (const item of result.items) {
+    if (item.status === "ok") {
+      okItems.push({ path: item.path, tags: item.tags, metadata: item });
+    } else {
+      errors.push({ path: item.path, error: item.error });
+    }
+  }
+  return { okItems, errors };
+}
+function buildTree(okItems) {
+  const tree = /* @__PURE__ */ new Map();
+  for (const item of okItems) {
+    const dir = dirname(item.path);
+    let node = tree.get(dir);
+    if (!node) {
+      node = { files: [], parent: dirname(dir) };
+      tree.set(dir, node);
+    }
+    node.files.push(item);
+  }
+  return tree;
+}
+function confirmDiscs(tree, minRank) {
+  const confirmedDiscs = /* @__PURE__ */ new Map();
+  for (const [dir, node] of tree) {
+    if (node.files.length === 0) continue;
+    const parse = parseDiscName(basename(dir));
+    if (!parse) continue;
+    const siblings = [...tree.keys()].filter(
+      (d) => d !== dir && dirname(d) === dirname(dir)
+    );
+    const corroboratedBySiblings = corroborated(parse, siblings);
+    let confidence = parse.gated ? "low" : baseConfidence(parse);
+    if (parse.gated) {
+      if (!corroboratedBySiblings) continue;
+    } else if (parse.kind === "bonus" || parse.kind === "bare") {
+      if (!corroboratedBySiblings) continue;
+    } else if (corroboratedBySiblings) {
+      confidence = "high";
+    }
+    if (CONFIDENCE_RANK[confidence] < minRank) continue;
+    confirmedDiscs.set(dir, { parse, confidence });
+  }
+  return confirmedDiscs;
+}
+function flatSubdivisions(tree, confirmedDiscs, useFlatPrefixes) {
+  const flat = /* @__PURE__ */ new Map();
+  if (!useFlatPrefixes) return flat;
+  for (const [dir, node] of tree) {
+    if (node.files.length === 0 || confirmedDiscs.has(dir)) continue;
+    const byFile = /* @__PURE__ */ new Map();
+    const forms = /* @__PURE__ */ new Set();
+    for (const item of node.files) {
+      const prefix = flatPrefix(basename(item.path));
+      if (prefix) {
+        byFile.set(item.path, prefix.disc);
+        forms.add(prefix.form);
+      }
+    }
+    if (byFile.size < 2) continue;
+    const distinct = [...new Set(byFile.values())].sort((a, b) => a - b);
+    const allCompact = forms.size === 1 && forms.has("compact");
+    const plausible = allCompact ? distinct.every((d) => d >= 1 && d <= distinct.length) : true;
+    if (plausible) flat.set(dir, byFile);
+  }
+  return flat;
+}
+function groupAlbums(result, options = {}) {
+  const minRank = CONFIDENCE_RANK[options.minFolderConfidence ?? "low"];
+  const useFlatPrefixes = options.flatDiscPrefixes ?? true;
+  const useFolderFallback = options.folderFallback ?? true;
+  const { okItems, errors } = normalizeOk(result);
+  if (okItems.length === 0) {
+    return { albums: [], singles: [], unmatched: [], errors };
+  }
+  const tree = buildTree(okItems);
+  const confirmedDiscs = confirmDiscs(tree, minRank);
+  const flat = flatSubdivisions(tree, confirmedDiscs, useFlatPrefixes);
+  const { albums, unmatched } = buildAlbumIdentity(
+    okItems,
+    confirmedDiscs,
+    flat,
+    { scanRoot: options.scanRoot, useFolderFallback }
+  );
+  const groups = assembleDiscs(albums);
+  const albumsOut = [];
+  const singles = [];
+  for (const group of groups) {
+    if (group.items.length === 1) {
+      singles.push(group.items[0]);
+    } else {
+      albumsOut.push(group);
+    }
+  }
+  albumsOut.sort(
+    (a, b) => (a.albumArtist ?? "").localeCompare(b.albumArtist ?? "") || (a.album ?? "").localeCompare(b.album ?? "")
+  );
+  return { albums: albumsOut, singles, unmatched, errors };
+}
+
 // src/web-utils/data-url.ts
 init_classes();
 function pictureToDataURL(picture) {
@@ -3841,6 +4750,7 @@ async function createPictureGallery(file, container, options = {}) {
 
 // index.browser.ts
 init_types2();
+init_bext();
 init_rating();
 init_module_loader_browser();
 export {
@@ -3867,6 +4777,7 @@ export {
   applyPictures,
   applyTags,
   applyTagsToFile,
+  bext_exports as bwf,
   canvasToPicture,
   clearPictures,
   clearTags,
@@ -3874,13 +4785,16 @@ export {
   createPictureGallery,
   createTagLib,
   dataURLToPicture,
+  discFolderInfo,
   displayPicture,
   findPictureByType,
   getAllProperties,
   getAllPropertyKeys,
   getPropertiesByFormat,
   getPropertyMetadata,
+  groupAlbums,
   imageFileToPicture,
+  isDenoCompiled,
   isEnvironmentError,
   isFileOperationError,
   isInvalidFormatError,
@@ -3897,6 +4811,7 @@ export {
   propertyValues,
   readCoverArt,
   readFormat,
+  readMediaChecksum,
   readMetadata,
   readMetadataBatch,
   readPictureMetadata,