pinokiod 8.0.102 → 8.0.105

package/kernel/vault/index.js

@@ -2854,6 +2854,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 +2918,7 @@ class Vault {
       }
     }
     if (affectedHashes.size) {
+      await this.freeUnusedAnchors(affectedHashes)
       await this.reclassifyHashes(affectedHashes)
     }
     const event = {
@@ -2998,6 +3002,7 @@ class Vault {
         }
       }
       if (affectedHashes.size) {
+        await this.freeUnusedAnchors(affectedHashes)
         await this.reclassifyHashes(affectedHashes)
       }
       if (changedHashes instanceof FileActionChanges) {
@@ -3074,6 +3079,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: "" }
@@ -3330,6 +3356,45 @@ 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
+      }, this.locationForPath(row.path, row.source_id))),
+      total: Number(result.total) || 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,77 @@ 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
+    return {
+      rows,
+      total,
+      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.105",
   "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.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,15 @@ const COPY = {
   selected_copy: "Selected",
   loading_copies: "Loading copies…",
   show_more_copies: "Show {count} more copies",
+  loading_locations: "Loading locations…",
+  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",
@@ -260,7 +259,6 @@ const COPY = {
   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",
   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,21 +271,20 @@ 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"
 }
@@ -330,6 +327,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)
@@ -416,6 +421,8 @@ const state = {
   expandedFiles: new Set(),
   expandedDuplicateGroups: new Set(),
   duplicateGroupChildren: new Map(),
+  fileLocations: new Map(),
+  locationsScanTs: undefined,
   duplicateGroupGeneration: 0,
   selectedDuplicateFiles: new Map(),
   selectedSeparateFiles: new Set(),
@@ -454,11 +461,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
 }
 
@@ -1696,15 +1711,22 @@ 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)
+  const label = `${COPY.identical_contents_at} ${countLabel(total, COPY.location, COPY.locations_lower)}`
+  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>`
+    : ""
+  return `<div class="vault-detail"><div class="vault-detail-label">${esc(label)}</div>${locations.items.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("")}${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 +1743,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 +1848,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 +2252,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 +2776,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 +2864,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,12 +2877,11 @@ 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
@@ -2883,6 +2900,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 +2942,11 @@ const applyFullData = (data) => {
     reviewedScan() !== String(data.last_scan.ts) &&
     (shareableDuplicateCount > 0 || data.last_scan.partial)
   settleFolderDiscoveryStart()
+  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 +3062,7 @@ const runAction = async (payload, success) => {
   } catch (error) {
     state.feedback = { error: true, message: error && error.message ? error.message : String(error) }
   }
+  closeFileLocations()
   await refresh(true)
 }
 
@@ -3741,11 +3770,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

@@ -2447,6 +2447,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

@@ -784,6 +784,110 @@ 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: ["first", "second", "third"].map((name) => ({
+            path: `/pinokio/api/app/models/${name}.bin`,
+            source_id: "app:app",
+            source_label: "app",
+            relative_path: `models/${name}.bin`
+          })),
+          total: 3,
+          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-detail") &&
+      document.querySelector(".vault-detail").textContent.includes("third.bin"))
+    const detail = document.querySelector(".vault-detail")
+    assert.match(detail.textContent, /Identical contents at 3 locations/)
+    assert.match(detail.textContent, /first\.bin/)
+    assert.doesNotMatch(detail.textContent, /sample\.bin/)
+    assert.doesNotMatch(detail.textContent, /of 3 locations shown/)
+    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("Cannot deduplicate is separate from actionable duplicates", async () => {
     const duplicate = item({
       path: "/pinokio/api/app/models/duplicate.bin",