@@ -64,14 +64,17 @@ var (
 			"Or give the run more memory through the memory setting")
 )
 
-// TooManyFilesInRun is what a run past MaxFilesPerRun asks for: the files it
-// came to at the target that crossed the ceiling, across all the targets it
-// has.
+// TooManyFilesInRun is what a run past MaxFilesPerRun asks for: every file of
+// every target, across all of them.
 //
 // Both the recipe reader and the engine count the run, and a recipe refused by
 // either reads the same - so the sentence is written here, once, rather than
-// beside each of them (O302).
-func TooManyFilesInRun(files, targets int) Said {
+// beside each of them (O302). The number is the whole run's, not the running
+// total at the target that crossed the ceiling where both of them refuse: ten
+// targets of a million were told they asked for two million (review of #219).
+// An int64 because a recipe of a megabyte holds tens of thousands of targets
+// of a million, which is past what an int of 32 bits counts.
+func TooManyFilesInRun(files int64, targets int) Said {
 	return Says("core.TooManyFilesInRun", "this run asks for %s across %s",
 		A("Files", SaysN("core.FilesInRun", "%d file", "%d files", A("Count", files))),
 		A("Targets", SaysN("core.TargetsInRun", "%d target", "%d targets", A("Count", targets))))
 
@@ -332,3 +332,23 @@ func BoundarySizes(limit int64) ([]int64, error) {
 	}
 	return []int64{limit - 1, limit, limit + 1}, nil
 }
+
+// Uniform is n files of the same size, in a list reserved at its length.
+//
+// Here because the recipe reader builds the same list as the engine and cannot
+// import it, and two copies of one list were what a review of #219 named.
+// Reserved rather than grown: one append at a time, the list for a million
+// files cost 40 B a file to build for 8 B a file kept - every growth leaves the
+// last array to the collector - and the batch screen builds it on every key
+// (O302, measured on 2026-11-04: 41.7 MB for a target of a million, 8.0 MB
+// reserved).
+func Uniform(n int, bytes int64) []int64 {
+	if n <= 0 {
+		return nil
+	}
+	out := make([]int64, n)
+	for i := range out {
+		out[i] = bytes
+	}
+	return out
+}
@@ -100,17 +100,9 @@ type SizeRange struct {
 	Min, Max int64
 }
 
-// Uniform is n files of the same size, which is what most targets ask for.
-func Uniform(n int, bytes int64) []int64 {
-	if n <= 0 {
-		return nil
-	}
-	out := make([]int64, n)
-	for i := range out {
-		out[i] = bytes
-	}
-	return out
-}
+// Uniform is n files of the same size, which is what most targets ask for. It
+// is core's, under the name the engine's callers reach for.
+func Uniform(n int, bytes int64) []int64 { return core.Uniform(n, bytes) }
 
 // Options are the settings of one run.
 type Options struct {
@@ -486,7 +478,7 @@ func PlanContext(ctx context.Context, targets []Target, opt Options) ([]PlannedF
 			// reader's is.
 			return nil, &RecipeError{
 				Setting: core.TargetAddress(i+1, SettingCount),
-				Detail:  core.TooManyFilesInRun(totalFiles, len(targets)),
+				Detail:  core.TooManyFilesInRun(filesIn(targets), len(targets)),
 				Because: core.TooManyFilesWhy,
 				Remedy:  core.TooManyFilesFix}
 		}
@@ -498,6 +490,17 @@ func PlanContext(ctx context.Context, targets []Target, opt Options) ([]PlannedF
 	return pl.out, nil
 }
 
+// filesIn is every file the targets ask for, which is what a refusal of the
+// run's ceiling says - rather than the running total at the target that
+// crossed it, which is where the refusal is made.
+func filesIn(targets []Target) int64 {
+	var n int64
+	for i := range targets {
+		n += int64(len(targets[i].Sizes))
+	}
+	return n
+}
+
 // Run writes a planned set of files.
 //
 // Each file is written under a temporary name and only then renamed, so the
 
@@ -2609,17 +2609,33 @@
         # The engine's address: the merged list, preset's targets first.
         "the run's ceiling names the target by the merged list rather than the file",
         "internal/recipe/recipe.go",
-        "p.add(at(t.ID).of(KeyCount), core.TooManyFilesInRun(planned+files, len(raw.Targets)),",
-        "p.add(targetSpot(i, t.ID).of(KeyCount), core.TooManyFilesInRun(planned+files, len(raw.Targets)),",
+        "crossedAt = at(t.ID).of(KeyCount)",
+        "crossedAt = targetSpot(i, t.ID).of(KeyCount)",
         "TestTheTargetThatCrossesTheRunCeilingIsPlacedInTheFile",
     ),
     (
         "the run's ceiling marks the size of the batch that crossed it rather than its count",
         "internal/recipe/recipe.go",
-        "p.add(at(t.ID).of(KeyCount), core.TooManyFilesInRun(planned+files, len(raw.Targets)),",
-        "p.add(at(t.ID).of(KeySize), core.TooManyFilesInRun(planned+files, len(raw.Targets)),",
+        "crossedAt = at(t.ID).of(KeyCount)",
+        "crossedAt = at(t.ID).of(KeySize)",
         "TestARefusalAboutTheWholeRunMarksTheBatchThatCausedIt",
     ),
+    (
+        # Review of #219: the running total where the run crossed is what both
+        # layers said, and ten targets of a million were told two million.
+        "the run's ceiling says the files up to the target that crossed it rather than the whole run's",
+        "internal/recipe/recipe.go",
+        "p.add(crossedAt, core.TooManyFilesInRun(asked, len(raw.Targets)),",
+        "p.add(crossedAt, core.TooManyFilesInRun(int64(planned), len(raw.Targets)),",
+        "TestTheRunCeilingSaysWhatTheWholeRunAsksFor",
+    ),
+    (
+        "the engine's ceiling says the files up to the target that crossed it rather than the whole run's",
+        "internal/engine/engine.go",
+        "Detail:  core.TooManyFilesInRun(filesIn(targets), len(targets)),",
+        "Detail:  core.TooManyFilesInRun(int64(totalFiles), len(targets)),",
+        "TestTheEngineCountsTheWholeRunOfTargetsHandedToItDirectly",
+    ),
     (
         "a target past the run's ceiling has its list built before it is refused",
         "internal/recipe/target.go",
@@ -2628,10 +2644,12 @@
         "TestATargetPastTheRunCeilingIsNotBuilt",
     ),
     (
+        # In core since the review of #219, which named the reader's own copy of
+        # engine.Uniform. Both now take this one.
         "a target's list of sizes is grown one file at a time again",
-        "internal/recipe/target.go",
-        "\tsizes := make([]int64, count)\n\tfor i := range sizes {\n\t\tsizes[i] = each\n\t}",
-        "\tvar sizes []int64\n\tfor range count {\n\t\tsizes = append(sizes, each)\n\t}",
+        "internal/core/size.go",
+        "\tout := make([]int64, n)\n\tfor i := range out {\n\t\tout[i] = bytes\n\t}",
+        "\tvar out []int64\n\tfor range n {\n\t\tout = append(out, bytes)\n\t}",
         "TestATargetsListOfSizesIsReservedAtItsLength",
     ),
     (
 
@@ -134,6 +134,23 @@ func TestTheRunCeilingSitsExactlyAtAMillion(t *testing.T) {
 	}
 }
 
+// The refusal says the files the whole run asks for, at the target that
+// crossed the ceiling.
+//
+// Both are refused where the run crosses, so the running total there was the
+// number they said - ten targets of a million were told they asked for two
+// million across ten targets (review of #219, measured with the binary before
+// O302 as well). The target after the one that crosses is what tells the two
+// numbers apart.
+func TestTheRunCeilingSaysWhatTheWholeRunAsksFor(t *testing.T) {
+	src := targetsOf(1, core.MaxFilesPerRun, core.MaxFilesPerRun)
+	ceilingAt(t, src, 2)
+	_, err := recipe.Parse(src, "whole run")
+	if !strings.Contains(err.Error(), "2000001 files across 3 targets") {
+		t.Errorf("the refusal does not say the files the whole run asks for, 2000001:\n%v", err)
+	}
+}
+
 // A run past the ceiling is reported together with whatever else is wrong.
 //
 // Every problem of a recipe arrives at once (RC7). While the engine counted the
@@ -241,19 +258,25 @@ targets:
 // targets by whoever calls it, though, and planCapacity reserves nothing past
 // the ceiling on the word of this refusal. The memory setting is there so a
 // build that lost the refusal plans until the plan ceiling stops it, a few
-// megabytes in, rather than a million files.
+// megabytes in, rather than a million files. A third target follows the one
+// that crosses, so the number the refusal says is asked to be the whole run's
+// rather than the running total where it stopped.
 func TestTheEngineCountsTheWholeRunOfTargetsHandedToItDirectly(t *testing.T) {
 	targets := []engine.Target{
 		{ID: "small", Format: "txt", Sizes: engine.Uniform(1, 1024)},
 		{ID: "big", Format: "txt", Sizes: engine.Uniform(core.MaxFilesPerRun, 1024)},
+		{ID: "after", Format: "txt", Sizes: engine.Uniform(core.MaxFilesPerRun, 1024)},
 	}
 	_, err := engine.Plan(targets, engine.Options{OutDir: t.TempDir(), ManifestName: "manifest.json", Memory: core.MemoryOf(32 << 20)})
 	if err == nil {
-		t.Fatal("a run of one file more than the ceiling was planned")
+		t.Fatal("a run of a million files more than the ceiling was planned")
 	}
-	if !strings.Contains(err.Error(), "1000001 files across 2 targets") {
+	if !strings.Contains(err.Error(), "files across 3 targets") {
 		t.Fatalf("the run was refused for something other than its count of files: %v", err)
 	}
+	if !strings.Contains(err.Error(), "2000001 files across 3 targets") {
+		t.Errorf("the refusal does not say the files the whole run asks for, 2000001: %v", err)
+	}
 	var about interface{ AboutSetting() string }
 	if !errors.As(err, &about) || about.AboutSetting() != core.TargetAddress(2, engine.SettingCount) {
 		t.Errorf("the refusal is not addressed to the target that crossed the ceiling, %s: %v",
 
@@ -448,17 +448,21 @@ func (raw rawRecipe) readTargets(p *problems, def Defaults, fromPreset int) []Ta
 	// adds more than the ceiling: a count past it is refused as the target's
 	// own and asks for nothing.
 	planned := 0
+	// What every target asks for, which is the number the refusal says. The
+	// running total stops at the target that crossed the ceiling, and ten
+	// targets of a million were told they asked for two (review of #219).
+	var asked int64
+	// The target that takes the run past the ceiling, which is the one
+	// somebody can shrink. Only one is: every target after it is past the
+	// ceiling as well, and saying so of each would bury the one that matters.
+	crossedAt := ""
 	for i, rt := range raw.Targets {
 		at := spotOfTarget(i, fromPreset)
 		room := core.MaxFilesPerRun - planned
 		t, files := rt.validate(p, at, def, room)
-		// Refused at the target that takes the run past the ceiling, which is
-		// the one somebody can shrink, and in the engine's words. Once, because
-		// every target after it is past the ceiling as well, and saying so of
-		// each would bury the one that matters.
+		asked += int64(files)
 		if room >= 0 && files > room {
-			p.add(at(t.ID).of(KeyCount), core.TooManyFilesInRun(planned+files, len(raw.Targets)),
-				core.TooManyFilesWhy, core.TooManyFilesFix)
+			crossedAt = at(t.ID).of(KeyCount)
 		}
 		planned = min(planned+files, core.MaxFilesPerRun+1)
 		if t.ID != "" {
@@ -470,6 +474,10 @@ func (raw rawRecipe) readTargets(p *problems, def Defaults, fromPreset int) []Ta
 		}
 		targets = append(targets, t)
 	}
+	// Said once every target is counted, in the engine's words.
+	if crossedAt != "" {
+		p.add(crossedAt, core.TooManyFilesInRun(asked, len(raw.Targets)), core.TooManyFilesWhy, core.TooManyFilesFix)
+	}
 	return targets
 }
 
 
@@ -245,7 +245,7 @@ func (rt rawTarget) resolveSize(p *problems, where spot, count int, t *Target) {
 				core.Says("recipe.UseSettingSuchAs2mb512kb", "use {a} {setting} such as 2mb, 512kb or a plain byte count"))
 			break
 		}
-		t.Sizes = sizesOf(count, n)
+		t.Sizes = core.Uniform(count, n)
 
 	case rt.SizeRange != nil:
 		// Placed above contains for the same reason size is: a stated size
@@ -268,15 +268,15 @@ func (rt rawTarget) resolveSize(p *problems, where spot, count int, t *Target) {
 		// The values stay zero here and the engine replaces them. What this
 		// list carries at this point is the number of files, exactly as it
 		// does for contains.
-		t.Sizes = sizesOf(count, 0)
+		t.Sizes = core.Uniform(count, 0)
 
 	case rt.Contains != nil:
 		// The fourth way of declaring a size, and not an exception to the rule.
 		// Every member has its own size, so the total follows from the parts
 		// and a dry run still reports a number without generating anything.
 		// See ARCHITECTURE.md section 9.
 		t.SizeFromContents = true
-		t.Sizes = sizesOf(count, 0)
+		t.Sizes = core.Uniform(count, 0)
 
 	default:
 		p.add(where.of("size"), core.Says("recipe.HasNoSetting", "%s has no {setting}", core.A("At", where)),
@@ -400,24 +400,6 @@ func boundaryText(p *problems, where spot, v *scalar) string {
 	return s
 }
 
-// sizesOf is count files of one size, in a list reserved at its length.
-//
-// Grown one append at a time, the list for a million files cost 40 B a file to
-// build for 8 B a file kept - every growth leaves the last array to the
-// collector - and the batch screen builds it on every key (O302, measured
-// 2026-11-04: 41.7 MB for one target of a million). engine.Uniform is the same
-// list on the side of the engine, which this package cannot import.
-func sizesOf(count int, each int64) []int64 {
-	if count <= 0 {
-		return nil
-	}
-	sizes := make([]int64, count)
-	for i := range sizes {
-		sizes[i] = each
-	}
-	return sizes
-}
-
 // boundarySizes turns a limit into the three sizes a boundary set means.
 //
 // This is the case the whole tool is pointed at: an application says it