pinokiod 8.0.102 → 8.0.106

package/kernel/vault/index.js

@@ -44,6 +44,12 @@ const AUTOMATIC_ACTIONS = new Set([
 ])
 const PERMISSION_DENIED_CODES = new Set(["EACCES", "EPERM"])
 const BUSY_CODES = new Set(["EBUSY"])
+const PUBLIC_FILE_STATUS = {
+  reference: "tracked",
+  duplicate: "duplicate",
+  unavailable: "unavailable",
+  linked: "shared"
+}
 const hardlinkUnavailableCode = (code) =>
   HARDLINK_UNSUPPORTED_CODES.has(code) || PERMISSION_DENIED_CODES.has(code)
 const replacementLockedCode = (code) =>
@@ -197,7 +203,16 @@ const revealInFileManager = (filePath, platform = process.platform) =>
     execFile(command, args, {
       timeout: 10000,
       windowsHide: true
-    }, (error) => error ? reject(error) : resolve())
+    }, (error) => {
+      // Explorer reports a non-zero exit code even when it opens the folder,
+      // so an exit status alone is not a failure on Windows. A missing binary
+      // or a refused spawn still is.
+      if (error && platform === "win32" && Number.isInteger(error.code)) {
+        resolve()
+        return
+      }
+      error ? reject(error) : resolve()
+    })
   })
 
 class Vault {
@@ -1359,8 +1374,10 @@ class Vault {
     if (!entry || entry.unavailable_reason === "stale") {
       return { error: "This file is no longer tracked. Scan again to refresh this view." }
     }
+    // Opening a file manager mutates nothing, so it is allowed for any tracked
+    // path regardless of the scope the request came from.
     const source = this.sourceForPath(entry.path, entry.source_id)
-    if (!source || !this.sourceIsWithinScope(source, scopeId)) {
+    if (!source) {
       return { error: "This file is outside the current location." }
     }
     if (!await this.canonicalPathIsWithinSource(entry.path, source)) {
@@ -1373,7 +1390,10 @@ class Vault {
     try {
       await this.fileManagerLauncher(entry.path)
     } catch (error) {
-      return { error: "The file manager could not open this file." }
+      // Naming the underlying failure is what makes a report actionable; the
+      // generic sentence hid whether the spawn, the binary, or the path failed.
+      const detail = error && error.message ? ` (${error.message})` : ""
+      return { error: `The file manager could not open this file.${detail}` }
     }
     return { revealed: true }
   }
@@ -2854,6 +2874,9 @@ class Vault {
     ))
     await this.refreshInodeSnapshots(entry.hash, entry.dev, entry.ino)
     if (options.reclassify !== false) {
+      // Free before reclassifying: classification must see the final state,
+      // or it records a reference against an anchor about to be deleted.
+      await this.freeUnusedAnchors([entry.hash])
       await this.reclassifyHashes([entry.hash])
     }
     if (options.changedHashes) options.changedHashes.add(entry.hash)
@@ -2915,6 +2938,7 @@ class Vault {
       }
     }
     if (affectedHashes.size) {
+      await this.freeUnusedAnchors(affectedHashes)
       await this.reclassifyHashes(affectedHashes)
     }
     const event = {
@@ -2998,6 +3022,7 @@ class Vault {
         }
       }
       if (affectedHashes.size) {
+        await this.freeUnusedAnchors(affectedHashes)
         await this.reclassifyHashes(affectedHashes)
       }
       if (changedHashes instanceof FileActionChanges) {
@@ -3074,6 +3099,27 @@ class Vault {
     return result
   }
 
+  // Separating the last path to shared content leaves an anchor nothing
+  // references. Freeing it here keeps that cleanup out of the user's hands.
+  // reclaim() revalidates and refuses while any path still links, so a
+  // partial separation frees nothing and a failure is never fatal.
+  async freeUnusedAnchors(hashes) {
+    for (const hash of hashes) {
+      let anchors = []
+      try {
+        anchors = await this.registry.anchorsForHash(hash)
+      } catch (error) {
+        continue
+      }
+      for (const anchor of anchors) {
+        if (anchor.nlink !== 1) continue
+        try {
+          await this.reclaim(hash, anchor.store_id)
+        } catch (error) {}
+      }
+    }
+  }
+
   async reclaimAll() {
     const summary = { reclaimed: 0, bytes_freed: 0, failed: 0 }
     let cursor = { store_id: "", hash: "" }
@@ -3227,12 +3273,7 @@ class Vault {
           dev: match.dev,
           ino: match.ino
         }, this.locationForPath(match.path, match.source_id)))
-      const publicStatus = {
-        reference: "tracked",
-        duplicate: "duplicate",
-        unavailable: "unavailable",
-        linked: "shared"
-      }[row.status]
+      const publicStatus = PUBLIC_FILE_STATUS[row.status]
       const result = Object.assign({
         path: row.path,
         hash: row.hash,
@@ -3330,6 +3371,47 @@ class Vault {
     }
   }
 
+  async fileLocations(scopeId, filePath, options = {}) {
+    if (typeof filePath !== "string" || !filePath) {
+      throw new TypeError("Invalid vault file path.")
+    }
+    const target = path.resolve(filePath)
+    const entry = await this.registry.getFile(target)
+    const sourceIds = this.scopeSourceIds(scopeId)
+    if (!entry ||
+        (scopeId && !sourceIds.includes(entry.source_id))) {
+      return { path: target, items: [], total: 0, next_cursor: null }
+    }
+    const cursor = typeof options.cursor === "string"
+      ? options.cursor.slice(0, 2048)
+      : ""
+    const pageSize = boundedInteger(
+      options.page_size, 100, 1, STATUS_PAGE_SIZE)
+    const identity = entry.status === "linked"
+      ? { dev: entry.dev, ino: entry.ino }
+      : { hash: entry.hash }
+    if (!identity.hash && !Number.isFinite(identity.dev)) {
+      return { path: target, items: [], total: 0, next_cursor: null }
+    }
+    // Every authorized location is listed whatever the scope. A scope decides
+    // what can be selected and acted on, not what the user is told exists.
+    const result = await this.registry.fileLocationChildren(Object.assign({
+      externalSourceIds: this.configuredExternalSourceIds(),
+      cursor,
+      pageSize
+    }, identity))
+    return {
+      path: target,
+      items: (result.rows || []).map((row) => Object.assign({
+        path: row.path,
+        status: PUBLIC_FILE_STATUS[row.status] || null
+      }, this.locationForPath(row.path, row.source_id))),
+      total: Number(result.total) || 0,
+      deduplicatable: Number(result.duplicateTotal) || 0,
+      next_cursor: result.nextCursor || null
+    }
+  }
+
   async duplicateGroupSelection(scopeId, hash, options = {}) {
     if (typeof hash !== "string" || !SHA256_RE.test(hash)) {
       throw new TypeError("Invalid vault content identifier.")

package/kernel/vault/registry.js

@@ -206,6 +206,7 @@ for (const method of [
   "appsForHashes",
   "reclaimableBatch",
   "duplicateGroupChildren",
+  "fileLocationChildren",
   "duplicateGroupSelection",
   "duplicateGroupPageSelection",
   "statusSnapshot",

package/kernel/vault/registry_core.js

@@ -5633,6 +5633,86 @@ class RegistryCore {
     }
   }
 
+  fileLocationChildren(options = {}) {
+    const externalSourceIds = [...new Set(
+      (options.externalSourceIds || []).filter(Boolean))]
+    const pageSize = Math.max(
+      1, Math.min(500, Number(options.pageSize) || 100))
+    const inode = Number.isFinite(options.dev) && Number.isFinite(options.ino)
+    const identity = inode
+      ? `${options.dev}:${options.ino}`
+      : String(options.hash || "")
+    const authorized = this.duplicateGroupFilter(
+      [],
+      "",
+      true,
+      "child",
+      inode ? ["linked"] : [],
+      externalSourceIds
+    )
+    const identityWhere = inode
+      ? "child.dev = ? AND child.ino = ?"
+      : "child.hash = ?"
+    const identityValues = inode
+      ? [options.dev, options.ino]
+      : [options.hash]
+    const decoded = this.decodeCursor(options.cursor)
+    const cursorWhere = []
+    const cursorValues = []
+    if (decoded &&
+        decoded.sort === "file-locations" &&
+        decoded.identity === identity &&
+        typeof decoded.path === "string") {
+      cursorWhere.push("child.path > ?")
+      cursorValues.push(decoded.path)
+    }
+    const rows = this.database.prepare(`
+      SELECT child.*
+      FROM files child
+      WHERE ${identityWhere}
+        AND ${authorized.where.join(" AND ")}
+        ${cursorWhere.length
+          ? `AND ${cursorWhere.join(" AND ")}`
+          : ""}
+      ORDER BY child.path
+      LIMIT ?
+    `).all(
+      ...identityValues,
+      ...authorized.values,
+      ...cursorValues,
+      pageSize + 1
+    )
+    const hasMore = rows.length > pageSize
+    if (hasMore) rows.pop()
+    const last = rows[rows.length - 1]
+    const total = Number(this.database.prepare(`
+      SELECT COUNT(*) AS count
+      FROM files child
+      WHERE ${identityWhere}
+        AND ${authorized.where.join(" AND ")}
+    `).get(...identityValues, ...authorized.values).count) || 0
+    // Only paths still storing their own copy can free anything.
+    const duplicateTotal = Number(this.database.prepare(`
+      SELECT COUNT(*) AS count
+      FROM files child
+      WHERE ${identityWhere}
+        AND child.status = 'duplicate'
+        AND ${authorized.where.join(" AND ")}
+    `).get(...identityValues, ...authorized.values).count) || 0
+    return {
+      rows,
+      total,
+      duplicateTotal,
+      nextCursor: hasMore && last
+        ? this.encodeCursor({
+            sort: "file-locations",
+            identity,
+            path: last.path
+          })
+        : null
+    }
+  }
+
   duplicateGroupSelection(options = {}) {
     const sourceIds = [...new Set(
       (options.sourceIds || []).filter(Boolean))]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pinokiod",
-  "version": "8.0.102",
+  "version": "8.0.106",
   "description": "",
   "main": "index.js",
   "scripts": {

package/server/index.js

@@ -15883,6 +15883,17 @@ class Server {
           req.query.folder_discovery_child_page))
         return
       }
+      const locationsPath = req.query &&
+        typeof req.query.locations_path === "string"
+        ? req.query.locations_path
+        : null
+      if (locationsPath) {
+        res.json(await vault.fileLocations(scopeId, locationsPath, {
+          cursor: req.query && req.query.cursor,
+          page_size: req.query && req.query.page_size
+        }))
+        return
+      }
       const groupHash = req.query &&
         typeof req.query.group_hash === "string"
         ? req.query.group_hash

package/server/public/vault.css

@@ -964,6 +964,32 @@ body[data-vault-mode="global"] .vault-explorer {
   outline: 2px solid color-mix(in srgb, var(--task-accent) 55%, transparent);
   outline-offset: 1px;
 }
+.vault-confirm-overlay {
+  position: fixed;
+  z-index: 140;
+  inset: 0;
+  display: grid;
+  place-items: center;
+  padding: 24px;
+  background: color-mix(in srgb, var(--task-text) 34%, transparent);
+}
+.vault-confirm-overlay[hidden] { display: none; }
+.vault-confirm-dialog {
+  width: min(420px, 100%);
+  padding: 18px 20px 16px;
+  border: 1px solid var(--task-border-strong);
+  border-radius: 10px;
+  background: var(--task-panel);
+  box-shadow: 0 22px 70px color-mix(in srgb, var(--task-text) 24%, transparent);
+}
+.vault-confirm-message {
+  margin: 0 0 16px;
+  color: var(--task-text);
+  font-size: 12.5px;
+  line-height: 1.5;
+}
+.vault-confirm-actions { display: flex; justify-content: flex-end; gap: 8px; }
+
 .vault-find-overlay {
   position: fixed;
   z-index: 120;
@@ -2043,9 +2069,40 @@ body.dark .vault-row-action .vault-text-button:hover:not(:disabled) {
   background: color-mix(in srgb, var(--task-soft) 48%, transparent);
 }
 .vault-detail-label { margin-bottom: 5px; color: var(--task-muted); font-size: 10px; font-weight: 650; }
-.vault-location-detail { display: flex; align-items: center; gap: 7px; padding: 2px 0; color: var(--task-text); font-size: 10.5px; }
+.vault-location-detail { display: flex; align-items: center; gap: 7px; min-height: 26px; color: var(--task-text); font-size: 10.5px; }
 .vault-location-detail i { color: var(--task-muted); }
 .vault-location-detail > span { min-width: 0; flex: 1; overflow-wrap: anywhere; }
+.vault-location-detail > .vault-location-path {
+  min-width: 0;
+  flex: 1;
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+.vault-location-detail > .vault-location-note {
+  flex: 0 0 auto;
+  margin-left: auto;
+  padding-left: 12px;
+  color: var(--task-muted);
+  white-space: nowrap;
+}
+.vault-location-detail > .vault-location-reveal-placeholder { flex: 0 0 26px; }
+.vault-location-link {
+  appearance: none;
+  padding: 0;
+  border: 0;
+  background: none;
+  color: var(--task-accent);
+  font: inherit;
+  text-align: left;
+  cursor: pointer;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+  max-width: 100%;
+}
+.vault-location-link:hover { text-decoration: underline; }
+.vault-location-link i { color: inherit; font-size: 9px; margin-left: 5px; }
 .vault-duplicate-content-group {
   min-height: 52px;
   background: color-mix(in srgb, var(--task-soft) 28%, transparent);

package/server/public/vault.js

@@ -5,14 +5,14 @@ const COPY = {
   duplicates: "Duplicates",
   cannot_deduplicate: "Cannot deduplicate",
   shared: "Deduplicated",
-  reclaimable: "Unused files",
+  reclaimable: "Trash",
   activity: "Activity",
   all_description: "Every scanned file and its current deduplication status.",
   duplicates_description: "Identical files waiting to be deduplicated.",
   unavailable_description: "Identical files that cannot share storage.",
   shared_description: "Files currently sharing disk storage through hardlinks.",
   tracked_description: "Files with no duplicate action required.",
-  reclaimable_description: "Private links no longer used by any linked file.",
+  reclaimable_description: "Spare copies no file is using.",
   activity_description: "A history of changes made by Disk Saver.",
   add_external_folder: "Add external folder",
   find_folders: "Find more savings",
@@ -236,16 +236,18 @@ const COPY = {
   selected_copy: "Selected",
   loading_copies: "Loading copies…",
   show_more_copies: "Show {count} more copies",
+  loading_locations: "Loading locations…",
+  open_in_disk_saver: "Open this file in Disk Saver",
+  open_location_confirm: "Open Disk Saver for {location}?",
+  open_location_accept: "Open",
+  show_more_locations: "Show {count} more locations",
   making_separate: "Making file separate",
   make_separate: "Make separate",
   try_again: "Try again",
-  reclaim: "Clean up",
-  reclaim_all: "Clean up all",
-  cleanup_ready: "{size} ready to clean up",
-  cleanup_ready_detail: "{count} left after their linked files were deleted.",
-  review_cleanup: "Review cleanup",
-  private_link: "private link",
-  private_links: "private links",
+  reclaim: "Delete",
+  reclaim_all: "Empty Trash",
+  cleanup_ready: "{size} in the Trash",
+  review_cleanup: "Open Trash",
   make_file_separate: "Make file separate",
   make_files_separate: "Make {count} files separate",
   making_separate_selected: "Making files separate",
@@ -259,8 +261,12 @@ const COPY = {
   separation_cancelled: "Separation cancelled after {count}.",
   select_for_separation: "Select to make separate",
   select_all_on_page: "Select all on this page",
-  identical_contents_at: "Identical contents at",
-  locations_shown: "{shown} of {total} locations shown",
+  stored_times: "Stored {count} times · {size} each",
+  this_file: "this file",
+  copy_that_stays: "the copy that stays",
+  already_deduplicated: "already deduplicated",
+  not_deduplicated_yet: "not deduplicated yet",
+  cannot_be_deduplicated: "cannot be deduplicated",
   no_files: "No files found",
   no_files_hint: "Run a scan to find files that can be deduplicated. Scanning never links files together or replaces them.",
   scan_waiting: "Waiting for scan results",
@@ -273,26 +279,34 @@ const COPY = {
   no_shared_hint: "Deduplicated files will appear here after you review duplicates.",
   no_tracked: "No files with no action needed",
   no_tracked_hint: "Files without a duplicate action will appear here after a scan.",
-  no_reclaimable: "No cleanup needed",
-  no_reclaimable_hint: "Private links with no remaining linked files will appear here.",
+  no_reclaimable: "Trash is empty",
+  no_reclaimable_hint: "Spare copies Pinokio no longer needs appear here.",
   no_activity: "No activity yet",
   no_activity_hint: "Changes made by Disk Saver will appear here.",
   view_all: "View all files",
   tracked_note: "Only files {size} and larger appear here. Files keep their current locations.",
   tracked_note_all: "All non-empty files appear here. Files keep their current locations.",
   duplicate_note: "Only files waiting for review are shown.",
-  reclaimable_note: "These private links have no remaining linked files. Cleaning them up frees disk space.",
   activity_note: "Recent changes made by Disk Saver.",
   converted: "Deduplicated",
   separated: "Separated",
   reclaimed: "Cleaned up",
   event_convert: "Deduplicated",
-  event_reclaim: "Cleaned up unused link",
+  event_reclaim: "Emptied from Trash",
   event_detach: "Separated",
   event_change: "File state changed"
 }
 
 const SCOPE_ID = document.body.dataset.vaultScope || null
+const FOCUS_GROUP = (() => {
+  const value = new URLSearchParams(window.location.search).get("group")
+  return typeof value === "string" && /^[a-f0-9]{64}$/.test(value.toLowerCase())
+    ? value.toLowerCase()
+    : null
+})()
+// A scoped page hands one content group off to the global page, which opens
+// on it once its first page of duplicate results arrives.
+let focusGroupPending = !!FOCUS_GROUP
 const IS_APP_MODE = document.body.dataset.vaultMode === "app" && !!SCOPE_ID
 const APP_NAME = IS_APP_MODE ? document.body.dataset.vaultApp || "" : ""
 const HOME_PATH = document.body.dataset.vaultHome || ""
@@ -330,6 +344,14 @@ const folderDiscoveryChildrenUrl = (folder, page = 0) => {
   })
   return `/info/dedup?${query.toString()}`
 }
+const fileLocationsUrl = (filePath, options = {}) => {
+  const query = new URLSearchParams()
+  if (SCOPE_ID) query.set("scope_id", SCOPE_ID)
+  query.set("locations_path", filePath)
+  if (options.cursor) query.set("cursor", options.cursor)
+  query.set("page_size", String(DUPLICATE_CHILD_PAGE_SIZE))
+  return `/info/dedup?${query.toString()}`
+}
 const duplicateGroupUrl = (hash, options = {}) => {
   const query = new URLSearchParams()
   if (SCOPE_ID) query.set("scope_id", SCOPE_ID)
@@ -405,17 +427,19 @@ const state = {
   candidateSize: defaultCandidateSize,
   persistedCandidateSize: defaultCandidateSize,
   candidateSizeInitialized: false,
-  view: "all",
+  view: FOCUS_GROUP ? "duplicates" : "all",
   sourceId: SCOPE_ID,
   query: "",
   statusFilter: "all",
-  displayMode: "folders",
-  sizeSort: null,
+  displayMode: FOCUS_GROUP ? "files" : "folders",
+  sizeSort: FOCUS_GROUP ? "desc" : null,
   collapsedSources: new Set(),
   collapsedDirs: new Set(),
   expandedFiles: new Set(),
   expandedDuplicateGroups: new Set(),
   duplicateGroupChildren: new Map(),
+  fileLocations: new Map(),
+  locationsScanTs: undefined,
   duplicateGroupGeneration: 0,
   selectedDuplicateFiles: new Map(),
   selectedSeparateFiles: new Set(),
@@ -454,11 +478,19 @@ const state = {
   pageCursors: [""]
 }
 
+// Expanded location lists describe one grouping of one file. Anything that
+// can change that grouping closes them instead of leaving stale paths open.
+const closeFileLocations = () => {
+  state.expandedFiles.clear()
+  state.fileLocations.clear()
+}
+
 const resetPage = () => {
   state.page = 0
   state.pageCursors = [""]
   state.expandedDuplicateGroups.clear()
   state.duplicateGroupChildren.clear()
+  closeFileLocations()
   state.duplicateGroupGeneration += 1
 }
 
@@ -594,9 +626,59 @@ const saveCandidateSize = (size) => {
   })
   return candidateSizeSaveTail
 }
+// Small confirm dialog in the workspace's own visual language, so leaving the
+// page never happens through a native browser prompt.
+const confirmLeave = (message, confirmLabel) => new Promise((resolve) => {
+  const overlay = document.createElement("div")
+  overlay.className = "vault-confirm-overlay"
+  overlay.innerHTML = `<section class="vault-confirm-dialog" role="dialog" aria-modal="true"><p class="vault-confirm-message"></p><div class="vault-confirm-actions"><button class="vault-button" type="button" data-confirm-cancel>${esc(COPY.cancel)}</button><button class="vault-button primary" type="button" data-confirm-accept>${esc(confirmLabel)}</button></div></section>`
+  overlay.querySelector(".vault-confirm-message").textContent = message
+  const settle = (value) => {
+    document.removeEventListener("keydown", onKey, true)
+    overlay.remove()
+    resolve(value)
+  }
+  const onKey = (event) => {
+    if (event.key !== "Escape") return
+    event.preventDefault()
+    event.stopPropagation()
+    settle(false)
+  }
+  overlay.addEventListener("click", (event) => {
+    if (event.target === overlay) settle(false)
+    if (event.target.closest("[data-confirm-cancel]")) settle(false)
+    if (event.target.closest("[data-confirm-accept]")) settle(true)
+  })
+  document.addEventListener("keydown", onKey, true)
+  document.body.appendChild(overlay)
+  const accept = overlay.querySelector("[data-confirm-accept]")
+  if (accept) accept.focus()
+})
+
 const openGlobalWorkspace = () => {
   window.parent.location.assign("/vault")
 }
+// Opens a new tab rather than navigating: this workspace can be embedded in an
+// app page, where navigating would either nest a second copy of the interface
+// or drop the user out of the app they were looking at.
+// A copy that belongs to another app opens that app's own workspace, where it
+// can actually be acted on. Anything else — caches, external folders — has no
+// app page, so it opens the global one. Either way the user is leaving this
+// page, so it is confirmed first and the parent window is replaced rather than
+// nesting a second copy of the interface inside this frame.
+const openContentGroup = async (group, kind, label) => {
+  // The label and kind travel with the row: an app workspace cannot look up
+  // sources belonging to other apps, so a lookup here would name every one of
+  // them "unknown" and send them all to the global page.
+  const app = kind === "app" && label ? label : null
+  const name = label || COPY.unknown_location
+  const accepted = await confirmLeave(
+    COPY.open_location_confirm.replace("{location}", name),
+    COPY.open_location_accept)
+  if (!accepted) return
+  const base = app ? `/vault/app/${encodeURIComponent(app)}` : "/vault"
+  window.parent.location.assign(`${base}?group=${encodeURIComponent(group)}`)
+}
 const applyAutomaticScanSnapshot = (snapshot) => {
   if (!IS_APP_MODE || !AUTOMATIC_SUPPORTED) return
   const settings = snapshot && Array.isArray(snapshot.settings)
@@ -688,24 +770,15 @@ const onAutomaticScanMessage = (event) => {
 }
 const sourceById = (id) => (state.data.sources || []).find((source) => source.id === id)
 const sourceChildren = (id) => (state.data.sources || []).filter((source) => source.parent_id === id)
-const sourceIsWithinScope = (sourceId) => {
-  if (!SCOPE_ID) return true
-  const seen = new Set()
-  let source = sourceById(sourceId)
-  while (source && !seen.has(source.id)) {
-    if (source.id === SCOPE_ID) return true
-    seen.add(source.id)
-    source = sourceById(source.parent_id)
-  }
-  return false
-}
 const revealLabel = document.body.dataset.platform === "darwin"
   ? COPY.show_in_finder
   : document.body.dataset.platform === "win32"
     ? COPY.show_in_file_explorer
     : COPY.open_containing_folder
+// Revealing changes nothing, so it is offered for every tracked path, not
+// only the ones the current scope can act on.
 const revealButton = (filePath, sourceId, name) => {
-  if (!filePath || !sourceIsWithinScope(sourceId)) return ""
+  if (!filePath) return ""
   const label = `${revealLabel}: ${name || basename(filePath)}`
   return `<button class="vault-reveal-button" type="button" data-reveal-file="${attr(filePath)}" aria-label="${attr(label)}" title="${attr(revealLabel)}"><i class="fa-regular fa-folder-open" aria-hidden="true"></i></button>`
 }
@@ -1696,15 +1769,46 @@ const sharingControl = (item) => {
 }
 
 const fileDetail = (item) => {
-  if (!state.expandedFiles.has(item.path) || !item.locations || item.locations.length < 2) return ""
-  const total = Math.max(item.locations.length, Number(item.location_count) || 0)
-  const label = total > item.locations.length
-    ? COPY.locations_shown
-      .replace("{shown}", item.locations.length)
-      .replace("{total}", total)
-    : `${COPY.identical_contents_at} ${countLabel(total, COPY.location, COPY.locations_lower)}`
-  return `<div class="vault-detail"><div class="vault-detail-label">${esc(label)}</div>${item.locations.map((location) => `
-    <div class="vault-location-detail"><i class="fa-regular fa-file"></i><span>${esc(externalLocation(location) || [location.source_label, location.relative_path].filter(Boolean).join(" / "))}</span>${revealButton(location.path, location.source_id, basename(location.relative_path))}</div>`).join("")}</div>`
+  if (!state.expandedFiles.has(item.path)) return ""
+  const locations = state.fileLocations.get(item.path)
+  if (!locations || (locations.loading && !locations.loaded)) {
+    return `<div class="vault-detail"><div class="vault-detail-label"><i class="fa-solid fa-circle-notch fa-spin"></i> ${esc(COPY.loading_locations)}</div></div>`
+  }
+  if (locations.error) {
+    return `<div class="vault-detail"><div class="vault-detail-label error">${esc(locations.error)}</div></div>`
+  }
+  const total = Math.max(locations.items.length, Number(locations.total) || 0)
+  // Copies are byte-identical, so the size is stated once for the group.
+  const label = COPY.stored_times
+    .replace("{count}", total)
+    .replace("{size}", fmt(item.size))
+  const remaining = Math.max(0, total - locations.items.length)
+  const more = locations.nextCursor
+    ? `<div class="vault-location-detail"><button class="vault-text-button" type="button" data-more-file-locations="${attr(item.path)}" ${locations.loading ? "disabled" : ""}>${esc(COPY.show_more_locations.replace("{count}", Math.min(remaining, DUPLICATE_CHILD_PAGE_SIZE)))}</button></div>`
+    : ""
+  const body = locations.items.map((location) => {
+    const where = externalLocation(location) ||
+      [location.source_label, location.relative_path].filter(Boolean).join(" / ")
+    const note = location.path === item.path
+      ? COPY.this_file
+      : location.status === "tracked"
+        ? COPY.copy_that_stays
+        : location.status === "shared"
+          ? COPY.already_deduplicated
+          : location.status === "unavailable"
+            ? COPY.cannot_be_deduplicated
+            : COPY.not_deduplicated_yet
+    const outside = SCOPE_ID && item.hash && location.source_id !== SCOPE_ID
+    const text = outside
+      ? `<button class="vault-location-link" type="button" data-open-group="${attr(item.hash)}" data-open-kind="${attr(location.source_kind || "")}" data-open-label="${attr(location.source_label || "")}" title="${attr(COPY.open_in_disk_saver)}">${esc(where)}</button>`
+      : esc(where)
+    // Rows keep identical slots whether or not a reveal button exists, so the
+    // notes form a column and every row is the same height.
+    const reveal = revealButton(
+      location.path, location.source_id, basename(location.relative_path))
+    return `<div class="vault-location-detail"><i class="fa-regular fa-file"></i><span class="vault-location-path" title="${attr(where)}">${text}</span><span class="vault-location-note">${esc(note)}</span>${reveal || `<span class="vault-location-reveal-placeholder"></span>`}</div>`
+  }).join("")
+  return `<div class="vault-detail"><div class="vault-detail-label">${esc(label)}</div>${body}${more}</div>`
 }
 const separateCheckbox = (item) => item.status === "shared"
   ? `<input class="vault-row-checkbox" type="checkbox" data-select-separate="${attr(item.path)}" aria-label="${attr(`${COPY.select_for_separation}: ${basename(item.relative_path)}`)}" ${state.separateAllMatching || state.selectedSeparateFiles.has(item.path) ? "checked" : ""} />`
@@ -1721,7 +1825,7 @@ const rowSelectionCheckbox = (item) =>
 const renderFileRow = (item, depth = 0, showMatch = false) => {
   const directoryPath = dirname(item.relative_path)
   const match = item.match
-  const expandable = item.locations && item.locations.length > 1
+  const expandable = Number(item.location_count) > 1
   const rowTail = showMatch
     ? `<span>${match ? `<span class="vault-match-path">${esc(match.path)}</span>` : "—"}</span>
       <span class="vault-space">${esc(spaceMarkup(item))}</span>
@@ -1826,7 +1930,7 @@ const flatLocation = (item) => externalLocation(item) ||
 const renderFlatFiles = (items) => [...items]
   .sort((a, b) => compareRows(a, b, flatLocation))
   .map((item) => {
-    const expandable = item.locations && item.locations.length > 1
+    const expandable = Number(item.location_count) > 1
     return `<div class="vault-file-row">
       <div class="vault-name-cell">
         ${separateCheckbox(item)}
@@ -2230,7 +2334,7 @@ const paneFooterText = () => {
     return `${count}${order ? ` · ${order}` : ""}`
   }
   if (state.view === "duplicates") return COPY.duplicate_note
-  if (state.view === "reclaimable") return COPY.reclaimable_note
+  if (state.view === "reclaimable") return ""
   if (state.view === "activity") return COPY.activity_note
   const minimumSize = state.data.last_scan &&
     Number.isFinite(state.data.last_scan.candidate_min_bytes)
@@ -2754,12 +2858,8 @@ const renderCleanupNotice = () => {
   }
   const bytes = Number(state.data.reclaimable) || 0
   const title = COPY.cleanup_ready.replace("{size}", fmt(bytes))
-  const detail = COPY.cleanup_ready_detail.replace(
-    "{count}",
-    countLabel(unusedCount, COPY.private_link, COPY.private_links)
-  )
   notice.className = "vault-cleanup-notice show"
-  notice.innerHTML = `<i class="fa-solid fa-broom" aria-hidden="true"></i><strong>${esc(title)}</strong><span class="vault-cleanup-notice-detail">${esc(detail)}</span><button class="vault-button" id="btn-review-cleanup" type="button">${esc(COPY.review_cleanup)}<i class="fa-solid fa-chevron-right" aria-hidden="true"></i></button>`
+  notice.innerHTML = `<i class="fa-regular fa-trash-can" aria-hidden="true"></i><strong>${esc(title)}</strong><button class="vault-button" id="btn-review-cleanup" type="button">${esc(COPY.review_cleanup)}<i class="fa-solid fa-chevron-right" aria-hidden="true"></i></button>`
 }
 
 const clearPanel = (id, className) => {
@@ -2846,9 +2946,9 @@ const fetchJson = async (url) => {
   if (!response.ok) throw new Error(COPY.status_request_failed.replace("{status}", response.status))
   return response.json()
 }
-const loadDuplicateGroupChildren = async (hash, append = false) => {
+const loadPagedChildren = async (cache, key, buildUrl, append) => {
   const generation = state.duplicateGroupGeneration
-  const current = state.duplicateGroupChildren.get(hash) || {
+  const current = cache.get(key) || {
     items: [],
     total: 0,
     nextCursor: null,
@@ -2859,16 +2959,18 @@ const loadDuplicateGroupChildren = async (hash, append = false) => {
   if (current.loading) return
   current.loading = true
   current.error = null
-  state.duplicateGroupChildren.set(hash, current)
+  cache.set(key, current)
   render()
   try {
-    const result = await fetchJson(duplicateGroupUrl(hash, {
-      cursor: append ? current.nextCursor : null
-    }))
+    const result = await fetchJson(
+      buildUrl(append ? current.nextCursor : null))
     if (generation !== state.duplicateGroupGeneration) return
     const items = Array.isArray(result.items) ? result.items : []
     current.items = append ? current.items.concat(items) : items
     current.total = Math.max(0, Number(result.total) || 0)
+    // Location lists carry how many copies still cost space; group children
+    // do not, and read as zero.
+    current.deduplicatable = Math.max(0, Number(result.deduplicatable) || 0)
     current.nextCursor = result.next_cursor || null
     current.loaded = true
   } catch (error) {
@@ -2883,6 +2985,12 @@ const loadDuplicateGroupChildren = async (hash, append = false) => {
     }
   }
 }
+const loadDuplicateGroupChildren = (hash, append = false) =>
+  loadPagedChildren(state.duplicateGroupChildren, hash, (cursor) =>
+    duplicateGroupUrl(hash, { cursor }), append)
+const loadFileLocations = (filePath, append = false) =>
+  loadPagedChildren(state.fileLocations, filePath, (cursor) =>
+    fileLocationsUrl(filePath, { cursor }), append)
 const duplicateGroupSelectionPaths = async (hash) =>
   fetchJson(duplicateGroupUrl(hash, { select: true }))
 const duplicateGroupPageSelectionItems = async () =>
@@ -2919,6 +3027,17 @@ const applyFullData = (data) => {
     reviewedScan() !== String(data.last_scan.ts) &&
     (shareableDuplicateCount > 0 || data.last_scan.partial)
   settleFolderDiscoveryStart()
+  if (focusGroupPending &&
+      data.inventory && data.inventory.view === "duplicates") {
+    focusGroupPending = false
+    state.expandedDuplicateGroups.add(FOCUS_GROUP)
+    loadDuplicateGroupChildren(FOCUS_GROUP)
+  }
+  const publishedScan = data.last_scan ? data.last_scan.ts : null
+  if (publishedScan !== state.locationsScanTs) {
+    state.locationsScanTs = publishedScan
+    closeFileLocations()
+  }
   state.data = data
   const fileAction = serverFileAction(data.file_action)
   if (fileAction) state.actionProgress = fileAction
@@ -3034,6 +3153,7 @@ const runAction = async (payload, success) => {
   } catch (error) {
     state.feedback = { error: true, message: error && error.message ? error.message : String(error) }
   }
+  closeFileLocations()
   await refresh(true)
 }
 
@@ -3371,6 +3491,13 @@ const closeScanSizeMenu = () => {
 document.addEventListener("click", async (event) => {
   const target = event.target.closest("button")
   if (!target) return
+  if (target.dataset.openGroup) {
+    await openContentGroup(
+      target.dataset.openGroup,
+      target.dataset.openKind,
+      target.dataset.openLabel)
+    return
+  }
   if (target.hasAttribute("data-dismiss-automatic-scan-coachmark")) {
     dismissAutomaticScanCoachmark(true)
     return
@@ -3741,11 +3868,21 @@ document.addEventListener("click", async (event) => {
       target.dataset.moreDuplicateGroup,
       true
     )
+  } else if (target.dataset.moreFileLocations) {
+    await loadFileLocations(target.dataset.moreFileLocations, true)
   } else if (target.dataset.expandFile) {
     const file = target.dataset.expandFile
-    if (state.expandedFiles.has(file)) state.expandedFiles.delete(file)
-    else state.expandedFiles.add(file)
-    render()
+    if (state.expandedFiles.has(file)) {
+      state.expandedFiles.delete(file)
+      render()
+    } else {
+      state.expandedFiles.add(file)
+      render()
+      const loaded = state.fileLocations.get(file)
+      if (!loaded || (!loaded.loaded && !loaded.loading)) {
+        await loadFileLocations(file)
+      }
+    }
   } else if (target.dataset.removeSource) {
     const source = sourceById(target.dataset.removeSource)
     if (!source) return

package/test/vault-engine.test.js

@@ -1553,7 +1553,7 @@ describe("Save Space engine", () => {
     await close(vault)
   })
 
-  test("revealing a file is scoped to a current registered path", async () => {
+  test("revealing works for any tracked path, whatever the scope", async () => {
     const { home, vault } = await makeVault()
     const pair = await duplicatePair(home, 'model "quoted".bin')
     await vault.sweeper.scan()
@@ -1571,19 +1571,18 @@ describe("Save Space engine", () => {
     }), { revealed: true })
     assert.deepEqual(launched, [pair.first])
 
-    const outside = await vault.perform("reveal", {
+    assert.notEqual(first.source_id, second.source_id)
+    assert.deepEqual(await vault.perform("reveal", {
       scope_id: first.source_id,
       path: pair.second
-    })
-    assert.match(outside.error, /outside the current location/i)
-    assert.notEqual(first.source_id, second.source_id)
-    assert.deepEqual(launched, [pair.first])
+    }), { revealed: true })
+    assert.deepEqual(launched, [pair.first, pair.second])
 
     const untracked = await vault.perform("reveal", {
       path: path.join(home, "api", "first", "missing.bin")
     })
     assert.match(untracked.error, /no longer tracked/i)
-    assert.deepEqual(launched, [pair.first])
+    assert.deepEqual(launched, [pair.first, pair.second])
 
     await close(vault)
   })
@@ -2447,6 +2446,159 @@ describe("Save Space engine", () => {
     await close(vault)
   })
 
+  test("Make separate frees the anchor once nothing links to it", async () => {
+    const { home, vault } = await makeVault()
+    const pair = await duplicatePair(home)
+    await vault.sweeper.scan()
+    const duplicate = [...await vault.registry.files({
+      statuses: ["duplicate"]
+    })][0]
+    await vault.perform("deduplicate", { path: duplicate.path })
+    const hash = duplicate.hash
+    const storePath = vault.storePathFor(hash)
+    const linked = [...await vault.registry.files({ statuses: ["linked"] })]
+    assert.equal(linked.length, 2)
+
+    assert.equal((await vault.perform("detach", {
+      path: linked[0].path
+    })).status, "detached")
+    assert.equal(fs.existsSync(storePath), true)
+    assert.equal((await fs.promises.stat(storePath)).nlink, 2)
+    assert.equal((await vault.registry.anchorsForHash(hash)).length, 1)
+
+    assert.equal((await vault.perform("detach", {
+      path: linked[1].path
+    })).status, "detached")
+    assert.equal(fs.existsSync(storePath), false)
+    assert.equal((await vault.registry.anchorsForHash(hash)).length, 0)
+
+    for (const entry of linked) {
+      await assertCandidateContents(entry.path, pair.contents, pair.size)
+    }
+    const activity = await vault.status(null, {
+      view: "activity",
+      page_size: 500
+    })
+    assert.equal(activity.items.some((item) => item.kind === "reclaim"), true)
+    await close(vault)
+  })
+
+  test("freeing the anchor leaves the registry ready to deduplicate again", async () => {
+    const { home, vault } = await makeVault()
+    await duplicatePair(home)
+    await vault.sweeper.scan()
+    const duplicate = [...await vault.registry.files({
+      statuses: ["duplicate"]
+    })][0]
+    await vault.perform("deduplicate", { path: duplicate.path })
+    for (const row of [...await vault.registry.files({
+      statuses: ["linked"]
+    })]) {
+      assert.equal((await vault.perform("detach", {
+        path: row.path
+      })).status, "detached")
+    }
+
+    const rows = [...await vault.registry.files({})]
+    assert.equal(rows.filter((row) => row.status === "reference").length, 1)
+    assert.equal(rows.filter((row) => row.status === "duplicate").length, 1)
+    const target = rows.find((row) => row.status === "duplicate")
+    assert.equal((await vault.perform("deduplicate", {
+      path: target.path
+    })).status, "converted")
+    await close(vault)
+  })
+
+  test("bulk Make separate frees only the anchors nothing links to", async () => {
+    const { home, vault } = await makeVault()
+    await duplicatePair(home, "kept.bin")
+    const trio = crypto.randomBytes(4096)
+    for (const name of ["one", "two", "three"]) {
+      await writeCandidate(path.join(home, "api", name, "freed.bin"), trio)
+    }
+    await vault.sweeper.scan()
+    const result = await vault.perform("deduplicate_files", {
+      paths: [...await vault.registry.files({
+        statuses: ["duplicate"]
+      })].map((item) => item.path)
+    })
+    assert.equal(result.converted, 3)
+
+    const linked = [...await vault.registry.files({ statuses: ["linked"] })]
+    const freedHash = linked.find((item) =>
+      path.basename(item.path) === "freed.bin").hash
+    const keptHash = linked.find((item) =>
+      path.basename(item.path) === "kept.bin").hash
+    const freedStore = vault.storePathFor(freedHash)
+    const keptStore = vault.storePathFor(keptHash)
+
+    const separated = await vault.perform("separate_files", {
+      paths: linked
+        .filter((item) => path.basename(item.path) === "freed.bin")
+        .map((item) => item.path)
+        .concat(linked.find((item) =>
+          path.basename(item.path) === "kept.bin").path)
+    })
+    assert.equal(separated.separated, 4)
+
+    assert.equal(fs.existsSync(freedStore), false)
+    assert.equal((await vault.registry.anchorsForHash(freedHash)).length, 0)
+    assert.equal(fs.existsSync(keptStore), true)
+    assert.equal((await vault.registry.anchorsForHash(keptHash)).length, 1)
+    await close(vault)
+  })
+
+  test("Expanding a file lists every location for its own identity", async () => {
+    const { home, vault } = await makeVault()
+    const contents = crypto.randomBytes(4096)
+    for (const name of ["one", "two", "three"]) {
+      await writeCandidate(path.join(home, "api", name, "shared.bin"), contents)
+    }
+    await vault.sweeper.scan()
+    const duplicate = [...await vault.registry.files({
+      statuses: ["duplicate"]
+    })][0]
+
+    const byHash = await vault.fileLocations(null, duplicate.path)
+    assert.equal(byHash.total, 3)
+    assert.equal(byHash.items.length, 3)
+    assert.equal(byHash.items.some((entry) =>
+      entry.path === duplicate.path), true)
+
+    await vault.perform("deduplicate", { path: duplicate.path })
+    const byInode = await vault.fileLocations(null, duplicate.path)
+    assert.equal(byInode.total, 2)
+    assert.equal(byInode.items.length, 2)
+    const untouched = [...await vault.registry.files({
+      statuses: ["duplicate"]
+    })][0]
+    assert.equal(byInode.items.some((entry) =>
+      entry.path === untouched.path), false)
+    await close(vault)
+  })
+
+  test("an app workspace lists every location but acts only on its own", async () => {
+    const { home, vault } = await makeVault()
+    const contents = crypto.randomBytes(4096)
+    for (const app of ["one", "two", "three"]) {
+      await writeCandidate(path.join(home, "api", app, "shared.bin"), contents)
+    }
+    await vault.sweeper.scan()
+
+    const scope = "app:two"
+    const status = await vault.status(scope, { view: "all", page_size: 100 })
+    assert.equal(status.items.length, 1)
+    const row = status.items[0]
+    assert.equal(row.location_count, 3)
+
+    const locations = await vault.fileLocations(scope, row.path)
+    assert.equal(locations.total, 3)
+    assert.equal(locations.items.length, 3)
+    assert.equal(new Set(locations.items.map((item) =>
+      item.source_id)).size, 3)
+    await close(vault)
+  })
+
   test("invalid scoped actions cannot expand into a global mutation", async () => {
     const { home, vault } = await makeVault()
     await duplicatePair(home)

package/test/vault-ui.test.js

@@ -160,7 +160,9 @@ const makePage = async (status, options = {}) => {
       runScripts: "outside-only",
       url: appMode
         ? "http://localhost/vault/app/app"
-        : "http://localhost/vault"
+        : `http://localhost/vault${options.focusGroup
+          ? `?group=${options.focusGroup}`
+          : ""}`
     }
   )
   const requests = []
@@ -784,6 +786,159 @@ describe("Save Space interface", () => {
     dom.window.close()
   })
 
+  test("expanding a file loads its real locations instead of row samples", async () => {
+    const duplicate = item({
+      path: "/pinokio/api/app/models/duplicate.bin",
+      relative_path: "models/duplicate.bin",
+      status: "duplicate",
+      shareable: true,
+      location_count: 3,
+      locations: [{
+        path: "/pinokio/api/app/models/duplicate.bin",
+        source_id: "app:app",
+        source_label: "app",
+        relative_path: "models/duplicate.bin"
+      }, {
+        path: "/pinokio/api/app/models/sample.bin",
+        source_id: "app:app",
+        source_label: "app",
+        relative_path: "models/sample.bin"
+      }]
+    })
+    const base = fixture([duplicate])
+    base.inventory.source_counts.duplicates["app:app"] = 1
+    base.inventory.shareable_by_source["app:app"] = 1
+    const response = (url) => {
+      const parsed = new URL(url, "http://localhost")
+      if (parsed.searchParams.get("locations_path")) {
+        return {
+          path: parsed.searchParams.get("locations_path"),
+          items: [
+            ["duplicate", "duplicate"],
+            ["first", "tracked"],
+            ["third", "shared"]
+          ].map(([name, status]) => ({
+            path: `/pinokio/api/app/models/${name}.bin`,
+            status,
+            source_id: "app:app",
+            source_label: "app",
+            relative_path: `models/${name}.bin`
+          })),
+          total: 3,
+          deduplicatable: 1,
+          next_cursor: null
+        }
+      }
+      const result = JSON.parse(JSON.stringify(base))
+      result.items = [duplicate]
+      return result
+    }
+    const { dom, getRequests } = await makePage(response)
+    const document = dom.window.document
+
+    document.querySelector('[data-view="duplicates"]').click()
+    await waitFor(() => document.querySelector(
+      '[data-view="duplicates"].selected'))
+    const disclosure = document.querySelector(
+      '[data-expand-file="/pinokio/api/app/models/duplicate.bin"]')
+    assert.ok(disclosure)
+    disclosure.click()
+
+    await waitFor(() => getRequests.some((url) =>
+      new URL(url, "http://localhost").searchParams
+        .get("locations_path") === "/pinokio/api/app/models/duplicate.bin"))
+    await waitFor(() => document.querySelector(".vault-location-path"))
+    const detail = document.querySelector(".vault-detail")
+    assert.match(detail.textContent, /Stored 3 times · 4\.1 KB each/)
+    assert.doesNotMatch(detail.textContent, /sample\.bin/)
+    assert.doesNotMatch(detail.textContent, /of 3 locations shown/)
+    const notes = [...detail.querySelectorAll(".vault-location-note")]
+      .map((node) => node.textContent)
+    assert.deepEqual(notes, [
+      "this file",
+      "the copy that stays",
+      "already deduplicated"
+    ])
+    await settle()
+    dom.window.close()
+  })
+
+  test("leftover storage is presented as a Trash the user can empty", async () => {
+    const blob = {
+      store_id: "home",
+      hash: "b".repeat(64),
+      size: 11500000,
+      nlink: 1,
+      orphan: 1
+    }
+    const base = fixture([])
+    base.inventory.counts.reclaimable = 1
+    base.reclaimable = blob.size
+    base.enabled = true
+    const response = (url) => {
+      const view = new URL(url, "http://localhost")
+        .searchParams.get("view") || "all"
+      const result = JSON.parse(JSON.stringify(base))
+      result.inventory.view = view
+      result.items = view === "reclaimable" ? [blob] : []
+      return result
+    }
+    const { dom } = await makePage(response)
+    const document = dom.window.document
+
+    assert.match(document.querySelector("#vault-views").textContent, /Trash/)
+    document.querySelector('[data-view="reclaimable"]').click()
+    await waitFor(() => document.querySelector(
+      '[data-view="reclaimable"].selected'))
+    await waitFor(() => document.querySelector("[data-reclaim]"))
+
+    const body = document.body.textContent
+    assert.match(body, /Empty Trash/)
+    assert.doesNotMatch(body, /private link/i)
+    assert.doesNotMatch(body, /ready to clean up/i)
+    assert.doesNotMatch(body, /their linked files were deleted/i)
+    await settle()
+    dom.window.close()
+  })
+
+  test("a scoped page hands one content group to the global page", async () => {
+    const hash = "c".repeat(64)
+    const duplicate = item({
+      path: "/pinokio/api/app/models/duplicate.bin",
+      relative_path: "models/duplicate.bin",
+      status: "duplicate",
+      shareable: true,
+      hash,
+      location_count: 3
+    })
+    const base = fixture([duplicate])
+    base.inventory.source_counts.duplicates["app:app"] = 1
+    base.inventory.shareable_by_source["app:app"] = 1
+    const response = (url) => {
+      const parsed = new URL(url, "http://localhost")
+      if (parsed.searchParams.get("group_hash")) {
+        return { hash, items: [], total: 3, next_cursor: null }
+      }
+      const result = JSON.parse(JSON.stringify(base))
+      result.inventory.view = parsed.searchParams.get("view") || "all"
+      result.items = [duplicate]
+      return result
+    }
+    const { dom, getRequests } = await makePage(response, {
+      focusGroup: hash
+    })
+    const document = dom.window.document
+
+    await waitFor(() => document.querySelector(
+      '[data-view="duplicates"].selected'))
+    assert.ok(document.querySelector('[data-display-mode="files"].selected'))
+    await waitFor(() => getRequests.some((url) =>
+      new URL(url, "http://localhost").searchParams
+        .get("group_hash") === hash))
+    await settle()
+    dom.window.close()
+  })
+
   test("Cannot deduplicate is separate from actionable duplicates", async () => {
     const duplicate = item({
       path: "/pinokio/api/app/models/duplicate.bin",