exif() returns every EXIF tag in the file (closes #156 )

`photo.exif()` returns `ExifTags`: every EXIF tag exifreader reads from the file, keyed by tag name, each with exifreader's `id`, `value`, `description` and `computed`. The embedded thumbnail's tags are under `Thumbnail`, without the thumbnail image. A file with no EXIF, or a video, gives `{}`. The thirteen typed methods stay. Each picks its field from the tags `exif()` returns through `readPhotoExif`, which now takes the tags instead of the bytes. GPS latitude and longitude are worked out from their tags and reference tags, since exifreader's computed position is not among the tags. Also closes #148. Model: opus-5-5
2026-10-02 02:02:37 +00:00
18 changed files with 125 additions and 410 deletions
@@ -1,12 +1,9 @@
 # Mirrors .gitignore, with one deliberate exception: .gitignore itself stays
 # in the build context, because prettier 3 reads it as a default ignore file
 # and dropping it would change what the lint phase's prettier check sees.
-#
-# .git is deliberately NOT excluded: the build derives the version it stamps
-# from it (script/version). It is sent without its config, which holds the
-# clone's remote URL and any credential in it, and which the build stage, the
-# final image, would otherwise carry. git describe does not need it.
-.git/config
+
+# VCS
+.git

 # OS
 .DS_Store
@@ -61,12 +61,9 @@ RUN script/bootstrap

 COPY . .

-# Version stamped into the build: the VERSION build arg when one is given,
-# otherwise what script/version derives from the .git the build context
-# carries (script/bootstrap installed git), so any `docker build .` of a
-# clone stamps its commit. The label can only carry the build arg, and is
-# empty without one.
-ARG VERSION
+# The version is computed on the host and passed in, because
+# .dockerignore excludes .git.
+ARG VERSION=dev
 LABEL org.opencontainers.image.version="${VERSION}"

 RUN make build
@@ -26,10 +26,8 @@ check:
 build:
 	@script/build

-# Bundles the built dist/, so the binary reports the version script/build
-# stamped.
-build-bin: build
-	nix-shell -p bun --run "bun build dist/bin/quak.js --compile --outfile bin/quak"
+build-bin:
+	nix-shell -p bun --run "bun build bin/quak.ts --compile --outfile bin/quak"

 install: build-bin
 	mkdir -p ~/bin
@@ -126,12 +126,9 @@ alpine. We provide:
  `script/bootstrap`, then `script/install-precommit`
 - `script/projectname` — output the project name (our own extension); used by
  `script/docker` for the image tag
- `script/build` — compile the TypeScript sources into `dist/`, stamp the
-  version into `dist/package.json`, then verify that the entrypoints
-  `package.json` declares (`main`, `types`, `bin`) are among the files the
-  compiler wrote, and make the CLI executable (our own extension)
- `script/version` — print the version `script/build` stamps (our own
-  extension); see Version below
+- `script/build` — compile the TypeScript sources into `dist/`, then verify that
+  the entrypoints `package.json` declares (`main`, `types`, `bin`) are among the
+  files the compiler wrote, and make the CLI executable (our own extension)
 - `script/test` — run the test suite, by building the `test` phase of the
  `Dockerfile` (vitest, 90s timeout, verbose rerun on failure); requires docker
 - `script/lint` — run eslint and a prettier check, by building the `lint` phase
@@ -179,34 +176,6 @@ an exact version, installed from `yarn.lock` under `--frozen-lockfile` in both
 places, and reads `.gitignore` as its default ignore file — which is why
 `.dockerignore` keeps `.gitignore` in the build context.

-### Version
-
-`quak --version` reports the `version` of `dist/package.json`, which
-`script/build` writes after compiling; the repo's own `package.json` keeps
-`0.0.0`, and that is what the tests, which run from source, report.
-`script/version` decides what is written:
-
- the `VERSION` environment variable, or the `Dockerfile`'s `VERSION` build arg
-  (`--build-arg VERSION=...`), when one is given and not empty;
- otherwise, in a checkout with `.git`, `git describe --tags --always`: the tag
-  on a tagged commit; the tag, the commits since it and the short commit on a
-  later commit (`v1.2.3-4-gabc1234`); the short commit when no tag is reachable;
- otherwise, as in a source tarball, the version `package.json` declares.
-
-The build fails if the checkout has `.git` and the version still comes out
-empty, `dev` or `unknown`: such a build could not be traced back to its commit.
-
-`.dockerignore` therefore does not leave out `.git`, so any `docker build .` of
-a clone stamps the commit it was built from; a shallow clone stamps a tag only
-when the cloned commit itself carries one, and otherwise the short commit. It
-leaves out `.git/config`, which holds the clone's remote URL and any credential
-in it, so the image carries `.git` without its config; `git describe` does not
-need that file. `script/docker` (and so `make docker`) and `script/cibuild` pass
-the version they resolve on the host, with `--dirty`, as the build arg, which
-takes precedence. The image's `org.opencontainers.image.version` label carries
-that build arg only, so a build given none leaves it empty. `make build-bin`
-bundles the built `dist/`, so the single binary reports the stamped version too.
-
 ## Rationale

 Ente is one of very few photo services with a credible end-to-end encryption
@@ -915,7 +884,10 @@ current account's records name.

 A live photo's original is cached as at its save path: 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.
+`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: the library
+removes the ZIP when it opens the cache, and fetches the two files when the
+photo is next read or precached.

 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
@@ -25,15 +25,6 @@ declares one.

 # Completed Steps

- 2026-10-02: `docker build .` stamps the commit's tag or short commit, not
-  `dev` (issue 154). `script/build` writes the version `script/version` prints
-  into `dist/package.json`: the `VERSION` environment variable or build arg when
-  one is given, otherwise `git describe --tags --always`, otherwise the version
-  `package.json` declares. `.dockerignore` sends `.git`, and a checkout with
-  `.git` whose version comes out empty, `dev` or `unknown` fails the build.
-  `make build-bin` bundles the built `dist/`, so the single binary reports the
-  same version.
-
 - 2026-10-02: `photo.exif()` returns every EXIF tag in the file as `ExifTags`,
  keyed by tag name, each as exifreader decodes it, not only the thirteen common
  fields (issue 156). The embedded thumbnail's tags are under `Thumbnail`,
@@ -41,10 +32,6 @@ declares one.
  field from the tags `exif()` returns, typed as in `PhotoExif`. The example
  script's JSON files now carry every tag.

- 2026-10-01: The content cache no longer looks for a live photo that an earlier
-  version cached as one ZIP (issue 151). When the cache opens, a live photo's
-  file that no JSON file names is now always left alone.
-
 - 2026-10-01: `examples/download-albums.ts` logs in, opens the library, and for
  every album downloads each photo to its save path, writes the photo's record
  and EXIF fields to a JSON file beside it, and writes the album's photos to
@@ -1,7 +1,7 @@
 #!/bin/sh
-# script/build: compile the TypeScript sources into dist/, stamp the version
-# script/version prints into it, then verify that the artifacts package.json
-# advertises are among the files the compiler actually wrote. tsc reports success by exit status alone and knows nothing
+# script/build: compile the TypeScript sources into dist/, then verify that
+# the artifacts package.json advertises are among the files the compiler
+# actually wrote. tsc reports success by exit status alone and knows nothing
 # about the manifest, so without this step a green build can still ship a
 # package whose main, types or bin resolve to nothing. Our own extension to
 # scripts-to-rule-them-all.
@@ -46,24 +46,13 @@ for (const bin of bins) {
 }

 # src/index.ts imports ../package.json for the version, which tsc copies to
-# dist/package.json. The version script/version prints is written into that
-# copy only; the repo's own package.json is left as it is.
-stamp_version() {
-    node -e '
-const { readFileSync, writeFileSync } = require("node:fs");
-
-const pkg = JSON.parse(readFileSync("dist/package.json", "utf-8"));
-pkg.version = process.argv[1];
-writeFileSync("dist/package.json", JSON.stringify(pkg, null, 4) + "\n");
-' "$1"
-}
-
-# Running the built CLI proves the import resolves from dist/ and reports
-# the stamped version.
+# dist/package.json. Running the built CLI proves that import resolves from
+# dist/ and reports the version package.json declares.
 verify_version() {
    built="$(node dist/bin/quak.js --version)"
-    if [ "$built" != "$1" ]; then
-        echo "build: dist/bin/quak.js reports $built, the build stamped $1" >&2
+    declared="$(node -p 'require("./package.json").version')"
+    if [ "$built" != "$declared" ]; then
+        echo "build: dist/bin/quak.js reports $built, package.json declares $declared" >&2
        exit 1
    fi
    echo "build: dist/bin/quak.js reports version $built"
@@ -71,12 +60,9 @@ verify_version() {

 main() {
    cd "$ROOT"
-    # Own line, so that a failing script/version stops the build.
-    version="$("$ROOT/script/version")"
    yarn run tsc
-    stamp_version "$version"
    verify_entrypoints
-    verify_version "$version"
+    verify_version
 }

 main "$@"
@@ -15,9 +15,9 @@ main() {
    cd "$ROOT"
    # Own line: a failing command substitution inside an argument does
    # not trip `set -e`, so the inline form degrades silently to an
-    # empty constant. The version resolved here goes in as the VERSION
-    # build arg, which takes precedence over what the build would derive
-    # from the .git in its context.
+    # empty constant. VERSION is computed here because .dockerignore
+    # excludes .git, so `git describe` in a build stage yields an empty
+    # version without failing.
    version="$(git describe --tags --always --dirty 2>/dev/null || true)"
    [ -n "$version" ] || version="unknown"
    docker build --no-cache \
@@ -12,9 +12,9 @@ main() {
    cd "$ROOT"
    # Own line: a failing command substitution inside an argument does
    # not trip `set -e`, so the inline form degrades silently to an
-    # empty constant. The version resolved here goes in as the VERSION
-    # build arg, which takes precedence over what the build would derive
-    # from the .git in its context.
+    # empty constant. VERSION is computed here because .dockerignore
+    # excludes .git, so `git describe` in a build stage yields an empty
+    # version without failing.
    version="$(git describe --tags --always --dirty 2>/dev/null || true)"
    [ -n "$version" ] || version="unknown"
    docker build --no-cache \
@@ -1,41 +0,0 @@
-#!/bin/sh
-# script/version: print the version script/build stamps into the built
-# package. Our own extension to scripts-to-rule-them-all.
-#
-# Order of precedence:
-#
-#   1. $VERSION, if set and not empty: an explicit value, such as the
-#      Dockerfile's VERSION build arg.
-#   2. If this checkout has .git, `git describe --tags --always`: the tag
-#      on a tagged commit; the tag, the commits since it and the short
-#      commit on a later commit (v1.2.3-4-gabc1234); the short commit when
-#      no tag is reachable.
-#   3. Otherwise, as in a source tarball, the version package.json declares.
-#
-# A checkout with .git whose version still comes out empty, dev or unknown
-# fails: git is missing or could not read the checkout, and the build could
-# not be traced back to its commit.
-set -eu
-
-ROOT="$(cd "$(dirname "$0")/.." && pwd -P)"
-
-main() {
-    cd "$ROOT"
-    version="${VERSION:-}"
-    if [ -e .git ]; then
-        if [ -z "$version" ]; then
-            version="$(git describe --tags --always || true)"
-        fi
-        case "$version" in
-            "" | dev | unknown)
-                echo "version: $ROOT has .git, but the version came out '$version'" >&2
-                exit 1
-                ;;
-        esac
-    elif [ -z "$version" ]; then
-        version="$(node -p 'require("./package.json").version')"
-    fi
-    echo "$version"
-}
-
-main "$@"
@@ -361,8 +361,8 @@ const openPart = async (
 // 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 are the image, then the video, renamed into
-// place; on any failure neither is stored.
+// 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, and the ZIP is refused once the
@@ -486,6 +486,7 @@ const decryptLivePhoto = async (
            await part.handle.sync();
            await part.handle.close();
        }
+        await rm(destination, { force: true });
        await rename(image.tmpPath, path);
        try {
            await rename(video.tmpPath, videoPath);
@@ -569,7 +570,8 @@ const fetchAndDecrypt = async (
    }, api.getRetryOptions());

 // Write `file`'s original to `outPath`. A live photo is written as its image
-// and its video beside `outPath` instead (see `decryptLivePhoto`).
+// and its video beside `outPath` instead, and whatever was at `outPath` is
+// removed (see `decryptLivePhoto`).
 export const downloadFile = async (
    api: ApiClient,
    file: EnteFile,
@@ -1,7 +1,5 @@
-// A build reports the version script/build stamps into dist/package.json;
-// package.json's own version is reported only when running from source. tsc
-// copies package.json to dist/package.json, so this path resolves from source
-// and from dist/src/.
+// package.json is the one place the version is written. tsc copies it to
+// dist/package.json, so this path resolves from source and from dist/src/.
 import pkg from "../package.json" with { type: "json" };

 export const VERSION: string = pkg.version;
@@ -29,7 +29,14 @@
 // the cache does not count as saved there, but is copied there rather than
 // fetched again.

-import { existsSync, readFileSync, statSync } from "node:fs";
+import {
+    closeSync,
+    existsSync,
+    openSync,
+    readFileSync,
+    readSync,
+    statSync,
+} from "node:fs";
 import {
    chmod,
    copyFile,
@@ -274,6 +281,25 @@ const fileSize = (path: string): number | undefined => {
 const hasContent = (path: string | undefined): boolean =>
    path !== undefined && (fileSize(path) ?? 0) > 0;

+// Whether the file at `path` begins as a ZIP does, with `PK\x03\x04`. False
+// when it cannot be read.
+const isZip = (path: string): boolean => {
+    try {
+        const fd = openSync(path, "r");
+        try {
+            const head = Buffer.alloc(4);
+            return (
+                readSync(fd, head, 0, 4, 0) === 4 &&
+                head.toString("latin1") === "PK\x03\x04"
+            );
+        } finally {
+            closeSync(fd);
+        }
+    } catch {
+        return false;
+    }
+};
+
 // 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
 // save path stores one, a JSON file of this name beside them names both.
@@ -687,10 +713,8 @@ export class ContentCache implements PhotoContent, ThumbnailsAPI {
                    await this.touch(cached.path);
                return { ...cached, bytes: size, cached: true };
            }
-            // A recorded file that has since gone re-fetches below. So does a
-            // live photo recorded with no video: the cache opened before the
-            // library's records said it is a live photo, while its image and
-            // video had no JSON file beside them yet.
+            // A recorded file that has since gone, or a live photo an earlier
+            // version stored as one ZIP, re-fetches below.
            known.delete(fileID);
        }

@@ -959,14 +983,20 @@ export class ContentCache implements PhotoContent, ThumbnailsAPI {
            if (id === undefined || !existsSync(path)) continue;
            // A live photo's image and video are one entry, as the JSON file
            // beside them names them. A live photo's file with no such JSON
-            // file is not its original and is left alone: another process may
-            // have just stored it and not yet written the JSON file.
+            // file is not its original. If it is a ZIP, it is the one an
+            // earlier version stored under the image's name, and is removed.
+            // Any other is left alone: another process may have just stored
+            // it and not yet written the JSON file.
            const livePhoto = names.has(livePhotoJSONName(String(id)))
                ? readLivePhotoJSON(dir, String(id))
                : undefined;
            if (livePhoto !== undefined) {
                into.set(id, livePhoto);
-            } else if (!isLivePhoto(id)) {
+            } else if (isLivePhoto(id)) {
+                if (isZip(path)) {
+                    await rm(path, { force: true }).catch(() => undefined);
+                }
+            } else {
                into.set(id, { path });
            }
        }
@@ -67,51 +67,6 @@ const TIFF_ALTITUDE_WITHOUT_REF = [
    ...[0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x02], // 25/2, at 44
 ];

-// A big-endian TIFF block holding a GPSLatitude of 33° 30' 0" and a
-// GPSLatitudeRef of "S".
-const TIFF_SOUTHERN_LATITUDE = [
-    ...[0x4d, 0x4d, 0x00, 0x2a, 0x00, 0x00, 0x00, 0x08], // the first IFD at 8
-    // The first IFD, at 8: one entry, then no next IFD.
-    ...[0x00, 0x01],
-    // The GPS IFD's offset (0x8825), LONG, 26.
-    ...[0x88, 0x25, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x1a],
-    ...[0x00, 0x00, 0x00, 0x00],
-    // The GPS IFD, at 26: two entries, then no next IFD.
-    ...[0x00, 0x02],
-    // GPSLatitudeRef (0x0001), 2 ASCII bytes: "S".
-    ...[0x00, 0x01, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x53, 0x00, 0x00, 0x00],
-    // GPSLatitude (0x0002), three RATIONALs at 56.
-    ...[0x00, 0x02, 0x00, 0x05, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x38],
-    ...[0x00, 0x00, 0x00, 0x00],
-    ...[0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x01], // 33/1, at 56
-    ...[0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x01], // 30/1
-    ...[0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01], // 0/1
-];
-
-// A big-endian TIFF block holding a GPSLatitude of 40° 26' 46" and a
-// GPSLongitude of 79° 58' 56", and neither GPSLatitudeRef nor GPSLongitudeRef.
-const TIFF_POSITION_WITHOUT_REFS = [
-    ...[0x4d, 0x4d, 0x00, 0x2a, 0x00, 0x00, 0x00, 0x08], // the first IFD at 8
-    // The first IFD, at 8: one entry, then no next IFD.
-    ...[0x00, 0x01],
-    // The GPS IFD's offset (0x8825), LONG, 26.
-    ...[0x88, 0x25, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x1a],
-    ...[0x00, 0x00, 0x00, 0x00],
-    // The GPS IFD, at 26: two entries, then no next IFD.
-    ...[0x00, 0x02],
-    // GPSLatitude (0x0002), three RATIONALs at 56.
-    ...[0x00, 0x02, 0x00, 0x05, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x38],
-    // GPSLongitude (0x0004), three RATIONALs at 80.
-    ...[0x00, 0x04, 0x00, 0x05, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x50],
-    ...[0x00, 0x00, 0x00, 0x00],
-    ...[0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x01], // 40/1, at 56
-    ...[0x00, 0x00, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x01], // 26/1
-    ...[0x00, 0x00, 0x00, 0x2e, 0x00, 0x00, 0x00, 0x01], // 46/1
-    ...[0x00, 0x00, 0x00, 0x4f, 0x00, 0x00, 0x00, 0x01], // 79/1, at 80
-    ...[0x00, 0x00, 0x00, 0x3a, 0x00, 0x00, 0x00, 0x01], // 58/1
-    ...[0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00, 0x01], // 56/1
-];
-
 // A big-endian TIFF block holding Orientation 6 and a Make whose value lies
 // past the end of the file.
 const TIFF_MAKE_PAST_END = [
@@ -227,24 +182,6 @@ describe("readPhotoExif", () => {
        });
    });

-    it("reads a GPSLatitude with GPSLatitudeRef S as south of the equator", () => {
-        const data = [...EXIF_HEADER, ...TIFF_SOUTHERN_LATITUDE];
-        expect(
-            readPhotoExif(readAllExifTags(bytes(SOI, app1(data), SOS))),
-        ).toStrictEqual({
-            gpsLatitude: -33.5,
-        });
-    });
-
-    it("gives no gpsLatitude or gpsLongitude without their reference tags", () => {
-        const data = [...EXIF_HEADER, ...TIFF_POSITION_WITHOUT_REFS];
-        const tags = readAllExifTags(bytes(SOI, app1(data), SOS));
-        // The position is read; only its hemisphere is unknown.
-        expect(tags.GPSLatitude?.computed).toStrictEqual([40, 26, 46]);
-        expect(tags.GPSLongitude?.computed).toStrictEqual([79, 58, 56]);
-        expect(readPhotoExif(tags)).toStrictEqual({});
-    });
-
    it("gives no make for a Make whose value lies past the end of the file", () => {
        const data = [...EXIF_HEADER, ...TIFF_MAKE_PAST_END];
        expect(
@@ -1883,6 +1883,15 @@ describe("downloadFile live photos", () => {
        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);

@@ -176,7 +176,7 @@ describe("Library content wiring", () => {
        await lib.close();
    });

-    it("does not take a live photo's image or video with no JSON file as its original when it opens, and precaches both", async () => {
+    it("removes a live photo's ZIP an earlier version cached when it opens, and precaches its image and video", async () => {
        const { file: live, body } = await asLivePhoto(file(1, 1));
        class LiveClient extends MockClient {
            override async filesSince(): Promise<FilesPage> {
@@ -197,8 +197,7 @@ describe("Library content wiring", () => {
        // A first run records the library, so the next one knows that file 1
        // is a live photo when it opens the cache.
        await (await open({})).close();
-        writeFileSync(join(originals, "1.heic"), "an image");
-        writeFileSync(join(originals, "1.mov"), "a video");
+        writeFileSync(join(originals, "1.jpg"), livePhotoZip());

        let precached!: () => void;
        const done = new Promise<void>((r) => (precached = r));
@@ -209,9 +208,7 @@ describe("Library content wiring", () => {
                    precached();
            },
        });
-        expect(
-            lib.photos.byID({ fileID: 1 })!.record().originalPath,
-        ).toBeUndefined();
+        expect(existsSync(join(originals, "1.jpg"))).toBe(false);
        await done;

        expect(readdirSync(originals).sort()).toEqual([
@@ -219,17 +216,6 @@ describe("Library content wiring", () => {
            "1.livephoto.json",
            "1.mov",
        ]);
-        expect(readFileSync(join(originals, "1.heic"))).toEqual(
-            Buffer.from(IMAGE),
-        );
-        expect(readFileSync(join(originals, "1.mov"))).toEqual(
-            Buffer.from(VIDEO),
-        );
-        expect(
-            JSON.parse(
-                readFileSync(join(originals, "1.livephoto.json"), "utf-8"),
-            ),
-        ).toEqual({ image: "1.heic", video: "1.mov" });
        expect(lib.photos.byID({ fileID: 1 })!.record().originalPath).toBe(
            join(originals, "1.heic"),
        );
@@ -566,6 +566,43 @@ describe("ContentCache live photos", () => {
        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]]));
+        // Opened without being told that file 5 is a live photo, the cache
+        // records the ZIP, and does not serve it.
+        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("removes a live photo's ZIP an earlier version stored when it opens, so the precache fetches the image and video", 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((fileID) => fileID === 5);
+
+        expect(readdirSync(originals())).toEqual([]);
+        expect(cache.pathsFor(5)).toEqual({});
+        const [fetched] = await cache.ensureOriginals({ fileIDs: [5] });
+        expect(fetched).toEqual({
+            fileID: 5,
+            path: join(originals(), "5.heic"),
+        });
+        expect(cache.pathsFor(5)).toEqual({ originalPath: fetched!.path });
+    });
+
    it("leaves the image and video another process has just stored when it opens before their JSON file is written", async () => {
        const { file: live, body } = await asLivePhoto(file(5, "IMG_5.HEIC"));
        const server = cdnSource(new Map([[5, body]]));
@@ -596,36 +633,6 @@ describe("ContentCache live photos", () => {
        expect(second!.pathsFor(5)).toEqual({});
    });

-    it("fetches a live photo's image and video again when the cache opened before knowing it is a live photo and no JSON file names them", async () => {
-        const { file: live, body } = await asLivePhoto(file(5, "IMG_5.HEIC"));
-        mkdirSync(originals(), { recursive: true });
-        writeFileSync(join(originals(), "5.heic"), "an image");
-        writeFileSync(join(originals(), "5.mov"), "a video");
-        const cache = cacheOf([live], new Map([[5, body]]));
-        // Opened without being told that file 5 is a live photo, the cache
-        // records one of the two files as its original, with no video.
-        await cache.open();
-
-        const events: string[] = [];
-        const result = await cache.original(5, {
-            onProgress: (e) => events.push(e.status),
-        });
-
-        expect(events.at(-1)).toBe("done");
-        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(
-            JSON.parse(
-                readFileSync(join(originals(), "5.livephoto.json"), "utf-8"),
-            ),
-        ).toEqual({ image: "5.heic", video: "5.mov" });
-    });
-
    it.each(["missing", "empty"])(
        "fetches a live photo again when the video its JSON file names is %s",
        async (state) => {
@@ -9,10 +9,8 @@
 // Excluding too much: Prettier 3 reads `.gitignore` as a default ignore file,
 // so dropping it from the context silently changes which files the lint
 // phase's prettier check looks at compared to `make fmt-check` on the host.
-// And without `.git`, a `docker build .` given no `VERSION` build arg cannot
-// derive the version (`script/version`) and stamps `package.json`'s instead.
 //
-// None of these shows up as a build failure, so they are asserted here.
+// Neither shows up as a build failure, so they are asserted here.
 import { describe, expect, it } from "vitest";
 import { existsSync, readFileSync } from "node:fs";
 import { fileURLToPath } from "node:url";
@@ -49,17 +47,6 @@ describe(".dockerignore", () => {
        expect(dockerignore).not.toContain(".gitignore");
    });

-    it("leaves .git in the build context for the version", () => {
-        expect(dockerignore).not.toContain(".git");
-        expect(dockerignore).not.toContain(".git/");
-    });
-
-    // The build stage is the final image, so a .git/config sent in would
-    // ship the clone's remote URL and any credential in it.
-    it("sends .git without its config", () => {
-        expect(dockerignore).toContain(".git/config");
-    });
-
    // BuildKit lets a `Dockerfile.dockerignore` shadow the root one; such a
    // file would silently give the build a different, unreviewed context —
    // and eslint's flat config does not ignore dot-directories, so a stray
@@ -1,137 +0,0 @@
-// `script/version` prints the version `script/build` stamps into
-// `dist/package.json`, which is what `quak --version` reports from a build.
-// A `docker build .` of a clone is given no `VERSION` build arg, so the
-// version has to come from the `.git` in its context: the tag on a tagged
-// commit; the tag, the commits since it and the short commit on a later commit;
-// the short commit when no tag is reachable. A checkout with `.git` that still
-// yields no usable version must fail the build, not ship a version nobody can
-// trace back to its commit.
-//
-// Each test copies the script into a fresh directory, which the script then
-// treats as the checkout, and executes it there.
-import { afterEach, describe, expect, it } from "vitest";
-import { execFileSync, spawnSync } from "node:child_process";
-import {
-    chmodSync,
-    copyFileSync,
-    mkdirSync,
-    mkdtempSync,
-    rmSync,
-    writeFileSync,
-} from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { fileURLToPath } from "node:url";
-
-const repoRoot = fileURLToPath(new URL("../../", import.meta.url));
-
-let checkout = "";
-
-afterEach(() => {
-    rmSync(checkout, { recursive: true, force: true });
-});
-
-// A checkout holding the script and a package.json that declares 0.0.0, with
-// no .git yet.
-const makeCheckout = (): void => {
-    checkout = mkdtempSync(join(tmpdir(), "quak-version-"));
-    mkdirSync(join(checkout, "script"));
-    copyFileSync(
-        join(repoRoot, "script/version"),
-        join(checkout, "script/version"),
-    );
-    chmodSync(join(checkout, "script/version"), 0o755);
-    writeFileSync(join(checkout, "package.json"), '{ "version": "0.0.0" }\n');
-};
-
-// git in the checkout, with an identity and no commit signing, whatever the
-// host's own git config says.
-const git = (...args: string[]): string =>
-    execFileSync(
-        "git",
-        [
-            "-c",
-            "user.name=quak",
-            "-c",
-            "user.email=quak@example.invalid",
-            "-c",
-            "commit.gpgsign=false",
-            ...args,
-        ],
-        { cwd: checkout, encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"] },
-    ).trim();
-
-const makeCommittedCheckout = (): void => {
-    makeCheckout();
-    git("init", "-q");
-    git("add", "package.json");
-    git("commit", "-q", "-m", "first");
-};
-
-// Runs the script with nothing in its environment but PATH and, when given,
-// VERSION.
-const runVersion = (version?: string) =>
-    spawnSync(join(checkout, "script/version"), {
-        cwd: checkout,
-        encoding: "utf-8",
-        env: { PATH: process.env.PATH, VERSION: version },
-    });
-
-describe("script/version", () => {
-    it("prints the short commit of an untagged commit", () => {
-        makeCommittedCheckout();
-        expect(runVersion().stdout.trim()).toBe(
-            git("rev-parse", "--short", "HEAD"),
-        );
-    });
-
-    it("prints the tag of a tagged commit", () => {
-        makeCommittedCheckout();
-        git("tag", "v1.2.3");
-        expect(runVersion().stdout.trim()).toBe("v1.2.3");
-    });
-
-    // script/docker and script/cibuild pass the version they resolve on the
-    // host as the VERSION build arg.
-    it("prints the VERSION it is given over what git would derive", () => {
-        makeCommittedCheckout();
-        expect(runVersion("x").stdout.trim()).toBe("x");
-    });
-
-    // `--build-arg VERSION=` must not stamp an empty version.
-    it("treats an empty VERSION as unset", () => {
-        makeCommittedCheckout();
-        expect(runVersion("").stdout.trim()).toBe(
-            git("rev-parse", "--short", "HEAD"),
-        );
-    });
-
-    // A source tarball has no .git: it keeps the version package.json
-    // declares, and must still build.
-    it("prints package.json's version where there is no .git", () => {
-        makeCheckout();
-        const result = runVersion();
-        expect(result.status).toBe(0);
-        expect(result.stdout.trim()).toBe("0.0.0");
-    });
-
-    // A repository with no commits stands in for any .git that git cannot
-    // describe: git missing from the image, or refusing to read the checkout.
-    it("fails where .git yields no version", () => {
-        makeCheckout();
-        git("init", "-q");
-        const result = runVersion();
-        expect(result.status).not.toBe(0);
-        expect(result.stdout).toBe("");
-    });
-
-    it.each(["dev", "unknown"])(
-        "fails where there is .git and the version is %s",
-        (version) => {
-            makeCommittedCheckout();
-            const result = runVersion(version);
-            expect(result.status).not.toBe(0);
-            expect(result.stdout).toBe("");
-        },
-    );
-});