Make lint and test phases of the Dockerfile (closes #96)

Follows the template: Dockerfile.lint is gone; the Dockerfile has a lint
phase (eslint, prettier --check .) and a test phase (vitest, run as the
node user, which the not-writable-directory tests need), and its
last stage compiles and depends on both. script/lint and script/test
build one phase each with --no-cache; script/docker and script/cibuild
pass --no-cache, so CHECK_EPOCH and LINT_EPOCH are removed.
script/cibuild is the single image build, so CI runs lint and the tests
once each. The tests that checked the old layout are deleted,
REPO_POLICIES.md is re-copied and the README describes the new layout.

Model: opus-5-5

README.md

@@ -214,23 +214,11 @@ quak/
         auth/           login flow (SRP + email OTP + TOTP), key unwrap
         model/          decrypted Collection, File, Metadata types + decrypt fns
         download/       streaming file/thumbnail download + decryption
-        library/        the cache-backed Library: metadata store, read
-                        surface, records, content cache, precache, ML data
-                        and search, request pools
         backup.ts       resilient full-account backup with dedup
-        metadata-backup.ts
-                        backup-metadata: all decrypted metadata as JSON
-        mldata-fetch.ts fetch + decrypt per-file ML data
-        filename.ts     safe file names from server metadata
         errors.ts       error types shared across layers
         retry.ts        retry classifier + exponential backoff with jitter
         thumbnails.ts   detect + regenerate missing thumbnails
         client.ts       high-level Client class assembled from the above
-        cli-commands.ts the CLI's commands as functions returning exit codes
-        cli-output.ts   how the CLI prints a file's title and time
-        cli-read.ts     fresh reads for the CLI's read commands
-        cli-run.ts      run a command, print its error, exit with its code
-        cli-session.ts  read the saved session file back into a Client
         index.ts        public library exports
     bin/
         quak.ts         CLI entrypoint (commander.js)
@@ -461,23 +449,16 @@ quak helper fix-missing-thumbnails [--file ids] generate + upload missing thumbn
 ```
 
 Every command runs on the same cache-backed library. The read commands —
-`collections`, `files`, `get`, `get-thumb`, `backup-metadata`,
-`helper list-missing-thumbnails` and `helper fix-missing-thumbnails` — force a
-fresh server round-trip before they 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. `--cache-dir` overrides where the
-cache lives; without it each account gets its own directory under the per-user
-cache path.
+`collections`, `files`, `get`, and `get-thumb` — force a fresh server round-trip
+before they answer, so they report current account state rather than whatever
+the cache last held. `--cache-dir` overrides where the cache lives; without it
+each account gets its own directory under the per-user cache path.
 
 `get` and `get-thumb` resolve the file by ID directly, so `--collection` is
-accepted for backward compatibility but ignored. For a live photo, `get` writes
-its image and its video, each named after the title with its own extension, as
-Ente's clients name them (`IMG_0001.heic` and `IMG_0001.mov`). With
-`--out PATH`, the image is written to `PATH` and the video beside it, with
-`PATH`'s name and the video's extension; a `PATH` with the video's extension is
-refused. `backup-metadata --exif` (alias `--all`) additionally downloads each
-file to extract full EXIF/IPTC/XMP metadata. The listing and backup commands
-support `--json` for machine-readable output.
+accepted for backward compatibility but ignored. `backup-metadata --exif` (alias
+`--all`) additionally downloads each file to extract full EXIF/IPTC/XMP
+metadata. The listing and backup commands support `--json` for machine-readable
+output.
 
 `backup-metadata` fetches ML data in requests of up to 200 files. When a request
 still fails after its retries, the error is logged, each of its files is written
@@ -503,41 +484,22 @@ the smallest does not.
 ```
 <dir>/
     originals/
-        <fileID>.<ext>          actual file content (one per unique file,
-                                two for a live photo: see below)
+        <fileID>.<ext>          actual file content (one per unique file)
         <fileID>.json           all decrypted metadata for that file
-        <fileID>.livephoto.json which of a live photo's two files is which
     collections/
         <name>/
             <title> -> ../../originals/<fileID>.<ext>   (symlink)
         <name>.json             collection metadata + file list
-    failures.json               files that failed and have not yet succeeded
 ```
 
-`failures.json` records each failed file with the kind of failure, how many
-times it has been tried and when it was last tried. A file leaves it once it
-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 `originals/`; `quak backup` does not.
-
 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
-name (ignoring case in both), each of them gets its ID added: two albums named
+collections would get the same name, or two files in one collection the same
+title (ignoring case in both), each of them gets its ID added: two albums named
 `Trip` become `Trip (10)/` and `Trip (11)/`, and two files titled `IMG_0001.JPG`
 become `IMG_0001 (12345).JPG` and `IMG_0001 (12346).JPG`. IDs never change, so a
 name stays the same from run to run until such a clash appears or goes away.
 
-A live photo, which Ente stores as one ZIP of its image and its video, is stored
-as those two files, which a photo viewer can open: each is
-`originals/<fileID>.<ext>` with the extension it has inside the ZIP (for example
-`12345.heic` and `12345.mov`), and `<fileID>.livephoto.json` names the two. The
-live photo counts as stored only when both files are present and not empty. Its
-album folder links both, each named after the title with that file's extension
-(`IMG_0001.heic` and `IMG_0001.mov`). A live photo that an earlier version of
-quak stored as the ZIP, under the image's name, is replaced by its two files on
-the next run, and the ZIP and its link are removed.
-
 Each run removes the symlinks into `originals/` that no longer belong in their
 collection's directory, and the directories (and JSON) of collections that were
 deleted or renamed. Nothing else in `collections/` is touched: a file or a
@@ -545,23 +507,17 @@ 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 into `originals/`, with no copy left in
-the cache. An original the cache already held is copied from there instead. On
-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 it fetches only what the backup stores.
+appears in. On 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.
 
-Each original is written to a temporary file in the same directory, synced to
-disk, and renamed into place, so an original is either complete or absent, even
-after a power cut. A downloaded original's temporary file is named
-`.quak-<pid>-<random>.tmp`, one copied from the cache
-`.quak-backup-<fileID>.<ext>-<pid>-<random>.tmp`. A run that is killed can leave
-one of these temporary files behind; the next backup deletes those whose process
-is no longer running. The content cache uses the same scheme, and opening a
-library deletes the temporary files in the cache whose process is no longer
-running, so a download another process has in progress in the same cache is left
-alone. The rename replaces whatever was at the destination rather than writing
+Each original is copied to a temporary file named
+`.quak-backup-<fileID>.<ext>-<pid>-<random>.tmp` in the same directory, synced
+to disk, and renamed into place, so an original is either complete or absent,
+even after a power cut. A run that is killed can leave one of these temporary
+files behind; the next backup deletes those whose process is no longer running.
+Downloads and the content cache use the same scheme with `.quak-<random>.tmp`
+names. The rename replaces whatever was at the destination rather than writing
 through it: a symlink there is replaced, not followed, and the new file has the
 temporary file's permissions, not those of the file it replaced.
 
@@ -571,12 +527,7 @@ temporary file's permissions, not those of the file it replaced.
       errors
 - [x] Update the API reference section below to match the current implementation
 - [x] `make docker` green
-- [x] Store live photos in a form a photo viewer can open
-      (https://git.eeqj.de/sneak/quak/issues/107): unpacked into the image and
-      the video
-
-Tagging and releases are decided by sneak alone, and happen only when he
-declares one.
+- [ ] Tag `v1.0.0`
 
 Future (desktop client, separate repo):
 
@@ -596,11 +547,10 @@ test suite is the canonical, executable documentation — `test/library/` and
 ### Opening a library
 
 `Library.open(options)` loads the on-disk cache, starts the background refresh
-loop, and resolves to a `Library`. On an empty cache it awaits the first
-refresh, so it opens onto the account's data whenever the server is reachable;
-if that refresh fails, it opens with no data and records the error in
-`lib.status()`. On an existing cache it returns immediately and refreshes in the
-background, so an unreachable server does not block opening.
+loop, and resolves to a `Library`. On an empty cache it awaits the first refresh
+so it never opens onto empty data; on an existing cache it returns immediately
+and refreshes in the background, so an unreachable server does not block
+opening.
 
 `LibraryOptions`:
 
@@ -665,9 +615,7 @@ An `Album` exposes its record fields and `album.photos.list()` → `Photo[]`
 (newest first). A `Photo` exposes its record fields, `photo.record()` →
 `PhotoRecord`, and two content methods:
 
-- `await photo.original(opts?)` → `{ path, bytes, videoPath? }` — the
-  full-resolution file. For a live photo, `path` and `bytes` are its image's and
-  `videoPath` is its video.
+- `await photo.original(opts?)` → `{ path, bytes }` — the full-resolution file.
 - `await photo.thumbnail(opts?)` → `{ path, bytes }`.
 
 Both serve from the on-disk content cache when the bytes are present and
@@ -687,7 +635,7 @@ The GUI-facing records hold no key material and no binary, so they survive
 - `PhotoRecord`: `fileID`, `albumIDs`, `title`, `takenAt` (milliseconds),
   `fileType`, optional `caption` / `width` / `height` / `latitude` /
   `longitude`, `isArchived`, `isHidden`, and `thumbnailPath` / `originalPath`
-  once the bytes are cached (for a live photo, `originalPath` is its image).
+  once the bytes are cached.
 - `AlbumRecord`: `collectionID`, `name`, `type`, `isShared`, `updationTime`, and
   `fileIDs` (newest first).
 - `LibrarySnapshot`: `{ albums, photos, takenAt }`.
@@ -713,15 +661,12 @@ photos newest first). `lib.subscribe({ onChange })` delivers a `LibraryChange`
   default limit 20). quak bundles no text encoder, so `searchByEmbedding` takes
   a query vector the caller produced elsewhere.
 - `await lib.backup(opts?)` → `BackupResult`. It refreshes, fetches every
-  in-scope original not already in the backup (and, with `includeThumbnails`,
-  thumbnails) through the content cache, and rebuilds the on-disk backup tree
-  with a durable failure ledger. A fetched original is written straight into the
-  backup's `originals/` 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 one `open()` was given),
-  `includeOriginals` (default `true`), `includeThumbnails` (default `false`),
-  `onlyAlbumNames`, and `onProgress`. See Backup layout above for the tree it
-  writes.
+  in-scope original (and, with `includeThumbnails`, thumbnails) through the
+  content cache, and rebuilds the on-disk backup tree with a durable failure
+  ledger. `BackupOptions`: `downloadDirectory` (falls back to the one `open()`
+  was given), `includeOriginals` (default `true`), `includeThumbnails` (default
+  `false`), `onlyAlbumNames`, and `onProgress`. See Backup layout above for the
+  tree it writes.
 
 ### Request pools
 
@@ -738,8 +683,6 @@ Under `cacheDirectory`:
 <cacheDirectory>/
     metadata.json                 decrypted account state + refresh cursor
     originals/<fileID>.<ext>      cached full-resolution files
-    originals/<fileID>.livephoto.json
-                                  which of a live photo's two files is which
     thumbnails/<fileID>.jpg       cached thumbnails
     mldata/
         <fileID>.json             one decrypted ML payload per file
@@ -752,21 +695,14 @@ When `metadata.json` belongs to a different account than the client's,
 originals and thumbnails are kept; they are reached only through the files the
 current account's records name.
 
-A live photo's original is cached as in the backup: its image and its video,
-each `originals/<fileID>.<ext>` with its own extension, and
-`originals/<fileID>.livephoto.json` naming them; the two are evicted together. A
-live photo that an earlier version cached as its ZIP is not served, and is
-replaced by its two files the next time it is read.
-
 A stored file appears only via an atomic temp-then-rename, so its presence means
 it is complete. Every downloaded original (by `quak get`, the cache, or
 `backup`) whose metadata records a content hash (`FileMetadata.hash`) is hashed
-as it is written: unkeyed BLAKE2b with a 64-byte output, standard base64. A live
-photo arrives as a ZIP and is unpacked as it is written; its image and its video
-are hashed separately and joined as `<imageHash>:<videoHash>`, and neither is
-stored unless both are complete and match. A mismatch stores nothing and fails
-the download with an error naming the file ID. An original with no recorded
-hash, from a very old client, is stored unchecked.
+as it is written: unkeyed BLAKE2b with a 64-byte output, standard base64. For a
+live photo, which is stored as a ZIP, the image and the video are hashed
+separately and joined as `<imageHash>:<videoHash>`. A mismatch stores nothing
+and fails the download with an error naming the file ID. An original with no
+recorded hash, from a very old client, is stored unchecked.
 
 ### Key types by source file
 
@@ -827,10 +763,8 @@ documents:
   markdown. Use `make fmt` to format. Use `yarn` not `npm`.
 
 - **Testing:** vitest. Tests go in `test/` mirroring the `src/` structure.
-  `make test` must finish in under 60 seconds (the hard cap) and should finish
-  in under 20. The 90-second `timeout` in the `test` phase of the `Dockerfile`
-  is a backstop that catches a hung test, not the time limit. Use `mkdtempSync`
-  for temporary directories, never manual timestamp paths.
+  `make test` must complete in under 20 seconds. Use `mkdtempSync` for temporary
+  directories, never manual timestamp paths.
 
 - **Code style:** `const` for everything, `let` if reassignment is needed, never
   `var`. Avoid unnecessary comments. No hand-rolled crypto. The

TODO.md

@@ -14,81 +14,10 @@ pre-1.0
 
 # Next Step
 
-None: every issue still open is done on `next` or `next2` and waits for it to
-reach `main`.
-
-Tagging and releases are decided by sneak alone, and happen only when he
-declares one.
+Tag v1.0.0.
 
 # Completed Steps
 
-- 2026-09-23: Live photos are stored as their image and their video (issue 107).
-  A live photo, which Ente stores as one ZIP, is unpacked as it downloads into
-  `<fileID>.<ext>` for the image and for the video, each with its extension from
-  the ZIP, beside `<fileID>.livephoto.json`, which names the two. Both are
-  checked against the recorded hash and renamed into place only when both are
-  complete. The backup and the content cache count the live photo as stored only
-  with both files, the album folder links both, `quak get` writes both, and the
-  content result gives the video as `videoPath`. A ZIP an earlier version stored
-  is replaced on the next backup run, and in the cache when the photo is next
-  read.
-
-- 2026-09-23: Settled the package metadata (issue 6). quak is not published, so
-  `package.json` is marked `"private": true` and the `files` field is gone.
-  `engines.node` is `>=22`, the major version `script/bootstrap` and the
-  `Dockerfile` use. An `exports` map makes `.` and `./package.json` the only
-  importable paths; `runMetadataBackup`, the thumbnail helpers and their types
-  stay internal to the CLI.
-
-- 2026-09-23: Brought the README and this file in line with the tree (issue
-  111). The layout lists `src/library/` and the other source files, the backup
-  layout names `failures.json` and the optional `thumbnails/`, "Opening a
-  library" says what happens when the first refresh fails, the Testing section
-  gives the 60-second hard cap and 20-second target for `make test` and names
-  the 90-second `timeout` in the `Dockerfile` as the backstop for a hung test,
-  and "Tag v1.0.0" is no longer listed as the next step.
-
-- 2026-09-23: Tested `quak login` and `backup-metadata --exif` (issue 110).
-  `loginCommand` takes its login function and its prompts from `CliContext`, and
-  `bin/quak.ts` passes `Client.login` and the terminal prompts. Tests cover a
-  login from `QUAK_EMAIL` and `QUAK_PASSWORD` with no prompt, the TOTP prompt, a
-  failed login, and the saved session's modes, and show that `--exif` and
-  `--all` each turn on EXIF extraction and that it is off without them.
-
-- 2026-09-23: `quak backup` writes each original once and no longer fills the
-  cache (issue 106). An original fetched for a backup is written by the download
-  writer straight into the backup's `originals/`, and the content cache records
-  it there instead of keeping its own copy; one the cache already held is still
-  copied. `quak backup` opens its library with the thumbnail and originals
-  precache off.
-
-- 2026-09-23: `backup-metadata`, `helper list-missing-thumbnails` and
-  `helper fix-missing-thumbnails` refresh before they answer (issue 100). Each
-  awaits `lib.fresh()` before reading, so a file added since the cache was
-  written is included, and a failed refresh prints one line and exits 1 instead
-  of answering from a stale or empty cache. The README lists them among the
-  commands that refresh first.
-
-- 2026-09-23: `quak backup` waits for the server refresh and fails when it fails
-  (issue 99). `lib.backup()` joins a refresh already running or starts one, as
-  `fresh()` does, and rejects before touching any file when it fails, leaving
-  `failures.json` as it was, so `quak backup` prints the error as one line and
-  exits 1 instead of backing up the previous run's file list, or nothing, and
-  exiting 0.
-
-- 2026-09-23: CLI errors print a message instead of a stack trace (issue 102).
-  An error a command throws is printed as one `quak: MESSAGE` line on stderr and
-  the CLI exits 1 once output has drained. The wrapper that does this moved from
-  `bin/quak.ts` to `src/cli-run.ts`, and `bin/quak.ts` now awaits
-  `program.parseAsync()`.
-
-- 2026-09-23: Opening a library no longer deletes another process's download in
-  progress (issue 105). The download writer's temp files are named
-  `.quak-<pid>-<random>.tmp`, and `removeLeftoverTempFiles`, moved from the
-  backup into the download module, deletes a `.quak-*.tmp` file only when the
-  process ID in its name is no longer running. The content cache calls it at
-  `open()` for `originals/` and `thumbnails/`, the backup as before.
-
 - 2026-09-23: Re-vendored the lint and test setup from the template (issue 96).
   Linting and testing are the `lint` and `test` phases of the `Dockerfile`;
   `script/lint` and `script/test` each build one with `--no-cache`, and the last

bin/quak.ts

@@ -1,7 +1,6 @@
 #!/usr/bin/env node
 
 import { stdout, stderr } from "node:process";
-import { input, password } from "@inquirer/prompts";
 import { Command } from "commander";
 import envPaths from "env-paths";
 import { init } from "../src/crypto/index.js";
@@ -19,9 +18,7 @@ import {
     listMissingThumbnailsCommand,
     fixMissingThumbnailsCommand,
 } from "../src/cli-commands.js";
-import { run as runCommand } from "../src/cli-run.js";
 import { loadSession } from "../src/cli-session.js";
-import { Client } from "../src/client.js";
 import { VERSION } from "../src/index.js";
 
 const paths = envPaths("quak", { suffix: "" });
@@ -44,13 +41,25 @@ const context = (): CliContext => ({
     sessionDir: paths.data,
     cacheDir: program.opts<{ cacheDir?: string }>().cacheDir,
     loadSession,
-    login: (opts) => Client.login(opts),
-    prompt: (message) => input({ message }),
-    promptSecret: (message) => password({ message, mask: true }),
 });
 
-const run = (command: Promise<number>): Promise<void> =>
-    runCommand(command, stdout, stderr, (code) => process.exit(code));
+// Run a command and exit with its code once stdout/stderr have drained.
+// Exiting before the drain can truncate piped output, and the library can keep
+// the event loop alive after a command returns, so a plain return could hang.
+const run = async (command: Promise<number>): Promise<void> => {
+    process.exitCode = await command;
+    const pending = [stdout, stderr].filter((s) => s.writableLength > 0);
+    if (pending.length === 0) {
+        process.exit();
+        return;
+    }
+    let remaining = pending.length;
+    for (const s of pending) {
+        s.once("drain", () => {
+            if (--remaining === 0) process.exit();
+        });
+    }
+};
 
 program
     .command("login")
@@ -160,4 +169,4 @@ helper
     );
 
 await init();
-await program.parseAsync();
+program.parse();

package.json

@@ -9,23 +9,17 @@
         "type": "git",
         "url": "https://git.eeqj.de/sneak/quak.git"
     },
-    "private": true,
     "type": "module",
-    "engines": {
-        "node": ">=22"
-    },
     "main": "./dist/src/index.js",
     "types": "./dist/src/index.d.ts",
-    "exports": {
-        ".": {
-            "types": "./dist/src/index.d.ts",
-            "import": "./dist/src/index.js"
-        },
-        "./package.json": "./package.json"
-    },
     "bin": {
         "quak": "./dist/bin/quak.js"
     },
+    "files": [
+        "dist/",
+        "README.md",
+        "LICENSE"
+    ],
     "scripts": {
         "build": "script/build",
         "quak": "node ./dist/bin/quak.js",

src/backup.ts

@@ -1,11 +1,9 @@
 // The backup command, rebuilt on the library API (issue #51).
 //
-// `lib.backup()` 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,
-// gets its original bytes onto disk under `downloadDirectory` and rebuilds the
-// derived views (per-file sidecars, per-collection symlink trees,
-// per-collection JSON) from the model. The on-disk layout is the historical
-// one:
+// `lib.backup()` refreshes the library, then, for every file in scope, gets its
+// original bytes onto disk under `downloadDirectory` and rebuilds the derived
+// views (per-file sidecars, per-collection symlink trees, per-collection JSON)
+// from the model. The on-disk layout is the historical one, unchanged:
 //
 //     <downloadDirectory>/
 //         originals/<fileID>.<ext>     the decrypted bytes
@@ -14,10 +12,6 @@
 //         collections/<name>.json      per-collection metadata
 //         failures.json                durable ledger of unresolved failures
 //
-// A live photo's original is its image and its video, `<fileID>.<ext>` each
-// with its own extension, and `originals/<fileID>.livephoto.json` naming them;
-// its album folders link both.
-//
 // Crash-safety rests on two properties. Bytes are present-means-complete: an
 // original appears under `originals/` only via the content layer's atomic
 // temp-then-rename, so a file that exists is whole and is never re-fetched — an
@@ -51,13 +45,8 @@ import {
 import { copyFile, rename, rm } from "node:fs/promises";
 import { basename, dirname, extname, join, relative } from "node:path";
 
-import { fsyncPath, removeLeftoverTempFiles } from "./download/index.js";
-import { sanitizeFileName, withExtension } from "./filename.js";
-import {
-    originalName,
-    storedOriginal,
-    writeLivePhoto,
-} from "./library/content.js";
+import { fsyncPath } from "./download/index.js";
+import { safeExtension, sanitizeFileName } from "./filename.js";
 import type { Collection, EnteFile } from "./model/types.js";
 
 export type ProgressCallback = (message: string) => void;
@@ -106,14 +95,8 @@ export interface BackupLibrary {
     listCollections(): Collection[];
     listFiles(collectionID: number): EnteFile[];
     // Get an original's bytes onto disk through the content cache/pools,
-    // returning where they landed: `destination` when they were fetched now,
-    // otherwise wherever they already were (the cache, or a prior backup). A
-    // live photo lands as its image and its video, fetched now beside
-    // `destination`.
-    original(
-        fileID: number,
-        destination: string,
-    ): Promise<{ path: string; videoPath?: string }>;
+    // returning where they landed (the cache, or a prior backup).
+    original(fileID: number): Promise<{ path: string }>;
     thumbnail(fileID: number): Promise<{ path: string }>;
 }
 
@@ -130,6 +113,12 @@ interface FailureEntry {
 
 const LEDGER_VERSION = 1;
 
+// The originals/ filename for a file: `<id><ext>`, the extension taken from the
+// title (or `.bin`). Matches the content cache's own naming so a present check
+// lines up with what a fetch would write.
+const originalName = (file: EnteFile): string =>
+    `${file.id}${safeExtension(file.metadata.title)}`;
+
 // A regular file with content is treated as complete. A zero-byte file is not:
 // it is the shape an aborted write leaves and must be re-fetched.
 const isPresent = (path: string): boolean => {
@@ -195,29 +184,34 @@ const copyAtomic = async (src: string, dest: string): Promise<void> => {
     }
 };
 
-// Put an original the library returned at `dest` in originals/, where a fresh
-// fetch already wrote it. A live photo's image and video go beside `dest`: when
-// they came from the cache they are copied, after removing whatever was at
-// `dest` (an earlier version's ZIP of the two). Then the JSON file naming them
-// is written, which is what makes the live photo count as stored.
-const placeOriginal = async (
-    file: EnteFile,
-    dest: string,
-    got: { path: string; videoPath?: string },
-): Promise<void> => {
-    if (got.videoPath === undefined) {
-        await copyAtomic(got.path, dest);
+// A process-ID check: signal 0 delivers nothing and only reports whether the
+// process exists. EPERM means it exists but belongs to another user.
+const isRunning = (pid: number): boolean => {
+    try {
+        process.kill(pid, 0);
+        return true;
+    } catch (err) {
+        return (err as NodeJS.ErrnoException).code === "EPERM";
+    }
+};
+
+// Delete the temp files `copyAtomic` leaves behind when a backup is killed
+// before its rename. Only files whose process is no longer running are
+// removed, so a backup running at the same time keeps its own. A reused
+// process ID can only keep a leftover a while longer, never remove a live one.
+const removeLeftoverTempFiles = (dir: string): void => {
+    let names: string[];
+    try {
+        names = readdirSync(dir);
+    } catch {
         return;
     }
-    const originalsDir = dirname(dest);
-    const path = join(originalsDir, basename(got.path));
-    const videoPath = join(originalsDir, basename(got.videoPath));
-    if (got.path !== path) {
-        await rm(dest, { force: true });
-        await copyAtomic(got.path, path);
-        await copyAtomic(got.videoPath, videoPath);
+    for (const name of names) {
+        const match = /^\.quak-backup-.*-(\d+)-[0-9a-z]*\.tmp$/.exec(name);
+        if (match && !isRunning(Number(match[1]))) {
+            rmSync(join(dir, name), { force: true });
+        }
     }
-    await writeLivePhoto(originalsDir, file.id, { path, videoPath });
 };
 
 // Ensure `linkPath` is a symlink to `target`, rebuilding a missing, wrong, or
@@ -236,61 +230,43 @@ const rebuildSymlink = (linkPath: string, target: string): void => {
     symlinkSync(target, linkPath);
 };
 
-// The on-disk names for the entries of one directory, in entry order. Each
-// name is used as is unless another entry would get the same name, ignoring
-// case (two names that differ only in case are one entry on a case-insensitive
+// The on-disk names for the entries of one directory, keyed by ID. Each name
+// is used as is unless another entry would get the same name, ignoring case
+// (two names that differ only in case are one entry on a case-insensitive
 // file system); then every entry sharing it gets ` (<id>)`, before the
 // extension when `beforeExtension` is set. A name with an ID added can match
 // another entry's own name (`IMG (6).JPG`), so this repeats until no name is
 // shared. IDs are stable, so the names are too.
-const uniqueNames = (
+const namesByID = (
     entries: { id: number; name: string }[],
     beforeExtension: boolean,
-): string[] => {
+): Map<number, string> => {
     const withID = (id: number, name: string): string => {
         const ext = beforeExtension ? extname(name) : "";
         const stem = name.slice(0, name.length - ext.length);
         return `${stem} (${id})${ext}`;
     };
-    const names = entries.map((e) => e.name);
+    const names = new Map<number, string>();
+    for (const { id, name } of entries) names.set(id, name);
     const suffixed = new Set<number>();
     for (;;) {
         const counts = new Map<string, number>();
-        for (const name of names) {
+        for (const name of names.values()) {
             const key = name.toLowerCase();
             counts.set(key, (counts.get(key) ?? 0) + 1);
         }
         let changed = false;
-        for (const [i, { id, name }] of entries.entries()) {
-            if (suffixed.has(i)) continue;
+        for (const { id, name } of entries) {
+            if (suffixed.has(id)) continue;
             if (counts.get(name.toLowerCase()) === 1) continue;
-            names[i] = withID(id, name);
-            suffixed.add(i);
+            names.set(id, withID(id, name));
+            suffixed.add(id);
             changed = true;
         }
         if (!changed) return names;
     }
 };
 
-// The links a file gets in its album's folder: one named after its title, to
-// its original if that is stored. A stored live photo gets two, to its image
-// and its video, each named after the title with that file's extension.
-const linksFor = (
-    file: EnteFile,
-    stored: { path: string; videoPath?: string } | undefined,
-): { id: number; name: string; file: EnteFile; target?: string }[] => {
-    const name = sanitizeFileName(file.metadata.title, `file-${file.id}`);
-    if (stored?.videoPath === undefined) {
-        return [{ id: file.id, name, file, target: stored?.path }];
-    }
-    return [stored.path, stored.videoPath].map((target) => ({
-        id: file.id,
-        name: withExtension(name, extname(target)),
-        file,
-        target,
-    }));
-};
-
 // Remove the symlinks in the album directory `dir` that point into
 // `originalsDir` and are not named in `keep`. Nothing else in the directory
 // is touched: anything else there was put there by the user.
@@ -470,21 +446,15 @@ export const runBackup = async (
     // tree; a present file is left as is.
     if (includeOriginals) {
         for (const [fileID, file] of distinct) {
-            if (storedOriginal(originalsDir, file) !== undefined) {
+            const dest = join(originalsDir, originalName(file));
+            if (isPresent(dest)) {
                 skipped++;
                 continue;
             }
-            const dest = join(originalsDir, originalName(file));
             try {
                 log(`Fetching original ${file.metadata.title} (${fileID})...`);
-                // A fetched original is written straight to `dest` (a live
-                // photo beside it); only one that was already cached elsewhere
-                // is copied.
-                await placeOriginal(
-                    file,
-                    dest,
-                    await lib.original(fileID, dest),
-                );
+                const { path } = await lib.original(fileID);
+                await copyAtomic(path, dest);
                 downloaded++;
             } catch (err) {
                 log(
@@ -520,7 +490,8 @@ export const runBackup = async (
     // every present original (this repairs stale ones).
     if (includeOriginals) {
         for (const [fileID, file] of distinct) {
-            if (storedOriginal(originalsDir, file) !== undefined) {
+            const orig = join(originalsDir, originalName(file));
+            if (isPresent(orig)) {
                 writeSidecar(join(originalsDir, `${fileID}.json`), file);
             }
         }
@@ -532,18 +503,19 @@ export const runBackup = async (
     // an album it skipped. Stale entries are removed before anything is
     // rebuilt, so on a case-insensitive file system removing an old name can
     // never remove the new one.
-    const dirNames = uniqueNames(
+    const albumDirNames = namesByID(
         allCollections.map((c) => ({
             id: c.id,
             name: sanitizeFileName(c.name, `collection-${c.id}`),
         })),
         false,
     );
-    const albumDirNames = new Map(
-        allCollections.map((c, i) => [c.id, dirNames[i]!]),
-    );
     try {
-        removeStaleAlbumDirs(collectionsDir, new Set(dirNames), originalsDir);
+        removeStaleAlbumDirs(
+            collectionsDir,
+            new Set(albumDirNames.values()),
+            originalsDir,
+        );
     } catch (err) {
         log(`FAILED removing old album directories: ${errorMessage(err)}`);
     }
@@ -554,33 +526,34 @@ export const runBackup = async (
         mkdirSync(colDir, { recursive: true });
 
         const files = filesByCollection.get(c.id) ?? [];
-        const links = files.flatMap((f) =>
-            linksFor(f, storedOriginal(originalsDir, f)),
+        const linkNames = namesByID(
+            files.map((f) => ({
+                id: f.id,
+                name: sanitizeFileName(f.metadata.title, `file-${f.id}`),
+            })),
+            true,
         );
-        const linkNames = uniqueNames(links, true);
         try {
-            removeStaleLinks(colDir, new Set(linkNames), originalsDir);
+            removeStaleLinks(colDir, new Set(linkNames.values()), originalsDir);
         } catch (err) {
             log(`FAILED removing old links in ${c.name}: ${errorMessage(err)}`);
         }
 
-        const metaFiles = files.map((f) => ({
-            id: f.id,
-            metadata: f.metadata,
-        }));
-        for (const [i, link] of links.entries()) {
-            if (!includeOriginals || link.target === undefined) continue;
-            const linkName = linkNames[i]!;
+        const metaFiles: { id: number; metadata: EnteFile["metadata"] }[] = [];
+        for (const file of files) {
+            metaFiles.push({ id: file.id, metadata: file.metadata });
+            if (!includeOriginals) continue;
+            const orig = join(originalsDir, originalName(file));
+            if (!isPresent(orig)) continue;
+            const linkName = linkNames.get(file.id)!;
+            const linkPath = join(colDir, linkName);
             try {
-                rebuildSymlink(
-                    join(colDir, linkName),
-                    relative(colDir, link.target),
-                );
+                rebuildSymlink(linkPath, relative(colDir, orig));
             } catch (err) {
                 log(
                     `FAILED symlink ${c.name}/${linkName}: ${errorMessage(err)}`,
                 );
-                recordFailure(link.file, c.name, err);
+                recordFailure(file, c.name, err);
             }
         }
 

src/cli-commands.ts

@@ -2,24 +2,20 @@
 //
 // Each command takes its options and a `CliContext` and resolves to the exit
 // code; a thrown error is left to the caller. Nothing here calls
-// `process.exit`: `bin/quak.ts` wires these to the command line, and `run` in
-// `cli-run.ts` prints a thrown error as one line and exits once output has
-// drained. Output must stay byte-identical (see `cli-output.ts`).
+// `process.exit`: `bin/quak.ts` wires these to the command line and exits with
+// the returned code once output has drained. Output must stay byte-identical
+// (see `cli-output.ts`).
 
+import { input, password as passwordPrompt } from "@inquirer/prompts";
 import {
     copyFileSync,
     existsSync,
     mkdirSync,
-    statSync,
     unlinkSync,
     writeFileSync,
 } from "node:fs";
-import { extname, join } from "node:path";
-import {
-    type Client,
-    type ClientSnapshot,
-    type LoginOptions,
-} from "./client.js";
+import { join } from "node:path";
+import { Client, type ClientSnapshot } from "./client.js";
 import { init } from "./crypto/index.js";
 import {
     defaultCacheDirectory,
@@ -33,7 +29,6 @@ import {
     thumbnailName,
 } from "./cli-output.js";
 import { freshCollections, freshFiles, freshFile } from "./cli-read.js";
-import { withExtension } from "./filename.js";
 import { runMetadataBackup } from "./metadata-backup.js";
 import { listMissingThumbnails, fixMissingThumbnails } from "./thumbnails.js";
 
@@ -48,12 +43,6 @@ export interface CliContext {
     // Reads the session file into a client, or null when there is none. The
     // CLI passes `loadSession` from `cli-session.ts`; tests pass a fake client.
     loadSession: (path: string) => Client | null;
-    // Used by `login` only. The CLI passes `Client.login` and terminal
-    // prompts; tests pass fakes.
-    login: (opts: LoginOptions) => Promise<Client>;
-    prompt: (message: string) => Promise<string>;
-    // Like `prompt`, but the answer is masked as it is typed.
-    promptSecret: (message: string) => Promise<string>;
 }
 
 const sessionPath = (ctx: CliContext): string =>
@@ -119,19 +108,24 @@ const openReadLibrary = (ctx: CliContext, client: Client): Promise<Library> =>
         precacheOriginals: false,
     });
 
+const prompt = async (message: string): Promise<string> => input({ message });
+
+const promptSecret = async (message: string): Promise<string> =>
+    passwordPrompt({ message, mask: true });
+
 export const loginCommand = async (ctx: CliContext): Promise<number> => {
     await init();
-    const email = process.env.QUAK_EMAIL ?? (await ctx.prompt("Email"));
+    const email = process.env.QUAK_EMAIL ?? (await prompt("Email"));
     const password =
-        process.env.QUAK_PASSWORD ?? (await ctx.promptSecret("Password"));
+        process.env.QUAK_PASSWORD ?? (await promptSecret("Password"));
 
     ctx.stderr.write("Authenticating...\n");
     try {
-        const client = await ctx.login({
+        const client = await Client.login({
             email,
             password,
-            totp: async () => ctx.prompt("TOTP code: "),
-            emailOTP: async () => ctx.prompt("Email verification code: "),
+            totp: async () => prompt("TOTP code: "),
+            emailOTP: async () => prompt("Email verification code: "),
         });
 
         saveSession(ctx.sessionDir, client.toJSON());
@@ -307,30 +301,9 @@ export const getCommand = async (
         // Default name is the file's own title, as the pre-library CLI used
         // (not the editedName-preferring projection title) (issue #52).
         const outPath = opts.out ?? originalName(file);
-        if (result.videoPath === undefined) {
         copyFileSync(result.path, outPath);
         ctx.stderr.write(`${result.bytes} bytes -> ${outPath}\n`);
         return 0;
-        }
-        // A live photo is written as its image and its video, each named after
-        // the title with its own extension, as Ente's clients name them. With
-        // --out, the image goes there and the video beside it.
-        const imageOut =
-            opts.out ?? withExtension(outPath, extname(result.path));
-        const videoOut = withExtension(outPath, extname(result.videoPath));
-        if (imageOut.toLowerCase() === videoOut.toLowerCase()) {
-            ctx.stderr.write(
-                `File ${fileID} is a live photo, and its video would also be written to ${imageOut}\n`,
-            );
-            return 1;
-        }
-        copyFileSync(result.path, imageOut);
-        copyFileSync(result.videoPath, videoOut);
-        ctx.stderr.write(
-            `${result.bytes} bytes -> ${imageOut}\n` +
-                `${statSync(videoOut).size} bytes -> ${videoOut}\n`,
-        );
-        return 0;
     } finally {
         await lib.close();
     }
@@ -383,9 +356,6 @@ export const backupMetadataCommand = async (
     if (!client) return 1;
     const lib = await openReadLibrary(ctx, client);
     try {
-        // Refresh first so the dump holds current account state, not what the
-        // cache last held; a failed refresh throws.
-        await lib.fresh();
         const { failedMLBatches } = await runMetadataBackup(lib, client, dir, {
             exif: opts.exif || opts.all,
             onProgress: (msg) => ctx.stderr.write(msg + "\n"),
@@ -406,14 +376,10 @@ export const backupCommand = async (
     if (!client) return 1;
 
     ctx.stderr.write("Starting backup...\n");
-    // The precache is off: the backup fetches what it needs, and must not
-    // also fill the cache with every thumbnail and the recent originals.
     const lib = await Library.open({
         client,
         downloadDirectory: dir,
         cacheDirectory: ctx.cacheDir,
-        precacheThumbnails: false,
-        precacheOriginals: false,
     });
     try {
         const result = await lib.backup({
@@ -456,9 +422,6 @@ export const listMissingThumbnailsCommand = async (
     if (!client) return 1;
     const lib = await openReadLibrary(ctx, client);
     try {
-        // Refresh first so files added since the cache was written are
-        // checked; a failed refresh throws.
-        await lib.fresh();
         const missing = await listMissingThumbnails(lib, client, (msg) => {
             if (!opts.json) ctx.stderr.write(msg + "\n");
         });
@@ -494,9 +457,6 @@ export const fixMissingThumbnailsCommand = async (
     if (!client) return 1;
     const lib = await openReadLibrary(ctx, client);
     try {
-        // Refresh first so files added since the cache was written are found;
-        // a failed refresh throws.
-        await lib.fresh();
         let fileIDs: number[];
         if (opts.file && opts.file.length > 0) {
             fileIDs = opts.file.map(Number).filter(Number.isFinite);

src/cli-run.ts

@@ -1,36 +0,0 @@
-// Runs one CLI command for `bin/quak.ts` and exits with its code.
-
-import type { Writable } from "node:stream";
-
-// Run a command and exit with its code once stdout/stderr have drained.
-// Exiting before the drain can truncate piped output, and the library can keep
-// the event loop alive after a command returns, so a plain return could hang.
-// An error the command throws is printed as one `quak: MESSAGE` line, without
-// the stack trace, and exits 1.
-export const run = async (
-    command: Promise<number>,
-    stdout: Writable,
-    stderr: Writable,
-    exit: (code: number) => void,
-): Promise<void> => {
-    let code: number;
-    try {
-        code = await command;
-    } catch (err) {
-        stderr.write(
-            `quak: ${err instanceof Error ? err.message : String(err)}\n`,
-        );
-        code = 1;
-    }
-    const pending = [stdout, stderr].filter((s) => s.writableLength > 0);
-    if (pending.length === 0) {
-        exit(code);
-        return;
-    }
-    let remaining = pending.length;
-    for (const s of pending) {
-        s.once("drain", () => {
-            if (--remaining === 0) exit(code);
-        });
-    }
-};

src/download/index.ts

@@ -1,5 +1,4 @@
-import { randomBytes } from "node:crypto";
-import { readdirSync, rmSync } from "node:fs";
+import { randomUUID } from "node:crypto";
 import { open, rename, rm } from "node:fs/promises";
 import type { FileHandle } from "node:fs/promises";
 import { dirname, join } from "node:path";
@@ -16,18 +15,14 @@ import {
     streamTagFinal,
 } from "../crypto/index.js";
 import { TruncatedStreamError } from "../errors.js";
-import { safeExtension, sanitizeFileName, withExtension } from "../filename.js";
+import { sanitizeFileName } from "../filename.js";
 import { withRetry } from "../retry.js";
 import type { ApiClient } from "../api/client.js";
 import type { EnteFile } from "../model/types.js";
 
 export interface DownloadResult {
-    // Where the file was written. A live photo is written as two files, its
-    // image here and its video at `videoPath` (see `decryptLivePhoto`).
     path: string;
-    // The decrypted length; for a live photo, that of the ZIP it arrives as.
     bytesWritten: number;
-    videoPath?: string;
 }
 
 // Fired as decrypted plaintext accumulates, with the running total of
@@ -49,9 +44,9 @@ const ENC_CHUNK_SIZE = STREAM_CHUNK_SIZE + STREAM_CHUNK_OVERHEAD;
 // new: a body cut short still decrypts and authenticates up to its last whole
 // chunk, so the absence of TAG_FINAL is the sole evidence it was cut short, and
 // this throws rather than let a caller keep a short file. The sink has already
-// seen those chunks by then; the callers (`decryptToTemp`, `decryptLivePhoto`)
-// stage them in temp files that are renamed into place only on a clean return,
-// so a throw leaves nothing on disk.
+// seen those chunks by then; the caller (`decryptToTemp`) stages them in a temp
+// file that is renamed into place only on a clean return, so a throw leaves
+// nothing on disk.
 const streamDecrypt = async (
     stream: ReadableStream<Uint8Array>,
     header: Uint8Array,
@@ -185,45 +180,6 @@ export const fsyncPath = async (path: string): Promise<void> => {
     }
 };
 
-// A process-ID check: signal 0 delivers nothing and only reports whether the
-// process exists. EPERM means it exists but belongs to another user.
-const isRunning = (pid: number): boolean => {
-    try {
-        process.kill(pid, 0);
-        return true;
-    } catch (err) {
-        return (err as NodeJS.ErrnoException).code === "EPERM";
-    }
-};
-
-// Delete the temp files a killed process left in `dir`: the writer's
-// `.quak-<pid>-<random>.tmp` and the backup copy's
-// `.quak-backup-<name>-<pid>-<random>.tmp`. Only files whose process is no
-// longer running are removed, so another process writing into the same
-// directory keeps its own. A reused process ID can only keep a leftover a while
-// longer, never remove a live one.
-export const removeLeftoverTempFiles = (dir: string): void => {
-    let names: string[];
-    try {
-        names = readdirSync(dir);
-    } catch {
-        return;
-    }
-    for (const name of names) {
-        const match = /^\.quak-(?:.*-)?(\d+)-[0-9a-z]*\.tmp$/.exec(name);
-        if (match && !isRunning(Number(match[1]))) {
-            rmSync(join(dir, name), { force: true });
-        }
-    }
-};
-
-// A new temp file name in `dir`. The random suffix keeps concurrent downloads
-// of the same destination from stepping on each other's temporary file; the
-// process ID lets `removeLeftoverTempFiles` tell a leftover from a write in
-// progress.
-const tempPathIn = (dir: string): string =>
-    join(dir, `.quak-${process.pid}-${randomBytes(16).toString("hex")}.tmp`);
-
 // Stage a write to `destination` atomically and durably, then rename it into
 // place. `fill` writes the contents into the open temp file handle — either the
 // whole buffer at once (`writeAtomic`) or chunk by chunk as they decrypt
@@ -248,7 +204,9 @@ const stageAtomic = async (
     fill: (handle: FileHandle) => Promise<void>,
 ): Promise<void> => {
     const dir = dirname(destination);
-    const tmpPath = tempPathIn(dir);
+    // The random suffix keeps concurrent downloads of the same destination
+    // from stepping on each other's temporary file.
+    const tmpPath = join(dir, `.quak-${randomUUID()}.tmp`);
     try {
         const handle = await open(tmpPath, "w");
         try {
@@ -283,14 +241,81 @@ export const writeAtomic = async (
 ): Promise<void> =>
     stageAtomic(destination, (handle) => handle.writeFile(plaintext));
 
-// Refuse an original whose bytes do not hash to what its uploader recorded.
-// The error is not retried.
-const checkHash = (file: EnteFile, actual: string): void => {
-    if (actual !== file.metadata.hash) {
-        throw new Error(
-            `download: file ${file.id}: content hash ${actual} does not match the hash its uploader recorded, ${file.metadata.hash}`,
+// Hashes an original's bytes as they are decrypted, for comparison with the
+// hash its uploader recorded.
+interface ContentHasher {
+    update: (plaintext: Uint8Array) => void;
+    digest: () => string;
+}
+
+const fileHasher = (): ContentHasher => {
+    const state = chunkHashInit();
+    return {
+        update: (plaintext) => chunkHashUpdate(state, plaintext),
+        digest: () => chunkHashFinal(state),
+    };
+};
+
+// A live photo is stored as a ZIP of its image and its video, and its recorded
+// hash is `<imageHash>:<videoHash>`, each over that part's own bytes. Like the
+// upstream client's decoder, this takes the first entries whose names start
+// with `image` and `video`.
+//
+// The ZIP is chosen by its uploader and may expand enormously, so entries are
+// hashed as they decompress and never held. fflate's `Unzip` inflates each
+// push in one piece, and deflate expands at most about 1000-fold, so the ZIP
+// is pushed in 4 KiB slices to keep each decompressed piece near 4 MiB, one
+// plaintext chunk. Every entry is started, even one that is not hashed,
+// because fflate keeps an unstarted entry's data in memory.
+const livePhotoHasher = (fileID: number): ContentHasher => {
+    const sliceSize = 4096;
+    const fail = (message: string, cause?: unknown): Error =>
+        new Error(`download: file ${fileID}: ${message}`, { cause });
+    const claimed = new Set<string>();
+    const hashes = new Map<string, string>();
+    const unzip = new Unzip((entry) => {
+        const part = ["image", "video"].find((p) => entry.name.startsWith(p));
+        const target =
+            part === undefined || claimed.has(part)
+                ? undefined
+                : { part, state: chunkHashInit() };
+        if (target !== undefined) claimed.add(target.part);
+        entry.ondata = (err, data, final) => {
+            if (err) throw err;
+            if (target === undefined) return;
+            chunkHashUpdate(target.state, data);
+            if (final) hashes.set(target.part, chunkHashFinal(target.state));
+        };
+        entry.start();
+    });
+    unzip.register(UnzipInflate);
+    // fflate reports a bad ZIP by throwing, sometimes a TypeError, which the
+    // retry would take for a network failure; a bad ZIP is never retried.
+    const push = (data: Uint8Array, final: boolean): void => {
+        try {
+            unzip.push(data, final);
+        } catch (err) {
+            throw fail("live photo is not a readable ZIP", err);
+        }
+    };
+    return {
+        update: (plaintext) => {
+            for (let i = 0; i < plaintext.length; i += sliceSize) {
+                push(plaintext.subarray(i, i + sliceSize), false);
+            }
+        },
+        digest: () => {
+            push(new Uint8Array(0), true);
+            const image = hashes.get("image");
+            const video = hashes.get("video");
+            if (image === undefined || video === undefined) {
+                throw fail(
+                    "live photo ZIP does not hold both an image and a video",
                 );
             }
+            return `${image}:${video}`;
+        },
+    };
 };
 
 // Decrypt `stream` straight to `destination`, one plaintext chunk at a time,
@@ -301,8 +326,9 @@ const checkHash = (file: EnteFile, actual: string): void => {
 // Returns the plaintext length written.
 //
 // `original` is the file whose original this is (none for a thumbnail, which
-// has no recorded hash). When its metadata has a hash, the decrypted bytes are
-// hashed as they stream and must match it, or nothing is stored.
+// has no recorded hash). When its metadata has a hash, the decrypted bytes
+// must match it or nothing is stored. Both a plain file and a live photo's
+// parts are hashed as they stream. The mismatch error is not retried.
 const decryptToTemp = async (
     destination: string,
     stream: ReadableStream<Uint8Array>,
@@ -311,175 +337,46 @@ const decryptToTemp = async (
     onProgress?: ProgressCallback,
     original?: EnteFile,
 ): Promise<number> => {
-    const hash =
-        original?.metadata.hash === undefined ? undefined : chunkHashInit();
+    const expected = original?.metadata.hash;
+    const hasher =
+        original === undefined || expected === undefined
+            ? undefined
+            : original.metadata.fileType === "livePhoto"
+              ? livePhotoHasher(original.id)
+              : fileHasher();
     let bytesWritten = 0;
+    try {
         await stageAtomic(destination, async (handle) => {
             bytesWritten = await streamDecrypt(
                 stream,
                 header,
                 key,
                 async (plaintext) => {
-                if (hash !== undefined) chunkHashUpdate(hash, plaintext);
+                    hasher?.update(plaintext);
                     await handle.write(plaintext);
                 },
                 onProgress,
             );
-        if (original !== undefined && hash !== undefined) {
-            checkHash(original, chunkHashFinal(hash));
+            if (original === undefined || hasher === undefined) return;
+            const actual = hasher.digest();
+            if (actual !== expected) {
+                throw new Error(
+                    `download: file ${original.id}: content hash ${actual} does not match the hash its uploader recorded, ${expected}`,
+                );
             }
         });
+    } catch (err) {
+        // Cancel the body so its connection is closed now rather than held
+        // until the stream is garbage collected. A backup run carries on past
+        // a failed file, so without this every failure would hold a socket.
+        // This covers every failure, including a temp file that cannot be
+        // opened and a header that is rejected before the body is read.
+        await stream.cancel(err).catch(() => undefined);
+        throw err;
+    }
     return bytesWritten;
 };
 
-// One of the two parts of a live photo being unpacked: the ZIP entry whose
-// name starts with `kind`, written to its own temp file.
-interface LivePhotoPart {
-    kind: "image" | "video";
-    tmpPath: string;
-    handle: FileHandle;
-    hash: ReturnType<typeof chunkHashInit>;
-    // Decompressed bytes not yet written.
-    pending: Uint8Array[];
-    // The entry's extension, set once all of the entry has been read.
-    ext?: string;
-}
-
-const openPart = async (
-    kind: "image" | "video",
-    dir: string,
-): Promise<LivePhotoPart> => {
-    const tmpPath = tempPathIn(dir);
-    const handle = await open(tmpPath, "w");
-    return { kind, tmpPath, handle, hash: chunkHashInit(), pending: [] };
-};
-
-// A live photo arrives as a ZIP of its image and its video. Ente's clients
-// name the entries `image.<ext>` and `video.<ext>`, and like the upstream
-// client's decoder this takes the first entries whose names start with `image`
-// and `video`. It is written unpacked: each part is named `destination` with
-// the extension replaced by its own entry's, and the two must differ ignoring
-// case. When the file records a hash, `<imageHash>:<videoHash>` must match it,
-// each over that part's own bytes. Only then is whatever was at `destination`
-// removed and the image, then the video, renamed into place; on any failure
-// neither is stored.
-//
-// The ZIP is chosen by its uploader and may expand enormously, so each part is
-// written as it decompresses and never held. fflate's `Unzip` inflates each
-// push in one piece before `push` returns, and deflate expands at most about
-// 1000-fold, so the ZIP is pushed in 4 KiB slices, keeping each decompressed
-// piece near 4 MiB, one plaintext chunk, and each piece is written before the
-// next slice is pushed. Every entry is started, even one that is not kept,
-// because fflate keeps an unstarted entry's data in memory.
-const decryptLivePhoto = async (
-    destination: string,
-    stream: ReadableStream<Uint8Array>,
-    header: Uint8Array,
-    key: Uint8Array,
-    onProgress: ProgressCallback | undefined,
-    file: EnteFile,
-): Promise<DownloadResult> => {
-    const sliceSize = 4096;
-    const dir = dirname(destination);
-    const fail = (message: string, cause?: unknown): Error =>
-        new Error(`download: file ${file.id}: ${message}`, { cause });
-    const parts: LivePhotoPart[] = [];
-    try {
-        const image = await openPart("image", dir);
-        parts.push(image);
-        const video = await openPart("video", dir);
-        parts.push(video);
-
-        const claimed = new Set<LivePhotoPart>();
-        const unzip = new Unzip((entry) => {
-            const part = parts.find(
-                (p) => !claimed.has(p) && entry.name.startsWith(p.kind),
-            );
-            if (part !== undefined) claimed.add(part);
-            entry.ondata = (err, data, final) => {
-                if (err) throw err;
-                if (part === undefined) return;
-                chunkHashUpdate(part.hash, data);
-                part.pending.push(data);
-                if (final) part.ext = safeExtension(entry.name);
-            };
-            entry.start();
-        });
-        unzip.register(UnzipInflate);
-        const push = async (
-            data: Uint8Array,
-            final: boolean,
-        ): Promise<void> => {
-            // fflate reports a bad ZIP by throwing, sometimes a TypeError,
-            // which the retry would take for a network failure; a bad ZIP is
-            // never retried.
-            try {
-                unzip.push(data, final);
-            } catch (err) {
-                throw fail("live photo is not a readable ZIP", err);
-            }
-            for (const part of parts) {
-                for (const piece of part.pending)
-                    await part.handle.write(piece);
-                part.pending = [];
-            }
-        };
-
-        const bytesWritten = await streamDecrypt(
-            stream,
-            header,
-            key,
-            async (plaintext) => {
-                for (let i = 0; i < plaintext.length; i += sliceSize) {
-                    await push(plaintext.subarray(i, i + sliceSize), false);
-                }
-            },
-            onProgress,
-        );
-        await push(new Uint8Array(0), true);
-
-        if (image.ext === undefined || video.ext === undefined) {
-            throw fail(
-                "live photo ZIP does not hold both an image and a video",
-            );
-        }
-        if (file.metadata.hash !== undefined) {
-            checkHash(
-                file,
-                `${chunkHashFinal(image.hash)}:${chunkHashFinal(video.hash)}`,
-            );
-        }
-        if (image.ext.toLowerCase() === video.ext.toLowerCase()) {
-            throw fail(
-                `live photo's image and video have the same extension, ${video.ext}`,
-            );
-        }
-        const path = withExtension(destination, image.ext);
-        const videoPath = withExtension(destination, video.ext);
-        for (const part of parts) {
-            await part.handle.sync();
-            await part.handle.close();
-        }
-        await rm(destination, { force: true });
-        await rename(image.tmpPath, path);
-        try {
-            await rename(video.tmpPath, videoPath);
-        } catch (err) {
-            await rm(path, { force: true }).catch(() => undefined);
-            throw err;
-        }
-        await fsyncPath(dir);
-        return { path, bytesWritten, videoPath };
-    } catch (err) {
-        // Best-effort cleanup, as in `stageAtomic`.
-        for (const part of parts) {
-            await part.handle.close().catch(() => undefined);
-            await rm(part.tmpPath, { force: true }).catch(() => undefined);
-        }
-        throw err;
-    }
-};
-
 // Fetch a stream and decrypt it to `destination`, retrying the whole sequence.
 //
 // The request is only the first third of a download. `getXStream` returns as
