pinokiod 8.0.78 → 8.0.79

package/kernel/api/notify/index.js

@@ -6,7 +6,8 @@
       href: <link location to open>,
       target: <target for window.open()>,
       features: <windowFeatures>,
-      audio: <play audio if true>,
+      type: <notification type>,
+      silent: <disable the notification sound if true>,
     }
   }
 (*/

package/kernel/vault/automatic_scans.js

@@ -1,7 +1,6 @@
 const fs = require("fs")
 const path = require("path")
 const {
-  SIZE_THRESHOLD,
   isCandidateFileSize,
   SHA256_RE,
   ENTRY_BATCH_SIZE
@@ -276,7 +275,7 @@ class AutomaticScans {
     if (!collected.size) this.discardChangedPaths(app)
   }
 
-  async candidatePolicy() {
+  async candidatePolicy(app = null) {
     const cached = this.vault.lastScanCache &&
       typeof this.vault.lastScanCache.get === "function"
       ? this.vault.lastScanCache.get("")
@@ -284,13 +283,13 @@ class AutomaticScans {
     const scan = cached || (this.vault.registry
       ? await this.vault.registry.scanFor()
       : null)
-    const threshold = scan ? Number(scan.candidate_min_bytes) : NaN
+    const threshold = app
+      ? await this.vault.candidateSizeForApp(app)
+      : await this.vault.candidateSizeSetting(null)
     const hasLinkableDevices = !!(
       scan && Array.isArray(scan.linkable_devices))
     return {
-      threshold: Number.isFinite(threshold) && threshold >= 0
-        ? threshold
-        : SIZE_THRESHOLD,
+      threshold,
       linkability_known: hasLinkableDevices,
       linkable_devices: new Set(hasLinkableDevices
         ? scan.linkable_devices
@@ -1039,7 +1038,7 @@ class AutomaticScans {
       unstable_hashes: 0
     }
     markStage("policy-read")
-    const policy = await this.candidatePolicy()
+    const policy = await this.candidatePolicy(app)
     const threshold = await this.candidateThreshold(policy)
     const linkableDevices = policy.linkable_devices
     const paths = [...new Set(active.paths || [])].filter((filePath) =>

package/kernel/vault/index.js

@@ -1899,6 +1899,25 @@ class Vault {
         }
         return this.runMutation(() =>
           this.removeExternalSource(payload.source_id))
+      case "set_candidate_size": {
+        if (payload.scope_id != null &&
+            typeof payload.scope_id !== "string") {
+          return { error: "Choose a valid scan scope." }
+        }
+        const scopeId = typeof payload.scope_id === "string" && payload.scope_id
+          ? payload.scope_id
+          : null
+        if (scopeId) {
+          const source = this.scanSource(scopeId)
+          if (!source || source.kind !== "app") {
+            return { error: "That app is no longer available." }
+          }
+        }
+        return this.setCandidateSizeSetting(
+          scopeId,
+          payload.candidate_size
+        )
+      }
       case "scan": {
         const scanSource = payload.scope_id
           ? this.scanSource(payload.scope_id)
@@ -1913,22 +1932,21 @@ class Vault {
             code: "global_scan_required"
           }
         }
-        let threshold = this.sizeThreshold
-        if (payload.candidate_size != null) {
-          if (!CANDIDATE_SIZE_OPTIONS.includes(payload.candidate_size)) {
-            return { error: "Choose a valid minimum file size." }
-          }
-          threshold = payload.candidate_size
-        }
+        const settingScopeId = scanSource && scanSource.kind === "app"
+          ? scanSource.id
+          : null
+        const threshold = await this.candidateSizeSetting(settingScopeId)
         return this.startScan(payload.scope_id || null, threshold)
       }
       case "cancel_scan":
         return this.cancelScan()
-      case "find_folders":
+      case "find_folders": {
+        const threshold = await this.candidateSizeSetting(null)
         return this.startFolderDiscovery(
           payload.path,
-          payload.candidate_size
+          threshold
         )
+      }
       case "cancel_find_folders":
         return this.cancelFolderDiscovery()
       case "clear_find_folders":
@@ -3115,6 +3133,33 @@ class Vault {
     return scoped
   }
 
+  async candidateSizeSetting(scopeId = null) {
+    const setting = await this.registry.scanSetting(scopeId)
+    const minimum = setting && Number(setting.candidate_min_bytes)
+    if (CANDIDATE_SIZE_OPTIONS.includes(minimum)) return minimum
+    return SIZE_THRESHOLD
+  }
+
+  async setCandidateSizeSetting(scopeId = null, candidateMinBytes) {
+    if (!Number.isSafeInteger(candidateMinBytes) ||
+        !CANDIDATE_SIZE_OPTIONS.includes(candidateMinBytes)) {
+      return { error: "Choose a valid minimum file size." }
+    }
+    const setting = await this.registry.setScanSetting(
+      scopeId,
+      candidateMinBytes
+    )
+    return {
+      scope_id: scopeId || null,
+      candidate_min_bytes: setting.candidate_min_bytes,
+      updated_at: setting.updated_at
+    }
+  }
+
+  candidateSizeForApp(app) {
+    return this.candidateSizeSetting(sourceId("app", app))
+  }
+
   sourceCountMaps(summaryRows) {
     const counts = {
       all: {},
@@ -3391,13 +3436,10 @@ class Vault {
     const lastScan = await this.scanForScope(scopeId)
     const globalScan = scopeId ? await this.scanForScope(null) : lastScan
     const globalScanReady = this.globalScanIsReady(globalScan)
-    const publishedCandidateMinimum = globalScan
-      ? Number(globalScan.candidate_min_bytes)
-      : NaN
-    const globalCandidateMinimum = Number.isFinite(
-      publishedCandidateMinimum) && publishedCandidateMinimum >= 0
-      ? publishedCandidateMinimum
-      : SIZE_THRESHOLD
+    const candidateMinimum = await this.candidateSizeSetting(scopeId)
+    const globalCandidateMinimum = scopeId
+      ? await this.candidateSizeSetting(null)
+      : candidateMinimum
     const before = lastScan && Number.isFinite(lastScan.bytes_total)
       ? lastScan.bytes_total
       : 0
@@ -3435,6 +3477,7 @@ class Vault {
     const result = {
       enabled: true,
       global_scan_ready: globalScanReady,
+      candidate_min_bytes: candidateMinimum,
       global_candidate_min_bytes: globalCandidateMinimum,
       mode: this.mode,
       scan: this.scanStatus(),

package/kernel/vault/registry.js

@@ -172,6 +172,8 @@ for (const method of [
   "removeAutomaticAppScanApp",
   "setAutomaticAppScanState",
   "scanFor",
+  "scanSetting",
+  "setScanSetting",
   "removeScan",
   "beginScan",
   "abortScan",

package/kernel/vault/registry_core.js

@@ -306,6 +306,13 @@ class RegistryCore {
       FROM automatic_app_scans
       WHERE state = 'paused';
 
+      CREATE TABLE IF NOT EXISTS minimum_size_settings (
+        scope_id TEXT PRIMARY KEY,
+        candidate_min_bytes INTEGER NOT NULL CHECK (
+          candidate_min_bytes >= 0
+        ),
+        updated_at INTEGER NOT NULL
+      );
     `)
     const automaticScanColumns = new Set(this.database.prepare(
       "PRAGMA table_info(automatic_app_scans)"
@@ -2670,6 +2677,38 @@ class RegistryCore {
     })
   }
 
+  scanSetting(scopeId = null) {
+    const row = this.database.prepare(`
+      SELECT candidate_min_bytes, updated_at
+      FROM minimum_size_settings
+      WHERE scope_id = ?
+    `).get(scopeId || "")
+    return row ? {
+      candidate_min_bytes: Number(row.candidate_min_bytes),
+      updated_at: Number(row.updated_at) || 0
+    } : null
+  }
+
+  setScanSetting(scopeId = null, candidateMinBytes) {
+    const minimum = candidateMinBytes
+    if (!Number.isSafeInteger(minimum) || minimum < 0) {
+      throw new Error("Invalid minimum file size setting.")
+    }
+    const updatedAt = Date.now()
+    this.database.prepare(`
+      INSERT INTO minimum_size_settings(
+        scope_id, candidate_min_bytes, updated_at
+      ) VALUES (?, ?, ?)
+      ON CONFLICT(scope_id) DO UPDATE SET
+        candidate_min_bytes = excluded.candidate_min_bytes,
+        updated_at = excluded.updated_at
+    `).run(scopeId || "", minimum, updatedAt)
+    return {
+      candidate_min_bytes: minimum,
+      updated_at: updatedAt
+    }
+  }
+
   automaticAppScanStates() {
     return this.database.prepare(`
       SELECT app, state, signature, updated_at

package/package.json

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

package/server/public/tab-idle-notifier.js

@@ -276,17 +276,24 @@
       return;
     }
     const rect = anchor.getBoundingClientRect();
-    const scrollX = window.scrollX || window.pageXOffset || 0;
-    const scrollY = window.scrollY || window.pageYOffset || 0;
-    const top = rect.bottom + scrollY + 6;
-    let left = rect.left + scrollX;
+    const viewportPadding = 12;
+    const menuGap = 6;
     const menuWidth = menu.offsetWidth || 0;
-    const viewportRight = scrollX + window.innerWidth;
-    if (left + menuWidth > viewportRight - 12) {
-      left = Math.max(scrollX + 12, viewportRight - menuWidth - 12);
-    }
-    if (left < scrollX + 12) {
-      left = scrollX + 12;
+    const menuHeight = menu.offsetHeight || 0;
+    let left = rect.left;
+    let top = rect.bottom + menuGap;
+    if (left + menuWidth > window.innerWidth - viewportPadding) {
+      left = Math.max(viewportPadding, window.innerWidth - menuWidth - viewportPadding);
+    }
+    if (left < viewportPadding) {
+      left = viewportPadding;
+    }
+    const topAbove = rect.top - menuHeight - menuGap;
+    if (top + menuHeight > window.innerHeight - viewportPadding && topAbove >= viewportPadding) {
+      top = topAbove;
+    } else {
+      top = Math.min(top, Math.max(viewportPadding, window.innerHeight - menuHeight - viewportPadding));
+      top = Math.max(viewportPadding, top);
     }
     menu.style.top = `${Math.round(top)}px`;
     menu.style.left = `${Math.round(left)}px`;
@@ -857,10 +864,13 @@
   color: var(--pinokio-focus-color, #4c9afe);
 }
 .pinokio-notify-popover {
-  position: absolute;
+  position: fixed;
   z-index: 2147482000;
   min-width: 220px;
   max-width: 280px;
+  max-height: calc(100dvh - 24px);
+  overflow-y: auto;
+  overscroll-behavior: contain;
   color: #f8fafc;
   background: rgba(15, 23, 42, 0.97);
   border-radius: 10px;
@@ -980,6 +990,133 @@ const syncToggleAppearance = (toggle, enabled) => {
     });
   };
 
+  const updateNotificationPreferenceForFrame = (frameName, enabled) => {
+    const state = getOrCreateState(frameName);
+    if (!state) {
+      return null;
+    }
+    const next = Boolean(enabled);
+    state.notifyEnabled = next;
+    setPreference(frameName, next);
+    syncInlineToggleStateForFrame(frameName);
+    return next;
+  };
+
+  const populateInlineSoundSelect = (select, options) => {
+    if (!(select instanceof HTMLSelectElement)) {
+      return;
+    }
+    const effectiveOptions = Array.isArray(options) && options.length > 0
+      ? options
+      : baseSoundOptions();
+    const selectedChoice = globalSoundPreference?.choice || SOUND_DEFAULT_CHOICE;
+    select.replaceChildren();
+    effectiveOptions.forEach((option) => {
+      if (!option || !option.value || !option.label) {
+        return;
+      }
+      const node = document.createElement('option');
+      node.value = option.value;
+      node.textContent = option.label;
+      node.selected = option.value === selectedChoice;
+      select.appendChild(node);
+    });
+    if (Array.from(select.options).some((option) => option.value === selectedChoice)) {
+      select.value = selectedChoice;
+    } else {
+      select.value = SOUND_DEFAULT_CHOICE;
+    }
+  };
+
+  const mountNotificationSettingsForLink = (link, container, callbacks = {}) => {
+    if (!(container instanceof HTMLElement)) {
+      return false;
+    }
+    const context = getNotificationMenuStateForLink(link);
+    if (!context.available || !context.frameName) {
+      return false;
+    }
+    const state = getOrCreateState(context.frameName);
+    if (!state) {
+      return false;
+    }
+
+    container.replaceChildren();
+
+    const toggleRow = document.createElement('div');
+    toggleRow.className = 'tab-link-notification-setting-row';
+    const toggleLabel = document.createElement('span');
+    toggleLabel.className = 'tab-link-notification-setting-label';
+    toggleLabel.textContent = 'Notifications for this tab';
+    const toggleControl = document.createElement('div');
+    toggleControl.className = 'tab-link-notification-toggle-control';
+    const toggleStatus = document.createElement('span');
+    toggleStatus.className = 'tab-link-notification-toggle-status';
+    const toggle = document.createElement('button');
+    toggle.type = 'button';
+    toggle.className = 'tab-link-notification-switch';
+    toggle.setAttribute('role', 'switch');
+    toggle.setAttribute('aria-label', 'Notifications for this tab');
+    const toggleThumb = document.createElement('span');
+    toggleThumb.className = 'tab-link-notification-switch-thumb';
+    toggle.setAttribute('aria-describedby', `${container.id || 'tab-link-notification-settings'}-status`);
+    toggleStatus.id = `${container.id || 'tab-link-notification-settings'}-status`;
+    toggle.appendChild(toggleThumb);
+    toggleControl.append(toggleStatus, toggle);
+    toggleRow.append(toggleLabel, toggleControl);
+
+    const soundRow = document.createElement('label');
+    soundRow.className = 'tab-link-notification-setting-row';
+    const soundLabel = document.createElement('span');
+    soundLabel.className = 'tab-link-notification-setting-label';
+    soundLabel.textContent = 'Sound';
+    const soundSelect = document.createElement('select');
+    soundSelect.className = 'tab-link-notification-sound-select';
+    soundSelect.setAttribute('aria-label', 'Notification sound');
+    soundRow.append(soundLabel, soundSelect);
+
+    const syncToggle = (enabled) => {
+      toggle.setAttribute('aria-checked', enabled ? 'true' : 'false');
+      toggle.dataset.enabled = enabled ? 'true' : 'false';
+      toggleStatus.textContent = enabled ? 'On' : 'Off';
+    };
+
+    syncToggle(Boolean(state.notifyEnabled));
+    populateInlineSoundSelect(soundSelect, soundOptionsCache || baseSoundOptions());
+    container.append(toggleRow, soundRow);
+
+    toggle.addEventListener('click', () => {
+      const current = getOrCreateState(context.frameName);
+      if (!current) {
+        return;
+      }
+      const enabled = updateNotificationPreferenceForFrame(context.frameName, !current.notifyEnabled);
+      if (enabled === null) {
+        return;
+      }
+      syncToggle(enabled);
+      if (typeof callbacks.onEnabledChange === 'function') {
+        callbacks.onEnabledChange(enabled);
+      }
+    });
+
+    soundSelect.addEventListener('change', () => {
+      applySoundSelection(soundSelect.value);
+      if (typeof callbacks.onSoundChange === 'function') {
+        callbacks.onSoundChange(globalSoundPreference.choice);
+      }
+    });
+
+    loadSoundOptions().then((options) => {
+      if (!container.isConnected || !container.contains(soundSelect)) {
+        return;
+      }
+      populateInlineSoundSelect(soundSelect, options);
+    }).catch(() => {});
+
+    return true;
+  };
+
   const getNotificationMenuStateForLink = (link) => {
     if (!(link instanceof HTMLElement)) {
       return { available: false, enabled: true, frameName: null };
@@ -1498,5 +1635,8 @@ const ensureTabAccessories = aggregateDebounce(() => {
     openMenuForLink(link, anchor) {
       return openNotificationMenuForLink(link, anchor);
     },
+    mountSettingsForLink(link, container, callbacks) {
+      return mountNotificationSettingsForLink(link, container, callbacks);
+    },
   };
 })();

package/server/public/tab-link-popover.css

@@ -220,6 +220,113 @@ body.dark .tab-link-popover .tab-link-popover-item:hover,
 body.dark .tab-link-popover .tab-link-popover-item:focus-visible {
   background: rgba(148, 163, 184, 0.12);
 }
+.tab-link-popover .tab-link-popover-item[aria-expanded="true"] {
+  background: rgba(15, 23, 42, 0.04);
+}
+body.dark .tab-link-popover .tab-link-popover-item[aria-expanded="true"] {
+  background: rgba(148, 163, 184, 0.08);
+}
+.tab-link-notification-settings {
+  margin: 0 14px 10px 40px;
+  border: 1px solid rgba(15, 23, 42, 0.1);
+  border-radius: 7px;
+  background: rgba(15, 23, 42, 0.025);
+  overflow: hidden;
+}
+body.dark .tab-link-notification-settings {
+  border-color: rgba(148, 163, 184, 0.18);
+  background: rgba(148, 163, 184, 0.045);
+}
+.tab-link-notification-setting-row {
+  min-height: 44px;
+  padding: 7px 10px;
+  display: grid;
+  grid-template-columns: minmax(0, 1fr) auto;
+  align-items: center;
+  gap: 12px;
+  box-sizing: border-box;
+  color: inherit;
+}
+.tab-link-notification-setting-row + .tab-link-notification-setting-row {
+  border-top: 1px solid rgba(15, 23, 42, 0.08);
+}
+body.dark .tab-link-notification-setting-row + .tab-link-notification-setting-row {
+  border-top-color: rgba(148, 163, 184, 0.14);
+}
+.tab-link-notification-setting-label {
+  min-width: 0;
+  font-size: 12px;
+  font-weight: 500;
+  color: rgba(15, 23, 42, 0.76);
+}
+body.dark .tab-link-notification-setting-label {
+  color: rgba(226, 232, 240, 0.86);
+}
+.tab-link-notification-toggle-control {
+  display: inline-flex;
+  align-items: center;
+  gap: 7px;
+}
+.tab-link-notification-toggle-status {
+  min-width: 18px;
+  font-size: 11px;
+  text-align: right;
+  color: rgba(15, 23, 42, 0.56);
+}
+body.dark .tab-link-notification-toggle-status {
+  color: rgba(226, 232, 240, 0.62);
+}
+.tab-link-notification-switch {
+  position: relative;
+  width: 36px;
+  height: 26px;
+  padding: 4px;
+  appearance: none;
+  border: 0;
+  border-radius: 999px;
+  background: rgba(100, 116, 139, 0.42);
+  cursor: pointer;
+  transition: background-color 140ms ease;
+}
+.tab-link-notification-switch[data-enabled="true"] {
+  background: var(--pinokio-focus-color, #2563eb);
+}
+.tab-link-notification-switch-thumb {
+  display: block;
+  width: 18px;
+  height: 18px;
+  border-radius: 50%;
+  background: #f8fafc;
+  box-shadow: 0 1px 2px rgba(15, 23, 42, 0.24);
+  transform: translateX(0);
+  transition: transform 140ms ease;
+}
+.tab-link-notification-switch[data-enabled="true"] .tab-link-notification-switch-thumb {
+  transform: translateX(10px);
+}
+.tab-link-notification-switch:focus-visible,
+.tab-link-notification-sound-select:focus-visible {
+  outline: 2px solid var(--pinokio-focus-color, #2563eb);
+  outline-offset: 2px;
+}
+.tab-link-notification-sound-select {
+  width: min(160px, 44vw);
+  min-height: 32px;
+  padding: 5px 28px 5px 9px;
+  border: 1px solid rgba(15, 23, 42, 0.14);
+  border-radius: 6px;
+  background: var(--pinokio-sidebar-tabbar-bg, #ffffff);
+  color: rgba(15, 23, 42, 0.82);
+  font: inherit;
+  font-size: 12px;
+  cursor: pointer;
+}
+body.dark .tab-link-notification-sound-select {
+  border-color: rgba(148, 163, 184, 0.22);
+  background: rgba(15, 23, 42, 0.42);
+  color: rgba(241, 245, 249, 0.9);
+  color-scheme: dark;
+}
 .tab-link-popover .tab-link-popover-item .label {
   font-size: 11px;
   font-weight: 600;
@@ -344,6 +451,27 @@ body.dark .tab-link-popover .tab-link-popover-footer:focus-visible {
     padding-right: 16px;
     padding-left: 16px;
   }
+  .tab-link-notification-settings {
+    margin-right: 16px;
+    margin-left: 42px;
+  }
+  .tab-link-notification-setting-row {
+    padding-right: 8px;
+    padding-left: 8px;
+  }
+}
+@media (pointer: coarse) {
+  .tab-link-notification-switch {
+    width: 44px;
+    height: 30px;
+    padding: 4px;
+  }
+  .tab-link-notification-switch[data-enabled="true"] .tab-link-notification-switch-thumb {
+    transform: translateX(14px);
+  }
+  .tab-link-notification-sound-select {
+    min-height: 44px;
+  }
 }
 .appcanvas > aside .menu-container .tab-link-popover-host {
   display: flex;

package/server/public/tab-link-popover.js

@@ -266,10 +266,39 @@
         if (action === "notifications") {
           const activeLink = tabLinkActiveLink
           const notifier = typeof window !== "undefined" ? window.PinokioIdleNotifier : null
-          const anchor = activeLink ? (activeLink.querySelector(`.${TAB_LINK_TRIGGER_CLASS}`) || activeLink) : null
-          hideTabLinkPopover({ immediate: true })
-          if (notifier && typeof notifier.openMenuForLink === "function") {
-            notifier.openMenuForLink(activeLink, anchor)
+          const existingPanel = item.nextElementSibling
+          if (existingPanel && existingPanel.classList.contains("tab-link-notification-settings")) {
+            existingPanel.remove()
+            item.setAttribute("aria-expanded", "false")
+            item.removeAttribute("aria-controls")
+            return
+          }
+          if (notifier && typeof notifier.mountSettingsForLink === "function") {
+            const panel = document.createElement("div")
+            panel.className = "tab-link-notification-settings"
+            panel.id = `${TAB_LINK_POPOVER_ID}-notification-settings`
+            panel.setAttribute("role", "group")
+            panel.setAttribute("aria-label", "Desktop notification settings")
+            item.insertAdjacentElement("afterend", panel)
+            const value = item.querySelector(".value")
+            const icon = item.querySelector(".tab-link-popover-action-icon i")
+            const mounted = notifier.mountSettingsForLink(activeLink, panel, {
+              onEnabledChange(enabled) {
+                if (value) {
+                  value.textContent = enabled ? "Enabled for this tab" : "Disabled for this tab"
+                }
+                if (icon) {
+                  icon.classList.toggle("fa-bell", enabled)
+                  icon.classList.toggle("fa-bell-slash", !enabled)
+                }
+              }
+            })
+            if (mounted) {
+              item.setAttribute("aria-controls", panel.id)
+              item.setAttribute("aria-expanded", "true")
+            } else {
+              panel.remove()
+            }
           }
           return
         }
@@ -1898,6 +1927,9 @@
       if (actionItem.action) {
         item.setAttribute("data-action", actionItem.action)
       }
+      if (actionItem.action === "notifications") {
+        item.setAttribute("aria-expanded", "false")
+      }
       if (actionItem.url) {
         item.setAttribute("data-url", actionItem.url)
       }

package/server/public/vault.js

@@ -402,6 +402,7 @@ const PAGE_SIZE = 500
 const state = {
   data: null,
   candidateSize: defaultCandidateSize,
+  persistedCandidateSize: defaultCandidateSize,
   candidateSizeInitialized: false,
   view: "all",
   sourceId: SCOPE_ID,
@@ -546,6 +547,52 @@ const post = async (payload) => {
   if (!result) throw new Error(COPY.action_request_failed.replace("{status}", response.status))
   return result
 }
+let candidateSizeSaveTail = Promise.resolve(true)
+let candidateSizeSaveGeneration = 0
+const saveCandidateSize = (size) => {
+  if (!candidateSizeOptions.includes(size)) return candidateSizeSaveTail
+  const generation = ++candidateSizeSaveGeneration
+  state.candidateSize = size
+  state.candidateSizeInitialized = true
+  renderCandidateSizeControl()
+  const save = candidateSizeSaveTail.then(async () => {
+    const result = await post({
+      action: "set_candidate_size",
+      scope_id: SCOPE_ID,
+      candidate_size: size
+    })
+    if (result.error) throw new Error(result.error)
+    state.persistedCandidateSize = size
+    return true
+  })
+  candidateSizeSaveTail = save.catch(async (error) => {
+    const isCurrent = () => generation === candidateSizeSaveGeneration
+    if (isCurrent() && candidateSize() === size) {
+      state.candidateSizeInitialized = false
+      const refreshed = await refresh(true)
+      if (!refreshed && isCurrent() && !state.candidateSizeInitialized) {
+        state.candidateSize = state.persistedCandidateSize
+        state.candidateSizeInitialized = true
+        renderCandidateSizeControl()
+      }
+    }
+    if (isCurrent()) {
+      state.feedback = {
+        error: true,
+        message: error && error.message ? error.message : String(error)
+      }
+      renderFeedback()
+    }
+    return false
+  })
+  const pending = candidateSizeSaveTail
+  pending.finally(() => {
+    if (candidateSizeSaveTail === pending) {
+      candidateSizeSaveTail = Promise.resolve(true)
+    }
+  })
+  return candidateSizeSaveTail
+}
 const openGlobalWorkspace = () => {
   window.parent.location.assign("/vault")
 }
@@ -2846,10 +2893,13 @@ const settleFolderDiscoveryStart = () => {
 }
 const applyFullData = (data) => {
   if (!state.candidateSizeInitialized) {
-    const published = Number(data && data.global_candidate_min_bytes)
-    state.candidateSize = candidateSizeOptions.includes(published)
-      ? published
+    const saved = Number(data && data.candidate_min_bytes)
+    const fallback = Number(data && data.global_candidate_min_bytes)
+    const selected = candidateSizeOptions.includes(saved) ? saved : fallback
+    state.candidateSize = candidateSizeOptions.includes(selected)
+      ? selected
       : defaultCandidateSize
+    state.persistedCandidateSize = state.candidateSize
     state.candidateSizeInitialized = true
   }
   const scanning = scanActive(data.scan)
@@ -3228,10 +3278,16 @@ const startFolderDiscovery = async (folderPath) => {
   renderFolderDiscovery()
   try {
     resetFolderDiscoveryChoices()
+    if (!await candidateSizeSaveTail) {
+      state.folderDiscoveryStarting = false
+      state.folderDiscoveryChoosingRoot = true
+      renderFolderDiscovery()
+      focusFolderDiscoveryDialog()
+      return
+    }
     const result = await post({
       action: "find_folders",
-      path: folderPath,
-      candidate_size: candidateSize()
+      path: folderPath
     })
     if (result.error) throw new Error(result.error)
     if (!result.started && !result.already_running) {
@@ -3354,10 +3410,8 @@ document.addEventListener("click", async (event) => {
   if (target.hasAttribute("data-candidate-size")) {
     const size = Number(target.dataset.candidateSize)
     if (candidateSizeOptions.includes(size)) {
-      state.candidateSize = size
-      state.candidateSizeInitialized = true
       closeScanSizeMenu()
-      renderCandidateSizeControl()
+      await saveCandidateSize(size)
     }
     return
   }
@@ -3768,10 +3822,13 @@ document.addEventListener("click", async (event) => {
     state.scanPreviewOpen = false
     state.feedback = null
     try {
+      if (!await candidateSizeSaveTail) {
+        state.scanRequested = false
+        return
+      }
       const result = await post({
         action: "scan",
-        scope_id: SCOPE_ID,
-        candidate_size: candidateSize()
+        scope_id: SCOPE_ID
       })
       if (result.error) throw new Error(result.error)
       await refresh()
@@ -4227,11 +4284,9 @@ document.addEventListener("change", async (event) => {
   if (["vault-candidate-size", "vault-find-candidate-size"]
       .includes(event.target.id)) {
     const size = Number(event.target.value)
-    state.candidateSize = candidateSizeOptions.includes(size)
+    await saveCandidateSize(candidateSizeOptions.includes(size)
       ? size
-      : defaultCandidateSize
-    state.candidateSizeInitialized = true
-    renderCandidateSizeControl()
+      : defaultCandidateSize)
     return
   }
   if (event.target.id !== "vault-status-filter") return

package/test/tab-notification-settings.test.js

@@ -0,0 +1,135 @@
+const assert = require("node:assert/strict")
+const fs = require("node:fs/promises")
+const path = require("node:path")
+const test = require("node:test")
+const { JSDOM, VirtualConsole } = require("jsdom")
+
+const root = path.resolve(__dirname, "..")
+const notifierPath = path.resolve(root, "server/public/tab-idle-notifier.js")
+const popoverPath = path.resolve(root, "server/public/tab-link-popover.js")
+const popoverCssPath = path.resolve(root, "server/public/tab-link-popover.css")
+
+const settle = () => new Promise((resolve) => setImmediate(resolve))
+
+test("desktop notification settings mount inline and persist both scopes", async () => {
+  const script = await fs.readFile(notifierPath, "utf8")
+  const virtualConsole = new VirtualConsole()
+  const dom = new JSDOM(`<!doctype html><html><head></head><body>
+    <div class="appcanvas vertical">
+      <aside>
+        <div class="menu-container">
+          <a class="frame-link" href="/run/test" target="test-shell" data-can-notify="true">
+            <span class="tab"><span class="tab-main">Test</span></span>
+          </a>
+        </div>
+      </aside>
+    </div>
+    <div id="settings"></div>
+  </body></html>`, {
+    url: "http://127.0.0.1:42000/run/test",
+    runScripts: "outside-only",
+    pretendToBeVisual: true,
+    virtualConsole,
+    beforeParse(window) {
+      window.fetch = async () => ({
+        ok: true,
+        async json() {
+          return {
+            sounds: [{
+              url: "/sound/bell.mp3",
+              label: "Bell",
+              filename: "bell.mp3"
+            }]
+          }
+        }
+      })
+      window.Audio = class {
+        play() {
+          return Promise.resolve()
+        }
+      }
+    }
+  })
+
+  try {
+    dom.window.eval(script)
+    const link = dom.window.document.querySelector(".frame-link")
+    const settings = dom.window.document.getElementById("settings")
+    let enabledChange = null
+    let soundChange = null
+
+    const mounted = dom.window.PinokioIdleNotifier.mountSettingsForLink(link, settings, {
+      onEnabledChange(enabled) {
+        enabledChange = enabled
+      },
+      onSoundChange(choice) {
+        soundChange = choice
+      }
+    })
+
+    assert.equal(mounted, true)
+    assert.equal(settings.textContent.includes("Notifications for this tab"), true)
+    assert.equal(settings.textContent.includes("Sound"), true)
+
+    const toggle = settings.querySelector('[role="switch"]')
+    const status = settings.querySelector(".tab-link-notification-toggle-status")
+    const select = settings.querySelector("select")
+    assert.equal(toggle.getAttribute("aria-checked"), "true")
+    assert.equal(status.textContent, "On")
+    assert.equal(select.value, "__default__")
+
+    toggle.click()
+    assert.equal(toggle.getAttribute("aria-checked"), "false")
+    assert.equal(status.textContent, "Off")
+    assert.equal(enabledChange, false)
+    assert.deepEqual(JSON.parse(dom.window.localStorage.getItem("pinokio:idle-prefs")), {
+      "test-shell": false
+    })
+
+    toggle.click()
+    assert.equal(toggle.getAttribute("aria-checked"), "true")
+    assert.equal(status.textContent, "On")
+    assert.equal(enabledChange, true)
+    assert.equal(dom.window.localStorage.getItem("pinokio:idle-prefs"), null)
+
+    await settle()
+    assert.equal(Array.from(select.options).some((option) => option.textContent === "Bell"), true)
+    select.value = "/sound/bell.mp3"
+    select.dispatchEvent(new dom.window.Event("change", { bubbles: true }))
+    assert.equal(soundChange, "/sound/bell.mp3")
+    assert.deepEqual(JSON.parse(dom.window.localStorage.getItem("pinokio:idle-sound")), {
+      choice: "/sound/bell.mp3"
+    })
+  } finally {
+    dom.window.close()
+  }
+})
+
+test("tab actions expands notification settings instead of reopening at the sidebar", async () => {
+  const [popover, css] = await Promise.all([
+    fs.readFile(popoverPath, "utf8"),
+    fs.readFile(popoverCssPath, "utf8")
+  ])
+  const branchStart = popover.indexOf('if (action === "notifications")')
+  const branchEnd = popover.indexOf('const url = item.getAttribute("data-url")', branchStart)
+  assert.notEqual(branchStart, -1)
+  assert.notEqual(branchEnd, -1)
+  const branch = popover.slice(branchStart, branchEnd)
+
+  assert.match(branch, /mountSettingsForLink\(activeLink, panel/)
+  assert.match(branch, /tab-link-notification-settings/)
+  assert.match(branch, /panel\.setAttribute\("role", "group"\)/)
+  assert.doesNotMatch(branch, /hideTabLinkPopover/)
+  assert.doesNotMatch(branch, /openMenuForLink/)
+  assert.match(css, /\.tab-link-notification-settings\s*\{/)
+  assert.match(css, /\.tab-link-notification-switch:focus-visible/)
+})
+
+test("legacy notification popover stays inside the viewport", async () => {
+  const notifier = await fs.readFile(notifierPath, "utf8")
+
+  assert.match(notifier, /\.pinokio-notify-popover \{[\s\S]*position: fixed;/)
+  assert.match(notifier, /\.pinokio-notify-popover \{[\s\S]*max-height: calc\(100dvh - 24px\);/)
+  assert.match(notifier, /const topAbove = rect\.top - menuHeight - menuGap;/)
+  assert.match(notifier, /top \+ menuHeight > window\.innerHeight - viewportPadding/)
+})

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

@@ -1247,6 +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)
     const hashedPaths = []
     const originalHashFile = vault.hashFile.bind(vault)
     vault.hashFile = async (filePath, options) => {

package/test/vault-engine.test.js

@@ -29,13 +29,18 @@ const makeOutside = async () => {
   return directory
 }
 
-const makeVault = async () => {
+const makeVault = async ({ candidateSize = CANDIDATE_SIZE_OPTIONS[0] } = {}) => {
   const home = await makeHome()
   const kernel = { homedir: home, platform: process.platform }
   const vault = new Vault(kernel)
   kernel.vault = vault
   await vault.init()
   vault.sizeThreshold = CANDIDATE_SIZE_OPTIONS[0]
+  if (candidateSize !== null) {
+    await vault.perform("set_candidate_size", {
+      candidate_size: candidateSize
+    })
+  }
   return { home, kernel, vault }
 }
 
@@ -175,15 +180,142 @@ describe("Save Space engine", () => {
     await close(vault)
   })
 
-  test("the published global scan minimum is reused by automatic checks", async () => {
-    const { vault } = await makeVault()
+  test("global and app minimum sizes persist and drive their own scans", async () => {
+    const { home, vault } = await makeVault()
+    const app = "minimum-size-app"
+    const appRoot = path.join(home, "api", app)
+    const appScope = `app:${app}`
+    const globalMinimum = CANDIDATE_SIZE_OPTIONS[2]
+    const appMinimum = CANDIDATE_SIZE_OPTIONS[1]
+    await fs.promises.mkdir(appRoot)
+    await vault.openWorkspace()
+
+    assert.equal((await vault.perform("set_candidate_size", {
+      candidate_size: globalMinimum
+    })).candidate_min_bytes, globalMinimum)
+    assert.equal((await vault.perform("set_candidate_size", {
+      scope_id: appScope,
+      candidate_size: appMinimum
+    })).candidate_min_bytes, appMinimum)
+    assert.equal((await vault.status()).candidate_min_bytes, globalMinimum)
+    assert.equal((await vault.status(appScope)).candidate_min_bytes, appMinimum)
+
+    const starts = []
+    vault.globalScanReady = async () => true
+    vault.startScan = (scopeId, threshold) => {
+      starts.push({ scope_id: scopeId, threshold })
+      return { started: true }
+    }
+    assert.deepEqual(await vault.perform("scan", {
+      candidate_size: CANDIDATE_SIZE_OPTIONS[0]
+    }), { started: true })
+    assert.deepEqual(await vault.perform("scan", {
+      scope_id: appScope,
+      candidate_size: CANDIDATE_SIZE_OPTIONS[0]
+    }), { started: true })
+    assert.deepEqual(starts, [
+      { scope_id: null, threshold: globalMinimum },
+      { scope_id: appScope, threshold: appMinimum }
+    ])
+    let folderThreshold = null
+    vault.startFolderDiscovery = (folderPath, threshold) => {
+      folderThreshold = threshold
+      return { started: true }
+    }
+    assert.deepEqual(await vault.perform("find_folders", {
+      path: home,
+      candidate_size: CANDIDATE_SIZE_OPTIONS[0]
+    }), { started: true })
+    assert.equal(folderThreshold, globalMinimum)
+    assert.equal((await vault.status()).candidate_min_bytes, globalMinimum)
+    assert.equal((await vault.status(appScope)).candidate_min_bytes, appMinimum)
+    assert.equal((await vault.automaticScans.candidatePolicy(app)).threshold,
+      appMinimum)
+
+    await close(vault)
+    const reopened = new Vault({ homedir: home, platform: process.platform })
+    await reopened.init()
+    assert.equal((await reopened.status()).candidate_min_bytes, globalMinimum)
+    assert.equal((await reopened.status(appScope)).candidate_min_bytes,
+      appMinimum)
+    await close(reopened)
+  })
+
+  test("reading a default minimum size does not persist it", async () => {
+    const { vault } = await makeVault({ candidateSize: null })
+
+    assert.equal(await vault.registry.scanSetting(), null)
+    assert.equal((await vault.status()).candidate_min_bytes, SIZE_THRESHOLD)
+    assert.equal(await vault.registry.scanSetting(), null)
+
+    await close(vault)
+  })
+
+  test("minimum size settings reject coerced values", async () => {
+    const { vault } = await makeVault({ candidateSize: null })
+
+    for (const candidateSize of [
+      null,
+      "",
+      String(CANDIDATE_SIZE_OPTIONS[1])
+    ]) {
+      assert.match((await vault.perform("set_candidate_size", {
+        candidate_size: candidateSize
+      })).error, /valid minimum file size/i)
+    }
+    assert.equal(await vault.registry.scanSetting(), null)
+
+    await close(vault)
+  })
+
+  test("minimum size settings reject malformed scopes", async () => {
+    const { vault } = await makeVault({ candidateSize: null })
+
+    const result = await vault.perform("set_candidate_size", {
+      scope_id: 123,
+      candidate_size: CANDIDATE_SIZE_OPTIONS[1]
+    })
+
+    assert.match(result.error, /valid scan scope/i)
+    assert.equal(await vault.registry.scanSetting(), null)
+
+    await close(vault)
+  })
+
+  test("scan history does not become a minimum size setting", async () => {
+    const home = await makeHome()
+    const vault = new Vault({ homedir: home, platform: process.platform })
+    await vault.init()
+    await vault.perform("set_candidate_size", {
+      candidate_size: CANDIDATE_SIZE_OPTIONS[2]
+    })
+    assert.equal((await vault.perform("scan")).started, true)
+    await waitForEngine(() => !vault.scanPromise &&
+      !vault.scanCompletionPromise)
+    await close(vault)
+
+    const database = new Database(path.join(home, "vault", "registry.sqlite3"))
+    database.exec("DROP TABLE minimum_size_settings")
+    database.close()
+
+    const reopened = new Vault({ homedir: home, platform: process.platform })
+    await reopened.init()
+    assert.equal((await reopened.status()).candidate_min_bytes,
+      SIZE_THRESHOLD)
+    assert.equal(await reopened.registry.scanSetting(), null)
+    await close(reopened)
+  })
+
+  test("the saved global minimum is reused by unscoped policy reads", async () => {
+    const { vault } = await makeVault({ candidateSize: null })
     const selected = CANDIDATE_SIZE_OPTIONS[2]
 
     assert.equal((await vault.status()).global_candidate_min_bytes,
       SIZE_THRESHOLD)
-    assert.deepEqual(await vault.perform("scan", {
+    await vault.perform("set_candidate_size", {
       candidate_size: selected
-    }), { started: true })
+    })
+    assert.deepEqual(await vault.perform("scan"), { started: true })
     await waitForEngine(() => !vault.scanPromise &&
       !vault.scanCompletionPromise)
 
@@ -994,6 +1126,9 @@ describe("Save Space engine", () => {
       crypto.randomBytes(512))
     vault.sizeThreshold = 0
     await vault.sweeper.scan()
+    await vault.perform("set_candidate_size", {
+      candidate_size: selectedThreshold
+    })
 
     const stageDiscoveryFiles = vault.registry.stageFolderDiscoveryFiles
       .bind(vault.registry)
@@ -1039,18 +1174,22 @@ describe("Save Space engine", () => {
     await close(vault)
   })
 
-  test("Find folders requires an explicit supported threshold", async () => {
+  test("Find folders ignores request thresholds and uses the saved setting", async () => {
     const { vault } = await makeVault()
     const outside = await makeOutside()
+    const thresholds = []
+    vault.startFolderDiscovery = (folderPath, threshold) => {
+      thresholds.push(threshold)
+      return { started: true }
+    }
 
-    assert.match((await vault.perform("find_folders", {
-      path: outside
-    })).error, /valid minimum file size/i)
-    assert.match((await vault.perform("find_folders", {
+    assert.deepEqual(await vault.perform("find_folders", {
       path: outside,
       candidate_size: 123
-    })).error, /valid minimum file size/i)
-    assert.equal(vault.folderDiscoveryPromise, null)
+    }), { started: true })
+    assert.deepEqual(thresholds, [CANDIDATE_SIZE_OPTIONS[0]])
+    assert.equal((await vault.status()).candidate_min_bytes,
+      CANDIDATE_SIZE_OPTIONS[0])
     await close(vault)
   })
 

package/test/vault-ui.test.js

@@ -414,7 +414,7 @@ const makePage = async (status, options = {}) => {
     const childManifest = parent
       ? folderDiscoveryChildren[parent]
       : null
-    const response = parent
+    const response = await (parent
       ? typeof childManifest === "function"
         ? childManifest(childPage)
         : childManifest || {
@@ -425,7 +425,7 @@ const makePage = async (status, options = {}) => {
             page_size: 500,
             pages: 1
           }
-      : typeof status === "function" ? status(url) : status
+      : typeof status === "function" ? status(url) : status)
     if (options.deferAutomaticStatus &&
         url === "/info/vault/automatic-scans") {
       await deferredAutomaticStatus
@@ -778,7 +778,7 @@ describe("Save Space interface", () => {
       request.action === "scan"))
     const scan = requests.find((request) => request.action === "scan")
     assert.equal(scan.scope_id, null)
-    assert.equal(scan.candidate_size, 100 * candidateBase ** 2)
+    assert.equal("candidate_size" in scan, false)
     await settle()
     dom.window.close()
   })
@@ -866,12 +866,13 @@ describe("Save Space interface", () => {
     dom.window.close()
   })
 
-  test("the scan minimum follows the latest global scan, not browser storage", async () => {
+  test("a scan relies on the saved scope setting, not browser storage", async () => {
     const candidateBase = process.platform === "win32" ? 1024 : 1000
-    const published = 50 * candidateBase ** 2
+    const saved = 50 * candidateBase ** 2
     const stored = 10 * candidateBase ** 2
     const { dom, requests } = await makePage(fixture([], {
-      global_candidate_min_bytes: published
+      candidate_min_bytes: saved,
+      global_candidate_min_bytes: 100 * candidateBase ** 2
     }), {
       storedCandidateSize: stored
     })
@@ -882,13 +883,39 @@ describe("Save Space interface", () => {
     document.getElementById("btn-scan").click()
     await waitFor(() => requests.some((request) =>
       request.action === "scan"))
-    assert.equal(requests.find((request) =>
-      request.action === "scan").candidate_size, published)
+    assert.equal("candidate_size" in requests.find((request) =>
+      request.action === "scan"), false)
 
     await settle()
     dom.window.close()
   })
 
+  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 selected = 50 * candidateBase ** 2
+    const { dom, requests } = await makePage(fixture([], {
+      candidate_min_bytes: appMinimum,
+      global_candidate_min_bytes: globalMinimum
+    }), { appMode: true })
+    const document = dom.window.document
+    const selector = document.getElementById("vault-candidate-size")
+
+    assert.equal(selector.value, String(appMinimum))
+    selector.value = String(selected)
+    selector.dispatchEvent(new dom.window.Event("change", { bubbles: true }))
+    await waitFor(() => requests.some((request) =>
+      request.action === "set_candidate_size"))
+    const request = requests.find((entry) =>
+      entry.action === "set_candidate_size")
+    assert.equal(request.scope_id, "app:app")
+    assert.equal(request.candidate_size, selected)
+    assert.equal(selector.value, String(selected))
+
+    dom.window.close()
+  })
+
   test("a threshold chosen before initial status remains selected", async () => {
     const candidateBase = process.platform === "win32" ? 1024 : 1000
     const published = 50 * candidateBase ** 2
@@ -914,13 +941,87 @@ describe("Save Space interface", () => {
     document.getElementById("btn-scan").click()
     await waitFor(() => requests.some((request) =>
       request.action === "scan"))
-    assert.equal(requests.find((request) =>
-      request.action === "scan").candidate_size, selected)
+    const savedIndex = requests.findIndex((request) =>
+      request.action === "set_candidate_size")
+    const scanIndex = requests.findIndex((request) =>
+      request.action === "scan")
+    assert.ok(savedIndex >= 0 && savedIndex < scanIndex)
+    assert.equal("candidate_size" in requests[scanIndex], false)
 
     await settle()
     dom.window.close()
   })
 
+  test("a rejected minimum size save blocks a pending scan and restores the saved size", async () => {
+    const candidateBase = process.platform === "win32" ? 1024 : 1000
+    const saved = 50 * candidateBase ** 2
+    const selected = 10 * candidateBase ** 2
+    const { dom, requests } = await makePage(fixture([], {
+      candidate_min_bytes: saved,
+      global_candidate_min_bytes: saved
+    }), {
+      actionResults: {
+        set_candidate_size: { error: "Could not save minimum file size." }
+      }
+    })
+    const document = dom.window.document
+
+    document.querySelector(`[data-candidate-size="${selected}"]`).click()
+    document.getElementById("btn-scan").click()
+
+    await waitFor(() => /50 MB\+/.test(document.getElementById(
+      "vault-scan-size-label").textContent) &&
+      /could not save minimum file size/i.test(
+        document.getElementById("vault-feedback").textContent))
+    assert.equal(requests.some((request) => request.action === "scan"), false)
+
+    dom.window.close()
+  })
+
+  test("a stale minimum size failure does not replace a newer successful selection", async () => {
+    const candidateBase = process.platform === "win32" ? 1024 : 1000
+    const first = 10 * candidateBase ** 2
+    const second = 50 * candidateBase ** 2
+    const currentStatus = fixture([], {
+      candidate_min_bytes: 100 * candidateBase ** 2,
+      global_candidate_min_bytes: 100 * candidateBase ** 2
+    })
+    let statusCount = 0
+    let releaseRecovery
+    const recovery = new Promise((resolve) => { releaseRecovery = resolve })
+    let saveCount = 0
+    const actionResults = {}
+    Object.defineProperty(actionResults, "set_candidate_size", {
+      get() {
+        saveCount += 1
+        return saveCount === 1
+          ? { error: "Could not save minimum file size." }
+          : {}
+      }
+    })
+    const { dom, requests } = await makePage(async () => {
+      statusCount += 1
+      if (statusCount === 2) await recovery
+      return currentStatus
+    }, { actionResults })
+    const document = dom.window.document
+
+    document.querySelector(`[data-candidate-size="${first}"]`).click()
+    await waitFor(() => statusCount === 2)
+    document.querySelector(`[data-candidate-size="${second}"]`).click()
+    releaseRecovery()
+
+    await waitFor(() => requests.filter((request) =>
+      request.action === "set_candidate_size").length === 2)
+    await settle()
+    assert.match(document.getElementById("vault-scan-size-label").textContent,
+      /50 MB\+/)
+    assert.doesNotMatch(document.getElementById("vault-feedback").textContent,
+      /could not save minimum file size/i)
+
+    dom.window.close()
+  })
+
   test("a runtime write denial is reported as cannot deduplicate", async () => {
     const duplicate = item({
       status: "duplicate",
@@ -1090,15 +1191,49 @@ describe("Save Space interface", () => {
       request.action === "find_folders"))
     assert.equal(requests.find((entry) =>
       entry.action === "find_folders").path, "/Users/test")
-    assert.equal(requests.find((entry) =>
-      entry.action === "find_folders").candidate_size,
-      selectedThreshold)
+    const savedIndex = requests.findIndex((request) =>
+      request.action === "set_candidate_size")
+    const findIndex = requests.findIndex((request) =>
+      request.action === "find_folders")
+    assert.ok(savedIndex >= 0 && savedIndex < findIndex)
+    assert.equal("candidate_size" in requests[findIndex], false)
     assert.equal(pickerRequests.length, 0)
     await waitFor(() => document.getElementById(
       "vault-find-overlay").hidden)
     dom.window.close()
   })
 
+  test("a rejected minimum size save blocks pending folder discovery", async () => {
+    const candidateBase = process.platform === "win32" ? 1024 : 1000
+    const saved = 100 * candidateBase ** 2
+    const selected = 50 * candidateBase ** 2
+    const { dom, requests } = await makePage(fixture([item()], {
+      candidate_min_bytes: saved,
+      global_candidate_min_bytes: saved
+    }), {
+      actionResults: {
+        set_candidate_size: { error: "Could not save minimum file size." }
+      }
+    })
+    const document = dom.window.document
+
+    document.getElementById("btn-find-folders").click()
+    await waitFor(() => document.querySelector("[data-find-home-folder]"))
+    const selector = document.getElementById("vault-find-candidate-size")
+    selector.value = String(selected)
+    selector.dispatchEvent(new dom.window.Event("change", { bubbles: true }))
+    document.querySelector("[data-find-home-folder]").click()
+
+    await waitFor(() => document.getElementById(
+      "vault-find-candidate-size").value === String(saved) &&
+      /could not save minimum file size/i.test(
+        document.getElementById("vault-feedback").textContent))
+    assert.equal(requests.some((request) =>
+      request.action === "find_folders"), false)
+
+    dom.window.close()
+  })
+
   test("Find folders explains when a lower threshold needs a global scan", async () => {
     const message = "Run a global scan with this minimum file size before searching folders."
     const { dom, requests } = await makePage(fixture([item()]), {
@@ -1121,9 +1256,8 @@ describe("Save Space interface", () => {
     assert.equal(document.querySelector(
       ".vault-find-partial[role='alert']").textContent.trim(), message)
     assert.ok(document.querySelector("[data-find-home-folder]"))
-    assert.equal(requests.find((request) =>
-      request.action === "find_folders").candidate_size,
-      50 * candidateBase ** 2)
+    assert.equal("candidate_size" in requests.find((request) =>
+      request.action === "find_folders"), false)
     dom.window.close()
   })