taglib-wasm 0.4.1 → 0.4.2

package/README.md

@@ -43,6 +43,8 @@ TagLib itself is legendary, and a core dependency of many music apps.
   reliability
 - **✅ Two API styles** – Use the “Simple” API (3 functions), or the full “Core”
   API for more advanced applications
+- **✅ Batch folder operations** – Scan directories, process multiple files,
+  find duplicates, and export metadata catalogs
 
 ## 📦 Installation
 
@@ -167,6 +169,36 @@ file.save();
 file.dispose();
 ```
 
+### Batch Folder Operations
+
+Process entire music collections efficiently:
+
+```typescript
+import { findDuplicates, scanFolder } from "taglib-wasm/folder";
+
+// Scan a music library
+const result = await scanFolder("/path/to/music", {
+  recursive: true,
+  concurrency: 4,
+  onProgress: (processed, total, file) => {
+    console.log(`Processing ${processed}/${total}: ${file}`);
+  },
+});
+
+console.log(`Found ${result.totalFound} audio files`);
+console.log(`Successfully processed ${result.totalProcessed} files`);
+
+// Process results
+for (const file of result.files) {
+  console.log(`${file.path}: ${file.tags.artist} - ${file.tags.title}`);
+  console.log(`Duration: ${file.properties?.duration}s`);
+}
+
+// Find duplicates
+const duplicates = await findDuplicates("/path/to/music", ["artist", "title"]);
+console.log(`Found ${duplicates.size} groups of duplicates`);
+```
+
 ### Working with Cover Art
 
 ```typescript

package/dist/index.d.ts

@@ -79,6 +79,14 @@ export { FormatMappings, getAllTagNames, isValidTagName, Tags, } from "./src/con
  * @see {@link copyCoverArt} - Copy cover art between files
  */
 export { copyCoverArt, exportAllPictures, exportCoverArt, exportPictureByType, findCoverArtFiles, importCoverArt, importPictureWithType, loadPictureFromFile, savePictureToFile, } from "./src/file-utils.ts";