@@ -508,12 +405,10 @@ const fetchAndDecrypt = async (
     destination: string,
     onProgress?: ProgressCallback,
     original?: EnteFile,
-): Promise<DownloadResult> =>
+): Promise<number> =>
     withRetry(async () => {
         const stream = await openStream();
-        try {
-            if (original?.metadata.fileType === "livePhoto") {
-                return await decryptLivePhoto(
+        return decryptToTemp(
             destination,
             stream,
             header,
@@ -521,31 +416,8 @@ const fetchAndDecrypt = async (
             onProgress,
             original,
         );
-            }
-            const bytesWritten = await decryptToTemp(
-                destination,
-                stream,
-                header,
-                key,
-                onProgress,
-                original,
-            );
-            return { path: destination, bytesWritten };
-        } catch (err) {
-            // Cancel the body so its connection is closed now rather than held
-            // until the stream is garbage collected. A backup run carries on
-            // past a failed file, so without this every failure would hold a
-            // socket. This covers every failure, including a temp file that
-            // cannot be opened and a header that is rejected before the body
-            // is read.
-            await stream.cancel(err).catch(() => undefined);
-            throw err;
-        }
     }, api.getRetryOptions());
 
-// Write `file`'s original to `outPath`. A live photo is written as its image
-// and its video beside `outPath` instead, and whatever was at `outPath` is
-// removed (see `decryptLivePhoto`).
 export const downloadFile = async (
     api: ApiClient,
     file: EnteFile,
@@ -557,7 +429,7 @@ export const downloadFile = async (
     const resolvedPath =
         outPath ?? sanitizeFileName(file.metadata.title, `file-${file.id}`);
     const header = fromBase64(file.file.decryptionHeader);
-    return fetchAndDecrypt(
+    const bytesWritten = await fetchAndDecrypt(
         api,
         () => api.getFileStream(file.id, { retry: false }),
         header,
@@ -566,6 +438,7 @@ export const downloadFile = async (
         onProgress,
         file,
     );
+    return { path: resolvedPath, bytesWritten };
 };
 
 export const downloadThumbnail = async (
@@ -578,7 +451,7 @@ export const downloadThumbnail = async (
         outPath ??
         `thumb_${sanitizeFileName(file.metadata.title, `file-${file.id}`)}`;
     const header = fromBase64(file.thumbnail.decryptionHeader);
-    return fetchAndDecrypt(
+    const bytesWritten = await fetchAndDecrypt(
         api,
         () => api.getThumbnailStream(file.id, { retry: false }),
         header,
@@ -586,4 +459,5 @@ export const downloadThumbnail = async (
         resolvedPath,
         onProgress,
     );
+    return { path: resolvedPath, bytesWritten };
 };

src/filename.ts

@@ -35,7 +35,3 @@ export const safeExtension = (title: string): string => {
     const ext = extname(title);
     return /^\.[A-Za-z0-9]+$/.test(ext) ? ext : ".bin";
 };
-
-// `name` with its extension, if it has one, replaced by `ext` (".mov").
-export const withExtension = (name: string, ext: string): string =>
-    name.slice(0, name.length - extname(name).length) + ext;

src/library/content.ts

@@ -1,13 +1,11 @@
 // The on-disk content and thumbnail cache keyed by fileID (issue #46).
 //
 // Layout under `cacheDirectory`: `originals/<fileID>.<ext>` and
-// `thumbnails/<fileID>.<ext>`, flat directories at 0700 with files at 0600. A
-// live photo's original is two files, its image and its video, with
-// `originals/<fileID>.livephoto.json` naming them. Content appears only by the
-// streaming atomic writer's rename (the download layer, #40), so a file that
-// exists is whole — "present means complete". The directory listing taken at
-// `open()` is the record of what is cached, and the orphan temp files a crashed
-// write may have left are reaped there.
+// `thumbnails/<fileID>.<ext>`, flat directories at 0700 with files at 0600.
+// Content appears only by the streaming atomic writer's rename (the download
+// layer, #40), so a file that exists is whole — "present means complete". The
+// directory listing taken at `open()` is the record of what is cached, and the
+// orphan temp files a crashed write may have left are reaped there.
 //
 // A fetch goes through the shared request pools (#45): the content pool for
 // originals, the thumbnail pool for thumbnails. The pool limits concurrency,
@@ -24,7 +22,7 @@
 // does; thumbnails have none. On top of that this module refuses to record a
 // stored file that came out empty.
 
-import { existsSync, readFileSync, statSync } from "node:fs";
+import { existsSync, statSync } from "node:fs";
 import {
     chmod,
     mkdir,
@@ -34,15 +32,13 @@ import {
     statfs,
     utimes,
 } from "node:fs/promises";
-import { basename, dirname, extname, join } from "node:path";
+import { dirname, extname, join } from "node:path";
 
 import type { ApiClient } from "../api/client.js";
 import {
     downloadFile,
     downloadThumbnail,
     type ProgressCallback,
-    removeLeftoverTempFiles,
-    writeAtomic,
 } from "../download/index.js";
 import { safeExtension } from "../filename.js";
 import type { EnteFile } from "../model/types.js";
@@ -50,6 +46,8 @@ import type { Priority, RequestPools } from "./pools.js";
 
 const DIR_MODE = 0o700;
 const FILE_MODE = 0o600;
+const TEMP_PREFIX = ".quak-";
+const TEMP_SUFFIX = ".tmp";
 const GIB = 1024 * 1024 * 1024;
 // Owner ruling (#36): bound the originals cache at 100 GiB, but back off when
 // the volume has under 50 GiB free so the cache never crowds the disk.
@@ -80,8 +78,6 @@ const poolPriorityOf = (priority: ThumbnailPriority): Priority =>
 export interface ContentResult {
     path: string;
     bytes: number;
-    // A live photo's video. `path` and `bytes` are then its image's.
-    videoPath?: string;
 }
 
 // Progress for a single `original`/`thumbnail` call. A present file emits one
@@ -132,14 +128,11 @@ export interface ThumbnailsAPI {
 // stand-in so the cache logic runs with no crypto and no network. Pool routing,
 // dedup, present-checks and integrity live in the cache, not here.
 export interface ContentSource {
-    // Writes the original at `destination`. A live photo is written beside it
-    // as its image and its video instead, and their paths are returned, as
-    // `downloadFile` does.
     original(args: {
         file: EnteFile;
         destination: string;
         onProgress?: ProgressCallback;
-    }): Promise<{ bytesWritten: number; path?: string; videoPath?: string }>;
+    }): Promise<{ bytesWritten: number }>;
     thumbnail(args: {
         file: EnteFile;
         destination: string;
@@ -217,9 +210,7 @@ class AbortDrop extends Error {
     }
 }
 
-// The originals/ name for a file: `<fileID><ext>`, the extension taken from the
-// title (or `.bin`). A backup names its originals the same way.
-export const originalName = (file: EnteFile): string =>
+const originalName = (file: EnteFile): string =>
     `${file.id}${safeExtension(file.metadata.title)}`;
 
 // The fileID a cache filename encodes, or undefined when the name is not one
@@ -241,73 +232,6 @@ const fileSize = (path: string): number | undefined => {
     }
 };
 
-// Whether `path` is a regular file with content. A zero-byte file is the shape
-// an aborted write leaves, so it does not count.
-const hasContent = (path: string | undefined): boolean =>
-    path !== undefined && (fileSize(path) ?? 0) > 0;
-
-// A live photo's image and video are named with the extensions from inside its
-// ZIP, so their names alone do not say which is which. Wherever the cache or a
-// backup stores one, this JSON file beside them names both.
-const livePhotoFileName = (fileID: number): string =>
-    `${fileID}.livephoto.json`;
-
-// The image and video that the live photo's JSON file in `dir` names, or
-// undefined when there is none. Only names of the form the cache writes are
-// taken, so the file cannot point outside `dir`.
-const readLivePhoto = (
-    dir: string,
-    fileID: number,
-): { path: string; videoPath: string } | undefined => {
-    const valid = (name: unknown): name is string =>
-        typeof name === "string" && name === `${fileID}${safeExtension(name)}`;
-    try {
-        const { image, video } = JSON.parse(
-            readFileSync(join(dir, livePhotoFileName(fileID)), "utf-8"),
-        );
-        if (valid(image) && valid(video)) {
-            return { path: join(dir, image), videoPath: join(dir, video) };
-        }
-    } catch {
-        // No such file, or not one the cache wrote.
-    }
-    return undefined;
-};
-
-// Write the JSON file naming a live photo's image and video, both in `dir`.
-export const writeLivePhoto = (
-    dir: string,
-    fileID: number,
-    stored: { path: string; videoPath: string },
-): Promise<void> =>
-    writeAtomic(
-        join(dir, livePhotoFileName(fileID)),
-        new TextEncoder().encode(
-            JSON.stringify({
-                image: basename(stored.path),
-                video: basename(stored.videoPath),
-            }),
-        ),
-    );
-
-// The original of `file` as the cache or a backup stored it in `dir`, when all
-// of it is there: `<fileID><ext>`, or a live photo's image and video.
-export const storedOriginal = (
-    dir: string,
-    file: EnteFile,
-): { path: string; videoPath?: string } | undefined => {
-    if (file.metadata.fileType !== "livePhoto") {
-        const path = join(dir, originalName(file));
-        return hasContent(path) ? { path } : undefined;
-    }
-    const stored = readLivePhoto(dir, file.id);
-    return stored !== undefined &&
-        hasContent(stored.path) &&
-        hasContent(stored.videoPath)
-        ? stored
-        : undefined;
-};
-
 export class ContentCache implements PhotoContent, ThumbnailsAPI {
     private readonly pools: RequestPools;
     private readonly source: ContentSource;
@@ -315,17 +239,10 @@ export class ContentCache implements PhotoContent, ThumbnailsAPI {
     private readonly getFile: (fileID: number) => EnteFile | undefined;
     private readonly originalsDir: string;
     private readonly thumbnailsDir: string;
-    // fileID -> absolute path of the cached bytes, and for a live photo's
-    // original its video's, seeded from the directory listing at open() and
-    // extended as fetches store new files.
-    private readonly originals = new Map<
-        number,
-        { path: string; videoPath?: string }
-    >();
-    private readonly thumbnails = new Map<
-        number,
-        { path: string; videoPath?: string }
-    >();
+    // fileID -> absolute path of the cached bytes, seeded from the directory
+    // listing at open() and extended as fetches store new files.
+    private readonly originals = new Map<number, string>();
+    private readonly thumbnails = new Map<number, string>();
     private readonly maxOriginalsBytes: number;
     private readonly freeBelowBytes: number;
     private readonly isPinned: (fileID: number) => boolean;
@@ -385,9 +302,9 @@ export class ContentCache implements PhotoContent, ThumbnailsAPI {
     pathsFor(fileID: number): CachedPaths {
         const out: CachedPaths = {};
         const original = this.originals.get(fileID);
-        if (original !== undefined) out.originalPath = original.path;
+        if (original !== undefined) out.originalPath = original;
         const thumbnail = this.thumbnails.get(fileID);
-        if (thumbnail !== undefined) out.thumbnailPath = thumbnail.path;
+        if (thumbnail !== undefined) out.thumbnailPath = thumbnail;
         return out;
     }
 
@@ -405,27 +322,6 @@ export class ContentCache implements PhotoContent, ThumbnailsAPI {
         return this.get(fileID, "thumbnail", "on-demand", opts?.onProgress);
     }
 
-    // Get an original for a backup. One not present anywhere is written
-    // straight to `destination` and recorded there, so no second copy lands
-    // in the cache; one already present is returned where it is.
-    async backupOriginal(
-        fileID: number,
-        destination: string,
-    ): Promise<ContentResult> {
-        const result = await this.acquire(
-            fileID,
-            "original",
-            "on-demand",
-            undefined,
-            { destination },
-        );
-        return {
-            path: result.path,
-            bytes: result.bytes,
-            videoPath: result.videoPath,
-        };
-    }
-
     async ensure(args: EnsureOptions): Promise<EnsureResult[]> {
         return this.ensureThumbnails(args);
     }
@@ -522,72 +418,51 @@ export class ContentCache implements PhotoContent, ThumbnailsAPI {
                 ? { status: "skipped", bytes: result.bytes }
                 : { status: "done", bytes: result.bytes },
         );
-        return {
-            path: result.path,
-            bytes: result.bytes,
-            videoPath: result.videoPath,
-        };
+        return { path: result.path, bytes: result.bytes };
     }
 
     // The core: return the cached path if present, else fetch through the pool,
     // store, and return it. `cached` distinguishes a present hit (no network,
-    // no download event) from a fresh fetch. A fetched original is stored at
-    // `opts.destination` when given, instead of in `originalsDir`. A live
-    // photo's original is present only with its video, and is returned with
-    // it.
+    // no download event) from a fresh fetch.
     private async acquire(
         fileID: number,
         kind: Kind,
         priority: Priority,
         signal: AbortSignal | undefined,
-        opts?: { onByte?: ProgressCallback; destination?: string },
-    ): Promise<{
-        path: string;
-        bytes: number;
-        videoPath?: string;
-        cached: boolean;
-    }> {
+        opts?: { onByte?: ProgressCallback },
+    ): Promise<{ path: string; bytes: number; cached: boolean }> {
         const file = this.getFile(fileID);
         if (!file) throw new Error(`content cache: unknown file ${fileID}`);
-        const isLivePhoto =
-            kind === "original" && file.metadata.fileType === "livePhoto";
 
         const known = kind === "original" ? this.originals : this.thumbnails;
         const cached = known.get(fileID);
         if (cached !== undefined) {
-            const size = fileSize(cached.path);
-            if (
-                size !== undefined &&
-                size > 0 &&
-                (!isLivePhoto || hasContent(cached.videoPath))
-            ) {
+            const size = fileSize(cached);
+            if (size !== undefined && size > 0) {
                 // Returning an original's path is a use: bump its mtime so LRU
                 // order reflects it and survives a restart with no ledger.
                 if (
                     kind === "original" &&
-                    dirname(cached.path) === this.originalsDir
+                    dirname(cached) === this.originalsDir
                 )
-                    await this.touch(cached.path);
-                return { ...cached, bytes: size, cached: true };
+                    await this.touch(cached);
+                return { path: cached, bytes: size, cached: true };
             }
-            // A recorded file that has since gone, or a live photo an earlier
-            // version stored as one ZIP, re-fetches below.
+            // A recorded file that has since gone re-fetches below.
             known.delete(fileID);
         }
 
         // An original a backup already stored counts as present.
         if (kind === "original" && this.downloadDirectory !== undefined) {
-            const stored = storedOriginal(
-                join(this.downloadDirectory, "originals"),
-                file,
+            const backupPath = join(
+                this.downloadDirectory,
+                "originals",
+                originalName(file),
             );
-            if (stored !== undefined) {
-                this.originals.set(fileID, stored);
-                return {
-                    ...stored,
-                    bytes: fileSize(stored.path) ?? 0,
-                    cached: true,
-                };
+            const size = fileSize(backupPath);
+            if (size !== undefined && size > 0) {
+                this.originals.set(fileID, backupPath);
+                return { path: backupPath, bytes: size, cached: true };
             }
         }
 
@@ -595,7 +470,7 @@ export class ContentCache implements PhotoContent, ThumbnailsAPI {
             kind === "original" ? this.originalsDir : this.thumbnailsDir;
         const dest =
             kind === "original"
-                ? (opts?.destination ?? join(dir, originalName(file)))
+                ? join(dir, originalName(file))
                 : join(dir, `${fileID}${THUMBNAIL_EXT}`);
         const pool =
             kind === "original" ? this.pools.content : this.pools.thumbnails;
@@ -616,39 +491,21 @@ export class ContentCache implements PhotoContent, ThumbnailsAPI {
                         ? this.beginOriginalWrite(fileID)
                         : null;
                 try {
-                    const stored = await this.download(
-                        file,
-                        dest,
-                        kind,
-                        opts?.onByte,
-                    );
-                    for (const path of [stored.path, stored.videoPath]) {
-                        if (path === undefined) continue;
-                        await chmod(path, FILE_MODE);
-                        if ((await stat(path)).size === 0) {
+                    await this.download(file, dest, kind, opts?.onByte);
+                    await chmod(dest, FILE_MODE);
+                    const size = (await stat(dest)).size;
+                    if (size === 0) {
                         throw new Error(
                             `content cache: ${kind} ${fileID} stored empty`,
                         );
                     }
-                    }
-                    // A backup records its own live photos.
-                    if (
-                        stored.videoPath !== undefined &&
-                        opts?.destination === undefined
-                    ) {
-                        await writeLivePhoto(dir, fileID, {
-                            path: stored.path,
-                            videoPath: stored.videoPath,
-                        });
-                    }
-                    known.set(fileID, stored);
+                    known.set(fileID, dest);
                     // A fresh original may have crossed the limit; make room by
                     // evicting least-recently-used originals. An over-budget
                     // fetch keeps the file it returns, and no overlapping
                     // sibling is evicted. Thumbnails are never bounded.
                     if (write) await this.enforceOriginalsLimit(write);
-                    const size = (await stat(stored.path)).size;
-                    return { ...stored, bytes: size, cached: false };
+                    return { path: dest, bytes: size, cached: false };
                 } finally {
                     if (write) this.inFlightOriginals.delete(write);
                 }
@@ -657,24 +514,18 @@ export class ContentCache implements PhotoContent, ThumbnailsAPI {
         );
     }
 
-    // Fetch into `destination`, returning where the bytes landed: there, or
-    // for a live photo, its image and video beside it.
     private async download(
         file: EnteFile,
         destination: string,
         kind: Kind,
         onProgress: ProgressCallback | undefined,
-    ): Promise<{ path: string; videoPath?: string }> {
+    ): Promise<number> {
         const args = { file, destination, onProgress };
-        if (kind === "thumbnail") {
-            await this.source.thumbnail(args);
-            return { path: destination };
-        }
-        const result = await this.source.original(args);
-        return {
-            path: result.path ?? destination,
-            videoPath: result.videoPath,
-        };
+        const result =
+            kind === "original"
+                ? await this.source.original(args)
+                : await this.source.thumbnail(args);
+        return result.bytesWritten;
     }
 
     // Best-effort bump of a file's mtime to now; a failed touch must never fail
@@ -685,14 +536,13 @@ export class ContentCache implements PhotoContent, ThumbnailsAPI {
     }
 
     // Every stored original that lives under `originalsDir` (a backup-directory
-    // hit recorded in the map is excluded), with its size and mtime; a live
-    // photo's size includes its video. Entries whose file has vanished are
-    // dropped from the map. Backups and thumbnails are never counted.
+    // hit recorded in the map is excluded), with its size and mtime. Entries
+    // whose file has vanished are dropped from the map. Backups and thumbnails
+    // are never counted.
     private async measureOriginals(): Promise<{
         entries: {
             fileID: number;
             path: string;
-            videoPath?: string;
             size: number;
             mtimeMs: number;
         }[];
@@ -701,28 +551,21 @@ export class ContentCache implements PhotoContent, ThumbnailsAPI {
         const entries: {
             fileID: number;
             path: string;
-            videoPath?: string;
             size: number;
             mtimeMs: number;
         }[] = [];
         let used = 0;
-        for (const [fileID, { path, videoPath }] of this.originals) {
+        for (const [fileID, path] of this.originals) {
             if (dirname(path) !== this.originalsDir) continue;
             try {
                 const s = await stat(path);
-                const size =
-                    s.size +
-                    (videoPath === undefined
-                        ? 0
-                        : (await stat(videoPath)).size);
                 entries.push({
                     fileID,
                     path,
-                    videoPath,
-                    size,
+                    size: s.size,
                     mtimeMs: s.mtimeMs,
                 });
-                used += size;
+                used += s.size;
             } catch {
                 this.originals.delete(fileID);
             }
@@ -786,18 +629,6 @@ export class ContentCache implements PhotoContent, ThumbnailsAPI {
                 for (const e of evictable) {
                     if (remaining <= limit) break;
                     await rm(e.path, { force: true });
-                    // A live photo goes whole: its video and the JSON file
-                    // naming the two go with its image.
-                    if (e.videoPath !== undefined) {
-                        await rm(e.videoPath, { force: true });
-                        await rm(
-                            join(
-                                this.originalsDir,
-                                livePhotoFileName(e.fileID),
-                            ),
-                            { force: true },
-                        );
-                    }
                     this.originals.delete(e.fileID);
                     remaining -= e.size;
                 }
@@ -822,30 +653,23 @@ export class ContentCache implements PhotoContent, ThumbnailsAPI {
         await chmod(dir, DIR_MODE);
     }
 
-    private async scan(
-        dir: string,
-        into: Map<number, { path: string; videoPath?: string }>,
-    ): Promise<void> {
-        // Another process sharing this cache may still be writing its temp
-        // files, so only those whose process has exited are removed.
-        removeLeftoverTempFiles(dir);
+    private async scan(dir: string, into: Map<number, string>): Promise<void> {
         let entries: string[];
         try {
             entries = await readdir(dir);
         } catch {
             return;
         }
-        const names = new Set(entries);
         for (const name of entries) {
+            if (name.startsWith(TEMP_PREFIX) && name.endsWith(TEMP_SUFFIX)) {
+                await rm(join(dir, name), { force: true }).catch(
+                    () => undefined,
+                );
+                continue;
+            }
             const id = fileIDFromName(name);
             const path = join(dir, name);
-            if (id === undefined || !existsSync(path)) continue;
-            // A live photo's image and video are one entry, as the JSON file
-            // beside them names them.
-            const livePhoto = names.has(livePhotoFileName(id))
-                ? readLivePhoto(dir, id)
-                : undefined;
-            into.set(id, livePhoto ?? { path });
+            if (id !== undefined && existsSync(path)) into.set(id, path);
         }
     }
 }

src/library/index.ts

@@ -538,13 +538,11 @@ export class Library {
     }
 
     // Back up every in-scope file to `downloadDirectory` in the historical
-    // on-disk layout, with a durable failure ledger (issue #51). Waits for a
-    // completed refresh first, as `fresh()` does, joining one already running,
-    // and rejects before touching any file when it fails. Then fetches pending
-    // originals (and optional thumbnails) through the content cache and pools,
-    // and rebuilds the derived symlink/JSON views from the model. Throws before
-    // any network work when no download directory is available or no content
-    // cache backs the originals it must fetch.
+    // on-disk layout, with a durable failure ledger (issue #51). Refreshes
+    // first, fetches pending originals (and optional thumbnails) through the
+    // content cache and pools, then rebuilds the derived symlink/JSON views
+    // from the model. Throws before any network work when no download directory
+    // is available or no content cache backs the originals it must fetch.
     backup(opts?: BackupOptions): Promise<BackupResult> {
         const downloadDirectory =
             opts?.downloadDirectory ?? this.downloadDirectory;
@@ -568,11 +566,10 @@ export class Library {
         const cache = this.cache;
         return runBackup(
             {
-                refresh: () => this.refreshNow(),
+                refresh: () => this.runRefresh(),
                 listCollections: () => this.store.listCollections(),
                 listFiles: (id) => this.store.listFiles(id),
-                original: (fileID, destination) =>
-                    cache!.backupOriginal(fileID, destination),
+                original: (fileID) => cache!.original(fileID),
                 thumbnail: (fileID) => cache!.thumbnail(fileID),
             },
             { ...opts, downloadDirectory },

src/library/read.ts

@@ -80,8 +80,7 @@ export class Photo {
     }
 
     // Fetch and cache the full-resolution original, returning its on-disk path
-    // and byte length; for a live photo, its image's, and its video's path as
-    // `videoPath`. Served from the cache (or the backup download directory)
+    // and byte length. Served from the cache (or the backup download directory)
     // when already present, otherwise fetched through the content pool.
     async original(opts?: ContentOptions): Promise<ContentResult> {
         return this.contentOrThrow().original(this.rec.fileID, opts);

src/library/records.ts

@@ -42,7 +42,6 @@ export interface PhotoRecord {
     isArchived: boolean;
     isHidden: boolean;
     // Local cache paths, set once a later phase caches the bytes; unset here.
-    // A live photo's `originalPath` is its image.
     thumbnailPath?: string;
     originalPath?: string;
 }

src/metadata-backup.ts

@@ -128,8 +128,7 @@ export const extractImageMetadata = (
 // Read a file's original bytes through the library's content cache and extract
 // its embedded image metadata. The bytes come from `photo.original()` — the
 // same on-disk cache the rest of the library fills — rather than a fresh
-// per-call download to a throwaway temp file. For a live photo, its `path` is
-// the image.
+// per-call download to a throwaway temp file.
 const extractExif = async (
     photo: Photo,
 ): Promise<Record<string, unknown> | undefined> => {
@@ -141,8 +140,8 @@ const extractExif = async (
 // Dump every decrypted metadata layer the account holds into a directory tree
 // of plain JSON: account, per-collection, and per-file records including the
 // private and public magic metadata and (by default) the ML data. Collections
-// and files are enumerated from the library's cache, which the caller refreshes
-// first. Returns how many ML data requests failed; their files are still
+// and files are enumerated from the library's cache rather than a fresh server
+// scan. Returns how many ML data requests failed; their files are still
 // written, with `mlDataError` in place of `mlData`.
 export const runMetadataBackup = async (
     lib: Library,

test/cli/backup.test.ts

@@ -53,13 +53,6 @@ import { Library } from "../../src/library/index.js";
 import type { ContentSource } from "../../src/library/content.js";
 import type { CollectionsPage, FilesPage } from "../../src/client.js";
 import type { Collection, EnteFile } from "../../src/model/types.js";
-import {
-    asLivePhoto,
-    cdnSource,
-    IMAGE,
-    livePhotoZip,
-    VIDEO,
-} from "../live-photo.js";
 
 // `open` and `rename` are wrapped to record, in order, every fsync and rename,
 // so a test can pin the sequence "fsync the temp file, rename, fsync the
@@ -569,39 +562,11 @@ describe("lib.backup", () => {
         lib.close();
     });
 
-    it("fetches each original once and writes it only into the backup", async () => {
-        // A backup of a 500 GB account must write 500 GB, not a copy in the
-        // cache as well: an original fetched for the backup goes straight
-        // into its originals/, and the cache records it there.
-        const source = stubSource();
-        const lib = await openLibrary(source);
-        const outDir = join(root, "backup");
-
-        const result = await lib.backup({ downloadDirectory: outDir });
-
-        expect(result.downloaded).toBe(3);
-        expect(source.originalCalls).toBe(3);
-        expect(readdirSync(join(root, "cache", "originals"))).toEqual([]);
-        const stored = readdirSync(join(outDir, "originals")).filter(
-            (name) => !name.endsWith(".json"),
-        );
-        expect(stored.sort()).toEqual(["100.jpg", "101.jpg", "200.png"]);
-        // The cache counts the backup's copy as present: reading the
-        // original afterwards fetches nothing and answers with that copy.
-        const read = await lib.photos.byID({ fileID: 100 })!.original();
-        expect(read.path).toBe(join(outDir, "originals", "100.jpg"));
-        expect(source.originalCalls).toBe(3);
-        await lib.close();
-    });
-
-    it("fsyncs an original copied from the cache before the rename and its directory after", async () => {
+    it("fsyncs a copied original before the rename and its directory after", async () => {
         const lib = await openLibrary(stubSource());
         const outDir = join(root, "backup");
         const originals = join(outDir, "originals");
         const dest = join(originals, "100.jpg");
-        // Only an original already in the cache is copied into the backup;
-        // one fetched for the backup is written there by the download writer.
-        await lib.photos.byID({ fileID: 100 })!.original();
         fsEvents.length = 0;
 
         await lib.backup({ downloadDirectory: outDir });
@@ -660,115 +625,6 @@ describe("lib.backup", () => {
     });
 });
 
-// Every refresh fails, as with an expired session or no network.
-class FailingClient extends MockClient {
-    override async collectionsSince(): Promise<CollectionsPage> {
-        throw new Error("HTTP 401 from server");
-    }
-}
-
-// Holds its refresh open until `release()` is called, then reports a third
-// album, so a backup can be started while that refresh is still running.
-class HeldClient extends MockClient {
-    release!: () => void;
-    private held = new Promise<void>((resolve) => {
-        this.release = resolve;
-    });
-    override async collectionsSince(): Promise<CollectionsPage> {
-        await this.held;
-        return {
-            collections: [collection(3, "Later")],
-            deleted: [],
-            cursor: 2,
-        };
-    }
-    override async filesSince(args: {
-        collectionID: number;
-    }): Promise<FilesPage> {
-        if (args.collectionID !== 3) return super.filesSince(args);
-        return { files: [file(300, 3, "late.jpg")], deleted: [], cursor: 2 };
-    }
-}
-
-// Fill the library cache on disk, so the next open starts its refresh in the
-// background instead of waiting for it.
-const fillCache = async (): Promise<void> => {
-    const lib = await openLibrary(stubSource());
-    await lib.close();
-};
-
-describe("the refresh before a backup", () => {
-    it("waits for a refresh already running and backs up what it found", async () => {
-        await fillCache();
-        const client = new HeldClient();
-        const lib = await openLibrary(stubSource(), client);
-        const outDir = join(root, "backup");
-
-        const backup = lib.backup({ downloadDirectory: outDir });
-        client.release();
-        const result = await backup;
-
-        expect(result.totalFiles).toBe(4);
-        expect(existsSync(join(outDir, "originals", "300.jpg"))).toBe(true);
-        await lib.close();
-    });
-
-    it("fails before any download when the refresh fails, leaving failures.json as it was", async () => {
-        await fillCache();
-        const outDir = join(root, "backup");
-        seedLedger(outDir, 100, "beach.jpg");
-        const ledgerPath = join(outDir, "failures.json");
-        const ledgerBefore = readFileSync(ledgerPath, "utf-8");
-        const source = stubSource();
-        const lib = await openLibrary(source, new FailingClient());
-
-        await expect(lib.backup({ downloadDirectory: outDir })).rejects.toThrow(
-            "HTTP 401 from server",
-        );
-
-        expect(source.originalCalls).toBe(0);
-        expect(readFileSync(ledgerPath, "utf-8")).toBe(ledgerBefore);
-        expect(existsSync(join(outDir, "originals"))).toBe(false);
-        await lib.close();
-    });
-
-    it("fails when the refresh fails on an empty cache, instead of backing up nothing", async () => {
-        const source = stubSource();
-        const lib = await openLibrary(source, new FailingClient());
-        const outDir = join(root, "backup");
-
-        await expect(lib.backup({ downloadDirectory: outDir })).rejects.toThrow(
-            "HTTP 401 from server",
-        );
-
-        expect(source.originalCalls).toBe(0);
-        expect(existsSync(outDir)).toBe(false);
-        await lib.close();
-    });
-});
-
-// Every entry under collections/, one level of directories deep, with each
-// symlink's target.
-const tree = (outDir: string): string[] => {
-    const lines: string[] = [];
-    const list = (dir: string, prefix: string): void => {
-        for (const name of readdirSync(dir).sort()) {
-            const path = join(dir, name);
-            const st = lstatSync(path);
-            if (st.isSymbolicLink()) {
-                lines.push(`${prefix}${name} -> ${readlinkSync(path)}`);
-            } else if (st.isDirectory() && prefix === "") {
-                lines.push(`${name}/`);
-                list(path, `${name}/`);
-            } else {
-                lines.push(`${prefix}${name}`);
-            }
-        }
-    };
-    list(join(outDir, "collections"), "");
-    return lines;
-};
-
 // The album folders under collections/, driven through `runBackup` with a
 // stand-in library whose albums a test changes between runs.
 describe("backup album folders", () => {
@@ -792,6 +648,28 @@ describe("backup album folders", () => {
         },
     });
 
+    // Every entry under collections/, one level of directories deep, with each
+    // symlink's target.
+    const tree = (outDir: string): string[] => {
+        const lines: string[] = [];
+        const list = (dir: string, prefix: string): void => {
+            for (const name of readdirSync(dir).sort()) {
+                const path = join(dir, name);
+                const st = lstatSync(path);
+                if (st.isSymbolicLink()) {
+                    lines.push(`${prefix}${name} -> ${readlinkSync(path)}`);
+                } else if (st.isDirectory() && prefix === "") {
+                    lines.push(`${name}/`);
+                    list(path, `${name}/`);
+                } else {
+                    lines.push(`${prefix}${name}`);
+                }
+            }
+        };
+        list(join(outDir, "collections"), "");
+        return lines;
+    };
+
     const albumID = (outDir: string, jsonName: string): number =>
         JSON.parse(readFileSync(join(outDir, "collections", jsonName), "utf-8"))
             .id;
@@ -1061,190 +939,3 @@ describe("backup album folders", () => {
         ).toBe(json);
     });
 });
-
-// A live photo, which Ente stores as one ZIP, is backed up as its image and
-// its video, which a photo viewer can open, beside a JSON file naming them,
-// and its album folder links both. These tests download a live photo ZIP
-// through the real download layer (test/live-photo.ts).
-describe("backup of live photos", () => {
-    // An account of one album, Trip (10), holding `files`.
-    class TripClient extends MockClient {
-        constructor(private readonly files: EnteFile[]) {
-            super();
-        }
-        override async collectionsSince(): Promise<CollectionsPage> {
-            return {
-                collections: [collection(10, "Trip")],
-                deleted: [],
-                cursor: 1,
-            };
-        }
-        override async filesSince(): Promise<FilesPage> {
-            return { files: this.files, deleted: [], cursor: 1 };
-        }
-    }
-
-    const open = (files: EnteFile[], bodies: Map<number, Uint8Array>) =>
-        openLibrary(cdnSource(bodies), new TripClient(files));
-
-    // What an earlier version stored for live photo 500: the ZIP under the
-    // image's name, and its link.
-    const earlierZIP = (outDir: string): void => {
-        mkdirSync(join(outDir, "originals"), { recursive: true });
-        mkdirSync(join(outDir, "collections", "Trip"), { recursive: true });
-        writeFileSync(join(outDir, "originals", "500.HEIC"), livePhotoZip());
-        symlinkSync(
-            "../../originals/500.HEIC",
-            join(outDir, "collections", "Trip", "IMG_0500.HEIC"),
-        );
-    };
-
-    const stored = ["500.heic", "500.json", "500.livephoto.json", "500.mov"];
-    const linked = [
-        "Trip/",
-        "Trip/IMG_0500.heic -> ../../originals/500.heic",
-        "Trip/IMG_0500.mov -> ../../originals/500.mov",
-        "Trip.json",
-    ];
-
-    it("stores a live photo as its image and its video and links both", async () => {
-        const { file: live, body } = await asLivePhoto(
-            file(500, 10, "IMG_0500.HEIC"),
-        );
-        const lib = await open([live], new Map([[500, body]]));
-        const outDir = join(root, "backup");
-        const originals = join(outDir, "originals");
-
-        const result = await lib.backup({ downloadDirectory: outDir });
-
-        expect(result).toMatchObject({ downloaded: 1, failed: 0 });
-        expect(readdirSync(originals).sort()).toEqual(stored);
-        expect(readFileSync(join(originals, "500.heic"))).toEqual(
-            Buffer.from(IMAGE),
-        );
-        expect(readFileSync(join(originals, "500.mov"))).toEqual(
-            Buffer.from(VIDEO),
-        );
-        expect(tree(outDir)).toEqual(linked);
-
-        // Both parts are there, so the next run fetches nothing.
-        const second = await lib.backup({ downloadDirectory: outDir });
-        expect(second).toMatchObject({ downloaded: 0, skipped: 1, failed: 0 });
-        await lib.close();
-    });
-
-    it("gives both links of each live photo their own names when titles clash", async () => {
-        const a = await asLivePhoto(file(500, 10, "IMG_0001.HEIC"));
-        const b = await asLivePhoto(file(501, 10, "IMG_0001.HEIC"));
-        const lib = await open(
-            [a.file, b.file],
-            new Map([
-                [500, a.body],
-                [501, b.body],
-            ]),
-        );
-        const outDir = join(root, "backup");
-
-        await lib.backup({ downloadDirectory: outDir });
-
-        expect(tree(outDir)).toEqual([
-            "Trip/",
-            "Trip/IMG_0001 (500).heic -> ../../originals/500.heic",
-            "Trip/IMG_0001 (500).mov -> ../../originals/500.mov",
-            "Trip/IMG_0001 (501).heic -> ../../originals/501.heic",
-            "Trip/IMG_0001 (501).mov -> ../../originals/501.mov",
-            "Trip.json",
-        ]);
-        await lib.close();
-    });
-
-    it("replaces the ZIP an earlier version stored, and its link", async () => {
-        const { file: live, body } = await asLivePhoto(
-            file(500, 10, "IMG_0500.HEIC"),
-        );
-        const outDir = join(root, "backup");
-        earlierZIP(outDir);
-        const lib = await open([live], new Map([[500, body]]));
-
-        const result = await lib.backup({ downloadDirectory: outDir });
-
-        expect(result).toMatchObject({ downloaded: 1, failed: 0 });
-        expect(readdirSync(join(outDir, "originals")).sort()).toEqual(stored);
-        expect(tree(outDir)).toEqual(linked);
-        await lib.close();
-    });
-
-    it("stores nothing for a live photo that fails its hash, and keeps what was there", async () => {
-        const { file: live, body } = await asLivePhoto(
-            file(500, 10, "IMG_0500.HEIC"),
-            livePhotoZip(),
-            "not:the recorded hash",
-        );
-        const outDir = join(root, "backup");
-        earlierZIP(outDir);
-        const lib = await open([live], new Map([[500, body]]));
-
-        const result = await lib.backup({ downloadDirectory: outDir });
-
-        expect(result).toMatchObject({ downloaded: 0, failed: 1 });
-        expect(result.errors.map((e) => e.fileID)).toEqual([500]);
-        expect(Object.keys(readLedger(outDir).files)).toEqual(["500"]);
-        expect(readdirSync(join(outDir, "originals"))).toEqual(["500.HEIC"]);
-        expect(tree(outDir)).toEqual([
-            "Trip/",
-            "Trip/IMG_0500.HEIC -> ../../originals/500.HEIC",
-            "Trip.json",
-        ]);
-        await lib.close();
-    });
-
-    it("copies both parts of a live photo the cache already holds", async () => {
-        const { file: live, body } = await asLivePhoto(
-            file(500, 10, "IMG_0500.HEIC"),
-        );
-        const lib = await open([live], new Map([[500, body]]));
-        const cached = await lib.photos.byID({ fileID: 500 })!.original();
-        const outDir = join(root, "backup");
-
-        const result = await lib.backup({ downloadDirectory: outDir });
-
-        expect(result).toMatchObject({ downloaded: 1, failed: 0 });
-        expect(readdirSync(join(outDir, "originals")).sort()).toEqual(stored);
-        expect(readFileSync(join(outDir, "originals", "500.mov"))).toEqual(
-            Buffer.from(VIDEO),
-        );
-        expect(tree(outDir)).toEqual(linked);
-        // The cache keeps its own copy.
-        expect(existsSync(cached.videoPath!)).toBe(true);
-        await lib.close();
-    });
-
-    it("serves a live photo the backup stored to a library reading the backup", async () => {
-        const { file: live, body } = await asLivePhoto(
-            file(500, 10, "IMG_0500.HEIC"),
-        );
-        const lib = await open([live], new Map([[500, body]]));
-        const outDir = join(root, "backup");
-        await lib.backup({ downloadDirectory: outDir });
-        await lib.close();
-
-        // Another cache over the same backup, whose server has nothing.
-        const reader = await Library.open({
-            client: new TripClient([live]),
-            cacheDirectory: join(root, "other-cache"),
-            downloadDirectory: outDir,
-            contentSource: cdnSource(new Map()),
-            refreshIntervalSeconds: 3600,
-            precacheThumbnails: false,
-            precacheOriginals: false,
-        });
-        const read = await reader.photos.byID({ fileID: 500 })!.original();
-
-        expect(read).toEqual({
-            path: join(outDir, "originals", "500.heic"),
-            videoPath: join(outDir, "originals", "500.mov"),
-            bytes: IMAGE.length,
-        });
-        await reader.close();
-    });
-});

test/cli/commands.test.ts

@@ -12,9 +12,7 @@
 
 import {
     existsSync,
-    mkdirSync,
     mkdtempSync,
-    readdirSync,
     readFileSync,
     rmSync,
     statSync,
@@ -22,22 +20,11 @@ import {
 } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
-import { PassThrough } from "node:stream";
-import * as jpegJs from "jpeg-js";
-import {
-    describe,
-    it,
-    expect,
-    vi,
-    beforeAll,
-    beforeEach,
-    afterEach,
-} from "vitest";
+import { describe, it, expect, beforeAll, beforeEach, afterEach } from "vitest";
 
 import {
     type CliContext,
     saveSession,
-    loginCommand,
     whoamiCommand,
     logoutCommand,
     collectionsCommand,
@@ -45,25 +32,14 @@ import {
     getCommand,
     getThumbCommand,
     backupCommand,
-    backupMetadataCommand,
     listMissingThumbnailsCommand,
-    fixMissingThumbnailsCommand,
 } from "../../src/cli-commands.js";
-import { run } from "../../src/cli-run.js";
 import { loadSession } from "../../src/cli-session.js";
-import type { Client, ClientSnapshot, LoginOptions } from "../../src/client.js";
+import type { Client, ClientSnapshot } from "../../src/client.js";
 import type { ContentSource } from "../../src/library/content.js";
 import type { Collection, EnteFile } from "../../src/model/types.js";
 import { init, toBase64 } from "../../src/crypto/index.js";
 import { defaultCacheDirectory } from "../../src/library/index.js";
-import {
-    asLivePhoto,
-    cdnSource,
-    IMAGE,
-    livePhotoHash,
-    livePhotoZip,
-    VIDEO,
-} from "../live-photo.js";
 
 const USER_ID = 42;
 
@@ -106,26 +82,8 @@ const FILES: Record<number, EnteFile[]> = {
 
 // An original is 7 bytes and a thumbnail 3. `failID` makes that file's
 // original fail; `emptyThumbID` makes the server report that file's
-// thumbnail as empty. `withNewFile` adds new.jpg (102) to Vacation, advancing
-// the collection's updationTime as the server does, and `refreshError` makes
-// listing collections fail with that message.
-const fakeClient = (
-    opts: {
-        failID?: number;
-        emptyThumbID?: number;
-        withNewFile?: boolean;
-        refreshError?: string;
-    } = {},
-) => {
-    const collections = opts.withNewFile
-        ? [{ ...COLLECTIONS[0], updationTime: 2 }, COLLECTIONS[1]]
-        : COLLECTIONS;
-    const files = opts.withNewFile
-        ? {
-              ...FILES,
-              1: [...FILES[1], { ...file(102, 1, "new.jpg"), updationTime: 2 }],
-          }
-        : FILES;
+// thumbnail as empty.
+const fakeClient = (opts: { failID?: number; emptyThumbID?: number } = {}) => {
     const source: ContentSource = {
         original: async ({ file: f, destination }) => {
             if (f.id === opts.failID) throw new Error("HTTP 500 from server");
@@ -139,19 +97,18 @@ const fakeClient = (
     };
     const fake = {
         whoami: () => ({ email: "cli@example.com", userID: USER_ID }),
-        collectionsSince: async () => {
-            if (opts.refreshError) throw new Error(opts.refreshError);
-            return { collections, deleted: [], cursor: 1 };
-        },
+        collectionsSince: async () => ({
+            collections: COLLECTIONS,
+            deleted: [],
+            cursor: 1,
+        }),
         filesSince: async (args: { collectionID: number }) => ({
-            files: files[args.collectionID] ?? [],
+            files: FILES[args.collectionID] ?? [],
             deleted: [],
             cursor: 1,
         }),
         contentSource: () => source,
         getApiClient: () => ({
-            // The ML data request of `backup-metadata`: no file has any.
-            postJSON: async () => ({ data: [] }),
             getThumbnailStream: async (fileID: number) =>
                 new ReadableStream<Uint8Array>({
                     start(controller) {
@@ -185,15 +142,6 @@ const context = (client: Client | null = fakeClient()): CliContext => ({
     sessionDir: join(root, "session"),
     cacheDir: join(root, "cache"),
     loadSession: () => client,
-    login: async () => {
-        throw new Error("login not expected");
-    },
-    prompt: async () => {
-        throw new Error("prompt not expected");
-    },
-    promptSecret: async () => {
-        throw new Error("prompt not expected");
-    },
 });
 
 beforeAll(async () => {
@@ -251,105 +199,6 @@ describe("session file", () => {
     });
 });
 
-// The login function is a fake that hands back a client whose snapshot is
-// `snapshot`; each prompt is recorded and answered with "123456".
-describe("login", () => {
-    const snapshot: ClientSnapshot = {
-        email: "cli@example.com",
-        userID: USER_ID,
-        token: "token",
-        masterKey: "a",
-        secretKey: "b",
-        publicKey: "c",
-    };
-
-    const loggedIn = {
-        whoami: () => ({ email: "cli@example.com", userID: USER_ID }),
-        toJSON: () => snapshot,
-    } as unknown as Client;
-
-    let prompts: string[];
-
-    const loginContext = (
-        login: (opts: LoginOptions) => Promise<Client>,
-    ): CliContext => ({
-        ...context(),
-        login,
-        prompt: async (message) => {
-            prompts.push(message);
-            return "123456";
-        },
-        promptSecret: async (message) => {
-            prompts.push(message);
-            return "123456";
-        },
-    });
-
-    beforeEach(() => {
-        prompts = [];
-        vi.stubEnv("QUAK_EMAIL", "cli@example.com");
-        vi.stubEnv("QUAK_PASSWORD", "hunter2");
-    });
-
-    afterEach(() => {
-        vi.unstubAllEnvs();
-    });
-
-    it("takes the email and password from the environment without a prompt", async () => {
-        const calls: LoginOptions[] = [];
-        const ctx = loginContext(async (opts) => {
-            calls.push(opts);
-            return loggedIn;
-        });
-        expect(await loginCommand(ctx)).toBe(0);
-
-        expect(prompts).toEqual([]);
-        expect(calls).toHaveLength(1);
-        expect(calls[0]!.email).toBe("cli@example.com");
-        expect(calls[0]!.password).toBe("hunter2");
-        const path = join(ctx.sessionDir, "session.json");
-        expect(stderr.text).toBe(
-            "Authenticating...\n" +
-                `Logged in as cli@example.com (user ${USER_ID})\n` +
-                `Session saved to ${path}\n`,
-        );
-    });
-
-    it("saves the session with mode 0600 in a directory with mode 0700", async () => {
-        const ctx = loginContext(async () => loggedIn);
-        expect(await loginCommand(ctx)).toBe(0);
-
-        expect(statSync(ctx.sessionDir).mode & 0o777).toBe(0o700);
-        const path = join(ctx.sessionDir, "session.json");
-        expect(statSync(path).mode & 0o777).toBe(0o600);
-        expect(JSON.parse(readFileSync(path, "utf-8"))).toEqual(snapshot);
-    });
-
-    it("asks for the TOTP code when the account needs one", async () => {
-        let code: string | undefined;
-        const ctx = loginContext(async (opts) => {
-            code = await opts.totp!();
-            return loggedIn;
-        });
-        expect(await loginCommand(ctx)).toBe(0);
-
-        expect(prompts).toEqual(["TOTP code: "]);
-        expect(code).toBe("123456");
-    });
-
-    it("a failed login exits 1, says why and writes no session", async () => {
-        const ctx = loginContext(async () => {
-            throw new Error("HTTP 401 from server");
-        });
-        expect(await loginCommand(ctx)).toBe(1);
-
-        expect(stderr.text).toBe(
-            "Authenticating...\nLogin failed: HTTP 401 from server\n",
-        );
-        expect(existsSync(join(ctx.sessionDir, "session.json"))).toBe(false);
-    });
-});
-
 // These use a real client read from the session file, over a fake API that
 // records each request and answers with `status`.
 describe("logout", () => {
@@ -541,120 +390,6 @@ describe("get and get-thumb", () => {
     });
 });
 
-// A live photo, which Ente stores as one ZIP, is written as its image and its
-// video, which a photo viewer can open. The account here is Vacation holding
-// one live photo, 300, downloaded through the real download layer
-// (test/live-photo.ts).
-describe("a live photo", () => {
-    const livePhotoClient = async (image = IMAGE): Promise<Client> => {
-        const { file: live, body } = await asLivePhoto(
-            file(300, 1, "IMG_0300.HEIC"),
-            livePhotoZip({ "image.heic": image, "video.mov": VIDEO }),
-            livePhotoHash(image, VIDEO),
-        );
-        const fake = {
-            whoami: () => ({ email: "cli@example.com", userID: USER_ID }),
-            collectionsSince: async () => ({
-                collections: [collection(1, "Vacation")],
-                deleted: [],
-                cursor: 1,
-            }),
-            filesSince: async () => ({ files: [live], deleted: [], cursor: 1 }),
-            contentSource: () => cdnSource(new Map([[300, body]])),
-            // The ML data request of `backup-metadata`: no file has any.
-            getApiClient: () => ({ postJSON: async () => ({ data: [] }) }),
-        };
-        return fake as unknown as Client;
-    };
-
-    it("get writes its image and video, named after the title with their own extensions", async () => {
-        const ctx = context(await livePhotoClient());
-        const dir = join(root, "cwd");
-        mkdirSync(dir);
-        const previous = process.cwd();
-        process.chdir(dir);
-        try {
-            expect(await getCommand(ctx, "300", {})).toBe(0);
-        } finally {
-            process.chdir(previous);
-        }
-
-        expect(readdirSync(dir).sort()).toEqual([
-            "IMG_0300.heic",
-            "IMG_0300.mov",
-        ]);
-        expect(readFileSync(join(dir, "IMG_0300.heic"))).toEqual(
-            Buffer.from(IMAGE),
-        );
-        expect(readFileSync(join(dir, "IMG_0300.mov"))).toEqual(
-            Buffer.from(VIDEO),
-        );
-        expect(stderr.text).toBe(
-            `${IMAGE.length} bytes -> IMG_0300.heic\n` +
-                `${VIDEO.length} bytes -> IMG_0300.mov\n`,
-        );
-    });
-
-    it("get --out writes the image there and the video beside it", async () => {
-        const out = join(root, "photo.jpg");
-        const video = join(root, "photo.mov");
-
-        expect(
-            await getCommand(context(await livePhotoClient()), "300", { out }),
-        ).toBe(0);
-
-        expect(readFileSync(out)).toEqual(Buffer.from(IMAGE));
-        expect(readFileSync(video)).toEqual(Buffer.from(VIDEO));
-        expect(stderr.text).toBe(
-            `${IMAGE.length} bytes -> ${out}\n${VIDEO.length} bytes -> ${video}\n`,
-        );
-    });
-
-    it("get exits 1 and writes nothing when --out has the video's extension", async () => {
-        const out = join(root, "photo.MOV");
-
-        expect(
-            await getCommand(context(await livePhotoClient()), "300", { out }),
-        ).toBe(1);
-
-        expect(existsSync(out)).toBe(false);
-        expect(existsSync(join(root, "photo.mov"))).toBe(false);
-        expect(stderr.text).toBe(
-            `File 300 is a live photo, and its video would also be written to ${out}\n`,
-        );
-    });
-
-    it("backup-metadata --exif reads its image", async () => {
-        // A 4x4 JPEG, whose size can only come from reading the image; the
-        // ZIP and the video are not JPEGs.
-        const jpeg = jpegJs.encode(
-            { data: new Uint8Array(4 * 4 * 4), width: 4, height: 4 },
-            50,
-        ).data;
-        const dir = join(root, "dump");
-
-        expect(
-            await backupMetadataCommand(
-                context(await livePhotoClient(new Uint8Array(jpeg))),
-                dir,
-                { exif: true },
-            ),
-        ).toBe(0);
-
-        const record = JSON.parse(
-            readFileSync(
-                join(dir, "collections", "1-Vacation", "300.json"),
-                "utf-8",
-            ),
-        );
-        expect(record.imageMetadata).toMatchObject({
-            format: "jpeg",
-            width: 4,
-            height: 4,
-        });
-    });
-});
-
 describe("backup", () => {
     it("exits 0 and prints a summary when every file is saved", async () => {
         const dir = join(root, "backup");
@@ -669,16 +404,6 @@ describe("backup", () => {
         expect(stdout.text).toBe("");
     });
 
-    // The backup opens its library with the precache off: it fetches the
-    // originals it needs into the backup, and must not also fetch every
-    // thumbnail in the account, or keep originals, in the per-user cache.
-    it("leaves nothing in the cache's originals and thumbnails", async () => {
-        const dir = join(root, "backup");
-        expect(await backupCommand(context(), dir, {})).toBe(0);
-        expect(readdirSync(join(root, "cache", "thumbnails"))).toEqual([]);
-        expect(readdirSync(join(root, "cache", "originals"))).toEqual([]);
-    });
-
     it("exits 1 and lists the file when one download fails", async () => {
         const ctx = context(fakeClient({ failID: 101 }));
         expect(await backupCommand(ctx, join(root, "backup"), {})).toBe(1);
@@ -705,34 +430,6 @@ describe("backup", () => {
         expect(result.errors[0].fileID).toBe(101);
         expect(stderr.text).toBe("Starting backup...\n");
     });
-
-    it("exits 1 with the error on one line when the refresh fails", async () => {
-        const client = {
-            ...fakeClient(),
-            collectionsSince: async () => {
-                throw new Error("HTTP 401 from server");
-            },
-        } as unknown as Client;
-        const dir = join(root, "backup");
-        // Through `run`, as `bin/quak.ts` does, which prints a thrown error.
-        const runStderr = new PassThrough();
-        let runText = "";
-        runStderr.on("data", (chunk: Buffer) => {
-            runText += chunk.toString();
-        });
-        const code = await new Promise<number>((resolve) => {
-            void run(
-                backupCommand(context(client), dir, {}),
-                new PassThrough(),
-                runStderr,
-                resolve,
-            );
-        });
-        expect(code).toBe(1);
-        expect(runText).toBe("quak: HTTP 401 from server\n");
-        expect(stderr.text).toBe("Starting backup...\nRefreshing library...\n");
-        expect(existsSync(join(dir, "originals"))).toBe(false);
-    });
 });
 
 describe("helper list-missing-thumbnails", () => {
@@ -765,92 +462,3 @@ describe("helper list-missing-thumbnails", () => {
         expect(stderr.text).toBe("");
     });
 });
-
-describe("backup-metadata --exif", () => {
-    // Runs the command and returns what it printed to stderr.
-    const backupMetadata = async (opts: { exif?: boolean; all?: boolean }) => {
-        expect(
-            await backupMetadataCommand(context(), join(root, "dump"), opts),
-        ).toBe(0);
-        return stderr.text;
-    };
-
-    it("--exif extracts EXIF", async () => {
-        expect(await backupMetadata({ exif: true })).toContain(
-            "[beach.jpg] Extracting EXIF...\n",
-        );
-    });
-
-    it("--all extracts EXIF", async () => {
-        expect(await backupMetadata({ all: true })).toContain(
-            "[beach.jpg] Extracting EXIF...\n",
-        );
-    });
-
-    it("without either flag extracts no EXIF", async () => {
-        expect(await backupMetadata({})).not.toContain("Extracting EXIF");
-    });
-});
-
-// Each test first runs `collections` so the cache holds the account as it was,
-// then changes the server under it.
-describe("backup-metadata and the thumbnail helpers refresh first", () => {
-    beforeEach(async () => {
-        expect(await collectionsCommand(context(), {})).toBe(0);
-        stdout.text = "";
-        stderr.text = "";
-    });
-
-    it("backup-metadata writes a file added since the cache was written", async () => {
-        const ctx = context(fakeClient({ withNewFile: true }));
-        const dir = join(root, "dump");
-        expect(await backupMetadataCommand(ctx, dir, {})).toBe(0);
-        expect(
-            existsSync(join(dir, "collections", "1-Vacation", "102.json")),
-        ).toBe(true);
-    });
-
-    it("list-missing-thumbnails checks a file added since the cache was written", async () => {
-        const ctx = context(
-            fakeClient({ withNewFile: true, emptyThumbID: 102 }),
-        );
-        expect(await listMissingThumbnailsCommand(ctx, {})).toBe(0);
-        expect(stdout.text).toBe(
-            "102\tnew.jpg\tVacation\tempty thumbnail (0 bytes)\n",
-        );
-    });
-
-    it("fix-missing-thumbnails finds a file added since the cache was written", async () => {
-        const ctx = context(fakeClient({ withNewFile: true }));
-        expect(
-            await fixMissingThumbnailsCommand(ctx, {
-                file: ["102"],
-                json: true,
-            }),
-        ).toBe(0);
-        // Found, then skipped because the server records no thumbnail size
-        // for it; a file missing from the cache would fail as not found.
-        expect(JSON.parse(stdout.text)).toMatchObject([
-            { fileID: 102, title: "new.jpg", status: "skipped" },
-        ]);
-    });
-
-    // `run` in `cli-run.ts` prints a thrown error as one line and exits 1.
-    it("all three throw when the refresh fails", async () => {
-        const ctx = context(
-            fakeClient({ refreshError: "HTTP 503 from server" }),
-        );
-        const dir = join(root, "dump");
-        await expect(backupMetadataCommand(ctx, dir, {})).rejects.toThrow(
-            "HTTP 503 from server",
-        );
-        expect(existsSync(dir)).toBe(false);
-        await expect(listMissingThumbnailsCommand(ctx, {})).rejects.toThrow(
-            "HTTP 503 from server",
-        );
-        await expect(
-            fixMissingThumbnailsCommand(ctx, { file: ["100"] }),
-        ).rejects.toThrow("HTTP 503 from server");
-        expect(stdout.text).toBe("");
-    });
-});

test/cli/run.test.ts

@@ -1,58 +0,0 @@
-/**
- * Tests for `run` in `src/cli-run.ts`, which every CLI command goes through.
- */
-
-import { PassThrough } from "node:stream";
-import { describe, it, expect } from "vitest";
-
-import { run } from "../../src/cli-run.js";
-
-// A stream whose written text is kept in `text`; writes finish at once, so
-// nothing is left waiting to drain.
-const collector = (): { stream: PassThrough; text: () => string } => {
-    const stream = new PassThrough();
-    const chunks: string[] = [];
-    stream.on("data", (chunk: Buffer) => chunks.push(chunk.toString()));
-    return { stream, text: () => chunks.join("") };
-};
-
-const runToExit = async (
-    command: Promise<number>,
-): Promise<{ code: number; stdout: string; stderr: string }> => {
-    const stdout = collector();
-    const stderr = collector();
-    const code = await new Promise<number>((resolve) => {
-        void run(command, stdout.stream, stderr.stream, resolve);
-    });
-    return { code, stdout: stdout.text(), stderr: stderr.text() };
-};
-
-describe("run", () => {
-    it("exits with the code the command returns", async () => {
-        const result = await runToExit(Promise.resolve(3));
-        expect(result).toEqual({ code: 3, stdout: "", stderr: "" });
-    });
-
-    it("prints a thrown error as one line without a stack trace and exits 1", async () => {
-        const failing = async (): Promise<number> => {
-            throw new Error(
-                "ENOTDIR: not a directory, mkdir '/dev/null/x/originals'",
-            );
-        };
-        const result = await runToExit(failing());
-        expect(result.code).toBe(1);
-        expect(result.stdout).toBe("");
-        expect(result.stderr).toBe(
-            "quak: ENOTDIR: not a directory, mkdir '/dev/null/x/originals'\n",
-        );
-    });
-
-    it("prints a thrown value that is not an Error", async () => {
-        const result = await runToExit(Promise.reject("offline"));
-        expect(result).toEqual({
-            code: 1,
-            stdout: "",
-            stderr: "quak: offline\n",
-        });
-    });
-});

test/download/download.test.ts

@@ -55,7 +55,6 @@ import {
     readFileSync,
     rmSync,
     mkdtempSync,
-    statSync,
     writeFileSync,
 } from "node:fs";
 import { dirname, join } from "node:path";
@@ -82,7 +81,6 @@ import {
     writeAtomic,
 } from "../../src/download/index.js";
 import type { EnteFile, FileMetadata } from "../../src/model/types.js";
-import { IMAGE, livePhotoHash, livePhotoZip, VIDEO } from "../live-photo.js";
 
 // ---------------------------------------------------------------------------
 // Test helpers
@@ -108,8 +106,6 @@ import { IMAGE, livePhotoHash, livePhotoZip, VIDEO } from "../live-photo.js";
 const renameHook = vi.hoisted(() => ({
     calls: [] as { from: string; to: string; sourceExisted: boolean }[],
     failWith: null as Error | null,
-    // When set, only a rename to this path fails.
-    failTo: null as string | null,
 }));
 
 /**
@@ -185,10 +181,7 @@ vi.mock("node:fs/promises", async (importOriginal) => {
                 sourceExisted: sourceExists(from),
             });
             durabilityHook.events.push(`rename:${to}`);
-            if (
-                renameHook.failWith !== null &&
-                (renameHook.failTo === null || renameHook.failTo === to)
-            ) {
+            if (renameHook.failWith !== null) {
                 throw renameHook.failWith;
             }
             await actual.rename(from, to);
@@ -223,7 +216,6 @@ beforeEach(() => {
     hashHook.lengths.length = 0;
     renameHook.calls.length = 0;
     renameHook.failWith = null;
-    renameHook.failTo = null;
     durabilityHook.events.length = 0;
     writeHook.writes.length = 0;
 });
@@ -1568,13 +1560,7 @@ describe("writeAtomic", () => {
         // directory so that new entry is on disk too. Do the directory fsync
         // before the rename, or skip it, and a crash can lose the rename.
         expect(durabilityHook.events).toHaveLength(3);
-        // The temp name carries this process's ID, so a library opening the
-        // same cache can tell a write in progress from a leftover.
-        const tempSync = durabilityHook.events[0]!;
-        expect(tempSync.startsWith(`sync:w:${dir}/`)).toBe(true);
-        expect(tempSync.slice(`sync:w:${dir}/`.length)).toMatch(
-            new RegExp(`^\\.quak-${process.pid}-[0-9a-f]{32}\\.tmp$`),
-        );
+        expect(durabilityHook.events[0]).toMatch(/^sync:w:.*\.tmp$/);
         expect(durabilityHook.events[1]).toBe(`rename:${dest}`);
         expect(durabilityHook.events[2]).toBe(`sync:r:${dir}`);
     });
@@ -1650,15 +1636,15 @@ describe.each(entryPoints)("$name progress", ({ name, download }) => {
     });
 });
 
-// Node's own BLAKE2b-512 is the reference, so the tests below do not depend on
-// the code under test to compute what they expect.
-const blake2b = (bytes: Uint8Array): string =>
+describe("downloadFile content hash", () => {
+    // Node's own BLAKE2b-512 is the reference, so these tests do not depend
+    // on the code under test to compute what they expect.
+    const blake2b = (bytes: Uint8Array): string =>
         createHash("blake2b512").update(bytes).digest("base64");
 
-// Serve `plaintext` encrypted as file 999 with the given metadata, to be
-// written to `f.bin` in a fresh directory. Four responses are scripted so a
-// retried failure would show in `requests`.
-const setup = (plaintext: Uint8Array, metadata: Partial<FileMetadata>) => {
+    // Serve `plaintext` encrypted as file 999 with the given metadata. Four
+    // responses are scripted so a retried mismatch would show in `requests`.
+    const setup = (plaintext: Uint8Array, metadata: Partial<FileMetadata>) => {
         const key = sodium.crypto_secretstream_xchacha20poly1305_keygen();
         const { header, ciphertext } = encryptFileBody(plaintext, key);
         const file = buildMockEnteFile(key, header, header);
@@ -1670,15 +1656,18 @@ const setup = (plaintext: Uint8Array, metadata: Partial<FileMetadata>) => {
         const outPath = join(dir, "f.bin");
         return {
             run: () => downloadFile(api, file, outPath),
-        api,
-        file,
             dir,
             outPath,
             requests,
         };
-};
+    };
+
+    const livePhotoZip = zipSync({
+        "image.heic": patternBytes(500, 81),
+        "video.mov": patternBytes(900, 82),
+    });
+    const livePhotoHash = `${blake2b(patternBytes(500, 81))}:${blake2b(patternBytes(900, 82))}`;
 
-describe("downloadFile content hash", () => {
     it("stores a file whose hash matches", async () => {
         const plaintext = patternBytes(700, 80);
         const t = setup(plaintext, { hash: blake2b(plaintext) });
@@ -1711,18 +1700,17 @@ describe("downloadFile content hash", () => {
     });
 
     it("stores a live photo whose image and video hashes match", async () => {
-        const t = setup(livePhotoZip(), {
+        const t = setup(livePhotoZip, {
             fileType: "livePhoto",
-            hash: livePhotoHash(),
+            hash: livePhotoHash,
         });
 
         await t.run();
 
-        expect(readFileSync(join(t.dir, "f.heic"))).toEqual(Buffer.from(IMAGE));
-        expect(readFileSync(join(t.dir, "f.mov"))).toEqual(Buffer.from(VIDEO));
+        expectSameBytes(readFileSync(t.outPath), livePhotoZip);
     });
 
-    it("writes a large live photo entry as it decompresses, never whole", async () => {
+    it("hashes a large live photo entry as it decompresses, never whole", async () => {
         // 64 MiB of zeros deflates to a few kilobytes, the shape of a ZIP
         // that would exhaust memory if expanded whole.
         const image = new Uint8Array(64 * 1024 * 1024);
@@ -1730,45 +1718,40 @@ describe("downloadFile content hash", () => {
         const zip = zipSync({ "image.heic": image, "video.mov": video });
         const t = setup(zip, {
             fileType: "livePhoto",
-            hash: livePhotoHash(image, video),
+            hash: `${blake2b(image)}:${blake2b(video)}`,
         });
 
         await t.run();
 
-        expect(statSync(join(t.dir, "f.heic")).size).toBe(image.length);
-        expectSameBytes(readFileSync(join(t.dir, "f.mov")), video);
+        expectSameBytes(readFileSync(t.outPath), zip);
         const hashed = hashHook.lengths.reduce((a, b) => a + b, 0);
         expect(hashed).toBe(image.length + video.length);
         expect(Math.max(...hashHook.lengths)).toBeLessThanOrEqual(
             2 * STREAM_CHUNK_SIZE,
         );
-        const written = writeHook.writes.filter((w) => w.path.endsWith(".tmp"));
-        expect(Math.max(...written.map((w) => w.length))).toBeLessThanOrEqual(
-            2 * STREAM_CHUNK_SIZE,
-        );
     });
 
-    it("rejects a live photo whose hash does not match, keeping what was there", async () => {
+    it("rejects a live photo whose hash does not match", async () => {
         // The whole ZIP's hash is not the recorded one: each part is hashed.
-        const zip = livePhotoZip();
-        const t = setup(zip, { fileType: "livePhoto", hash: blake2b(zip) });
-        writeFileSync(t.outPath, "an earlier download");
+        const t = setup(livePhotoZip, {
+            fileType: "livePhoto",
+            hash: blake2b(livePhotoZip),
+        });
 
         await expect(t.run()).rejects.toThrow(
             /file 999: content hash .* does not match/,
         );
 
-        expect(readdirSync(t.dir)).toEqual(["f.bin"]);
-        expect(readFileSync(t.outPath, "utf-8")).toBe("an earlier download");
+        expect(readdirSync(t.dir)).toEqual([]);
     });
 
     it("rejects a live photo that is not a readable ZIP and does not retry", async () => {
         // Bytes 8-9 of a ZIP entry's local header name its compression
         // method; 99 is one no reader knows, so the entry cannot be read.
-        const zip = livePhotoZip();
+        const zip = livePhotoZip.slice();
         zip[8] = 99;
         zip[9] = 0;
-        const t = setup(zip, { fileType: "livePhoto", hash: livePhotoHash() });
+        const t = setup(zip, { fileType: "livePhoto", hash: livePhotoHash });
 
         await expect(t.run()).rejects.toThrow(
             /file 999: live photo is not a readable ZIP/,
@@ -1779,8 +1762,8 @@ describe("downloadFile content hash", () => {
     });
 
     it("rejects a live photo ZIP with no image entry", async () => {
-        const zip = livePhotoZip({ "video.mov": VIDEO });
-        const t = setup(zip, { fileType: "livePhoto", hash: livePhotoHash() });
+        const zip = zipSync({ "video.mov": patternBytes(900, 82) });
+        const t = setup(zip, { fileType: "livePhoto", hash: livePhotoHash });
 
         await expect(t.run()).rejects.toThrow(
             /file 999: live photo ZIP does not hold both an image and a video/,
@@ -1790,8 +1773,8 @@ describe("downloadFile content hash", () => {
     });
 
     it("rejects a live photo ZIP with no video entry", async () => {
-        const zip = livePhotoZip({ "image.heic": IMAGE });
-        const t = setup(zip, { fileType: "livePhoto", hash: livePhotoHash() });
+        const zip = zipSync({ "image.heic": patternBytes(500, 81) });
+        const t = setup(zip, { fileType: "livePhoto", hash: livePhotoHash });
 
         await expect(t.run()).rejects.toThrow(
             /file 999: live photo ZIP does not hold both an image and a video/,
@@ -1800,99 +1783,3 @@ describe("downloadFile content hash", () => {
         expect(readdirSync(t.dir)).toEqual([]);
     });
 });
-
-// ---------------------------------------------------------------------------
-// Live photos
-//
-// A live photo arrives as a ZIP of its image and its video. It is written as
-// those two files, which a photo viewer can open, each named after the
-// destination with its own extension from the ZIP, the way Ente's clients name
-// them when they save one.
-// ---------------------------------------------------------------------------
-
-describe("downloadFile live photos", () => {
-    const livePhoto = { fileType: "livePhoto", hash: livePhotoHash() } as const;
-
-    it("names the image and the video after the title when no outPath is given", async () => {
-        const t = setup(livePhotoZip(), {
-            ...livePhoto,
-            title: "IMG_1234.HEIC",
-        });
-
-        const result = await inDirectory(t.dir, () =>
-            downloadFile(t.api, t.file),
-        );
-
-        // `bytesWritten` is the length of the decrypted ZIP.
-        expect(result).toEqual({
-            path: "IMG_1234.heic",
-            videoPath: "IMG_1234.mov",
-            bytesWritten: livePhotoZip().length,
-        });
-        expect(readdirSync(t.dir).sort()).toEqual([
-            "IMG_1234.heic",
-            "IMG_1234.mov",
-        ]);
-    });
-
-    it("gives each part its own extension from the ZIP, letters and digits only", async () => {
-        const zip = livePhotoZip({ "image.JPG": IMAGE, "video.m-4v": VIDEO });
-        const t = setup(zip, livePhoto);
-
-        const result = await downloadFile(t.api, t.file, join(t.dir, "f.HEIC"));
-
-        expect(result.path).toBe(join(t.dir, "f.JPG"));
-        expect(result.videoPath).toBe(join(t.dir, "f.bin"));
-        expect(readdirSync(t.dir).sort()).toEqual(["f.JPG", "f.bin"]);
-    });
-
-    it("replaces what was at the destination, such as an earlier ZIP of the two", async () => {
-        const t = setup(livePhotoZip(), livePhoto);
-        writeFileSync(t.outPath, livePhotoZip());
-
-        await t.run();
-
-        expect(readdirSync(t.dir).sort()).toEqual(["f.heic", "f.mov"]);
-    });
-
-    it("renames the image and then the video into place, each from its own temp file", async () => {
-        const t = setup(livePhotoZip(), livePhoto);
-
-        await t.run();
-
-        expect(
-            renameHook.calls.map((c) => [
-                dirname(c.from),
-                c.to,
-                c.sourceExisted,
-            ]),
-        ).toEqual([
-            [t.dir, join(t.dir, "f.heic"), true],
-            [t.dir, join(t.dir, "f.mov"), true],
-        ]);
-    });
-
-    it("stores neither part when the video cannot be renamed into place", async () => {
-        const t = setup(livePhotoZip(), livePhoto);
-        renameHook.failWith = new Error("simulated rename failure");
-        renameHook.failTo = join(t.dir, "f.mov");
-
-        await expect(t.run()).rejects.toThrow("simulated rename failure");
-
-        expect(readdirSync(t.dir)).toEqual([]);
-    });
-
-    it("refuses an image and a video with the same extension, storing nothing", async () => {
-        // On a file system that ignores case, the two would be one file.
-        const zip = livePhotoZip({ "image.mov": IMAGE, "video.MOV": VIDEO });
-        const t = setup(zip, livePhoto);
-        writeFileSync(t.outPath, "an earlier download");
-
-        await expect(t.run()).rejects.toThrow(
-            /file 999: live photo's image and video have the same extension/,
-        );
-
-        expect(readdirSync(t.dir)).toEqual(["f.bin"]);
-        expect(t.requests()).toBe(1);
-    });
-});

test/library/content.test.ts

@@ -31,11 +31,8 @@ import {
     existsSync,
     writeFileSync,
     mkdirSync,
-    readdirSync,
-    readFileSync,
     statSync,
 } from "node:fs";
-import { spawnSync } from "node:child_process";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 
@@ -46,13 +43,6 @@ import {
 } from "../../src/library/content.js";
 import { RequestPools } from "../../src/library/pools.js";
 import type { EnteFile } from "../../src/model/types.js";
-import {
-    asLivePhoto,
-    cdnSource,
-    IMAGE,
-    livePhotoZip,
-    VIDEO,
-} from "../live-photo.js";
 
 const file = (id: number, title = `file-${id}.jpg`): EnteFile => ({
     id,
@@ -171,28 +161,15 @@ describe("ContentCache.open", () => {
         expect(statSync(thumbnails).mode & 0o777).toBe(0o700);
     });
 
-    it("removes temp files of an exited process, keeping those of a running one and complete content", async () => {
+    it("reaps orphan temp files but keeps complete content", async () => {
         const originals = join(cacheDir, "originals");
         const thumbnails = join(cacheDir, "thumbnails");
         mkdirSync(originals, { recursive: true });
         mkdirSync(thumbnails, { recursive: true });
-        // A child that has already exited: its process ID is not running.
-        const exitedPID = spawnSync(process.execPath, ["-e", ""]).pid;
-        const orphan = join(originals, `.quak-${exitedPID}-abc123.tmp`);
-        const orphanThumb = join(thumbnails, `.quak-${exitedPID}-abc456.tmp`);
-        // This test's own process stands in for another process still
-        // downloading into the same cache.
-        const inProgress = join(originals, `.quak-${process.pid}-def123.tmp`);
-        const inProgressThumb = join(
-            thumbnails,
-            `.quak-${process.pid}-def456.tmp`,
-        );
+        const orphan = join(originals, ".quak-abc123.tmp");
         const complete = join(originals, "1.jpg");
         const thumb = join(thumbnails, "2.jpg");
         writeFileSync(orphan, "half-written");
-        writeFileSync(orphanThumb, "half-written");
-        writeFileSync(inProgress, "half-written");
-        writeFileSync(inProgressThumb, "half-written");
         writeFileSync(complete, "whole");
         writeFileSync(thumb, "whole-thumb");
 
@@ -200,12 +177,8 @@ describe("ContentCache.open", () => {
         await cache.open();
 
         expect(existsSync(orphan)).toBe(false);
-        expect(existsSync(orphanThumb)).toBe(false);
-        expect(existsSync(inProgress)).toBe(true);
-        expect(existsSync(inProgressThumb)).toBe(true);
         expect(existsSync(complete)).toBe(true);
         expect(existsSync(thumb)).toBe(true);
-        expect(cache.pathsFor(1)).toEqual({ originalPath: complete });
     });
 
     it("records already-cached files so their paths appear in pathsFor", async () => {
@@ -467,125 +440,3 @@ describe("ContentCache.ensureThumbnails", () => {
         expect(results[1]?.error).toMatch(/unknown file/i);
     });
 });
-
-// A live photo's original is two files, its image and its video, which a
-// photo viewer can open, and a JSON file naming them: the two are named with
-// the extensions from inside the ZIP, so the names alone do not say which is
-// which. These tests download a live photo ZIP through the real download
-// layer (test/live-photo.ts).
-describe("ContentCache live photos", () => {
-    const originals = (): string => join(cacheDir, "originals");
-
-    // A cache over the stand-in server, which holds `bodies` by file ID.
-    const cacheOf = (
-        files: EnteFile[],
-        bodies: Map<number, Uint8Array>,
-    ): ContentCache => buildCache({ files, source: cdnSource(bodies) }).cache;
-
-    it("stores a live photo as its image and its video and a JSON file naming them", async () => {
-        const { file: live, body } = await asLivePhoto(file(5, "IMG_5.HEIC"));
-        const cache = cacheOf([live], new Map([[5, body]]));
-        await cache.open();
-
-        const result = await cache.original(5);
-
-        expect(result).toEqual({
-            path: join(originals(), "5.heic"),
-            videoPath: join(originals(), "5.mov"),
-            bytes: IMAGE.length,
-        });
-        expect(readFileSync(result.path)).toEqual(Buffer.from(IMAGE));
-        expect(readFileSync(result.videoPath!)).toEqual(Buffer.from(VIDEO));
-        expect(statSync(result.videoPath!).mode & 0o777).toBe(0o600);
-        expect(
-            JSON.parse(
-                readFileSync(join(originals(), "5.livephoto.json"), "utf-8"),
-            ),
-        ).toEqual({ image: "5.heic", video: "5.mov" });
-        expect(cache.pathsFor(5)).toEqual({ originalPath: result.path });
-    });
-
-    it("serves a stored live photo from disk after the cache is opened again", async () => {
-        const { file: live, body } = await asLivePhoto(file(5, "IMG_5.HEIC"));
-        const first = cacheOf([live], new Map([[5, body]]));
-        await first.open();
-        const stored = await first.original(5);
-
-        // This server has nothing, so a fetch would fail.
-        const second = cacheOf([live], new Map());
-        await second.open();
-        const events: string[] = [];
-        const served = await second.original(5, {
-            onProgress: (e) => events.push(e.status),
-        });
-
-        expect(served).toEqual(stored);
-        expect(events).toEqual(["skipped"]);
-    });
-
-    it("replaces a live photo an earlier version stored as a ZIP under the image's name", async () => {
-        const { file: live, body } = await asLivePhoto(file(5, "IMG_5.HEIC"));
-        mkdirSync(originals(), { recursive: true });
-        writeFileSync(join(originals(), "5.HEIC"), livePhotoZip());
-        const cache = cacheOf([live], new Map([[5, body]]));
-        await cache.open();
-
-        const result = await cache.original(5);
-
-        expect(result.videoPath).toBe(join(originals(), "5.mov"));
-        expect(readdirSync(originals()).sort()).toEqual([
-            "5.heic",
-            "5.livephoto.json",
-            "5.mov",
-        ]);
-    });
-
-    it("evicts a live photo's image, video and JSON file together", async () => {
-        const a = await asLivePhoto(file(5, "a.HEIC"));
-        const b = await asLivePhoto(file(6, "b.HEIC"));
-        const size = IMAGE.length + VIDEO.length;
-        const cache = new ContentCache({
-            pools: new RequestPools(),
-            source: cdnSource(
-                new Map([
-                    [5, a.body],
-                    [6, b.body],
-                ]),
-            ),
-            cacheDirectory: cacheDir,
-            getFile: (id) => [a.file, b.file].find((f) => f.id === id),
-            // Room for one live photo, on a disk with plenty free.
-            cacheOriginalsMaxBytes: size,
-            freeBelowBytes: 0,
-            statfs: async () => ({ bsize: 1, bavail: 1e12 }),
-        });
-        await cache.open();
-
-        await cache.original(5);
-        await cache.original(6);
-
-        expect(readdirSync(originals()).sort()).toEqual([
-            "6.heic",
-            "6.livephoto.json",
-            "6.mov",
-        ]);
-        expect(cache.originalsStatus().usedBytes).toBe(size);
-    });
-
-    it("stores nothing when a live photo does not match its recorded hash", async () => {
-        const { file: live, body } = await asLivePhoto(
-            file(5, "IMG_5.HEIC"),
-            livePhotoZip(),
-            "not:the recorded hash",
-        );
-        const cache = cacheOf([live], new Map([[5, body]]));
-        await cache.open();
-
-        await expect(cache.original(5)).rejects.toThrow(
-            /file 5: content hash .* does not match/,
-        );
-
-        expect(readdirSync(originals())).toEqual([]);
-        expect(cache.pathsFor(5)).toEqual({});
-    });
-});

test/live-photo.ts

@@ -1,77 +0,0 @@
-/**
- * Live photo fixtures for the download, content cache, backup and CLI tests.
- *
- * Ente stores a live photo as one ZIP holding its image and its video, which
- * Ente's clients name `image.<ext>` and `video.<ext>`. The ZIP is built here
- * with fflate from small fixed bytes and encrypted the way the server serves a
- * file under 4 MiB, as one secretstream chunk. `cdnSource` serves it to the
- * real download layer, so a test checks what quak stores for a real one.
- */
-
-import { createHash } from "node:crypto";
-import { zipSync } from "fflate";
-
-import { ApiClient } from "../src/api/client.js";
-import { encryptBlob, init, toBase64 } from "../src/crypto/index.js";
-import {
-    makeDownloadContentSource,
-    type ContentSource,
-} from "../src/library/content.js";
-import type { EnteFile } from "../src/model/types.js";
-
-export const IMAGE = new TextEncoder().encode("the still image");
-export const VIDEO = new TextEncoder().encode("the few seconds of video");
-
-// A live photo's ZIP; by default the entries an iPhone's live photo gets.
-export const livePhotoZip = (
-    entries: Record<string, Uint8Array> = {
-        "image.heic": IMAGE,
-        "video.mov": VIDEO,
-    },
-): Uint8Array => zipSync(entries);
-
-const blake2b = (bytes: Uint8Array): string =>
-    createHash("blake2b512").update(bytes).digest("base64");
-
-// The hash Ente's clients record for a live photo: the unkeyed BLAKE2b-512 of
-// the image and of the video, each in standard base64, joined by a colon.
-export const livePhotoHash = (image = IMAGE, video = VIDEO): string =>
-    `${blake2b(image)}:${blake2b(video)}`;
-
-// `file` as a live photo whose original is `zip` and whose recorded hash is
-// `hash`, and `body`, what the server serves for it: `zip` encrypted under the
-// file's key and header.
-export const asLivePhoto = async (
-    file: EnteFile,
-    zip = livePhotoZip(),
-    hash = livePhotoHash(),
-): Promise<{ file: EnteFile; body: Uint8Array }> => {
-    await init();
-    const key = new Uint8Array(32).fill(file.id & 0xff);
-    const { header, ciphertext } = encryptBlob(zip, key);
-    return {
-        file: {
-            ...file,
-            key,
-            metadata: { ...file.metadata, fileType: "livePhoto", hash },
-            file: { decryptionHeader: toBase64(header) },
-        },
-        body: ciphertext,
-    };
-};
-
-// A content source that downloads through the real download layer from a
-// stand-in server, which serves `bodies` by file ID and a 404 for any other.
-export const cdnSource = (bodies: Map<number, Uint8Array>): ContentSource =>
-    makeDownloadContentSource(
-        new ApiClient({
-            fetch: (async (url: string | URL) => {
-                const fileID = new URL(String(url)).searchParams.get("fileID");
-                const body = bodies.get(Number(fileID));
-                return body === undefined
-                    ? new Response("not found", { status: 404 })
-                    : new Response(body);
-            }) as typeof globalThis.fetch,
-            retry: { attempts: 1 },
-        }),
-    );