quak backup refuses to run while another backup of the same directory runs, exit 2 (closes #169 )

lib.backup() takes a lock, backup.lock in its download directory, made with proper-lockfile, before its refresh, and removes it when it ends. A second backup of the directory fails at once with an error naming it; quak backup prints it as one line and exits 2. A lock untouched for 10 seconds, left by a killed run, is taken over. Deviation: yarn.lock was regenerated by yarn add in the pinned node image. Judgement call: a run failing at its refresh leaves the directory, empty. Judgement call: a lock removed mid-run stops that run with an uncaught error, the library's default. Model: opus-5-5
quak backup writes each original's EXIF, XMP and dimensions into its JSON (closes #167 )
2026-10-06 14:49:05 +00:00 · 2026-10-06 16:47:31 +02:00
12 changed files with 612 additions and 145 deletions
@@ -524,10 +524,10 @@ stack trace. All three exit with status 3, which means the user must run
 `quak login` again. `quak logout` is the exception: with no file it says there
 is no session and exits 0, and it handles a corrupt file or a failed server call
 as described below. `quak backup` meets an expired session on the refresh that
-starts every run, before it touches any file. A session that stops working
-partway through a backup instead fails each remaining file into `failures.json`,
-so that run exits 1 and the next one stops at its refresh with status 3. No
-command but `quak login` ever prompts.
+starts every run, before it touches any file but its lock (see "Backup layout").
+A session that stops working partway through a backup instead fails each
+remaining file into `failures.json`, so that run exits 1 and the next one stops
+at its refresh with status 3. No command but `quak login` ever prompts.

 `quak logout` ends the session on the server, so the token in `session.json`
 stops working even in a copy of the file, and then deletes the file. If the
@@ -611,7 +611,8 @@ the smallest does not.
                                    below)
        YYYY-MM-DD.<fileID>.json    the file's basic metadata fields quak
                                    keeps, its update time, its private and
-                                    public magic metadata, and its ML data
+                                    public magic metadata, its ML data, and
+                                    its original's EXIF, XMP and dimensions
        YYYY-MM-DD.<fileID>.livephoto.json
                                    which of a live photo's two files is which
    collections/
@@ -620,6 +621,7 @@ the smallest does not.
                                    (symlink)
        <name>.json                 collection metadata + file list
    account.json                    the account's email and user ID
+    backup.lock                     the lock a running backup holds (see below)
    failures.json                   files that failed and have not yet succeeded
 ```

@@ -648,12 +650,38 @@ not in the cache gets the reason in `mlDataError` instead and counts as failed,
 and the next run fetches it again. The JSON files are rewritten on every run, so
 ML data that arrived since the last run appears.

+A file's JSON holds, as `imageMetadata`, what `backup-metadata --exif` records
+from its original, or from a live photo's image: `format`, `width` and `height`
+for a JPEG, `exif` (or `exifRaw` and `exifError`), and `xmp`. An original with
+none of these gets `{}`. A video gets no `imageMetadata`: reading a whole video
+to look for tags is not worth it. When the original cannot be read, the reason
+is in `imageMetadataError` instead; neither the file nor the run fails. The
+original is read when the run stores it, or when the JSON beside it has neither
+field, as one an earlier version wrote. Otherwise the field is taken from that
+JSON when it is rewritten, so a run does not read every stored original again.
+
 `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 `collections/`; `quak backup` does not.

+`backup.lock` keeps two backups of the same directory from running at once, such
+as a cron run that starts while the previous one is still going. A backup
+creates `<dir>` if it is missing and takes the lock before its refresh, and
+removes the lock when it ends, whether it succeeds or fails. The lock is a
+directory that
+[proper-lockfile](https://github.com/moxystudio/node-proper-lockfile) creates
+and keeps touching while the backup runs. A second backup of the directory, from
+another process or the same one, fails at once: `quak backup` prints
+`quak: another backup of <dir> is running` and exits with status 2. It opens its
+library before the backup takes the lock, so a refused run still waits for the
+refresh that opening the library starts before it exits. A run that is killed
+leaves the lock behind; once it has gone 10 seconds untouched, the next run
+takes it over, so nobody has to remove it. The lock is outside the date folders
+and `collections/`, so it is never taken for an original, and the removal of old
+album directories never touches it.
+
 A 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
@@ -901,17 +929,19 @@ photos newest first). `lib.subscribe({ onChange })` delivers a `LibraryChange`
  `SimilarResult[]` (`{ fileID, score }`, cosine similarity, most similar first,
  default limit 20). quak bundles no text encoder, so `searchByEmbedding` takes
  a query vector the caller produced elsewhere.
- `await lib.backup(opts?)` → `BackupResult`. It waits for a refresh as
-  `fresh()` does, puts every in-scope original not already at its save path
-  there as `photo.download()` does (and, with `includeThumbnails`, fetches
-  thumbnails) through the content cache, waits for an ML data fetch, and
-  rebuilds the on-disk backup tree, each file's JSON with its ML data, with a
-  durable failure ledger. A fetched original is written straight to its save
-  path and not into the cache, which then counts it as present; one the cache
-  already held is copied from there. `BackupOptions`: `downloadDirectory` (falls
-  back to the library's), `includeOriginals` (default `true`),
-  `includeThumbnails` (default `false`), `onlyAlbumNames`, and `onProgress`. See
-  Backup layout above for the tree it writes.
+- `await lib.backup(opts?)` → `BackupResult`. It takes the lock in the download
+  directory, and fails at once with an error whose `code` is `ELOCKED` while
+  another backup of it runs. It waits for a refresh as `fresh()` does, puts
+  every in-scope original not already at its save path there as
+  `photo.download()` does (and, with `includeThumbnails`, fetches thumbnails)
+  through the content cache, waits for an ML data fetch, and rebuilds the
+  on-disk backup tree, each file's JSON with its ML data and its original's
+  EXIF, XMP and dimensions, with a durable failure ledger. A fetched original is
+  written straight to its save path and not into the cache, which then counts it
+  as present; one the cache already held is copied from there. `BackupOptions`:
+  `downloadDirectory` (falls back to the library's), `includeOriginals` (default
+  `true`), `includeThumbnails` (default `false`), `onlyAlbumNames`, and
+  `onProgress`. See Backup layout above for the tree it writes.

 ### Request pools

@@ -25,6 +25,24 @@ declares one.

 # Completed Steps

+- 2026-10-06: Two backups of the same directory never run at once (issue 169).
+  `lib.backup()` takes a lock, `backup.lock` in its download directory, made
+  with `proper-lockfile`, before its refresh, and removes it when it ends,
+  whether it succeeds or fails. A second backup of the directory, from another
+  process or the same one, fails at once with an error naming the directory;
+  `quak backup` prints it as one line and exits 2. A lock that has gone 10
+  seconds untouched, left by a run that was killed, is taken over by the next
+  run.
+
+- 2026-10-06: `quak backup` writes each original's EXIF, XMP and dimensions into
+  the file's JSON as `imageMetadata`, what `backup-metadata --exif` records
+  (issue 167): for a live photo from its image, for a video nothing, and `{}`
+  for an original with none of them. A failed read puts the reason in
+  `imageMetadataError` and fails neither the file nor the run. An original is
+  read when the run stores it or when its JSON has neither field; otherwise the
+  field is taken from that JSON. The hand-built JPEGs moved to
+  `test/exif-jpeg.ts`, beside the HEIC.
+
 - 2026-10-06: When the server answers HTTP 401 and that ends a command that
  loads the saved session, because the server no longer accepts its token, the
  command prints one line,
@@ -36,6 +36,7 @@
    "devDependencies": {
        "@eslint/js": "9.38.0",
        "@types/node": "22.18.13",
+        "@types/proper-lockfile": "4.1.4",
        "eslint": "9.38.0",
        "prettier": "3.8.1",
        "typescript": "5.9.3",
@@ -50,6 +51,7 @@
        "fast-srp-hap": "2.0.4",
        "fflate": "0.8.3",
        "jpeg-js": "0.4.4",
-        "libsodium-wrappers-sumo": "0.8.4"
+        "libsodium-wrappers-sumo": "0.8.4",
+        "proper-lockfile": "4.1.2"
    }
 }
