taglib-wasm 2.2.1 → 2.2.2

package/dist/src/folder-api/album-grouping.js

@@ -0,0 +1,118 @@
+import { basename } from "../utils/path.js";
+import { dirname } from "./folder-disc.js";
+import { baseConfidence, parseDiscName } from "./folder-disc.js";
+import { CONFIDENCE_RANK, corroborated } from "./album-corroborate.js";
+import { buildAlbumIdentity } from "./album-identity.js";
+import { assembleDiscs } from "./album-discs.js";
+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 };
+}
+export {
+  groupAlbums
+};

package/dist/src/folder-api/album-identity.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Album identity resolution (spec step 5, taglib-ys7m split).
+ *
+ * Tags are authority: key on normalized (albumArtist, album), folding generic
+ * album artists into an album-only key. Untagged files fall back to a folder
+ * walk, and folder-derived groups merge into matching tag-keyed groups.
+ */
+import type { AudioFileMetadata } from "./types.js";
+import type { AlbumAccumulator, AlbumGroupKey, DiscConfidence, DiscParse, OkItem } from "./album-types.js";
+type ConfirmedDiscs = Map<string, {
+    parse: DiscParse;
+    confidence: DiscConfidence;
+}>;
+export interface AlbumIdentity {
+    albums: Map<AlbumGroupKey, AlbumAccumulator>;
+    unmatched: AudioFileMetadata[];
+}
+/**
+ * Build the album map (spec step 5): tag-keyed groups first, folder fallback
+ * for untagged files, then mixed-folder merges into tag-keyed groups.
+ */
+export declare function buildAlbumIdentity(okItems: OkItem[], confirmedDiscs: ConfirmedDiscs, flatSubdivisions: Map<string, Map<string, number>>, options: {
+    scanRoot?: string | undefined;
+    useFolderFallback: boolean;
+}): AlbumIdentity;
+export {};
+//# sourceMappingURL=album-identity.d.ts.map

package/dist/src/folder-api/album-identity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"album-identity.d.ts","sourceRoot":"","sources":["../../../src/folder-api/album-identity.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AACpD,OAAO,KAAK,EACV,gBAAgB,EAChB,aAAa,EACb,cAAc,EACd,SAAS,EAET,MAAM,EACP,MAAM,kBAAkB,CAAC;AAY1B,KAAK,cAAc,GAAG,GAAG,CACvB,MAAM,EACN;IAAE,KAAK,EAAE,SAAS,CAAC;IAAC,UAAU,EAAE,cAAc,CAAA;CAAE,CACjD,CAAC;AAEF,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,GAAG,CAAC,aAAa,EAAE,gBAAgB,CAAC,CAAC;IAC7C,SAAS,EAAE,iBAAiB,EAAE,CAAC;CAChC;AA6ED;;;GAGG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,MAAM,EAAE,EACjB,cAAc,EAAE,cAAc,EAC9B,gBAAgB,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,EAClD,OAAO,EAAE;IAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAAC,iBAAiB,EAAE,OAAO,CAAA;CAAE,GACrE,aAAa,CAmGf"}

package/dist/src/folder-api/album-identity.js

@@ -0,0 +1,151 @@
+import { basename } from "../utils/path.js";
+import { dirname } from "./folder-disc.js";
+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, flatSubdivisions) {
+  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 = flatSubdivisions.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, flatSubdivisions, 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, flatSubdivisions);
+      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, flatSubdivisions);
+    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 };
+}
+export {
+  buildAlbumIdentity
+};

package/dist/src/folder-api/{group-albums.d.ts → album-types.d.ts}

