pinokiod 8.0.41 → 8.0.44

package/kernel/vault/sweeper.js

@@ -50,7 +50,6 @@ class Sweeper {
     this.hashJobsByIno = new Map()
     this.completedHashesByIno = new Map()
     this.inaccessiblePaths = new Set()
-    this.inaccessibleCodes = new Map()
   }
   idleState() {
     return {
@@ -77,27 +76,12 @@ class Sweeper {
     this.hashJobsByIno.clear()
     this.completedHashesByIno.clear()
     this.inaccessiblePaths.clear()
-    this.inaccessibleCodes.clear()
-    this.fatalError = null
-    const registryWasDirty = !!(
-      this.vault.registry.persistDirty || this.vault.registry.persistTimer
-    )
-    const registrySnapshot = this.vault.registry.snapshotState()
     this.vault.registry.beginBatch()
-    this.vault.beginScanDraft()
     let completed = false
     let incomplete = false
-    let rollbackMetadataChanged = false
     try {
       await this.vault.refreshSources()
       if (!scopeId) this.vault.reconcileConfiguredSources()
-      if (!scopeId) {
-        for (const source of this.vault.sources()) {
-          if (source.kind === "external" && source.available === false && source.root) {
-            this.recordUnavailable(source.root, source.error_code)
-          }
-        }
-      }
       const scanRoots = this.vault.scanRoots(scopeId)
       if (!scanRoots.length) throw new Error("That scan location is no longer available.")
       const previous = this.vault.registry.scanFor(scopeId)
@@ -136,9 +120,6 @@ class Sweeper {
       await this.settle()
       this.state.hash_wait_duration_ms = Date.now() - hashWaitStarted
       const scanMeta = {
-        ts: Date.now(),
-        complete: true,
-        candidate_min_bytes: this.vault.sizeThreshold,
         dirs: this.state.dirs,
         files: this.state.files,
         bytes_total: this.state.bytes_total,
@@ -156,8 +137,7 @@ class Sweeper {
         count_duration_ms: this.state.count_duration_ms,
         walk_duration_ms: this.state.walk_duration_ms,
         hash_wait_duration_ms: this.state.hash_wait_duration_ms,
-        hash_duration_ms: this.state.hash_duration_ms,
-        unreadable: []
+        hash_duration_ms: this.state.hash_duration_ms
       }
       // Refresh dead-name and orphan state from filesystem identity after
       // every completed discovery pass, as required by the Vault contract.
@@ -173,60 +153,35 @@ class Sweeper {
       })
       this.state.duration_ms = Date.now() - this.state.started
       incomplete = this.state.inaccessible > 0
-      scanMeta.ts = Date.now()
-      scanMeta.complete = !incomplete
-      scanMeta.duration_ms = this.state.duration_ms
-      scanMeta.unreadable = [...this.inaccessiblePaths].map((filePath) => ({
-        path: filePath,
-        code: this.inaccessibleCodes.get(filePath) || "EACCES"
-      }))
-      this.refreshExcludedVerification(scanRoots)
-      if (incomplete) this.markUnavailableRows()
-      this.vault.registry.setScanAttempt(scanMeta, scopeId)
       if (!incomplete) {
+        scanMeta.ts = Date.now()
+        scanMeta.duration_ms = this.state.duration_ms
         this.vault.registry.setLastScan(scanMeta, scopeId)
-      }
-      if (!scopeId) {
-        for (const source of this.vault.sources()) {
-          if (source.kind !== "app" || !source.available) continue
-          const sourceId = source.id
-          const sourceIncomplete = [...this.inaccessiblePaths].some((unreadable) =>
-            isPathWithin(source.root, unreadable) || isPathWithin(unreadable, source.root))
-          const bytes = scanMeta.source_bytes[sourceId] || 0
-          const scopedMeta = {
-            ts: scanMeta.ts,
-            complete: !sourceIncomplete,
-            duration_ms: scanMeta.duration_ms,
-            count_duration_ms: scanMeta.count_duration_ms,
-            walk_duration_ms: scanMeta.walk_duration_ms,
-            hash_wait_duration_ms: scanMeta.hash_wait_duration_ms,
-            candidate_min_bytes: scanMeta.candidate_min_bytes,
-            files: scanMeta.source_files[sourceId] || 0,
-            bytes_total: bytes,
-            home_bytes_total: 0,
-            hash_failures: scanMeta.source_hash_failures[sourceId] || 0,
-            source_bytes: { [sourceId]: bytes },
-            source_files: { [sourceId]: scanMeta.source_files[sourceId] || 0 },
-            source_hash_failures: {
-              [sourceId]: scanMeta.source_hash_failures[sourceId] || 0
-            },
-            unreadable: sourceIncomplete
-              ? scanMeta.unreadable.filter((entry) =>
-                  isPathWithin(source.root, entry.path) || isPathWithin(entry.path, source.root))
-              : []
+        if (!scopeId) {
+          for (const source of this.vault.sources()) {
+            if (source.kind !== "app" || !source.available) continue
+            const sourceId = source.id
+            const bytes = scanMeta.source_bytes[sourceId] || 0
+            this.vault.registry.setLastScan({
+              ts: scanMeta.ts,
+              duration_ms: scanMeta.duration_ms,
+              count_duration_ms: scanMeta.count_duration_ms,
+              walk_duration_ms: scanMeta.walk_duration_ms,
+              hash_wait_duration_ms: scanMeta.hash_wait_duration_ms,
+              files: scanMeta.source_files[sourceId] || 0,
+              bytes_total: bytes,
+              home_bytes_total: 0,
+              hash_failures: scanMeta.source_hash_failures[sourceId] || 0,
+              source_bytes: { [sourceId]: bytes },
+              source_files: { [sourceId]: scanMeta.source_files[sourceId] || 0 },
+              source_hash_failures: {
+                [sourceId]: scanMeta.source_hash_failures[sourceId] || 0
+              }
+            }, sourceId)
           }
-          this.vault.registry.setScanAttempt(scopedMeta, sourceId)
-          if (!sourceIncomplete) this.vault.registry.setLastScan(scopedMeta, sourceId)
         }
       }
-      await this.vault.commitScanDraft()
       completed = true
-    } catch (error) {
-      // Drain every queued hash before restoring the snapshot; otherwise a
-      // late worker could mutate the restored registry after rollback.
-      await this.settle().catch(() => {})
-      rollbackMetadataChanged = await this.vault.abortScanDraft(registrySnapshot)
-      throw error
     } finally {
       // A failed walk must not leave background hash work or per-scan inode
       // state alive when the next manual scan starts.
@@ -236,15 +191,7 @@ class Sweeper {
       this.completedHashesByIno.clear()
       this.state.active = false
       this.state.phase = completed ? (incomplete ? "incomplete" : "complete") : "failed"
-      try {
-        await this.vault.registry.endBatch(completed ? { flush: true } : { discard: true })
-      } catch (error) {
-        if (!completed) throw error
-        this.vault.scanPersistenceWarning = true
-      }
-      if (!completed && (registryWasDirty || rollbackMetadataChanged)) {
-        this.vault.registry.schedulePersist()
-      }
+      await this.vault.registry.endBatch({ flush: true })
     }
     return {
       dirs: this.state.dirs, files: this.state.files,
@@ -255,19 +202,12 @@ class Sweeper {
   }
   recordInaccessible(error, filePath) {
     if (!isAccessError(error)) return false
-    return this.recordUnavailable(filePath, error.code)
-  }
-  recordUnavailable(filePath, code = null) {
     const target = path.resolve(filePath)
     if ([...this.inaccessiblePaths].some((existing) => isPathWithin(existing, target))) return true
     for (const existing of [...this.inaccessiblePaths]) {
-      if (isPathWithin(target, existing)) {
-        this.inaccessiblePaths.delete(existing)
-        this.inaccessibleCodes.delete(existing)
-      }
+      if (isPathWithin(target, existing)) this.inaccessiblePaths.delete(existing)
     }
     this.inaccessiblePaths.add(target)
-    this.inaccessibleCodes.set(target, code || "EACCES")
     this.state.inaccessible = this.inaccessiblePaths.size
     this.state.inaccessible_paths = [...this.inaccessiblePaths].slice(0, 20)
     return true
@@ -275,33 +215,12 @@ class Sweeper {
   isInaccessible(filePath) {
     return [...this.inaccessiblePaths].some((target) => isPathWithin(target, filePath))
   }
-  markUnavailableRows() {
-    const mark = (entries) => {
-      for (const [filePath, entry] of entries) {
-        if (!this.isInaccessible(filePath)) continue
-        entry.unverified = true
-      }
-    }
-    mark(this.vault.registry.links)
-    mark(this.vault.registry.duplicates)
-    mark(this.vault.registry.excluded)
-    this.vault.registry.schedulePersist()
-  }
-  refreshExcludedVerification(scanRoots) {
-    for (const [filePath, entry] of this.vault.registry.excluded) {
-      if (!scanRoots.some((source) => isPathWithin(source.root, filePath))) continue
-      entry.unverified = this.isInaccessible(filePath)
-    }
-    this.vault.registry.schedulePersist()
-  }
   async countFiles(root) {
     const vaultRoot = this.vault.root
     for await (const directoryResults of walkBatches(root, {
       concurrency: this.dirConcurrency,
       skipDirectory: (full) => full === vaultRoot,
       strictErrors: true,
-      onRootMissing: (error, filePath) =>
-        this.recordUnavailable(filePath, error && error.code),
       onError: (error, filePath) => this.recordInaccessible(error, filePath)
     })) {
       this.state.counted_dirs += directoryResults.filter((group) => group.firstChunk).length
@@ -311,11 +230,6 @@ class Sweeper {
   }
   async settle() {
     await this.hashQueue.drained()
-    if (this.fatalError) {
-      const error = this.fatalError
-      this.fatalError = null
-      throw error
-    }
   }
   async walk(root, preferredSourceId = null) {
     const vaultRoot = this.vault.root
@@ -323,8 +237,6 @@ class Sweeper {
       concurrency: this.dirConcurrency,
       skipDirectory: (full) => full === vaultRoot,
       strictErrors: true,
-      onRootMissing: (error, filePath) =>
-        this.recordUnavailable(filePath, error && error.code),
       onError: (error, filePath) => this.recordInaccessible(error, filePath)
     })) {
       this.state.dirs += directoryResults.filter((group) => group.firstChunk).length
@@ -374,42 +286,33 @@ class Sweeper {
       this.state.total_files = this.state.files
     }
   }
-  async considerStat(filePath, st, preferredSourceId = null, options = {}) {
+  async considerStat(filePath, st, preferredSourceId = null) {
     if (filePath.endsWith(TMP_SUFFIX)) return
     const registry = this.vault.registry
     const source = this.vault.sourceForPath(filePath, preferredSourceId)
     const sourceId = source ? source.id : null
     const appName = source && source.kind === "app" ? source.app : null
     const sourceKey = sourceId || preferredSourceId || "pinokio"
-    if (options.count !== false) {
-      this.countFile(sourceKey)
-      this.state.bytes_total += st.size
-      this.state.source_bytes[sourceKey] = (this.state.source_bytes[sourceKey] || 0) + st.size
-      if (!preferredSourceId) this.state.home_bytes_total += st.size
-    }
+    this.countFile(sourceKey)
+    this.state.bytes_total += st.size
+    this.state.source_bytes[sourceKey] = (this.state.source_bytes[sourceKey] || 0) + st.size
+    if (!preferredSourceId) this.state.home_bytes_total += st.size
     if (registry.excluded.has(filePath)) {
       registry.untrack(filePath)
       return
     }
     if (st.size < this.vault.sizeThreshold) {
-      if (this.preserveTrackedBelowThreshold(filePath, st, appName, sourceId)) return
-      if (!registry.links.has(filePath)) {
-        registry.untrack(filePath)
-        return
-      }
-    } else {
-      this.state.candidates += 1
+      await this.untrackBelowThreshold(filePath, st, { app: appName, source_id: sourceId })
+      return
     }
+    this.state.candidates += 1
     // Known and unchanged: nothing to do.
     const inoHash = registry.byIno.get(registry.inoKey(st.dev, st.ino))
     if (inoHash && st.nlink > 1) {
       const cached = registry.scanIndex.get(filePath)
       const unchanged = cached && cached.hash === inoHash && sameSnapshot(cached, st)
       if (unchanged) {
-        registry.addLink(filePath, {
-          hash: inoHash, app: appName, source_id: sourceId,
-          dev: st.dev, ino: st.ino, unverified: false
-        })
+        registry.addLink(filePath, { hash: inoHash, app: appName, source_id: sourceId, dev: st.dev, ino: st.ino, mode: "link" })
         return
       }
     }
@@ -458,28 +361,52 @@ class Sweeper {
   invalidateLinkedInode(hash, dev, ino) {
     const registry = this.vault.registry
     for (const [filePath, entry] of [...registry.links]) {
-      if (entry.hash === hash && entry.dev === dev && entry.ino === ino) {
+      if (entry.hash === hash && entry.mode === "link" && entry.dev === dev && entry.ino === ino) {
         registry.untrack(filePath)
       }
     }
-    registry.removeBlob(hash)
+    const hasCopies = [...registry.links.values()].some((entry) =>
+      entry.hash === hash && entry.mode === "copy")
+    if (hasCopies) {
+      const blob = registry.blobs.get(hash)
+      if (blob) {
+        blob.orphan = false
+        blob.verified_at = null
+        registry.schedulePersist()
+      }
+    } else {
+      registry.removeBlob(hash)
+    }
   }
-  preserveTrackedBelowThreshold(filePath, st, appName, sourceId) {
+  async untrackBelowThreshold(filePath, st, meta = {}) {
     const registry = this.vault.registry
     const linked = registry.links.get(filePath)
-    const cached = registry.scanIndex.get(filePath)
-    if (!linked || !cached || cached.hash !== linked.hash ||
-        linked.dev !== st.dev || linked.ino !== st.ino ||
-        !sameSnapshot(cached, st)) return false
-    registry.addLink(filePath, {
-      hash: linked.hash,
-      app: appName,
-      source_id: sourceId,
-      dev: st.dev,
-      ino: st.ino,
-      unverified: false
-    })
-    return true
+    if (linked && linked.mode === "link") {
+      let storeStat = null
+      try {
+        storeStat = await this.vault.storeStatIfPresent(this.vault.storePathFor(linked.hash))
+      } catch (error) {
+        if (!isMissingError(error)) throw error
+      }
+      if (storeStat && storeStat.dev === st.dev && storeStat.ino === st.ino) {
+        const cached = registry.scanIndex.get(filePath)
+        try {
+          await fs.promises.unlink(this.vault.storePathFor(linked.hash))
+        } catch (error) {
+          if (!error || error.code !== "ENOENT") return
+        }
+        this.invalidateLinkedInode(linked.hash, st.dev, st.ino)
+        if (cached && !sameSnapshot(cached, st)) {
+          await this.vault.recordEvent({
+            kind: "diverged", hash: linked.hash, path: filePath,
+            app: meta.app || linked.app || null,
+            source_id: meta.source_id || linked.source_id || null,
+            size: st.size
+          })
+        }
+      }
+    }
+    registry.untrack(filePath)
   }
   async _hashJob(job) {
     const primary = job.names[0]
@@ -503,8 +430,7 @@ class Sweeper {
         try {
           st = name === primary ? primaryStat : await fs.promises.lstat(name.filePath)
         } catch (e) {
-          if (isMissingError(e) || this.recordInaccessible(e, name.filePath)) continue
-          throw e
+          continue
         }
         // Same (device, inode) is physical identity, not a content guess.
         // Size and mtime also prevent applying a completed digest after an
@@ -528,7 +454,6 @@ class Sweeper {
         const sourceId = primary.source_id || "pinokio"
         this.state.source_hash_failures[sourceId] =
           (this.state.source_hash_failures[sourceId] || 0) + 1
-        if (!this.fatalError) this.fatalError = e
       }
     } finally {
       this.state.hash_duration_ms += Date.now() - started
@@ -565,29 +490,34 @@ class Sweeper {
     const sourceId = source ? source.id : null
     const appName = source && source.kind === "app" ? source.app : null
     // Divergence: this inode was registered under a different hash — the
-    // shared content was written in place. Retire the stale store name only
-    // when the scan commits so a later fatal error leaves the filesystem and
-    // registry at their pre-scan state.
+    // shared content was written in place. Evict the stale blob.
     const priorHash = registry.byIno.get(registry.inoKey(st.dev, st.ino))
     if (priorHash && priorHash !== hash) {
       const stalePath = this.vault.storePathFor(priorHash)
-      let retiredStaleStore = false
+      let removedStaleStore = false
       try {
         const staleStat = await this.vault.storeStatIfPresent(stalePath)
         if (staleStat && staleStat.isFile() && staleStat.dev === st.dev && staleStat.ino === st.ino) {
-          const inodeKey = registry.inoKey(st.dev, st.ino)
-          this.vault.rememberRetiredScanStore(stalePath, staleStat, [
-            filePath,
-            ...(registry.pathsByIno.get(inodeKey) || [])
-          ])
-          retiredStaleStore = true
+          await fs.promises.unlink(stalePath)
+          removedStaleStore = true
         }
       } catch (error) {
         if (!isMissingError(error)) throw error
       }
-      if (retiredStaleStore) this.invalidateLinkedInode(priorHash, st.dev, st.ino)
+      if (removedStaleStore) this.invalidateLinkedInode(priorHash, st.dev, st.ino)
       else registry.untrack(filePath)
       this.vault.recordEvent({ kind: "diverged", hash: priorHash, path: filePath, app: appName, source_id: sourceId, size: st.size })
+      if (removedStaleStore) {
+        // Removing the stale store name changes ctime on this inode. Refresh
+        // the trusted snapshot before adoption, but reject any content change.
+        const current = await fs.promises.lstat(filePath)
+        if (!sameContentState(fileSnapshot(st), current)) {
+          registry.untrack(filePath)
+          this.state.unstable_hashes += 1
+          return
+        }
+        st = current
+      }
     }
     const storePath = this.vault.storePathFor(hash)
     let storeStat = null
@@ -597,6 +527,14 @@ class Sweeper {
       if (!isMissingError(error)) throw error
     }
     const registered = registry.links.get(filePath)
+    if (registered && registered.mode === "copy" &&
+        registered.hash === hash && registered.dev === st.dev && registered.ino === st.ino) {
+      registry.addLink(filePath, {
+        hash, app: appName, source_id: sourceId, dev: st.dev, ino: st.ino, mode: "copy"
+      })
+      this.updateScanIndex(filePath, st, hash, sourceId)
+      return
+    }
     if (!storeStat && ((source && source.shareable) || !registry.blobs.has(hash) || (registered &&
         registered.hash === hash && registered.dev === st.dev && registered.ino === st.ino))) {
       const adopted = await this.vault.adopt(filePath, hash, {
@@ -609,7 +547,7 @@ class Sweeper {
         this.state.unstable_hashes += 1
         return
       }
-      if (adopted.status === "adopted" || adopted.status === "already") {
+      if (adopted.status !== "duplicate") {
         return
       }
       try {
@@ -619,10 +557,7 @@ class Sweeper {
       }
     }
     if (storeStat && storeStat.dev === st.dev && storeStat.ino === st.ino) {
-      registry.addLink(filePath, {
-        hash, app: appName, source_id: sourceId,
-        dev: st.dev, ino: st.ino, unverified: false
-      })
+      registry.addLink(filePath, { hash, app: appName, source_id: sourceId, dev: st.dev, ino: st.ino, mode: "link" })
       this.updateScanIndex(filePath, st, hash, sourceId)
       return
     }
@@ -632,8 +567,7 @@ class Sweeper {
     }
     const previous = registry.setDuplicate(filePath, {
       hash, size: st.size, app: appName, source_id: sourceId, discovered: Date.now(),
-      dev: st.dev, ino: st.ino, mtime: st.mtimeMs, ctime: st.ctimeMs,
-      unverified: false
+      dev: st.dev, ino: st.ino, mtime: st.mtimeMs, ctime: st.ctimeMs
     }, scanEntry)
     if (!previous || previous.hash !== hash) {
       this.vault.recordEvent({ kind: "found", hash, path: filePath, app: appName, source_id: sourceId, size: st.size })
@@ -667,21 +601,12 @@ class Sweeper {
       this.state.source_bytes[sourceKey] = (this.state.source_bytes[sourceKey] || 0) + st.size
       if (!preferredSourceId) this.state.home_bytes_total += st.size
       if (!SHA256_RE.test(name)) continue
-      if (this.vault.registry.excluded.has(full)) {
-        this.vault.registry.untrack(full)
-        continue
-      }
       if (st.size < this.vault.sizeThreshold) {
-        if (this.preserveTrackedBelowThreshold(full, st, appName, sourceId)) continue
-        if (this.vault.registry.links.has(full)) {
-          await this.considerStat(full, st, preferredSourceId, { count: false })
-        } else {
-          this.vault.registry.untrack(full)
-        }
+        await this.untrackBelowThreshold(full, st, { app: appName, source_id: sourceId })
         continue
-      } else {
-        this.state.candidates += 1
       }
+      if (this.vault.registry.excluded.has(full)) continue
+      this.state.candidates += 1
       await this.classify(full, st, name, preferredSourceId)
     }
   }

package/kernel/vault/walker.js

@@ -10,13 +10,12 @@ const isHandledError = (options, error, target) => !!(
 // One traversal primitive for Scan and Repair. It owns only directory
 // discovery and symlink policy; callers decide how files are classified.
 async function * walkBatches(root, options = {}) {
-  const resolvedRoot = path.resolve(root)
   const concurrency = Math.max(1, Number(options.concurrency) || 1)
   const entryBatchSize = Math.max(1, Number(options.entryBatchSize) || ENTRY_BATCH_SIZE)
   const statConcurrency = Math.max(1, Number(options.statConcurrency) || 32)
   const skipDirectory = options.skipDirectory || (() => false)
   const strictErrors = !!options.strictErrors
-  const pending = [{ dir: resolvedRoot, followRootSymlink: true }]
+  const pending = [{ dir: path.resolve(root), followRootSymlink: true }]
   const active = []
   try {
     while (pending.length || active.length) {
@@ -34,9 +33,6 @@ async function * walkBatches(root, options = {}) {
           }
           active.push({ dir, handle: await fs.promises.opendir(dir), firstChunk: true })
         } catch (error) {
-          if (isMissingError(error) && dir === resolvedRoot && options.onRootMissing) {
-            options.onRootMissing(error, dir)
-          }
           if (strictErrors && !isMissingError(error) && !isHandledError(options, error, dir)) throw error
           yield [{ dir, entries: null, files: [], discoveredDirs: 0, discoveredFiles: 0, firstChunk: true }]
         }
@@ -55,9 +51,6 @@ async function * walkBatches(root, options = {}) {
             entries.push(entry)
           }
         } catch (error) {
-          if (isMissingError(error) && task.dir === resolvedRoot && options.onRootMissing) {
-            options.onRootMissing(error, task.dir)
-          }
           if (strictErrors && !isMissingError(error) && !isHandledError(options, error, task.dir)) throw error
           done = true
         }

package/package.json

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

package/server/index.js

@@ -15741,25 +15741,6 @@ class Server {
 
     // Vault dashboard data: registry-backed with bounded per-blob stats,
     // never a discovery walk. Scans run ONLY via the explicit action below.
-    this.app.get("/info/dedup/nav", ex(async (req, res) => {
-      if (!privacyFilterCache.isSameOriginRequest(req)) {
-        res.sendStatus(403)
-        return
-      }
-      const vault = this.kernel.vault
-      if (vault && vault.ready) await vault.ready
-      if (!vault || !vault.enabled) {
-        res.sendStatus(404)
-        return
-      }
-      res.set("Cache-Control", "no-store")
-      const appName = req.query && typeof req.query.app === "string"
-        ? req.query.app
-        : null
-      res.json(appName
-        ? vault.navigationStatusForApp(appName)
-        : vault.navigationStatus())
-    }))
     this.app.get("/info/dedup", ex(async (req, res) => {
       if (!privacyFilterCache.isSameOriginRequest(req)) {
         res.sendStatus(403)
@@ -15771,6 +15752,7 @@ class Server {
         res.sendStatus(404)
         return
       }
+      await vault.ensureInitialized()
       res.set("Cache-Control", "no-store")
       const scopeId = req.query && typeof req.query.scope_id === "string"
         ? req.query.scope_id
@@ -15796,7 +15778,7 @@ class Server {
         return
       }
       await vault.ensureInitialized()
-      res.render("vault", { theme: this.theme, agent: req.agent })
+      res.render("vault", { theme: this.theme, platform: this.kernel.platform, agent: req.agent })
     }))
     this.app.get("/vault/app/:name", ex(async (req, res) => {
       if (!privacyFilterCache.isSameOriginRequest(req)) {
@@ -15819,6 +15801,7 @@ class Server {
       }
       res.render("vault_app", {
         theme: this.theme,
+        platform: this.kernel.platform,
         agent: req.agent,
         scope_id: source.id
       })

package/server/public/storage-size.js

@@ -1,10 +1,12 @@
 (function (root) {
-  const base = 1000
   const units = ["B", "KB", "MB", "GB", "TB"]
 
   root.PinokioFormatStorageSize = (value) => {
     const bytes = Number(value)
     if (!Number.isFinite(bytes) || bytes <= 0) return "0 B"
+    const platform = root.document && root.document.body &&
+      root.document.body.dataset.platform
+    const base = platform === "win32" ? 1024 : 1000
     const index = Math.min(units.length - 1, Math.floor(Math.log(bytes) / Math.log(base)))
     const scaled = bytes / Math.pow(base, index)
     return `${Number(scaled.toFixed(index ? 2 : 0))} ${units[index]}`

package/server/public/style.css

@@ -1567,14 +1567,6 @@ body.main-sidebar-page aside.main-sidebar .tab.selected .main-sidebar-action-ico
   background: rgba(45, 180, 92, 0.14);
   color: #247a43;
 }
-.main-sidebar [data-main-sidebar-vault-tab][data-vault-state="new"]:not(.selected) {
-  background: var(--pinokio-sidebar-tab-hover);
-}
-.main-sidebar .main-sidebar-status-badge[data-state="new"] {
-  border: 1px solid rgba(71, 85, 105, 0.22);
-  background: transparent;
-  color: rgba(31, 41, 55, 0.72);
-}
 body.dark .main-sidebar .main-sidebar-status-badge {
   background: rgba(255, 255, 255, 0.08);
   color: rgba(229, 231, 235, 0.68);
@@ -1583,11 +1575,6 @@ body.dark .main-sidebar .main-sidebar-status-badge[data-state="on"] {
   background: rgba(74, 222, 128, 0.14);
   color: #86efac;
 }
-body.dark .main-sidebar .main-sidebar-status-badge[data-state="new"] {
-  border-color: rgba(226, 232, 240, 0.22);
-  background: transparent;
-  color: rgba(248, 250, 252, 0.76);
-}
 .main-sidebar .tab.submenu {
   padding-left: 14px !important;
 }