+/**
+ * Folder/batch operations for processing multiple audio files.
+ * @see {@link scanFolder} - Scan folder for audio files and read metadata
+ * @see {@link updateFolderTags} - Update tags for multiple files
+ * @see {@link findDuplicates} - Find duplicate files based on metadata
+ * @see {@link exportFolderMetadata} - Export folder metadata to JSON
+ */
+export { type AudioFileMetadata, exportFolderMetadata, findDuplicates, type FolderScanOptions, type FolderScanResult, scanFolder, updateFolderTags, } from "./src/folder-api.ts";
 /**
  * Web browser utilities for cover art operations.
  * @see {@link pictureToDataURL} - Convert picture to data URL

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH;;;;;GAKG;AACH,OAAO,EACL,aAAa,IAAI,SAAS,EAC1B,YAAY,EACZ,MAAM,GACP,MAAM,iBAAiB,CAAC;AAEzB;;;;;;;;;;GAUG;AACH,OAAO,EACL,gBAAgB,EAChB,kBAAkB,EAClB,kBAAkB,EAClB,kBAAkB,EAClB,oBAAoB,EACpB,oBAAoB,EACpB,aAAa,EACb,eAAe,EACf,aAAa,EACb,wBAAwB,EACxB,WAAW,EACX,aAAa,EACb,iBAAiB,EACjB,WAAW,EACX,yBAAyB,EACzB,sBAAsB,GACvB,MAAM,iBAAiB,CAAC;AAEzB;;;;;;;;;;;GAWG;AACH,OAAO,EACL,UAAU,EACV,aAAa,EACb,SAAS,EACT,aAAa,EACb,SAAS,EACT,iBAAiB,EACjB,WAAW,EACX,SAAS,EACT,kBAAkB,EAClB,gBAAgB,EAChB,YAAY,EACZ,cAAc,EACd,QAAQ,EACR,oBAAoB,EACpB,WAAW,EACX,UAAU,GACX,MAAM,iBAAiB,CAAC;AAEzB;;;;;;GAMG;AACH,OAAO,EACL,cAAc,EACd,cAAc,EACd,cAAc,EACd,IAAI,GACL,MAAM,oBAAoB,CAAC;AAC5B;;;;;GAKG;AACH,OAAO,EACL,YAAY,EACZ,iBAAiB,EACjB,cAAc,EACd,mBAAmB,EACnB,iBAAiB,EACjB,cAAc,EACd,qBAAqB,EACrB,mBAAmB,EACnB,iBAAiB,GAClB,MAAM,qBAAqB,CAAC;AAE7B;;;;;GAKG;AACH,OAAO,EACL,eAAe,EACf,wBAAwB,EACxB,oBAAoB,EACpB,gBAAgB,EAChB,cAAc,EACd,kBAAkB,EAClB,gBAAgB,EAChB,qBAAqB,GACtB,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;;GAQG;AACH,YAAY,EACV,WAAW,EACX,eAAe,EACf,WAAW,EACX,YAAY,EACZ,QAAQ,EACR,OAAO,EACP,WAAW,EACX,GAAG,EACH,OAAO,GACR,MAAM,gBAAgB,CAAC;AAExB;;GAEG;AACH,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAE7C;;;;GAIG;AACH,YAAY,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAG9D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAElD;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC;;;OAGG;IACH,UAAU,CAAC,EAAE,WAAW,GAAG,UAAU,CAAC;IAEtC;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAsB,gBAAgB,CACpC,OAAO,CAAC,EAAE,iBAAiB,GAC1B,OAAO,CAAC,YAAY,CAAC,CA0BvB"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH;;;;;GAKG;AACH,OAAO,EACL,aAAa,IAAI,SAAS,EAC1B,YAAY,EACZ,MAAM,GACP,MAAM,iBAAiB,CAAC;AAEzB;;;;;;;;;;GAUG;AACH,OAAO,EACL,gBAAgB,EAChB,kBAAkB,EAClB,kBAAkB,EAClB,kBAAkB,EAClB,oBAAoB,EACpB,oBAAoB,EACpB,aAAa,EACb,eAAe,EACf,aAAa,EACb,wBAAwB,EACxB,WAAW,EACX,aAAa,EACb,iBAAiB,EACjB,WAAW,EACX,yBAAyB,EACzB,sBAAsB,GACvB,MAAM,iBAAiB,CAAC;AAEzB;;;;;;;;;;;GAWG;AACH,OAAO,EACL,UAAU,EACV,aAAa,EACb,SAAS,EACT,aAAa,EACb,SAAS,EACT,iBAAiB,EACjB,WAAW,EACX,SAAS,EACT,kBAAkB,EAClB,gBAAgB,EAChB,YAAY,EACZ,cAAc,EACd,QAAQ,EACR,oBAAoB,EACpB,WAAW,EACX,UAAU,GACX,MAAM,iBAAiB,CAAC;AAEzB;;;;;;GAMG;AACH,OAAO,EACL,cAAc,EACd,cAAc,EACd,cAAc,EACd,IAAI,GACL,MAAM,oBAAoB,CAAC;AAC5B;;;;;GAKG;AACH,OAAO,EACL,YAAY,EACZ,iBAAiB,EACjB,cAAc,EACd,mBAAmB,EACnB,iBAAiB,EACjB,cAAc,EACd,qBAAqB,EACrB,mBAAmB,EACnB,iBAAiB,GAClB,MAAM,qBAAqB,CAAC;AAE7B;;;;;;GAMG;AACH,OAAO,EACL,KAAK,iBAAiB,EACtB,oBAAoB,EACpB,cAAc,EACd,KAAK,iBAAiB,EACtB,KAAK,gBAAgB,EACrB,UAAU,EACV,gBAAgB,GACjB,MAAM,qBAAqB,CAAC;AAE7B;;;;;GAKG;AACH,OAAO,EACL,eAAe,EACf,wBAAwB,EACxB,oBAAoB,EACpB,gBAAgB,EAChB,cAAc,EACd,kBAAkB,EAClB,gBAAgB,EAChB,qBAAqB,GACtB,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;;GAQG;AACH,YAAY,EACV,WAAW,EACX,eAAe,EACf,WAAW,EACX,YAAY,EACZ,QAAQ,EACR,OAAO,EACP,WAAW,EACX,GAAG,EACH,OAAO,GACR,MAAM,gBAAgB,CAAC;AAExB;;GAEG;AACH,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAE7C;;;;GAIG;AACH,YAAY,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAG9D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAElD;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC;;;OAGG;IACH,UAAU,CAAC,EAAE,WAAW,GAAG,UAAU,CAAC;IAEtC;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAsB,gBAAgB,CACpC,OAAO,CAAC,EAAE,iBAAiB,GAC1B,OAAO,CAAC,YAAY,CAAC,CA0BvB"}

package/dist/index.js

@@ -57,6 +57,12 @@ import {
   loadPictureFromFile,
   savePictureToFile
 } from "./src/file-utils.js";
+import {
+  exportFolderMetadata,
+  findDuplicates,
+  scanFolder,
+  updateFolderTags
+} from "./src/folder-api.js";
 import {
   canvasToPicture,
   createPictureDownloadURL,
@@ -114,8 +120,10 @@ export {
   displayPicture,
   exportAllPictures,
   exportCoverArt,
+  exportFolderMetadata,
   exportPictureByType,
   findCoverArtFiles,
+  findDuplicates,
   findPictureByType,
   getAllTagNames,
   getCoverArt,
@@ -141,7 +149,9 @@ export {
   readTags,
   replacePictureByType,
   savePictureToFile,
+  scanFolder,
   setCoverArt,
   setCoverArtFromCanvas,
+  updateFolderTags,
   updateTags
 };

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

@@ -0,0 +1,136 @@
+/**
+ * Batch folder operations for taglib-wasm
+ * Provides APIs for scanning directories and processing multiple audio files
+ */
+import { type Tag } from "./simple.ts";
+import type { AudioProperties } from "./types.ts";
+/**
+ * Metadata for a single audio file including path information
+ */
+export interface AudioFileMetadata {
+    /** Absolute or relative path to the audio file */
+    path: string;
+    /** Basic tag information (title, artist, album, etc.) */
+    tags: Tag;
+    /** Audio properties (duration, bitrate, sample rate, etc.) */
+    properties?: AudioProperties;
+    /** Any errors encountered while reading this file */
+    error?: Error;
+}
+/**
+ * Options for scanning folders
+ */
+export interface FolderScanOptions {
+    /** Whether to scan subdirectories recursively (default: true) */
+    recursive?: boolean;
+    /** File extensions to include (default: common audio formats) */
+    extensions?: string[];
+    /** Maximum number of files to process (default: unlimited) */
+    maxFiles?: number;
+    /** Progress callback called after each file is processed */
+    onProgress?: (processed: number, total: number, currentFile: string) => void;
+    /** Whether to include audio properties (default: true) */
+    includeProperties?: boolean;
+    /** Whether to continue on errors (default: true) */
+    continueOnError?: boolean;
+    /** Number of files to process in parallel (default: 4) */
+    concurrency?: number;
+}
+/**
+ * Result of a folder scan operation
+ */
+export interface FolderScanResult {
+    /** Successfully processed files with metadata */
+    files: AudioFileMetadata[];
+    /** Files that failed to process */
+    errors: Array<{
+        path: string;
+        error: Error;
+    }>;
+    /** Total number of audio files found */
+    totalFound: number;
+    /** Total number of files successfully processed */
+    totalProcessed: number;
+    /** Time taken in milliseconds */
+    duration: number;
+}
+/**
+ * Scan a folder and read metadata from all audio files
+ *
+ * @param folderPath - Path to the folder to scan
+ * @param options - Scanning options
+ * @returns Metadata for all audio files found
+ *
+ * @example
+ * ```typescript
+ * // Scan a folder recursively
+ * const result = await scanFolder("/path/to/music");
+ * console.log(`Found ${result.totalFound} audio files`);
+ * console.log(`Successfully processed ${result.totalProcessed} files`);
+ *
+ * // Process results
+ * for (const file of result.files) {
+ *   console.log(`${file.path}: ${file.tags.artist} - ${file.tags.title}`);
+ * }
+ *
+ * // Scan with options
+ * const result2 = await scanFolder("/path/to/music", {
+ *   recursive: false,
+ *   extensions: [".mp3", ".flac"],
+ *   onProgress: (processed, total, file) => {
+ *     console.log(`Processing ${processed}/${total}: ${file}`);
+ *   }
+ * });
+ * ```
+ */
+export declare function scanFolder(folderPath: string, options?: FolderScanOptions): Promise<FolderScanResult>;
+/**
+ * Update metadata for multiple files in a folder
+ *
+ * @param updates - Array of objects containing path and tags to update
+ * @param options - Update options
+ * @returns Results of the update operation
+ *
+ * @example
+ * ```typescript
+ * // Update multiple files
+ * const updates = [
+ *   { path: "/music/song1.mp3", tags: { artist: "New Artist" } },
+ *   { path: "/music/song2.mp3", tags: { album: "New Album" } }
+ * ];
+ *
+ * const result = await updateFolderTags(updates);
+ * console.log(`Updated ${result.successful} files`);
+ * ```
+ */
+export declare function updateFolderTags(updates: Array<{
+    path: string;
+    tags: Partial<Tag>;
+}>, options?: {
+    continueOnError?: boolean;
+    concurrency?: number;
+}): Promise<{
+    successful: number;
+    failed: Array<{
+        path: string;
+        error: Error;
+    }>;
+    duration: number;
+}>;
+/**
+ * Find duplicate audio files based on metadata
+ *
+ * @param folderPath - Path to scan for duplicates
+ * @param criteria - Which fields to compare (default: artist and title)
+ * @returns Groups of potential duplicate files
+ */
+export declare function findDuplicates(folderPath: string, criteria?: Array<keyof Tag>): Promise<Map<string, AudioFileMetadata[]>>;
+/**
+ * Export metadata from a folder to JSON
+ *
+ * @param folderPath - Path to scan
+ * @param outputPath - Where to save the JSON file
+ * @param options - Scan options
+ */
+export declare function exportFolderMetadata(folderPath: string, outputPath: string, options?: FolderScanOptions): Promise<void>;
+//# sourceMappingURL=folder-api.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"folder-api.d.ts","sourceRoot":"","sources":["../../src/folder-api.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,EAAuB,KAAK,GAAG,EAAE,MAAM,aAAa,CAAC;AAC5D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAgBlD;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,kDAAkD;IAClD,IAAI,EAAE,MAAM,CAAC;IACb,yDAAyD;IACzD,IAAI,EAAE,GAAG,CAAC;IACV,8DAA8D;IAC9D,UAAU,CAAC,EAAE,eAAe,CAAC;IAC7B,qDAAqD;IACrD,KAAK,CAAC,EAAE,KAAK,CAAC;CACf;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,iEAAiE;IACjE,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,iEAAiE;IACjE,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IACtB,8DAA8D;IAC9D,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,4DAA4D;IAC5D,UAAU,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,KAAK,IAAI,CAAC;IAC7E,0DAA0D;IAC1D,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,oDAAoD;IACpD,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,0DAA0D;IAC1D,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,iDAAiD;IACjD,KAAK,EAAE,iBAAiB,EAAE,CAAC;IAC3B,mCAAmC;IACnC,MAAM,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,KAAK,CAAA;KAAE,CAAC,CAAC;IAC9C,wCAAwC;IACxC,UAAU,EAAE,MAAM,CAAC;IACnB,mDAAmD;IACnD,cAAc,EAAE,MAAM,CAAC;IACvB,iCAAiC;IACjC,QAAQ,EAAE,MAAM,CAAC;CAClB;AAgHD;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAsB,UAAU,CAC9B,UAAU,EAAE,MAAM,EAClB,OAAO,GAAE,iBAAsB,GAC9B,OAAO,CAAC,gBAAgB,CAAC,CAsF3B;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAsB,gBAAgB,CACpC,OAAO,EAAE,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC,GAAG,CAAC,CAAA;CAAE,CAAC,EACpD,OAAO,GAAE;IAAE,eAAe,CAAC,EAAE,OAAO,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,CAAA;CAAO,GAChE,OAAO,CAAC;IACT,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,KAAK,CAAA;KAAE,CAAC,CAAC;IAC9C,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC,CA0CD;AAED;;;;;;GAMG;AACH,wBAAsB,cAAc,CAClC,UAAU,EAAE,MAAM,EAClB,QAAQ,GAAE,KAAK,CAAC,MAAM,GAAG,CAAuB,GAC/C,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,iBAAiB,EAAE,CAAC,CAAC,CA4B3C;AAED;;;;;;GAMG;AACH,wBAAsB,oBAAoB,CACxC,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,EAClB,OAAO,CAAC,EAAE,iBAAiB,GAC1B,OAAO,CAAC,IAAI,CAAC,CAuBf"}