@@ -1,22 +1,9 @@
 /**
- * @fileoverview Pure album grouping over a FolderScanResult (2026-08-03 spec).
- *
- * Given a folder scan, produce albums with disc subdivisions, using embedded
- * tags as authority and folder/filename structure as evidence. Synchronous,
- * runtime-agnostic, no wasm, no I/O: everything the algorithm needs arrives
- * in the scan result (tags, paths, statuses).
- *
- * Model contract (invariants, enforced by tests):
- *   1. Every ok item appears exactly once across albums[*].items, singles,
- *      and unmatched; errors is disjoint.
- *   2. discs >= 1 per album; items >= 1 per disc.
- *   3. discNumber === tagDiscNumber ?? folderDiscNumber on every disc.
- *   4. key is stable for identical input.
- *   5. Every item's albumDir/discNumber match the disc it was assigned to.
- *   6. compilation is true/false only under full tag agreement, else undefined.
- *   7. singles holds exactly the ok items whose resolved album has one file.
+ * Types for pure album grouping (taglib-ys7m split). No runtime imports:
+ * every module in the disc-folder graph must stay Wasm-free (taglib-cd7b).
  */
-import type { AudioFileMetadata, FolderScanResult } from "./types.js";
+import type { AudioFileMetadata } from "./types.js";
+/** Opaque, stable album identity. */
 export type AlbumGroupKey = string & {
     __brand: "AlbumGroupKey";
 };
@@ -111,12 +98,54 @@ export interface DiscFolderInfo {
      * "high" inside groupAlbums. Gated names stay "low" even corroborated. */
     confidence: DiscConfidence;
 }
-/**
- * Recognize a directory name as a disc folder. Standalone — it only
- * classifies the name; it does not resolve the folder to its parent (use
- * the album result's per-file `albumDir` for that). Returns undefined for
- * non-disc names. Plain "Bonus" and "Extras" are never discs by name.
- */
-export declare function discFolderInfo(name: string): DiscFolderInfo | undefined;
-export declare function groupAlbums(result: FolderScanResult, options?: GroupAlbumsOptions): AlbumGroupingResult;
-//# sourceMappingURL=group-albums.d.ts.map
+export type DiscKind = "exact" | "embedded" | "volume" | "bonus" | "bare";
+export interface DiscParse {
+    kind: DiscKind;
+    /** Disc number when the name carries one. */
+    number: number | undefined;
+    /** "of N" total from "CD 1 of 2". */
+    total: number | undefined;
+    /** Title text before an embedded marker ("Album (Disc 1)" -> "Album"). */
+    title: string | undefined;
+    /** Trailing text after the number ("Bonus Tracks" from "Disc 2 (Bonus Tracks)"). */
+    discTitle: string | undefined;
+    /** True for title-word markers (tape/vinyl/cassette/lp/record) and
+     * single-letter number tokens: corroboration required, low confidence. */
+    gated: boolean;
+    /** True when the number token was a single letter ("CD D"): a side label,
+     * not a number — corroboration required (2026-08-04 feedback). */
+    sideLetter: boolean;
+    /** True when the number token was arabic digits ("CD1" vs "Disc One"). */
+    digit: boolean;
+}
+export interface OkItem {
+    path: string;
+    tags: AudioFileMetadata["tags"];
+    metadata: AudioFileMetadata;
+}
+export interface DirNode {
+    files: OkItem[];
+    parent: string | undefined;
+}
+/** Per-file disc evidence, resolved before tag merging. */
+export interface FileDiscEvidence {
+    /** Folder-derived disc number (own/ancestor parse or flat prefix). */
+    folderDiscNumber: number | undefined;
+    /** "of N" total from the folder name. */
+    total: number | undefined;
+    folderDiscTitle: string | undefined;
+    confidence: DiscConfidence;
+    /** The album directory attributed to this file. */
+    albumDir: string;
+}
+/** Accumulator for one album during identity and disc assembly. */
+export interface AlbumAccumulator {
+    key: AlbumGroupKey;
+    album: string;
+    albumArtist: string | undefined;
+    source: "tags" | "folder";
+    directory: string | undefined;
+    items: AlbumGroupItem[];
+    evidence: Map<string, FileDiscEvidence | undefined>;
+}
+//# sourceMappingURL=album-types.d.ts.map

package/dist/src/folder-api/album-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"album-types.d.ts","sourceRoot":"","sources":["../../../src/folder-api/album-types.ts"],"names":[],"mappings":"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"}

