Default the manifest to index.mf and keep it out of its own listing (closes #100)

mfer gen now writes index.mf instead of .index.mf, the name fetch
requests and the README calls the standard filename. Given a
directory, check, freshen, list and export look only for index.mf;
.index.mf is no longer recognized. Because index.mf is not hidden, gen
and freshen now leave the manifest they write out of its own listing by
file identity (os.SameFile), so it is recognized however its path is
spelled, through a symlink included, while an ordinary file of the same
name elsewhere in the tree is still listed.

Model: opus-5-5

internal/cli/check.go

@@ -295,11 +295,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

@@ -505,10 +505,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())
@@ -532,10 +529,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)
 }
@@ -748,10 +742,7 @@ func TestGenerateFailsWithoutForceWhenOutputExists(t *testing.T) {
 func manifestPaths(t *testing.T, fs afero.Fs, path string) []string {
 	t.Helper()
 
-	manifest, err := mfer.NewManifestFromFile(&mfer.ManifestFromFileOptions{
-		Path: path,
-		Fs:   fs,
-	})
+	manifest, err := mfer.NewManifestFromFile(fs, path)
 	require.NoError(t, err)
 
 	paths := make([]string, 0, len(manifest.Files()))
@@ -821,26 +812,6 @@ func TestGenerateDefaultOutputLeftOutOfListing(t *testing.T) {
 	assert.Equal(t, []string{testFileTxt}, manifestPaths(t, fs, "index.mf"))
 }
 
-// TestGenerateLeavesLeftoverTempFileOutOfListing runs gen where an
-// interrupted run left its temp file, index.mf.tmp, beside the output:
-// the leftover is not listed, and gen does not fail when it overwrites
-// it.
-func TestGenerateLeavesLeftoverTempFileOutOfListing(t *testing.T) {
-	t.Parallel()
-
-	root := t.TempDir()
-	output := filepath.Join(root, "index.mf")
-
-	fs := afero.NewOsFs()
-	writeTestFile(t, fs, filepath.Join(root, testFileTxt), "hello")
-	writeTestFile(t, fs, output+".tmp", "part of a manifest")
-
-	opts := testOpts([]string{testApp, cmdGenerate, "-q", "-o", output, root}, fs)
-	require.Equal(t, 0, runCLI(opts), "stderr: %s", testStderr(t, opts))
-
-	assert.Equal(t, []string{testFileTxt}, manifestPaths(t, fs, output))
-}
-
 func TestGenerateAtomicWriteUsesTemp(t *testing.T) {
 	t.Parallel()
 

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

@@ -58,7 +58,6 @@ type freshenScanner struct {
 	fs              afero.Fs
 	absBase         string
 	manifestInfo    fs.FileInfo // the manifest being freshened
-	tmpInfo         fs.FileInfo // its leftover temp file; nil when there is none
 	includeDotfiles bool
 	followSymlinks  bool
 	showProgress    bool
@@ -182,10 +181,9 @@ func (s *freshenScanner) walk(path string, info fs.FileInfo, walkErr error) erro
 		info = realInfo
 	}
 
-	// Skip the manifest file itself and a temp file left beside it by an
-	// interrupted run, however their paths are spelled; gen leaves out its
-	// output file the same way. os.SameFile never matches a nil FileInfo.
-	if os.SameFile(info, s.manifestInfo) || os.SameFile(info, s.tmpInfo) {
+	// Skip the manifest file itself, however its path is spelled; gen
+	// leaves out its output file the same way.
+	if os.SameFile(info, s.manifestInfo) {
 		return nil
 	}
 
@@ -373,21 +371,10 @@ func (mfa *CLIApp) freshenScan(
 		return nil, 0, fmt.Errorf("freshen: %w", err)
 	}
 
-	// The temp file writeFreshenedManifest writes, if an interrupted run
-	// left one. One that cannot be stat'd, normally because it does not
-	// exist, needs no leaving out.
-	var tmpInfo fs.FileInfo
-
-	info, err := mfa.Fs.Stat(manifestPath + ".tmp")
-	if err == nil {
-		tmpInfo = info
-	}
-
 	scanner := &freshenScanner{
 		fs:              mfa.Fs,
 		absBase:         absBase,
 		manifestInfo:    manifestInfo,
-		tmpInfo:         tmpInfo,
 		includeDotfiles: ctx.Bool("include-dotfiles"),
 		followSymlinks:  ctx.Bool("follow-symlinks"),
 		showProgress:    showProgress,
@@ -465,10 +452,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

@@ -59,10 +59,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)
 }
@@ -74,10 +71,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)
 
@@ -132,34 +126,6 @@ func TestFreshenLeavesManifestOutOfListing(t *testing.T) {
 		manifestPaths(t, fs, manifestPath))
 }
 
-// TestFreshenLeavesLeftoverTempFileOutOfListing freshens a manifest where
-// an interrupted run left its temp file, index.mf.tmp, beside it: the
-// leftover is not listed.
-func TestFreshenLeavesLeftoverTempFileOutOfListing(t *testing.T) {
-	t.Parallel()
-
-	root := t.TempDir()
-	manifestPath := filepath.Join(root, "index.mf")
-
-	fs := afero.NewOsFs()
-	writeTestFile(t, fs, filepath.Join(root, testFileTxt), "hello")
-
-	opts := testOpts([]string{testApp, cmdGenerate, "-q", "-o", manifestPath, root}, fs)
-	require.Equal(t, 0, runCLI(opts), "stderr: %s", testStderr(t, opts))
-
-	writeTestFile(t, fs, manifestPath+".tmp", "part of a manifest")
-	// A new file gives freshen something to write.
-	writeTestFile(t, fs, filepath.Join(root, "added.txt"), "added")
-
-	opts = testOpts([]string{
-		testApp, "freshen", "-q", testFlagBase, root, manifestPath,
-	}, fs)
-	require.Equal(t, 0, runCLI(opts), "stderr: %s", testStderr(t, opts))
-
-	assert.ElementsMatch(t, []string{testFileTxt, "added.txt"},
-		manifestPaths(t, fs, manifestPath))
-}
-
 // TestFreshenRecordEntryMtimePresence pins the behavior of recordEntry
 // with respect to MFFilePath.Mtime, which is a message pointer with
 // proto3 field presence and may legitimately be absent.

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"
 
@@ -19,10 +17,6 @@ const (
 	testFile1      = "file1.txt"
 	testFile2      = "file2.txt"
 	testExistsFile = "exists.txt"
-	testManifestPath = "/manifest.mf"
-	testDataDir      = "/data"
-	// testDataManifestPath is a manifest kept inside the checked tree.
-	testDataManifestPath = testDataDir + "/index.mf"
 )
 
 func TestStatusString(t *testing.T) {
@@ -72,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))
 	}
 }
