reelsort 0.2.5 → 0.2.7

package/dist/index.js

@@ -1150,8 +1150,8 @@ var reset = async ({ dir: inputDir, double }) => {
 var reset_default = reset;
 
 // src/actions/scan.ts
-var import_fs10 = require("fs");
-var import_path11 = require("path");
+var import_fs11 = require("fs");
+var import_path12 = require("path");
 var import_termkit10 = require("termkit");
 
 // src/helpers/detectEdition.ts
@@ -1175,10 +1175,49 @@ var detectEdition = (filename) => {
 // src/helpers/hyperlink.ts
 var hyperlink = (url, text) => `\x1B]8;;${url}\x1B\\${text}\x1B]8;;\x1B\\`;
 
+// src/helpers/trash.ts
+var import_child_process2 = require("child_process");
+var import_fs10 = require("fs");
+var import_os3 = require("os");
+var import_path11 = require("path");
+var trashDir = () => {
+  if (process.platform === "linux") return (0, import_path11.join)((0, import_os3.homedir)(), ".local", "share", "Trash", "files");
+  return (0, import_path11.join)((0, import_os3.homedir)(), ".Trash");
+};
+var trashPath = (filePath, opts) => {
+  if (process.platform === "darwin" || process.platform === "linux") {
+    try {
+      const dir = trashDir();
+      if (!(0, import_fs10.existsSync)(dir)) (0, import_fs10.mkdirSync)(dir, { recursive: true });
+      const name = (0, import_path11.basename)(filePath);
+      let dest = (0, import_path11.join)(dir, name);
+      let i = 1;
+      while ((0, import_fs10.existsSync)(dest)) dest = (0, import_path11.join)(dir, `${name} ${i++}`);
+      (0, import_fs10.renameSync)(filePath, dest);
+      return;
+    } catch {
+    }
+  } else if (process.platform === "win32") {
+    try {
+      const escaped = filePath.replace(/'/g, "''");
+      const isDir = opts?.recursive ?? false;
+      const method = isDir ? "DeleteDirectory" : "DeleteFile";
+      (0, import_child_process2.execSync)(
+        `powershell -NoProfile -NonInteractive -Command "Add-Type -AssemblyName Microsoft.VisualBasic; [Microsoft.VisualBasic.FileIO.FileSystem]::${method}('${escaped}', 'OnlyErrorDialogs', 'SendToRecycleBin')"`,
+        { stdio: "ignore" }
+      );
+      return;
+    } catch {
+    }
+  }
+  (0, import_fs10.rmSync)(filePath, { recursive: opts?.recursive ?? false, force: true });
+};
+
 // src/helpers/parseDownloadName.ts
 var QUALITY_TOKENS = /* @__PURE__ */ new Set(["480p", "576p", "720p", "1080p", "2160p", "4k", "8k", "bluray", "bdrip", "bdremux", "brrip", "webrip", "web-dl", "webdl", "web", "hdtv", "dvdrip", "dvdscr", "cam", "ts", "scr", "x264", "x265", "hevc", "avc", "h264", "h265", "xvid", "divx", "dts", "ac3", "aac", "mp3", "truehd", "atmos", "dd5", "hdr", "hdr10", "hlg", "dv", "dolby", "remux", "proper", "repack", "extended", "theatrical", "unrated", "multi", "dubbed", "subbed", "internal"]);
 var TV_PATTERN = /^(.*?)[.\s_-]*(?:S(\d{2,3})E(\d{2,3})|(\d{1,2})x(\d{2,3})|Season[\s.](\d+))/i;
-var parseDownloadName = (name) => {
+var parseDownloadName = (rawName) => {
+  const name = rawName.replace(/^[\w.-]+\.\w{2,6}\s+-+\s+/i, "");
   const base = name.replace(/\.[a-z0-9]{2,4}$/i, "");
   const tvMatch = TV_PATTERN.exec(base);
   if (tvMatch) {
@@ -1277,45 +1316,63 @@ var bookExtensions_default = ["epub", "mobi", "azw3", "azw"];
 var sameDev = (a, b) => {
   try {
     let bExisting = b;
-    while (!(0, import_fs10.existsSync)(bExisting)) bExisting = (0, import_path11.dirname)(bExisting);
-    return (0, import_fs10.statSync)(a).dev === (0, import_fs10.statSync)(bExisting).dev;
+    while (!(0, import_fs11.existsSync)(bExisting)) bExisting = (0, import_path12.dirname)(bExisting);
+    return (0, import_fs11.statSync)(a).dev === (0, import_fs11.statSync)(bExisting).dev;
   } catch {
     return false;
   }
 };
 var moveFolder = (src, dest) => {
   if (sameDev(src, dest)) {
-    (0, import_fs10.renameSync)(src, dest);
+    (0, import_fs11.renameSync)(src, dest);
   } else {
-    (0, import_fs10.cpSync)(src, dest, { recursive: true });
-    (0, import_fs10.rmSync)(src, { recursive: true, force: true });
+    (0, import_fs11.cpSync)(src, dest, { recursive: true });
+    trashPath(src, { recursive: true });
   }
 };
-var findVideo = (dir) => (0, import_fs10.readdirSync)(dir).find((f) => {
+var findVideo = (dir) => (0, import_fs11.readdirSync)(dir).find((f) => {
   const ext = f.match(/([^.]+$)/)?.[0];
   return ext && videoExtensions_default.includes(ext);
 }) ?? null;
-var containsBook = (dir, depth = 2) => (0, import_fs10.readdirSync)(dir).some((f) => {
+var containsBook = (dir, depth = 2) => (0, import_fs11.readdirSync)(dir).some((f) => {
   const ext = f.match(/([^.]+$)/)?.[0];
   if (ext && bookExtensions_default.includes(ext)) return true;
   if (depth > 1) {
     try {
-      const sub = (0, import_path11.resolve)(dir, f);
-      if ((0, import_fs10.lstatSync)(sub).isDirectory()) return containsBook(sub, depth - 1);
+      const sub = (0, import_path12.resolve)(dir, f);
+      if ((0, import_fs11.lstatSync)(sub).isDirectory()) return containsBook(sub, depth - 1);
     } catch {
     }
   }
   return false;
 });
+var containsPdf = (dir) => {
+  try {
+    return (0, import_fs11.readdirSync)(dir).some((f) => /\.pdf$/i.test(f));
+  } catch {
+    return false;
+  }
+};
+var countVideos = (dir) => {
+  try {
+    return (0, import_fs11.readdirSync)(dir).filter((f) => {
+      if (/\bsample\b/i.test(f)) return false;
+      const ext = f.match(/([^.]+$)/)?.[0];
+      return !!(ext && videoExtensions_default.includes(ext));
+    }).length;
+  } catch {
+    return 0;
+  }
+};
 var isTvEpisodeName = (name) => /S\d{2,3}E\d{2,3}/i.test(name) || /\d+x\d{2,3}/i.test(name);
 var isSeasonDirName = (name) => !isTvEpisodeName(name) && /(?:^|[.\s_-])(?:season|s)\s*0*\d+(?:[.\s_-]|$)/i.test(name);
 var gatherEntries = (source) => {
   const result = [];
-  for (const name of (0, import_fs10.readdirSync)(source)) {
-    const fullPath = (0, import_path11.resolve)(source, name);
+  for (const name of (0, import_fs11.readdirSync)(source)) {
+    const fullPath = (0, import_path12.resolve)(source, name);
     let isDir;
     try {
-      isDir = (0, import_fs10.lstatSync)(fullPath).isDirectory();
+      isDir = (0, import_fs11.lstatSync)(fullPath).isDirectory();
     } catch {
       continue;
     }
@@ -1333,17 +1390,17 @@ var gatherEntries = (source) => {
     }
     let children;
     try {
-      children = (0, import_fs10.readdirSync)(fullPath);
+      children = (0, import_fs11.readdirSync)(fullPath);
     } catch {
       result.push({ entry: name, entryPath: fullPath, isDir: true });
       continue;
     }
     if (children.some((c) => isTvEpisodeName(c))) {
       for (const child of children) {
-        const childPath = (0, import_path11.resolve)(fullPath, child);
+        const childPath = (0, import_path12.resolve)(fullPath, child);
         let childIsDir;
         try {
-          childIsDir = (0, import_fs10.lstatSync)(childPath).isDirectory();
+          childIsDir = (0, import_fs11.lstatSync)(childPath).isDirectory();
         } catch {
           continue;
         }
@@ -1355,25 +1412,25 @@ var gatherEntries = (source) => {
     }
     const seasonDirs = children.filter((c) => {
       try {
-        return isSeasonDirName(c) && (0, import_fs10.lstatSync)((0, import_path11.resolve)(fullPath, c)).isDirectory();
+        return isSeasonDirName(c) && (0, import_fs11.lstatSync)((0, import_path12.resolve)(fullPath, c)).isDirectory();
       } catch {
         return false;
       }
     });
     if (seasonDirs.length > 0) {
       for (const seasonDir of seasonDirs) {
-        const seasonPath = (0, import_path11.resolve)(fullPath, seasonDir);
+        const seasonPath = (0, import_path12.resolve)(fullPath, seasonDir);
         let seasonChildren;
         try {
-          seasonChildren = (0, import_fs10.readdirSync)(seasonPath);
+          seasonChildren = (0, import_fs11.readdirSync)(seasonPath);
         } catch {
           continue;
         }
         for (const child of seasonChildren) {
-          const childPath = (0, import_path11.resolve)(seasonPath, child);
+          const childPath = (0, import_path12.resolve)(seasonPath, child);
           let childIsDir;
           try {
-            childIsDir = (0, import_fs10.lstatSync)(childPath).isDirectory();
+            childIsDir = (0, import_fs11.lstatSync)(childPath).isDirectory();
           } catch {
             continue;
           }
@@ -1389,19 +1446,19 @@ var gatherEntries = (source) => {
   return result;
 };
 var findShowFolder = (destRoot, title) => {
-  if (!(0, import_fs10.existsSync)(destRoot)) return null;
+  if (!(0, import_fs11.existsSync)(destRoot)) return null;
   const normalize = (s) => s.toLowerCase().replace(/[^a-z0-9]/g, "");
   const target = normalize(title);
-  return (0, import_fs10.readdirSync)(destRoot).filter((f) => {
+  return (0, import_fs11.readdirSync)(destRoot).filter((f) => {
     try {
-      return (0, import_fs10.lstatSync)((0, import_path11.resolve)(destRoot, f)).isDirectory();
+      return (0, import_fs11.lstatSync)((0, import_path12.resolve)(destRoot, f)).isDirectory();
     } catch {
       return false;
     }
   }).find((f) => normalize(f) === target) ?? null;
 };
 var findShowFolderByContent = (destRoot, title) => {
-  if (!(0, import_fs10.existsSync)(destRoot)) return null;
+  if (!(0, import_fs11.existsSync)(destRoot)) return null;
   const normalize = (s) => s.toLowerCase().replace(/[^a-z0-9]/g, "");
   const target = normalize(title);
   const matchesTitle = (name) => {
@@ -1409,18 +1466,18 @@ var findShowFolderByContent = (destRoot, title) => {
     const p = parseDownloadName(name);
     return !!p && normalize(p.title) === target;
   };
-  for (const folder of (0, import_fs10.readdirSync)(destRoot)) {
+  for (const folder of (0, import_fs11.readdirSync)(destRoot)) {
     try {
-      const folderPath = (0, import_path11.resolve)(destRoot, folder);
-      if (!(0, import_fs10.lstatSync)(folderPath).isDirectory()) continue;
-      const children = (0, import_fs10.readdirSync)(folderPath);
+      const folderPath = (0, import_path12.resolve)(destRoot, folder);
+      if (!(0, import_fs11.lstatSync)(folderPath).isDirectory()) continue;
+      const children = (0, import_fs11.readdirSync)(folderPath);
       if (children.some(matchesTitle)) return folder;
       for (const child of children) {
         if (!isSeasonDirName(child)) continue;
         try {
-          const seasonPath = (0, import_path11.resolve)(folderPath, child);
-          if (!(0, import_fs10.lstatSync)(seasonPath).isDirectory()) continue;
-          if ((0, import_fs10.readdirSync)(seasonPath).some(matchesTitle)) return folder;
+          const seasonPath = (0, import_path12.resolve)(folderPath, child);
+          if (!(0, import_fs11.lstatSync)(seasonPath).isDirectory()) continue;
+          if ((0, import_fs11.readdirSync)(seasonPath).some(matchesTitle)) return folder;
         } catch {
         }
       }
@@ -1429,15 +1486,19 @@ var findShowFolderByContent = (destRoot, title) => {
   }
   return null;
 };
-var findSeasonFolder = (showPath, season) => {
-  if (!(0, import_fs10.existsSync)(showPath)) return null;
-  const folders = (0, import_fs10.readdirSync)(showPath).filter((f) => {
+var findSeasonFolder = (showPath, season, specialsFolder) => {
+  if (!(0, import_fs11.existsSync)(showPath)) return null;
+  const folders = (0, import_fs11.readdirSync)(showPath).filter((f) => {
     try {
-      return (0, import_fs10.lstatSync)((0, import_path11.resolve)(showPath, f)).isDirectory();
+      return (0, import_fs11.lstatSync)((0, import_path12.resolve)(showPath, f)).isDirectory();
     } catch {
       return false;
     }
   });
+  if (season === 0 && specialsFolder) {
+    const existing = folders.find((f) => f.toLowerCase() === specialsFolder.toLowerCase());
+    if (existing) return existing;
+  }
   return folders.find((f) => {
     const match = f.match(/(?:season|s)\s*0*(\d+)/i);
     return match && parseInt(match[1]) === season;
@@ -1466,11 +1527,13 @@ var scan = async ({ type, hardlink: useHardlink, dryRun, auto, force, interactiv
   const language = config.language ?? "eng";
   const movieFormat = config.format?.movie ?? DEFAULT_MOVIE_FORMAT;
   const seasonFormat = config.format?.season ?? DEFAULT_SEASON_FORMAT;
+  const specialsFolder = config.specialsFolder ?? "Specials";
   const lookupMovie = async (parsed) => {
     let tmdbId;
     let resolvedTitle = parsed.title;
     let resolvedYear = parsed.year;
     if (config.tmdbApiKey) {
+      spinner_default.text = `TMDb: ${parsed.title}`;
       const results = await searchMovie(parsed.title, parsed.year, config.tmdbApiKey);
       if (results.length === 1) {
         tmdbId = results[0].id;
@@ -1498,8 +1561,8 @@ var scan = async ({ type, hardlink: useHardlink, dryRun, auto, force, interactiv
   const importMovie = async (entry, entryPath, isDir, resolvedTitle, resolvedYear, tmdbId, destRoot) => {
     const edition = detectEdition(entry);
     const folderName = formatMovieName(movieFormat, resolvedTitle, resolvedYear, edition);
-    const destFolder = (0, import_path11.resolve)(destRoot, folderName);
-    if ((0, import_fs10.existsSync)(destFolder)) {
+    const destFolder = (0, import_path12.resolve)(destRoot, folderName);
+    if ((0, import_fs11.existsSync)(destFolder)) {
       spinner_default.warn(`already exists: ${folderName}`);
       return false;
     }
@@ -1510,43 +1573,43 @@ var scan = async ({ type, hardlink: useHardlink, dryRun, auto, force, interactiv
     }
     const videoExt = videoFile.match(/([^.]+$)/)?.[0];
     const destVideoName = `${folderName}.${videoExt}`;
-    const videoSourcePath = isDir ? (0, import_path11.resolve)(entryPath, videoFile) : entryPath;
-    const dirFiles = isDir ? (0, import_fs10.readdirSync)(entryPath) : [];
+    const videoSourcePath = isDir ? (0, import_path12.resolve)(entryPath, videoFile) : entryPath;
+    const dirFiles = isDir ? (0, import_fs11.readdirSync)(entryPath) : [];
     const subtitle = isDir ? findSubtitle(dirFiles, language) : null;
     const subtitleExt = subtitle?.match(/([^.]+$)/)?.[0];
-    const subtitleSourcePath = subtitle ? (0, import_path11.resolve)(entryPath, subtitle) : null;
+    const subtitleSourcePath = subtitle ? (0, import_path12.resolve)(entryPath, subtitle) : null;
     const destSubtitleName = subtitle && subtitleExt ? `${folderName}.${subtitleExt}` : null;
     if (!dryRun) {
       if (useHardlink) {
-        (0, import_fs10.mkdirSync)(destFolder, { recursive: true });
-        const destVideoPath = (0, import_path11.resolve)(destFolder, destVideoName);
+        (0, import_fs11.mkdirSync)(destFolder, { recursive: true });
+        const destVideoPath = (0, import_path12.resolve)(destFolder, destVideoName);
         let mode;
         try {
           if (!sameDev(videoSourcePath, destRoot)) throw new Error("cross-filesystem");
-          (0, import_fs10.linkSync)(videoSourcePath, destVideoPath);
+          (0, import_fs11.linkSync)(videoSourcePath, destVideoPath);
           mode = "hardlink";
         } catch {
           spinner_default.warn(`hardlink unavailable \u2014 copying instead: ${folderName}`);
-          (0, import_fs10.cpSync)(videoSourcePath, destVideoPath);
+          (0, import_fs11.cpSync)(videoSourcePath, destVideoPath);
           mode = "copy";
         }
-        if (subtitleSourcePath && destSubtitleName) (0, import_fs10.cpSync)(subtitleSourcePath, (0, import_path11.resolve)(destFolder, destSubtitleName));
+        if (subtitleSourcePath && destSubtitleName) (0, import_fs11.cpSync)(subtitleSourcePath, (0, import_path12.resolve)(destFolder, destSubtitleName));
         recordImport(sessionId, entryPath, destFolder, mode, tmdbId, "movie");
       } else {
         if (isDir) {
           const keep = new Set([videoFile, subtitle].filter(Boolean));
-          for (const f of dirFiles.filter((f2) => !keep.has(f2))) (0, import_fs10.rmSync)((0, import_path11.resolve)(entryPath, f), { recursive: true, force: true });
-          (0, import_fs10.renameSync)(videoSourcePath, (0, import_path11.resolve)(entryPath, destVideoName));
-          if (subtitleSourcePath && destSubtitleName) (0, import_fs10.renameSync)(subtitleSourcePath, (0, import_path11.resolve)(entryPath, destSubtitleName));
+          for (const f of dirFiles.filter((f2) => !keep.has(f2))) trashPath((0, import_path12.resolve)(entryPath, f), { recursive: true });
+          (0, import_fs11.renameSync)(videoSourcePath, (0, import_path12.resolve)(entryPath, destVideoName));
+          if (subtitleSourcePath && destSubtitleName) (0, import_fs11.renameSync)(subtitleSourcePath, (0, import_path12.resolve)(entryPath, destSubtitleName));
           moveFolder(entryPath, destFolder);
         } else {
-          (0, import_fs10.mkdirSync)(destFolder, { recursive: true });
-          const destVideoPath = (0, import_path11.resolve)(destFolder, destVideoName);
+          (0, import_fs11.mkdirSync)(destFolder, { recursive: true });
+          const destVideoPath = (0, import_path12.resolve)(destFolder, destVideoName);
           if (sameDev(videoSourcePath, destRoot)) {
-            (0, import_fs10.renameSync)(videoSourcePath, destVideoPath);
+            (0, import_fs11.renameSync)(videoSourcePath, destVideoPath);
           } else {
-            (0, import_fs10.cpSync)(videoSourcePath, destVideoPath);
-            (0, import_fs10.rmSync)(videoSourcePath);
+            (0, import_fs11.cpSync)(videoSourcePath, destVideoPath);
+            trashPath(videoSourcePath);
           }
         }
         recordImport(sessionId, entryPath, destFolder, "move", tmdbId, "movie");
@@ -1560,15 +1623,18 @@ var scan = async ({ type, hardlink: useHardlink, dryRun, auto, force, interactiv
   let imported = 0, skipped = 0;
   const pendingMovies = [];
   const pendingTv = [];
+  const pendingBooks = [];
+  const pendingAnime = [];
   const ignoreSet = new Set(config.ignore ?? []);
   const seenIgnored = /* @__PURE__ */ new Set();
   for (const source of config.sources) {
-    if (!(0, import_fs10.existsSync)(source)) {
+    if (!(0, import_fs11.existsSync)(source)) {
       spinner_default.warn(`source not found: ${import_termkit10.Color.white.encoder(source)}`);
       continue;
     }
     spinner_default.text = `scanning ${import_termkit10.Color.white.encoder(source)}`;
     for (const { entry, entryPath, isDir } of gatherEntries(source)) {
+      spinner_default.text = `scanning: ${entry}`;
       if (ignoreSet.has(entry)) {
         seenIgnored.add(entry);
         if (isVerbose()) spinner_default.info(`ignored: ${entry}`);
@@ -1603,8 +1669,8 @@ var scan = async ({ type, hardlink: useHardlink, dryRun, auto, force, interactiv
           continue;
         }
         const destName = `${nameMatch[0]} [${id}]`;
-        const destPath = (0, import_path11.resolve)(destRoot, destName);
-        if ((0, import_fs10.existsSync)(destPath)) {
+        const destPath = (0, import_path12.resolve)(destRoot, destName);
+        if ((0, import_fs11.existsSync)(destPath)) {
           spinner_default.warn(`already exists: ${destName}`);
           skipped++;
           continue;
@@ -1618,8 +1684,8 @@ var scan = async ({ type, hardlink: useHardlink, dryRun, auto, force, interactiv
         continue;
       }
       if (detectedType === "book") {
-        const destPath = (0, import_path11.resolve)(destRoot, entry);
-        if ((0, import_fs10.existsSync)(destPath)) {
+        const destPath = (0, import_path12.resolve)(destRoot, entry);
+        if ((0, import_fs11.existsSync)(destPath)) {
           spinner_default.warn(`already exists: ${entry}`);
           skipped++;
           continue;
@@ -1628,12 +1694,12 @@ var scan = async ({ type, hardlink: useHardlink, dryRun, auto, force, interactiv
           if (isDir || isBookDir) {
             moveFolder(entryPath, destPath);
           } else {
-            (0, import_fs10.mkdirSync)(destRoot, { recursive: true });
+            (0, import_fs11.mkdirSync)(destRoot, { recursive: true });
             if (sameDev(entryPath, destRoot)) {
-              (0, import_fs10.renameSync)(entryPath, destPath);
+              (0, import_fs11.renameSync)(entryPath, destPath);
             } else {
-              (0, import_fs10.cpSync)(entryPath, destPath);
-              (0, import_fs10.rmSync)(entryPath);
+              (0, import_fs11.cpSync)(entryPath, destPath);
+              (0, import_fs11.rmSync)(entryPath);
             }
           }
           recordImport(sessionId, entryPath, destPath, "move", void 0, "book");
@@ -1642,6 +1708,22 @@ var scan = async ({ type, hardlink: useHardlink, dryRun, auto, force, interactiv
         imported++;
         continue;
       }
+      if (detectedType === "movie" && isDir) {
+        const videoCount = countVideos(entryPath);
+        if (videoCount === 0) {
+          if (containsPdf(entryPath)) {
+            pendingBooks.push({ entry, entryPath });
+          } else if (isVerbose()) {
+            spinner_default.info(`no media found, skipped: ${entry}`);
+          }
+          skipped++;
+          continue;
+        }
+        if (videoCount >= 2) {
+          pendingAnime.push({ entry, entryPath, videoCount });
+          continue;
+        }
+      }
       const parsed = parseDownloadName(entry);
       if (!parsed) {
         if (isVerbose()) spinner_default.info(`could not parse: ${entry}`);
@@ -1665,6 +1747,7 @@ var scan = async ({ type, hardlink: useHardlink, dryRun, auto, force, interactiv
       let resolvedYear = parsed.year;
       if (config.tmdbApiKey) {
         if (detectedType === "tv") {
+          spinner_default.text = `TMDb: ${parsed.title}`;
           const results = await searchTv(parsed.title, config.tmdbApiKey);
           if (results.length === 1) {
             tmdbId = results[0].id;
@@ -1709,18 +1792,18 @@ var scan = async ({ type, hardlink: useHardlink, dryRun, auto, force, interactiv
           const existingFolder = findShowFolder(destRoot, resolvedTitle) ?? findShowFolderByContent(destRoot, resolvedTitle);
           if (existingFolder) {
             showFolderName = existingFolder;
-            showPath = (0, import_path11.resolve)(destRoot, existingFolder);
+            showPath = (0, import_path12.resolve)(destRoot, existingFolder);
           } else if (auto) {
             showFolderName = formatMovieName(movieFormat, resolvedTitle, resolvedYear);
-            showPath = (0, import_path11.resolve)(destRoot, showFolderName);
+            showPath = (0, import_path12.resolve)(destRoot, showFolderName);
             if (!dryRun) upsertShow(showPath, tmdbId ?? null, resolvedTitle);
           } else {
             pendingTv.push({ entry, entryPath, isDir, parsed, resolvedTitle, destRoot });
             continue;
           }
         }
-        const seasonFolderName = findSeasonFolder(showPath, parsed.season) ?? formatSeasonFolder(seasonFormat, parsed.season);
-        const seasonPath = (0, import_path11.resolve)(showPath, seasonFolderName);
+        const seasonFolderName = parsed.season === 0 ? findSeasonFolder(showPath, 0, specialsFolder) ?? specialsFolder : findSeasonFolder(showPath, parsed.season) ?? formatSeasonFolder(seasonFormat, parsed.season);
+        const seasonPath = (0, import_path12.resolve)(showPath, seasonFolderName);
         const videoFile = isDir ? findVideo(entryPath) : entry;
         if (!videoFile) {
           if (isVerbose()) spinner_default.info(`no video found in: ${entry}`);
@@ -1728,13 +1811,15 @@ var scan = async ({ type, hardlink: useHardlink, dryRun, auto, force, interactiv
           continue;
         }
         const videoExt = videoFile.match(/([^.]+$)/)?.[0];
+        if (tmdbId && config.tmdbApiKey) spinner_default.text = `TMDb: episode name for ${resolvedTitle}`;
         const tmdbEpisodeName = tmdbId && config.tmdbApiKey ? await getEpisodeName(tmdbId, parsed.season, parsed.episode ?? 1, config.tmdbApiKey) : null;
         const episodeName = formatEpisode(parsed.season, parsed.episode ?? 1, config.format?.episode, false, resolvedTitle, tmdbEpisodeName ?? void 0);
         const destVideoName = `${episodeName}.${videoExt}`;
-        const destVideoPath = (0, import_path11.resolve)(seasonPath, destVideoName);
-        const videoSourcePath = isDir ? (0, import_path11.resolve)(entryPath, videoFile) : entryPath;
-        if ((0, import_fs10.existsSync)(destVideoPath)) {
-          let shouldReplace = force;
+        const destVideoPath = (0, import_path12.resolve)(seasonPath, destVideoName);
+        const videoSourcePath = isDir ? (0, import_path12.resolve)(entryPath, videoFile) : entryPath;
+        if ((0, import_fs11.existsSync)(destVideoPath)) {
+          const isRepack = /\brepack\d*\b|\bproper\b/i.test(entry);
+          let shouldReplace = force || isRepack;
           if (!shouldReplace && interactive) {
             spinner_default.stop();
             const select = new import_termkit10.Select();
@@ -1751,39 +1836,39 @@ var scan = async ({ type, hardlink: useHardlink, dryRun, auto, force, interactiv
             continue;
           }
           if (!dryRun) {
-            for (const f of (0, import_fs10.readdirSync)(seasonPath)) {
-              if (f.startsWith(`${episodeName}.`)) (0, import_fs10.rmSync)((0, import_path11.resolve)(seasonPath, f));
+            for (const f of (0, import_fs11.readdirSync)(seasonPath)) {
+              if (f.startsWith(`${episodeName}.`)) trashPath((0, import_path12.resolve)(seasonPath, f));
             }
           }
         }
-        const dirFiles = isDir ? (0, import_fs10.readdirSync)(entryPath) : [];
+        const dirFiles = isDir ? (0, import_fs11.readdirSync)(entryPath) : [];
         const subtitle = isDir ? findSubtitle(dirFiles, language) : null;
         const subtitleExt = subtitle?.match(/([^.]+$)/)?.[0];
-        const subtitleSourcePath = subtitle ? (0, import_path11.resolve)(entryPath, subtitle) : null;
+        const subtitleSourcePath = subtitle ? (0, import_path12.resolve)(entryPath, subtitle) : null;
         const destSubtitleName = subtitle && subtitleExt ? `${episodeName}.${subtitleExt}` : null;
         if (!dryRun) {
-          (0, import_fs10.mkdirSync)(seasonPath, { recursive: true });
+          (0, import_fs11.mkdirSync)(seasonPath, { recursive: true });
           let mode = "move";
           if (useHardlink) {
             try {
               if (!sameDev(videoSourcePath, seasonPath)) throw new Error("cross-filesystem");
-              (0, import_fs10.linkSync)(videoSourcePath, destVideoPath);
+              (0, import_fs11.linkSync)(videoSourcePath, destVideoPath);
               mode = "hardlink";
             } catch {
               spinner_default.warn(`hardlink unavailable \u2014 copying instead: ${episodeName}`);
-              (0, import_fs10.cpSync)(videoSourcePath, destVideoPath);
+              (0, import_fs11.cpSync)(videoSourcePath, destVideoPath);
               mode = "copy";
             }
-            if (subtitleSourcePath && destSubtitleName) (0, import_fs10.cpSync)(subtitleSourcePath, (0, import_path11.resolve)(seasonPath, destSubtitleName));
+            if (subtitleSourcePath && destSubtitleName) (0, import_fs11.cpSync)(subtitleSourcePath, (0, import_path12.resolve)(seasonPath, destSubtitleName));
           } else {
             if (sameDev(videoSourcePath, seasonPath)) {
-              (0, import_fs10.renameSync)(videoSourcePath, destVideoPath);
+              (0, import_fs11.renameSync)(videoSourcePath, destVideoPath);
             } else {
-              (0, import_fs10.cpSync)(videoSourcePath, destVideoPath);
-              (0, import_fs10.rmSync)(videoSourcePath);
+              (0, import_fs11.cpSync)(videoSourcePath, destVideoPath);
+              trashPath(videoSourcePath);
             }
-            if (subtitleSourcePath && destSubtitleName) (0, import_fs10.renameSync)(subtitleSourcePath, (0, import_path11.resolve)(seasonPath, destSubtitleName));
-            if (isDir) (0, import_fs10.rmSync)(entryPath, { recursive: true, force: true });
+            if (subtitleSourcePath && destSubtitleName) (0, import_fs11.renameSync)(subtitleSourcePath, (0, import_path12.resolve)(seasonPath, destSubtitleName));
+            if (isDir) trashPath(entryPath, { recursive: true });
           }
           recordImport(sessionId, entryPath, seasonPath, mode, tmdbId, "tv");
         }
@@ -1832,6 +1917,15 @@ var scan = async ({ type, hardlink: useHardlink, dryRun, auto, force, interactiv
     for (const p of pendingTv) spinner_default.info(`  ${typeGlyph("tv")} ${p.resolvedTitle} \u2014 ${p.entry.replace(/\/$/, "")}${typeTag("tv")}`);
     skipped += pendingTv.length;
   }
+  if (pendingBooks.length > 0) {
+    spinner_default.warn(`${pendingBooks.length} uncertain book${pendingBooks.length > 1 ? "s" : ""} skipped \u2014 contains PDFs, review manually`);
+    for (const p of pendingBooks) spinner_default.info(`  ${typeGlyph("book")} ${p.entry}${typeTag("book")}`);
+  }
+  if (pendingAnime.length > 0) {
+    spinner_default.warn(`${pendingAnime.length} uncertain anime/TV director${pendingAnime.length > 1 ? "ies" : "y"} skipped \u2014 multiple videos with no episode naming`);
+    for (const p of pendingAnime) spinner_default.info(`  ${typeGlyph("tv")} ${p.entry} (${p.videoCount} video${p.videoCount > 1 ? "s" : ""})${typeTag("tv")}`);
+    skipped += pendingAnime.length;
+  }
   if (ignoreSet.size > 0) {
     const stale = [...ignoreSet].filter((name) => !seenIgnored.has(name));
     if (stale.length > 0 && !dryRun) {
@@ -1848,7 +1942,7 @@ var scan = async ({ type, hardlink: useHardlink, dryRun, auto, force, interactiv
 var scan_default = scan;
 
 // src/actions/undo.ts
-var import_fs11 = require("fs");
+var import_fs12 = require("fs");
 var import_termkit11 = require("termkit");
 var undo = async () => {
   spinner_default.start();
@@ -1863,7 +1957,7 @@ var undo = async () => {
   if (!useImports) {
     let undone2 = 0;
     for (const record of renameRecords) {
-      (0, import_fs11.renameSync)(record.newPath, record.oldPath);
+      (0, import_fs12.renameSync)(record.newPath, record.oldPath);
       spinner_default.succeed(`${import_termkit11.Color.green.encoder(record.newPath)} \u2192 ${import_termkit11.Color.white.encoder(record.oldPath)}`);
       undone2++;
     }
@@ -1885,12 +1979,12 @@ var undo = async () => {
       skipped++;
       continue;
     }
-    if (!(0, import_fs11.existsSync)(record.destinationPath)) {
+    if (!(0, import_fs12.existsSync)(record.destinationPath)) {
       spinner_default.info(`skipped \u2014 destination no longer exists: ${record.destinationPath}`);
       skipped++;
       continue;
     }
-    (0, import_fs11.renameSync)(record.destinationPath, record.sourcePath);
+    (0, import_fs12.renameSync)(record.destinationPath, record.sourcePath);
     spinner_default.succeed(`${import_termkit11.Color.green.encoder(record.destinationPath)} \u2192 ${import_termkit11.Color.white.encoder(record.sourcePath)}`);
     undone++;
   }
@@ -1903,37 +1997,37 @@ var undo_default = undo;
 
 // src/actions/watch.ts
 var import_chokidar = __toESM(require("chokidar"));
-var import_fs12 = require("fs");
-var import_path12 = require("path");
+var import_fs13 = require("fs");
+var import_path13 = require("path");
 var import_termkit12 = require("termkit");
 var sameDev2 = (a, b) => {
   try {
     let bExisting = b;
-    while (!(0, import_fs12.existsSync)(bExisting)) bExisting = (0, import_path12.dirname)(bExisting);
-    return (0, import_fs12.statSync)(a).dev === (0, import_fs12.statSync)(bExisting).dev;
+    while (!(0, import_fs13.existsSync)(bExisting)) bExisting = (0, import_path13.dirname)(bExisting);
+    return (0, import_fs13.statSync)(a).dev === (0, import_fs13.statSync)(bExisting).dev;
   } catch {
     return false;
   }
 };
 var moveItem = (src, dest) => {
   if (sameDev2(src, dest)) {
-    (0, import_fs12.renameSync)(src, dest);
+    (0, import_fs13.renameSync)(src, dest);
   } else {
-    (0, import_fs12.cpSync)(src, dest, { recursive: true });
-    (0, import_fs12.rmSync)(src, { recursive: true, force: true });
+    (0, import_fs13.cpSync)(src, dest, { recursive: true });
+    (0, import_fs13.rmSync)(src, { recursive: true, force: true });
   }
 };
-var findVideo2 = (dir) => (0, import_fs12.readdirSync)(dir).find((f) => {
+var findVideo2 = (dir) => (0, import_fs13.readdirSync)(dir).find((f) => {
   const ext = f.match(/([^.]+$)/)?.[0];
   return ext && videoExtensions_default.includes(ext);
 }) ?? null;
-var containsBook2 = (dir, depth = 2) => (0, import_fs12.readdirSync)(dir).some((f) => {
+var containsBook2 = (dir, depth = 2) => (0, import_fs13.readdirSync)(dir).some((f) => {
   const ext = f.match(/([^.]+$)/)?.[0];
   if (ext && bookExtensions_default.includes(ext)) return true;
   if (depth > 1) {
     try {
-      const sub = (0, import_path12.resolve)(dir, f);
-      if ((0, import_fs12.lstatSync)(sub).isDirectory()) return containsBook2(sub, depth - 1);
+      const sub = (0, import_path13.resolve)(dir, f);
+      if ((0, import_fs13.lstatSync)(sub).isDirectory()) return containsBook2(sub, depth - 1);
     } catch {
     }
   }
@@ -1944,26 +2038,26 @@ var isSeasonDirName2 = (name) => !isTvEpisodeName2(name) && /(?:^|[.\s_-])(?:sea
 var expandWatchPath = (p) => {
   let isDir;
   try {
-    isDir = (0, import_fs12.lstatSync)(p).isDirectory();
+    isDir = (0, import_fs13.lstatSync)(p).isDirectory();
   } catch {
     return [p];
   }
   if (!isDir) return [p];
-  const name = (0, import_path12.basename)(p);
+  const name = (0, import_path13.basename)(p);
   if (isTvEpisodeName2(name) || /(?<=\[).+?(?=\])/.test(name) || /^[A-Z]{4}\d{5}/i.test(name)) return [p];
   let children;
   try {
-    children = (0, import_fs12.readdirSync)(p);
+    children = (0, import_fs13.readdirSync)(p);
   } catch {
     return [p];
   }
   if (children.some((c) => isTvEpisodeName2(c))) {
     const entries = [];
     for (const child of children) {
-      const cp = (0, import_path12.resolve)(p, child);
+      const cp = (0, import_path13.resolve)(p, child);
       let cd;
       try {
-        cd = (0, import_fs12.lstatSync)(cp).isDirectory();
+        cd = (0, import_fs13.lstatSync)(cp).isDirectory();
       } catch {
         continue;
       }
@@ -1975,7 +2069,7 @@ var expandWatchPath = (p) => {
   }
   const seasonDirs = children.filter((c) => {
     try {
-      return isSeasonDirName2(c) && (0, import_fs12.lstatSync)((0, import_path12.resolve)(p, c)).isDirectory();
+      return isSeasonDirName2(c) && (0, import_fs13.lstatSync)((0, import_path13.resolve)(p, c)).isDirectory();
     } catch {
       return false;
     }
@@ -1983,18 +2077,18 @@ var expandWatchPath = (p) => {
   if (seasonDirs.length > 0) {
     const entries = [];
     for (const sd of seasonDirs) {
-      const sp = (0, import_path12.resolve)(p, sd);
+      const sp = (0, import_path13.resolve)(p, sd);
       let sc;
       try {
-        sc = (0, import_fs12.readdirSync)(sp);
+        sc = (0, import_fs13.readdirSync)(sp);
       } catch {
         continue;
       }
       for (const child of sc) {
-        const cp = (0, import_path12.resolve)(sp, child);
+        const cp = (0, import_path13.resolve)(sp, child);
         let cd;
         try {
-          cd = (0, import_fs12.lstatSync)(cp).isDirectory();
+          cd = (0, import_fs13.lstatSync)(cp).isDirectory();
         } catch {
           continue;
         }
@@ -2008,10 +2102,10 @@ var expandWatchPath = (p) => {
   return [p];
 };
 var findSeasonFolder2 = (showPath, season) => {
-  if (!(0, import_fs12.existsSync)(showPath)) return null;
-  const folders = (0, import_fs12.readdirSync)(showPath).filter((f) => {
+  if (!(0, import_fs13.existsSync)(showPath)) return null;
+  const folders = (0, import_fs13.readdirSync)(showPath).filter((f) => {
     try {
-      return (0, import_fs12.lstatSync)((0, import_path12.resolve)(showPath, f)).isDirectory();
+      return (0, import_fs13.lstatSync)((0, import_path13.resolve)(showPath, f)).isDirectory();
     } catch {
       return false;
     }
@@ -2024,10 +2118,10 @@ var findSeasonFolder2 = (showPath, season) => {
 var processItem = async (entryPath, useHardlink, language, auto) => {
   const config = getConfig();
   const sessionId = (/* @__PURE__ */ new Date()).toISOString();
-  const entry = (0, import_path12.basename)(entryPath);
+  const entry = (0, import_path13.basename)(entryPath);
   const movieFormat = config.format?.movie ?? DEFAULT_MOVIE_FORMAT;
   const seasonFormat = config.format?.season ?? DEFAULT_SEASON_FORMAT;
-  const isDir = (0, import_fs12.lstatSync)(entryPath).isDirectory();
+  const isDir = (0, import_fs13.lstatSync)(entryPath).isDirectory();
   const ext = entry.match(/([^.]+$)/)?.[0];
   const isVideo = !isDir && ext && videoExtensions_default.includes(ext);
   const isBook = !isDir && ext && bookExtensions_default.includes(ext);
@@ -2053,8 +2147,8 @@ var processItem = async (entryPath, useHardlink, language, auto) => {
     const id = entry.split("-")[0];
     if (!nameMatch || !id) return;
     const destName = `${nameMatch[0]} [${id}]`;
-    const destPath = (0, import_path12.resolve)(destRoot, destName);
-    if ((0, import_fs12.existsSync)(destPath)) {
+    const destPath = (0, import_path13.resolve)(destRoot, destName);
+    if ((0, import_fs13.existsSync)(destPath)) {
       spinner_default.warn(`already exists: ${destName}`);
       return;
     }
@@ -2064,20 +2158,20 @@ var processItem = async (entryPath, useHardlink, language, auto) => {
     return;
   }
   if (detectedType === "book") {
-    const destPath = (0, import_path12.resolve)(destRoot, entry);
-    if ((0, import_fs12.existsSync)(destPath)) {
+    const destPath = (0, import_path13.resolve)(destRoot, entry);
+    if ((0, import_fs13.existsSync)(destPath)) {
       spinner_default.warn(`already exists: ${entry}`);
       return;
     }
     if (isDir || isBookDir) {
       moveItem(entryPath, destPath);
     } else {
-      (0, import_fs12.mkdirSync)(destRoot, { recursive: true });
+      (0, import_fs13.mkdirSync)(destRoot, { recursive: true });
       if (sameDev2(entryPath, destRoot)) {
-        (0, import_fs12.renameSync)(entryPath, destPath);
+        (0, import_fs13.renameSync)(entryPath, destPath);
       } else {
-        (0, import_fs12.cpSync)(entryPath, destPath);
-        (0, import_fs12.rmSync)(entryPath);
+        (0, import_fs13.cpSync)(entryPath, destPath);
+        (0, import_fs13.rmSync)(entryPath);
       }
     }
     recordImport(sessionId, entryPath, destPath, "move", void 0, "book");
@@ -2102,14 +2196,14 @@ var processItem = async (entryPath, useHardlink, language, auto) => {
       showFolderName = showPath.split("/").pop() ?? registeredShow.path;
     } else if (auto) {
       showFolderName = formatMovieName(movieFormat, parsed.title, parsed.year);
-      showPath = (0, import_path12.resolve)(destRoot, showFolderName);
+      showPath = (0, import_path13.resolve)(destRoot, showFolderName);
       upsertShow(showPath, null, parsed.title);
     } else {
       if (isVerbose()) spinner_default.info(`not registered, skipped: ${parsed.title} \u2014 run: reelsort add "${parsed.title}"`);
       return;
     }
     const seasonFolderName = findSeasonFolder2(showPath, parsed.season) ?? formatSeasonFolder(seasonFormat, parsed.season);
-    const seasonPath = (0, import_path12.resolve)(showPath, seasonFolderName);
+    const seasonPath = (0, import_path13.resolve)(showPath, seasonFolderName);
     const videoFile2 = isDir ? findVideo2(entryPath) : entry;
     if (!videoFile2) {
       if (isVerbose()) spinner_default.info(`no video found in: ${entry}`);
@@ -2119,39 +2213,39 @@ var processItem = async (entryPath, useHardlink, language, auto) => {
     const tmdbEpisodeName = registeredShow?.tmdbId && config.tmdbApiKey ? await getEpisodeName(registeredShow.tmdbId, parsed.season, parsed.episode ?? 1, config.tmdbApiKey) : null;
     const episodeName = formatEpisode(parsed.season, parsed.episode ?? 1, config.format?.episode, false, parsed.title, tmdbEpisodeName ?? void 0);
     const destVideoName2 = `${episodeName}.${videoExt2}`;
-    const destVideoPath = (0, import_path12.resolve)(seasonPath, destVideoName2);
-    const videoSourcePath2 = isDir ? (0, import_path12.resolve)(entryPath, videoFile2) : entryPath;
-    if ((0, import_fs12.existsSync)(destVideoPath)) {
+    const destVideoPath = (0, import_path13.resolve)(seasonPath, destVideoName2);
+    const videoSourcePath2 = isDir ? (0, import_path13.resolve)(entryPath, videoFile2) : entryPath;
+    if ((0, import_fs13.existsSync)(destVideoPath)) {
       spinner_default.warn(`already exists: ${episodeName}`);
       return;
     }
-    const dirFiles2 = isDir ? (0, import_fs12.readdirSync)(entryPath) : [];
+    const dirFiles2 = isDir ? (0, import_fs13.readdirSync)(entryPath) : [];
     const subtitle2 = isDir ? findSubtitle(dirFiles2, language) : null;
     const subtitleExt2 = subtitle2?.match(/([^.]+$)/)?.[0];
-    const subtitleSourcePath2 = subtitle2 ? (0, import_path12.resolve)(entryPath, subtitle2) : null;
+    const subtitleSourcePath2 = subtitle2 ? (0, import_path13.resolve)(entryPath, subtitle2) : null;
     const destSubtitleName2 = subtitle2 && subtitleExt2 ? `${episodeName}.${subtitleExt2}` : null;
-    (0, import_fs12.mkdirSync)(seasonPath, { recursive: true });
+    (0, import_fs13.mkdirSync)(seasonPath, { recursive: true });
     let mode = "move";
     if (useHardlink) {
       try {
         if (!sameDev2(videoSourcePath2, seasonPath)) throw new Error("cross-filesystem");
-        (0, import_fs12.linkSync)(videoSourcePath2, destVideoPath);
+        (0, import_fs13.linkSync)(videoSourcePath2, destVideoPath);
         mode = "hardlink";
       } catch {
         spinner_default.warn(`hardlink unavailable \u2014 copying instead: ${episodeName}`);
-        (0, import_fs12.cpSync)(videoSourcePath2, destVideoPath);
+        (0, import_fs13.cpSync)(videoSourcePath2, destVideoPath);
         mode = "copy";
       }
-      if (subtitleSourcePath2 && destSubtitleName2) (0, import_fs12.cpSync)(subtitleSourcePath2, (0, import_path12.resolve)(seasonPath, destSubtitleName2));
+      if (subtitleSourcePath2 && destSubtitleName2) (0, import_fs13.cpSync)(subtitleSourcePath2, (0, import_path13.resolve)(seasonPath, destSubtitleName2));
     } else {
       if (sameDev2(videoSourcePath2, seasonPath)) {
-        (0, import_fs12.renameSync)(videoSourcePath2, destVideoPath);
+        (0, import_fs13.renameSync)(videoSourcePath2, destVideoPath);
       } else {
-        (0, import_fs12.cpSync)(videoSourcePath2, destVideoPath);
-        (0, import_fs12.rmSync)(videoSourcePath2);
+        (0, import_fs13.cpSync)(videoSourcePath2, destVideoPath);
+        (0, import_fs13.rmSync)(videoSourcePath2);
       }
-      if (subtitleSourcePath2 && destSubtitleName2) (0, import_fs12.renameSync)(subtitleSourcePath2, (0, import_path12.resolve)(seasonPath, destSubtitleName2));
-      if (isDir) (0, import_fs12.rmSync)(entryPath, { recursive: true, force: true });
+      if (subtitleSourcePath2 && destSubtitleName2) (0, import_fs13.renameSync)(subtitleSourcePath2, (0, import_path13.resolve)(seasonPath, destSubtitleName2));
+      if (isDir) (0, import_fs13.rmSync)(entryPath, { recursive: true, force: true });
     }
     recordImport(sessionId, entryPath, seasonPath, mode, void 0, "tv");
     spinner_default.succeed(`imported ${import_termkit12.Color.green.encoder(`${showFolderName} / ${seasonFolderName} / ${episodeName}`)}`);
@@ -2159,8 +2253,8 @@ var processItem = async (entryPath, useHardlink, language, auto) => {
   }
   const edition = detectEdition(entry);
   const folderName = formatMovieName(movieFormat, parsed.title, parsed.year, edition);
-  const destFolder = (0, import_path12.resolve)(destRoot, folderName);
-  if ((0, import_fs12.existsSync)(destFolder)) {
+  const destFolder = (0, import_path13.resolve)(destRoot, folderName);
+  if ((0, import_fs13.existsSync)(destFolder)) {
     spinner_default.warn(`already exists: ${folderName}`);
     return;
   }
@@ -2171,42 +2265,42 @@ var processItem = async (entryPath, useHardlink, language, auto) => {
   }
   const videoExt = videoFile.match(/([^.]+$)/)?.[0];
   const destVideoName = `${folderName}.${videoExt}`;
-  const videoSourcePath = isDir ? (0, import_path12.resolve)(entryPath, videoFile) : entryPath;
-  const dirFiles = isDir ? (0, import_fs12.readdirSync)(entryPath) : [];
+  const videoSourcePath = isDir ? (0, import_path13.resolve)(entryPath, videoFile) : entryPath;
+  const dirFiles = isDir ? (0, import_fs13.readdirSync)(entryPath) : [];
   const subtitle = isDir ? findSubtitle(dirFiles, language) : null;
   const subtitleExt = subtitle?.match(/([^.]+$)/)?.[0];
-  const subtitleSourcePath = subtitle ? (0, import_path12.resolve)(entryPath, subtitle) : null;
+  const subtitleSourcePath = subtitle ? (0, import_path13.resolve)(entryPath, subtitle) : null;
   const destSubtitleName = subtitle && subtitleExt ? `${folderName}.${subtitleExt}` : null;
   if (useHardlink) {
-    (0, import_fs12.mkdirSync)(destFolder, { recursive: true });
-    const destVideoPath = (0, import_path12.resolve)(destFolder, destVideoName);
+    (0, import_fs13.mkdirSync)(destFolder, { recursive: true });
+    const destVideoPath = (0, import_path13.resolve)(destFolder, destVideoName);
     let mode;
     try {
       if (!sameDev2(videoSourcePath, destRoot)) throw new Error("cross-filesystem");
-      (0, import_fs12.linkSync)(videoSourcePath, destVideoPath);
+      (0, import_fs13.linkSync)(videoSourcePath, destVideoPath);
       mode = "hardlink";
     } catch {
       spinner_default.warn(`hardlink unavailable \u2014 copying instead: ${folderName}`);
-      (0, import_fs12.cpSync)(videoSourcePath, destVideoPath);
+      (0, import_fs13.cpSync)(videoSourcePath, destVideoPath);
       mode = "copy";
     }
-    if (subtitleSourcePath && destSubtitleName) (0, import_fs12.cpSync)(subtitleSourcePath, (0, import_path12.resolve)(destFolder, destSubtitleName));
+    if (subtitleSourcePath && destSubtitleName) (0, import_fs13.cpSync)(subtitleSourcePath, (0, import_path13.resolve)(destFolder, destSubtitleName));
     recordImport(sessionId, entryPath, destFolder, mode, void 0, "movie");
   } else {
     if (isDir) {
       const keep = new Set([videoFile, subtitle].filter(Boolean));
-      for (const f of dirFiles.filter((f2) => !keep.has(f2))) (0, import_fs12.rmSync)((0, import_path12.resolve)(entryPath, f), { recursive: true, force: true });
-      (0, import_fs12.renameSync)(videoSourcePath, (0, import_path12.resolve)(entryPath, destVideoName));
-      if (subtitleSourcePath && destSubtitleName) (0, import_fs12.renameSync)(subtitleSourcePath, (0, import_path12.resolve)(entryPath, destSubtitleName));
+      for (const f of dirFiles.filter((f2) => !keep.has(f2))) (0, import_fs13.rmSync)((0, import_path13.resolve)(entryPath, f), { recursive: true, force: true });
+      (0, import_fs13.renameSync)(videoSourcePath, (0, import_path13.resolve)(entryPath, destVideoName));
+      if (subtitleSourcePath && destSubtitleName) (0, import_fs13.renameSync)(subtitleSourcePath, (0, import_path13.resolve)(entryPath, destSubtitleName));
       moveItem(entryPath, destFolder);
     } else {
-      (0, import_fs12.mkdirSync)(destFolder, { recursive: true });
-      const destVideoPath = (0, import_path12.resolve)(destFolder, destVideoName);
+      (0, import_fs13.mkdirSync)(destFolder, { recursive: true });
+      const destVideoPath = (0, import_path13.resolve)(destFolder, destVideoName);
       if (sameDev2(videoSourcePath, destRoot)) {
-        (0, import_fs12.renameSync)(videoSourcePath, destVideoPath);
+        (0, import_fs13.renameSync)(videoSourcePath, destVideoPath);
       } else {
-        (0, import_fs12.cpSync)(videoSourcePath, destVideoPath);
-        (0, import_fs12.rmSync)(videoSourcePath);
+        (0, import_fs13.cpSync)(videoSourcePath, destVideoPath);
+        (0, import_fs13.rmSync)(videoSourcePath);
       }
     }
     recordImport(sessionId, entryPath, destFolder, "move", void 0, "movie");