objectstack-ai
diff --git a/‎scripts/check-sdui-manifest.mjs‎
Lines changed: 107 additions & 1 deletion b/‎scripts/check-sdui-manifest.mjs‎
Lines changed: 107 additions & 1 deletion
@@ -144,6 +144,49 @@ export function checkTree(root) {
 // as one that passed (#13798).
 const SELF_TEST_VERDICT = 'check-sdui-manifest self-test reached its verdict';
 
+// ── The self-test's own battery roster and floor (#13489) ──────────────────
+//
+// `failures === 0` 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 PR
+// #13487 way: what is pinned is the registered NAMES, not a number.
+//
+// This self-test is TABLE-DRIVEN — one literal `cases` table, one loop over it,
+// and a sink (`failures++`) that writes only when a case FAILS. Routing THAT
+// sink through `registerCase()` would register a case only when it fails: a
+// fully green run would register 0 and every battery would read DID NOT RUN, the
+// floor inverted rather than installed. So the roster is the table's own rows.
+// Each row LABEL is a declared battery, verbatim, with a floor of 1, and
+// `registerCase(name)` is the first statement of the driving loop body — so the
+// case is attributed to the row actually being run, whatever that row asserts
+// afterwards. There is no `battery()` opener: for a table-driven self-test the
+// ROW is the battery, so attribution is the loop variable rather than a
+// most-recently-opened section.
+//
+// ⛔ A pinned TOTAL is not the repair, and neither is a roster DERIVED from the
+// table: `cases.length` moves with the table, so a deleted row would delete its
+// own floor. The roster below is a LITERAL the table is checked against, which
+// is what lets a deleted or renamed row name ITSELF in the refusal.
+//
+// The counts are a FLOOR, not an equality — a row that grows into several
+// registrations must not red. 1 is the honest floor for a table row: the loop
+// reaches it exactly once per run.
+const SELF_TEST_BATTERIES = Object.freeze({
+  'green fixture passes': 1,
+  'missing artefact is RED': 1,
+  'hand-edited artefact (hash mismatch) is RED': 1,
+  'moved pin is RED': 1,
+  'empty components is RED': 1,
+  'missing record is RED': 1,
+});
+
+// DELETING an entry silences that battery's floor exactly as effectively as
+// zeroing it, so the roster's own size is pinned too. This pin is also half of
+// the duplicate-label refusal: two rows sharing a label collapse to ONE key in
+// the literal above, so the roster falls below this number; the table
+// cross-check in the floor block is the other half, and names WHICH label
+// collided.
+const SELF_TEST_BATTERY_FLOOR = 6;
+
 function selfTest() {
   const mk = (mutate) => {
     const root = mkdtempSync(join(tmpdir(), 'sdui-manifest-check-'));
@@ -187,8 +230,15 @@ function selfTest() {
     ['missing record is RED', mk((r) => rmSync(join(r, 'scripts', 'sdui-manifest.record.json'))), 1],
   ];
 
+  // The ledger this self-test's floor is evaluated against (#13489).
+  const batterySeen = new Map();
+  const registerCase = (name) => {
+    batterySeen.set(name, (batterySeen.get(name) ?? 0) + 1);
+  };
+
   let failures = 0;
   for (const [name, root, want] of cases) {
+    registerCase(name);
     const problems = checkTree(root);
     const got = problems.length ? 1 : 0;
     if (got !== want) {
@@ -197,8 +247,64 @@ function selfTest() {
       for (const p of problems) console.error(`    ${p}`);
     }
   }
+  // ── The floor: every declared row RAN, and ran its case (#13489) ───────
+  //
+  // Evaluated after every row 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 rows
+  // that registered EQUALS the set declared. A set difference names WHICH row
+  // stopped; a count says only that something did.
+  const floorFailure = (message) => {
+    console.error(`✗ self-test floor: ${message}`);
+    failures++;
+  };
+  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.`,
+    );
+  }
+  const rowLabels = cases.map(([name]) => name);
+  const duplicated = [...new Set(rowLabels.filter((name, i) => rowLabels.indexOf(name) !== i))];
+  if (duplicated.length > 0) {
+    floorBreached = true;
+    floorFailure(
+      `the cases table uses ${duplicated.map((n) => JSON.stringify(n)).join(', ')} as a row label more than once — ` +
+        'two rows sharing a label are ONE battery, so the second can stop running while the first keeps the floor met.',
+    );
+  }
+  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 — a case 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 that case holds.'
+        : `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 (a deleted row, a renamed label, a loop that no longer ' +
+        'reaches it) and restore it.',
+    );
+  }
+
   if (failures) {
-    console.error(`✗ check-sdui-manifest self-test: ${failures} case(s) failed.`);
+    console.error(`✗ check-sdui-manifest self-test: ${failures} failure(s) (cases and floor).`);
     process.exit(1);
   }
   console.log(`✓ check-sdui-manifest self-test: ${cases.length} cases behave (green passes; absence, tamper, moved pin, emptiness are RED).`);