docker build . stamps the git tag or short commit, not dev (closes #154)

A plain `docker build .` now stamps the version from git rather than `dev`/`0.0.0`. After `tsc`, `script/build` writes into `dist/package.json` the version `script/version` decides: `VERSION` when given, otherwise `git describe --tags --always` (the tag; or tag, commits since and short commit; or the short commit), otherwise `package.json`'s. A checkout with `.git` that yields an empty, `dev` or `unknown` version fails the build. `.dockerignore` sends `.git` but not `.git/config`, so no remote URL or credential reaches the image. `ARG VERSION` has no default, and the host scripts' version still wins.

Not changed: `REPO_POLICIES.md` still says `ARG VERSION=dev` until the shared policy changes.

Model: opus-5-5
Co-authored-by: clawbot <sneak+clawbot@sneak.cloud>

.dockerignore

@@ -1,9 +1,12 @@
 # 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.
-
-# VCS
-.git
+#
+# .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
 
 # OS
 .DS_Store

Dockerfile

@@ -61,9 +61,12 @@ RUN script/bootstrap
 
 COPY . .
 
-# The version is computed on the host and passed in, because
-# .dockerignore excludes .git.
-ARG VERSION=dev
+# 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
 LABEL org.opencontainers.image.version="${VERSION}"
 
 RUN make build

Makefile

@@ -26,8 +26,10 @@ check:
 build:
 	@script/build
 
-build-bin:
-	nix-shell -p bun --run "bun build bin/quak.ts --compile --outfile bin/quak"
+# 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"
 
 install: build-bin
 	mkdir -p ~/bin

README.md

@@ -126,9 +126,12 @@ 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/`, 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/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/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
@@ -176,6 +179,34 @@ 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
@@ -884,10 +915,7 @@ 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. 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.
+`originals/<fileID>.livephoto.json` naming them; the two are evicted together.
 
 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

TODO.md

@@ -25,6 +25,15 @@ 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`,
@@ -32,6 +41,10 @@ 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

script/build

@@ -1,7 +1,7 @@
 #!/bin/sh
-# 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
+# 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
 # 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,13 +46,24 @@ for (const bin of bins) {
 }
 
 # src/index.ts imports ../package.json for the version, which tsc copies to
-# dist/package.json. Running the built CLI proves that import resolves from
-# dist/ and reports the version package.json declares.
+# 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.
 verify_version() {
     built="$(node dist/bin/quak.js --version)"
-    declared="$(node -p 'require("./package.json").version')"
-    if [ "$built" != "$declared" ]; then
-        echo "build: dist/bin/quak.js reports $built, package.json declares $declared" >&2
+    if [ "$built" != "$1" ]; then
+        echo "build: dist/bin/quak.js reports $built, the build stamped $1" >&2
         exit 1
     fi
     echo "build: dist/bin/quak.js reports version $built"
@@ -60,9 +71,12 @@ 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
+    verify_version "$version"
 }
 
 main "$@"

script/cibuild

@@ -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. VERSION is computed here because .dockerignore
-    # excludes .git, so `git describe` in a build stage yields an empty
-    # version without failing.
+    # 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.
     version="$(git describe --tags --always --dirty 2>/dev/null || true)"
     [ -n "$version" ] || version="unknown"
     docker build --no-cache \

script/docker

@@ -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. VERSION is computed here because .dockerignore
-    # excludes .git, so `git describe` in a build stage yields an empty
-    # version without failing.
+    # 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.
     version="$(git describe --tags --always --dirty 2>/dev/null || true)"
     [ -n "$version" ] || version="unknown"
     docker build --no-cache \

script/version

@@ -0,0 +1,41 @@
+#!/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 "$@"

src/download/index.ts

@@ -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 is whatever was at `destination` removed and the
-// image, then the video, renamed into place; on any failure neither is stored.
+// part's own bytes. Only then are 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,7 +486,6 @@ 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);
@@ -570,8 +569,7 @@ 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, and whatever was at `outPath` is
-// removed (see `decryptLivePhoto`).
+// and its video beside `outPath` instead (see `decryptLivePhoto`).
 export const downloadFile = async (
     api: ApiClient,
     file: EnteFile,

src/index.ts

@@ -1,5 +1,7 @@
-// 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/.
+// 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/.
 import pkg from "../package.json" with { type: "json" };
 
 export const VERSION: string = pkg.version;

src/library/content.ts

@@ -29,14 +29,7 @@
 // the cache does not count as saved there, but is copied there rather than
 // fetched again.
 
-import {
-    closeSync,
-    existsSync,
-    openSync,
-    readFileSync,
-    readSync,
-    statSync,
-} from "node:fs";
+import { existsSync, readFileSync, statSync } from "node:fs";
 import {
     chmod,
     copyFile,
@@ -281,25 +274,6 @@ 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.
@@ -713,8 +687,10 @@ export class ContentCache implements PhotoContent, ThumbnailsAPI {
                     await this.touch(cached.path);
                 return { ...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. 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.
             known.delete(fileID);
         }
 
@@ -983,20 +959,14 @@ 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. 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.
+            // file is not its original and 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)) {
-                if (isZip(path)) {
-                    await rm(path, { force: true }).catch(() => undefined);
-                }
-            } else {
+            } else if (!isLivePhoto(id)) {
                 into.set(id, { path });
             }
         }

test/cli/metadata-exif.test.ts

@@ -67,6 +67,51 @@ 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 = [
@@ -182,6 +227,24 @@ 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(

test/download/download.test.ts

@@ -1883,15 +1883,6 @@ 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);
 

test/library/content-library.test.ts

@@ -176,7 +176,7 @@ describe("Library content wiring", () => {
         await lib.close();
     });
 
-    it("removes a live photo's ZIP an earlier version cached when it opens, and precaches its image and video", async () => {
+    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 () => {
         const { file: live, body } = await asLivePhoto(file(1, 1));
         class LiveClient extends MockClient {
             override async filesSince(): Promise<FilesPage> {
@@ -197,7 +197,8 @@ 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.jpg"), livePhotoZip());
+        writeFileSync(join(originals, "1.heic"), "an image");
+        writeFileSync(join(originals, "1.mov"), "a video");
 
         let precached!: () => void;
         const done = new Promise<void>((r) => (precached = r));
@@ -208,7 +209,9 @@ describe("Library content wiring", () => {
                     precached();
             },
         });
-        expect(existsSync(join(originals, "1.jpg"))).toBe(false);
+        expect(
+            lib.photos.byID({ fileID: 1 })!.record().originalPath,
+        ).toBeUndefined();
         await done;
 
         expect(readdirSync(originals).sort()).toEqual([
@@ -216,6 +219,17 @@ 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"),
         );

test/library/content.test.ts

@@ -566,43 +566,6 @@ 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]]));
@@ -633,6 +596,36 @@ 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) => {

test/packaging/build-context.test.ts

@@ -9,8 +9,10 @@
 // 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.
 //
-// Neither shows up as a build failure, so they are asserted here.
+// None of these 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";
@@ -47,6 +49,17 @@ 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

test/packaging/version.test.ts

@@ -0,0 +1,137 @@
+// `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("");
+        },
+    );
+});