Never regenerate mf.pb.go during checks; fail when it is stale (closes #71)

The test and format scripts regenerated mfer/mf.pb.go whenever
mfer/mf.proto looked newer by mtime, which a fresh checkout often causes,
so make check could rewrite a committed file and needed protoc. Nothing
regenerates it any more except make generate (script/generate), which
also records the hash of mf.proto in mfer/mf.proto.sha256. A Go test
compares that hash with mf.proto and fails, naming make generate, when
they differ; it needs no protoc. The Makefile's mtime rule for mf.pb.go,
make clean's deletion of it and the Dockerfile's touch workarounds are
removed.

Model: opus-5-5

Makefile

@@ -2,6 +2,7 @@ export DOCKER_BUILDKIT := 1
 export PROGRESS_NO_TRUNC := 1
 GOPATH := $(shell go env GOPATH)
 export PATH := $(PATH):$(GOPATH)/bin
+PROTOC_GEN_GO := $(GOPATH)/bin/protoc-gen-go
 SOURCEFILES := mfer/*.go mfer/*.proto internal/*/*.go cmd/*/*.go go.mod go.sum
 ARCH := $(shell uname -m)
 GITREV_BUILD := $(shell bash $(PWD)/bin/gitrev.sh 2>/dev/null || echo unknown)
@@ -34,6 +35,9 @@ test:
 fuzz:
 	@script/fuzz
 
+$(PROTOC_GEN_GO):
+	test -e $(PROTOC_GEN_GO) || go install -v google.golang.org/protobuf/cmd/protoc-gen-go@v1.28.1
+
 fixme:
 	@grep -nir fixme . | grep -v Makefile
 

README.md

@@ -74,17 +74,10 @@ provide:
   such as `script/docker`
 - `script/test` — run the test suite (`go test`); one test fails when
   `mfer/mf.proto` no longer matches the hash `script/generate` recorded
-- `script/generate` (`make generate`) — regenerate `mfer/mf.pb.go` from
-  `mfer/mf.proto` and record the hash of that `mfer/mf.proto` in
-  `mfer/mf.proto.sha256`; the only thing that regenerates the committed
-  `mfer/mf.pb.go`. It needs the exact versions that wrote the committed file,
-  and refuses to run with any other: `protoc` 33.4 (unpack
-  `protoc-33.4-<platform>.zip` from
-  [its release](https://github.com/protocolbuffers/protobuf/releases/tag/v33.4)
-  and put its `bin/protoc` on `PATH`) and `protoc-gen-go` v1.36.11
-  (`go install google.golang.org/protobuf/cmd/protoc-gen-go@v1.36.11`, which
-  installs it in `$(go env GOPATH)/bin`; `make generate` adds that directory to
-  `PATH`)
+- `script/generate` — regenerate `mfer/mf.pb.go` from `mfer/mf.proto` and record
+  the hash of that `mfer/mf.proto` in `mfer/mf.proto.sha256`; needs `protoc` and
+  `protoc-gen-go`, and is the only thing that regenerates the committed
+  `mfer/mf.pb.go`
 - `script/fuzz` — fuzz the manifest parser for one minute; run by hand
   (`make fuzz`), never by CI, while `script/test` runs its committed seed corpus
   as ordinary tests

internal/cli/check.go

@@ -298,11 +298,7 @@ func (mfa *CLIApp) checkManifestOperation(ctx *cli.Context) error {
 	log.Infof("checking manifest %s with base %s", manifestPath, basePath)
 
 	// Create checker
-	chk, err := mfer.NewChecker(&mfer.CheckerOptions{
-		ManifestPath: manifestPath,
-		BasePath:     basePath,
-		Fs:           mfa.Fs,
-	})
+	chk, err := mfer.NewChecker(manifestPath, basePath, mfa.Fs)
 	if err != nil {
 		return fmt.Errorf("failed to load manifest: %w", err)
 	}

internal/cli/entry_test.go

@@ -504,10 +504,7 @@ func TestGenerateExcludesDotfilesByDefault(t *testing.T) {
 	assert.True(t, exists)
 
 	// Verify manifest only has 1 file (the non-dotfile)
-	manifest, err := mfer.NewManifestFromFile(&mfer.ManifestFromFileOptions{
-		Path: testMF,
-		Fs:   fs,
-	})
+	manifest, err := mfer.NewManifestFromFile(fs, testMF)
 	require.NoError(t, err)
 	assert.Len(t, manifest.Files(), 1)
 	assert.Equal(t, "file1.txt", manifest.Files()[0].GetPath())
@@ -531,10 +528,7 @@ func TestGenerateWithIncludeDotfiles(t *testing.T) {
 	require.Equal(t, 0, exitCode)
 
 	// Verify manifest has 2 files (including dotfile)
-	manifest, err := mfer.NewManifestFromFile(&mfer.ManifestFromFileOptions{
-		Path: testMF,
-		Fs:   fs,
-	})
+	manifest, err := mfer.NewManifestFromFile(fs, testMF)
 	require.NoError(t, err)
 	assert.Len(t, manifest.Files(), 2)
 }

internal/cli/errmsg_test.go

@@ -61,11 +61,7 @@ func unsignedChecker(t *testing.T) *mfer.Checker {
 	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(&mfer.CheckerOptions{
-		ManifestPath: "/d/index.mf",
-		BasePath:     "/d",
-		Fs:           fs,
-	})
+	chk, err := mfer.NewChecker("/d/index.mf", "/d", fs)
 	require.NoError(t, err)
 	require.False(t, chk.IsSigned())
 
@@ -171,11 +167,7 @@ func signedChecker(t *testing.T) *mfer.Checker {
 	fs := afero.NewMemMapFs()
 	require.NoError(t, afero.WriteFile(fs, "/index.mf", buf.Bytes(), 0o644))
 
-	chk, err := mfer.NewChecker(&mfer.CheckerOptions{
-		ManifestPath: "/index.mf",
-		BasePath:     "/",
-		Fs:           fs,
-	})
+	chk, err := mfer.NewChecker("/index.mf", "/", fs)
 	require.NoError(t, err)
 	require.True(t, chk.IsSigned())
 

internal/cli/freshen.go

@@ -445,10 +445,7 @@ func (mfa *CLIApp) loadExistingEntries(
 	log.Infof("loading manifest from %s", manifestPath)
 
 	// Load existing manifest
-	manifest, err := mfer.NewManifestFromFile(&mfer.ManifestFromFileOptions{
-		Path: manifestPath,
-		Fs:   mfa.Fs,
-	})
+	manifest, err := mfer.NewManifestFromFile(mfa.Fs, manifestPath)
 	if err != nil {
 		return nil, fmt.Errorf("failed to load manifest: %w", err)
 	}

internal/cli/freshen_test.go

@@ -58,10 +58,7 @@ func TestFreshenUnchanged(t *testing.T) {
 	setupFreshenDir(t, fs)
 
 	// Parse manifest to verify
-	manifest, err := mfer.NewManifestFromFile(&mfer.ManifestFromFileOptions{
-		Path: "/testdir/.index.mf",
-		Fs:   fs,
-	})
+	manifest, err := mfer.NewManifestFromFile(fs, "/testdir/.index.mf")
 	require.NoError(t, err)
 	assert.Len(t, manifest.Files(), 2)
 }
@@ -73,10 +70,7 @@ func TestFreshenWithChanges(t *testing.T) {
 	setupFreshenDir(t, fs)
 
 	// Verify initial manifest has 2 files
-	manifest, err := mfer.NewManifestFromFile(&mfer.ManifestFromFileOptions{
-		Path: "/testdir/.index.mf",
-		Fs:   fs,
-	})
+	manifest, err := mfer.NewManifestFromFile(fs, "/testdir/.index.mf")
 	require.NoError(t, err)
 	assert.Len(t, manifest.Files(), 2)
 

mfer/builder_test.go

@@ -5,12 +5,10 @@ import (
 	"bytes"
 	"context"
 	"fmt"
-	"path/filepath"
 	"strings"
 	"testing"
 	"time"
 
-	"github.com/spf13/afero"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
@@ -399,29 +397,6 @@ func TestNewManifestFromReaderTruncated(t *testing.T) {
 	assert.Error(t, err)
 }
 
-func TestNewManifestFromFileRequiresPath(t *testing.T) {
-	t.Parallel()
-
-	_, err := NewManifestFromFile(nil)
-	require.ErrorIs(t, err, errManifestPathEmpty)
-
-	_, err = NewManifestFromFile(&ManifestFromFileOptions{Fs: afero.NewMemMapFs()})
-	require.ErrorIs(t, err, errManifestPathEmpty)
-}
-
-func TestNewManifestFromFileNilFsUsesOsFs(t *testing.T) {
-	t.Parallel()
-
-	path := filepath.Join(t.TempDir(), "index.mf")
-	createTestManifest(t, afero.NewOsFs(), path, map[string][]byte{
-		testFileName: []byte("hello"),
-	})
-
-	m, err := NewManifestFromFile(&ManifestFromFileOptions{Path: path})
-	require.NoError(t, err)
-	assert.Len(t, m.Files(), 1)
-}
-
 func TestManifestString(t *testing.T) {
 	t.Parallel()
 

mfer/checker.go

@@ -14,11 +14,7 @@ import (
 	"github.com/spf13/afero"
 )
 
-var (
-	errNoSigningPubKey   = errors.New("manifest has no signing public key")
-	errManifestPathEmpty = errors.New("manifest path cannot be empty")
-	errBasePathEmpty     = errors.New("base path cannot be empty")
-)
+var errNoSigningPubKey = errors.New("manifest has no signing public key")
 
 // Result represents the outcome of checking a single file.
 type Result struct {
@@ -86,42 +82,20 @@ type Checker struct {
 	signingPubKey []byte
 }
 
-// CheckerOptions configures a Checker.
-type CheckerOptions struct {
-	// ManifestPath is the manifest file to check against (required).
-	ManifestPath string
-	// BasePath is the directory relative to which manifest paths are
-	// resolved (required).
-	BasePath string
-	// Fs is the filesystem to use, defaults to OsFs if nil.
-	Fs afero.Fs
-}
-
-// NewChecker creates a new Checker with the given options. It returns an
-// error if opts is nil or either path is empty.
-func NewChecker(opts *CheckerOptions) (*Checker, error) {
-	if opts == nil || opts.ManifestPath == "" {
-		return nil, errManifestPathEmpty
-	}
-
-	if opts.BasePath == "" {
-		return nil, errBasePathEmpty
-	}
-
-	fs := opts.Fs
+// NewChecker creates a new Checker for the given manifest, base path, and filesystem.
+// The basePath is the directory relative to which manifest paths are resolved.
+// If fs is nil, the real filesystem (OsFs) is used.
+func NewChecker(manifestPath string, basePath string, fs afero.Fs) (*Checker, error) {
 	if fs == nil {
 		fs = afero.NewOsFs()
 	}
 
-	m, err := NewManifestFromFile(&ManifestFromFileOptions{
-		Path: opts.ManifestPath,
-		Fs:   fs,
-	})
+	m, err := NewManifestFromFile(fs, manifestPath)
 	if err != nil {
 		return nil, err
 	}
 
-	abs, err := filepath.Abs(opts.BasePath)
+	abs, err := filepath.Abs(basePath)
 	if err != nil {
 		return nil, err
 	}
@@ -134,7 +108,7 @@ func NewChecker(opts *CheckerOptions) (*Checker, error) {
 	}
 
 	// Compute manifest's relative path from basePath for exclusion in FindExtraFiles
-	absManifest, err := filepath.Abs(opts.ManifestPath)
+	absManifest, err := filepath.Abs(manifestPath)
 	if err != nil {
 		return nil, err
 	}

mfer/checker_test.go

@@ -5,8 +5,6 @@ import (
 	"bytes"
 	"context"
 	"fmt"
-	"os"
-	"path/filepath"
 	"testing"
 	"time"
 
@@ -16,11 +14,9 @@ import (
 )
 
 const (
-	testFile1        = "file1.txt"
-	testFile2        = "file2.txt"
-	testExistsFile   = "exists.txt"
-	testManifestPath = "/manifest.mf"
-	testDataDir      = "/data"
+	testFile1      = "file1.txt"
+	testFile2      = "file2.txt"
+	testExistsFile = "exists.txt"
 )
 
 func TestStatusString(t *testing.T) {
@@ -70,13 +66,15 @@ func createTestManifest(
 }
 
 // createFilesOnDisk creates the given files on the filesystem under
-// testDataDir.
+// /data.
 func createFilesOnDisk(t *testing.T, fs afero.Fs, files map[string][]byte) {
 	t.Helper()
 
+	basePath := "/data"
+
 	for path, content := range files {
-		fullPath := testDataDir + "/" + path
-		require.NoError(t, fs.MkdirAll(testDataDir, 0o755))
+		fullPath := basePath + "/" + path
+		require.NoError(t, fs.MkdirAll(basePath, 0o755))
 		require.NoError(t, afero.WriteFile(fs, fullPath, content, 0o644))
 	}
 }
@@ -92,13 +90,9 @@ func TestNewChecker(t *testing.T) {
 			testFile1: []byte("hello"),
 			testFile2: []byte("world"),
 		}
-		createTestManifest(t, fs, testManifestPath, files)
+		createTestManifest(t, fs, "/manifest.mf", files)
 
-		chk, err := NewChecker(&CheckerOptions{
-			ManifestPath: testManifestPath,
-			BasePath:     "/",
-			Fs:           fs,
-		})
+		chk, err := NewChecker("/manifest.mf", "/", fs)
 		require.NoError(t, err)
 		assert.NotNil(t, chk)
 		assert.Equal(t, FileCount(2), chk.FileCount())
@@ -108,11 +102,7 @@ func TestNewChecker(t *testing.T) {
 		t.Parallel()
 
 		fs := afero.NewMemMapFs()
-		_, err := NewChecker(&CheckerOptions{
-			ManifestPath: "/nonexistent.mf",
-			BasePath:     "/",
-			Fs:           fs,
-		})
+		_, err := NewChecker("/nonexistent.mf", "/", fs)
 		assert.Error(t, err)
 	})
 
@@ -121,73 +111,11 @@ func TestNewChecker(t *testing.T) {
 
 		fs := afero.NewMemMapFs()
 		require.NoError(t, afero.WriteFile(fs, "/bad.mf", []byte("not a manifest"), 0o644))
-		_, err := NewChecker(&CheckerOptions{
-			ManifestPath: "/bad.mf",
-			BasePath:     "/",
-			Fs:           fs,
-		})
+		_, err := NewChecker("/bad.mf", "/", fs)
 		assert.Error(t, err)
 	})
 }
 
-func TestNewCheckerRequiredPaths(t *testing.T) {
-	t.Parallel()
-
-	for _, tc := range []struct {
-		name string
-		opts *CheckerOptions
-		want string
-		is   error
-	}{
-		{
-			name: "nil options",
-			opts: nil,
-			want: "manifest path cannot be empty",
-			is:   errManifestPathEmpty,
-		},
-		{
-			name: "empty manifest path",
-			opts: &CheckerOptions{BasePath: testDataDir},
-			want: "manifest path cannot be empty",
-			is:   errManifestPathEmpty,
-		},
-		{
-			name: "empty base path",
-			opts: &CheckerOptions{ManifestPath: testManifestPath},
-			want: "base path cannot be empty",
-			is:   errBasePathEmpty,
-		},
-	} {
-		t.Run(tc.name, func(t *testing.T) {
-			t.Parallel()
-
-			chk, err := NewChecker(tc.opts)
-			require.ErrorIs(t, err, tc.is)
-			require.EqualError(t, err, tc.want)
-			assert.Nil(t, chk)
-		})
-	}
-}
-
-func TestNewCheckerNilFsUsesOsFs(t *testing.T) {
-	t.Parallel()
-
-	dir := t.TempDir()
-	manifestPath := filepath.Join(dir, "index.mf")
-	content := []byte("hello")
-	createTestManifest(t, afero.NewOsFs(), manifestPath, map[string][]byte{
-		testFile1: content,
-	})
-	require.NoError(t, os.WriteFile(filepath.Join(dir, testFile1), content, 0o600))
-
-	chk, err := NewChecker(&CheckerOptions{ManifestPath: manifestPath, BasePath: dir})
-	require.NoError(t, err)
-
-	results := make(chan Result, 1)
-	require.NoError(t, chk.Check(context.Background(), results, nil))
-	assert.Equal(t, StatusOK, (<-results).Status)
-}
-
 func TestCheckerFileCountAndTotalBytes(t *testing.T) {
 	t.Parallel()
 
@@ -197,13 +125,9 @@ func TestCheckerFileCountAndTotalBytes(t *testing.T) {
 		"medium.txt": []byte("hello world"),
 		"large.txt":  bytes.Repeat([]byte("x"), 1000),
 	}
-	createTestManifest(t, fs, testManifestPath, files)
+	createTestManifest(t, fs, "/manifest.mf", files)
 
-	chk, err := NewChecker(&CheckerOptions{
-		ManifestPath: testManifestPath,
-		BasePath:     "/",
-		Fs:           fs,
-	})
+	chk, err := NewChecker("/manifest.mf", "/", fs)
 	require.NoError(t, err)
 
 	assert.Equal(t, FileCount(3), chk.FileCount())
@@ -218,14 +142,10 @@ func TestCheckAllFilesOK(t *testing.T) {
 		testFile1: []byte("content one"),
 		testFile2: []byte("content two"),
 	}
-	createTestManifest(t, fs, testManifestPath, files)
+	createTestManifest(t, fs, "/manifest.mf", files)
 	createFilesOnDisk(t, fs, files)
 
-	chk, err := NewChecker(&CheckerOptions{
-		ManifestPath: testManifestPath,
-		BasePath:     testDataDir,
-		Fs:           fs,
-	})
+	chk, err := NewChecker("/manifest.mf", "/data", fs)
 	require.NoError(t, err)
 
 	results := make(chan Result, 10)
@@ -252,17 +172,13 @@ func TestCheckMissingFile(t *testing.T) {
 		testExistsFile: []byte("I exist"),
 		"missing.txt":  []byte("I don't exist on disk"),
 	}
-	createTestManifest(t, fs, testManifestPath, files)
+	createTestManifest(t, fs, "/manifest.mf", files)
 	// Only create one file
 	createFilesOnDisk(t, fs, map[string][]byte{
 		testExistsFile: []byte("I exist"),
 	})
 
-	chk, err := NewChecker(&CheckerOptions{
-		ManifestPath: testManifestPath,
-		BasePath:     testDataDir,
-		Fs:           fs,
-	})
+	chk, err := NewChecker("/manifest.mf", "/data", fs)
 	require.NoError(t, err)
 
 	results := make(chan Result, 10)
@@ -295,17 +211,13 @@ func TestCheckSizeMismatch(t *testing.T) {
 	files := map[string][]byte{
 		testFileName: []byte("original content"),
 	}
-	createTestManifest(t, fs, testManifestPath, files)
+	createTestManifest(t, fs, "/manifest.mf", files)
 	// Create file with different size
 	createFilesOnDisk(t, fs, map[string][]byte{
 		testFileName: []byte("short"),
 	})
 
-	chk, err := NewChecker(&CheckerOptions{
-		ManifestPath: testManifestPath,
-		BasePath:     testDataDir,
-		Fs:           fs,
-	})
+	chk, err := NewChecker("/manifest.mf", "/data", fs)
 	require.NoError(t, err)
 
 	results := make(chan Result, 10)
@@ -325,7 +237,7 @@ func TestCheckHashMismatch(t *testing.T) {
 	files := map[string][]byte{
 		testFileName: originalContent,
 	}
-	createTestManifest(t, fs, testManifestPath, files)
+	createTestManifest(t, fs, "/manifest.mf", files)
 	// Create file with same size but different content
 	differentContent := []byte("different contnt") // same length (16 bytes) but different
 	require.Len(t, differentContent, len(originalContent), "test requires same length")
@@ -333,11 +245,7 @@ func TestCheckHashMismatch(t *testing.T) {
 		testFileName: differentContent,
 	})
 
-	chk, err := NewChecker(&CheckerOptions{
-		ManifestPath: testManifestPath,
-		BasePath:     testDataDir,
-		Fs:           fs,
-	})
+	chk, err := NewChecker("/manifest.mf", "/data", fs)
 	require.NoError(t, err)
 
 	results := make(chan Result, 10)
@@ -357,14 +265,10 @@ func TestCheckWithProgress(t *testing.T) {
 		testFile1: bytes.Repeat([]byte("a"), 100),
 		testFile2: bytes.Repeat([]byte("b"), 200),
 	}
-	createTestManifest(t, fs, testManifestPath, files)
+	createTestManifest(t, fs, "/manifest.mf", files)
 	createFilesOnDisk(t, fs, files)
 
-	chk, err := NewChecker(&CheckerOptions{
-		ManifestPath: testManifestPath,
-		BasePath:     testDataDir,
-		Fs:           fs,
-	})
+	chk, err := NewChecker("/manifest.mf", "/data", fs)
 	require.NoError(t, err)
 
 	results := make(chan Result, 10)
@@ -401,14 +305,10 @@ func TestCheckContextCancellation(t *testing.T) {
 		files[string(rune('a'+i%26))+".txt"] = bytes.Repeat([]byte("x"), 1000)
 	}
 
-	createTestManifest(t, fs, testManifestPath, files)
+	createTestManifest(t, fs, "/manifest.mf", files)
 	createFilesOnDisk(t, fs, files)
 
-	chk, err := NewChecker(&CheckerOptions{
-		ManifestPath: testManifestPath,
-		BasePath:     testDataDir,
-		Fs:           fs,
-	})
+	chk, err := NewChecker("/manifest.mf", "/data", fs)
 	require.NoError(t, err)
 
 	ctx, cancel := context.WithCancel(context.Background())
@@ -427,7 +327,7 @@ func TestFindExtraFiles(t *testing.T) {
 	manifestFiles := map[string][]byte{
 		testFile1: []byte("in manifest"),
 	}
-	createTestManifest(t, fs, testManifestPath, manifestFiles)
+	createTestManifest(t, fs, "/manifest.mf", manifestFiles)
 
 	// Disk has file1 and file2
 	createFilesOnDisk(t, fs, map[string][]byte{
@@ -435,11 +335,7 @@ func TestFindExtraFiles(t *testing.T) {
 		testFile2: []byte("extra file"),
 	})
 
-	chk, err := NewChecker(&CheckerOptions{
-		ManifestPath: testManifestPath,
-		BasePath:     testDataDir,
-		Fs:           fs,
-	})
+	chk, err := NewChecker("/manifest.mf", "/data", fs)
 	require.NoError(t, err)
 
 	results := make(chan Result, 10)
@@ -472,14 +368,10 @@ func TestFindExtraFilesSkipsManifestAndDotfiles(t *testing.T) {
 	require.NoError(t, afero.WriteFile(fs, "/data/.hidden", []byte("hidden"), 0o644))
 	require.NoError(t, afero.WriteFile(fs, "/data/.config/settings", []byte("cfg"), 0o644))
 	// Create a real extra file
-	require.NoError(t, fs.MkdirAll(testDataDir, 0o755))
+	require.NoError(t, fs.MkdirAll("/data", 0o755))
 	require.NoError(t, afero.WriteFile(fs, "/data/extra.txt", []byte("extra"), 0o644))
 
-	chk, err := NewChecker(&CheckerOptions{
-		ManifestPath: "/data/.index.mf",
-		BasePath:     testDataDir,
-		Fs:           fs,
-	})
+	chk, err := NewChecker("/data/.index.mf", "/data", fs)
 	require.NoError(t, err)
 
 	results := make(chan Result, 10)
@@ -508,14 +400,10 @@ func TestFindExtraFilesContextCancellation(t *testing.T) {
 
 	fs := afero.NewMemMapFs()
 	files := map[string][]byte{testFileName: []byte("data")}
-	createTestManifest(t, fs, testManifestPath, files)
+	createTestManifest(t, fs, "/manifest.mf", files)
 	createFilesOnDisk(t, fs, files)
 
-	chk, err := NewChecker(&CheckerOptions{
-		ManifestPath: testManifestPath,
-		BasePath:     testDataDir,
-		Fs:           fs,
-	})
+	chk, err := NewChecker("/manifest.mf", "/data", fs)
 	require.NoError(t, err)
 
 	ctx, cancel := context.WithCancel(context.Background())
@@ -531,14 +419,10 @@ func TestCheckNilChannels(t *testing.T) {
 
 	fs := afero.NewMemMapFs()
 	files := map[string][]byte{testFileName: []byte("data")}
-	createTestManifest(t, fs, testManifestPath, files)
+	createTestManifest(t, fs, "/manifest.mf", files)
 	createFilesOnDisk(t, fs, files)
 
-	chk, err := NewChecker(&CheckerOptions{
-		ManifestPath: testManifestPath,
-		BasePath:     testDataDir,
-		Fs:           fs,
-	})
+	chk, err := NewChecker("/manifest.mf", "/data", fs)
 	require.NoError(t, err)
 
 	// Should not panic with nil channels
@@ -551,14 +435,10 @@ func TestFindExtraFilesNilChannel(t *testing.T) {
 
 	fs := afero.NewMemMapFs()
 	files := map[string][]byte{testFileName: []byte("data")}
-	createTestManifest(t, fs, testManifestPath, files)
+	createTestManifest(t, fs, "/manifest.mf", files)
 	createFilesOnDisk(t, fs, files)
 
-	chk, err := NewChecker(&CheckerOptions{
-		ManifestPath: testManifestPath,
-		BasePath:     testDataDir,
-		Fs:           fs,
-	})
+	chk, err := NewChecker("/manifest.mf", "/data", fs)
 	require.NoError(t, err)
 
 	// Should not panic with nil channel
@@ -575,7 +455,7 @@ func TestCheckSubdirectories(t *testing.T) {
 		"dir1/dir2/file2.txt":     []byte("content2"),
 		"dir1/dir2/dir3/deep.txt": []byte("deep content"),
 	}
-	createTestManifest(t, fs, testManifestPath, files)
+	createTestManifest(t, fs, "/manifest.mf", files)
 
 	// Create files with full directory structure
 	for path, content := range files {
@@ -585,11 +465,7 @@ func TestCheckSubdirectories(t *testing.T) {
 		require.NoError(t, afero.WriteFile(fs, fullPath, content, 0o644))
 	}
 
-	chk, err := NewChecker(&CheckerOptions{
-		ManifestPath: testManifestPath,
-		BasePath:     testDataDir,
-		Fs:           fs,
-	})
+	chk, err := NewChecker("/manifest.mf", "/data", fs)
 	require.NoError(t, err)
 
 	results := make(chan Result, 10)
@@ -617,17 +493,13 @@ func TestCheckMissingFileDetectedWithoutFallback(t *testing.T) {
 		testExistsFile: []byte("here"),
 		"missing.txt":  []byte("not on disk"),
 	}
-	createTestManifest(t, fs, testManifestPath, files)
+	createTestManifest(t, fs, "/manifest.mf", files)
 	// Only create one file on disk
 	createFilesOnDisk(t, fs, map[string][]byte{
 		testExistsFile: []byte("here"),
 	})
 
-	chk, err := NewChecker(&CheckerOptions{
-		ManifestPath: testManifestPath,
-		BasePath:     testDataDir,
-		Fs:           fs,
-	})
+	chk, err := NewChecker("/manifest.mf", "/data", fs)
 	require.NoError(t, err)
 
 	results := make(chan Result, 10)
@@ -665,11 +537,7 @@ func TestFindExtraFilesSkipsDotfiles(t *testing.T) {
 	require.NoError(t,
 		afero.WriteFile(fs, "/data/.git/config", []byte("git config"), 0o644))
 
-	chk, err := NewChecker(&CheckerOptions{
-		ManifestPath: "/data/.index.mf",
-		BasePath:     testDataDir,
-		Fs:           fs,
-	})
+	chk, err := NewChecker("/data/.index.mf", "/data", fs)
 	require.NoError(t, err)
 
 	results := make(chan Result, 10)
@@ -698,11 +566,7 @@ func TestFindExtraFilesSkipsManifestFile(t *testing.T) {
 	createTestManifest(t, fs, "/data/index.mf", files)
 	createFilesOnDisk(t, fs, files)
 
-	chk, err := NewChecker(&CheckerOptions{
-		ManifestPath: "/data/index.mf",
-		BasePath:     testDataDir,
-		Fs:           fs,
-	})
+	chk, err := NewChecker("/data/index.mf", "/data", fs)
 	require.NoError(t, err)
 
 	results := make(chan Result, 10)
@@ -723,13 +587,9 @@ func TestCheckEmptyManifest(t *testing.T) {
 
 	fs := afero.NewMemMapFs()
 	// Create manifest with no files
-	createTestManifest(t, fs, testManifestPath, map[string][]byte{})
+	createTestManifest(t, fs, "/manifest.mf", map[string][]byte{})
 
-	chk, err := NewChecker(&CheckerOptions{
-		ManifestPath: testManifestPath,
-		BasePath:     testDataDir,
-		Fs:           fs,
-	})
+	chk, err := NewChecker("/manifest.mf", "/data", fs)
 	require.NoError(t, err)
 
 	assert.Equal(t, FileCount(0), chk.FileCount())
@@ -761,14 +621,10 @@ func TestCheckProgressRateLimited(t *testing.T) {
 		files[name] = []byte("content")
 	}
 
-	createTestManifest(t, fs, testManifestPath, files)
+	createTestManifest(t, fs, "/manifest.mf", files)
 	createFilesOnDisk(t, fs, files)
 
-	chk, err := NewChecker(&CheckerOptions{
-		ManifestPath: testManifestPath,
-		BasePath:     testDataDir,
-		Fs:           fs,
-	})
+	chk, err := NewChecker("/manifest.mf", "/data", fs)
 	require.NoError(t, err)
 
 	results := make(chan Result, 200)

mfer/deserialize.go

@@ -352,29 +352,16 @@ func NewManifestFromReader(input io.Reader) (*manifest, error) {
 	return m, nil
 }
 
-// ManifestFromFileOptions configures NewManifestFromFile.
-type ManifestFromFileOptions struct {
-	// Path is the manifest file to read (required).
-	Path string
-	// Fs is the filesystem to use, defaults to OsFs if nil.
-	Fs afero.Fs
-}
-
-// NewManifestFromFile reads a manifest from a file. It returns an error if
-// opts is nil or its path is empty.
+// NewManifestFromFile reads a manifest from a file path using the given filesystem.
+// If fs is nil, the real filesystem (OsFs) is used.
 //
 //nolint:revive // unexported-return: exporting manifest is owner question 13
-func NewManifestFromFile(opts *ManifestFromFileOptions) (*manifest, error) {
-	if opts == nil || opts.Path == "" {
-		return nil, errManifestPathEmpty
-	}
-
-	fs := opts.Fs
+func NewManifestFromFile(fs afero.Fs, path string) (*manifest, error) {
 	if fs == nil {
 		fs = afero.NewOsFs()
 	}
 
-	f, err := fs.Open(opts.Path)
+	f, err := fs.Open(path)
 	if err != nil {
 		return nil, err
 	}

script/generate

@@ -2,51 +2,16 @@
 # script/generate: regenerate mfer/mf.pb.go from mfer/mf.proto, and record
 # the hash of that mf.proto in mfer/mf.proto.sha256. Nothing else
 # regenerates mf.pb.go: it is committed, so building and checking need no
-# protoc. A test fails while mf.proto no longer matches the recorded hash.
-#
-# Needs exactly the protoc and protoc-gen-go versions named in the header of
-# the committed mf.pb.go (README.md says how to install them). Another
-# version writes a different mf.pb.go, so the script refuses to run.
+# protoc. Needs protoc and protoc-gen-go on PATH. A test fails while
+# mf.proto no longer matches the recorded hash.
 set -eu
 
 ROOT="$(cd "$(dirname "$0")/.." && pwd -P)"
 
-# protoc 33.4 names itself v6.33.4 in the mf.pb.go header.
-PROTOC_VERSION="33.4"
-PROTOC_GEN_GO_VERSION="v1.36.11"
-
-# require_version <command> <its exact --version output>
-require_version() {
-    actual="$("$1" --version 2>/dev/null || true)"
-    if [ "$actual" != "$2" ]; then
-        echo "generate: needs $2 on PATH, found: ${actual:-none}" >&2
-        echo "  README.md says how to install it." >&2
-        exit 1
-    fi
-}
-
-# sha256 <file>: print "<hash>  <file>", with sha256sum, or with shasum
-# where there is no sha256sum.
-sha256() {
-    if command -v sha256sum >/dev/null 2>&1; then
-        sha256sum "$1"
-    elif command -v shasum >/dev/null 2>&1; then
-        shasum -a 256 "$1"
-    else
-        echo "generate: needs sha256sum or shasum on PATH" >&2
-        exit 1
-    fi
-}
-
 main() {
     cd "$ROOT/mfer"
-    require_version protoc "libprotoc $PROTOC_VERSION"
-    require_version protoc-gen-go "protoc-gen-go $PROTOC_GEN_GO_VERSION"
-    # Hashed before regenerating, so a missing hash tool stops the script
-    # before it changes anything. Regenerating leaves mf.proto as it is.
-    proto_hash="$(sha256 mf.proto)"
     go generate .
-    echo "$proto_hash" >mf.proto.sha256
+    shasum -a 256 mf.proto >mf.proto.sha256
 }
 
 main "$@"