@@ -94,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())
@@ -110,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)
 	})
 
@@ -123,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()
 
@@ -199,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())
@@ -220,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)
@@ -254,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)
@@ -297,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)
@@ -327,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")
@@ -335,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)
@@ -359,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)
@@ -403,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())
@@ -429,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{
@@ -437,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)
@@ -466,7 +360,7 @@ func TestFindExtraFilesSkipsManifestAndDotfiles(t *testing.T) {
 	manifestFiles := map[string][]byte{
 		testFile1: []byte("in manifest"),
 	}
-	createTestManifest(t, fs, testDataManifestPath, manifestFiles)
+	createTestManifest(t, fs, "/data/index.mf", manifestFiles)
 	createFilesOnDisk(t, fs, map[string][]byte{
 		testFile1: []byte("in manifest"),
 	})
@@ -474,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: testDataManifestPath,
-		BasePath:     testDataDir,
-		Fs:           fs,
-	})
+	chk, err := NewChecker("/data/index.mf", "/data", fs)
 	require.NoError(t, err)
 
 	results := make(chan Result, 10)
@@ -510,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())
@@ -533,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
@@ -553,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
@@ -577,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 {
@@ -587,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)
@@ -619,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)
@@ -658,7 +528,7 @@ func TestFindExtraFilesSkipsDotfiles(t *testing.T) {
 	files := map[string][]byte{
 		testFile1: []byte("in manifest"),
 	}
-	createTestManifest(t, fs, testDataManifestPath, files)
+	createTestManifest(t, fs, "/data/index.mf", files)
 	createFilesOnDisk(t, fs, files)
 
 	// Add dotfiles and manifest file on disk
@@ -667,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: testDataManifestPath,
-		BasePath:     testDataDir,
-		Fs:           fs,
-	})
+	chk, err := NewChecker("/data/index.mf", "/data", fs)
 	require.NoError(t, err)
 
 	results := make(chan Result, 10)