package/dist/src/folder-api.js

@@ -0,0 +1,242 @@
+import { TagLib } from "./taglib.js";
+import { applyTags, readTags } from "./simple.js";
+function join(...paths) {
+  return paths.filter((p) => p).join("/").replace(/\/+/g, "/");
+}
+function extname(path) {
+  const lastDot = path.lastIndexOf(".");
+  if (lastDot === -1 || lastDot === path.length - 1) return "";
+  return path.slice(lastDot);
+}
+const DEFAULT_AUDIO_EXTENSIONS = [
+  ".mp3",
+  ".m4a",
+  ".mp4",
+  ".flac",
+  ".ogg",
+  ".oga",
+  ".opus",
+  ".wav",
+  ".wv",
+  ".ape",
+  ".mpc",
+  ".tta",
+  ".wma"
+];
+async function* walkDirectory(path, options = {}) {
+  const { recursive = true, extensions = DEFAULT_AUDIO_EXTENSIONS } = options;
+  if (typeof Deno !== "undefined") {
+    for await (const entry of Deno.readDir(path)) {
+      const fullPath = join(path, entry.name);
+      if (entry.isDirectory && recursive) {
+        yield* walkDirectory(fullPath, options);
+      } else if (entry.isFile) {
+        const ext = extname(entry.name).toLowerCase();
+        if (extensions.includes(ext)) {
+          yield fullPath;
+        }
+      }
+    }
+  } else if (typeof globalThis.process !== "undefined" && globalThis.process.versions?.node) {
+    const fs = await import("fs/promises");
+    const entries = await fs.readdir(path, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = join(path, entry.name);
+      if (entry.isDirectory() && recursive) {
+        yield* walkDirectory(fullPath, options);
+      } else if (entry.isFile()) {
+        const ext = extname(entry.name).toLowerCase();
+        if (extensions.includes(ext)) {
+          yield fullPath;
+        }
+      }
+    }
+  } else if (typeof globalThis.process !== "undefined" && globalThis.process.versions?.bun) {
+    const fs = await import("fs/promises");
+    const entries = await fs.readdir(path, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = join(path, entry.name);
+      if (entry.isDirectory() && recursive) {
+        yield* walkDirectory(fullPath, options);
+      } else if (entry.isFile()) {
+        const ext = extname(entry.name).toLowerCase();
+        if (extensions.includes(ext)) {
+          yield fullPath;
+        }
+      }
+    }
+  } else {
+    throw new Error("Directory scanning not supported in this runtime");
+  }
+}
+async function processBatch(files, processor, concurrency) {
+  const results = [];
+  const executing = [];
+  for (const file of files) {
+    const promise = processor(file).then((result) => {
+      results.push(result);
+    });
+    executing.push(promise);
+    if (executing.length >= concurrency) {
+      await Promise.race(executing);
+      executing.splice(executing.findIndex((p) => p === promise), 1);
+    }
+  }
+  await Promise.all(executing);
+  return results;
+}
+async function scanFolder(folderPath, options = {}) {
+  const startTime = Date.now();
+  const {
+    maxFiles = Infinity,
+    includeProperties = true,
+    continueOnError = true,
+    concurrency = 4,
+    onProgress
+  } = options;
+  const files = [];
+  const errors = [];
+  const filePaths = [];
+  let fileCount = 0;
+  for await (const filePath of walkDirectory(folderPath, options)) {
+    filePaths.push(filePath);
+    fileCount++;
+    if (fileCount >= maxFiles) break;
+  }
+  const totalFound = filePaths.length;
+  let processed = 0;
+  const taglib = await TagLib.initialize();
+  try {
+    const processor = async (filePath) => {
+      try {
+        const tags = await readTags(filePath);
+        let properties;
+        if (includeProperties) {
+          const audioFile = await taglib.open(filePath);
+          try {
+            const props = audioFile.audioProperties();
+            if (props) {
+              properties = props;
+            }
+          } finally {
+            audioFile.dispose();
+          }
+        }
+        processed++;
+        onProgress?.(processed, totalFound, filePath);
+        return { path: filePath, tags, properties };
+      } catch (error) {
+        const err = error instanceof Error ? error : new Error(String(error));
+        if (continueOnError) {
+          errors.push({ path: filePath, error: err });
+          processed++;
+          onProgress?.(processed, totalFound, filePath);
+          return { path: filePath, tags: {}, error: err };
+        } else {
+          throw err;
+        }
+      }
+    };
+    const batchSize = concurrency * 10;
+    for (let i = 0; i < filePaths.length; i += batchSize) {
+      const batch = filePaths.slice(
+        i,
+        Math.min(i + batchSize, filePaths.length)
+      );
+      const batchResults = await processBatch(batch, processor, concurrency);
+      files.push(...batchResults.filter((r) => !r.error));
+    }
+  } finally {
+  }
+  return {
+    files,
+    errors,
+    totalFound,
+    totalProcessed: processed,
+    duration: Date.now() - startTime
+  };
+}
+async function updateFolderTags(updates, options = {}) {
+  const startTime = Date.now();
+  const { continueOnError = true, concurrency = 4 } = options;
+  let successful = 0;
+  const failed = [];
+  const processor = async (update) => {
+    try {
+      await applyTags(update.path, update.tags);
+      successful++;
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      if (continueOnError) {
+        failed.push({ path: update.path, error: err });
+      } else {
+        throw err;
+      }
+    }
+  };
+  const batchSize = concurrency * 10;
+  for (let i = 0; i < updates.length; i += batchSize) {
+    const batch = updates.slice(i, Math.min(i + batchSize, updates.length));
+    await processBatch(
+      batch.map((u) => u.path),
+      async (path) => {
+        const update = batch.find((u) => u.path === path);
+        await processor(update);
+        return { path, tags: {} };
+      },
+      concurrency
+    );
+  }
+  return {
+    successful,
+    failed,
+    duration: Date.now() - startTime
+  };
+}
+async function findDuplicates(folderPath, criteria = ["artist", "title"]) {
+  const result = await scanFolder(folderPath);
+  const duplicates = /* @__PURE__ */ new Map();
+  for (const file of result.files) {
+    const key = criteria.map((field) => file.tags[field] || "").filter((v) => v !== "").join("|");
+    if (key) {
+      const group = duplicates.get(key) || [];
+      group.push(file);
+      if (group.length > 1) {
+        duplicates.set(key, group);
+      }
+    }
+  }
+  for (const [key, files] of duplicates.entries()) {
+    if (files.length < 2) {
+      duplicates.delete(key);
+    }
+  }
+  return duplicates;
+}
+async function exportFolderMetadata(folderPath, outputPath, options) {
+  const result = await scanFolder(folderPath, options);
+  const data = {
+    folder: folderPath,
+    scanDate: (/* @__PURE__ */ new Date()).toISOString(),
+    summary: {
+      totalFiles: result.totalFound,
+      processedFiles: result.totalProcessed,
+      errors: result.errors.length,
+      duration: result.duration
+    },
+    files: result.files,
+    errors: result.errors
+  };
+  if (typeof Deno !== "undefined") {
+    await Deno.writeTextFile(outputPath, JSON.stringify(data, null, 2));
+  } else if (typeof globalThis.process !== "undefined") {
+    const fs = await import("fs/promises");
+    await fs.writeFile(outputPath, JSON.stringify(data, null, 2));
+  }
+}
+export {
+  exportFolderMetadata,
+  findDuplicates,
+  scanFolder,
+  updateFolderTags
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "taglib-wasm",
-  "version": "0.4.1",
+  "version": "0.4.2",
   "description": "TagLib for TypeScript platforms: Deno, Node.js, Bun, Electron, browsers, and Cloudflare Workers",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -16,6 +16,10 @@
     "./simple": {
       "types": "./dist/src/simple.d.ts",
       "default": "./dist/src/simple.js"
+    },
+    "./folder": {
+      "types": "./dist/src/folder-api.d.ts",
+      "default": "./dist/src/folder-api.js"
     }
   },
   "files": [