pinokiod 8.0.80 → 8.0.100

package/kernel/shell.js

@@ -1263,6 +1263,13 @@ class Shell {
           if (cuda_script) {
             conda_activation.push(`CALL "${cuda_script}" > "${cuda_log}" 2>&1`)
           }
+          // The conda-forge VS activation script prepends Library\lib before
+          // calling vcvars, but vcvars rebuilds LIB and drops that entry.
+          // Restore both the active Conda environment and managed CUDA import
+          // libraries after all compiler activation scripts have completed.
+          // CALL's second expansion is required because these commands are
+          // joined on one cmd.exe line and must read LIB after vcvars updates it.
+          conda_activation.push(`CALL set "LIB=%%CONDA_PREFIX%%\\Library\\lib;%%CUDA_HOME%%\\lib;%%LIB%%"`)
         } catch (e) {
           console.log('vc vars setup', e)
         }

package/kernel/vault/constants.js

@@ -1,11 +1,13 @@
 const CANDIDATE_SIZE_BASE = process.platform === "win32" ? 1024 : 1000
 const SIZE_THRESHOLD = 100 * CANDIDATE_SIZE_BASE ** 2
-const CANDIDATE_SIZE_OPTIONS = [0]
-  .concat([1, 10, 50, 100, 500].map((value) => value * CANDIDATE_SIZE_BASE ** 2))
+const CANDIDATE_SIZE_OPTIONS = [10, 50, 100, 500]
+  .map((value) => value * CANDIDATE_SIZE_BASE ** 2)
   .concat(CANDIDATE_SIZE_BASE ** 3)
