From 542892f8e9370582f40a4e1528a7ff01bb004dd3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ralph=20K=C3=BCpper?= <ralph2@skelpo.com>
Date: Sat, 13 Jun 2026 23:17:51 +0200
Subject: [PATCH] test(node-suite): normalize env-variant tokens so console
 scores 119/119
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The console formatter already matches node v26 byte-for-byte on every
deterministic output across all 119 node-suite console tests. The 10
residual diffs were entirely environment-variant content that the
print-and-diff runner compared raw:

  - 9x console.time/timeEnd/timeLog: node's formatTime prints a live
    hrtime delta as the raw float `${ms}ms`, non-deterministic run-to-run
    (node itself prints 0.004ms / 0.004ms / 0.003ms across three runs).
  - 1x output/error-cause: stack-trace frames (absolute paths, line/col,
    node-internal ESM-loader frames Perry can't reproduce).

Masking ms / removing frame lines makes every one byte-identical, i.e.
they were never Perry defects — they're the timing/stack class the suite
docs already say to leave alone.

Fix the scorer, not the runtime: node_suite_run.normalize() scrubs the
two env-variant token classes symmetrically from both node and perry
stdout before the equality check (mirrors gen_feature_matrix.py already
stripping `(node:PID) Warning` noise):

  - durations: anchored on the `<label>: ` separator so only timer output
    is masked; the unit is kept so a dropped `ms`/wrong label still diffs.
  - stack frames: lines indented >=4 spaces starting with `at `/`N:` plus
    Perry's `(… N more identical frames)` elision; the >=4-space guard
    leaves ordinary 2-space-per-level inspect output untouched.

Ratchet the console floor 108 -> 119. Verified no other module drops
below its floor (assert/buffer/os/path/timers at full pass, util +1 from
the same error-cause stack normalization, all >= floor). No runtime code
changed, so the inspect engine is byte-identical to origin/main.
---
 scripts/node_suite_run.py            | 39 ++++++++++++++++++++++++++--
 test-parity/node_suite_baseline.json |  6 ++---
 2 files changed, 40 insertions(+), 5 deletions(-)

diff --git a/scripts/node_suite_run.py b/scripts/node_suite_run.py
index 92fd3c71e1..a95778c343 100755
--- a/scripts/node_suite_run.py
+++ b/scripts/node_suite_run.py
@@ -22,10 +22,45 @@
 
 Usage: node_suite_run.py <perry-bin> <repo-root> [comma-separated-modules]
 """
-import os, subprocess, sys, tempfile
+import os, re, subprocess, sys, tempfile
 from concurrent.futures import ThreadPoolExecutor
 from collections import defaultdict
 
+# Environment-variant tokens that defeat byte-for-byte stdout comparison without
+# indicating any Perry defect. Scrubbed SYMMETRICALLY from both node and perry
+# output before the equality check (see normalize()).
+#
+#   1. console.time/timeEnd/timeLog durations. Node's formatTime renders a live
+#      hrtime delta as the raw float `${ms}ms` (or `${s}s`, or `m:ss.mmm`), so the
+#      number is non-deterministic run-to-run AND has a variable decimal count —
+#      node itself prints e.g. 0.004ms / 0.004ms / 0.003ms, and 2.59ms / 2.68ms,
+#      across runs of the same program. The duration always follows the timer
+#      label as `<label>: <dur>`, so we anchor on `: ` (a lookbehind) and mask the
+#      numeric value while KEEPING the unit — a dropped `ms`, a wrong label, or a
+#      missing trailing arg still surfaces as a diff, and the `: ` anchor keeps
+#      ordinary numbers elsewhere in the output untouched.
+#   2. Stack-trace frames. console.trace, thrown-error inspection, and `[cause]`
+#      blocks print `    at <path>:<line>:<col>` plus node-internal ESM-loader
+#      frames Perry cannot reproduce (and Perry's own native-symbol /
+#      `(… N more identical frames)` placeholders). Paths and line numbers vary by
+#      machine, so whole frame lines are dropped. Frames are always indented >=4
+#      spaces, which keeps ordinary 2-space-per-level inspect output untouched.
+_DUR_MS = re.compile(r"(?<=: )\d+(?:\.\d+)?(ms|s)\b")
+_DUR_CLOCK = re.compile(r"\b\d+:\d{2}\.\d{3} \((h:mm|m):ss\.mmm\)")
+_FRAME = re.compile(r"^\s{4,}(at\s|\d+:\s)|… \d+ more identical frames")
+
+
+def normalize(text: str) -> str:
+    out = []
+    for line in text.split("\n"):
+        if _FRAME.search(line):
+            continue
+        line = _DUR_MS.sub(lambda m: "<dur>" + m.group(1), line)
+        line = _DUR_CLOCK.sub(lambda m: "<dur:" + m.group(1) + ">", line)
+        out.append(line)
+    return "\n".join(out)
+
+
 PERRY = sys.argv[1]
 ROOT = sys.argv[2]
 MODS = sys.argv[3].split(",") if len(sys.argv) > 3 and sys.argv[3] else None
@@ -72,7 +107,7 @@ def run_one(args):
     # Match stdout byte-for-byte (ignore only trailing-newline noise, not leading
     # whitespace) AND exit code — so a Perry crash that happened to print matching
     # output before dying is a diff, not a false pass.
-    ok = (n.stdout.rstrip("\n") == p.stdout.rstrip("\n")) and (n.returncode == p.returncode)
+    ok = (normalize(n.stdout.rstrip("\n")) == normalize(p.stdout.rstrip("\n"))) and (n.returncode == p.returncode)
     return (mod, "pass" if ok else "diff")
 
 
diff --git a/test-parity/node_suite_baseline.json b/test-parity/node_suite_baseline.json
index 7efc2971fd..79dc7291d1 100644
--- a/test-parity/node_suite_baseline.json
+++ b/test-parity/node_suite_baseline.json
@@ -2,9 +2,9 @@
   "_schema": {
     "description": "Floor baseline for scripts/node_suite_regression_check.py. Each module's run must produce pass >= floor.pass; dropping below is a regression (exit 1). Improvements are always accepted and reported as ratchet candidates. Captured in the node-26 environment with scripts/node_suite_run.py (pre-warm + fast/slow lanes).",
     "oracle": "node v26.3.0 on Linux (the box)",
-    "note": "Deterministic modules are floored at full pass. Timing/racy modules (http2, net, stream, diagnostics_channel, fs-promises) carry a small margin below observed pass so ordinary flake does not false-alarm; the guard still catches real regressions, which are large (e.g. dns 6->0, http 19->9)."
+    "note": "Deterministic modules are floored at full pass. Timing/racy modules (http2, net, stream, diagnostics_channel, fs-promises) carry a small margin below observed pass so ordinary flake does not false-alarm; the guard still catches real regressions, which are large (e.g. dns 6->0, http 19->9). node_suite_run.normalize() scrubs environment-variant tokens (console.time hrtime durations, stack-trace frame lines) symmetrically before the stdout compare, so console is floored at full pass (119) on its deterministic content."
   },
-  "overall": { "pass": 2781, "total": 2863, "pct": 97.1 },
+  "overall": { "pass": 2792, "total": 2863, "pct": 97.5 },
   "modules": {
     "assert": { "pass": 70, "total": 70 },
     "async_hooks": { "pass": 5, "total": 5 },
@@ -12,7 +12,7 @@
     "buffer": { "pass": 134, "total": 134 },
     "child_process": { "pass": 26, "total": 26 },
     "cluster": { "pass": 1, "total": 1 },
-    "console": { "pass": 108, "total": 119 },
+    "console": { "pass": 119, "total": 119 },
     "constants": { "pass": 4, "total": 4 },
     "crypto": { "pass": 240, "total": 242 },
     "dgram": { "pass": 4, "total": 4 },