@@ -1,20 +1,24 @@
 // 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,
-// puts its original at its save path under `downloadDirectory`, as
-// `Photo.download()` does, waits for an ML data fetch, and rebuilds the derived
-// views (per-file sidecars, per-collection symlink trees, per-collection JSON)
-// from the model. The on-disk layout:
+// `lib.backup()` takes the lock in `downloadDirectory`, and fails at once when
+// another backup of it holds the lock. It waits for a completed refresh of the
+// library (a failed one fails the backup before any file is touched), then, for
+// every file in scope, puts its original at its save path under
+// `downloadDirectory`, as `Photo.download()` does, waits for an ML data fetch,
+// and rebuilds the derived views (per-file sidecars, per-collection symlink
+// trees, per-collection JSON) from the model. The on-disk layout:
 //
 //     <downloadDirectory>/
 //         YYYY/YYYY-MM/YYYY-MM-DD/
 //             YYYY-MM-DD.<fileID>.<ext>    the decrypted bytes (the save path)
 //             YYYY-MM-DD.<fileID>.json     per-file metadata sidecar, with
-//                                          the file's ML data
+//                                          the file's ML data and its
+//                                          original's EXIF, XMP and
+//                                          dimensions
 //         collections/<name>/<title>       symlink to the original
 //         collections/<name>.json          per-collection metadata
 //         account.json                     the account's email and user ID
+//         backup.lock                      the lock, while a backup runs
 //         failures.json                    durable ledger of unresolved failures
 //
 // A live photo's original is its image and its video, each with its own
@@ -28,7 +32,10 @@
 // no unique state, so they are rebuilt every run; that repairs stale sidecars
 // and missing or broken symlinks left by an earlier crash. A rebuild also
 // removes the symlinks to originals that no longer belong to an album, and the
-// directories of albums that no longer exist.
+// directories of albums that no longer exist. The one thing a sidecar takes
+// from the sidecar it replaces is its original's EXIF, XMP and dimensions (or
+// why they could not be read), so that a run does not read every stored
+// original again; a sidecar without them gets them read from the original.
 //
 // Resilience (issue #8): no per-file condition aborts the run. A failed
 // download, a failed symlink, or ML data missing because the ML data fetch
@@ -53,7 +60,9 @@ import {
    symlinkSync,
    writeFileSync,
 } from "node:fs";
+import { readFile } from "node:fs/promises";
 import { dirname, extname, join, relative, resolve } from "node:path";
+import lockfile from "proper-lockfile";

 import { removeLeftoverTempFiles } from "./download/index.js";
 import { sanitizeFileName, withExtension } from "./filename.js";
@@ -64,6 +73,7 @@ import {
    storedAtSavePath,
 } from "./library/content.js";
 import { representative } from "./library/records.js";
+import { extractImageMetadata } from "./metadata-backup.js";
 import type { MLData } from "./mldata-fetch.js";
 import type { Collection, EnteFile, FileMetadata } from "./model/types.js";

@@ -354,12 +364,53 @@ const saveLedger = (path: string, ledger: Map<number, FailureEntry>): void => {
    );
 };

