taglib-wasm 2.2.1 → 2.2.2

package/dist/disc-folder.d.ts

@@ -14,6 +14,8 @@
  * discFolderInfo("CD1"); // { kind: "exact", number: 1, ... }
  * ```
  */
-export * from "./src/folder-api/group-albums.js";
+export { discFolderInfo } from "./src/folder-api/folder-disc.js";
+export { groupAlbums } from "./src/folder-api/album-grouping.js";
+export type { AlbumDisc, AlbumGroup, AlbumGroupingResult, AlbumGroupItem, AlbumGroupKey, DiscConfidence, DiscFolderInfo, GroupAlbumsOptions, } from "./src/folder-api/album-types.js";
 export type { FolderScanResult } from "./src/folder-api/types.js";
 //# sourceMappingURL=disc-folder.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"disc-folder.d.ts","sourceRoot":"","sources":["../disc-folder.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,cAAc,kCAAkC,CAAC;AACjD,YAAY,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC"}
+{"version":3,"file":"disc-folder.d.ts","sourceRoot":"","sources":["../disc-folder.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAGH,OAAO,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAC;AACjE,OAAO,EAAE,WAAW,EAAE,MAAM,oCAAoC,CAAC;AACjE,YAAY,EACV,SAAS,EACT,UAAU,EACV,mBAAmB,EACnB,cAAc,EACd,aAAa,EACb,cAAc,EACd,cAAc,EACd,kBAAkB,GACnB,MAAM,iCAAiC,CAAC;AACzC,YAAY,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC"}

package/dist/disc-folder.js

@@ -1,23 +1,4 @@
-// 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/group-albums.ts
-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/folder-api/folder-disc.ts
 function dirname(path) {
   const i = Math.max(path.lastIndexOf("/"), path.lastIndexOf("\\"));
   return i === -1 ? path : path.slice(0, i);
@@ -168,6 +149,32 @@ function baseConfidence(parse) {
       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;
@@ -193,13 +200,8 @@ function corroborated(parse, siblings) {
   }
   return false;
 }
-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;
-}
+
+// src/folder-api/album-identity.ts
 function normalizeKey(s) {
   return s.trim().toLowerCase().replace(/\s+/g, " ");
 }
@@ -208,134 +210,63 @@ function isGenericAlbumArtist(albumArtist) {
   const n = normalizeKey(albumArtist);
   return n === "various artists" || n === "va";
 }
-var CONFIDENCE_RANK = {
-  low: 0,
-  medium: 1,
-  high: 2
-};
-function groupAlbums(result, options = {}) {
-  const minRank = CONFIDENCE_RANK[options.minFolderConfidence ?? "low"];
-  const useFlatPrefixes = options.flatDiscPrefixes ?? true;
-  const useFolderFallback = options.folderFallback ?? true;
-  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 });
-    }
-  }
-  if (okItems.length === 0) {
-    return { albums: [], singles: [], unmatched: [], errors };
+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)
+    };
   }
-  const scanRoot = options.scanRoot;
-  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);
+  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)
+      };
     }
-    node.files.push(item);
+    const parent = dirname(cursor);
+    if (parent === cursor) break;
+    cursor = parent;
   }
-  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 });
+  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
+    };
   }
-  const flatSubdivisions = /* @__PURE__ */ new Map();
-  if (useFlatPrefixes) {
-    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) flatSubdivisions.set(dir, byFile);
-    }
+  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 = [];
-  const evidenceFor = (item) => {
-    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;
-  };
-  const folderIdentity = (dir) => {
-    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;
-  };
   for (const item of okItems) {
     const dir = dirname(item.path);
     const albumTag = item.tags.album?.[0]?.trim();
@@ -356,7 +287,7 @@ function groupAlbums(result, options = {}) {
         };
         albums.set(key2, acc2);
       }
-      const evidence2 = evidenceFor(item);
+      const evidence2 = evidenceFor(item, confirmedDiscs, flatSubdivisions2);
       acc2.evidence.set(item.path, evidence2);
       acc2.items.push({
         ...item.metadata,
@@ -365,11 +296,11 @@ function groupAlbums(result, options = {}) {
       });
       continue;
     }
-    if (!useFolderFallback) {
+    if (!options.useFolderFallback) {
       unmatched.push(item.metadata);
       continue;
     }
-    const identity = folderIdentity(dir);
+    const identity = folderIdentity(dir, confirmedDiscs, options.scanRoot);
     if (!identity) {
       unmatched.push(item.metadata);
       continue;
@@ -388,7 +319,7 @@ function groupAlbums(result, options = {}) {
       };
       albums.set(key, acc);
     }
-    const evidence = evidenceFor(item);
+    const evidence = evidenceFor(item, confirmedDiscs, flatSubdivisions2);
     acc.evidence.set(item.path, evidence);
     acc.items.push({
       ...item.metadata,
@@ -415,6 +346,11 @@ function groupAlbums(result, options = {}) {
       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();
@@ -530,6 +466,105 @@ function groupAlbums(result, options = {}) {
       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) {

package/dist/index.browser.js

@@ -3004,7 +3004,7 @@ var VERSION;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    VERSION = "2.2.1";
+    VERSION = "2.2.2";
   }
 });
 

package/dist/simple.browser.js

@@ -2936,7 +2936,7 @@ var VERSION;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    VERSION = "2.2.1";
+    VERSION = "2.2.2";
   }
 });
 

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

@@ -0,0 +1,13 @@
+/**
+ * Sibling corroboration for gated disc-folder names (taglib-ys7m split).
+ *
+ * Gated names (title-word markers, single-letter tokens, bonus, bare) are
+ * discs only when a sibling under the same parent confirms them — an
+ * unconditional disc sibling, or sibling numbering of their own (a folder
+ * never confirms itself). Side-letter tokens corroborate each other
+ * ("CD D" + "CD E").
+ */
+import type { DiscConfidence, DiscParse } from "./album-types.js";
+export declare const CONFIDENCE_RANK: Record<DiscConfidence, number>;
+export declare function corroborated(parse: DiscParse, siblings: string[]): boolean;
+//# sourceMappingURL=album-corroborate.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"album-corroborate.d.ts","sourceRoot":"","sources":["../../../src/folder-api/album-corroborate.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAIH,OAAO,KAAK,EAAE,cAAc,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAElE,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,cAAc,EAAE,MAAM,CAI1D,CAAC;AAEF,wBAAgB,YAAY,CAAC,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,OAAO,CAoC1E"}

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

@@ -0,0 +1,36 @@
+import { basename } from "../utils/path.js";
+import { parseDiscName } from "./folder-disc.js";
+const 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;
+}
+export {
+  CONFIDENCE_RANK,
+  corroborated
+};

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

@@ -0,0 +1,13 @@
+/**
+ * Disc assembly and finalization (spec steps 6-7, taglib-ys7m split).
+ *
+ * Each file resolves to a disc number: the common tag value among its
+ * directory's files (missing abstains, disagreement falls back to the
+ * folder), else the folder evidence (own disc parse, ancestor, or flat
+ * filename prefix). Files resolving to the SAME number merge into one
+ * AlbumDisc, with tagDiscNumber recomputed over the merged set.
+ */
+import type { AlbumAccumulator, AlbumGroup } from "./album-types.js";
+/** Assemble discs per album, then sort discs and items (steps 6-7). */
+export declare function assembleDiscs(albums: Map<AlbumAccumulator["key"], AlbumAccumulator>): AlbumGroup[];
+//# sourceMappingURL=album-discs.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"album-discs.d.ts","sourceRoot":"","sources":["../../../src/folder-api/album-discs.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,KAAK,EACV,gBAAgB,EAEhB,UAAU,EAEX,MAAM,kBAAkB,CAAC;AAE1B,uEAAuE;AACvE,wBAAgB,aAAa,CAC3B,MAAM,EAAE,GAAG,CAAC,gBAAgB,CAAC,KAAK,CAAC,EAAE,gBAAgB,CAAC,GACrD,UAAU,EAAE,CAoKd"}

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

@@ -0,0 +1,122 @@
+import { dirname } from "./folder-disc.js";
+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;
+}
+export {
+  assembleDiscs
+};

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

@@ -0,0 +1,24 @@
+/**
+ * @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). taglib-ys7m split: disc
+ * recognition lives in folder-disc.ts, identity in album-identity.ts, disc
+ * assembly in album-discs.ts, types in album-types.ts.
+ *
+ * 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.
+ */
+import type { FolderScanResult } from "./types.js";
+import type { AlbumGroupingResult, GroupAlbumsOptions } from "./album-types.js";
+export declare function groupAlbums(result: FolderScanResult, options?: GroupAlbumsOptions): AlbumGroupingResult;
+//# sourceMappingURL=album-grouping.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"album-grouping.d.ts","sourceRoot":"","sources":["../../../src/folder-api/album-grouping.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAIH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AACnD,OAAO,KAAK,EAEV,mBAAmB,EAInB,kBAAkB,EAEnB,MAAM,kBAAkB,CAAC;AA0I1B,wBAAgB,WAAW,CACzB,MAAM,EAAE,gBAAgB,EACxB,OAAO,GAAE,kBAAuB,GAC/B,mBAAmB,CAuCrB"}