Byte-cap the annotation excerpt's primary portion before appending the teardown banner

annotationBody() byte-truncates the whole excerpt before splitting into
lines. A single retained primary line that alone approaches the truncation
budget got cut mid-line, taking the appended teardown banner and message
down with it even though the line-count reservation had left them room.

Author: cderv

tests/test.ts

@@ -515,17 +515,26 @@ function reportFailure(
     );
 
     // annotationBody keeps only its first kAnnotationExcerptLines NON-EMPTY
-    // lines of whatever excerpt it's given - a much smaller window than the
-    // kExcerptLines the primary message above was reserved against. A
-    // primary message with as few as kAnnotationExcerptLines non-empty lines
-    // already fills that window, silently dropping the teardown banner and
-    // message from the annotation even though both still fit in the fuller
-    // step-summary excerpt. Build the annotation body from a dedicated,
-    // reserved excerpt instead of reusing `excerpt` when a teardown/cleanup
-    // failure rides along; otherwise reuse `excerpt` unchanged.
+    // lines of whatever excerpt it's given, after its own defensive
+    // truncateUtf8Bytes(excerpt, kExcerptMaxBytes) - a much smaller line
+    // window than kExcerptLines, and a byte cap the primary message above
+    // was never bounded against for THIS excerpt. A primary message with as
+    // few as kAnnotationExcerptLines non-empty lines, or with a single line
+    // that alone approaches kExcerptMaxBytes, already fills that window,
+    // silently dropping the teardown banner and message from the annotation
+    // even though both still fit in the fuller step-summary excerpt. Build
+    // the annotation body from a dedicated, reserved excerpt instead of
+    // reusing `excerpt` when a teardown/cleanup failure rides along -
+    // capping the primary portion's bytes BEFORE appending the banner and
+    // message, so annotationBody's own byte truncation lands after them
+    // instead of cutting into the primary and consuming them too; otherwise
+    // reuse `excerpt` unchanged.
     const annotationExcerpt = finallyFailure
       ? [
-        ...stripAnsi(primary?.message ?? "")
+        ...truncateUtf8Bytes(
+          stripAnsi(primary?.message ?? ""),
+          kExcerptMaxBytes / 2,
+        )
           .split("\n")
           .filter((line) => line.trim().length > 0)
           .slice(0, kAnnotationExcerptLines - kFinallyAnnotationReservedLines),

tests/unit/harness-failure-reporting.test.ts

@@ -363,6 +363,29 @@ unitTest("harness-reporting - a primary message that trips both the line and byt
   );
 });
 
+unitTest("harness-reporting - a huge single-line primary message still leaves room for the teardown banner and message in the annotation", async () => {
+  const run = await gha();
+  const annotations = annotationsFor(
+    run.stdout,
+    "huge single-line message and teardown also throws",
+  );
+  assertEquals(annotations.length, 1);
+  assert(
+    !annotations[0].includes("y".repeat(300 * 1024)),
+    "the huge primary line must still be bounded, not embedded whole, in the annotation",
+  );
+  assert(
+    annotations[0].includes("TEARDOWN ALSO FAILED:"),
+    `the annotation's byte cap must not cut into the joined excerpt before the banner; annotation was:\n${
+      annotations[0]
+    }`,
+  );
+  assert(
+    annotations[0].includes("FIXTURE_HUGELINE_TEARDOWN_BOOM"),
+    "the annotation must also name the teardown failure, not just the summary",
+  );
+});
+
 unitTest("harness-reporting - a passing test produces no row and no annotation", async () => {
   const run = await gha();
   assertEquals(summaryRowsFor(run.summary, "fixture passes").length, 0);

tests/unit/harness-reporting-fixture.ts

@@ -102,3 +102,17 @@ unitTest("fixture throws a primary message that trips both the line and byte cap
     throw new Error("FIXTURE_BOTHCAPS_TEARDOWN_BOOM");
   },
 });
+
+// A single retained primary line that alone exceeds the annotation's own
+// byte cap, paired with a throwing teardown: the annotation excerpt's byte
+// truncation (applied AFTER the primary/banner/message are joined) must not
+// cut into the joined string before the banner and message, or they're
+// dropped from the annotation even though the step summary still shows them.
+// deno-lint-ignore require-await
+unitTest("fixture throws a huge single-line message and teardown also throws", async () => {
+  throw new Error("FIXTURE_HUGELINE_PRIMARY_" + "y".repeat(300 * 1024));
+}, {
+  teardown: () => {
+    throw new Error("FIXTURE_HUGELINE_TEARDOWN_BOOM");
+  },
+});