@@ -697,14 +563,10 @@ func TestFindExtraFilesSkipsManifestFile(t *testing.T) {
 	files := map[string][]byte{
 		testFile1: []byte("content"),
 	}
-	createTestManifest(t, fs, testDataManifestPath, files)
+	createTestManifest(t, fs, "/data/index.mf", files)
 	createFilesOnDisk(t, fs, files)
 
-	chk, err := NewChecker(&CheckerOptions{
-		ManifestPath: testDataManifestPath,
-		BasePath:     testDataDir,
-		Fs:           fs,
-	})
+	chk, err := NewChecker("/data/index.mf", "/data", fs)
 	require.NoError(t, err)
 
 	results := make(chan Result, 10)
@@ -725,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())
@@ -763,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
 	}

mfer/scanner.go

@@ -59,11 +59,10 @@ type ScannerOptions struct {
 	// Seed, if set, derives a deterministic UUID from this seed.
 	Seed string
 	// OutputPath, if set, is the file the manifest will be written to.
-	// Enumeration leaves out that file and OutputPath + ".tmp", the temp
-	// file mfer gen writes first, if they exist when the scanner is
-	// created, however their paths are spelled (through a symlink, a hard
-	// link, or in different letter case), so neither a manifest being
-	// replaced nor a temp file left by an interrupted run is ever listed.
+	// If that file exists when the scanner is created, enumeration leaves
+	// it out however its path is spelled (through a symlink, a hard link,
+	// or in different letter case), so a manifest being replaced is never
+	// listed.
 	// Files are matched with os.SameFile, which only recognizes files on
 	// the operating system's filesystem.
 	OutputPath string
@@ -86,7 +85,6 @@ type Scanner struct {
 	options    *ScannerOptions
 	fs         afero.Fs
 	outputInfo fs.FileInfo // the existing output file; nil when there is none
-	tmpInfo    fs.FileInfo // its leftover temp file; nil when there is none
 }
 
 // NewScanner creates a new Scanner with default options.
@@ -112,17 +110,12 @@ func NewScannerWithOptions(opts *ScannerOptions) *Scanner {
 	}
 
 	if opts.OutputPath != "" {
-		// A file that cannot be stat'd, normally because it does not
-		// exist, needs no leaving out.
+		// If the output file cannot be stat'd, normally because it does
+		// not exist yet, there is nothing to leave out.
 		info, err := s.fs.Stat(opts.OutputPath)
 		if err == nil {
 			s.outputInfo = info
 		}
-
-		info, err = s.fs.Stat(opts.OutputPath + ".tmp")
-		if err == nil {
-			s.tmpInfo = info
-		}
 	}
 
 	return s
@@ -463,9 +456,8 @@ func (s *Scanner) enumerateFileWithInfo(
 		info = realInfo
 	}
 
-	// Neither the manifest being written nor its temp file is one of the
-	// files it lists. os.SameFile never matches a nil FileInfo.
-	if os.SameFile(info, s.outputInfo) || os.SameFile(info, s.tmpInfo) {
+	// The manifest being written is not one of the files it lists.
+	if s.outputInfo != nil && os.SameFile(info, s.outputInfo) {
 		return nil
 	}