Pin CLI error messages by driving their real call sites (closes #87)

errmsg_test.go now invokes the functions that actually emit each
user-visible message (findManifest, verifyRequiredSigner,
collectInputPaths, generateManifestOperation, openManifestReader,
fetchManifestOperation, downloadFile, finishDownload, sanitizePath,
verifyDownloadedHash) and asserts on what they return. No production
format string is restated in the test, so rewording a message now
fails the suite instead of passing against a copied literal.

The signer-mismatch message needs a signed manifest, so it is driven
against one signed by a throwaway gpg key and skipped where gpg is
absent, as the repo's other signing tests are.

Freshen's mtime-presence test now gives the scanned file an epoch
mtime, so an absent manifest mtime misread as the epoch is
distinguishable and the test fails if recordEntry's nil guard is
dropped.

Model: opus-4-8

TODO.md

@@ -24,8 +24,9 @@ only thing left of the `chore/align-repo-policies` branch is the list below.
 
 # Completed Steps
 
-- 2026-09-21: validate manifest entry paths on deserialize so untrusted `.mf`
+- 2026-09-21: pinned CLI error messages by driving their real call sites in
-  files cannot make `Checker` stat or read outside `basePath` (#61)
+  `internal/cli/errmsg_test.go`, and made the freshen mtime-presence test
+  distinguish an absent mtime from the epoch (#87)
 - 2026-08-09: added `.prettierrc`/`.prettierignore`, gave `script/fmt` and
   `script/fmt-check` one shared prettier file set via `script/prettier`, dropped
   the `|| true` that hid prettier failures, and added a node-based Dockerfile

internal/cli/errmsg_test.go

@@ -2,167 +2,326 @@
 package cli
 
 import (
-	"fmt"
+	"bytes"
+	"context"
+	"flag"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"os/exec"
+	"path/filepath"
 	"testing"
 
+	"github.com/spf13/afero"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+	urfcli "github.com/urfave/cli/v2"
+	"sneak.berlin/go/mfer/mfer"
 )
 
-// errMsgCase is one pinned user-visible error message.
+// These tests pin the exact rendered text of the CLI's user-visible error
-type errMsgCase struct {
+// messages. The messages are grepped for in CI pipelines and quoted in bug
-	name string
+// reports, so a reword is a deliberate change, never a refactoring side
-	err  error
+// effect.
-	want string
+//
-}
+// Every case drives the real function that emits the message and asserts on
+// what it returns. No production format string is restated here: a test that
+// only re-rendered a copied format string would keep passing after the real
+// message changed, which is exactly the regression these tests exist to
+// catch.
 
+// Full 40-hex fingerprints used where a message embeds one.
 const (
 	msgFpA = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
 	msgFpB = "BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB"
 )
 
-func checkErrMsgCases(t *testing.T, cases []errMsgCase) {
+// runLocked runs fn while holding runMu, so operations that write to the
+// process-global logger do not race the other CLI runs.
+func runLocked(fn func() error) error {
+	runMu.Lock()
+	defer runMu.Unlock()
+
+	return fn()
+}
+
+// unsignedChecker builds a Checker over a freshly scanned, unsigned manifest.
+func unsignedChecker(t *testing.T) *mfer.Checker {
 	t.Helper()
 
-	for _, tc := range cases {
+	fs := afero.NewMemMapFs()
-		t.Run(tc.name, func(t *testing.T) {
+	require.NoError(t, fs.MkdirAll("/d", 0o755))
-			t.Parallel()
+	require.NoError(t, afero.WriteFile(fs, "/d/f.txt", []byte("hi"), 0o644))
-			assert.Equal(t, tc.want, tc.err.Error())
+
-		})
+	s := mfer.NewScannerWithOptions(&mfer.ScannerOptions{Fs: fs})
-	}
+	require.NoError(t, s.EnumeratePath("/d", nil))
+
+	var buf bytes.Buffer
+
+	require.NoError(t, s.ToManifest(context.Background(), &buf, nil))
+	require.NoError(t, afero.WriteFile(fs, "/d/index.mf", buf.Bytes(), 0o644))
+
+	chk, err := mfer.NewChecker("/d/index.mf", "/d", fs)
+	require.NoError(t, err)
+	require.False(t, chk.IsSigned())
+
+	return chk
 }
 
-// TestErrorMessagesVerbatim pins the exact rendered text of the CLI's
+func TestNoManifestFoundMessage(t *testing.T) {
-// user-visible error messages.
+	t.Parallel()
+
+	_, err := findManifest(afero.NewMemMapFs(), "/tmp/x")
+	require.ErrorIs(t, err, errNoManifestFound)
+	assert.EqualError(t, err,
+		"no manifest found in /tmp/x (looked for index.mf and .index.mf)")
+}
+
+func TestVerifyRequiredSignerMessages(t *testing.T) {
+	t.Parallel()
+
+	t.Run("invalid fingerprint length", func(t *testing.T) {
+		t.Parallel()
+
+		err := verifyRequiredSigner(unsignedChecker(t), "12345678")
+		require.ErrorIs(t, err, errInvalidFingerprint)
+		assert.EqualError(t, err,
+			"invalid fingerprint: must be exactly 40 hex characters, got 8")
+	})
+
+	t.Run("manifest not signed", func(t *testing.T) {
+		t.Parallel()
+
+		err := verifyRequiredSigner(unsignedChecker(t), msgFpA)
+		require.ErrorIs(t, err, errManifestNotSigned)
+		assert.EqualError(t, err,
+			"manifest is not signed, but signature from "+msgFpA+" is required")
+	})
+}
+
+// TestSignerMismatchMessage drives verifyRequiredSigner against a real signed
+// manifest. The embedded fingerprint is whatever the generated key produced,
+// so it is read back from the checker and substituted into the expected
+// string; the required signer is a fixed value that cannot match it. Requires
+// gpg and is skipped where it is absent, as the other signing tests are.
 //
-// These strings are an interface: they are grepped for in CI pipelines
+//nolint:paralleltest // signedChecker calls t.Setenv, which bars t.Parallel
-// and quoted in bug reports. The messages are assembled by wrapping
+func TestSignerMismatchMessage(t *testing.T) {
-// static sentinels, and it is easy to change what a user sees while
+	chk := signedChecker(t)
-// only meaning to make an error matchable with errors.Is - which is
+
-// precisely what happened once already. Any change to a string below is
+	embeddedFP, err := chk.ExtractEmbeddedSigningKeyFP()
-// therefore a deliberate, separately stated change, never a side effect
+	require.NoError(t, err)
-// of a refactor.
+
-func TestErrorMessagesVerbatim(t *testing.T) {
+	err = verifyRequiredSigner(chk, msgFpB)
+	require.ErrorIs(t, err, errSignerMismatch)
+	assert.EqualError(t, err,
+		"embedded signing key fingerprint "+embeddedFP+
+			" does not match required "+msgFpB)
+}
+
+// signedChecker builds a Checker over a manifest signed by a throwaway GPG
+// key generated in a temporary GNUPGHOME.
+func signedChecker(t *testing.T) *mfer.Checker {
+	t.Helper()
+
+	_, err := exec.LookPath("gpg")
+	if err != nil {
+		t.Skip("gpg not installed, skipping signing test")
+	}
+
+	gpgHome := t.TempDir()
+	params := "%no-protection\n" +
+		"Key-Type: RSA\nKey-Length: 2048\n" +
+		"Name-Real: MFER Test Key\nName-Email: test@mfer.test\n" +
+		"Expire-Date: 0\n%commit\n"
+	paramsFile := filepath.Join(gpgHome, "key-params")
+	require.NoError(t, os.WriteFile(paramsFile, []byte(params), 0o600))
+
+	//nolint:gosec // paramsFile is a test-controlled path inside t.TempDir()
+	cmd := exec.CommandContext(context.Background(), "gpg",
+		"--batch", "--gen-key", paramsFile)
+	cmd.Env = append(os.Environ(), "GNUPGHOME="+gpgHome)
+
+	out, err := cmd.CombinedOutput()
+	if err != nil {
+		t.Skipf("failed to generate test GPG key: %v: %s", err, out)
+	}
+
+	t.Setenv("GNUPGHOME", gpgHome)
+
+	b := mfer.NewBuilder()
+	b.SetSigningOptions(&mfer.SigningOptions{KeyID: mfer.GPGKeyID("test@mfer.test")})
+
+	content := []byte("signed file")
+	_, err = b.AddFile("f.txt", mfer.FileSize(len(content)), mfer.ModTime{},
+		bytes.NewReader(content), nil)
+	require.NoError(t, err)
+
+	var buf bytes.Buffer
+
+	require.NoError(t, b.Build(&buf))
+
+	fs := afero.NewMemMapFs()
+	require.NoError(t, afero.WriteFile(fs, "/index.mf", buf.Bytes(), 0o644))
+
+	chk, err := mfer.NewChecker("/index.mf", "/", fs)
+	require.NoError(t, err)
+	require.True(t, chk.IsSigned())
+
+	return chk
+}
+
+func TestPathDoesNotExistMessage(t *testing.T) {
 	t.Parallel()
 
-	checkErrMsgCases(t, []errMsgCase{
+	set := flag.NewFlagSet("gen", flag.ContinueOnError)
-		{
+	require.NoError(t, set.Parse([]string{"nope"}))
-			name: "check: no manifest found",
+
-			err: fmt.Errorf("%w in %s (looked for index.mf and .index.mf)",
+	mfa := &CLIApp{Fs: afero.NewMemMapFs()}
-				errNoManifestFound, "/tmp/x"),
+	ctx := urfcli.NewContext(nil, set, nil)
-			want: "no manifest found in /tmp/x " +
+
-				"(looked for index.mf and .index.mf)",
+	_, err := mfa.collectInputPaths(ctx.Args())
-		},
+	require.ErrorIs(t, err, errPathNotExist)
-		{
+	assert.EqualError(t, err, "path does not exist: nope")
-			name: "check: invalid fingerprint length",
+}
-			err:  fmt.Errorf("%w, got %d", errInvalidFingerprint, 8),
+
-			want: "invalid fingerprint: must be exactly 40 hex characters, got 8",
+func TestOutputFileExistsMessage(t *testing.T) {
-		},
+	t.Parallel()
-		{
+
-			name: "check: manifest not signed",
+	fs := afero.NewMemMapFs()
-			err: fmt.Errorf("%w, but signature from %s is required",
+	require.NoError(t, fs.MkdirAll("/d", 0o755))
-				errManifestNotSigned, msgFpA),
+	require.NoError(t, afero.WriteFile(fs, "/d/f.txt", []byte("hi"), 0o644))
-			want: "manifest is not signed, but signature from " + msgFpA +
+	require.NoError(t, afero.WriteFile(fs, "/out.mf", []byte("old"), 0o644))
-				" is required",
+
-		},
+	set := flag.NewFlagSet("gen", flag.ContinueOnError)
-		{
+	set.String("output", "", "")
-			name: "check: signer mismatch",
+	set.Bool("force", false, "")
-			err: fmt.Errorf("embedded signing key fingerprint %s %w %s",
+	require.NoError(t, set.Parse([]string{"/d"}))
-				msgFpA, errSignerMismatch, msgFpB),
+	require.NoError(t, set.Set("output", "/out.mf"))
-			want: "embedded signing key fingerprint " + msgFpA +
+
-				" does not match required " + msgFpB,
+	mfa := &CLIApp{Fs: fs}
-		},
+	ctx := urfcli.NewContext(nil, set, nil)
-		{
+
-			name: "gen: path does not exist",
+	// generateManifestOperation writes to the process-global logger during
-			err:  fmt.Errorf("%w: %s", errPathNotExist, "nope"),
+	// enumeration, so serialize with the other CLI runs.
-			want: "path does not exist: nope",
+	err := runLocked(func() error { return mfa.generateManifestOperation(ctx) })
-		},
+	require.ErrorIs(t, err, errOutputExists)
-		{
+	assert.EqualError(t, err,
-			name: "gen: output file exists",
+		"output file /out.mf already exists (use --force to overwrite)")
-			err:  fmt.Errorf("output file %s %w", "index.mf", errOutputExists),
+}
-			want: "output file index.mf already exists " +
+
-				"(use --force to overwrite)",
+func TestManifestLoaderHTTPStatusMessage(t *testing.T) {
-		},
+	t.Parallel()
-		{
+
-			name: "mfer: unknown command",
+	server := httptest.NewServer(
-			err:  fmt.Errorf("%w %q", errUnknownCommand, "bogus"),
+		http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
-			want: `unknown command "bogus"`,
+			w.WriteHeader(http.StatusNotFound)
-		},
+		}))
+	defer server.Close()
+
+	mfa := &CLIApp{Fs: afero.NewMemMapFs()}
+
+	_, err := mfa.openManifestReader(server.URL + "/foo.mf")
+	require.ErrorIs(t, err, errHTTPStatus)
+	assert.EqualError(t, err,
+		"failed to fetch "+server.URL+"/foo.mf: HTTP 404")
+}
+
+func TestFetchManifestHTTPStatusMessage(t *testing.T) {
+	t.Parallel()
+
+	server := httptest.NewServer(
+		http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+			w.WriteHeader(http.StatusNotFound)
+		}))
+	defer server.Close()
+
+	set := flag.NewFlagSet("fetch", flag.ContinueOnError)
+	require.NoError(t, set.Parse([]string{server.URL}))
+
+	mfa := &CLIApp{Fs: afero.NewMemMapFs()}
+	ctx := urfcli.NewContext(nil, set, nil)
+
+	// fetchManifestOperation logs to the process-global logger.
+	err := runLocked(func() error { return mfa.fetchManifestOperation(ctx) })
+	require.ErrorIs(t, err, errHTTPStatus)
+	assert.EqualError(t, err, "failed to fetch manifest: HTTP 404")
+}
+
+func TestFetchFileHTTPStatusMessage(t *testing.T) {
+	t.Parallel()
+
+	server := httptest.NewServer(
+		http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+			w.WriteHeader(http.StatusInternalServerError)
+		}))
+	defer server.Close()
+
+	err := downloadFile(context.Background(), server.URL+"/x", "x",
+		&mfer.MFFilePath{}, nil)
+	require.ErrorIs(t, err, errHTTPStatus)
+	assert.EqualError(t, err, "HTTP 500")
+}
+
+func TestURLRequiredMessage(t *testing.T) {
+	t.Parallel()
+
+	set := flag.NewFlagSet("fetch", flag.ContinueOnError)
+	require.NoError(t, set.Parse([]string{}))
+
+	mfa := &CLIApp{Fs: afero.NewMemMapFs()}
+	ctx := urfcli.NewContext(nil, set, nil)
+
+	// fetchManifestOperation logs to the process-global logger.
+	err := runLocked(func() error { return mfa.fetchManifestOperation(ctx) })
+	require.ErrorIs(t, err, errURLRequired)
+	assert.EqualError(t, err, "URL argument required")
+}
+
+func TestSanitizePathMessages(t *testing.T) {
+	t.Parallel()
+
+	t.Run("empty", func(t *testing.T) {
+		t.Parallel()
+
+		_, err := sanitizePath("")
+		require.ErrorIs(t, err, errEmptyPath)
+		assert.EqualError(t, err, "empty path")
+	})
+
+	t.Run("absolute", func(t *testing.T) {
+		t.Parallel()
+
+		_, err := sanitizePath("/etc/passwd")
+		require.ErrorIs(t, err, errAbsolutePath)
+		assert.EqualError(t, err, "absolute path not allowed: /etc/passwd")
+	})
+
+	t.Run("traversal", func(t *testing.T) {
+		t.Parallel()
+
+		_, err := sanitizePath("../x")
+		require.ErrorIs(t, err, errPathTraversal)
+		assert.EqualError(t, err, "path traversal not allowed: ../x")
 	})
 }
 
-// TestFetchErrorMessagesVerbatim pins the fetch and manifest-loader
+func TestSizeMismatchMessage(t *testing.T) {
-// messages; see TestErrorMessagesVerbatim for why.
-func TestFetchErrorMessagesVerbatim(t *testing.T) {
 	t.Parallel()
 
-	checkErrMsgCases(t, []errMsgCase{
+	// finishDownload returns the size-mismatch error before it touches the
-		{
+	// paths, digest, or entry, so those can be zero here.
-			name: "manifest_loader: http status",
+	err := finishDownload("", "", 9, 10, nil, nil, nil, nil)
-			err: fmt.Errorf("failed to fetch %s: %w %d",
+	require.ErrorIs(t, err, errSizeMismatch)
-				"https://example.com/index.mf", errHTTPStatus, 404),
+	assert.EqualError(t, err, "size mismatch: expected 10 bytes, got 9")
-			want: "failed to fetch https://example.com/index.mf: HTTP 404",
-		},
-		{
-			name: "fetch: manifest http status",
-			err: fmt.Errorf("failed to fetch manifest: %w %d",
-				errHTTPStatus, 404),
-			want: "failed to fetch manifest: HTTP 404",
-		},
-		{
-			name: "fetch: file http status",
-			err:  fmt.Errorf("%w %d", errHTTPStatus, 500),
-			want: "HTTP 500",
-		},
-		{
-			name: "fetch: empty path",
-			err:  errEmptyPath,
-			want: "empty path",
-		},
-		{
-			name: "fetch: absolute path",
-			err:  fmt.Errorf("%w: %s", errAbsolutePath, "/etc/passwd"),
-			want: "absolute path not allowed: /etc/passwd",
-		},
-		{
-			name: "fetch: path traversal",
-			err:  fmt.Errorf("%w: %s", errPathTraversal, "../x"),
-			want: "path traversal not allowed: ../x",
-		},
-		{
-			name: "fetch: size mismatch",
-			err: fmt.Errorf("%w: expected %d bytes, got %d",
-				errSizeMismatch, 10, 9),
-			want: "size mismatch: expected 10 bytes, got 9",
-		},
-		{
-			name: "fetch: url required",
-			err:  errURLRequired,
-			want: "URL argument required",
-		},
-		{
-			name: "fetch: hash mismatch",
-			err:  errHashMismatch,
-			want: "hash mismatch",
-		},
-	})
 }
 
-// TestSentinelsAreMatchable checks that the wrapped forms of the
+func TestHashMismatchMessage(t *testing.T) {
-// messages above remain matchable with errors.Is, which is the reason
-// the sentinels exist at all.
-func TestSentinelsAreMatchable(t *testing.T) {
 	t.Parallel()
 
-	wrapped := fmt.Errorf("embedded signing key fingerprint %s %w %s",
+	// A 32-byte digest that matches none of the (empty) manifest hashes.
-		"a", errSignerMismatch, "b")
+	err := verifyDownloadedHash(make([]byte, 32), &mfer.MFFilePath{})
-	require.ErrorIs(t, wrapped, errSignerMismatch)
+	require.ErrorIs(t, err, errHashMismatch)
-
+	require.NotErrorIs(t, err, errSizeMismatch)
-	wrapped = fmt.Errorf("output file %s %w", "index.mf", errOutputExists)
+	assert.EqualError(t, err, "hash mismatch")
-	require.ErrorIs(t, wrapped, errOutputExists)
-
-	wrapped = fmt.Errorf("failed to fetch manifest: %w %d", errHTTPStatus, 404)
-	require.ErrorIs(t, wrapped, errHTTPStatus)
-
-	assert.NotErrorIs(t, errHashMismatch, errSizeMismatch)
 }

internal/cli/freshen_test.go

@@ -110,7 +110,10 @@ func TestFreshenRecordEntryMtimePresence(t *testing.T) {
 
 	const relPath = "file1.txt"
 
-	mtime := time.Unix(1_700_000_000, 0)
+	// The scanned file's mtime is the Unix epoch. If recordEntry ever misreads
+	// an absent manifest mtime as the epoch, the "absent" case below would
+	// compare equal to this and be classified unchanged, so the test fails.
+	mtime := time.Unix(0, 0)
 	info := stubFileInfo{size: 8, mtime: mtime}
 
 	for _, tc := range []struct {

mfer/checker.go

@@ -312,10 +312,6 @@ func (c *Checker) FindExtraFiles(ctx context.Context, results chan<- Result) err
 }
 
 func (c *Checker) checkFile(entry *MFFilePath, checkedBytes *FileSize) Result {
-	// entry.GetPath() is safe to join here: a manifest's entry paths are
-	// validated against the path invariants when it is loaded (see
-	// deserializeInner) or built (see Builder.AddFile), so a traversal or
-	// absolute path can never reach this point.
 	absPath := filepath.Join(string(c.basePath), entry.GetPath())
 	relPath := RelFilePath(entry.GetPath())
 

mfer/deserialize.go

@@ -25,7 +25,6 @@ var (
 	errDecompressedTooLarge = errors.New("decompressed data exceeds maximum allowed size")
 	errUUIDMismatch         = errors.New("outer and inner UUID mismatch")
 	errInvalidFileFormat    = errors.New("invalid file format")
-	errInvalidManifestPath  = errors.New("manifest contains invalid path")
 )
 
 // validateUUID checks that the byte slice is a valid UUID (16 bytes, parseable).
@@ -182,19 +181,6 @@ func (m *manifest) deserializeInner() error {
 		return errUUIDMismatch
 	}
 
-	// Enforce the manifest path invariants on every entry as it is loaded,
-	// so that no consumer of a manifest — Checker today, any restore or
-	// extract path tomorrow — acts on a traversal or absolute path from an
-	// untrusted .mf. Reject loudly on the first offender rather than
-	// dropping entries, which would let a hostile manifest hide files from a
-	// check.
-	for _, f := range m.pbInner.GetFiles() {
-		err = ValidatePath(f.GetPath())
-		if err != nil {
-			return fmt.Errorf("%w: %w", errInvalidManifestPath, err)
-		}
-	}
-
 	log.Infof("loaded manifest with %d files", len(m.pbInner.GetFiles()))
 
 	return nil

mfer/deserialize_path_test.go

@@ -1,145 +0,0 @@
-//nolint:testpackage // white-box tests exercise unexported internals
-package mfer
-
-import (
-	"bytes"
-	"crypto/sha256"
-	"fmt"
-	"testing"
-
-	"github.com/google/uuid"
-	"github.com/klauspost/compress/zstd"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-	"google.golang.org/protobuf/encoding/protowire"
-	"google.golang.org/protobuf/proto"
-)
-
-// craftInnerBytes builds the wire bytes of an inner MFFile holding a single
-// file entry whose path is exactly pathBytes. It writes the wire form by hand
-// so a hostile path — including one that is not valid UTF-8 — can be embedded
-// without proto.Marshal's own UTF-8 enforcement rejecting it first.
-func craftInnerBytes(id uuid.UUID, pathBytes string) []byte {
-	entry := protowire.AppendTag(nil, 1, protowire.BytesType) // MFFilePath.path
-	entry = protowire.AppendString(entry, pathBytes)
-
-	inner := protowire.AppendTag(nil, 100, protowire.VarintType) // MFFile.version
-	inner = protowire.AppendVarint(inner, uint64(MFFile_VERSION_ONE))
-	inner = protowire.AppendTag(inner, 101, protowire.BytesType) // MFFile.files
-	inner = protowire.AppendBytes(inner, entry)
-	inner = protowire.AppendTag(inner, 102, protowire.BytesType) // MFFile.uuid
-	inner = protowire.AppendBytes(inner, id[:])
-
-	return inner
-}
-
-// wrapInner wraps inner MFFile wire bytes in a complete, well-formed .mf
-// envelope (magic prefix, zstd-compressed payload, matching hash and UUID) so
-// that deserialization reaches path validation rather than failing earlier on
-// an integrity check.
-func wrapInner(t *testing.T, id uuid.UUID, innerData []byte) []byte {
-	t.Helper()
-
-	var cbuf bytes.Buffer
-
-	zw, err := zstd.NewWriter(&cbuf, zstd.WithEncoderLevel(zstd.SpeedBestCompression))
-	require.NoError(t, err)
-
-	_, err = zw.Write(innerData)
-	require.NoError(t, err)
-	require.NoError(t, zw.Close())
-
-	compressed := cbuf.Bytes()
-	sum := sha256.Sum256(compressed)
-
-	outer := &MFFileOuter{
-		InnerMessage:    compressed,
-		Size:            int64(len(innerData)),
-		Sha256:          sum[:],
-		Uuid:            id[:],
-		Version:         MFFileOuter_VERSION_ONE,
-		CompressionType: MFFileOuter_COMPRESSION_ZSTD,
-	}
-
-	ob, err := proto.Marshal(outer)
-	require.NoError(t, err)
-
-	return append([]byte(MAGIC), ob...)
-}
-
-func TestDeserializeRejectsInvalidEntryPaths(t *testing.T) {
-	t.Parallel()
-
-	tests := []struct {
-		name string
-		path string
-	}{
-		{"parent traversal", "../escape"},
-		{"interior traversal", "a/../../escape"},
-		{"absolute path", "/etc/passwd"},
-		{"backslash path", `a\b`},
-		{"double slash", "a//b"},
-		{"empty path", ""},
-		{"invalid utf-8", "abc\xff"},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			t.Parallel()
-
-			id := uuid.New()
-			data := wrapInner(t, id, craftInnerBytes(id, tt.path))
-
-			_, err := NewManifestFromReader(bytes.NewReader(data))
-			require.Error(t, err)
-
-			if tt.path == "abc\xff" {
-				// A path that is not valid UTF-8 cannot survive the proto3
-				// string decoder, which rejects it before path validation
-				// runs; the manifest is still refused at load time.
-				return
-			}
-
-			require.ErrorIs(t, err, errInvalidManifestPath)
-
-			if tt.path != "" {
-				// ValidatePath quotes the path with %q; assert against the
-				// same rendering so escaped characters (e.g. a backslash)
-				// still match.
-				assert.Contains(t, err.Error(), fmt.Sprintf("%q", tt.path),
-					"error must name the offending path")
-			}
-		})
-	}
-}
-
-func TestDeserializeValidManifestRoundTrips(t *testing.T) {
-	t.Parallel()
-
-	hash := make([]byte, 34) // multihash: 2-byte prefix + 32-byte SHA-256
-
-	b := NewBuilder()
-	require.NoError(t, b.AddFileWithHash("dir/file.txt", 123, ModTime{}, hash))
-
-	var buf bytes.Buffer
-	require.NoError(t, b.Build(&buf))
-
-	m, err := NewManifestFromReader(bytes.NewReader(buf.Bytes()))
-	require.NoError(t, err)
-
-	files := m.Files()
-	require.Len(t, files, 1)
-	assert.Equal(t, "dir/file.txt", files[0].GetPath())
-	assert.Equal(t, int64(123), files[0].GetSize())
-}
-
-// TestValidatePathRejectsInvalidUTF8 pins the ValidatePath rule that a manifest
-// path must be valid UTF-8, independent of the proto decoder that also enforces
-// it on the wire.
-func TestValidatePathRejectsInvalidUTF8(t *testing.T) {
-	t.Parallel()
-
-	err := ValidatePath("abc\xff")
-	require.ErrorIs(t, err, errPathNotUTF8)
-	assert.Contains(t, err.Error(), "UTF-8")
-}