test(events): harden public-SSE field test + clarify state-key comment

Addresses code-review minor findings on 46aed25:

1. serviceType mapping (r.type ?? r.serviceType) only tested the type:1 path.
   Add a fallback case ({serviceType:2}, no type) and a type:0 case that locks
   in ?? (not ||) semantics so a valid 0 service type is not dropped.
2. The naive balanced-brace/bracket extractors silently truncate if a brace or
   bracket ever lands inside a string/regex in a target. Add mustExtract(): it
   asserts each extracted block ends with its closing token AND contains a known
   last field (baselineAtTest / activeRunNumber / next_in_ms), turning a
   mis-extraction into a loud, clear failure instead of a misleading
   field-missing assertion.
3. server.js PUBLIC_STATE_KEYS comment understated the audit — reword to note a
   subset (testRun/runMode/runPlanId/pricingMode) is also read by public.html.

npm test: 57 assertions in the new suite, full suite green.

Author: Sentinel-Bluebuilder

server.js

@@ -1892,7 +1892,8 @@ function _redactPublicError(v, max = 200) {
 // Keep only the state fields /live actually reads. Strips wallet, balance*,
 // spent*, MNEMONIC-derived data, errorMessage internals, and any counter or
 // progress field the public surfaces never consume.
-// Each key below is verified read by live.html:
+// Each key below is verified read by live.html (and a subset — testRun /
+// runMode / runPlanId / pricingMode — also by public.html):
 //   - status / totalNodes / testRun / runMode / runPlanId / pricingMode /
 //     activeRunNumber are read directly off _liveState.
 //   - baselineMbps / baselineHistory feed computeBaselineAvg(_liveState) for

test/public-sse-fields.test.js

@@ -61,20 +61,45 @@ function extractArrayLiteral(s, name) {
   return s.slice(start, j); // "[ ... ]"
 }
 
+// The extractors above are naive char counters: a brace/bracket inside a
+// string or regex literal in the target would silently truncate the slice and
+// turn into a confusing "field missing" assertion downstream. Guard against
+// that by asserting the extracted block ends with its expected closing token
+// AND still contains a known last field — so a mis-extraction throws loudly.
+function mustExtract(extracted, what, endToken, sentinel) {
+  const trimmed = extracted.trimEnd();
+  if (!trimmed.endsWith(endToken)) {
+    throw new Error(`mis-extracted ${what}: expected it to end with "${endToken}" ` +
+      `but got "...${trimmed.slice(-40)}" (a brace/bracket inside a string or ` +
+      `regex likely truncated the balanced-token scan)`);
+  }
+  if (!extracted.includes(sentinel)) {
+    throw new Error(`mis-extracted ${what}: expected it to contain "${sentinel}" ` +
+      `(extraction stopped early before the last field)`);
+  }
+  return extracted;
+}
+
 // sanitizePublicResult closes over _redactPublicError; provide a stub so the
 // extracted fn runs in isolation.
 const sandbox = {
   _redactPublicError: (v, max = 200) => (v == null ? null : String(v).slice(0, max)),
   console,
 };
 vm.createContext(sandbox);
-vm.runInContext(extractFn(src, 'sanitizePublicResult'), sandbox);
-vm.runInContext('var PUBLIC_STATE_KEYS = ' + extractArrayLiteral(src, 'PUBLIC_STATE_KEYS') + ';', sandbox);
+vm.runInContext(
+  mustExtract(extractFn(src, 'sanitizePublicResult'), 'sanitizePublicResult', '}', 'baselineAtTest'),
+  sandbox);
+vm.runInContext('var PUBLIC_STATE_KEYS = ' +
+  mustExtract(extractArrayLiteral(src, 'PUBLIC_STATE_KEYS'), 'PUBLIC_STATE_KEYS', ']', 'activeRunNumber') +
+  ';', sandbox);
 // sanitizeForPublic depends on sanitizePublicResult / sanitizePublicState /
 // _redactPublicError. We only exercise its top-level field forwarding here, so
 // provide a passthrough sanitizePublicState; sanitizePublicResult is real.
 vm.runInContext('var sanitizePublicState = (s) => s;', sandbox);
-vm.runInContext(extractFn(src, 'sanitizeForPublic'), sandbox);
+vm.runInContext(
+  mustExtract(extractFn(src, 'sanitizeForPublic'), 'sanitizeForPublic', '}', 'next_in_ms'),
+  sandbox);
 
 const KEPT_RESULT_FIELDS = [
   'address', 'moniker', 'serviceType', 'countryCode', 'city', 'actualMbps',
@@ -127,6 +152,23 @@ console.log('[1] sanitizePublicResult keeps consumed fields, drops 6 unused');
   }
 }
 
+// serviceType mapping is `r.type ?? r.serviceType` — exercise the fallback
+// branch (no type) and the `?? not ||` distinction (type: 0 is a real value).
+console.log('[1b] serviceType uses r.type ?? r.serviceType (fallback + nullish)');
+{
+  // (a) no `type` at all → falls back to r.serviceType.
+  sandbox._row = { address: 'sent1a', serviceType: 2 };
+  const safe = vm.runInContext('sanitizePublicResult(_row)', sandbox);
+  ok(safe.serviceType === 2, 'no type → falls back to r.serviceType (got ' + safe.serviceType + ')');
+}
+{
+  // (b) type: 0 is a valid service type — `??` keeps it; `||` would wrongly
+  // fall through to serviceType. Lock in `??` semantics.
+  sandbox._row = { address: 'sent1b', type: 0, serviceType: 2 };
+  const safe = vm.runInContext('sanitizePublicResult(_row)', sandbox);
+  ok(safe.serviceType === 0, 'type:0 is kept (?? not ||) (got ' + safe.serviceType + ')');
+}
+
 // ─── 2. PUBLIC_STATE_KEYS ─────────────────────────────────────────────────────
 console.log('[2] PUBLIC_STATE_KEYS is exactly the 10 consumed keys');
 {