package/dist/src/folder-api/folder-disc.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Disc-folder name recognition (pure grammar, taglib-ys7m split).
+ *
+ * Standalone recognizer: classifies a directory name as a disc folder and
+ * corroborates gated names against siblings. No Wasm, no I/O — this module
+ * is part of the disc-folder subpath's pure graph (taglib-cd7b).
+ */
+import type { DiscConfidence, DiscFolderInfo, DiscParse } from "./album-types.js";
+export declare function dirname(path: string): string;
+/**
+ * Parse a directory name as a disc folder. Returns undefined for non-disc
+ * names. Plain "Bonus" and "Extras" are NEVER discs by name (tuneup rule;
+ * the low-tier table's "Extras" row was the flagged divergence).
+ */
+export declare function parseDiscName(name: string): DiscParse | undefined;
+export declare function baseConfidence(parse: DiscParse): DiscConfidence;
+/**
+ * Recognize a directory name as a disc folder. Standalone — it only
+ * classifies the name; it does not resolve the folder to its parent (use
+ * the album result's per-file `albumDir` for that). Returns undefined for
+ * non-disc names. Plain "Bonus" and "Extras" are never discs by name.
+ */
+export declare function discFolderInfo(name: string): DiscFolderInfo | undefined;
+//# sourceMappingURL=folder-disc.d.ts.map

package/dist/src/folder-api/folder-disc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"folder-disc.d.ts","sourceRoot":"","sources":["../../../src/folder-api/folder-disc.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EACV,cAAc,EACd,cAAc,EACd,SAAS,EACV,MAAM,kBAAkB,CAAC;AAE1B,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAG5C;AAyED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS,CA6GjE;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,SAAS,GAAG,cAAc,CAa/D;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc,GAAG,SAAS,CAYvE"}

package/dist/src/folder-api/folder-disc.js

@@ -0,0 +1,169 @@
+function dirname(path) {
+  const i = Math.max(path.lastIndexOf("/"), path.lastIndexOf("\\"));
+  return i === -1 ? path : path.slice(0, i);
+}
+const UNCONDITIONAL_MARKERS = [
+  "cd",
+  "disc",
+  "disk",
+  "dvd",
+  "sacd",
+  "blu-ray",
+  "bd",
+  "digital media"
+];
+const GATED_MARKERS = ["tape", "vinyl", "cassette", "lp", "record"];
+const MARKERS = [...UNCONDITIONAL_MARKERS, ...GATED_MARKERS];
+const GATED_MARKER_SET = new Set(GATED_MARKERS);
+const 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;
+}
+const SEP = String.raw`[\s._#-]*`;
+const 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)
+  };
+}
+export {
+  baseConfidence,
+  dirname,
+  discFolderInfo,
+  parseDiscName
+};

package/dist/src/folder-api/index.d.ts

@@ -5,6 +5,8 @@
 export type { AudioDynamics, AudioFileMetadata, DuplicateGroup, FolderScanItem, FolderScanOptions, FolderScanResult, } from "./types.js";
 export { scanFolder } from "./scan-operations.js";
 export { exportFolderMetadata, findDuplicates } from "./folder-operations.js";