+const MINIMUM_CANDIDATE_SIZE = CANDIDATE_SIZE_OPTIONS[0]
 const isCandidateFileSize = (size, threshold) => size > 0 && size >= threshold
 
 module.exports = {
+  MINIMUM_CANDIDATE_SIZE,
   SIZE_THRESHOLD,
   CANDIDATE_SIZE_OPTIONS,
   isCandidateFileSize,

package/kernel/vault/index.js

@@ -11,6 +11,7 @@ const AutomaticScans = require("./automatic_scans")
 const { fileSnapshot, sameSnapshot, sameContentState } = require("./snapshot")
 const { cancelledError } = require("./operation_errors")
 const {
+  MINIMUM_CANDIDATE_SIZE,
   SIZE_THRESHOLD,
   CANDIDATE_SIZE_OPTIONS,
   TMP_SUFFIX,
@@ -2417,6 +2418,9 @@ class Vault {
         unavailable_reason: unavailableReason
       }
     }
+    if (targetStat.size < MINIMUM_CANDIDATE_SIZE) {
+      return markUnavailable("below_minimum_size")
+    }
     const prepared = await this.ensureAnchorForHash(target.hash, targetStat)
     if (prepared.status !== "ready") {
       if (prepared.status === "unavailable") {

package/kernel/vault/registry_core.js

@@ -3227,7 +3227,7 @@ class RegistryCore {
   beginScan(scopeId = null) {
     // The scan schema is reset for every run, so a compact integer is enough.
     // Repeating a UUID in tens of millions of temporary rows and indexes turns
-    // an All files scan into many gigabytes of avoidable I/O.
+    // a low-threshold scan into many gigabytes of avoidable I/O.
     const id = 1
     this.scanSizes.clear()
     this.scanInodes.clear()

package/package.json

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

package/server/public/vault.js

@@ -90,7 +90,7 @@ const COPY = {
   manual_description: "Scan only when requested",
   storage_saved_headline: "{size} saved by deduplicating",
   storage_unique_headline: "{size} unique to this app",
-  storage_still_used: "Still used",
+  storage_still_used: "In use",
   storage_saved: "Saved",
   storage_unique: "Unique",
   storage_shared: "Shared",
@@ -192,6 +192,7 @@ const COPY = {
   hardlinks_unavailable: "This disk does not support shared files",
   anchor_conflict: "The stored matching copy could not be verified",
   permission_denied: "Disk Saver cannot modify this file or its folder",
+  below_minimum_size: "This file is below the 10 MB safety minimum",
   cannot_share_safely: "This file cannot safely share storage",
   changed_since_scan: "Some files changed since the scan. Scan again before deduplicating them.",
   deduplicate_locked: "Stop the app before deduplicating this file.",
@@ -394,8 +395,8 @@ const candidateSizeBase = document.body.dataset.platform === "win32" ? 1024 : 10
 const AUTOMATIC_SUPPORTED = document.body.dataset.platform === "darwin" ||
   document.body.dataset.platform === "win32"
 const defaultCandidateSize = 100 * candidateSizeBase ** 2
-const candidateSizeOptions = [0]
-  .concat([1, 10, 50, 100, 500].map((value) => value * candidateSizeBase ** 2))
+const candidateSizeOptions = [10, 50, 100, 500]
+  .map((value) => value * candidateSizeBase ** 2)
   .concat(candidateSizeBase ** 3)
 const PAGE_SIZE = 500
 
@@ -494,7 +495,7 @@ const candidateSize = () => {
   return candidateSizeOptions.includes(value) ? value : defaultCandidateSize
 }
 const candidateSizeLabel = (size = candidateSize()) => {
-  return size === 0 ? COPY.all : `${fmt(size)}+`
+  return `${fmt(size)}+`
 }
 const renderCandidateSizeControl = () => {
   const size = candidateSize()
@@ -1657,7 +1658,8 @@ const unavailableLabel = (item) => ({
   hardlinks: COPY.hardlinks_unavailable,
   different_disk: COPY.different_disk,
   anchor_conflict: COPY.anchor_conflict,
-  permission_denied: COPY.permission_denied
+  permission_denied: COPY.permission_denied,
+  below_minimum_size: COPY.below_minimum_size
 }[item.unavailable_reason] || COPY.cannot_share_safely)
 const statusMarkup = (item) => {
   if (item.status === "unavailable") {

package/test/shell-run-template.test.js

@@ -174,6 +174,47 @@ test('Shell.activate keeps managed Python downloads automatic on every platform'
   }
 })
 
+test('Shell.activate restores Conda and CUDA library paths after Windows compiler activation', async (t) => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-shell-windows-lib-'))
+  t.after(() => fs.rm(root, { recursive: true, force: true }))
+  const activateRoot = path.join(root, 'bin', 'miniforge', 'etc', 'conda', 'activate.d', 'pinokio')
+  const compilerScript = path.join(activateRoot, 'vs2019_compiler_vars.bat')
+  const cudaScript = path.join(activateRoot, '~cuda-nvcc_activate.bat')
+  await fs.mkdir(activateRoot, { recursive: true })
+  await fs.writeFile(compilerScript, '@echo off\n')
+  await fs.writeFile(cudaScript, '@echo off\n')
+
+  const kernel = createKernel(root)
+  kernel.bin = {
+    activationCommands: () => [],
+    path: (...parts) => path.join(root, 'bin', ...parts),
+    vs_path_env: {},
+  }
+  const shell = createShell(kernel)
+  shell.platform = 'win32'
+  shell.shell = 'cmd.exe'
+  shell.env = {}
+
+  const params = await shell.activate({
+    build: true,
+    path: root,
+    message: ['uv pip install cupy'],
+  })
+
+  const activation = params.message[0]
+  const compilerIndex = activation.indexOf(`CALL "${compilerScript}"`)
+  const cudaIndex = activation.indexOf(`CALL "${cudaScript}"`)
+  const libraryCommand = 'CALL set "LIB=%%CONDA_PREFIX%%\\Library\\lib;%%CUDA_HOME%%\\lib;%%LIB%%"'
+  const libraryIndex = activation.indexOf(libraryCommand)
+
+  assert.notEqual(compilerIndex, -1)
+  assert.notEqual(cudaIndex, -1)
+  assert.notEqual(libraryIndex, -1)
+  assert.ok(compilerIndex < cudaIndex)
+  assert.ok(cudaIndex < libraryIndex)
+  assert.equal(params.message[1], 'uv pip install cupy')
+})
+
 test('Shell.init_env defaults the uv HTTP timeout without overriding apps', async () => {
   const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-shell-uv-timeout-'))
   await fs.mkdir(path.join(root, 'api'), { recursive: true })

package/test/vault-automatic-scans.test.js

@@ -1247,7 +1247,7 @@ describe("automatic app checks", () => {
     await fs.promises.writeFile(second, "same-content")
     const vault = await makeVault(home)
     vault.lastScanCache.set("", { candidate_min_bytes: 1 })
-    await vault.registry.setScanSetting(`app:${app}`, 0)
+    vault.automaticScans.candidateThreshold = async () => 1
     const hashedPaths = []
     const originalHashFile = vault.hashFile.bind(vault)
     vault.hashFile = async (filePath, options) => {

package/test/vault-engine.test.js

@@ -9,9 +9,12 @@ const Vault = require("../kernel/vault")
 const Registry = require("../kernel/vault/registry")
 const {
   CANDIDATE_SIZE_OPTIONS,
+  MINIMUM_CANDIDATE_SIZE,
   SIZE_THRESHOLD
 } = require("../kernel/vault/constants")
 
+const candidateBase = process.platform === "win32" ? 1024 : 1000
+
 const homes = []
 
 const makeHome = async () => {
@@ -35,7 +38,7 @@ const makeVault = async ({ candidateSize = CANDIDATE_SIZE_OPTIONS[0] } = {}) =>
   const vault = new Vault(kernel)
   kernel.vault = vault
   await vault.init()
-  vault.sizeThreshold = CANDIDATE_SIZE_OPTIONS[0]
+  vault.sizeThreshold = 1
   if (candidateSize !== null) {
     await vault.perform("set_candidate_size", {
       candidate_size: candidateSize
@@ -50,13 +53,29 @@ const write = async (filePath, contents) => {
   return filePath
 }
 
+const writeCandidate = async (
+  filePath,
+  contents,
+  size = MINIMUM_CANDIDATE_SIZE
+) => {
+  await write(filePath, contents)
+  await fs.promises.truncate(filePath, size)
+  return filePath
+}
+
+const assertCandidateContents = async (filePath, contents, size) => {
+  const expected = Buffer.alloc(size)
+  contents.copy(expected)
+  assert.deepEqual(await fs.promises.readFile(filePath), expected)
+}
+
 const duplicatePair = async (home, name = "model.bin") => {
   const contents = crypto.randomBytes(4096)
-  const first = await write(
+  const first = await writeCandidate(
     path.join(home, "api", "first", name), contents)
-  const second = await write(
+  const second = await writeCandidate(
     path.join(home, "api", "second", name), contents)
-  return { contents, first, second }
+  return { contents, first, second, size: MINIMUM_CANDIDATE_SIZE }
 }
 
 const close = async (vault) => {
@@ -268,6 +287,33 @@ describe("Save Space engine", () => {
     await close(vault)
   })
 
+  test("minimum size settings reject values below 10 MB", async () => {
+    const { vault } = await makeVault({ candidateSize: null })
+
+    for (const candidateSize of [0, candidateBase ** 2]) {
+      assert.match((await vault.perform("set_candidate_size", {
+        candidate_size: candidateSize
+      })).error, /valid minimum file size/i)
+    }
+    assert.equal(CANDIDATE_SIZE_OPTIONS[0],
+      MINIMUM_CANDIDATE_SIZE)
+    assert.deepEqual(CANDIDATE_SIZE_OPTIONS, [
+      10, 50, 100, 500, 1000
+    ].map((value) => value * candidateBase ** 2))
+    assert.equal(await vault.registry.scanSetting(), null)
+
+    await close(vault)
+  })
+
+  test("legacy minimum size settings fall back to 100 MB", async () => {
+    const { vault } = await makeVault({ candidateSize: null })
+    await vault.registry.setScanSetting(null, candidateBase ** 2)
+
+    assert.equal((await vault.status()).candidate_min_bytes, SIZE_THRESHOLD)
+
+    await close(vault)
+  })
+
   test("minimum size settings reject malformed scopes", async () => {
     const { vault } = await makeVault({ candidateSize: null })
 
@@ -677,11 +723,11 @@ describe("Save Space engine", () => {
     const { home, vault } = await makeVault()
     const outside = await makeOutside()
     const contents = crypto.randomBytes(4096)
-    const pinokioFile = await write(
+    const pinokioFile = await writeCandidate(
       path.join(home, "api", "app", "model.bin"), contents)
-    const direct = await write(
+    const direct = await writeCandidate(
       path.join(outside, "other-app", "model.bin"), contents)
-    const nested = await write(
+    const nested = await writeCandidate(
       path.join(outside, "other-app", "models", "model.bin"),
       contents
     )
@@ -721,11 +767,11 @@ describe("Save Space engine", () => {
     assert.equal(discovery.phase, "complete", discovery.error)
     assert.equal(discovery.result_count, 1)
     assert.equal(discovery.result_files, 2)
-    assert.equal(discovery.result_bytes, contents.length * 2)
+    assert.equal(discovery.result_bytes, MINIMUM_CANDIDATE_SIZE * 2)
     assert.equal(discovery.candidates_known, true)
     assert.equal(discovery.processed, discovery.candidates)
     assert.equal(discovery.verified_files, 2)
-    assert.equal(discovery.verified_bytes, contents.length * 2)
+    assert.equal(discovery.verified_bytes, MINIMUM_CANDIDATE_SIZE * 2)
     const results = await vault.folderDiscoveryResults()
     assert.equal(results.total, 1)
     assert.equal(results.root.folder,
@@ -733,7 +779,7 @@ describe("Save Space engine", () => {
     assert.equal(results.items[0].folder,
       path.join(await fs.promises.realpath(outside), "other-app"))
     assert.equal(results.items[0].file_count, 2)
-    assert.equal(results.items[0].bytes, contents.length * 2)
+    assert.equal(results.items[0].bytes, MINIMUM_CANDIDATE_SIZE * 2)
     assert.equal(results.items[0].eligible_file_count, 2)
     const recommendations = await vault.registry
       .folderDiscoveryRecommendations(vault.folderFinder.runId)
@@ -772,20 +818,20 @@ describe("Save Space engine", () => {
     const first = crypto.randomBytes(4096)
     const second = crypto.randomBytes(6144)
     const unrelated = crypto.randomBytes(7168)
-    await write(path.join(home, "api", "first", "model.bin"), first)
-    await write(path.join(home, "api", "second", "model.bin"), second)
-    const unrelatedPath = await write(
+    await writeCandidate(path.join(home, "api", "first", "model.bin"), first)
+    await writeCandidate(path.join(home, "api", "second", "model.bin"), second)
+    const unrelatedPath = await writeCandidate(
       path.join(home, "api", "unrelated-a", "model.bin"), unrelated)
-    await write(
+    await writeCandidate(
       path.join(home, "api", "unrelated-b", "model.bin"), unrelated)
     const comfy = path.join(outside, ".comfycraft")
     const release = path.join(outside, "pinokio_2026_0627")
-    await write(path.join(comfy, "kits", "ace", "model.bin"), first)
-    await write(path.join(comfy, "kits", "hello", "model.bin"), second)
+    await writeCandidate(path.join(comfy, "kits", "ace", "model.bin"), first)
+    await writeCandidate(path.join(comfy, "kits", "hello", "model.bin"), second)
     await write(path.join(comfy, "logs", "history.bin"),
       crypto.randomBytes(2048))
-    await write(path.join(release, "api", "first", "model.bin"), first)
-    await write(path.join(release, "api", "second", "model.bin"), second)
+    await writeCandidate(path.join(release, "api", "first", "model.bin"), first)
+    await writeCandidate(path.join(release, "api", "second", "model.bin"), second)
 
     await vault.sweeper.scan()
     const unrelatedHash = (await vault.registry.getFile(unrelatedPath)).hash
@@ -823,7 +869,7 @@ describe("Save Space engine", () => {
     const kitChildren = await vault.folderDiscoveryChildren(
       comfyChildren.items[0].folder)
     assert.equal(kitChildren.items.length, 2)
-    assert.equal(comfyResult.eligible_file_count, 3)
+    assert.equal(comfyResult.eligible_file_count, 2)
     assert.equal(comfyResult.file_count, 2)
 
     const selected = [
@@ -889,9 +935,9 @@ describe("Save Space engine", () => {
     const contents = crypto.randomBytes(8192)
     await write(path.join(home, "api", "baseline", "unique.bin"),
       crypto.randomBytes(contents.length))
-    const first = await write(
+    const first = await writeCandidate(
       path.join(outside, "first-app", "model.bin"), contents)
-    const second = await write(
+    const second = await writeCandidate(
       path.join(outside, "second-app", "model.bin"), contents)
 
     await vault.sweeper.scan()
@@ -904,7 +950,7 @@ describe("Save Space engine", () => {
     const discovery = vault.folderDiscoveryStatus()
     const results = await vault.folderDiscoveryResults()
     assert.equal(discovery.result_files, 2)
-    assert.equal(discovery.result_bytes, contents.length * 2)
+    assert.equal(discovery.result_bytes, MINIMUM_CANDIDATE_SIZE * 2)
     assert.equal(results.selection.selected_count, 0)
     await vault.perform("update_folder_discovery_selection", {
       root: discovery.root,
@@ -915,7 +961,7 @@ describe("Save Space engine", () => {
     const staged = (await vault.folderDiscoveryResults()).selection
     assert.equal(staged.selected_count, 1)
     assert.equal(staged.selected_files, 2)
-    assert.equal(staged.potential_savings, contents.length)
+    assert.equal(staged.potential_savings, MINIMUM_CANDIDATE_SIZE)
 
     vault.hashFile = async () => {
       throw new Error("Adding staged results must not hash files again.")
@@ -936,8 +982,9 @@ describe("Save Space engine", () => {
     assert.equal(secondRow.status, "duplicate")
     const status = await vault.status()
     assert.equal(status.bytes_without_sharing, contents.length)
-    assert.equal(status.logical_bytes, contents.length * 3)
-    assert.equal(status.pending_bytes, contents.length)
+    assert.equal(status.logical_bytes,
+      MINIMUM_CANDIDATE_SIZE * 2 + contents.length)
+    assert.equal(status.pending_bytes, MINIMUM_CANDIDATE_SIZE)
     await close(vault)
   })
 
@@ -957,7 +1004,8 @@ describe("Save Space engine", () => {
     await vault.sweeper.scan()
     assert.equal((await vault.registry.files()).length, 0)
 
-    await write(path.join(outside, "models", "model.bin"), pair.contents)
+    await writeCandidate(
+      path.join(outside, "models", "model.bin"), pair.contents, pair.size)
     assert.equal((await vault.perform("find_folders", {
       path: outside,
       candidate_size: CANDIDATE_SIZE_OPTIONS[0]
@@ -967,7 +1015,7 @@ describe("Save Space engine", () => {
     const discovery = vault.folderDiscoveryStatus()
     assert.equal(discovery.phase, "complete", discovery.error)
     assert.equal(discovery.result_files, 1)
-    assert.equal(discovery.result_bytes, pair.contents.length)
+    assert.equal(discovery.result_bytes, pair.size)
     const results = await vault.folderDiscoveryResults()
     assert.equal(results.total, 1)
     assert.equal(results.selection.selected_count, 0)
@@ -979,7 +1027,7 @@ describe("Save Space engine", () => {
     })
     const selected = (await vault.folderDiscoveryResults()).selection
     assert.equal(selected.selected_files, 1)
-    assert.equal(selected.potential_savings, pair.contents.length)
+    assert.equal(selected.potential_savings, pair.size)
     await close(vault)
   })
 
@@ -987,8 +1035,8 @@ describe("Save Space engine", () => {
     const { home, vault } = await makeVault()
     const outside = await makeOutside()
     const contents = crypto.randomBytes(4096)
-    await write(path.join(home, "api", "app", "model.bin"), contents)
-    const outsideFile = await write(
+    await writeCandidate(path.join(home, "api", "app", "model.bin"), contents)
+    const outsideFile = await writeCandidate(
       path.join(outside, "models", "model.bin"), contents)
     const canonicalOutsideFile = await fs.promises.realpath(outsideFile)
     await vault.sweeper.scan()
@@ -1037,18 +1085,45 @@ describe("Save Space engine", () => {
     const { home, vault } = await makeVault()
     const outside = await makeOutside()
     const contents = crypto.randomBytes(64)
-    await write(path.join(home, "api", "context", "model.bin"), contents)
+    await writeCandidate(
+      path.join(home, "api", "context", "model.bin"), contents)
     for (let index = 0; index < 501; index++) {
-      await write(path.join(
+      await writeCandidate(path.join(
         outside,
         `app-${String(index).padStart(3, "0")}`,
         "models",
         "model.bin"
       ), contents)
     }
-    await write(path.join(outside, "unrelated.bin"),
-      crypto.randomBytes(contents.length * 1000))
     await vault.sweeper.scan()
+    const resultHash = crypto.createHash("sha256")
+      .update(contents)
+      .update(Buffer.alloc(MINIMUM_CANDIDATE_SIZE - contents.length))
+      .digest("hex")
+    vault.hashFile = async (filePath) => ({
+      hash: resultHash,
+      size: (await fs.promises.stat(filePath)).size
+    })
+    const prepareResults = vault.registry.prepareFolderDiscoveryResults
+      .bind(vault.registry)
+    vault.registry.prepareFolderDiscoveryResults = async (runId, root) => {
+      const stat = await fs.promises.stat(root)
+      // Force recommendations below the root without creating a huge file.
+      const staged = await vault.registry.stageFolderDiscoveryFiles(runId, [{
+        path: path.join(root, "unrelated.bin"),
+        size: MINIMUM_CANDIDATE_SIZE * 1000,
+        mtime: stat.mtimeMs,
+        ctime: stat.ctimeMs,
+        dev: stat.dev,
+        ino: 0,
+        nlink: 1,
+        mode: stat.mode,
+        uid: stat.uid,
+        gid: stat.gid
+      }])
+      assert.equal(staged.changes, 1)
+      return prepareResults(runId, root)
+    }
     assert.equal((await vault.perform("find_folders", {
       path: outside,
       candidate_size: CANDIDATE_SIZE_OPTIONS[0]
@@ -1084,13 +1159,24 @@ describe("Save Space engine", () => {
       const outside = await makeOutside()
       const first = crypto.randomBytes(1000)
       const second = crypto.randomBytes(1000)
-      await write(path.join(home, "api", "first", "model.bin"), first)
-      await write(path.join(home, "api", "second", "model.bin"), second)
-      await write(path.join(outside, "group", "a", "model.bin"), first)
-      await write(path.join(outside, "group", "b", "model.bin"), second)
+      await writeCandidate(
+        path.join(home, "api", "first", "model.bin"), first)
+      await writeCandidate(
+        path.join(home, "api", "second", "model.bin"), second)
+      await writeCandidate(
+        path.join(outside, "group", "a", "model.bin"), first)
+      await writeCandidate(
+        path.join(outside, "group", "b", "model.bin"), second)
       for (let index = 0; index < extraSizes.length; index++) {
-        await write(path.join(outside, "group", `extra-${index}.bin`),
-          crypto.randomBytes(extraSizes[index]))
+        const size = Math.max(
+          MINIMUM_CANDIDATE_SIZE,
+          MINIMUM_CANDIDATE_SIZE * extraSizes[index] / 1000
+        )
+        await writeCandidate(
+          path.join(outside, "group", `extra-${index}.bin`),
+          crypto.randomBytes(extraSizes[index]),
+          size
+        )
       }
       await vault.sweeper.scan()
       await vault.perform("find_folders", {
@@ -1249,13 +1335,15 @@ describe("Save Space engine", () => {
     const contents = crypto.randomBytes(4096)
     const stale = []
     for (let index = 0; index < 32; index++) {
-      stale.push(await write(
+      stale.push(await writeCandidate(
         path.join(home, "api", "app", `a${String(index).padStart(2, "0")}.bin`),
         contents
       ))
     }
-    await write(path.join(home, "api", "app", "z-valid.bin"), contents)
-    await write(path.join(outside, "models", "model.bin"), contents)
+    await writeCandidate(
+      path.join(home, "api", "app", "z-valid.bin"), contents)
+    await writeCandidate(
+      path.join(outside, "models", "model.bin"), contents)
     await vault.sweeper.scan()
 
     for (let index = 0; index < stale.length; index++) {
@@ -1338,8 +1426,10 @@ describe("Save Space engine", () => {
     const { home, vault } = await makeVault()
     const outside = await makeOutside()
     const contents = crypto.randomBytes(4096)
-    await write(path.join(home, "api", "app", "model.bin"), contents)
-    await write(path.join(outside, "models", "model.bin"), contents)
+    await writeCandidate(
+      path.join(home, "api", "app", "model.bin"), contents)
+    await writeCandidate(
+      path.join(outside, "models", "model.bin"), contents)
     await vault.sweeper.scan()
     const publishedFiles = await vault.registry.countFiles()
     vault.hashFile = async () => {
@@ -1387,7 +1477,7 @@ describe("Save Space engine", () => {
       store: kernel.store
     })
     await replacement.init()
-    replacement.sizeThreshold = pair.contents.length * 2
+    replacement.sizeThreshold = pair.size * 2
 
     assert.deepEqual(replacement.configuredLocations(), [])
     assert.equal(await replacement.globalScanReady(), false)
@@ -1401,6 +1491,33 @@ describe("Save Space engine", () => {
     await close(replacement)
   })
 
+  test("deduplication refuses legacy scan results below 10 MB", async () => {
+    const { home, vault } = await makeVault()
+    const contents = crypto.randomBytes(4096)
+    const pair = {
+      first: await write(path.join(home, "api", "first", "small.bin"),
+        contents),
+      second: await write(path.join(home, "api", "second", "small.bin"),
+        contents)
+    }
+    await vault.sweeper.scan()
+    const duplicate = [...await vault.registry.files({
+      statuses: ["duplicate"]
+    })][0]
+    const result = await vault.perform("deduplicate", {
+      path: duplicate.path
+    })
+
+    assert.equal(result.status, "unavailable")
+    assert.equal(result.unavailable_reason, "below_minimum_size")
+    const [first, second] = await Promise.all([
+      fs.promises.stat(pair.first),
+      fs.promises.stat(pair.second)
+    ])
+    assert.notEqual(first.ino, second.ino)
+    await close(vault)
+  })
+
   test("explicit deduplication creates the first anchor and changes one path atomically", async () => {
     const { home, vault } = await makeVault()
     const pair = await duplicatePair(home)
@@ -1418,7 +1535,7 @@ describe("Save Space engine", () => {
       path: duplicate.path
     })
     assert.equal(result.status, "converted")
-    assert.equal(result.bytes_saved, pair.contents.length)
+    assert.equal(result.bytes_saved, pair.size)
 
     const firstStat = await fs.promises.stat(pair.first)
     const secondStat = await fs.promises.stat(pair.second)
@@ -1691,7 +1808,7 @@ describe("Save Space engine", () => {
       unavailable_reason: "hardlinks"
     })
     assert.equal((await fs.promises.stat(duplicate.path)).ino, before.ino)
-    assert.deepEqual(await fs.promises.readFile(duplicate.path), pair.contents)
+    await assertCandidateContents(duplicate.path, pair.contents, pair.size)
     const rows = await vault.registry.files({ hash: duplicate.hash })
     assert.equal(rows.every((row) =>
       row.status === "unavailable" &&
@@ -1739,7 +1856,7 @@ describe("Save Space engine", () => {
     assert.equal(row.status, "unavailable")
     assert.equal(row.unavailable_reason, "permission_denied")
     assert.equal((await fs.promises.stat(duplicate.path)).ino, before.ino)
-    assert.deepEqual(await fs.promises.readFile(duplicate.path), pair.contents)
+    await assertCandidateContents(duplicate.path, pair.contents, pair.size)
     const status = await vault.status(null, { view: "duplicates" })
     const unavailable = await vault.status(null, { view: "unavailable" })
     assert.equal(status.inventory.counts.duplicates, 0)
@@ -1903,7 +2020,7 @@ describe("Save Space engine", () => {
     assert.equal(row.status, "unavailable")
     assert.equal(row.unavailable_reason, "metadata")
     assert.equal((await fs.promises.stat(duplicate.path)).ino, before.ino)
-    assert.deepEqual(await fs.promises.readFile(duplicate.path), pair.contents)
+    await assertCandidateContents(duplicate.path, pair.contents, pair.size)
     await close(vault)
   })
 
@@ -1950,7 +2067,7 @@ describe("Save Space engine", () => {
     assert.equal(row.status, "unavailable")
     assert.equal(row.unavailable_reason, "different_disk")
     assert.equal((await fs.promises.stat(duplicate.path)).ino, before.ino)
-    assert.deepEqual(await fs.promises.readFile(duplicate.path), pair.contents)
+    await assertCandidateContents(duplicate.path, pair.contents, pair.size)
     await close(vault)
   })
 
@@ -1990,7 +2107,7 @@ describe("Save Space engine", () => {
     assert.equal(fs.existsSync(
       `${duplicate.path}.pinokio-dedup-tmp`), false)
     assert.equal((await fs.promises.stat(duplicate.path)).ino, before.ino)
-    assert.deepEqual(await fs.promises.readFile(duplicate.path), pair.contents)
+    await assertCandidateContents(duplicate.path, pair.contents, pair.size)
     await close(vault)
   })
 
@@ -2009,7 +2126,8 @@ describe("Save Space engine", () => {
     )
     const anchor = vault.storePathFor(duplicate.hash)
     await fs.promises.unlink(anchor)
-    await fs.promises.writeFile(anchor, crypto.randomBytes(pair.contents.length))
+    await writeCandidate(anchor, crypto.randomBytes(pair.contents.length),
+      pair.size)
     const before = await fs.promises.stat(duplicate.path)
 
     const result = await vault.perform("deduplicate", {
@@ -2018,10 +2136,7 @@ describe("Save Space engine", () => {
 
     assert.equal(result.status, "stale")
     assert.equal((await fs.promises.stat(duplicate.path)).ino, before.ino)
-    assert.deepEqual(
-      await fs.promises.readFile(duplicate.path),
-      pair.contents
-    )
+    await assertCandidateContents(duplicate.path, pair.contents, pair.size)
     await close(vault)
   })
 
@@ -2098,7 +2213,7 @@ describe("Save Space engine", () => {
     assert.equal(matching.inventory.current.separate_count, 2)
     assert.equal(
       matching.inventory.current.separate_bytes,
-      firstPair.contents.length * 2
+      firstPair.size * 2
     )
 
     const result = await vault.perform("separate_all", {
@@ -2161,11 +2276,11 @@ describe("Save Space engine", () => {
     await vault.sweeper.scan()
     let status = await vault.status()
 
-    assert.equal(status.bytes_without_sharing, pair.contents.length * 2)
-    assert.equal(status.logical_bytes, pair.contents.length * 2)
+    assert.equal(status.bytes_without_sharing, pair.size * 2)
+    assert.equal(status.logical_bytes, pair.size * 2)
     assert.equal(status.saved_by_sharing, 0)
-    assert.equal(status.bytes_on_disk, pair.contents.length * 2)
-    assert.equal(status.pending_bytes, pair.contents.length)
+    assert.equal(status.bytes_on_disk, pair.size * 2)
+    assert.equal(status.pending_bytes, pair.size)
     assert.equal(Object.hasOwn(status, "shared_logical_bytes"), false)
     let appStatus = await vault.status("app:first")
     assert.equal(appStatus.shared_logical_bytes, 0)
@@ -2175,21 +2290,21 @@ describe("Save Space engine", () => {
     })][0]
     await vault.perform("deduplicate", { path: duplicate.path })
     status = await vault.status()
-    assert.equal(status.saved_by_sharing, pair.contents.length)
-    assert.equal(status.logical_bytes, pair.contents.length * 2)
-    assert.equal(status.bytes_on_disk, pair.contents.length)
+    assert.equal(status.saved_by_sharing, pair.size)
+    assert.equal(status.logical_bytes, pair.size * 2)
+    assert.equal(status.bytes_on_disk, pair.size)
     assert.equal(status.pending_bytes, 0)
     appStatus = await vault.status("app:first", {
       view: "duplicates",
       query: "does-not-match"
     })
-    assert.equal(appStatus.shared_logical_bytes, pair.contents.length)
+    assert.equal(appStatus.shared_logical_bytes, pair.size)
 
     await vault.perform("separate_files", { paths: [duplicate.path] })
     status = await vault.status()
     assert.equal(status.saved_by_sharing, 0)
-    assert.equal(status.bytes_on_disk, pair.contents.length * 2)
-    assert.equal(status.pending_bytes, pair.contents.length)
+    assert.equal(status.bytes_on_disk, pair.size * 2)
+    assert.equal(status.pending_bytes, pair.size)
     await close(vault)
   })
 
@@ -2254,7 +2369,7 @@ describe("Save Space engine", () => {
     })).status, "detached")
     assert.notEqual((await fs.promises.stat(duplicate.path)).ino, linked.ino)
     assert.equal((await vault.registry.getFile(duplicate.path)).status, "duplicate")
-    assert.deepEqual(await fs.promises.readFile(duplicate.path), pair.contents)
+    await assertCandidateContents(duplicate.path, pair.contents, pair.size)
     assert.equal((await vault.perform("review_again", {
       path: duplicate.path
     })).error, "unknown action")

package/test/vault-sweep.test.js

@@ -6,6 +6,7 @@ const os = require("node:os")
 const path = require("node:path")
 const Vault = require("../kernel/vault")
 const RegistryCore = require("../kernel/vault/registry_core")
+const { MINIMUM_CANDIDATE_SIZE } = require("../kernel/vault/constants")
 const { statMany } = require("../kernel/vault/walker")
 
 const homes = []
@@ -20,6 +21,12 @@ const write = async (filePath, contents) => {
   return filePath
 }
 
+const writeCandidate = async (filePath, contents) => {
+  await write(filePath, contents)
+  await fs.promises.truncate(filePath, MINIMUM_CANDIDATE_SIZE)
+  return filePath
+}
+
 const makeVault = async (threshold = 1) => {
   const home = await fs.promises.mkdtemp(
     path.join(os.tmpdir(), "pinokio-vault-scan-"))
@@ -455,7 +462,7 @@ describe("Save Space scans", () => {
     assert.equal((await vault.registry.getFile(linked)).status, "linked")
   })
 
-  test("All files excludes empty files and retains more than one page", async () => {
+  test("a low-threshold scan excludes empty files and retains more than one page", async () => {
     const { home, vault } = await makeVault(0)
     const root = path.join(home, "api", "many")
     const paths = []
@@ -490,7 +497,7 @@ describe("Save Space scans", () => {
       .concat(secondPage.items.map((item) => item.path))).size, paths.length)
   })
 
-  test("All files sends only matching size groups to hash work", async () => {
+  test("a low-threshold scan sends only matching size groups to hash work", async () => {
     const { home, vault } = await makeVault(0)
     const root = path.join(home, "api", "windows")
     for (let index = 1; index <= 300; index++) {
@@ -676,9 +683,10 @@ describe("Save Space scans", () => {
   test("an anchor sharing a scanned inode is not counted as a second read", async () => {
     const { home, vault } = await makeVault()
     const contents = crypto.randomBytes(4096)
-    const first = await write(
+    const first = await writeCandidate(
       path.join(home, "api", "one", "model.bin"), contents)
-    await write(path.join(home, "api", "two", "model.bin"), contents)
+    await writeCandidate(
+      path.join(home, "api", "two", "model.bin"), contents)
     await vault.sweeper.scan()
     const duplicate = [...await vault.registry.files({
       statuses: ["duplicate"]
@@ -703,10 +711,11 @@ describe("Save Space scans", () => {
     assert.equal(reads, 1)
     assert.equal(vault.sweeper.state.hash_work_files, 1)
     assert.equal(vault.sweeper.state.hash_files_completed, 1)
-    assert.equal(vault.sweeper.state.hash_work_bytes, contents.length)
+    assert.equal(vault.sweeper.state.hash_work_bytes,
+      MINIMUM_CANDIDATE_SIZE)
     assert.equal(
       vault.sweeper.state.hash_bytes_completed,
-      contents.length
+      MINIMUM_CANDIDATE_SIZE
     )
     assert.equal((await vault.registry.getFile(first)).hash, duplicate.hash)
   })
@@ -1375,8 +1384,10 @@ describe("Save Space scans", () => {
   test("an anchor fallback does not change the discovered hash workload", async () => {
     const { home, vault } = await makeVault()
     const contents = crypto.randomBytes(4096)
-    await write(path.join(home, "api", "one", "model.bin"), contents)
-    await write(path.join(home, "api", "two", "model.bin"), contents)
+    await writeCandidate(
+      path.join(home, "api", "one", "model.bin"), contents)
+    await writeCandidate(
+      path.join(home, "api", "two", "model.bin"), contents)
     await vault.sweeper.scan()
     const duplicate = [...await vault.registry.files({
       statuses: ["duplicate"]
@@ -1429,7 +1440,7 @@ describe("Save Space scans", () => {
       const progress = vault.scanStatus()
       assert.equal(progress.hash_work_files, 1)
       assert.equal(progress.hash_files_completed, 0)
-      assert.equal(progress.hash_work_bytes, contents.length)
+      assert.equal(progress.hash_work_bytes, MINIMUM_CANDIDATE_SIZE)
       assert.equal(progress.hash_bytes_completed, 0)
     } finally {
       releaseAnchor()
@@ -1445,10 +1456,11 @@ describe("Save Space scans", () => {
     assert.equal(result.outcome, "completed_with_exclusions")
     assert.equal(vault.sweeper.state.hash_work_files, 1)
     assert.equal(vault.sweeper.state.hash_files_completed, 1)
-    assert.equal(vault.sweeper.state.hash_work_bytes, contents.length)
+    assert.equal(vault.sweeper.state.hash_work_bytes,
+      MINIMUM_CANDIDATE_SIZE)
     assert.equal(
       vault.sweeper.state.hash_bytes_completed,
-      contents.length
+      MINIMUM_CANDIDATE_SIZE
     )
   })
 
@@ -1602,12 +1614,15 @@ describe("Save Space scans", () => {
   test("a missing database is rebuilt by a normal scan, including managed links below the threshold", async () => {
     const { home, vault, store } = await makeVault()
     const contents = crypto.randomBytes(4096)
-    await write(path.join(home, "api", "one", "model.bin"), contents)
-    await write(path.join(home, "api", "two", "model.bin"), contents)
+    await writeCandidate(
+      path.join(home, "api", "one", "model.bin"), contents)
+    await writeCandidate(
+      path.join(home, "api", "two", "model.bin"), contents)
     await vault.sweeper.scan()
     const duplicate = [...await vault.registry.files({
       statuses: ["duplicate"]
     })][0]
+    const hash = duplicate.hash
     await vault.perform("deduplicate", { path: duplicate.path })
     const managedPath = duplicate.path
 
@@ -1619,7 +1634,7 @@ describe("Save Space scans", () => {
       store
     })
     await replacement.init()
-    replacement.sizeThreshold = contents.length * 2
+    replacement.sizeThreshold = MINIMUM_CANDIDATE_SIZE * 2
     vaults.push(replacement)
     assert.equal(await replacement.registry.countFiles(), 0)
 
@@ -1628,21 +1643,23 @@ describe("Save Space scans", () => {
     const rebuilt = await replacement.registry.getFile(managedPath)
     assert.ok(rebuilt)
     assert.equal(rebuilt.status, "linked")
-    assert.equal(rebuilt.hash, sha256(contents))
+    assert.equal(rebuilt.hash, hash)
   })
 
   test("managed links remain tracked below the threshold if their anchor was removed externally", async () => {
     const { home, vault } = await makeVault()
     const contents = crypto.randomBytes(4096)
-    await write(path.join(home, "api", "one", "model.bin"), contents)
-    await write(path.join(home, "api", "two", "model.bin"), contents)
+    await writeCandidate(
+      path.join(home, "api", "one", "model.bin"), contents)
+    await writeCandidate(
+      path.join(home, "api", "two", "model.bin"), contents)
     await vault.sweeper.scan()
     const duplicate = [...await vault.registry.files({
       statuses: ["duplicate"]
     })][0]
     await vault.perform("deduplicate", { path: duplicate.path })
     await fs.promises.unlink(vault.storePathFor(duplicate.hash))
-    vault.sizeThreshold = contents.length * 2
+    vault.sizeThreshold = MINIMUM_CANDIDATE_SIZE * 2
 
     await vault.sweeper.scan()
 
@@ -1744,11 +1761,11 @@ describe("Save Space scans", () => {
     }
     const { home, vault } = await makeVault()
     const contents = crypto.randomBytes(4096)
-    const incompatible = await write(
+    const incompatible = await writeCandidate(
       path.join(home, "api", "a", "model.bin"), contents)
-    const compatibleOne = await write(
+    const compatibleOne = await writeCandidate(
       path.join(home, "api", "b", "model.bin"), contents)
-    const compatibleTwo = await write(
+    const compatibleTwo = await writeCandidate(
       path.join(home, "api", "c", "model.bin"), contents)
     await fs.promises.chmod(incompatible, 0o600)
     await fs.promises.chmod(compatibleOne, 0o644)

package/test/vault-ui.test.js

@@ -520,8 +520,9 @@ describe("Save Space interface", () => {
     assert.doesNotMatch(combined,
       /Keep separate|Kept separate|Review again|review_again/)
     assert.doesNotMatch(combined, /\bundo\b/i)
-    assert.match(combined, /const candidateSizeOptions = \[0\]/)
-    assert.match(combined, /\[1, 10, 50, 100, 500\]/)
+    assert.match(combined,
+      /const candidateSizeOptions = \[10, 50, 100, 500\]/)
+    assert.doesNotMatch(combined, /const candidateSizeOptions = \[0\]/)
     assert.match(combined, /The rest of the scan completed\./)
     assert.doesNotMatch(combined, /Previous completed results were kept\./)
     assert.match(combined, /Scan completed with exclusions/)
@@ -617,11 +618,11 @@ describe("Save Space interface", () => {
     const globalChart = globalDocument.querySelector(".vault-storage-chart")
 
     assert.match(globalHeadline.textContent, /saved by deduplicating/)
-    assert.match(globalChart.getAttribute("aria-label"), /Still used:/)
+    assert.match(globalChart.getAttribute("aria-label"), /In use:/)
     assert.match(globalChart.getAttribute("aria-label"), /Saved:/)
     assert.match(globalChart.getAttribute("aria-label"), /Can save:/)
     assert.match(globalDocument.querySelector(
-      ".vault-storage-key.occupied").textContent, /Still used/)
+      ".vault-storage-key.occupied").textContent, /In use/)
     assert.match(globalDocument.querySelector(
       ".vault-storage-key.optimized").textContent, /Saved/)
     assert.match(globalDocument.querySelector(
@@ -747,9 +748,9 @@ describe("Save Space interface", () => {
     assert.match(document.getElementById("btn-scan").textContent,
       /Scan again/)
     assert.equal(requests.some((request) => request.action === "scan"), false)
-    document.querySelector('[data-candidate-size="0"]').click()
-    assert.match(document.getElementById("vault-scan-size-label").textContent,
-      /All files/)
+    assert.equal(document.querySelector('[data-candidate-size="0"]'), null)
+    assert.equal(document.querySelector(
+      `[data-candidate-size="${candidateBase ** 2}"]`), null)
     assert.equal(requests.some((request) => request.action === "scan"), false)
     document.querySelector(`[data-candidate-size="${100 * candidateBase ** 2}"]`).click()
     assert.ok(document.querySelector('.vault-all-locations[data-source=""]'))
@@ -892,8 +893,8 @@ describe("Save Space interface", () => {
 
   test("an app displays and immediately saves its own minimum size", async () => {
     const candidateBase = process.platform === "win32" ? 1024 : 1000
-    const appMinimum = candidateBase ** 2
-    const globalMinimum = 10 * candidateBase ** 2
+    const appMinimum = 10 * candidateBase ** 2
+    const globalMinimum = 100 * candidateBase ** 2
     const selected = 50 * candidateBase ** 2
     const { dom, requests } = await makePage(fixture([], {
       candidate_min_bytes: appMinimum,