README: say which records quak could not decrypt lib.backup() reports

It reports each such album, and each such file in its scope that has no
copy that decrypted, not every record the library left out.

Model: opus-5-5

README.md

@@ -135,13 +135,13 @@ matters.
 | `3`  | There is no usable session: none is saved, the saved one is corrupt, or the server no longer accepts it. Run `quak login` as the user the cron job runs as.                       |
 
 After a `1`, the next run fetches each missing original again, fetches the ML
-data that is not cached, and rebuilds the album links. An album quak could not
-decrypt, or a file in `failures.json` because quak could not decrypt it, keeps
-the exit code at `1` until the server sends a copy that decrypts, or deletes it
-(see "Backup layout"). An original that a `--verify` run could not read, or put
-back with bytes that still do not match, stays at its save path. Only a later
-`--verify` run checks it again: a run without `--verify` leaves it as it is and
-takes the file out of `failures.json`, so that run can exit 0.
+data that is not cached, and rebuilds the album links. A file or album quak
+could not decrypt keeps the exit code at `1` until the server sends a copy that
+decrypts, or deletes it (see "Backup layout"). An original that a `--verify` run
+could not read, or put back with bytes that still do not match, stays at its
+save path. Only a later `--verify` run checks it again: a run without `--verify`
+leaves it as it is and takes the file out of `failures.json`, so that run can
+exit 0.
 
 ## Examples
 