-// The file's JSON: its basic fields, its magic metadata, and its ML data, or
-// the reason the ML data is missing.
+// A file's EXIF, XMP and dimensions as its JSON holds them: what
+// `extractImageMetadata` found in its original, or why the original could not
+// be read.
+interface ImageMetadata {
+    imageMetadata?: Record<string, unknown>;
+    imageMetadataError?: string;
+}
+
+// The image metadata for the file whose original is at `originalPath` (for a
+// live photo, its image) and whose JSON is at `jsonPath`. A video gets none,
+// as `photo.exif()` reads none. An original stored before this run is not read
+// again when its JSON already holds image metadata: that is kept. A failed
+// read gives the reason, and fails neither the file nor the run. An original
+// with no EXIF, XMP or JPEG dimensions gets `{}`, so it is not read again.
+const imageMetadataFor = async (
+    file: EnteFile,
+    originalPath: string,
+    jsonPath: string,
+    storedThisRun: boolean,
+): Promise<ImageMetadata> => {
+    if (file.metadata.fileType === "video") return {};
+    if (!storedThisRun) {
+        try {
+            const { imageMetadata, imageMetadataError } = JSON.parse(
+                readFileSync(jsonPath, "utf-8"),
+            ) as ImageMetadata;
+            if (imageMetadata !== undefined || imageMetadataError !== undefined)
+                return { imageMetadata, imageMetadataError };
+        } catch {
+            // No JSON yet, or one that cannot be parsed: read the original.
+        }
+    }
+    try {
+        const bytes = await readFile(originalPath);
+        return { imageMetadata: extractImageMetadata(bytes) ?? {} };
+    } catch (err) {
+        return { imageMetadataError: errorMessage(err) };
+    }
+};
+
+// The file's JSON: its basic fields, its magic metadata, its ML data or the
+// reason the ML data is missing, and its image metadata.
 const writeSidecar = (
    path: string,
    file: EnteFile,
    ml: { mlData?: MLData; mlDataError?: string },
+    image: ImageMetadata,
 ): void => {
    const meta: Record<string, unknown> = {
        id: file.id,
@@ -372,6 +423,10 @@ const writeSidecar = (
    if (file.pubMagicMetadata) meta.pubMagicMetadata = file.pubMagicMetadata;
    if (ml.mlData) meta.mlData = ml.mlData;
    if (ml.mlDataError) meta.mlDataError = ml.mlDataError;
+    if (image.imageMetadata) meta.imageMetadata = image.imageMetadata;
+    if (image.imageMetadataError) {
+        meta.imageMetadataError = image.imageMetadataError;
+    }
    writeFileSync(path, JSON.stringify(meta, null, 2));
 };

@@ -398,17 +453,12 @@ const writeAlbumJSON = (
    writeFileSync(path, JSON.stringify(album, null, 2));
 };

-export const runBackup = async (
+// The backup itself, which `runBackup` below runs while it holds the lock.
+const runLockedBackup = async (
    lib: BackupLibrary,
    opts: BackupOptions,
+    downloadDirectory: string,
 ): Promise<BackupResult> => {
-    const downloadDirectory = opts.downloadDirectory;
-    if (!downloadDirectory) {
-        throw new Error(
-            "backup requires a downloadDirectory (pass one to backup() or " +
-                "open the library with one)",
-        );
-    }
    const includeOriginals = opts.includeOriginals ?? true;
    const includeThumbnails = opts.includeThumbnails ?? false;
    const log = opts.onProgress ?? (() => {});
@@ -468,6 +518,7 @@ export const runBackup = async (

    const errors: BackupError[] = [];
    const failedThisRun = new Set<number>();
+    const storedThisRun = new Set<number>();
    let downloaded = 0;
    let skipped = 0;

@@ -516,6 +567,7 @@ export const runBackup = async (
                await placeOriginal(downloadDirectory, file, (dest) =>
                    lib.original(fileID, dest),
                );
+                storedThisRun.add(fileID);
                downloaded++;
            } catch (err) {
                log(
@@ -549,9 +601,10 @@ export const runBackup = async (

    // Phase 2: rebuild the derived views from the model. Sidecars first, for
    // every present original (this repairs stale ones), each with the file's
-    // ML data once an ML data fetch has completed. When the fetch fails, a
-    // file with no cached ML data gets the reason instead and is recorded as
-    // failed. The next run fetches its ML data again because none is cached.
+    // ML data once an ML data fetch has completed, and its image metadata.
+    // When the fetch fails, a file with no cached ML data gets the reason
+    // instead and is recorded as failed. The next run fetches its ML data
+    // again because none is cached.
    if (includeOriginals) {
        let mlDataError: string | undefined;
        try {
@@ -562,23 +615,28 @@ export const runBackup = async (
            log(`FAILED ML data: ${mlDataError}`);
        }
        for (const file of distinct.values()) {
-            if (storedAtSavePath(downloadDirectory, file) === undefined) {
-                continue;
-            }
+            const stored = storedAtSavePath(downloadDirectory, file);
+            if (stored === undefined) continue;
            const path = withExtension(
                savePath(downloadDirectory, file),
                ".json",
            );
+            const image = await imageMetadataFor(
+                file,
+                stored.path,
+                path,
+                storedThisRun.has(file.id),
+            );
            const mlData = await lib.mlData(file.id);
            if (mlData === undefined && mlDataError !== undefined) {
-                writeSidecar(path, file, { mlDataError });
+                writeSidecar(path, file, { mlDataError }, image);
                recordFailure(
                    file,
                    collectionName.get(file.collectionID) ?? "",
                    new Error(`ML data: ${mlDataError}`),
                );
            } else {
-                writeSidecar(path, file, { mlData });
+                writeSidecar(path, file, { mlData }, image);
            }
        }
    }
@@ -676,3 +734,39 @@ export const runBackup = async (
        errors,
    };
 };
+
+// Only one backup of a directory runs at a time, in this process or another:
+// a second one fails at once with an error whose `code` is `ELOCKED`. The lock
+// is the directory `backup.lock`, whose modification time proper-lockfile
+// keeps current while the backup runs. One it has not touched for 10 seconds
+// was left by a run that was killed, and is taken over.
+export const runBackup = async (
+    lib: BackupLibrary,
+    opts: BackupOptions,
+): Promise<BackupResult> => {
+    const downloadDirectory = opts.downloadDirectory;
+    if (!downloadDirectory) {
+        throw new Error(
+            "backup requires a downloadDirectory (pass one to backup() or " +
+                "open the library with one)",
+        );
+    }
+    mkdirSync(downloadDirectory, { recursive: true });
+    let release: () => Promise<void>;
+    try {
+        release = await lockfile.lock(downloadDirectory, {
+            lockfilePath: join(downloadDirectory, "backup.lock"),
+        });
+    } catch (err) {
+        if ((err as NodeJS.ErrnoException).code !== "ELOCKED") throw err;
+        throw Object.assign(
+            new Error(`another backup of ${downloadDirectory} is running`),
+            { code: "ELOCKED" },
+        );
+    }
+    try {
+        return await runLockedBackup(lib, opts, downloadDirectory);
+    } finally {
+        await release();
+    }
+};
@@ -22,6 +22,7 @@ import {
 } from "./client.js";
 import { init } from "./crypto/index.js";
 import {
+    type BackupResult,
    defaultCacheDirectory,
    Library,
    type LibraryClient,
@@ -418,12 +419,20 @@ export const backupCommand = async (
        precacheOriginals: false,
    });
    try {
-        const result = await lib.backup({
-            downloadDirectory: dir,
-            onProgress: (msg) => {
-                if (!opts.json) ctx.stderr.write(msg + "\n");
-            },
-        });
+        let result: BackupResult;
+        try {
+            result = await lib.backup({
+                downloadDirectory: dir,
+                onProgress: (msg) => {
+                    if (!opts.json) ctx.stderr.write(msg + "\n");
+                },
+            });
+        } catch (err) {
+            // Another backup of `dir` is running and holds its lock.
+            if ((err as NodeJS.ErrnoException).code !== "ELOCKED") throw err;
+            ctx.stderr.write(`quak: ${(err as Error).message}\n`);
+            return 2;
+        }

        if (opts.json) {
            ctx.stdout.write(JSON.stringify(result, null, 2) + "\n");
@@ -566,13 +566,15 @@ export class Library {

    // Back up every in-scope file to `opts.downloadDirectory`, or else the
    // library's, each original at its save path, with a durable failure
-    // ledger (issue #51). Waits for a completed refresh first, as `fresh()`
-    // does, joining one already running, and rejects before touching any file
-    // when it fails. Then puts pending originals at their save paths as
-    // `Photo.download()` does (and optional thumbnails) through the content
-    // cache and pools, waits for an ML data fetch, and rebuilds the derived
-    // symlink/JSON views from the model, each file's JSON with its ML data,
-    // beside an `account.json` with the account's email and user ID.
+    // ledger (issue #51). Takes the lock in that directory first, failing at
+    // once while another backup of it runs (see `runBackup`). Waits for a
+    // completed refresh, as `fresh()` does, joining one already running, and
+    // rejects before touching any file but the lock when it fails. Then puts
+    // pending originals at their save paths as `Photo.download()` does (and
+    // optional thumbnails) through the content cache and pools, waits for an
+    // ML data fetch, and rebuilds the derived symlink/JSON views from the
+    // model, each file's JSON with its ML data, beside an `account.json` with
+    // the account's email and user ID.
    // Throws before any network work when no content cache backs the
    // originals it must fetch.
    backup(opts?: BackupOptions): Promise<BackupResult> {
@@ -33,6 +33,7 @@
 */

 import {
+    chmodSync,
    existsSync,
    lstatSync,
    mkdirSync,
@@ -42,6 +43,7 @@ import {
    readlinkSync,
    rmSync,
    symlinkSync,
+    utimesSync,
    writeFileSync,
 } from "node:fs";
 import { spawnSync } from "node:child_process";
@@ -53,12 +55,16 @@ import { runBackup, type BackupLibrary } from "../../src/backup.js";
 import { Library } from "../../src/library/index.js";
 import type { ContentSource } from "../../src/library/content.js";
 import type { CollectionsPage, FilesPage } from "../../src/client.js";
+import { extractImageMetadata } from "../../src/metadata-backup.js";
 import type { MLData } from "../../src/mldata-fetch.js";
 import type { Collection, EnteFile } from "../../src/model/types.js";
+import { HEIC_WITH_EXIF } from "../exif-heic.js";
+import { JPEG_WITH_EXIF } from "../exif-jpeg.js";
 import {
    asLivePhoto,
    cdnSource,
    IMAGE,
+    livePhotoHash,
    livePhotoZip,
    VIDEO,
 } from "../live-photo.js";
@@ -825,7 +831,81 @@ describe("the refresh before a backup", () => {
        );

        expect(source.originalCalls).toBe(0);
-        expect(existsSync(outDir)).toBe(false);
+        // The backup made the directory for its lock, and removed the lock.
+        expect(readdirSync(outDir)).toEqual([]);
+        await lib.close();
+    });
+});
+
+describe("the backup lock", () => {
+    const lockPath = (outDir: string): string => join(outDir, "backup.lock");
+
+    it("refuses a second backup of the directory while one runs", async () => {
+        await fillCache();
+        const client = new HeldClient();
+        const lib = await openLibrary(stubSource(), client);
+        const outDir = join(root, "backup");
+        // The first backup holds the lock once it starts its refresh, which
+        // `HeldClient` keeps from finishing.
+        let refreshing!: () => void;
+        const started = new Promise<void>((resolve) => {
+            refreshing = resolve;
+        });
+        const first = lib.backup({
+            downloadDirectory: outDir,
+            onProgress: (msg) => {
+                if (msg === "Refreshing library...") refreshing();
+            },
+        });
+        await started;
+
+        await expect(lib.backup({ downloadDirectory: outDir })).rejects.toThrow(
+            `another backup of ${outDir} is running`,
+        );
+
+        client.release();
+        expect((await first).failed).toBe(0);
+        await lib.close();
+    });
+
+    it("releases the lock after a backup succeeds", async () => {
+        const lib = await openLibrary(stubSource());
+        const outDir = join(root, "backup");
+
+        await lib.backup({ downloadDirectory: outDir });
+
+        expect(existsSync(lockPath(outDir))).toBe(false);
+        // So the next backup of the directory runs.
+        expect((await lib.backup({ downloadDirectory: outDir })).skipped).toBe(
+            3,
+        );
+        await lib.close();
+    });
+
+    it("releases the lock after a backup fails", async () => {
+        const lib = await openLibrary(stubSource(), new FailingClient());
+        const outDir = join(root, "backup");
+
+        await expect(lib.backup({ downloadDirectory: outDir })).rejects.toThrow(
+            "HTTP 401 from server",
+        );
+
+        expect(existsSync(lockPath(outDir))).toBe(false);
+        await lib.close();
+    });
+
+    it("takes over a lock left by a run that was killed", async () => {
+        const outDir = join(root, "backup");
+        // A killed run's lock, last touched a minute ago.
+        mkdirSync(lockPath(outDir), { recursive: true });
+        const minuteAgo = new Date(Date.now() - 60_000);
+        utimesSync(lockPath(outDir), minuteAgo, minuteAgo);
+        const lib = await openLibrary(stubSource());
+
+        const result = await lib.backup({ downloadDirectory: outDir });
+
+        expect(result.downloaded).toBe(3);
+        expect(existsSync(lockPath(outDir))).toBe(false);
        await lib.close();
    });
 });
@@ -1018,6 +1098,179 @@ describe("account and album records", () => {
    });
 });

+// What a file's JSON holds as `imageMetadata` for an original of `bytes`.
+const imageMetadataOf = (bytes: Uint8Array): unknown =>
+    JSON.parse(JSON.stringify(extractImageMetadata(bytes)));
+
+describe("image metadata in each file's JSON", () => {
+    // Serves `files` in the Vacation album and nothing in Work.
+    class FilesClient extends MockClient {
+        constructor(private readonly files: EnteFile[]) {
+            super();
+        }
+        override async filesSince(args: {
+            collectionID: number;
+        }): Promise<FilesPage> {
+            return {
+                files: args.collectionID === 1 ? this.files : [],
+                deleted: [],
+                cursor: 1,
+            };
+        }
+    }
+
+    // Writes `originals.get(fileID)` as each file's original, looked up at
+    // each fetch, so a test can change it between runs.
+    const bytesSource = (
+        originals: Map<number, Uint8Array>,
+    ): ContentSource => ({
+        original: async ({ file: f, destination }) => {
+            const bytes = originals.get(f.id)!;
+            writeFileSync(destination, bytes);
+            return { bytesWritten: bytes.length };
+        },
+        thumbnail: async () => {
+            throw new Error("no thumbnails in this source");
+        },
+    });
+
+    // A JPEG, a HEIC, a video, and a file holding no image metadata. The
+    // video's bytes are the JPEG's, so reading it would find EXIF.
+    const clip = file(602, 1, "clip.mov");
+    const files = [
+        file(600, 1, "photo.jpg"),
+        file(601, 1, "photo.heic"),
+        { ...clip, metadata: { ...clip.metadata, fileType: "video" as const } },
+        file(603, 1, "notes.png"),
+    ];
+    const originals = (): Map<number, Uint8Array> =>
+        new Map([
+            [600, JPEG_WITH_EXIF],
+            [601, HEIC_WITH_EXIF],
+            [602, JPEG_WITH_EXIF],
+            [603, new TextEncoder().encode("not an image")],
+        ]);
+    const open = (bytes = originals()): Promise<Library> =>
+        openLibrary(bytesSource(bytes), new FilesClient(files));
+
+    // Rewrite the JSON of `fileID` without its image metadata, as an earlier
+    // version of quak wrote it.
+    const dropImageMetadata = (outDir: string, fileID: number): void => {
+        const json = fileJSON(outDir, fileID);
+        delete json.imageMetadata;
+        writeFileSync(saved(outDir, `${fileID}.json`), JSON.stringify(json));
+    };
+
+    it("writes each new original's image metadata, and none for a video", async () => {
+        const lib = await open();
+        const outDir = join(root, "backup");
+
+        const result = await lib.backup({ downloadDirectory: outDir });
+
+        expect(result).toMatchObject({ downloaded: 4, failed: 0 });
+        expect(fileJSON(outDir, 600).imageMetadata).toEqual(
+            imageMetadataOf(JPEG_WITH_EXIF),
+        );
+        expect(fileJSON(outDir, 601).imageMetadata).toEqual(
+            imageMetadataOf(HEIC_WITH_EXIF),
+        );
+        expect(fileJSON(outDir, 602)).not.toHaveProperty("imageMetadata");
+        expect(fileJSON(outDir, 602)).not.toHaveProperty("imageMetadataError");
+        // Empty, so that the next run does not read it again.
+        expect(fileJSON(outDir, 603).imageMetadata).toEqual({});
+        await lib.close();
+    });
+
+    it("reads a live photo's image", async () => {
+        const { file: live, body } = await asLivePhoto(
+            file(500, 1, "IMG_0500.HEIC"),
+            livePhotoZip({ "image.heic": HEIC_WITH_EXIF, "video.mov": VIDEO }),
+            livePhotoHash(HEIC_WITH_EXIF, VIDEO),
+        );
+        const lib = await openLibrary(
+            cdnSource(new Map([[500, body]])),
+            new FilesClient([live]),
+        );
+        const outDir = join(root, "backup");
+
+        await lib.backup({ downloadDirectory: outDir });
+
+        expect(fileJSON(outDir, 500).imageMetadata).toEqual(
+            imageMetadataOf(HEIC_WITH_EXIF),
+        );
+        await lib.close();
+    });
+
+    it("keeps the image metadata of an original stored by an earlier run without reading it again", async () => {
+        const lib = await open();
+        const outDir = join(root, "backup");
+        await lib.backup({ downloadDirectory: outDir });
+        // A read of the original now would give the HEIC's.
+        writeFileSync(saved(outDir, "600.jpg"), HEIC_WITH_EXIF);
+
+        const second = await lib.backup({ downloadDirectory: outDir });
+
+        expect(second).toMatchObject({ downloaded: 0, failed: 0 });
+        expect(fileJSON(outDir, 600).imageMetadata).toEqual(
+            imageMetadataOf(JPEG_WITH_EXIF),
+        );
+        await lib.close();
+    });
+
+    it("reads an original stored by an earlier version, whose JSON has no image metadata", async () => {
+        const lib = await open();
+        const outDir = join(root, "backup");
+        await lib.backup({ downloadDirectory: outDir });
+        dropImageMetadata(outDir, 600);
+
+        const second = await lib.backup({ downloadDirectory: outDir });
+
+        expect(second).toMatchObject({ downloaded: 0, failed: 0 });
+        expect(fileJSON(outDir, 600).imageMetadata).toEqual(
+            imageMetadataOf(JPEG_WITH_EXIF),
+        );
+        await lib.close();
+    });
+
+    it("reads an original the run stores again, though its JSON has image metadata", async () => {
+        const bytes = originals();
+        const lib = await open(bytes);
+        const outDir = join(root, "backup");
+        await lib.backup({ downloadDirectory: outDir });
+        rmSync(saved(outDir, "600.jpg"));
+        bytes.set(600, HEIC_WITH_EXIF);
+
+        const second = await lib.backup({ downloadDirectory: outDir });
+
+        expect(second).toMatchObject({ downloaded: 1, failed: 0 });
+        expect(fileJSON(outDir, 600).imageMetadata).toEqual(
+            imageMetadataOf(HEIC_WITH_EXIF),
+        );
+        await lib.close();
+    });
+
+    // Root ignores file permissions, so this fails when run as root. The
+    // `test` phase of the `Dockerfile` runs as the `node` user.
+    it("gives the reason an original could not be read, failing neither the file nor the run", async () => {
+        const lib = await open();
+        const outDir = join(root, "backup");
+        await lib.backup({ downloadDirectory: outDir });
+        dropImageMetadata(outDir, 600);
+        const original = saved(outDir, "600.jpg");
+        chmodSync(original, 0o000);
+
+        const second = await lib
+            .backup({ downloadDirectory: outDir })
+            .finally(() => chmodSync(original, 0o600));
+
+        expect(second).toMatchObject({ failed: 0, errors: [] });
+        expect(existsSync(join(outDir, "failures.json"))).toBe(false);
+        expect(fileJSON(outDir, 600)).not.toHaveProperty("imageMetadata");
+        expect(fileJSON(outDir, 600).imageMetadataError).toMatch(/EACCES/);
+        await lib.close();
+    });
+});
+
 // Every entry under collections/, one level of directories deep, with each
 // symlink's target.
 const tree = (outDir: string): string[] => {
@@ -18,6 +18,7 @@ import {
    readFileSync,
    rmSync,
    statSync,
+    utimesSync,
    writeFileSync,
 } from "node:fs";
 import { join } from "node:path";
@@ -792,7 +793,7 @@ describe("backup", () => {
        expect(code).toBe(1);
        expect(runText).toBe("quak: HTTP 503 from server\n");
        expect(stderr.text).toBe("Starting backup...\nRefreshing library...\n");
-        expect(existsSync(dir)).toBe(false);
+        expect(readdirSync(dir)).toEqual([]);
    });

    // A real saved session, read back by `loadSession`, whose server answers
@@ -823,7 +824,23 @@ describe("backup", () => {
            `quak: the saved session is no longer valid; run "quak login"\n`,
        );
        expect(stderr.text).toBe("Starting backup...\nRefreshing library...\n");
-        expect(existsSync(dir)).toBe(false);
+        expect(readdirSync(dir)).toEqual([]);
+    });
+
+    it("exits 2 with one line naming the directory while another backup of it runs", async () => {
+        const dir = join(root, "backup");
+        // The lock another backup holds. Its modification time is set an hour
+        // ahead, so it stays current however long this test takes.
+        const lock = join(dir, "backup.lock");
+        mkdirSync(lock, { recursive: true });
+        const hourAhead = new Date(Date.now() + 3_600_000);
+        utimesSync(lock, hourAhead, hourAhead);
+
+        expect(await backupCommand(context(), dir, {})).toBe(2);
+        expect(stderr.text).toBe(
+            `Starting backup...\nquak: another backup of ${dir} is running\n`,
+        );
+        expect(readdirSync(dir)).toEqual(["backup.lock"]);
    });
 });

@@ -1,7 +1,7 @@
 /**
 * `exif.heic`, beside this file: a real 64x64 HEIC whose EXIF holds the same
- * values as the hand-built JPEG in `library/content-library.test.ts`, for the
- * tests of `exif()` and `backup-metadata --exif`.
+ * values as the hand-built JPEG in `exif-jpeg.ts`, for the tests of `exif()`,
+ * `backup-metadata --exif` and the image metadata `quak backup` records.
 *
 * It was made once, in a throwaway node:22-alpine container (Alpine 3.23.3),
 * with libheif 1.23.0 and exiftool 13.55:
@@ -0,0 +1,89 @@
+/**
+ * Hand-built JPEGs for the tests of `exif()` and of the image metadata
+ * `quak backup` records: one whose EXIF holds the same values as `exif.heic`
+ * (see `exif-heic.ts`), and one whose EXIF cannot be parsed.
+ */
+
+// Big-endian bytes for the hand-built JPEG below.
+const u16 = (n: number): number[] => [n >> 8, n & 0xff];
+const u32 = (n: number): number[] => [...u16(n >>> 16), ...u16(n & 0xffff)];
+const ascii = (s: string): number[] => [...new TextEncoder().encode(s), 0];
+const rational = (num: number, den: number): number[] => [
+    ...u32(num),
+    ...u32(den),
+];
+// One IFD entry: tag, type (1 BYTE, 2 ASCII, 3 SHORT, 4 LONG, 5 RATIONAL),
+// count, then the value when it fits in 4 bytes, else its offset.
+const entry = (
+    tag: number,
+    type: number,
+    count: number,
+    value: number[],
+): number[] => [...u16(tag), ...u16(type), ...u32(count), ...value];
+
+// The TIFF block of a JPEG's EXIF segment, holding every field `Photo`'s typed
+// methods return: the camera in the first IFD, the exposure in the Exif IFD,
+// and a GPS position of 40°26'46" N, 79°58'56" W, 12.5 m below sea level.
+// Offsets count from the start of this block.
+const TIFF = [
+    ...[0x4d, 0x4d, 0x00, 0x2a], // big-endian TIFF
+    ...u32(8), // the first IFD's offset
+    // The first IFD, at 8: five entries, then no next IFD.
+    ...u16(5),
+    ...entry(0x010f, 2, 6, u32(74)), // Make
+    ...entry(0x0110, 2, 7, u32(80)), // Model
+    ...entry(0x0112, 3, 1, [...u16(6), 0, 0]), // Orientation
+    ...entry(0x8769, 4, 1, u32(88)), // the Exif IFD's offset
+    ...entry(0x8825, 4, 1, u32(246)), // the GPS IFD's offset
+    ...u32(0),
+    ...ascii("Canon"), // at 74
+    ...ascii("EOS R5"), // at 80
+    0, // a pad byte
+    // The Exif IFD, at 88: seven entries, then no next IFD.
+    ...u16(7),
+    ...entry(0x829a, 5, 1, u32(178)), // ExposureTime
+    ...entry(0x829d, 5, 1, u32(186)), // FNumber
+    ...entry(0x8827, 3, 1, [...u16(400), 0, 0]), // ISOSpeedRatings
+    ...entry(0x9003, 2, 20, u32(194)), // DateTimeOriginal
+    ...entry(0x9011, 2, 7, u32(214)), // OffsetTimeOriginal
+    ...entry(0x920a, 5, 1, u32(222)), // FocalLength
+    ...entry(0xa434, 2, 16, u32(230)), // LensModel
+    ...u32(0),
+    ...rational(1, 250), // at 178
+    ...rational(28, 10), // at 186
+    ...ascii("2021:07:15 14:30:00"), // at 194
+    ...ascii("+02:00"), // at 214
+    0, // a pad byte
+    ...rational(50, 1), // at 222
+    ...ascii("RF50mm F1.8 STM"), // at 230
+    // The GPS IFD, at 246: six entries, then no next IFD.
+    ...u16(6),
+    ...entry(0x0001, 2, 2, [...ascii("N"), 0, 0]), // GPSLatitudeRef
+    ...entry(0x0002, 5, 3, u32(324)), // GPSLatitude
+    ...entry(0x0003, 2, 2, [...ascii("W"), 0, 0]), // GPSLongitudeRef
+    ...entry(0x0004, 5, 3, u32(348)), // GPSLongitude
+    ...entry(0x0005, 1, 1, [1, 0, 0, 0]), // GPSAltitudeRef: below sea level
+    ...entry(0x0006, 5, 1, u32(372)), // GPSAltitude
+    ...u32(0),
+    ...[...rational(40, 1), ...rational(26, 1), ...rational(46, 1)], // at 324
+    ...[...rational(79, 1), ...rational(58, 1), ...rational(56, 1)], // at 348
+    ...rational(25, 2), // at 372
+];
+
+export const JPEG_WITH_EXIF = new Uint8Array([
+    ...[0xff, 0xd8], // start of image
+    ...[0xff, 0xe1, ...u16(2 + 6 + TIFF.length)], // APP1 and its length
+    ...[...ascii("Exif"), 0], // "Exif\0\0"
+    ...TIFF,
+    ...[0xff, 0xda, 0x00, 0x02], // start of scan
+]);
+
+// A JPEG whose EXIF segment is laid out correctly but holds "XX" where the TIFF
+// byte order belongs, so exifreader cannot parse it.
+export const JPEG_WITH_BAD_EXIF = new Uint8Array([
+    ...[0xff, 0xd8], // start of image
+    ...[0xff, 0xe1, ...u16(2 + 6 + 2)], // APP1 and its length
+    ...[...ascii("Exif"), 0], // "Exif\0\0"
+    ...[0x58, 0x58], // "XX"
+    ...[0xff, 0xda, 0x00, 0x02], // start of scan
+]);
@@ -29,6 +29,7 @@ import type { CollectionsPage, FilesPage } from "../../src/client.js";
 import type { Collection, EnteFile } from "../../src/model/types.js";
 import { readPhotoExif, type PhotoExif } from "../../src/exif.js";
 import { HEIC_WITH_EXIF } from "../exif-heic.js";
+import { JPEG_WITH_BAD_EXIF, JPEG_WITH_EXIF } from "../exif-jpeg.js";
 import {
    asLivePhoto,
    cdnSource,
@@ -256,90 +257,6 @@ describe("Library content wiring", () => {
    });
 });

-// Big-endian bytes for the hand-built JPEG below.
-const u16 = (n: number): number[] => [n >> 8, n & 0xff];
-const u32 = (n: number): number[] => [...u16(n >>> 16), ...u16(n & 0xffff)];
-const ascii = (s: string): number[] => [...new TextEncoder().encode(s), 0];
-const rational = (num: number, den: number): number[] => [
-    ...u32(num),
-    ...u32(den),
-];
-// One IFD entry: tag, type (1 BYTE, 2 ASCII, 3 SHORT, 4 LONG, 5 RATIONAL),
-// count, then the value when it fits in 4 bytes, else its offset.
-const entry = (
-    tag: number,
-    type: number,
-    count: number,
-    value: number[],
-): number[] => [...u16(tag), ...u16(type), ...u32(count), ...value];
-
-// The TIFF block of a JPEG's EXIF segment, holding every field `Photo`'s typed
-// methods return: the camera in the first IFD, the exposure in the Exif IFD,
-// and a GPS position of 40°26'46" N, 79°58'56" W, 12.5 m below sea level.
-// Offsets count from the start of this block.
-const TIFF = [
-    ...[0x4d, 0x4d, 0x00, 0x2a], // big-endian TIFF
-    ...u32(8), // the first IFD's offset
-    // The first IFD, at 8: five entries, then no next IFD.
-    ...u16(5),
-    ...entry(0x010f, 2, 6, u32(74)), // Make
-    ...entry(0x0110, 2, 7, u32(80)), // Model
-    ...entry(0x0112, 3, 1, [...u16(6), 0, 0]), // Orientation
-    ...entry(0x8769, 4, 1, u32(88)), // the Exif IFD's offset
-    ...entry(0x8825, 4, 1, u32(246)), // the GPS IFD's offset
-    ...u32(0),
-    ...ascii("Canon"), // at 74
-    ...ascii("EOS R5"), // at 80
-    0, // a pad byte
-    // The Exif IFD, at 88: seven entries, then no next IFD.
-    ...u16(7),
-    ...entry(0x829a, 5, 1, u32(178)), // ExposureTime
-    ...entry(0x829d, 5, 1, u32(186)), // FNumber
-    ...entry(0x8827, 3, 1, [...u16(400), 0, 0]), // ISOSpeedRatings
-    ...entry(0x9003, 2, 20, u32(194)), // DateTimeOriginal
-    ...entry(0x9011, 2, 7, u32(214)), // OffsetTimeOriginal
-    ...entry(0x920a, 5, 1, u32(222)), // FocalLength
-    ...entry(0xa434, 2, 16, u32(230)), // LensModel
-    ...u32(0),
-    ...rational(1, 250), // at 178
-    ...rational(28, 10), // at 186
-    ...ascii("2021:07:15 14:30:00"), // at 194
-    ...ascii("+02:00"), // at 214
-    0, // a pad byte
-    ...rational(50, 1), // at 222
-    ...ascii("RF50mm F1.8 STM"), // at 230
-    // The GPS IFD, at 246: six entries, then no next IFD.
-    ...u16(6),
-    ...entry(0x0001, 2, 2, [...ascii("N"), 0, 0]), // GPSLatitudeRef
-    ...entry(0x0002, 5, 3, u32(324)), // GPSLatitude
-    ...entry(0x0003, 2, 2, [...ascii("W"), 0, 0]), // GPSLongitudeRef
-    ...entry(0x0004, 5, 3, u32(348)), // GPSLongitude
-    ...entry(0x0005, 1, 1, [1, 0, 0, 0]), // GPSAltitudeRef: below sea level
-    ...entry(0x0006, 5, 1, u32(372)), // GPSAltitude
-    ...u32(0),
-    ...[...rational(40, 1), ...rational(26, 1), ...rational(46, 1)], // at 324
-    ...[...rational(79, 1), ...rational(58, 1), ...rational(56, 1)], // at 348
-    ...rational(25, 2), // at 372
-];
-
-const JPEG_WITH_EXIF = new Uint8Array([
-    ...[0xff, 0xd8], // start of image
-    ...[0xff, 0xe1, ...u16(2 + 6 + TIFF.length)], // APP1 and its length
-    ...[...ascii("Exif"), 0], // "Exif\0\0"
-    ...TIFF,
-    ...[0xff, 0xda, 0x00, 0x02], // start of scan
-]);
-
-// A JPEG whose EXIF segment is laid out correctly but holds "XX" where the TIFF
-// byte order belongs, so exifreader cannot parse it.
-const JPEG_WITH_BAD_EXIF = new Uint8Array([
-    ...[0xff, 0xd8], // start of image
-    ...[0xff, 0xe1, ...u16(2 + 6 + 2)], // APP1 and its length
-    ...[...ascii("Exif"), 0], // "Exif\0\0"
-    ...[0x58, 0x58], // "XX"
-    ...[0xff, 0xda, 0x00, 0x02], // start of scan
-]);
-
 describe("Photo save path, local copy, content and EXIF", () => {
    // The same account, with `files` in its album instead.
    class FilesClient extends MockClient {
@@ -535,6 +535,18 @@
  dependencies:
    undici-types "~6.21.0"

+"@types/proper-lockfile@4.1.4":
+  version "4.1.4"
+  resolved "https://registry.yarnpkg.com/@types/proper-lockfile/-/proper-lockfile-4.1.4.tgz#cd9fab92bdb04730c1ada542c356f03620f84008"
+  integrity sha512-uo2ABllncSqg9F1D4nugVl9v93RmjxF6LJzQLMLDdPaXCUIDPeOJ21Gbqi43xNKzBi/WQ0Q0dICqufzQbMjipQ==
+  dependencies:
+    "@types/retry" "*"
+
+"@types/retry@*":
+  version "0.12.5"
+  resolved "https://registry.yarnpkg.com/@types/retry/-/retry-0.12.5.tgz#f090ff4bd8d2e5b940ff270ab39fd5ca1834a07e"
+  integrity sha512-3xSjTp3v03X/lSQLkczaN9UIEwJMoMCA1+Nb5HfbJEQWogdeQIyVtTvxPXDQjZ5zws8rFQfVfRdz03ARihPJgw==
+
 "@typescript-eslint/eslint-plugin@8.46.2":
  version "8.46.2"
  resolved "https://registry.yarnpkg.com/@typescript-eslint/eslint-plugin/-/eslint-plugin-8.46.2.tgz#dc4ab93ee3d7e6c8e38820a0d6c7c93c7183e2dc"
@@ -1140,6 +1152,11 @@ globals@^14.0.0:
  resolved "https://registry.yarnpkg.com/globals/-/globals-14.0.0.tgz#898d7413c29babcf6bafe56fcadded858ada724e"
  integrity sha512-oahGvuMGQlPw/ivIYBjVSrWAfWLBeku5tpPE2fOPLi+WHffIWbuh2tCjhyQhTBPMf5E9jDEH4FOmTYgYwbKwtQ==

+graceful-fs@^4.2.4:
+  version "4.2.11"
+  resolved "https://registry.yarnpkg.com/graceful-fs/-/graceful-fs-4.2.11.tgz#4183e4e8bf08bb6e05bbb2f7d2e0c8f712ca40e3"
+  integrity sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==
+
 graphemer@^1.4.0:
  version "1.4.0"
  resolved "https://registry.yarnpkg.com/graphemer/-/graphemer-1.4.0.tgz#fb2f1d55e0e3a1849aeffc90c4fa0dd53a0e66c6"
@@ -1414,6 +1431,15 @@ prettier@3.8.1:
  resolved "https://registry.yarnpkg.com/prettier/-/prettier-3.8.1.tgz#edf48977cf991558f4fcbd8a3ba6015ba2a3a173"
  integrity sha512-UOnG6LftzbdaHZcKoPFtOcCKztrQ57WkHDeRD9t/PTQtmT0NHSeWWepj6pS0z/N7+08BHFDQVUrfmfMRcZwbMg==

+proper-lockfile@4.1.2:
+  version "4.1.2"
+  resolved "https://registry.yarnpkg.com/proper-lockfile/-/proper-lockfile-4.1.2.tgz#c8b9de2af6b2f1601067f98e01ac66baa223141f"
+  integrity sha512-TjNPblN4BwAWMXU8s9AEz4JmQxnD1NNL7bNOY/AKUzyamc379FWASUhc/K1pL2noVb+XmZKLL68cjzLsiOAMaA==
+  dependencies:
+    graceful-fs "^4.2.4"
+    retry "^0.12.0"
+    signal-exit "^3.0.2"
+
 punycode@^2.1.0:
  version "2.3.1"
  resolved "https://registry.yarnpkg.com/punycode/-/punycode-2.3.1.tgz#027422e2faec0b25e1549c3e1bd8309b9133b6e5"
@@ -1429,6 +1455,11 @@ resolve-from@^4.0.0:
  resolved "https://registry.yarnpkg.com/resolve-from/-/resolve-from-4.0.0.tgz#4abcd852ad32dd7baabfe9b40e00a36db5f392e6"
  integrity sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==

+retry@^0.12.0:
+  version "0.12.0"
+  resolved "https://registry.yarnpkg.com/retry/-/retry-0.12.0.tgz#1b42a6266a21f07421d1b0b54b7dc167b01c013b"
+  integrity sha512-9LkiTwjUh6rT555DtE9rTX+BKByPfrMzEAtnlEtdEwr3Nkffwiihqe2bWADg+OQRjt9gl6ICdmB/ZFDCGAtSow==
+
 reusify@^1.0.4:
  version "1.1.0"
  resolved "https://registry.yarnpkg.com/reusify/-/reusify-1.1.0.tgz#0fe13b9522e1473f51b558ee796e08f11f9b489f"
@@ -1502,6 +1533,11 @@ siginfo@^2.0.0:
  resolved "https://registry.yarnpkg.com/siginfo/-/siginfo-2.0.0.tgz#32e76c70b79724e3bb567cb9d543eb858ccfaf30"
  integrity sha512-ybx0WO1/8bSBLEWXZvEd7gMW3Sn3JFlW3TvX1nREbDLRNQNaeNN8WK0meBwPdAaOI7TtRRRJn/Es1zhrrCHu7g==

+signal-exit@^3.0.2:
+  version "3.0.7"
+  resolved "https://registry.yarnpkg.com/signal-exit/-/signal-exit-3.0.7.tgz#a9a1767f8af84155114eaabd73f99273c8f59ad9"
+  integrity sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ==
+
 signal-exit@^4.1.0:
  version "4.1.0"
  resolved "https://registry.yarnpkg.com/signal-exit/-/signal-exit-4.1.0.tgz#952188c1cbd546070e2dd20d0f41c0ae0530cb04"