-export { type AlbumDisc, type AlbumGroup, type AlbumGroupingResult, type AlbumGroupItem, type AlbumGroupKey, type DiscConfidence, type DiscFolderInfo, discFolderInfo, groupAlbums, type GroupAlbumsOptions, } from "./group-albums.js";
+export { type AlbumDisc, type AlbumGroup, type AlbumGroupingResult, type AlbumGroupItem, type AlbumGroupKey, type DiscConfidence, type DiscFolderInfo, type GroupAlbumsOptions, } from "./album-types.js";
+export { discFolderInfo } from "./folder-disc.js";
+export { groupAlbums } from "./album-grouping.js";
 export { scanForAlbums, type ScanForAlbumsOptions } from "./scan-for-albums.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/src/folder-api/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/folder-api/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,YAAY,EACV,aAAa,EACb,iBAAiB,EACjB,cAAc,EACd,cAAc,EACd,iBAAiB,EACjB,gBAAgB,GACjB,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAElD,OAAO,EAAE,oBAAoB,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAE9E,OAAO,EACL,KAAK,SAAS,EACd,KAAK,UAAU,EACf,KAAK,mBAAmB,EACxB,KAAK,cAAc,EACnB,KAAK,aAAa,EAClB,KAAK,cAAc,EACnB,KAAK,cAAc,EACnB,cAAc,EACd,WAAW,EACX,KAAK,kBAAkB,GACxB,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EAAE,aAAa,EAAE,KAAK,oBAAoB,EAAE,MAAM,sBAAsB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/folder-api/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,YAAY,EACV,aAAa,EACb,iBAAiB,EACjB,cAAc,EACd,cAAc,EACd,iBAAiB,EACjB,gBAAgB,GACjB,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAElD,OAAO,EAAE,oBAAoB,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAE9E,OAAO,EACL,KAAK,SAAS,EACd,KAAK,UAAU,EACf,KAAK,mBAAmB,EACxB,KAAK,cAAc,EACnB,KAAK,aAAa,EAClB,KAAK,cAAc,EACnB,KAAK,cAAc,EACnB,KAAK,kBAAkB,GACxB,MAAM,kBAAkB,CAAC;AAE1B,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAElD,OAAO,EAAE,aAAa,EAAE,KAAK,oBAAoB,EAAE,MAAM,sBAAsB,CAAC"}

package/dist/src/folder-api/index.js

@@ -1,9 +1,7 @@
 import { scanFolder } from "./scan-operations.js";
 import { exportFolderMetadata, findDuplicates } from "./folder-operations.js";
-import {
-  discFolderInfo,
-  groupAlbums
-} from "./group-albums.js";
+import { discFolderInfo } from "./folder-disc.js";
+import { groupAlbums } from "./album-grouping.js";
 import { scanForAlbums } from "./scan-for-albums.js";
 export {
   discFolderInfo,

package/dist/src/folder-api/scan-for-albums.d.ts

@@ -4,7 +4,7 @@
  * and runtime-agnostic.
  */
 import type { FolderScanOptions } from "./types.js";
-import { type AlbumGroupingResult, type GroupAlbumsOptions } from "./group-albums.js";
+import type { AlbumGroupingResult, GroupAlbumsOptions } from "./album-types.js";
 export type ScanForAlbumsOptions = FolderScanOptions & GroupAlbumsOptions;
 /**
  * Scan a folder and group the result into albums with disc subdivisions.

package/dist/src/folder-api/scan-for-albums.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scan-for-albums.d.ts","sourceRoot":"","sources":["../../../src/folder-api/scan-for-albums.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAEpD,OAAO,EACL,KAAK,mBAAmB,EAExB,KAAK,kBAAkB,EACxB,MAAM,mBAAmB,CAAC;AAE3B,MAAM,MAAM,oBAAoB,GAAG,iBAAiB,GAAG,kBAAkB,CAAC;AAE1E;;;;;;;;;GASG;AACH,wBAAsB,aAAa,CACjC,UAAU,EAAE,MAAM,EAClB,OAAO,GAAE,oBAAyB,GACjC,OAAO,CAAC,mBAAmB,CAAC,CAc9B"}
+{"version":3,"file":"scan-for-albums.d.ts","sourceRoot":"","sources":["../../../src/folder-api/scan-for-albums.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAEpD,OAAO,KAAK,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAGhF,MAAM,MAAM,oBAAoB,GAAG,iBAAiB,GAAG,kBAAkB,CAAC;AAE1E;;;;;;;;;GASG;AACH,wBAAsB,aAAa,CACjC,UAAU,EAAE,MAAM,EAClB,OAAO,GAAE,oBAAyB,GACjC,OAAO,CAAC,mBAAmB,CAAC,CAc9B"}

package/dist/src/folder-api/scan-for-albums.js

@@ -1,7 +1,5 @@
 import { scanFolder } from "./scan-operations.js";
-import {
-  groupAlbums
-} from "./group-albums.js";
+import { groupAlbums } from "./album-grouping.js";
 async function scanForAlbums(folderPath, options = {}) {
   const {
     minFolderConfidence,