@@ -626,9 +626,9 @@ answer, so they report current account state rather than whatever the cache last
 held. If that round-trip fails, the command prints the error on one line and
 exits 1, or 3 when the server no longer accepts the saved session (see "Session
 handling"). An album or file quak cannot decrypt does not fail it; the command
-answers from what did decrypt (see "Default reads vs. fresh reads").
-`--cache-dir` overrides where the cache lives; without it each account gets its
-own directory under the per-user cache path.
+answers without it (see "Default reads vs. fresh reads"). `--cache-dir`
+overrides where the cache lives; without it each account gets its own directory
+under the per-user cache path.
 
 An ID given to `files --collection`, `get`, `get-thumb` or
 `helper fix-missing-thumbnails --file` is written in decimal digits, no larger
@@ -745,25 +745,23 @@ succeeds, or once it is no longer in the library or in the backup's scope. The
 library's `lib.backup({ includeThumbnails: true })` also writes
 `thumbnails/<fileID>.jpg` beside `collections/`; `quak backup` does not.
 
-A file in the backup's scope that the library could not decrypt (see "Default
-reads vs. fresh reads") goes into `failures.json` with an error that starts
-`could not be decrypted:` and gives the reason. If a copy of it in another album
-decrypted, it does not: its original is stored from that copy, and the album
-where it does not decrypt neither links nor lists it. An album the library could
-not decrypt has no name quak can read and no files it can list. A run without
-`--json` prints one line for it,
+A file the library could not decrypt (see "Default reads vs. fresh reads") goes
+into `failures.json` with an empty title, since its title is encrypted too, and
+an error that starts `could not be decrypted:` and gives the reason. A file in
+two albums is backed up as usual if its copy in the other album decrypted. An
+album the library could not decrypt has no name quak can read and no files it
+can list. A run without `--json` prints one line for it,
 `FAILED album <id>: could not be decrypted: <reason>`, and `--json` and the
-`BackupResult` list its ID in `undecryptableAlbums`. Such a file in
-`failures.json`, or such an album, keeps the exit code at 1, run after run,
-until the server sends a copy that decrypts or deletes it; the next run then
-drops it.
+`BackupResult` list its ID in `undecryptableAlbums`. Every other file is backed
+up. Either kind keeps the exit code at 1, run after run, until the server sends
+a copy that decrypts or deletes it; the next run then drops it.
 
 `backup.lock` keeps two backups of the same directory from running at once, such
 as a cron run that starts while the previous one is still going. A backup
 creates `<dir>` if it is missing and takes the lock before its refresh, and
-removes the lock when it ends, whether it succeeds or fails, unless it lost the
-lock (see below); `quak backup` takes it before it opens its library, so a
-refused run sends no request. The lock is a directory that
+removes the lock when it ends, whether it succeeds or fails; `quak backup` takes
+it before it opens its library, so a refused run sends no request. The lock is a
+directory that
 [proper-lockfile](https://github.com/moxystudio/node-proper-lockfile) creates
 and keeps touching while the backup runs. A second backup of the directory, from
 another process or the same one, fails at once: `quak backup` prints
@@ -775,16 +773,6 @@ over, so nobody has to remove it. The lock is outside the date folders and
 `collections/`, so it is never taken for an original, and the removal of old
 album directories never touches it.
 
-A running backup loses its lock when someone removes `backup.lock`, or when
-another backup takes it over because the running one left it untouched for 10
-seconds, as a stopped or stalled process does. The backup finds this out the
-next time it goes to touch the lock, which it does every 5 seconds, and then
-stops before it starts another file. The originals it is downloading at that
-moment are still stored. It leaves `failures.json` and `backup.lock` as they
-are, since another backup may be using them. `quak backup` prints
-`quak: lost the lock on <dir>: <reason>` as one line and exits 1, and
-`lib.backup()` rejects with `lost the lock on <dir>: <reason>`.
-
 A collection's directory and JSON are named after the collection, and a symlink
 after the file's title, both with unsafe characters replaced. When two
 collections would get the same name, or two symlinks in one collection the same
@@ -804,12 +792,9 @@ both, each named after the title with that file's extension (`IMG_0001.heic` and
 
 Each run removes the symlinks into the date folders that no longer belong in
 their collection's directory, and the directories (and JSON) of collections that
-were deleted or renamed. An album quak can no longer decrypt loses its directory
-and JSON the same way, and a file whose copy in an album quak can no longer
-decrypt loses its symlink there and its entry in that album's JSON; the
-originals stay at their save paths. Nothing else in `collections/` is touched: a
-file or a symlink you put there stays, and a directory that still holds one
-after its symlinks are removed stays too, with its JSON.
+were deleted or renamed. Nothing else in `collections/` is touched: a file or a
+symlink you put there stays, and a directory that still holds one after its
+symlinks are removed stays too, with its JSON.
 
 Each file is downloaded exactly once regardless of how many collections it
 appears in, and written once: straight to its save path, with no copy left in
@@ -818,8 +803,7 @@ subsequent runs, existing originals are skipped. If a download fails, the error
 is logged and the backup continues with the next file. The exit code is non-zero
 if any files failed. `quak backup` opens its library with the thumbnail and
 originals precache off, so the only file content it fetches is the originals the
-backup stores. It also opens it with no background timer, so it asks the server
-for changes only as it starts, not again while it downloads.
+backup stores.
 
 With `--verify`, or `lib.backup({ verify: true })`, a run also hashes each
 original already at its save path the way a download is checked (see "On-disk
@@ -900,7 +884,7 @@ background, so an unreachable server does not block opening.
 | `client`                 | required                                           | the account client (a `Client`, or any `LibraryClient`)              |
 | `cacheDirectory`         | `quak/<userID>` under the per-user cache directory | where `metadata.json` and the content cache live                     |
 | `downloadDirectory`      | `photos` in the working directory                  | root of the save paths; an original stored there counts as cached    |
-| `refreshIntervalSeconds` | `3`                                                | background refresh cadence; `Infinity` for no background timer       |
+| `refreshIntervalSeconds` | `3`                                                | background refresh cadence                                           |
 | `precacheThumbnails`     | `true`                                             | prefetch every thumbnail, newest first                               |
 | `precacheOriginals`      | `true`                                             | prefetch the favorites album and the latest-window originals         |
 | `precacheOriginalsDays`  | `7`                                                | length in days of that latest window                                 |
@@ -1070,24 +1054,21 @@ photos newest first). `lib.subscribe({ onChange })` delivers a `LibraryChange`
   directory, and fails at once with an error whose `code` is `ELOCKED` while
   another backup of it runs. A caller can instead take the lock itself, before
   it opens its library, as `quak backup` does: `await lockBackupDirectory(dir)`
-  takes it, failing the same way, and returns a `BackupLock`, whose `release()`
-  removes the lock unless it was lost and whose `lost` holds why it was lost.
-  The caller passes it to the backup as `lock`, and releases it once the backup
-  ends. It waits for a refresh as `fresh()` does, puts every in-scope original
-  not already at its save path there as `photo.download()` does (and, with
-  `includeThumbnails`, fetches thumbnails) through the content cache, waits for
-  an ML data fetch, and rebuilds the on-disk backup tree with a durable failure
-  ledger. Each file's JSON holds its ML data and, for an image (for a live
-  photo, its image), its original's EXIF and XMP, with its dimensions for a JPEG
-  only; a video's JSON holds none of these three. A fetched original is written
-  straight to its save path and not into the cache, which then counts it as
-  present; one the cache already held is copied from there. `BackupOptions`:
-  `downloadDirectory` (falls back to the library's), `includeOriginals` (default
-  `true`), `includeThumbnails` (default `false`), `onlyAlbumNames`, `verify`
-  (default `false`), `onProgress`, and `lock`. See Backup layout above for the
-  tree it writes. Whether the backup took the lock or its caller did, once the
-  lock is lost the backup rejects with `lost the lock on <dir>: <reason>` before
-  it starts another file.
+  takes it, failing the same way, and returns the function that releases it, and
+  the caller passes `lockHeld: true` to the backup. It waits for a refresh as
+  `fresh()` does, puts every in-scope original not already at its save path
+  there as `photo.download()` does (and, with `includeThumbnails`, fetches
+  thumbnails) through the content cache, waits for an ML data fetch, and
+  rebuilds the on-disk backup tree with a durable failure ledger. Each file's
+  JSON holds its ML data and, for an image (for a live photo, its image), its
+  original's EXIF and XMP, with its dimensions for a JPEG only; a video's JSON
+  holds none of these three. A fetched original is written straight to its save
+  path and not into the cache, which then counts it as present; one the cache
+  already held is copied from there. `BackupOptions`: `downloadDirectory` (falls
+  back to the library's), `includeOriginals` (default `true`),
+  `includeThumbnails` (default `false`), `onlyAlbumNames`, `verify` (default
+  `false`), `onProgress`, and `lockHeld` (default `false`). See Backup layout
+  above for the tree it writes.
 
 ### Request pools
 
@@ -1096,11 +1077,6 @@ photos newest first). `lib.subscribe({ onChange })` delivers a `LibraryChange`
 Each pool orders on-demand work ahead of background/precache work and dedups
 in-flight fetches by key, and an idle pool never lends its slots to a busy one.
 
-`lib.backup()`, and so `quak backup`, works on up to the content pool's limit of
-originals at once, 5 unless the library was opened with other `pools`. The limit
-covers everything it does for one original, hashing it for `verify` included, so
-however large the account is, no more originals than that are open at once.
-
 ### On-disk cache layout
 
 Under `cacheDirectory`:
@@ -1152,7 +1128,7 @@ from a very old client, is stored unchecked.
 - `src/library/mlsearch.ts`: `MLDataAPI`, `SimilarResult`
 - `src/exif.ts`: `ExifTags`, `PhotoExif`
 - `src/library/pools.ts`: `RequestPools`, `RequestPoolsOptions`, `BoundedPool`
-- `src/backup.ts`: `BackupLock`, `BackupOptions`, `BackupResult`, `BackupError`
+- `src/backup.ts`: `BackupOptions`, `BackupResult`, `BackupError`
 - `src/client.ts`: `Client`, `LoginOptions`, `ClientSnapshot`
 - `src/api/client.ts`: `ApiClient`, `ApiClientOptions`, `StreamOptions`
 - `src/errors.ts`: `ApiError`, `TruncatedStreamError`

TODO.md

@@ -17,59 +17,24 @@ pre-1.0
 
 # Next Step
 
-None: no implementation work is open. The check of quak against a live Ente
-account, https://git.eeqj.de/sneak/quak/issues/187, needs an account only sneak
-has, so it waits on him.
+None: no implementation work is open. The cache design,
+https://git.eeqj.de/sneak/quak/issues/36, waits on sneak's review.
 
 Tagging and releases are decided by sneak alone, and happen only when he
 declares one.
 
 # Completed Steps
 
-- 2026-10-14: `lib.backup()`, and so `quak backup`, works on up to the content
-  pool's limit of originals at once, 5 by default, instead of one at a time
-  (issue 182). That many workers take files from one shared list, each doing all
-  the work for one original, its `--verify` hashing included, so no more
-  originals than that are open at once. `BackupLibrary` says the limit as
-  `contentConcurrency`. A test holds each download at the fake Ente server to
-  count those in flight. Once a worker has thrown, as one does when `onProgress`
-  throws, or the lock is lost, no worker takes another file; the backup fails
-  once the originals under way are in place, and a lost lock stops it before it
-  fetches ML data.
-
-- 2026-10-14: Next Step said the cache design, issue 36, waits on sneak's
-  review, though that issue closed on 2026-10-03 (issue 194). It now names the
-  issues open on the tracker.
-
-- 2026-10-14: A backup whose lock is lost no longer dies with a stack trace
-  (issue 184). `lockBackupDirectory` gives proper-lockfile an `onCompromised`
-  that records why the lock was lost instead of throwing from its timer, and
-  returns the lock, which `quak backup` passes to `lib.backup()` as `lock`. The
-  backup then stops before it starts another file with
-  `lost the lock on DIR: REASON`, which `quak backup` prints as one line before
-  it exits 1. Releasing a lost lock leaves `backup.lock` alone. Tests in
-  `test/cli/backup-end-to-end.test.ts` remove the lock, or put another backup's
-  in its place, while a download is held open.
-
-- 2026-10-14: An album or file quak cannot decrypt, or whose metadata is not
+- 2026-10-13: An album or file quak cannot decrypt, or whose metadata is not
   JSON, no longer fails the refresh, so one bad record no longer stops
   `quak backup` from storing anything (issue 181). The refresh leaves it out, an
   album with its files, and the library keeps it with the reason in
-  `metadata.json` until the server sends a copy that decrypts or deletes it.
-  `quak backup` stores every other file, records each such file in
-  `failures.json` with an error starting `could not be decrypted:`, names each
-  such album's ID in a printed line, or with `--json` in `undecryptableAlbums`,
-  and exits 1 while any remain. A file whose copy in another album decrypts is
-  not recorded: its original is stored from that copy, and the album where it
-  does not decrypt neither links nor lists it. The read commands answer from
-  what decrypted.
-
-- 2026-10-14: `quak backup` no longer asks the server for changes every 3
-  seconds while it runs (issue 183). It opens its library with
-  `refreshIntervalSeconds: Infinity`, which the library now takes as no
-  background timer, so the backup refreshes only as it starts and no timed
-  refresh starts another ML data pass during the run. A test holds a backup's
-  download open while two hours pass and counts its `/collections/v2` requests.
+  `metadata.json` until the server sends a copy that decrypts or deletes it. The
+  backup stores every other file, records each such file in `failures.json` with
+  an error starting `could not be decrypted:`, prints one line naming each such
+  album's ID, lists those IDs in `undecryptableAlbums`, and exits 1 while any
+  remain. A file whose copy in another album decrypts is backed up as usual. The
+  read commands answer from what decrypted.
 
 - 2026-10-14: `test/cli/backup-end-to-end.test.ts` runs `quak backup` as cron
   does (issue 186): `backupCommand` and `run`, the real `loadSession` reading a

src/backup.ts

@@ -1,14 +1,13 @@
 // The backup command, rebuilt on the library API (issue #51).
 //
 // `lib.backup()` takes the lock in `downloadDirectory` (unless its caller
-// passes one in), and fails at once when another backup of it holds the
-// lock; when the lock is lost while it runs, it fails before it starts another
-// file. It waits for a completed refresh of the library (a failed one fails the
+// already holds it), and fails at once when another backup of it holds the
+// lock. It waits for a completed refresh of the library (a failed one fails the
 // backup before any file is touched), then, for every file in scope, puts its
 // original at its save path under `downloadDirectory`, as `Photo.download()`
-// does, up to the content pool's limit of them at once, waits for an ML data
-// fetch, and rebuilds the derived views (per-file sidecars, per-collection
-// symlink trees, per-collection JSON) from the model. The on-disk layout:
+// does, waits for an ML data fetch, and rebuilds the derived views (per-file
+// sidecars, per-collection symlink trees, per-collection JSON) from the model.
+// The on-disk layout:
 //
 //     <downloadDirectory>/
 //         YYYY/YYYY-MM/YYYY-MM-DD/
@@ -97,14 +96,6 @@ import type { Collection, EnteFile, FileMetadata } from "./model/types.js";
 
 export type ProgressCallback = (message: string) => void;
 
-// The lock in a backup directory, as `lockBackupDirectory` returns it.
-export interface BackupLock {
-    // Removes `backup.lock`, unless the lock was lost.
-    release(): Promise<void>;
-    // Why the lock was lost, once it is.
-    lost?: Error;
-}
-
 export interface BackupOptions {
     // Where the backup tree lives. `lib.backup()` defaults it to the library's
     // download directory; `runBackup` with none throws before any network
@@ -121,11 +112,10 @@ export interface BackupOptions {
     // bytes do not match the content hash its metadata records. Default false.
     verify?: boolean;
     onProgress?: ProgressCallback;
-    // The lock in `downloadDirectory`, when the caller took it with
-    // `lockBackupDirectory` and releases it itself. The backup then does not
-    // take the lock, and fails once this one is lost. `quak backup` takes it
-    // before it opens its library.
-    lock?: BackupLock;
+    // The caller already holds the lock in `downloadDirectory`, taken with
+    // `lockBackupDirectory`, and releases it itself, so the backup does not
+    // take it. `quak backup` takes it before it opens its library.
+    lockHeld?: boolean;
 }
 
 export interface BackupError {
@@ -181,9 +171,6 @@ export interface BackupLibrary {
         destination: string,
     ): Promise<{ path: string; videoPath?: string }>;
     thumbnail(fileID: number): Promise<{ path: string }>;
-    // How many originals the backup works on at once: the limit of the
-    // library's content pool.
-    contentConcurrency: number;
     // Wait for an ML data fetch to complete, joining one already running or
     // starting one. Rejects with the reason when it fails; resolves at once
     // when the library cannot fetch ML data.
@@ -523,14 +510,11 @@ const writeAlbumJSON = (
     writeFileSync(path, JSON.stringify(album, null, 2));
 };
 
-// The backup itself, which `runBackup` below runs while `lock` is held. Once
-// the lock is lost, another backup may be writing to `downloadDirectory`, so
-// this one fails before it starts another file.
+// The backup itself, which `runBackup` below runs while the lock is held.
 const runLockedBackup = async (
     lib: BackupLibrary,
     opts: BackupOptions,
     downloadDirectory: string,
-    lock: BackupLock,
 ): Promise<BackupResult> => {
     const includeOriginals = opts.includeOriginals ?? true;
     const includeThumbnails = opts.includeThumbnails ?? false;
@@ -540,7 +524,6 @@ const runLockedBackup = async (
 
     log("Refreshing library...");
     await lib.refresh();
-    if (lock.lost) throw lock.lost;
 
     const collectionsDir = join(downloadDirectory, "collections");
     const thumbnailsDir = join(downloadDirectory, "thumbnails");
@@ -657,31 +640,74 @@ const runLockedBackup = async (
     // present original is hashed first, and one that does not match the hash
     // its metadata records is removed and fetched like a missing one. One
     // that cannot be read is recorded as failed and left where it is.
-    // `storeOriginal` does this for one original, and records its failure.
-    const storeOriginal = async (file: EnteFile): Promise<void> => {
-        let stored = storedAtSavePath(downloadDirectory, file);
-        let mismatch = false;
-        if (stored !== undefined && verify) {
-            try {
-                if (file.metadata.hash === undefined) {
-                    unchecked++;
-                } else if ((await storedHash(stored)) === file.metadata.hash) {
-                    verified++;
-                } else {
-                    log(
-                        `MISMATCH original ${file.metadata.title} (${file.id}): its bytes do not match its content hash`,
-                    );
-                    mismatched++;
-                    mismatch = true;
-                    rmSync(stored.path);
-                    if (stored.videoPath !== undefined) {
-                        rmSync(stored.videoPath);
+    if (includeOriginals) {
+        for (const [fileID, file] of distinct) {
+            let stored = storedAtSavePath(downloadDirectory, file);
+            let mismatch = false;
+            if (stored !== undefined && verify) {
+                try {
+                    if (file.metadata.hash === undefined) {
+                        unchecked++;
+                    } else if (
+                        (await storedHash(stored)) === file.metadata.hash
+                    ) {
+                        verified++;
+                    } else {
+                        log(
+                            `MISMATCH original ${file.metadata.title} (${fileID}): its bytes do not match its content hash`,
+                        );
+                        mismatched++;
+                        mismatch = true;
+                        rmSync(stored.path);
+                        if (stored.videoPath !== undefined) {
+                            rmSync(stored.videoPath);
+                        }
+                        stored = undefined;
                     }
-                    stored = undefined;
+                } catch (err) {
+                    log(
+                        `FAILED verifying original ${file.metadata.title}: ${errorMessage(err)}`,
+                    );
+                    recordFailure(
+                        file.id,
+                        file.metadata.title,
+                        collectionName.get(file.collectionID) ?? "",
+                        err,
+                    );
+                    continue;
                 }
+            }
+            if (stored !== undefined) {
+                skipped++;
+                continue;
+            }
+            try {
+                log(`Fetching original ${file.metadata.title} (${fileID})...`);
+                // A fetched original is written straight to its save path (a
+                // live photo beside it); only one that was already cached
+                // elsewhere is copied.
+                const placed = await placeOriginal(
+                    downloadDirectory,
+                    file,
+                    (dest) => lib.original(fileID, dest),
+                );
+                storedThisRun.add(fileID);
+                // A copy from the cache is not checked as a download is and can
+                // hold the same bad bytes, so what is put back after a
+                // mismatch is hashed too. A bad copy stays where it is and the
+                // file fails.
+                if (
+                    mismatch &&
+                    (await storedHash(placed)) !== file.metadata.hash
+                ) {
+                    throw new Error(
+                        "the original put back does not match its content hash either",
+                    );
+                }
+                downloaded++;
             } catch (err) {
                 log(
-                    `FAILED verifying original ${file.metadata.title}: ${errorMessage(err)}`,
+                    `FAILED original ${file.metadata.title}: ${errorMessage(err)}`,
                 );
                 recordFailure(
                     file.id,
@@ -689,79 +715,12 @@ const runLockedBackup = async (
                     collectionName.get(file.collectionID) ?? "",
                     err,
                 );
-                return;
             }
         }
-        if (stored !== undefined) {
-            skipped++;
-            return;
-        }
-        try {
-            log(`Fetching original ${file.metadata.title} (${file.id})...`);
-            // A fetched original is written straight to its save path (a
-            // live photo beside it); only one that was already cached
-            // elsewhere is copied.
-            const placed = await placeOriginal(
-                downloadDirectory,
-                file,
-                (dest) => lib.original(file.id, dest),
-            );
-            storedThisRun.add(file.id);
-            // A copy from the cache is not checked as a download is and can
-            // hold the same bad bytes, so what is put back after a mismatch
-            // is hashed too. A bad copy stays where it is and the file fails.
-            if (mismatch && (await storedHash(placed)) !== file.metadata.hash) {
-                throw new Error(
-                    "the original put back does not match its content hash either",
-                );
-            }
-            downloaded++;
-        } catch (err) {
-            log(`FAILED original ${file.metadata.title}: ${errorMessage(err)}`);
-            recordFailure(
-                file.id,
-                file.metadata.title,
-                collectionName.get(file.collectionID) ?? "",
-                err,
-            );
-        }
-    };
-
-    // Up to the content pool's limit of originals are worked on at once,
-    // their `verify` hashing included, so however large the account is, no
-    // more than that many are open. Each worker takes the next file from the
-    // iterator they all share until none is left. Once a worker has thrown,
-    // as one does when `onProgress` throws, or the lock is lost, no worker
-    // takes another file. The backup fails only once every worker has
-    // stopped, so none writes into the backup after it has ended. It checks
-    // the lock then too, so it does not go on to the thumbnails or the ML
-    // data fetch without it.
-    if (includeOriginals) {
-        const pending = distinct.values();
-        let workerThrew = false;
-        const worker = async (): Promise<void> => {
-            for (const file of pending) {
-                if (workerThrew || lock.lost) return;
-                try {
-                    await storeOriginal(file);
-                } catch (err) {
-                    workerThrew = true;
-                    throw err;
-                }
-            }
-        };
-        const workers = await Promise.allSettled(
-            Array.from({ length: lib.contentConcurrency }, worker),
-        );
-        for (const w of workers) {
-            if (w.status === "rejected") throw w.reason;
-        }
-        if (lock.lost) throw lock.lost;
     }
 
     if (includeThumbnails) {
         for (const [fileID, file] of distinct) {
-            if (lock.lost) throw lock.lost;
             const dest = join(thumbnailsDir, `${fileID}.jpg`);
             if (isPresent(dest)) continue;
             try {
@@ -794,7 +753,6 @@ const runLockedBackup = async (
             log(`FAILED ML data: ${mlDataError}`);
         }
         for (const file of distinct.values()) {
-            if (lock.lost) throw lock.lost;
             const stored = storedAtSavePath(downloadDirectory, file);
             if (stored === undefined) continue;
             const path = withExtension(
@@ -838,7 +796,6 @@ const runLockedBackup = async (
     const albumDirNames = new Map(
         allCollections.map((c, i) => [c.id, dirNames[i]!]),
     );
-    if (lock.lost) throw lock.lost;
     try {
         removeStaleAlbumDirs(
             collectionsDir,
@@ -850,7 +807,6 @@ const runLockedBackup = async (
     }
 
     for (const c of collections) {
-        if (lock.lost) throw lock.lost;
         const colDirName = albumDirNames.get(c.id)!;
         const colDir = join(collectionsDir, colDirName);
         mkdirSync(colDir, { recursive: true });
@@ -908,9 +864,7 @@ const runLockedBackup = async (
     // its failure resolved; a file gone from the library (deleted) or outside
     // this run's scope is not something this run can resolve, so keeping its
     // stale entry would keep the exit code non-zero forever — a single
-    // since-deleted photo would fail every future scheduled backup. A backup
-    // whose lock was lost leaves the ledger as it is.
-    if (lock.lost) throw lock.lost;
+    // since-deleted photo would fail every future scheduled backup.
     for (const fileID of [...ledger.keys()]) {
         if (!failedThisRun.has(fileID)) ledger.delete(fileID);
     }
@@ -931,36 +885,18 @@ const runLockedBackup = async (
 
 // Only one backup of a directory runs at a time, in this process or another.
 // Creates `downloadDirectory` if it is missing, takes the lock in it and
-// returns it; while another backup holds the lock, fails at once with an error
-// whose `code` is `ELOCKED`. The lock is the directory `backup.lock`, whose
-// modification time proper-lockfile keeps current while it is held. One it has
-// not touched for 10 seconds was left by a run that could not remove it, and
-// is taken over.
-//
-// proper-lockfile finds the lock lost when `backup.lock` is gone or is another
-// backup's, and calls `onCompromised` from a timer, where throwing would end
-// the process. The `onCompromised` given here sets the lock's `lost` instead,
-// and the backup holding the lock stops before it starts another file (see
-// `runLockedBackup`). Releasing a lost lock leaves `backup.lock` alone, since
-// it may be another backup's.
+// returns the function that releases it; while another backup holds the lock,
+// fails at once with an error whose `code` is `ELOCKED`. The lock is the
+// directory `backup.lock`, whose modification time proper-lockfile keeps
+// current while it is held. One it has not touched for 10 seconds was left by
+// a run that could not remove it, and is taken over.
 export const lockBackupDirectory = async (
     downloadDirectory: string,
-): Promise<BackupLock> => {
+): Promise<() => Promise<void>> => {
     mkdirSync(downloadDirectory, { recursive: true });
-    let release: () => Promise<void>;
-    const lock: BackupLock = {
-        release: async () => {
-            if (lock.lost === undefined) await release();
-        },
-    };
     try {
-        release = await lockfile.lock(downloadDirectory, {
+        return await lockfile.lock(downloadDirectory, {
             lockfilePath: join(downloadDirectory, "backup.lock"),
-            onCompromised: (err) => {
-                lock.lost = new Error(
-                    `lost the lock on ${downloadDirectory}: ${err.message}`,
-                );
-            },
         });
     } catch (err) {
         if ((err as NodeJS.ErrnoException).code !== "ELOCKED") throw err;
@@ -969,11 +905,10 @@ export const lockBackupDirectory = async (
             { code: "ELOCKED" },
         );
     }
-    return lock;
 };
 
 // Runs the backup holding the lock, which it takes and releases itself unless
-// the caller passes the lock it took (`opts.lock`).
+// the caller already holds it (`opts.lockHeld`).
 export const runBackup = async (
     lib: BackupLibrary,
     opts: BackupOptions,
@@ -985,21 +920,13 @@ export const runBackup = async (
                 "open the library with one)",
         );
     }
-    // As `BoundedPool` does. A limit below 1, or one that is not a number,
-    // would back up no original and end with no error.
-    const { contentConcurrency } = lib;
-    if (!Number.isInteger(contentConcurrency) || contentConcurrency < 1) {
-        throw new RangeError(
-            `contentConcurrency must be a positive integer, got ${contentConcurrency}`,
-        );
+    if (opts.lockHeld) {
+        return runLockedBackup(lib, opts, downloadDirectory);
     }
-    if (opts.lock) {
-        return runLockedBackup(lib, opts, downloadDirectory, opts.lock);
-    }
-    const lock = await lockBackupDirectory(downloadDirectory);
+    const release = await lockBackupDirectory(downloadDirectory);
     try {
-        return await runLockedBackup(lib, opts, downloadDirectory, lock);
+        return await runLockedBackup(lib, opts, downloadDirectory);
     } finally {
-        await lock.release();
+        await release();
     }
 };

src/cli-commands.ts

@@ -20,7 +20,7 @@ import {
     type ClientSnapshot,
     type LoginOptions,
 } from "./client.js";
-import { lockBackupDirectory, type BackupLock } from "./backup.js";
+import { lockBackupDirectory } from "./backup.js";
 import { init } from "./crypto/index.js";
 import {
     defaultCacheDirectory,
@@ -416,9 +416,9 @@ export const backupCommand = async (
     ctx.stderr.write("Starting backup...\n");
     // The lock is taken before the library opens and starts its refresh, so a
     // run refused while another backup of `dir` runs sends no request.
-    let lock: BackupLock;
+    let release: () => Promise<void>;
     try {
-        lock = await lockBackupDirectory(dir);
+        release = await lockBackupDirectory(dir);
     } catch (err) {
         if ((err as NodeJS.ErrnoException).code !== "ELOCKED") throw err;
         ctx.stderr.write(`quak: ${(err as Error).message}\n`);
@@ -427,20 +427,17 @@ export const backupCommand = async (
     try {
         // The precache is off: the backup fetches what it needs, and must not
         // also fill the cache with every thumbnail and the recent originals.
-        // No refresh starts on a timer: the backup lists its files once, from
-        // the refresh it waits for, and can run for hours.
         const lib = await Library.open({
             client,
             downloadDirectory: dir,
             cacheDirectory: ctx.cacheDir,
-            refreshIntervalSeconds: Infinity,
             precacheThumbnails: false,
             precacheOriginals: false,
         });
         try {
             const result = await lib.backup({
                 downloadDirectory: dir,
-                lock,
+                lockHeld: true,
                 verify: opts.verify,
                 onProgress: (msg) => {
                     if (!opts.json) ctx.stderr.write(msg + "\n");
@@ -477,7 +474,7 @@ export const backupCommand = async (
             await lib.close();
         }
     } finally {
-        await lock.release();
+        await release();
     }
 };
 

src/index.ts

@@ -69,7 +69,6 @@ export {
     type EnsureEvent,
     lockBackupDirectory,
     runBackup,
-    type BackupLock,
     type BackupOptions,
     type BackupResult,
     type BackupError,

src/library/index.ts

@@ -96,7 +96,6 @@ import { runBackup, type BackupOptions, type BackupResult } from "../backup.js";
 export {
     lockBackupDirectory,
     runBackup,
-    type BackupLock,
     type BackupOptions,
     type BackupResult,
     type BackupError,
@@ -180,9 +179,6 @@ export interface LibraryOptions {
     // directory at open. The content cache treats an original already stored
     // at its save path as present.
     downloadDirectory?: string;
-    // How long after one refresh ends the background timer starts the next.
-    // `Infinity` starts none: the library then refreshes only as it opens and
-    // when `fresh()` or `backup()` asks.
     refreshIntervalSeconds?: number;
     onProgress?: RefreshProgressCallback;
     // The bounded request pools (issue #45), shared by the ML-data fetch (the
@@ -571,10 +567,9 @@ export class Library {
 
     // Back up every in-scope file to `opts.downloadDirectory`, or else the
     // library's, each original at its save path, with a durable failure
-    // ledger (issue #51). Takes the lock in that directory first, unless the
-    // caller passes the lock it took as `opts.lock`, failing at once while
-    // another backup of it runs, and before it starts another file once the
-    // lock is lost (see `lockBackupDirectory`). Waits for a
+    // ledger (issue #51). Takes the lock in that directory first, unless
+    // `opts.lockHeld` says the caller holds it, failing at once while another
+    // backup of it runs (see `runBackup`). Waits for a
     // completed refresh, as `fresh()` does, joining one already running, and
     // rejects before touching any file but the lock when it fails. Then puts
     // pending originals at their save paths as `Photo.download()` does (and
@@ -607,7 +602,6 @@ export class Library {
                 original: (fileID, destination) =>
                     cache!.backupOriginal(fileID, destination),
                 thumbnail: (fileID) => cache!.thumbnail(fileID),
-                contentConcurrency: this.pools.content.concurrency,
                 fetchMLData: () => this.fetchMLDataNow(),
                 mlData: (fileID) => this.mldata.forFile({ fileID }),
             },
@@ -634,8 +628,7 @@ export class Library {
     }
 
     private scheduleNext(): void {
-        // `setTimeout` would turn an infinite delay into 1 ms.
-        if (this.closed || this.intervalMs === Infinity) return;
+        if (this.closed) return;
         this.timer = setTimeout(() => {
             void this.runRefresh().then(() => this.scheduleNext());
         }, this.intervalMs);

src/library/store.ts

@@ -119,12 +119,7 @@ export class MetadataStore {
                 };
                 store.files.set(fileKey(file.collectionID, file.id), file);
             }
-            for (const record of parsed.undecryptable) {
-                if (typeof record.collectionID !== "number") {
-                    throw new Error("damaged record of what did not decrypt");
-                }
-                store.undecryptable.push(record);
-            }
+            store.undecryptable = parsed.undecryptable ?? [];
         } catch {
             // Any corruption discards the partial result: a half-read cache is
             // worse than an empty one, since the refresh unit will rebuild it.

test/cli/backup-concurrency.test.ts

@@ -1,608 +0,0 @@
-/**
- * How many originals `lib.backup()` works on at once.
- *
- * The backup puts up to the content pool's limit of originals at their save
- * paths at the same time: 5 for a library opened with the default
- * `RequestPools`, as `quak backup` opens it, or the `contentConcurrency` of the
- * pools a library was opened with. Everything the backup does for one original
- * counts against that limit, hashing it for `verify` included, so however large
- * the account is, the backup has no more than that many originals open at once.
- *
- * As in `backup-end-to-end.test.ts`, the real `Client` and `Library` run
- * against `buildMetaFetch` from `test/ente-server.ts`, a fake of the Ente HTTP
- * API serving data this file encrypts with libsodium. Here a test can also hold
- * each original's download until it lets it go, to see how many the backup has
- * in flight at once.
- *
- * The account, user 42, has one album of its own, Holiday, of eight photos,
- * all taken at noon on 1 March 2024, each with an original of its own.
- */
-
-import {
-    existsSync,
-    lstatSync,
-    mkdtempSync,
-    readdirSync,
-    readFileSync,
-    readlinkSync,
-    rmSync,
-    writeFileSync,
-} from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import sodium from "libsodium-wrappers-sumo";
-import { afterAll, beforeAll, describe, expect, it, vi } from "vitest";
-
-import type { BackupOptions } from "../../src/backup.js";
-import { Client, type ClientSnapshot } from "../../src/client.js";
-import { init, toBase64 } from "../../src/crypto/index.js";
-import { Library } from "../../src/library/index.js";
-import { RequestPools } from "../../src/library/pools.js";
-import {
-    buildAccount,
-    buildMetaFetch,
-    encryptSecretbox,
-    encryptStreamBlob,
-} from "../ente-server.js";
-import { blake2b } from "../live-photo.js";
-
-const EMAIL = "backup@example.com";
-const PASSWORD = "backup-password";
-// The fake server logs every account in as user 42.
-const USER_ID = 42;
-
-// Noon on 1 March 2024 in the time zone of the machine running the test, in
-// microseconds, as Ente records times.
-const TAKEN = new Date(2024, 2, 1, 12).getTime() * 1000;
-
-// The eight photos' IDs. Photo `id` is titled `photo-<id>.jpg`, and its
-// original is a few bytes naming it.
-const PHOTO_IDS = [101, 102, 103, 104, 105, 106, 107, 108];
-const originalOf = (id: number): Uint8Array =>
-    new TextEncoder().encode(`the photo ${id}`);
-
-// Where a backup to `dir` saves photo `id`'s original.
-const savedAt = (dir: string, id: number): string =>
-    join(dir, "2024/2024-03/2024-03-01", `2024-03-01.${id}.jpg`);
-
-// The fake server, the session it logs the account in with, and the
-// directory every backup below is made in.
-let server: typeof globalThis.fetch;
-let session: ClientSnapshot;
-let root: string;
-
-// The fake server, holding the account encrypted as Ente's clients upload it.
-const buildServer = async () => {
-    const account = await buildAccount(PASSWORD);
-
-    // The album as `/collections/v2` lists it: its key encrypted with the
-    // account's master key, its name with its own key.
-    const albumKey = sodium.crypto_secretbox_keygen();
-    const encryptedAlbumKey = encryptSecretbox(albumKey, account.masterKey);
-    const encryptedName = encryptSecretbox(
-        new TextEncoder().encode("Holiday"),
-        albumKey,
-    );
-    const album = {
-        id: 10,
-        owner: { id: USER_ID },
-        encryptedKey: toBase64(encryptedAlbumKey.ciphertext),
-        keyDecryptionNonce: toBase64(encryptedAlbumKey.nonce),
-        encryptedName: toBase64(encryptedName.ciphertext),
-        nameDecryptionNonce: toBase64(encryptedName.nonce),
-        type: "album",
-        updationTime: TAKEN,
-    };
-
-    // Each photo as the album's `/collections/v2/diff` lists it: its key
-    // encrypted with the album's key, and its metadata, holding the hash of
-    // its original, encrypted with its own key. Its original, encrypted with
-    // its own key too, is what the files CDN serves for it.
-    const ciphertexts: Record<number, Uint8Array> = {};
-    const photos = PHOTO_IDS.map((id) => {
-        const key = sodium.crypto_secretstream_xchacha20poly1305_keygen();
-        const original = encryptStreamBlob(originalOf(id), key);
-        ciphertexts[id] = original.ciphertext;
-        const encryptedKey = encryptSecretbox(key, albumKey);
-        const metadata = encryptStreamBlob(
-            new TextEncoder().encode(
-                JSON.stringify({
-                    title: `photo-${id}.jpg`,
-                    fileType: 0,
-                    hash: blake2b(originalOf(id)),
-                    creationTime: TAKEN,
-                    modificationTime: TAKEN,
-                }),
-            ),
-            key,
-        );
-        return {
-            id,
-            collectionID: 10,
-            ownerID: USER_ID,
-            encryptedKey: toBase64(encryptedKey.ciphertext),
-            keyDecryptionNonce: toBase64(encryptedKey.nonce),
-            metadata: {
-                encryptedData: toBase64(metadata.ciphertext),
-                decryptionHeader: toBase64(metadata.header),
-            },
-            file: { decryptionHeader: toBase64(original.header) },
-            thumbnail: {
-                decryptionHeader: toBase64(sodium.randombytes_buf(24)),
-            },
-            updationTime: TAKEN,
-        };
-    });
-
-    return buildMetaFetch({
-        verifier: account.verifier,
-        srpAttributes: account.srpAttributes,
-        keyAttributes: account.keyAttributes,
-        encryptedToken: account.encryptedToken,
-        collections: [album],
-        filesByCollection: { 10: photos },
-        encryptedMLData: {},
-        fileCiphertexts: ciphertexts,
-    });
-};
-
-beforeAll(async () => {
-    await init();
-    await sodium.ready;
-    root = mkdtempSync(join(tmpdir(), "quak-backup-concurrency-"));
-    server = await buildServer();
-    const client = await Client.login({
-        email: EMAIL,
-        password: PASSWORD,
-        apiOptions: { fetch: server },
-    });
-    session = client.toJSON();
-});
-
-afterAll(() => {
-    rmSync(root, { recursive: true, force: true });
-});
-
-// The ID of the photo whose original a request downloads, or undefined for any
-// other request. quak downloads an original from
-// `https://files.ente.io/?fileID=<id>`.
-const downloadOf = (input: RequestInfo | URL): number | undefined => {
-    const url = new URL(String(input));
-    return url.hostname === "files.ente.io"
-        ? Number(url.searchParams.get("fileID"))
-        : undefined;
-};
-
-// The fake server, except that it answers 404 to every download of photo
-// `failing`'s original.
-const failingFor =
-    (failing: number): typeof globalThis.fetch =>
-    async (input, init) =>
-        downloadOf(input) === failing
-            ? new Response("not found", { status: 404 })
-            : server(input, init);
-
-// The fake server, holding each download of an original until the test lets
-// it go. `held` lists the downloads waiting, the first to arrive first;
-// `most()` is the largest number that ever waited at once. A held download of
-// photo `failing`'s original is answered 404 once it is let go.
-const holdingServer = (failing?: number) => {
-    const held: { id: number; release: () => void }[] = [];
-    let most = 0;
-    const fetch: typeof globalThis.fetch = async (input, init) => {
-        const id = downloadOf(input);
-        if (id !== undefined) {
-            await new Promise<void>((release) => {
-                held.push({ id, release });
-                most = Math.max(most, held.length);
-            });
-            if (id === failing) {
-                return new Response("not found", { status: 404 });
-            }
-        }
-        return server(input, init);
-    };
-    return { fetch, held, most: () => most };
-};
-
-// Let the held downloads go one at a time, the first to arrive first, each
-// once `limit` of them wait, or all the downloads still to come when there
-// are fewer. Each of the eight photos is downloaded once. With a backup that
-// downloads fewer than `limit` at once, this fails waiting for them. Each wait
-// allows five seconds, for a loaded machine's disk to sync the files written.
-const releaseOneAtATime = async (
-    held: { release: () => void }[],
-    limit: number,
-): Promise<void> => {
-    for (let left = PHOTO_IDS.length; left > 0; left--) {
-        await vi.waitFor(
-            () => expect(held).toHaveLength(Math.min(limit, left)),
-            { interval: 5, timeout: 5000 },
-        );
-        held.shift()!.release();
-    }
-};
-
-// A library of the account opened as `quak backup` opens one, with no
-// precache and no background refresh, sending its requests through `fetch`.
-// It backs up to `dir` and keeps its cache beside it. Its request pools are
-// `pools`, or by default the library's own.
-const openLibrary = (
-    dir: string,
-    fetch: typeof globalThis.fetch,
-    pools?: RequestPools,
-): Promise<Library> =>
-    Library.open({
-        client: Client.fromJSON(session, { fetch }),
-        downloadDirectory: dir,
-        cacheDirectory: `${dir}-cache`,
-        refreshIntervalSeconds: Infinity,
-        precacheThumbnails: false,
-        precacheOriginals: false,
-        pools,
-    });
-
-// Every entry under `dir`, relative to it, sorted, a symlink as
-// `name -> target`.
-const listTree = (dir: string): string[] =>
-    readdirSync(dir, { recursive: true })
-        .sort()
-        .map((name) => {
-            const path = join(dir, name);
-            return lstatSync(path).isSymbolicLink()
-                ? `${name} -> ${readlinkSync(path)}`
-                : name;
-        });
-
-const expectStored = (dir: string, ids: number[]): void => {
-    for (const id of ids) {
-        expect(readFileSync(savedAt(dir, id))).toEqual(
-            Buffer.from(originalOf(id)),
-        );
-    }
-};
-
-describe("lib.backup()", () => {
-    // A library opened with the default pools, as `quak backup` opens one,
-    // downloads up to five originals at once. As soon as one finishes, the
-    // backup starts on the next photo, so five stay in flight until fewer
-    // than five are left.
-    it("downloads five originals at once, and never more, with the default pools", async () => {
-        const dir = mkdtempSync(join(root, "backup-"));
-        const holding = holdingServer();
-        const lib = await openLibrary(dir, holding.fetch);
-        try {
-            const backup = lib.backup();
-            await releaseOneAtATime(holding.held, 5);
-            const result = await backup;
-
-            expect(holding.most()).toBe(5);
-            expect(result).toMatchObject({
-                totalFiles: 8,
-                downloaded: 8,
-                failed: 0,
-            });
-            expectStored(dir, PHOTO_IDS);
-        } finally {
-            await lib.close();
-        }
-    });
-
-    // The limit is the content pool's, so a library opened with pools of
-    // another `contentConcurrency` backs up that many at once.
-    it("downloads as many originals at once as the content pool of the pools it was opened with allows", async () => {
-        const dir = mkdtempSync(join(root, "backup-"));
-        const holding = holdingServer();
-        const lib = await openLibrary(
-            dir,
-            holding.fetch,
-            new RequestPools({ contentConcurrency: 2 }),
-        );
-        try {
-            const backup = lib.backup();
-            await releaseOneAtATime(holding.held, 2);
-            const result = await backup;
-
-            expect(holding.most()).toBe(2);
-            expect(result).toMatchObject({ downloaded: 8, failed: 0 });
-            expectStored(dir, PHOTO_IDS);
-        } finally {
-            await lib.close();
-        }
-    });
-
-    // With `verify`, hashing an original already stored is part of the work
-    // on it, and counts against the limit too: a large backup never has more
-    // than five originals open for hashing. Here every stored original has
-    // changed on disk, so each is hashed, found not to match, and downloaded
-    // again. While five downloads wait, the backup has hashed only those five
-    // photos' originals; it opens the next one once a download finishes.
-    it("with verify, hashes no more originals ahead of their downloads than the limit", async () => {
-        const dir = mkdtempSync(join(root, "backup-"));
-        const first = await openLibrary(dir, server);
-        try {
-            await first.backup();
-        } finally {
-            await first.close();
-        }
-        for (const id of PHOTO_IDS) {
-            writeFileSync(savedAt(dir, id), "not the photo any more");
-        }
-
-        const holding = holdingServer();
-        const lib = await openLibrary(dir, holding.fetch);
-        const lines: string[] = [];
-        const mismatches = () =>
-            lines.filter((line) => line.startsWith("MISMATCH"));
-        try {
-            const backup = lib.backup({
-                verify: true,
-                onProgress: (line) => lines.push(line),
-            });
-            await vi.waitFor(() => expect(holding.held).toHaveLength(5), {
-                interval: 5,
-                timeout: 5000,
-            });
-            expect(mismatches()).toHaveLength(5);
-
-            await releaseOneAtATime(holding.held, 5);
-            const result = await backup;
-
-            expect(holding.most()).toBe(5);
-            expect(mismatches()).toHaveLength(8);
-            expect(result).toMatchObject({
-                downloaded: 8,
-                verified: 0,
-                mismatched: 8,
-                failed: 0,
-            });
-            expectStored(dir, PHOTO_IDS);
-        } finally {
-            await lib.close();
-        }
-    });
-
-    // The server answers 404 for photo 103's original. A 404 is not retried,
-    // so that download fails at once, while other downloads are still in
-    // flight. The backup records the failure and goes on: the downloads
-    // beside it finish, the photos after it are downloaded, and only photo
-    // 103 is missing from the backup and in failures.json.
-    it("goes on with the other originals when one fails", async () => {
-        const dir = mkdtempSync(join(root, "backup-"));
-        const holding = holdingServer(103);
-        const lib = await openLibrary(dir, holding.fetch);
-        try {
-            const backup = lib.backup();
-            await releaseOneAtATime(holding.held, 5);
-            const result = await backup;
-
-            expect(result).toMatchObject({
-                totalFiles: 8,
-                downloaded: 7,
-                failed: 1,
-            });
-            expect(result.errors.map((e) => e.fileID)).toEqual([103]);
-            expectStored(
-                dir,
-                PHOTO_IDS.filter((id) => id !== 103),
-            );
-            expect(existsSync(savedAt(dir, 103))).toBe(false);
-            const failures = JSON.parse(
-                readFileSync(join(dir, "failures.json"), "utf-8"),
-            );
-            expect(Object.keys(failures.files)).toEqual(["103"]);
-        } finally {
-            await lib.close();
-        }
-    });
-
-    // A throw from `onProgress` fails the backup: `lib.backup()` rejects with
-    // it. From then on the backup starts no further original. It finishes the
-    // ones it is working on, and rejects only once they are in place, so
-    // nothing is written into the backup after it has ended and removed its
-    // lock. Here the first five downloads wait. Photo 103's is let go first
-    // and answered 404, and the line reporting that failure throws while the
-    // other four wait. Only those five downloads are held: a backup that went
-    // on would store the other three photos.
-    it("when onProgress throws, starts no further original, and rejects once the originals it was working on are in place", async () => {
-        const dir = mkdtempSync(join(root, "backup-"));
-        const downloads: number[] = [];
-        const held: { id: number; release: () => void }[] = [];
-        const fetch: typeof globalThis.fetch = async (input, init) => {
-            const id = downloadOf(input);
-            if (id !== undefined) {
-                downloads.push(id);
-                if (downloads.length <= 5) {
-                    await new Promise<void>((release) =>
-                        held.push({ id, release }),
-                    );
-                }
-                if (id === 103) {
-                    return new Response("not found", { status: 404 });
-                }
-            }
-            return server(input, init);
-        };
-        const lib = await openLibrary(dir, fetch);
-        const lines: string[] = [];
-        try {
-            const backup = lib.backup({
-                onProgress: (line) => {
-                    lines.push(line);
-                    if (line.startsWith("FAILED")) {
-                        throw new Error("the progress output is closed");
-                    }
-                },
-            });
-            // The photos whose originals are in place, and whether the lock
-            // is there, at the moment `lib.backup()` rejects.
-            let storedWhenRejected: number[] = [];
-            let lockedWhenRejected = true;
-            const rejection = backup.catch((err: unknown) => {
-                storedWhenRejected = PHOTO_IDS.filter((id) =>
-                    existsSync(savedAt(dir, id)),
-                );
-                lockedWhenRejected = existsSync(join(dir, "backup.lock"));
-                return err;
-            });
-
-            await vi.waitFor(() => expect(held).toHaveLength(5), {
-                interval: 5,
-                timeout: 5000,
-            });
-            const at103 = held.findIndex((h) => h.id === 103);
-            held.splice(at103, 1)[0]!.release();
-            await vi.waitFor(
-                () =>
-                    expect(
-                        lines.some((line) => line.startsWith("FAILED")),
-                    ).toBe(true),
-                { interval: 5, timeout: 5000 },
-            );
-            for (const download of held) download.release();
-
-            expect(await rejection).toEqual(
-                new Error("the progress output is closed"),
-            );
-            expect(downloads.sort()).toEqual([101, 102, 103, 104, 105]);
-            expect(storedWhenRejected).toEqual([101, 102, 104, 105]);
-            expect(lockedWhenRejected).toBe(false);
-        } finally {
-            await lib.close();
-        }
-    });
-
-    // Once the backup's lock is lost, another backup may be writing to the
-    // directory, so the backup starts no further original. It finishes the
-    // ones it is working on, and `lib.backup()` rejects once they are all in
-    // place. Here `backup.lock` is removed while the first five downloads
-    // wait, and proper-lockfile's timer finds it gone. As in
-    // `backup-end-to-end.test.ts`, only `setTimeout` and `clearTimeout` are
-    // faked, so the test can fire that timer without waiting 5 seconds. Only
-    // the first five downloads are held: a backup that went on would store
-    // the other three photos.
-    it("when its lock is lost, starts no further original, and rejects once the originals it was working on are in place", async () => {
-        const dir = mkdtempSync(join(root, "backup-"));
-        const lockPath = join(dir, "backup.lock");
-        const downloads: number[] = [];
-        const held: (() => void)[] = [];
-        const fetch: typeof globalThis.fetch = async (input, init) => {
-            const id = downloadOf(input);
-            if (id !== undefined) {
-                downloads.push(id);
-                if (downloads.length <= 5) {
-                    await new Promise<void>((release) => held.push(release));
-                }
-            }
-            return server(input, init);
-        };
-        const lib = await openLibrary(dir, fetch);
-        vi.useFakeTimers({ toFake: ["setTimeout", "clearTimeout"] });
-        try {
-            const backup = lib.backup();
-            // The photos whose originals are in place at the moment
-            // `lib.backup()` rejects.
-            let storedWhenRejected: number[] = [];
-            const rejection = backup.catch((err: unknown) => {
-                storedWhenRejected = PHOTO_IDS.filter((id) =>
-                    existsSync(savedAt(dir, id)),
-                );
-                return err;
-            });
-
-            await vi.waitFor(() => expect(held).toHaveLength(5), {
-                interval: 5,
-                timeout: 5000,
-            });
-            rmSync(lockPath, { recursive: true });
-            // Fire proper-lockfile's timer, and wait for the look at the lock
-            // on disk that it starts to finish: Node lists a file system call
-            // in progress as an `FSReqCallback`.
-            vi.advanceTimersByTime(5_000);
-            while (process.getActiveResourcesInfo().includes("FSReqCallback")) {
-                await new Promise((resolve) => setImmediate(resolve));
-            }
-            for (const release of held) release();
-
-            expect(await rejection).toEqual(
-                new Error(
-                    `lost the lock on ${dir}: ENOENT: no such file or directory, stat '${lockPath}'`,
-                ),
-            );
-            expect(downloads.sort()).toEqual([101, 102, 103, 104, 105]);
-            expect(storedWhenRejected).toEqual([101, 102, 103, 104, 105]);
-        } finally {
-            vi.useRealTimers();
-            await lib.close();
-        }
-    });
-
-    // Working on several originals at once changes only how long a backup
-    // takes. The same two runs, with a content pool of one, which backs up
-    // one original at a time, and with the default pools, end the same way:
-    // the same result, the same progress lines (in another order), the same
-    // failures.json, and the same tree. The first run stores every photo but
-    // 103, whose download is answered 404. Then two stored originals change
-    // on disk, and a run with `verify` puts them back and tries 103 again.
-    it("ends as a backup of one original at a time does", async () => {
-        const twoRuns = async (pools: RequestPools) => {
-            const dir = mkdtempSync(join(root, "backup-"));
-            const lines: string[] = [];
-            const backup = async (opts: BackupOptions) => {
-                const lib = await openLibrary(dir, failingFor(103), pools);
-                try {
-                    return await lib.backup({
-                        ...opts,
-                        onProgress: (line) => lines.push(line),
-                    });
-                } finally {
-                    await lib.close();
-                }
-            };
-            const first = await backup({});
-            writeFileSync(savedAt(dir, 101), "not the photo any more");
-            writeFileSync(savedAt(dir, 105), "not the photo any more");
-            const second = await backup({ verify: true });
-
-            // Each entry of failures.json without the time it was last
-            // tried, which differs from run to run.
-            const { files } = JSON.parse(
-                readFileSync(join(dir, "failures.json"), "utf-8"),
-            ) as { files: Record<string, { lastTriedAt?: number }> };
-            for (const entry of Object.values(files)) delete entry.lastTriedAt;
-
-            return {
-                first,
-                second,
-                lines: lines.sort(),
-                failures: files,
-                tree: listTree(dir),
-            };
-        };
-
-        const oneAtATime = await twoRuns(
-            new RequestPools({ contentConcurrency: 1 }),
-        );
-        const fiveAtATime = await twoRuns(new RequestPools());
-
-        expect(oneAtATime.first).toMatchObject({
-            totalFiles: 8,
-            downloaded: 7,
-            skipped: 0,
-            failed: 1,
-        });
-        expect(oneAtATime.second).toMatchObject({
-            totalFiles: 8,
-            downloaded: 2,
-            skipped: 5,
-            verified: 5,
-            mismatched: 2,
-            unchecked: 0,
-            failed: 1,
-        });
-        expect(oneAtATime.failures).toEqual({
-            "103": expect.objectContaining({ fileID: 103, attempts: 2 }),
-        });
-        expect(fiveAtATime).toEqual(oneAtATime);
-    });
-});

test/cli/backup-end-to-end.test.ts

@@ -9,8 +9,7 @@
  * data this file encrypts with libsodium, as Ente's clients encrypt it. So
  * quak's own code fetches each original, decrypts it, checks it against the
  * hash its uploader recorded and unpacks a live photo, and quak's own retries
- * repeat a failed request. Two tests run `lib.backup()` instead, as a program
- * using quak as a library does.
+ * repeat a failed request.
  *
  * The account, user 42, has three albums:
  *
@@ -25,7 +24,6 @@
 import {
     existsSync,
     lstatSync,
-    mkdirSync,
     mkdtempSync,
     readdirSync,
     readFileSync,
@@ -38,16 +36,7 @@ import { join } from "node:path";
 import { Writable } from "node:stream";
 import { gzipSync } from "node:zlib";
 import sodium from "libsodium-wrappers-sumo";
-import {
-    afterAll,
-    afterEach,
-    beforeAll,
-    beforeEach,
-    describe,
-    expect,
-    it,
-    vi,
-} from "vitest";
+import { afterAll, beforeAll, describe, expect, it } from "vitest";
 
 import {
     backupCommand,
@@ -58,7 +47,6 @@ import { run } from "../../src/cli-run.js";
 import { loadSession } from "../../src/cli-session.js";
 import { Client } from "../../src/client.js";
 import { init, toBase64 } from "../../src/crypto/index.js";
-import { Library, lockBackupDirectory } from "../../src/library/index.js";
 import { UNATTENDED_RETRY_OPTIONS } from "../../src/retry.js";
 import {
     buildAccount,
@@ -645,191 +633,3 @@ describe("quak backup", () => {
         expect(stderr).toContain("  Verified:    2\n  Mismatched:  1\n");
     });
 });
-
-// `backup.lock` is a directory that proper-lockfile touches every 5 seconds,
-// from a timer, while the backup runs. Each time, it first looks at the lock
-// on disk. The lock is lost when it is gone, or when another backup has made
-// its own in its place, as one does with a lock nobody touched for 10
-// seconds. Another backup may then be writing to the directory, so the backup
-// stops before it starts another file.
-//
-// The fake server holds one file's download open until the test lets it go,
-// so the lock can be lost while the backup runs: beach.jpg's, the first file
-// backed up, unless the test names another. Only `setTimeout` and
-// `clearTimeout` are faked, so a test can fire proper-lockfile's timer without
-// waiting 5 seconds.
-describe("a backup whose lock is lost", () => {
-    let dir: string;
-    let lockPath: string;
-    let downloads: number[];
-    let heldFile: number;
-    let heldRequested: Promise<void>;
-    let releaseHeld: () => void;
-    let fetch: typeof globalThis.fetch;
-
-    beforeEach(() => {
-        dir = mkdtempSync(join(root, "backup-"));
-        lockPath = join(dir, "backup.lock");
-        downloads = [];
-        heldFile = BEACH.id;
-        let requested!: () => void;
-        heldRequested = new Promise((resolve) => {
-            requested = resolve;
-        });
-        const released = new Promise<void>((resolve) => {
-            releaseHeld = resolve;
-        });
-        const recording = recordingDownloads(downloads);
-        fetch = async (input, init) => {
-            if (downloadOf(input) === heldFile) {
-                requested();
-                await released;
-            }
-            return recording(input, init);
-        };
-        vi.useFakeTimers({ toFake: ["setTimeout", "clearTimeout"] });
-    });
-
-    afterEach(() => {
-        vi.useRealTimers();
-    });
-
-    // Fire proper-lockfile's timer, and wait for the look at the lock on disk
-    // that it starts to finish: Node lists a file system call in progress as
-    // an `FSReqCallback`.
-    const fireLockTimer = async (): Promise<void> => {
-        vi.advanceTimersByTime(5_000);
-        while (process.getActiveResourcesInfo().includes("FSReqCallback")) {
-            await new Promise((resolve) => setImmediate(resolve));
-        }
-    };
-
-    // The backup downloads up to five originals at once, so it has started
-    // all three when the lock is lost, and beach.jpg is stored. The backup
-    // then stops before it fetches ML data. `quak backup` prints why as one
-    // line, with no stack trace, and exits 1.
-    it("stops quak backup before it fetches ML data when backup.lock is removed, and exits 1", async () => {
-        const result = backup(dir, {}, fetch);
-        await heldRequested;
-        rmSync(lockPath, { recursive: true });
-        await fireLockTimer();
-        releaseHeld();
-        const { code, stderr } = await result;
-
-        expect(code).toBe(1);
-        expect(stderr).toBe(
-            "Starting backup...\n" +
-                "Refreshing library...\n" +
-                "Fetching original beach.jpg (100)...\n" +
-                "Fetching original IMG_0002.HEIC (300)...\n" +
-                "Fetching original toast.mp4 (200)...\n" +
-                `quak: lost the lock on ${dir}: ENOENT: no such file or directory, stat '${lockPath}'\n`,
-        );
-        expect(downloads.sort()).toEqual([100, 200, 300]);
-        expect(readFileSync(join(dir, DAY, "2024-03-01.100.jpg"))).toEqual(
-            Buffer.from(JPEG_WITH_EXIF),
-        );
-    });
-
-    // Here the lock is lost while toast.mp4, the last original, downloads.
-    // All three originals are stored, beside what the backup wrote before it
-    // started them, but no file's JSON and no album is written.
-    it("stops quak backup before any file's JSON when the lock is lost during the last original", async () => {
-        heldFile = TOAST_VIDEO.id;
-        const result = backup(dir, {}, fetch);
-        await heldRequested;
-        rmSync(lockPath, { recursive: true });
-        await fireLockTimer();
-        releaseHeld();
-        const { code, stderr } = await result;
-
-        expect(code).toBe(1);
-        expect(stderr).toContain(`quak: lost the lock on ${dir}: `);
-        expect(listTree(dir)).toEqual([
-            "2024",
-            "2024/2024-03",
-            "2024/2024-03/2024-03-01",
-            "2024/2024-03/2024-03-01/2024-03-01.100.jpg",
-            "2024/2024-03/2024-03-01/2024-03-01.200.mp4",
-            "2024/2024-03/2024-03-01/2024-03-01.300.heic",
-            "2024/2024-03/2024-03-01/2024-03-01.300.livephoto.json",
-            "2024/2024-03/2024-03-01/2024-03-01.300.mov",
-            "account.json",
-            "collections",
-        ]);
-    });
-
-    // Nothing touches the lock but quak, which finds it as it left it each
-    // time it looks, so the backup runs to the end and removes its lock.
-    it("lets quak backup run to the end while its lock stays", async () => {
-        const result = backup(dir, {}, fetch);
-        await heldRequested;
-        await fireLockTimer();
-        await fireLockTimer();
-        releaseHeld();
-        const { code } = await result;
-
-        expect(code).toBe(0);
-        expect(downloads.sort()).toEqual([100, 200, 300]);
-        expect(existsSync(lockPath)).toBe(false);
-    });
-
-    // The library a program using quak opens to back `dir` up.
-    const openLibrary = () =>
-        Library.open({
-            client: loadSession(join(sessionDir, "session.json"), { fetch })!,
-            cacheDirectory: `${dir}-cache`,
-            downloadDirectory: dir,
-            refreshIntervalSeconds: Infinity,
-            precacheThumbnails: false,
-            precacheOriginals: false,
-        });
-
-    // A program using quak as a library sees the same: `lib.backup()` rejects
-    // with the reason. Here another backup has made its own lock in place of
-    // quak's, and that lock is left where it is.
-    it("rejects lib.backup() when another backup has taken the lock over", async () => {
-        const lib = await openLibrary();
-        try {
-            const result = lib.backup();
-            await heldRequested;
-            rmSync(lockPath, { recursive: true });
-            mkdirSync(lockPath);
-            await fireLockTimer();
-            releaseHeld();
-
-            await expect(result).rejects.toThrow(
-                `lost the lock on ${dir}: Unable to update lock within the stale threshold`,
-            );
-            expect(downloads.sort()).toEqual([100, 200, 300]);
-            expect(existsSync(lockPath)).toBe(true);
-        } finally {
-            await lib.close();
-        }
-    });
-
-    // A program can take the lock before it opens its library, as `quak
-    // backup` does: `lockBackupDirectory` returns the lock, which the program
-    // passes to `lib.backup()` and releases once the backup ends. The backup
-    // checks it as it checks a lock it took, and the lock's `lost` says why it
-    // was lost.
-    it("rejects lib.backup() given its caller's lock once that lock is lost", async () => {
-        const lock = await lockBackupDirectory(dir);
-        const lib = await openLibrary();
-        try {
-            const result = lib.backup({ lock });
-            await heldRequested;
-            rmSync(lockPath, { recursive: true });
-            await fireLockTimer();
-            releaseHeld();
-
-            const lost = `lost the lock on ${dir}: ENOENT: no such file or directory, stat '${lockPath}'`;
-            await expect(result).rejects.toThrow(lost);
-            expect(lock.lost?.message).toBe(lost);
-            expect(downloads.sort()).toEqual([100, 200, 300]);
-        } finally {
-            await lib.close();
-            await lock.release();
-        }
-    });
-});

test/cli/backup-undecryptable.test.ts

@@ -23,13 +23,7 @@
  * key replaced by bytes no key opens, or its metadata text that is not JSON.
  */
 
-import {
-    existsSync,
-    mkdtempSync,
-    readdirSync,
-    readFileSync,
-    rmSync,
-} from "node:fs";
+import { existsSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import sodium from "libsodium-wrappers-sumo";
@@ -259,18 +253,6 @@ const brokenAccount = (): FakeEnte => {
     return ente;
 };
 
-// Album 1, "Trip", holds file 10, and album 2, "Family", holds file 20. Both
-// files decrypt, but album 2's own key does not, so the album is the only
-// record left out. All of it as of time 1.
-const brokenAlbumAccount = (): FakeEnte => {
-    const ente = new FakeEnte();
-    ente.putAlbum(1, "Trip", 1);
-    ente.putFile(1, 10, 1);
-    ente.putAlbum(2, "Family", 1, true);
-    ente.putFile(2, 20, 1);
-    return ente;
-};
-
 // Collects everything written to it.
 class Output {
     text = "";
@@ -339,12 +321,6 @@ const failures = (): Record<string, { error: string; attempts: number }> => {
 const stored = (id: number): boolean =>
     existsSync(join(backupDir(), DAY, `2026-03-01.${id}.jpg`));
 
-// The IDs of the files that album `name`'s JSON lists.
-const albumFiles = (name: string): number[] =>
-    JSON.parse(
-        readFileSync(join(backupDir(), "collections", `${name}.json`), "utf-8"),
-    ).files.map((f: { id: number }) => f.id);
-
 describe("quak backup with records it cannot decrypt", () => {
     it("backs up every other file, records each file it cannot decrypt in failures.json, names each such album, and exits 1", async () => {
         expect(await backup(brokenAccount())).toBe(1);
@@ -422,67 +398,6 @@ describe("quak backup with records it cannot decrypt", () => {
         expect(stderr.text).not.toContain("FAILED");
     });
 
-    it("exits 1 when the only record it cannot decrypt is an album, and 0 once the album decrypts", async () => {
-        const ente = brokenAlbumAccount();
-
-        // No file is in `failures.json`: the album alone keeps the exit code
-        // at 1.
-        expect(await backup(ente)).toBe(1);
-        expect(failures()).toEqual({});
-
-        ente.putAlbum(2, "Family", 2);
-        expect(await backup(ente)).toBe(0);
-        expect(stored(20)).toBe(true);
-    });
-
-    it("exits 1 when the only record it cannot decrypt is an album, and 0 once the album is deleted", async () => {
-        const ente = brokenAlbumAccount();
-
-        expect(await backup(ente)).toBe(1);
-        expect(failures()).toEqual({});
-
-        ente.deleteAlbum(2, 2);
-        expect(await backup(ente)).toBe(0);
-    });
-
-    it("removes what an earlier run linked for an album or a file that no longer decrypts, and keeps the originals", async () => {
-        // At time 1 everything decrypts: the first run links files 10 and 11
-        // in Trip and file 20 in Family.
-        const ente = new FakeEnte();
-        ente.putAlbum(1, "Trip", 1);
-        ente.putFile(1, 10, 1);
-        ente.putFile(1, 11, 1);
-        ente.putAlbum(2, "Family", 1);
-        ente.putFile(2, 20, 1);
-        expect(await backup(ente)).toBe(0);
-        const collections = join(backupDir(), "collections");
-        expect(readdirSync(join(collections, "Trip")).sort()).toEqual([
-            "photo-10.jpg",
-            "photo-11.jpg",
-        ]);
-        expect(readdirSync(join(collections, "Family"))).toEqual([
-            "photo-20.jpg",
-        ]);
-
-        // At time 2 the server's copy of file 11 in Trip, and album 2 itself,
-        // no longer decrypt. A run builds the album folders, their JSON and
-        // their links from what the library holds, so it removes them as if
-        // the album and the file had been deleted: Family's folder and JSON
-        // go, and Trip neither links nor lists file 11. The originals stay at
-        // their save paths, and the run exits 1.
-        ente.putFile(1, 11, 2, { corruptKey: true });
-        ente.putAlbum(2, "Family", 2, true);
-        expect(await backup(ente)).toBe(1);
-
-        expect(readdirSync(collections).sort()).toEqual(["Trip", "Trip.json"]);
-        expect(readdirSync(join(collections, "Trip"))).toEqual([
-            "photo-10.jpg",
-        ]);
-        expect(albumFiles("Trip")).toEqual([10]);
-        expect([10, 11, 20].map(stored)).toEqual([true, true, true]);
-        expect(Object.keys(failures())).toEqual(["11"]);
-    });
-
     it("backs up a file that does not decrypt in one album but does in another, and does not report it", async () => {
         // File 30 is in albums 1 and 3, each holding its key sealed under the
         // album's own key. In album 1 that is corrupt; in album 3 it is not,
@@ -497,13 +412,6 @@ describe("quak backup with records it cannot decrypt", () => {
 
         expect(stored(30)).toBe(true);
         expect(failures()).toEqual({});
-        // Album 1 has no copy of file 30 that decrypts, so it neither links
-        // the original nor lists the file; album 3 lists it.
-        expect(readdirSync(join(backupDir(), "collections", "Trip"))).toEqual(
-            [],
-        );
-        expect(albumFiles("Trip")).toEqual([]);
-        expect(albumFiles("Favorites")).toEqual([30]);
     });
 
     it("backs up that file in a run limited to the album where it does not decrypt", async () => {

test/cli/backup.test.ts

@@ -909,27 +909,6 @@ describe("the backup lock", () => {
         expect(existsSync(lockPath(outDir))).toBe(false);
         await lib.close();
     });
-
-    // `runBackup` takes a library object from its caller. With a
-    // `contentConcurrency` below 1, or one that is not a number, it would
-    // back up no original and report no error. It rejects any that is not a
-    // positive integer, as `BoundedPool` does, before it takes the lock,
-    // which would create the download directory, and before it asks the
-    // library for anything: the object here has nothing else.
-    it("rejects a library whose contentConcurrency is not a positive integer, before taking the lock", async () => {
-        const outDir = join(root, "backup");
-        for (const contentConcurrency of [undefined, 0, -1, 1.5, NaN]) {
-            const lib = { contentConcurrency } as unknown as BackupLibrary;
-
-            await expect(
-                runBackup(lib, { downloadDirectory: outDir }),
-            ).rejects.toThrow(
-                `contentConcurrency must be a positive integer, got ${contentConcurrency}`,
-            );
-
-            expect(existsSync(outDir)).toBe(false);
-        }
-    });
 });
 
 // Also serves ML data: file 100 has `ML_PAYLOAD`, the other two have none.
@@ -1512,7 +1491,6 @@ describe("backup album folders", () => {
         thumbnail: async () => {
             throw new Error("no thumbnails in this stand-in");
         },
-        contentConcurrency: 5,
         fetchMLData: async () => {},
         mlData: async () => undefined,
         whoami: () => ({ email: "backup@example.com", userID: USER_ID }),

test/cli/commands.test.ts

@@ -25,7 +25,6 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { PassThrough } from "node:stream";
 import * as jpegJs from "jpeg-js";
-import sodium from "libsodium-wrappers-sumo";
 import {
     describe,
     it,
@@ -56,7 +55,7 @@ import { loadSession } from "../../src/cli-session.js";
 import type { Client, ClientSnapshot, LoginOptions } from "../../src/client.js";
 import { savePath, type ContentSource } from "../../src/library/content.js";
 import type { Collection, EnteFile } from "../../src/model/types.js";
-import { encryptBlob, init, toBase64 } from "../../src/crypto/index.js";
+import { init, toBase64 } from "../../src/crypto/index.js";
 import { defaultCacheDirectory } from "../../src/library/index.js";
 import { HEIC_WITH_EXIF } from "../exif-heic.js";
 import {
@@ -904,146 +903,6 @@ describe("backup", () => {
         // Opening the library would have made its cache directory.
         expect(existsSync(join(root, "cache"))).toBe(false);
     });
-
-    // A backup runs for as long as its downloads take, hours on a large
-    // account. It lists its files from the refresh it waits for as it starts,
-    // so it must not ask the server for changes again on a timer while it
-    // runs: each refresh is a request, and each also starts a pass that asks
-    // again for the ML data of every file Ente holds none for.
-    //
-    // A saved session is read back by `loadSession`, its `fetch` a fake of the
-    // Ente HTTP API serving one album with one photo, encrypted as the server
-    // serves them. The fake holds the photo's download open while the clock
-    // moves on by two hours, then serves it. Only `setTimeout` and
-    // `clearTimeout` are faked: the library's refresh timer runs on them.
-    it("asks the server for changes only as it starts, however long it runs", async () => {
-        const masterKey = new Uint8Array(32).fill(1);
-        const albumKey = new Uint8Array(32).fill(2);
-        const photoKey = new Uint8Array(32).fill(3);
-        saveSession(join(root, "session"), {
-            email: "cli@example.com",
-            userID: USER_ID,
-            token: "token",
-            masterKey: toBase64(masterKey),
-            secretKey: toBase64(new Uint8Array(32)),
-            publicKey: toBase64(new Uint8Array(32)),
-        });
-        // A secretbox as the server sends one: ciphertext and nonce, base64.
-        const box = (plaintext: Uint8Array, key: Uint8Array) => {
-            const nonce = sodium.randombytes_buf(
-                sodium.crypto_secretbox_NONCEBYTES,
-            );
-            return {
-                ciphertext: toBase64(
-                    sodium.crypto_secretbox_easy(plaintext, nonce, key),
-                ),
-                nonce: toBase64(nonce),
-            };
-        };
-        const albumKeyBox = box(albumKey, masterKey);
-        const albumName = box(new TextEncoder().encode("Vacation"), albumKey);
-        const photoKeyBox = box(photoKey, albumKey);
-        const metadata = encryptBlob(
-            new TextEncoder().encode(
-                JSON.stringify({
-                    title: "beach.jpg",
-                    fileType: 0,
-                    creationTime: 1_700_000_000_000_000,
-                    modificationTime: 1_700_000_000_000_000,
-                }),
-            ),
-            photoKey,
-        );
-        const content = encryptBlob(
-            new TextEncoder().encode("the photo's bytes"),
-            photoKey,
-        );
-        const album = {
-            id: 1,
-            owner: { id: USER_ID },
-            encryptedKey: albumKeyBox.ciphertext,
-            keyDecryptionNonce: albumKeyBox.nonce,
-            encryptedName: albumName.ciphertext,
-            nameDecryptionNonce: albumName.nonce,
-            type: "album",
-            updationTime: 1,
-        };
-        const photo = {
-            id: 100,
-            collectionID: 1,
-            ownerID: USER_ID,
-            encryptedKey: photoKeyBox.ciphertext,
-            keyDecryptionNonce: photoKeyBox.nonce,
-            metadata: {
-                encryptedData: toBase64(metadata.ciphertext),
-                decryptionHeader: toBase64(metadata.header),
-            },
-            file: { decryptionHeader: toBase64(content.header) },
-            // The backup fetches no thumbnail.
-            thumbnail: { decryptionHeader: "" },
-            updationTime: 1,
-        };
-
-        // Each refresh starts with `collectionsSince`, which sends one
-        // `/collections/v2` request.
-        let refreshes = 0;
-        let downloadRequested!: () => void;
-        const requested = new Promise<void>((resolve) => {
-            downloadRequested = resolve;
-        });
-        let releaseDownload!: () => void;
-        const released = new Promise<void>((resolve) => {
-            releaseDownload = resolve;
-        });
-        const json = (body: unknown): Response =>
-            new Response(JSON.stringify(body), {
-                headers: { "content-type": "application/json" },
-            });
-        const fetch = async (url: string | URL): Promise<Response> => {
-            const { hostname, pathname } = new URL(String(url));
-            if (hostname === "files.ente.io") {
-                downloadRequested();
-                await released;
-                return new Response(content.ciphertext);
-            }
-            if (pathname === "/collections/v2") {
-                refreshes++;
-                return json({ collections: [album] });
-            }
-            if (pathname === "/collections/v2/diff") {
-                return json({ diff: [photo], hasMore: false });
-            }
-            // Ente holds no ML data for the photo.
-            if (pathname === "/files/data/fetch") return json({ data: [] });
-            return new Response("not found", { status: 404 });
-        };
-        const ctx = {
-            ...context(),
-            // The download's idle deadline is set past the two hours, or quak
-            // would give up the held download as stalled.
-            loadSession: (path: string) =>
-                loadSession(path, {
-                    fetch: fetch as typeof globalThis.fetch,
-                    downloadTimeoutMs: 3 * 3_600_000,
-                }),
-        };
-
-        vi.useFakeTimers({ toFake: ["setTimeout", "clearTimeout"] });
-        try {
-            const backup = backupCommand(ctx, join(root, "backup"), {});
-            await requested;
-            vi.advanceTimersByTime(2 * 3_600_000);
-            releaseDownload();
-            expect(await backup).toBe(0);
-        } finally {
-            vi.useRealTimers();
-        }
-
-        // Two refreshes, both before the download: the library opens onto the
-        // empty cache with one, and the backup waits for the other before it
-        // lists its files.
-        expect(refreshes).toBe(2);
-    });
 });
 
 describe("helper list-missing-thumbnails", () => {

test/library/store.test.ts

@@ -172,29 +172,6 @@ describe("MetadataStore", () => {
         expect(store.listCollections()).toEqual([]);
     });
 
-    it("loads an empty store when the list of what the refresh could not decrypt is damaged", async () => {
-        // A backup reads that list on every run, so a damaged one that loaded
-        // would fail every backup until the cache was deleted. A string is
-        // damaged too, though JavaScript can loop over its characters.
-        mkdirSync(join(dir, "cache"), { recursive: true });
-        for (const undecryptable of [{}, "not a list", [1]]) {
-            writeFileSync(
-                path,
-                JSON.stringify({
-                    schemaVersion: METADATA_SCHEMA_VERSION,
-                    userID: 42,
-                    collectionsSinceTime: 0,
-                    collections: [],
-                    files: [],
-                    undecryptable,
-                }),
-            );
-            const store = await MetadataStore.load(path);
-            expect(store.userID).toBe(0);
-            expect(store.listUndecryptable()).toEqual([]);
-        }
-    });
-
     it("creates the directory 0700 and the file 0600", async () => {
         const store = await MetadataStore.load(path);
         store.putCollection(sampleCollection());