test(scripts): floor publish-smoke-pack's self-test with a hoisted single battery

`SELF-TEST PASSED (n cases)` was printed on `process.exitCode !== 1` alone, so
a self-test whose four cases never registered printed the same line as one
where every case held.

Recipe b5 (PR #15217): ONE battery opened at the top of the self-test body,
named `publish-smoke-pack self-test`, floor = the count measured on a run (4),
`SELF_TEST_BATTERIES` size pinned at 1, `registerCase()` called from the
existing `check(name, fn)` helper's block body, and a verdict that refuses a
below-floor / DID-NOT-RUN / undeclared battery through the same sink the cases
use (a `FAIL` line plus the failing exit code). No comment is promoted to a
section head; no assertion condition is touched; the verdict handshake
(`SELF_TEST_VERDICT`) is unchanged.

Floor measured, not counted: the roster was first pinned at 9999 and the breach
line named `registered 4 case(s)`.

Part of #13799

Co-authored-by: Claude <noreply@anthropic.com>

Author: claude

scripts/publish-smoke-pack.mjs

@@ -180,15 +180,65 @@ async function main() {
  * the derivation) is invisible to any fixture whose names all start with `@`.
  */
 
+// ── The self-test's own battery roster and floor (#13489) ──────────────────
+//
+// A `cases` list that holds a line per case, ok or FAIL, used to be this
+// self-test's ONLY success condition, so "every case held" and "the cases
+// never ran" printed the same line. Closed the way PR #13487 validated on
+// check-doc-authoring: what is pinned is the registered NAMES, not a
+// number. The floor requires the OPENED set to equal the DECLARED set with
+// each battery at or above its own count.
+//
+// This file declares ONE battery, opened at the top of the self-test body. It
+// carries fewer than the two named section banners the sectioning criterion
+// needs, and ⛔ a comment is NOT promoted to a section head — that is a
+// judgement per comment this transplant does not make. The hoisted single
+// battery is the shape PR #14896, PR #15003 and PR #15217 landed for exactly
+// this case.
+//
+// ⛔ A pinned TOTAL is not the repair: a battery dropping from 9 cases to 3
+// keeps a total "right" the moment a sibling grows.
+//
+// The count is a FLOOR, not an equality — adding cases is ordinary work and must
+// not red. A battery BELOW its floor means cases stopped running; the remedy is
+// to find what stopped registering.
+const SELF_TEST_BATTERIES = Object.freeze({
+  'publish-smoke-pack self-test': 4,
+});
+
+// DELETING an entry silences that battery's floor exactly as effectively as
+// zeroing it, so the roster's own size is pinned too.
+const SELF_TEST_BATTERY_FLOOR = 1;
+
+// The key an assertion is filed under when no battery is open. It is not a
+// declared battery, so it reds by the same set difference rather than silently
+// inflating whichever battery happened to run last.
+const UNATTRIBUTED_BATTERY = '(no battery open)';
+
 // Returned by `selfTest()` only after its verdict is printed. The dispatch
 // refuses anything else: a `return` that leaves the function above that line
 // prints nothing and still exits 0 — a self-test that never finished, reported
 // as one that passed (#13798).
 const SELF_TEST_VERDICT = 'publish-smoke-pack self-test reached its verdict';
 
 function selfTest() {
+  // The battery ledger this self-test's floor is evaluated against (#13489).
+  // `battery()` opens a battery; every assertion below is attributed to the one
+  // most recently opened, so a section that stops running stops registering and
+  // names ITSELF at the floor rather than going quiet.
+  const batterySeen = new Map();
+  let openBattery = null;
+  const battery = (name) => {
+    openBattery = name;
+  };
+  const registerCase = () => {
+    const b = openBattery ?? UNATTRIBUTED_BATTERY;
+    batterySeen.set(b, (batterySeen.get(b) ?? 0) + 1);
+  };
+  battery('publish-smoke-pack self-test');
   const cases = [];
   const check = (name, fn) => {
+    registerCase();
     try {
       fn();
       cases.push(`  ok — ${name}`);
@@ -248,6 +298,56 @@ function selfTest() {
     assert(msg.includes('@objectstack/gone'), `the diagnostic does not name the surplus package: ${msg}`);
   });
 
+  // ── The floor: every declared battery RAN, and ran its cases (#13489) ────
+  //
+  // Evaluated after every battery has had its chance and BEFORE the verdict, so
+  // the success line below can only be printed by a run in which the set of
+  // batteries that registered assertions EQUALS the set declared. A set
+  // difference names WHICH battery stopped; a count says only that something did.
+  // The floor's refusal joins the SAME sink the cases use — a line in the
+  // report and the failing exit code — so a breached floor reads exactly like a
+  // failed case and cannot be printed over by the verdict below.
+  const floorFailure = (message) => {
+    cases.push(`  FAIL — ${message}`);
+    process.exitCode = 1;
+  };
+  const declaredBatteries = Object.keys(SELF_TEST_BATTERIES);
+  let floorBreached = false;
+  if (declaredBatteries.length < SELF_TEST_BATTERY_FLOOR) {
+    floorBreached = true;
+    floorFailure(
+      `SELF_TEST_BATTERIES declares ${declaredBatteries.length} batteries, below the pinned `
+        + `${SELF_TEST_BATTERY_FLOOR} — a battery deleted from the roster takes its own floor with it.`,
+    );
+  }
+  for (const [name, count] of batterySeen) {
+    if (declaredBatteries.includes(name)) continue;
+    floorBreached = true;
+    floorFailure(
+      `self-test battery "${name}" registered ${count} case(s) but is not declared in `
+        + 'SELF_TEST_BATTERIES — an assertion attributed to no declared battery is one nothing floors.',
+    );
+  }
+  for (const name of declaredBatteries) {
+    const count = batterySeen.get(name) ?? 0;
+    if (count >= SELF_TEST_BATTERIES[name]) continue;
+    floorBreached = true;
+    floorFailure(
+      count === 0
+        ? `self-test battery "${name}" DID NOT RUN — 0 cases registered, ${SELF_TEST_BATTERIES[name]} pinned. `
+          + 'The verdict below would have claimed those cases hold.'
+        : `self-test battery "${name}" registered ${count} case(s), below its pinned floor of `
+          + `${SELF_TEST_BATTERIES[name]} — cases that used to run no longer do.`,
+    );
+  }
+  if (floorBreached) {
+    floorFailure(
+      'A battery at or below its floor means cases STOPPED RUNNING — the battery is the bug, not the '
+        + 'number. Find what stopped registering (an early return, a deleted block, a guard that now '
+        + 'skips) and restore it.',
+    );
+  }
+
   console.log('publish-smoke-pack self-test');
   for (const line of cases) console.log(line);
   console.log(process.exitCode === 1 ? 'SELF-TEST FAILED' : `SELF-TEST PASSED (${cases.length} cases)`);