From c2f718ee502eac0c0414059df98f21a852b66eaf Mon Sep 17 00:00:00 2001
From: AlexZ005 <alexz005.info@gmail.com>
Date: Sat, 24 Oct 2026 17:13:20 +0300
Subject: [PATCH 01/46] [test] test-health-1 P0: budget targets follow the
 Quest/phone research
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- perf/budgets.json targets reconciled with cloud plans/core/pending/research/quest-phone-perf.md §1:
  phone calls 300 -> 150 and shadow draws 300 -> 150 (the MID phone row, 100-150 [3P]);
  desktop texture memory 512 -> 1024 MB (1-2 GB [U]). The comment records the source.
- Quest unchanged: 150 calls is inside <200 [M] / 100-150 [3P]; its 300k triangles / 64 MB are
  stricter than the research's [U] web estimates (QUESTIONS Q1). Low-phone row = follow-up (Q2).
- validateBudgets clean; vitest perfBudget + budgetMeterCore 44/0; svelte-check unchanged (298/39).

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 perf/budgets.json | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/perf/budgets.json b/perf/budgets.json
index ef7734fc2..737962320 100644
--- a/perf/budgets.json
+++ b/perf/budgets.json
@@ -16,10 +16,10 @@
 		"textureMB": 64
 	},
 	"targets": {
-		"comment": "46 B1/B2 — the editor's budget chip and Statistics ▸ Budget judge a scene against ONE of these (picked in the chip's menu, LOCAL). Quest's four gated metrics are `defaults` above and are NOT repeated here (perfBudget.cjs refuses a copy, so the chip and the gate cannot disagree); the gate never reads this block. shadowLights / shadowCasters are meter-only rows; shadowCasters counts shadow DRAWS (casters x shadow lights) and is held to the draw-call budget, since every one is a call. Phone and desktop are starting values, not gated: phone = sceneBudget's measured VR/mobile green ceilings, desktop = 26-E's measured desktop green ceilings (owed on device).",
+		"comment": "46 B1/B2 — the editor's budget chip and Statistics ▸ Budget judge a scene against ONE of these (picked in the chip's menu, LOCAL). Quest's four gated metrics are `defaults` above and are NOT repeated here (perfBudget.cjs refuses a copy, so the chip and the gate cannot disagree); the gate never reads this block. shadowLights / shadowCasters are meter-only rows; shadowCasters counts shadow DRAWS (casters x shadow lights) and is held to the draw-call budget, since every one is a call. Phone and desktop are starting values, not gated: phone = sceneBudget's measured VR/mobile green ceilings, desktop = 26-E's measured desktop green ceilings (owed on device) test-health-1 (2026-10-24) reconciled them with cloud plans/core/pending/research/quest-phone-perf.md §1: phone = its MID phone row (calls 100-150 [3P] -> 150, shadow draws held to that; 500k triangles, 256 MB, one shadow map already inside it), desktop texture memory 512 -> 1024 MB (its 1-2 GB [U]). Quest is unchanged: 150 calls is inside <200 [M] / 100-150 [3P], and its triangles / texture MB are STRICTER than the research's [U] web estimates (500-750k, <=512 MB), which say measure on device.",
 		"quest": { "label": "Quest / VR", "short": "Quest", "shadowLights": 1, "shadowCasters": 150 },
-		"phone": { "label": "Phone", "short": "Phone", "calls": 300, "triangles": 500000, "lights": 3, "textureMB": 256, "shadowLights": 1, "shadowCasters": 300 },
-		"desktop": { "label": "Desktop", "short": "Desktop", "calls": 2000, "triangles": 4000000, "lights": 8, "textureMB": 512, "shadowLights": 4, "shadowCasters": 2000 }
+		"phone": { "label": "Phone", "short": "Phone", "calls": 150, "triangles": 500000, "lights": 3, "textureMB": 256, "shadowLights": 1, "shadowCasters": 150 },
+		"desktop": { "label": "Desktop", "short": "Desktop", "calls": 2000, "triangles": 4000000, "lights": 8, "textureMB": 1024, "shadowLights": 4, "shadowCasters": 2000 }
 	},
 	"games": {},
 	"levels": {},

From 607b3fecb4b90ce4fdb9d69c9fb851283ce13fcf Mon Sep 17 00:00:00 2001
From: AlexZ005 <alexz005.info@gmail.com>
Date: Sat, 24 Oct 2026 17:22:58 +0300
Subject: [PATCH 02/46] [test] test-health-1 P1: e2e quarantine manifest + the
 battery's non-blocking tier
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- tests/e2e/quarantine.json: suite + optional check (substring of its FAIL label) + reason / owner /
  since / review — perf/budgets.json "allow" for e2e. Seeded with 25 check-level flakes (lock-ux,
  ui-fixes-15lmno x3, checkpoints x3, scene-load L3 1.4/6.3/4.4, net-handshake, flow-physics-actions x4,
  select-41 G4, avatar-feet, aquarium-reef x2, knock-physics, pack-behavior, code-workspace,
  animation-node, dock-strip-drop, toolbar-slots-42; sources in each reason: 50-int, deps-1,
  mux-pc-host, 53/57/59/65 STATUS) + the 30 whole-suite carried reds moved from battery.json "optional"
  (phase 2 removes them one by one). Every label was checked against today's suite text.
- scripts/ci/quarantine.cjs: validate / classify / warnings / triage. Non-blocking only when EVERY
  failed check of the run matches an entry for that suite; a crash or timeout never matches a check.
- scripts/ci/battery.cjs: `optional` gone; a red-twice suite the quarantine covers = `quarantined`
  (own tier in the step summary, not a red); report lists past-review / now-green entries.
- tests/unit/quarantine.test.js 10/0 (counterfactuals: a new red beside a quarantined row gates; a crash
  gates; another suite's identical label gates). depsCi 7/0. svelte-check 298/39 (= base).

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 scripts/ci/battery.cjs        |  53 +++++++----
 scripts/ci/quarantine.cjs     | 173 ++++++++++++++++++++++++++++++++++
 tests/e2e/README.md           |  16 ++++
 tests/e2e/battery.json        |  36 +------
 tests/e2e/quarantine.json     |  60 ++++++++++++
 tests/unit/quarantine.test.js |  73 ++++++++++++++
 6 files changed, 359 insertions(+), 52 deletions(-)
 create mode 100644 scripts/ci/quarantine.cjs
 create mode 100644 tests/e2e/quarantine.json
 create mode 100644 tests/unit/quarantine.test.js

diff --git a/scripts/ci/battery.cjs b/scripts/ci/battery.cjs
index f994cf223..f4c6d6c77 100755
--- a/scripts/ci/battery.cjs
+++ b/scripts/ci/battery.cjs
@@ -4,9 +4,10 @@
 // The battery is the list an integrator runs before a release: tests/e2e/battery.json holds it
 // (suite → seconds measured on a GitHub runner, or twice the desk time until one has run), the
 // suites a public runner must skip (`skip`: they need the self-hosted signaling box, a hosts-file
-// origin or a built app) and the ones that run but do not gate (`optional`: red or flaky on
-// SwiftShader with the same red on the unchanged base — the reason is on the line). Nothing here
-// names a suite; the list is data, refreshed from the integrators' battery runs (`refresh`).
+// origin or a built app). What runs but does not gate is tests/e2e/quarantine.json (test-health-1:
+// it replaced battery.json's suite-wide `optional` map) — per CHECK, with an owner and a review date,
+// read through scripts/ci/quarantine.cjs. Nothing here names a suite; the list is data, refreshed from
+// the integrators' battery runs (`refresh`).
 //
 //   node scripts/ci/battery.cjs plan                      # matrix JSON for GITHUB_OUTPUT
 //   node scripts/ci/battery.cjs run --shard 3 --of 14     # run one shard (serves the app itself)
@@ -15,20 +16,22 @@
 //
 // Sharding is longest-first onto the least-loaded shard, by name on ties: every shard computes the
 // same assignment from the same file, so the plan job only has to say how many shards there are.
-// A failed suite runs once more; green on the retry = `flaky` (reported, not a red).
+// A failed suite runs once more; green on the retry = `flaky` (reported, not a red). Red twice and
+// every failed check quarantined = `quarantined` (reported in its own tier, not a red).
 
 const fs = require('fs');
 const path = require('path');
 const { spawn, spawnSync } = require('child_process');
+const quarantine = require('./quarantine.cjs');
 
 const ROOT = path.resolve(__dirname, '..', '..');
 const BATTERY = path.join(ROOT, 'tests', 'e2e', 'battery.json');
 
 /**
  * @typedef {{ comment?: string, refs: Record<string, {repo: string, ref: string}>, shards: {target_minutes: number, max: number, min: number},
- *   pc?: {games: string[], levels: string[]}, skip: Record<string, string>, optional: Record<string, string>, setup: Record<string, string>,
+ *   pc?: {games: string[], levels: string[]}, skip: Record<string, string>, setup: Record<string, string>,
  *   suites: Record<string, number> }} Battery
- * @typedef {{ name: string, status: 'pass'|'flaky'|'fail'|'timeout'|'gone', required: boolean, rc: number|null, secs: number,
+ * @typedef {{ name: string, status: 'pass'|'flaky'|'quarantined'|'fail'|'timeout'|'gone', required: boolean, rc: number|null, secs: number,
  *   retrySecs?: number, pass: number, fail: number, last: string, shard: number }} SuiteResult
  */
 
@@ -166,7 +169,7 @@ function runSuite(name, est, out, tag) {
 			fs.closeSync(log);
 			const text = fs.readFileSync(logFile, 'utf8');
 			if (timedOut) fs.appendFileSync(logFile, `\n[battery] TIMEOUT after ${timeout / 1000}s\n`);
-			resolve({ rc: timedOut ? null : code, secs: Math.round((Date.now() - t0) / 1000), timedOut, ...counts(text) });
+			resolve({ rc: timedOut ? null : code, secs: Math.round((Date.now() - t0) / 1000), timedOut, text, ...counts(text) });
 		});
 	});
 }
@@ -174,6 +177,12 @@ function runSuite(name, est, out, tag) {
 /** @param {string[]} argv */
 async function run(argv) {
 	const b = load();
+	const q = quarantine.load();
+	const qErrors = quarantine.validate(q);
+	if (qErrors.length) {
+		for (const e of qErrors) console.error('quarantine.json: ' + e);
+		process.exit(2);
+	}
 	const of = Number(opt(argv, '--of') || shardCount(b));
 	const shard = Number(opt(argv, '--shard') || 1);
 	const out = path.resolve(opt(argv, '--out') || process.env.BATTERY_OUT || path.join(ROOT, '..', 'battery-out'));
@@ -187,7 +196,7 @@ async function run(argv) {
 	const results = [];
 	console.log(`shard ${shard}/${of}: ${mine.length} suites, est ${Math.round(mine.reduce((t, s) => t + (b.suites[s] || 60), 0) / 60)} min`);
 	for (const name of mine) {
-		const required = !(name in b.optional);
+		const required = true;
 		if (!fs.existsSync(path.join(ROOT, 'tests', 'e2e', name + '.test.cjs'))) {
 			results.push({ name, status: 'gone', required: false, rc: null, secs: 0, pass: 0, fail: 0, last: 'no such suite (refresh battery.json)', shard });
 			continue;
@@ -214,10 +223,19 @@ async function run(argv) {
 			if (again.rc === 0) status = 'flaky';
 			else r = again;
 		}
-		const res = { name, status, required, rc: r.rc, secs: r.secs, retrySecs, pass: r.pass, fail: r.fail, last: r.last, shard };
+		/** @type {string[]} */
+		let quarantinedChecks = [];
+		if (status === 'fail' || status === 'timeout') {
+			const v = quarantine.classify(q, name, r.text, { timedOut: r.timedOut });
+			if (v.quarantined) {
+				status = 'quarantined';
+				quarantinedChecks = v.whole ? ['(whole suite)'] : v.failed;
+			}
+		}
+		const res = { name, status, required, rc: r.rc, secs: r.secs, retrySecs, pass: r.pass, fail: r.fail, last: quarantinedChecks.length ? 'quarantined: ' + quarantinedChecks.join(' | ').slice(0, 140) : r.last, shard };
 		results.push(res);
-		if (status === 'pass' || status === 'flaky') fs.rmSync(path.join(out, 'evidence', name), { recursive: true, force: true });
-		console.log(`${name} ${status}${required ? '' : ' (optional)'} rc=${r.rc} pass~${r.pass} fail~${r.fail} ${r.secs}s${retrySecs ? ` retry ${retrySecs}s` : ''} :: ${r.last}`);
+		if (status === 'pass' || status === 'flaky' || status === 'quarantined') fs.rmSync(path.join(out, 'evidence', name), { recursive: true, force: true });
+		console.log(`${name} ${status} rc=${r.rc} pass~${r.pass} fail~${r.fail} ${r.secs}s${retrySecs ? ` retry ${retrySecs}s` : ''} :: ${r.last}`);
 	}
 	stop(server);
 	fs.writeFileSync(path.join(out, `results-${shard}.json`), JSON.stringify({ shard, of, results }, null, 1));
@@ -232,14 +250,14 @@ async function run(argv) {
 function table(results, title) {
 	const red = results.filter((r) => r.status === 'fail' || r.status === 'timeout');
 	const req = red.filter((r) => r.required);
-	const opt = red.filter((r) => !r.required);
+	const quar = results.filter((r) => r.status === 'quarantined');
 	const flaky = results.filter((r) => r.status === 'flaky');
 	const secs = results.reduce((t, r) => t + r.secs + (r.retrySecs || 0), 0);
 	const row = (/** @type {SuiteResult} */ r) => `| ${r.name} | ${r.status} | ${r.shard} | ${r.pass}/${r.fail} | ${r.secs}s | ${r.last.replace(/\|/g, '\\|')} |`;
 	const head = '| suite | status | shard | ✓/✗ | time | last line |\n|---|---|---|---|---|---|\n';
-	let md = `### ${title}: ${results.length} suites, ${req.length} required red, ${opt.length} optional red, ${flaky.length} flaky (${Math.round(secs / 60)} suite-min)\n\n`;
+	let md = `### ${title}: ${results.length} suites, ${req.length} required red, ${quar.length} quarantined, ${flaky.length} flaky (${Math.round(secs / 60)} suite-min)\n\n`;
 	if (req.length) md += `**Required reds**\n\n${head}${req.map(row).join('\n')}\n\n`;
-	if (opt.length) md += `<details><summary>Optional reds (do not gate)</summary>\n\n${head}${opt.map(row).join('\n')}\n\n</details>\n\n`;
+	if (quar.length) md += `<details><summary>Quarantined reds (tests/e2e/quarantine.json — do not gate)</summary>\n\n${head}${quar.map(row).join('\n')}\n\n</details>\n\n`;
 	if (flaky.length) md += `<details><summary>Flaky (green on the retry)</summary>\n\n${head}${flaky.map(row).join('\n')}\n\n</details>\n\n`;
 	const gone = results.filter((r) => r.status === 'gone');
 	if (gone.length) md += `Listed but gone (refresh tests/e2e/battery.json): ${gone.map((r) => r.name).join(', ')}\n\n`;
@@ -262,6 +280,8 @@ function report(argv) {
 	const b = load();
 	const missing = Array.from({ length: of || shardCount(b) }, (_, i) => i + 1).filter((s) => !seen.has(s));
 	let md = table(all, 'e2e battery');
+	const qWarn = quarantine.warnings(quarantine.load(), all, Object.keys(b.suites));
+	if (qWarn.length) md += `<details><summary>Quarantine to review (${qWarn.length})</summary>\n\n${qWarn.map((w) => '- ' + w).join('\n')}\n\n</details>\n\n`;
 	if (missing.length) md += `**Shards with no results (crashed or cancelled): ${missing.join(', ')}**\n`;
 	if (process.env.GITHUB_STEP_SUMMARY) fs.appendFileSync(process.env.GITHUB_STEP_SUMMARY, md);
 	else console.log(md);
@@ -296,7 +316,6 @@ function write(b) {
 		`\t"shards": ${JSON.stringify(b.shards)}`,
 		`\t"pc": ${JSON.stringify(b.pc || { games: [], levels: [] })}`,
 		`\t"skip": ${obj(b.skip, '\t')}`,
-		`\t"optional": ${obj(b.optional, '\t')}`,
 		`\t"setup": ${obj(b.setup, '\t')}`,
 		`\t"suites": ${obj(b.suites, '\t')}`
 	];
@@ -329,9 +348,9 @@ function refresh(argv) {
 			for (const [n, s] of Object.entries(JSON.parse(fs.readFileSync(f, 'utf8')))) if (n in b.suites) b.suites[n] = Number(s);
 		}
 	}
-	for (const k of Object.keys(b.optional)) if (!(k in b.suites)) delete b.optional[k];
 	write(b);
-	console.log(`battery.json: ${Object.keys(b.suites).length} suites, ${Object.keys(b.skip).length} skipped, ${Object.keys(b.optional).length} optional, ${shardCount(b)} shards`);
+	console.log(`battery.json: ${Object.keys(b.suites).length} suites, ${Object.keys(b.skip).length} skipped, ${shardCount(b)} shards`);
+	for (const w of quarantine.warnings(quarantine.load(), [], Object.keys(b.suites))) console.log('warning: ' + w);
 }
 
 // ---------------------------------------------------------------- plan
diff --git a/scripts/ci/quarantine.cjs b/scripts/ci/quarantine.cjs
new file mode 100644
index 000000000..2f79f0333
--- /dev/null
+++ b/scripts/ci/quarantine.cjs
@@ -0,0 +1,173 @@
+#!/usr/bin/env node
+// test-health-1 — THE QUARANTINE: known flaky or known-red e2e checks, by name, with an owner and a date.
+//
+// The battery (scripts/ci/battery.cjs, and the integrators' battery.sh through `triage`) gates on every
+// red EXCEPT one listed in tests/e2e/quarantine.json. It is perf/budgets.json's `allow` list one domain
+// over: an entry records a known debt, it is not a place to put a red you have not read. Every entry
+// names the suite, optionally ONE check (a substring of its `FAIL <label>` line — the label text a suite
+// passes to h.check), why it is there, who owns the fix, when it went in and when to look again.
+//
+// THE NON-BLOCKING TIER IS PER CHECK. A suite red counts as quarantined only when EVERY failed check of
+// its run matches an entry for that suite (or the suite has a whole-suite entry, `check` absent) — so a
+// quarantined timing row cannot hide a new red in the same suite. A suite that crashed (`SCRIPT FAILED`,
+// no FAIL line, no summary line) or timed out is never covered by a check entry: nothing says the
+// quarantined row is what stopped it.
+//
+// Dates warn, they never fail (the allow-list rule: a date must not turn an unrelated PR red). An entry
+// whose review date passed, or whose suite ran fully green, is printed as a warning to act on.
+//
+//   node scripts/ci/quarantine.cjs check                       # validate the file
+//   node scripts/ci/quarantine.cjs triage <summary.txt> [<logdir>]  # split a battery.sh summary's reds
+//   node scripts/ci/quarantine.cjs list                        # what is quarantined, by review date
+
+const fs = require('fs');
+const path = require('path');
+
+const ROOT = path.resolve(__dirname, '..', '..');
+const QUARANTINE = path.join(ROOT, 'tests', 'e2e', 'quarantine.json');
+const REQUIRED = ['suite', 'reason', 'owner', 'since', 'review'];
+const KEYS = [...REQUIRED, 'check'];
+const DATE = /^\d{4}-\d{2}-\d{2}$/;
+
+/**
+ * @typedef {{ suite: string, check?: string, reason: string, owner: string, since: string, review: string }} Entry
+ * @typedef {{ comment?: string, quarantine: Entry[] }} Quarantine
+ * @typedef {{ quarantined: boolean, whole: boolean, failed: string[], unmatched: string[], entries: Entry[] }} Verdict
+ */
+
+/** @returns {Quarantine} */
+function load(file = QUARANTINE) {
+	if (!fs.existsSync(file)) return { quarantine: [] };
+	return JSON.parse(fs.readFileSync(file, 'utf8'));
+}
+
+/** @param {any} q @returns {string[]} */
+function validate(q) {
+	/** @type {string[]} */
+	const errors = [];
+	if (!q || !Array.isArray(q.quarantine)) return ['quarantine must be an array'];
+	const seen = new Set();
+	q.quarantine.forEach((/** @type {any} */ e, /** @type {number} */ i) => {
+		const at = `quarantine[${i}]${e?.suite ? ' (' + e.suite + ')' : ''}`;
+		for (const k of REQUIRED) if (typeof e?.[k] !== 'string' || !e[k].trim()) errors.push(`${at}.${k} is required`);
+		for (const k of Object.keys(e ?? {})) if (!KEYS.includes(k)) errors.push(`${at}: unknown key ${k}`);
+		if ('check' in (e ?? {}) && (typeof e.check !== 'string' || !e.check.trim())) errors.push(`${at}.check must be a non-empty string (omit it for the whole suite)`);
+		for (const k of ['since', 'review']) if (e?.[k] && !DATE.test(e[k])) errors.push(`${at}.${k} must be YYYY-MM-DD`);
+		if (e?.since && e?.review && e.review <= e.since) errors.push(`${at}: review must be after since`);
+		const key = `${e?.suite}\u0000${e?.check ?? '*'}`;
+		if (seen.has(key)) errors.push(`${at}: duplicate entry`);
+		seen.add(key);
+	});
+	return errors;
+}
+
+/** the labels of the FAIL lines a suite printed (helpers.check) @param {string} log */
+function failedChecks(log) {
+	return log
+		.split('\n')
+		.map((l) => /^\s*(?:✗|FAIL|not ok)\s+(.*)$/.exec(l))
+		.filter((m) => m !== null)
+		.map((m) => /** @type {RegExpExecArray} */ (m)[1].trim());
+}
+
+/** did the suite reach helpers.finish (its own verdict line) rather than crash @param {string} log */
+function finished(log) {
+	return /^(ALL PASS|\d+ FAILURES)\s*$/m.test(log) && !/^SCRIPT FAILED/m.test(log);
+}
+
+/**
+ * Is this red non-blocking? @param {Quarantine} q @param {string} suite @param {string} log
+ * @param {{timedOut?: boolean}} [opts] @returns {Verdict}
+ */
+function classify(q, suite, log, opts = {}) {
+	const mine = (q.quarantine ?? []).filter((e) => e.suite === suite);
+	const whole = mine.find((e) => !e.check);
+	const failed = failedChecks(log);
+	if (whole) return { quarantined: true, whole: true, failed, unmatched: [], entries: [whole] };
+	const used = new Set();
+	const unmatched = failed.filter((label) => {
+		const hit = mine.find((e) => e.check && label.includes(e.check));
+		if (hit) used.add(hit);
+		return !hit;
+	});
+	const covered = !opts.timedOut && finished(log) && failed.length > 0 && unmatched.length === 0;
+	return { quarantined: covered, whole: false, failed, unmatched, entries: [...used] };
+}
+
+/**
+ * What to act on: past review dates, entries that saw their suite (or their check) green, and entries
+ * for suites the battery no longer has. @param {Quarantine} q
+ * @param {{name: string, status: string, log?: string}[]} results @param {string[]} [known] suite names
+ * @param {string} [today] YYYY-MM-DD
+ */
+function warnings(q, results = [], known, today = new Date().toISOString().slice(0, 10)) {
+	/** @type {string[]} */
+	const out = [];
+	const byName = new Map(results.map((r) => [r.name, r]));
+	for (const e of q.quarantine ?? []) {
+		const tag = `${e.suite}${e.check ? ' "' + e.check + '"' : ''}`;
+		if (e.review < today) out.push(`quarantine ${tag}: review date ${e.review} has passed (owner ${e.owner}) — fix it, delete the check, or re-date the entry`);
+		const r = byName.get(e.suite);
+		if (r && r.status === 'pass') out.push(`quarantine ${tag}: the suite ran green — remove the entry once it holds`);
+		else if (r && e.check && r.log != null && !failedChecks(r.log).some((l) => l.includes(/** @type {string} */ (e.check)))) out.push(`quarantine ${tag}: that check did not fail this run`);
+		if (known && !known.includes(e.suite)) out.push(`quarantine ${tag}: no such suite in the battery — stale entry`);
+	}
+	return out;
+}
+
+/**
+ * Split an integrator battery.sh summary (`<suite> rc=<n> pass~ fail~ <s>s :: <last line>`) into the
+ * reds that gate and the ones the quarantine covers. Reads <logdir>/<suite>.log for the check names.
+ * @param {string} summaryFile @param {string} [logDir]
+ */
+function triage(summaryFile, logDir = path.dirname(summaryFile)) {
+	const q = load();
+	/** @type {{name: string, rc: string, v: Verdict}[]} */
+	const blocking = [];
+	/** @type {{name: string, rc: string, v: Verdict}[]} */
+	const quarantined = [];
+	/** @type {{name: string, status: string, log?: string}[]} */
+	const results = [];
+	for (const line of fs.readFileSync(summaryFile, 'utf8').split('\n')) {
+		const m = /^(\S+) rc=(\S+) /.exec(line);
+		if (!m || m[1].startsWith('MOD:')) continue;
+		const [, name, rc] = m;
+		const logFile = path.join(logDir, name + '.log');
+		const log = fs.existsSync(logFile) ? fs.readFileSync(logFile, 'utf8') : '';
+		results.push({ name, status: rc === '0' ? 'pass' : 'fail', log });
+		if (rc === '0') continue;
+		const v = classify(q, name, log, { timedOut: rc === '124' });
+		(v.quarantined ? quarantined : blocking).push({ name, rc, v });
+	}
+	return { blocking, quarantined, warnings: warnings(q, results) };
+}
+
+if (require.main === module) {
+	const [cmd, ...argv] = process.argv.slice(2);
+	const q = load();
+	const errors = validate(q);
+	if (cmd === 'check' || !cmd) {
+		for (const e of errors) console.error('quarantine.json: ' + e);
+		for (const w of warnings(q)) console.log('warning: ' + w);
+		console.log(errors.length ? `${errors.length} errors` : `quarantine.json: ${q.quarantine.length} entries OK`);
+		process.exit(errors.length ? 1 : 0);
+	} else if (cmd === 'list') {
+		for (const e of [...q.quarantine].sort((a, b) => (a.review < b.review ? -1 : 1))) console.log(`${e.review}  ${e.suite}${e.check ? ' :: ' + e.check : ' (whole suite)'}  — ${e.owner}`);
+	} else if (cmd === 'triage' && argv[0]) {
+		if (errors.length) {
+			for (const e of errors) console.error('quarantine.json: ' + e);
+			process.exit(2);
+		}
+		const t = triage(argv[0], argv[1]);
+		for (const b of t.blocking) console.log(`RED  ${b.name} rc=${b.rc}${b.v.unmatched.length ? ' :: ' + b.v.unmatched.slice(0, 3).join(' | ') : ''}`);
+		for (const b of t.quarantined) console.log(`QUAR ${b.name} :: ${b.v.whole ? 'whole suite' : b.v.failed.join(' | ')}`);
+		for (const w of t.warnings) console.log('warning: ' + w);
+		console.log(`${t.blocking.length} blocking red, ${t.quarantined.length} quarantined`);
+		process.exit(t.blocking.length ? 1 : 0);
+	} else {
+		console.error('usage: quarantine.cjs check | list | triage <summary.txt> [<logdir>]');
+		process.exit(2);
+	}
+}
+
+module.exports = { QUARANTINE, load, validate, failedChecks, finished, classify, warnings, triage };
diff --git a/tests/e2e/README.md b/tests/e2e/README.md
index 5b326e66d..afb154aa3 100644
--- a/tests/e2e/README.md
+++ b/tests/e2e/README.md
@@ -80,3 +80,19 @@ light and custom (`fixtures/lock/lock-custom.theme.json`) themes, named
 
 All lock suites launch on the GPU backend (`lockHelpers.launch`): on SwiftShader the 3D view
 behind the panels starves the page (a CDP round trip measured 271 ms vs 2 ms).
+
+## Quarantine (test-health-1)
+
+`tests/e2e/quarantine.json` lists the checks that run but do not gate: a known flake or a known red,
+each with the suite, optionally ONE check (a substring of its `FAIL <label>` line), the reason, an
+owner, `since` and a `review` date — the `allow` list of `perf/budgets.json`, for e2e. It replaced
+battery.json's suite-wide `optional` map.
+
+- The CI battery (`scripts/ci/battery.cjs`) reports a red that is red twice and whose EVERY failed check
+  is quarantined as `quarantined`, in its own tier; it does not fail the run. A crash or a timeout is
+  never covered by a check entry (only by a whole-suite entry, `check` absent).
+- An integrator's `battery.sh` summary: `node scripts/ci/quarantine.cjs triage <summary.txt> [<logdir>]`
+  prints `RED` (gates) / `QUAR` (does not) per suite and exits 1 on a blocking red.
+- `node scripts/ci/quarantine.cjs check` validates the file; `list` prints it by review date. A past
+  review date or an entry whose suite ran green is a WARNING — fix the check, delete it with a reason,
+  or re-date the entry. Remove an entry in the PR that fixes it.
diff --git a/tests/e2e/battery.json b/tests/e2e/battery.json
index 5d5d97255..c28e0cbeb 100644
--- a/tests/e2e/battery.json
+++ b/tests/e2e/battery.json
@@ -1,5 +1,5 @@
 {
-	"comment": "deps-auto: the e2e battery deps.yml runs in shards on GitHub-hosted runners (scripts/ci/battery.cjs). suites = name -> seconds on a runner (2x the desk time until a runner has measured it); skip = cannot run on a public runner (the reason); optional = runs and reports, does not gate (the reason); setup = extra install a suite needs. Refresh after an integrator battery: node scripts/ci/battery.cjs refresh --list <listA> --list <listB> --summary <summary.txt>... (RELEASING.md, Dependency updates). pc = the games (fps) and levels (shots) scripts/ci/pc-battery.sh measures on a desktop GPU.",
+	"comment": "deps-auto: the e2e battery deps.yml runs in shards on GitHub-hosted runners (scripts/ci/battery.cjs). suites = name -> seconds on a runner (2x the desk time until a runner has measured it); skip = cannot run on a public runner (the reason); what runs but does not gate is tests/e2e/quarantine.json (per check, owner + review date; test-health-1 replaced the old `optional` map); setup = extra install a suite needs. Refresh after an integrator battery: node scripts/ci/battery.cjs refresh --list <listA> --list <listB> --summary <summary.txt>... (RELEASING.md, Dependency updates). pc = the games (fps) and levels (shots) scripts/ci/pc-battery.sh measures on a desktop GPU.",
 	"refs": {
 		"modules": {"repo":"theprototype-app/modules","ref":"80fca17f7cd963cf698d6b5f29beaff14f28f9e1"},
 		"packs": {"repo":"theprototype-app/packs","ref":"360f31686652f0f9c7e240ff09785c6b6c60d678"},
@@ -15,40 +15,6 @@
 		"perf-beacon": "reads a hosts-mapped preview origin",
 		"timeline-export": "needs the built app (scripts/serve-build.cjs), not the dev server"
 	},
-	"optional": {
-		"animation-sync": "red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23)",
-		"behaviours": "red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23)",
-		"char-controller": "red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23)",
-		"collider-live": "red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23)",
-		"context-menu-redesign": "red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23)",
-		"edit-move-games": "red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23)",
-		"fb-water": "red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23)",
-		"flow-physics-actions": "flaky on every app/driver pair (deps-1 ab3, 2026-10-23)",
-		"flow-physics-nodes": "red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23)",
-		"game-loop-v4": "red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23)",
-		"game-sky-run": "red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23)",
-		"kit-instancing": "red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23)",
-		"lock-search": "red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23)",
-		"mesh-toolbox-redesign": "red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23)",
-		"model-preview": "red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23)",
-		"net-stress": "red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23)",
-		"panels": "red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23)",
-		"phone-sheets": "red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23)",
-		"physics-discoverability": "red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23)",
-		"physics-kinematic": "red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23)",
-		"scene-budget": "red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23)",
-		"scene-post": "red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23)",
-		"scene-post-effects": "red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23)",
-		"search-menus": "red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23)",
-		"select-41": "G4 flick timing flake (deps-1 ab3: 12/12 green on --local, red under load)",
-		"settings-layout": "red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23)",
-		"shader-sync": "red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23)",
-		"sound-node": "red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23)",
-		"themes": "red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23)",
-		"timeline-export": "red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23)",
-		"touch-actions": "red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23)",
-		"water-migration": "red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23)"
-	},
 	"setup": {
 		"agent-bridge": "agent"
 	},
diff --git a/tests/e2e/quarantine.json b/tests/e2e/quarantine.json
new file mode 100644
index 000000000..c468d07c3
--- /dev/null
+++ b/tests/e2e/quarantine.json
@@ -0,0 +1,60 @@
+{
+	"comment": "test-health-1 — e2e checks that run but do not gate (scripts/ci/quarantine.cjs; the battery reports them in their own tier). perf/budgets.json \"allow\" one domain over: suite + optionally ONE check (a substring of its FAIL label; absent = the whole suite), why, who owns the fix, since, review. A suite red is non-blocking only when EVERY failed check matches an entry (a crash or timeout never is, unless the whole suite is listed). Past-review and now-green entries print as warnings. Remove an entry in the PR that fixes it.",
+	"quarantine": [
+		{"suite": "lock-ux", "check": "B renders a lock highlight box", "reason": "load-sensitive: the Approve toast click is intercepted by the canvas and the toast detaches; green in a quiet slot (75 s vs 131-136 s red), red on v1.42.0 in the same place (57-union, 65-union)", "owner": "test-health (standing lane)", "since": "2026-10-24", "review": "2026-11-07"},
+		{"suite": "ui-fixes-15lmno", "check": "incoming toasts never shift it", "reason": "the toast burst moves the spectator 8 px under load (a fixed sleep); a different row red each run, pristine v1.41.0 3/3 red (50-int r4)", "owner": "test-health (standing lane)", "since": "2026-10-23", "review": "2026-11-07"},
+		{"suite": "ui-fixes-15lmno", "check": "the Roughness readout shows the material", "reason": "read before the Inspector re-renders under load (fixed sleep); red on pristine v1.41.0 (50-int r4)", "owner": "test-health (standing lane)", "since": "2026-10-23", "review": "2026-11-07"},
+		{"suite": "ui-fixes-15lmno", "check": "it hides after the grace period", "reason": "fixed-sleep grace window vs load (50-int r3)", "owner": "test-health (standing lane)", "since": "2026-10-23", "review": "2026-11-07"},
+		{"suite": "checkpoints", "check": "after Accept the peer has the checkpoint", "reason": "two-peer timing; red on the union AND pristine v1.41.0, green in r4 (50-int, 50-window)", "owner": "test-health (standing lane)", "since": "2026-10-23", "review": "2026-11-07"},
+		{"suite": "checkpoints", "check": "and so does the host", "reason": "flips run to run with the row above (green r1, red r3; 50-int)", "owner": "test-health (standing lane)", "since": "2026-10-23", "review": "2026-11-07"},
+		{"suite": "checkpoints", "check": "an autosave write cuts an automatic row", "reason": "the automatic row lands ~15.7 s, the check waits 12 s (50-window)", "owner": "test-health (standing lane)", "since": "2026-10-23", "review": "2026-11-07"},
+		{"suite": "scene-load", "check": "1.4 no long task over", "reason": "a 204-389 ms long task vs the 200 ms line under load; known in 39/40/41/42 incl. A/B bases (L3)", "owner": "test-health (standing lane)", "since": "2026-10-23", "review": "2026-11-07"},
+		{"suite": "scene-load", "check": "6.3 no long task over", "reason": "as 1.4, while restoring; the one L3 row red on preview-1-42 (50-int)", "owner": "test-health (standing lane)", "since": "2026-10-23", "review": "2026-11-07"},
+		{"suite": "scene-load", "check": "4.4 a toast says the load was stopped", "reason": "the toast is read after it expired under load (49-int x1, 50-int)", "owner": "test-health (standing lane)", "since": "2026-10-23", "review": "2026-11-07"},
+		{"suite": "net-handshake", "check": "C received the scene", "reason": "third peer handshake timing; red on pristine v1.41.0 and on 904599c1 (50-int r3, 55-invite)", "owner": "test-health (standing lane)", "since": "2026-10-23", "review": "2026-11-07"},
+		{"suite": "flow-physics-actions", "check": "2.1 mode 'continuous' KEEPS pushing", "reason": "body at 0 m/s under a held key on a slow frame; flaky in every app x driver cell (deps-1 ab3)", "owner": "test-health (standing lane)", "since": "2026-10-23", "review": "2026-11-07"},
+		{"suite": "flow-physics-actions", "check": "4.3 read 'speed' reports real motion", "reason": "as 2.1 (deps-1 ab3)", "owner": "test-health (standing lane)", "since": "2026-10-23", "review": "2026-11-07"},
+		{"suite": "flow-physics-actions", "check": "6.5 (premise) the trigger hops the box", "reason": "two-peer world timing (deps-1 ab3, 49-int)", "owner": "test-health (standing lane)", "since": "2026-10-23", "review": "2026-11-07"},
+		{"suite": "flow-physics-actions", "check": "8.5 and the very NEXT press throws the box", "reason": "stale-press guard vs frame timing (pcA, deps-1)", "owner": "test-health (standing lane)", "since": "2026-10-23", "review": "2026-11-07"},
+		{"suite": "select-41", "check": "G4 (near) a finger on the crate takes it", "reason": "G4 flick timing: 12/12 green on --local, red under load (deps-1 ab3)", "owner": "test-health (standing lane)", "since": "2026-10-23", "review": "2026-11-07"},
+		{"suite": "avatar-feet", "check": "1.3 standing: B's lowest sole is on the floor", "reason": "red 2/4 d3d12, 3/3 llvmpipe, green on rerun (mux-pc-host)", "owner": "test-health (standing lane)", "since": "2026-10-23", "review": "2026-11-07"},
+		{"suite": "aquarium-reef", "check": "2.1 every fallback group built its PACK model", "reason": "1 red in 3 on each GPU path: pack fetch vs the wait (mux-pc-host)", "owner": "test-health (standing lane)", "since": "2026-10-23", "review": "2026-11-07"},
+		{"suite": "aquarium-reef", "check": "2.2 every group DRAWS a pack level", "reason": "as 2.1 (mux-pc-host)", "owner": "test-health (standing lane)", "since": "2026-10-23", "review": "2026-11-07"},
+		{"suite": "knock-physics", "check": "2.12 within 60 ms B's rendered ball has moved", "reason": "a 60 ms window on a remote frame; pc rerun 3/3 green (mux-pc-host)", "owner": "test-health (standing lane)", "since": "2026-10-23", "review": "2026-11-07"},
+		{"suite": "pack-behavior", "check": "7.2 OPEN: the capsule walks through the doorway", "reason": "a fixed 300 ms wait vs charController's lazy physics import; base 1/3 red (59-replace)", "owner": "test-health (standing lane)", "since": "2026-10-23", "review": "2026-11-07"},
+		{"suite": "code-workspace", "check": "Save as file binds the node", "reason": "a 2000 ms wait; flaked on both base and lane (50-yjs, 50-window)", "owner": "test-health (standing lane)", "since": "2026-10-23", "review": "2026-11-07"},
+		{"suite": "animation-node", "check": "so the door closes rather than restarting", "reason": "~1.7 fps under load: a 900 ms window holds 1-2 frames; 35/0 on a GPU slot (57-clips)", "owner": "test-health (standing lane)", "since": "2026-10-23", "review": "2026-11-07"},
+		{"suite": "dock-strip-drop", "check": "6.3 opening an Explorer image brings the docked editor forward", "reason": "red 1/2 on both 1.41 and 1.40 production, green on base in deps-1 ab1 (53-int)", "owner": "test-health (standing lane)", "since": "2026-10-23", "review": "2026-11-07"},
+		{"suite": "toolbar-slots-42", "check": "I9: each corner shows ONE", "reason": "known deployed flake (touch reorder, unfolded dark); same 2 reds on production 1.39 (49-int, 53-int)", "owner": "test-health (standing lane)", "since": "2026-10-23", "review": "2026-11-07"},
+		{"suite": "animation-sync", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
+		{"suite": "behaviours", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
+		{"suite": "char-controller", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
+		{"suite": "collider-live", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
+		{"suite": "context-menu-redesign", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
+		{"suite": "edit-move-games", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
+		{"suite": "fb-water", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
+		{"suite": "flow-physics-nodes", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
+		{"suite": "game-loop-v4", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
+		{"suite": "game-sky-run", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
+		{"suite": "kit-instancing", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
+		{"suite": "lock-search", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
+		{"suite": "mesh-toolbox-redesign", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
+		{"suite": "model-preview", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
+		{"suite": "net-stress", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
+		{"suite": "panels", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
+		{"suite": "phone-sheets", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
+		{"suite": "physics-discoverability", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
+		{"suite": "physics-kinematic", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
+		{"suite": "scene-budget", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
+		{"suite": "scene-post", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
+		{"suite": "scene-post-effects", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
+		{"suite": "search-menus", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
+		{"suite": "settings-layout", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
+		{"suite": "shader-sync", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
+		{"suite": "sound-node", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
+		{"suite": "themes", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
+		{"suite": "timeline-export", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
+		{"suite": "touch-actions", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
+		{"suite": "water-migration", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"}
+	]
+}
diff --git a/tests/unit/quarantine.test.js b/tests/unit/quarantine.test.js
new file mode 100644
index 000000000..66324113f
--- /dev/null
+++ b/tests/unit/quarantine.test.js
@@ -0,0 +1,73 @@
+// test-health-1: the e2e quarantine (scripts/ci/quarantine.cjs) decides which battery reds gate a PR,
+// without a person — so the per-check rule, the crash rule and the file's shape are pinned here.
+import { describe, it, expect } from 'vitest';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const { load, validate, failedChecks, classify, warnings } = require('../../scripts/ci/quarantine.cjs');
+
+const entry = (/** @type {Record<string, string>} */ over = {}) => ({
+	suite: 'ui-fixes',
+	check: 'toast burst',
+	reason: 'a fixed sleep',
+	owner: 'test-health',
+	since: '2026-10-24',
+	review: '2026-11-07',
+	...over
+});
+const q = (/** @type {any[]} */ ...list) => ({ quarantine: list });
+const log = (/** @type {string[]} */ ...lines) => [...lines, lines.some((l) => l.startsWith('FAIL')) ? `${lines.filter((l) => l.startsWith('FAIL')).length} FAILURES` : 'ALL PASS'].join('\n');
+
+describe('quarantine: which reds do not gate', () => {
+	it('reads the FAIL labels helpers.check prints', () => {
+		expect(failedChecks('PASS a\nFAIL the toast burst moved 8 px\n  ✗ two\nnot ok three\n')).toEqual(['the toast burst moved 8 px', 'two', 'three']);
+	});
+	it('a red whose every failed check is quarantined is non-blocking', () => {
+		const v = classify(q(entry()), 'ui-fixes', log('PASS x', 'FAIL the toast burst moved 8 px'));
+		expect(v.quarantined).toBe(true);
+		expect(v.entries).toHaveLength(1);
+	});
+	it('a quarantined row cannot hide a NEW red in the same suite', () => {
+		const v = classify(q(entry()), 'ui-fixes', log('FAIL the toast burst moved 8 px', 'FAIL Roughness row'));
+		expect(v.quarantined).toBe(false);
+		expect(v.unmatched).toEqual(['Roughness row']);
+	});
+	it('a check entry never covers a crash or a timeout', () => {
+		const crash = 'PASS a\nFAIL the toast burst moved 8 px\nSCRIPT FAILED: Timeout 30000ms exceeded';
+		expect(classify(q(entry()), 'ui-fixes', crash).quarantined).toBe(false);
+		expect(classify(q(entry()), 'ui-fixes', 'PASS a\nFAIL the toast burst\n').quarantined).toBe(false); // no verdict line
+		expect(classify(q(entry()), 'ui-fixes', log('FAIL the toast burst'), { timedOut: true }).quarantined).toBe(false);
+	});
+	it('an entry is per suite: the same label in another suite still gates', () => {
+		expect(classify(q(entry()), 'other-suite', log('FAIL the toast burst')).quarantined).toBe(false);
+	});
+	it('a whole-suite entry (no check) covers any red, crash included', () => {
+		const { check, ...whole } = entry();
+		expect(classify(q(whole), 'ui-fixes', 'SCRIPT FAILED: boom').quarantined).toBe(true);
+	});
+});
+
+describe('quarantine.json: the file', () => {
+	it('the committed file validates', () => {
+		expect(validate(load())).toEqual([]);
+	});
+	it('every committed entry names a suite that exists', async () => {
+		const fs = require('node:fs');
+		const path = require('node:path');
+		for (const e of load().quarantine) expect(fs.existsSync(path.resolve('tests/e2e', e.suite + '.test.cjs')), e.suite).toBe(true);
+	});
+	it('refuses a missing field, a bad date, an unknown key and a duplicate', () => {
+		const { owner, ...noOwner } = entry();
+		expect(validate(q(noOwner))).toEqual([expect.stringContaining('.owner is required')]);
+		expect(validate(q(entry({ review: '7 Nov' })))[0]).toContain('review must be YYYY-MM-DD');
+		expect(validate(q(entry({ review: '2026-10-01' })))[0]).toContain('review must be after since');
+		expect(validate(q({ ...entry(), note: 'x' }))[0]).toContain('unknown key note');
+		expect(validate(q(entry(), entry()))[0]).toContain('duplicate');
+	});
+	it('warns (never fails) on a past review date and on a suite that ran green', () => {
+		const w = warnings(q(entry()), [{ name: 'ui-fixes', status: 'pass' }], ['ui-fixes'], '2026-12-01');
+		expect(w.some((x) => x.includes('review date 2026-11-07 has passed'))).toBe(true);
+		expect(w.some((x) => x.includes('ran green'))).toBe(true);
+		expect(warnings(q(entry()), [], ['elsewhere'], '2026-10-25')).toEqual([expect.stringContaining('stale entry')]);
+	});
+});

From b4b46abd7c14e677bee2a5d68ac8f28c29aa2013 Mon Sep 17 00:00:00 2001
From: AlexZ005 <alexz005.info@gmail.com>
Date: Sat, 24 Oct 2026 17:30:14 +0300
Subject: [PATCH 03/46] [test] test-health-1 P3a: e2e-smoke can go red, and its
 two runner reds are fixed
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- ci.yml e2e-smoke: the suites run through `battery.cjs run --only …` — the old loop's
  `|| echo "SUITE FAILED"` could never fail the step, so "green" meant nothing. Now a red is a red,
  a failed suite runs once more (green on the retry = flaky, reported) and quarantine.json applies;
  the logs upload as an artifact. continue-on-error stays until this runs green on the PR.
- What it had been hiding on GitHub runners (logs of runs 40088706029, 40013497378, 40003340521):
  script-guard "the render loop is still running (3 frames in 1800ms)" — the runner measures exactly
  3 frames and the check wanted > 3; now 3000 ms and >= 3 (a frozen loop reads 0-1). script-guard
  "a slow node is paused … (null)" — the guard needs 30 slow frames in a row and the wait was a fixed
  30 s at ~2 fps; the wait is now counted in frames from the rate measured just above.
  diagnostics "the section reads the live peer id through the store" — the id is empty until the
  public signaling server answers; it waits for it now (an IMPORTED id would stay empty: still red).
- local, through the new path (battery.cjs run --only diagnostics,script-guard): 16/0 + 11/0, rc 0.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 .github/workflows/ci.yml        | 23 ++++++++++++++++++-----
 tests/e2e/diagnostics.test.cjs  |  7 +++++++
 tests/e2e/script-guard.test.cjs | 19 +++++++++++++------
 3 files changed, 38 insertions(+), 11 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 496f60fdb..8691b23a3 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -180,14 +180,20 @@ jobs:
           # Deliberately NOT added: net-stress and signaling-reconnect are multi-peer and
           # meet on the self-hosted signaling box, which a public runner cannot reach and
           # should not be pointed at (see the header) — they stay a manual gate.
-          for s in net-backoff net-mesh wire-hardening runtime-resilience diagnostics mesh-budget script-guard dispose approval-timeout; do
-            echo "::group::$s"
-            npm run e2e -- "$s" || echo "SUITE FAILED: $s"
-            echo "::endgroup::"
-          done
+          # test-health-1: through the battery runner, so a red is a red (the old loop's
+          # `|| echo SUITE FAILED` could never fail the step), a failed suite runs once more
+          # (green on the retry = flaky, reported) and tests/e2e/quarantine.json applies.
+          node scripts/ci/battery.cjs run --only net-backoff,net-mesh,wire-hardening,runtime-resilience,diagnostics,mesh-budget,script-guard,dispose,approval-timeout --port 5173 --out /tmp/smoke
       - name: dev server log on failure
         if: failure()
         run: tail -40 /tmp/dev.log
+      - name: suite logs
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: e2e-smoke-logs
+          path: /tmp/smoke/logs
+          if-no-files-found: ignore
 
   # 53-reader (A4): THE ACCESSIBILITY GATE. axe-core over the main surfaces (editor shell, object
   # list, Inspector, Settings, Asset Browser on recorded fixtures, phone shell) FAILS on serious and
@@ -230,6 +236,13 @@ jobs:
       - name: dev server log on failure
         if: failure()
         run: tail -40 /tmp/dev.log
+      - name: suite logs
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: e2e-smoke-logs
+          path: /tmp/smoke/logs
+          if-no-files-found: ignore
 
   # 38 (NOTES-38 #18): THE TOKEN SCREENSHOT DIFF. /kit renders every redesign primitive in every
   # state; this job shoots it in the dark, light and custom themes on the PR's BASE ref and on its
diff --git a/tests/e2e/diagnostics.test.cjs b/tests/e2e/diagnostics.test.cjs
index 3165ad7a3..d477462a8 100644
--- a/tests/e2e/diagnostics.test.cjs
+++ b/tests/e2e/diagnostics.test.cjs
@@ -42,6 +42,13 @@ h.run(async () => {
 	h.check(/line 319\b/.test(ring.last), `the NEWEST line is kept: ${ring.last}`);
 
 	// ---- 2. the bundle, and the registered section --------------------------------
+	// test-health-1: the peer id is empty until the signaling server hands one out, which on a
+	// public CI runner (the public PeerJS cloud) can take longer than this suite's first seconds;
+	// a section that captured an IMPORT instead of reading the store stays empty forever, so
+	// waiting for it keeps the counterfactual.
+	await page
+		.waitForFunction(() => (window.__stores.diagnostics.bundle().sections?.session?.peerId ?? '').length > 0, null, { timeout: 30000 })
+		.catch(() => {});
 	const bundle = await page.evaluate(() => window.__stores.diagnostics.bundle());
 	h.check(
 		!!bundle.version && !!bundle.at && typeof bundle.ua === 'string',
diff --git a/tests/e2e/script-guard.test.cjs b/tests/e2e/script-guard.test.cjs
index 9041ae925..13b883db8 100644
--- a/tests/e2e/script-guard.test.cjs
+++ b/tests/e2e/script-guard.test.cjs
@@ -94,23 +94,28 @@ h.run(async () => {
 	h.check(clicked !== null, 'and the real UI is still there to be driven');
 
 	// the frame loop kept going: rAF still fires
+	const FRAME_WINDOW_MS = 3000;
 	const frames = await A.page.evaluate(
-		() =>
+		(FRAME_WINDOW_MS) =>
 			new Promise((resolve) => {
 				let n = 0;
 				const t0 = performance.now();
 				const step = () => {
 					n++;
-					if (performance.now() - t0 > 1800) return resolve(n);
+					if (performance.now() - t0 > FRAME_WINDOW_MS) return resolve(n);
 					requestAnimationFrame(step);
 				};
 				requestAnimationFrame(step);
-			})
+			}),
+		FRAME_WINDOW_MS
 	);
 	// 1800 ms, not 600: headless SwiftShader runs ~5 fps and the runaway costs part of every frame, so 600 ms
 	// was 2-4 frames on either side of the threshold (1.24.0 and 1.25 both measure 9 frames / 2 s — 36-int-125);
-	// a frozen loop reads 0-1
-	h.check(frames > 3, `the render loop is still running (${frames} frames in 1800ms)`);
+	// a frozen loop reads 0-1. test-health-1: 3000 ms and >= 3 — a GitHub runner measured exactly 3 in 1800 ms
+	// (ci.yml e2e-smoke, 2026-10-23/24), red at `> 3` with the loop plainly alive.
+	h.check(frames >= 3, `the render loop is still running (${frames} frames in ${FRAME_WINDOW_MS}ms)`);
+	// what one frame costs here, for the waits below that count frames
+	const frameMs = FRAME_WINDOW_MS / Math.max(1, frames);
 
 	// ---- 3. a healthy node beside it still works ---------------------------------------
 	const uuid2 = await makeBox(A);
@@ -155,7 +160,9 @@ h.run(async () => {
 				window.__stores.scriptErrors.subscribe((m) => (v = m))();
 				return /too slow/i.test(String(v['slow'] ?? '')) ? v['slow'] : false;
 			},
-			{ timeout: 30000 }
+			// the guard pauses after SLOW_FRAMES (30) slow frames in a row, so the wait is counted in FRAMES:
+			// at a runner's ~2 fps (slower still with this node eating each one) 30 s was not 30 frames
+			{ timeout: Math.max(30000, Math.round(30 * frameMs * 3) + 5000) }
 		)
 		.then((r) => r.jsonValue())
 		.catch(() => null);

From bc453ae880950a697efd37e2f36958f9effe1394 Mon Sep 17 00:00:00 2001
From: AlexZ005 <alexz005.info@gmail.com>
Date: Sat, 24 Oct 2026 17:42:40 +0300
Subject: [PATCH 04/46] [test] test-health-1 P3b: script-guard says why the
 slow-node badge never came
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- First strict e2e-smoke run on this PR (run 40102808352): 8 of 9 suites green, diagnostics fixed;
  script-guard "a slow node is paused …" still null on the runner although the wait is now 72 s
  (4 frames / 3000 ms measured). The guard (scriptRuntime.timed) pauses after 30 consecutive calls
  over 8 ms and the fixture measures 37 ms there, so either the node is not being called or it is
  and something resets the streak. The check now reports, on failure: how often the slow script ran,
  the scriptErrors map, flowPaused and the page's visibility — one CI run tells which.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 tests/e2e/script-guard.test.cjs | 19 +++++++++++++++++--
 1 file changed, 17 insertions(+), 2 deletions(-)

diff --git a/tests/e2e/script-guard.test.cjs b/tests/e2e/script-guard.test.cjs
index 13b883db8..3e8e74451 100644
--- a/tests/e2e/script-guard.test.cjs
+++ b/tests/e2e/script-guard.test.cjs
@@ -140,8 +140,10 @@ h.run(async () => {
 	// script at a million iterations, so it cannot buy time by looping MORE, it has to do
 	// more work per iteration. 900k plain additions measured about a millisecond here and
 	// the check failed for the fixture's sake rather than the feature's.
+	// (the counter on window is test-health-1's: when the badge never comes, it tells "the node did
+	// not run" from "it ran and was never paused")
 	const SLOW_SRC =
-		'let s = 0; for (let i = 0; i < 500000; i++) { s += Math.sin(i) * Math.cos(i); } data.s = s;';
+		'let s = 0; for (let i = 0; i < 500000; i++) { s += Math.sin(i) * Math.cos(i); } data.s = s; globalThis.__slowRuns = (globalThis.__slowRuns || 0) + 1;';
 	const bodyMs = await A.page.evaluate((src) => {
 		const fn = new Function('data', src);
 		const t0 = performance.now();
@@ -166,7 +168,20 @@ h.run(async () => {
 		)
 		.then((r) => r.jsonValue())
 		.catch(() => null);
-	h.check(!!slowBadge, `a slow node is paused rather than left to eat the frame (${slowBadge})`);
+	const slowWhy = slowBadge
+		? slowBadge
+		: JSON.stringify(
+				await A.page
+					.evaluate(() => {
+						/** @type {any} */ let errs = {};
+						/** @type {any} */ let paused = null;
+						window.__stores.scriptErrors.subscribe((/** @type {any} */ m) => (errs = m))();
+						window.__stores.flowPaused.subscribe((/** @type {any} */ p) => (paused = p))();
+						return { runs: /** @type {any} */ (globalThis).__slowRuns ?? 0, errs, paused, visible: document.visibilityState };
+					})
+					.catch((/** @type {any} */ e) => String(e))
+			);
+	h.check(!!slowBadge, `a slow node is paused rather than left to eat the frame (${slowWhy})`);
 	h.check(
 		await A.page.evaluate(() => 1 + 1).then((v) => v === 2),
 		'and the page is still responsive after it'

From e77ca3f71769bdffb8d201d90306f65578eb48ed Mon Sep 17 00:00:00 2001
From: AlexZ005 <alexz005.info@gmail.com>
Date: Sat, 24 Oct 2026 17:48:54 +0300
Subject: [PATCH 05/46] [test] test-health-1 WIP (checkpoint, NOT yet verified
 by a run): P2 test fixes + P5 suites
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Unverified, from read-only root-causing (each to be run, split into one commit per suite, and its
quarantine entry removed once green):
- flow-physics-nodes: Base made static (95df3a66 made every /create box dynamic) — stale test
- collider-live: wait on the body's speed, not 2500 ms (physics slow-motion on software GL)
- flow-physics-actions: section 2 driven by a Toggle (held key re-stamped after physics reads it,
  < 3.3 fps reads 0 — product follow-up in STATUS); 6.5a waits for the box on B instead of crashing
- game-loop-v4: A travels to the Lobby first (rooms are content partitions since R22 round 30/34)
- game-sky-run: vignette is a level since e16c7413 — ON reads 'high'
- animation-sync: bounded poll until both peers ended the once-clip (third page's frame lag)
- helpers.connect: dial the live id after both signaling links opened (re-rolled ids: behaviours)
- new: tests/e2e/net-drop.test.cjs (5 s quiet + hard drop), tests/e2e/reload-memory.test.cjs (probe)

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 tests/e2e/animation-sync.test.cjs       |  10 ++
 tests/e2e/collider-live.test.cjs        |  11 +-
 tests/e2e/flow-physics-actions.test.cjs |  22 ++-
 tests/e2e/flow-physics-nodes.test.cjs   |   4 +
 tests/e2e/game-loop-v4.test.cjs         |  15 ++
 tests/e2e/game-sky-run.test.cjs         |   4 +-
 tests/e2e/helpers.cjs                   |  22 +++
 tests/e2e/net-drop.test.cjs             | 227 ++++++++++++++++++++++++
 tests/e2e/reload-memory.test.cjs        | 100 +++++++++++
 9 files changed, 404 insertions(+), 11 deletions(-)
 create mode 100644 tests/e2e/net-drop.test.cjs
 create mode 100644 tests/e2e/reload-memory.test.cjs

diff --git a/tests/e2e/animation-sync.test.cjs b/tests/e2e/animation-sync.test.cjs
index 6f99b8999..d81cfb70b 100644
--- a/tests/e2e/animation-sync.test.cjs
+++ b/tests/e2e/animation-sync.test.cjs
@@ -266,6 +266,16 @@ h.run(async () => {
 	);
 	await A.page.evaluate((id) => window.__stores.animationPreview.play(id), doorUuid);
 	await A.page.waitForTimeout(1600); // a 'once' clip: both peers end at 90deg
+	// test-health-1: only a FRAME poses the door and ends the clip (tickAnimationPreview runs from
+	// Scene's useTask), and C is a third software-GL page — 1600 ms was not always one of C's
+	// frames (0.0deg, still playing, while two reads later showed it at 90). Poll, bounded: a C
+	// that never got or never evaluates `animplay` still reads wrong at the end.
+	const ended = (/** @type {any} */ r) => r && r.rotY !== null && Math.abs(r.rotY - Math.PI / 2) < 0.02 && !r.playing;
+	for (let t = Date.now(); Date.now() - t < 15000; ) {
+		const [a, c] = await Promise.all([readAnim(A.page, doorUuid), readAnim(C.page, doorUuid)]);
+		if (ended(a) && ended(c)) break;
+		await A.page.waitForTimeout(250);
+	}
 
 	const [doorA, doorC] = await Promise.all([readAnim(A.page, doorUuid), readAnim(C.page, doorUuid)]);
 	h.check(
diff --git a/tests/e2e/collider-live.test.cjs b/tests/e2e/collider-live.test.cjs
index 84371094e..c1345f2cf 100644
--- a/tests/e2e/collider-live.test.cjs
+++ b/tests/e2e/collider-live.test.cjs
@@ -55,7 +55,16 @@ h.run(async () => {
 		window.__ball.userData.physics = { ...window.__ball.userData.physics, collider: 'box' };
 		window.__stores.physics.physicsShapeChanged(window.__ball.uuid);
 	});
-	await A.page.waitForTimeout(2500); // let the box scrub off the roll speed
+	// let the box scrub off the roll speed — by its SPEED, not a fixed 2500 ms (test-health-1): physics
+	// steps at most 8 x 1/60 s per frame, so on a software-GL page (~2-5 fps) 2.5 s of wall clock is
+	// well under a second of simulation and the box was still sliding (dx 0.87). A sphere collider
+	// keeps rolling down the ramp, so it never gets here.
+	const speed = () =>
+		A.page.evaluate(() => {
+			const v = window.__stores.physics.physicsDebug().find((b) => b.uuid === window.__ball.uuid)?.linvel;
+			return v ? Math.hypot(v.x, v.y, v.z) : null;
+		});
+	await h.eventually(speed, (v) => v !== null && v < 0.05, 'the box collider scrubs the roll to rest', 30000);
 	const still = await A.page.evaluate(async () => {
 		const x0 = window.__ball.position.x;
 		await new Promise((r) => setTimeout(r, 1200));
diff --git a/tests/e2e/flow-physics-actions.test.cjs b/tests/e2e/flow-physics-actions.test.cjs
index d4e2748a3..14feb4fe5 100644
--- a/tests/e2e/flow-physics-actions.test.cjs
+++ b/tests/e2e/flow-physics-actions.test.cjs
@@ -244,14 +244,18 @@ h.run(async () => {
 	console.log('\n=== 2. Set Velocity ===');
 
 	await page.evaluate(() => window.__stores.physics.stopSimulation());
+	// test-health-1: a TOGGLE holds the trigger, as 1.4 does. A held Key Press is re-stamped AFTER
+	// the physics actions read it in runTick, so on a page slower than its 0.3 s pulse (~3 fps,
+	// software GL) the key read 0 every frame and this section measured -0.00 m/s; what 2.x is
+	// about is Set Velocity's continuous mode, not the key (the key path stays in 1.x and 6.x).
 	await setGraph(
 		page,
 		[
-			node('key1', 'keypress', { code: 'KeyR', pulse: 0.3 }),
+			node('tog2', 'toggle', { on: false }),
 			node('sv1', 'setvelocity', { mode: 'continuous', x: 2, y: 0, z: 0 }, 200),
 			node('sel1', 'objectselector', { selected: box }, 400)
 		],
-		[edge('key1', 'sv1', 'trigger'), edge('sv1', 'sel1')]
+		[edge('tog2', 'sv1', 'trigger'), edge('sv1', 'sel1')]
 	);
 	await page.evaluate(
 		(uuid) => {
@@ -267,16 +271,12 @@ h.run(async () => {
 	await page.evaluate(() => window.__stores.physics.toggleSimulation());
 	await page.waitForTimeout(1200);
 
-	await page.evaluate(() => {
-		document.dispatchEvent(new KeyboardEvent('keydown', { code: 'KeyR', bubbles: true }));
-	});
+	await page.evaluate(() => window.__stores.nodesHandler.setNodeData('tog2', { on: true }));
 	await page.waitForTimeout(1400); // let it reach the speed before sampling it
 	const held1 = (await bodyOf(page, box))?.linvel?.x ?? 0;
 	await page.waitForTimeout(700);
 	const held2 = (await bodyOf(page, box))?.linvel?.x ?? 0;
-	await page.evaluate(() => {
-		document.dispatchEvent(new KeyboardEvent('keyup', { code: 'KeyR', bubbles: true }));
-	});
+	await page.evaluate(() => window.__stores.nodesHandler.setNodeData('tog2', { on: false }));
 	// the velocity is re-written once per FLOW TICK, and friction bleeds it between
 	// ticks, so the observable property is a STEADY speed rather than exactly the
 	// dialled number
@@ -475,7 +475,11 @@ h.run(async () => {
 			return original(message);
 		};
 	});
-	const beforeHopY = (await posOf(B.page, box))[1];
+	// test-health-1: the box reaches B through the object sync, which can land well after the graph
+	// (6.3) on a software-GL page — read it once it is there (a box that never arrives is a named red
+	// here, not a TypeError that ended the suite at this line)
+	await h.eventually(() => posOf(B.page, box), (p) => Array.isArray(p), '6.5a (premise) the late joiner has the box', 30000);
+	const beforeHopY = (await posOf(B.page, box))?.[1] ?? 0;
 	// Drive the trigger through applyNodeTrigger — the SAME entry point a Key
 	// Press produces (flowRuntime calls exactly this, with replicate: true), so
 	// the path under test is unchanged: rising edge -> updatePhysicsActions ->
diff --git a/tests/e2e/flow-physics-nodes.test.cjs b/tests/e2e/flow-physics-nodes.test.cjs
index 2e25198b6..3a82a6e44 100644
--- a/tests/e2e/flow-physics-nodes.test.cjs
+++ b/tests/e2e/flow-physics-nodes.test.cjs
@@ -45,6 +45,10 @@ h.run(async () => {
 		base.position.set(6, 0.5, 0);
 		rotor.position.set(6, 2.2, 0);
 		rotor.userData.physics = { mode: 'dynamic', mass: 1 };
+		// test-health-1: since 95df3a66 ("fun-by-default primitives") every created box is DYNAMIC, so
+		// the Base this scene means as an anchor had a body and the "refused on a non-dynamic body"
+		// check below found one; say it is the static anchor the comment above describes
+		base.userData.physics = { mode: 'static' };
 		const peer = await new Promise((r) => window.__stores.peers.subscribe(r)());
 		[spinner, base, rotor].forEach((o) => {
 			peer.send({ type: 'move', uuid: o.uuid, pos: o.position.toArray(), rot: [0, 0, 0], scale: [1, 1, 1] });
diff --git a/tests/e2e/game-loop-v4.test.cjs b/tests/e2e/game-loop-v4.test.cjs
index 1d6c463f1..0126fea47 100644
--- a/tests/e2e/game-loop-v4.test.cjs
+++ b/tests/e2e/game-loop-v4.test.cjs
@@ -90,6 +90,21 @@ h.run(async () => {
 	await makeBox(B);
 	const lobby = await B.page.evaluate(() => window.__stores.levels.saveSceneAsLevel('Lobby'));
 	h.check(!!lobby?.hash, 'the Lobby scene is in the project');
+	// test-health-1: saving the cleared world as Lobby MOVES B's room (R22 round 30/34: rooms are
+	// content partitions, a save names the room) while A still stands in Hunt — so B's node and
+	// edge below were withheld from A as "elsewhere" and the travel never reached it. A joins the
+	// Lobby by name first, the way a player would.
+	await A.page.evaluate(() => window.__stores.levels.travelToScene('Lobby'));
+	await h.eventually(
+		() => A.page.evaluate(() => {
+			let c;
+			window.__stores.levels.currentLevel.subscribe((v) => (c = v))();
+			return c?.name ?? '';
+		}),
+		(n) => n === 'Lobby',
+		'premise: A stands in the Lobby with B',
+		30000
+	);
 	// the travel NODE in name mode, pulsed on B, moves BOTH peers to the CURRENT Hunt
 	const node = await B.page.evaluate(() => {
 		const s = window.__stores;
diff --git a/tests/e2e/game-sky-run.test.cjs b/tests/e2e/game-sky-run.test.cjs
index ba2c1787a..51d385e1a 100644
--- a/tests/e2e/game-sky-run.test.cjs
+++ b/tests/e2e/game-sky-run.test.cjs
@@ -96,7 +96,9 @@ h.run(async () => {
 		return cam.getWorldPosition(new s.THREE.Vector3()).toArray().map((n) => +n.toFixed(2));
 	});
 	const vignette = await page.evaluate(() => { let v; window.__stores.gameKit.gameSettings?.gameSettingValues?.subscribe((x) => (v = x))(); return v?.vignette ?? null; });
-	h.check(vignette === true, `the comfort vignette defaults ON for this game (${vignette})`);
+	// test-health-1: 53-play phase 6 (e16c7413) made the vignette a LEVEL (default/off/low/high) and
+	// maps the module's `true` to 'high' (gameSettings aliases), so ON reads 'high' now
+	h.check(vignette === 'high', `the comfort vignette defaults ON (high) for this game (${vignette})`);
 	h.check(eye0[1] > 12.5 && Math.abs(eye0[0]) < 3, `Play put the player on stage 1's start pad, up in the sky (${eye0})`);
 
 	console.log('\n=== 3. a scripted run of stage 1 ===');
diff --git a/tests/e2e/helpers.cjs b/tests/e2e/helpers.cjs
index b39fbda66..748ef1d3f 100644
--- a/tests/e2e/helpers.cjs
+++ b/tests/e2e/helpers.cjs
@@ -252,6 +252,28 @@ async function setupPageQuiet(browser, name, others, options = {}) {
 
 /** Connect `from` to `to` (approve on `to`), then let the mesh settle. */
 async function connect(from, to, settleMs = 9000) {
+	// test-health-1: dial the id the page holds NOW. setupPage reads it before the signaling link
+	// has opened, and a page whose first id the server reports as taken re-rolls it
+	// (peerHandler 'unavailable-id') — behaviours dialled the stale id and waited 30 s for an
+	// Approve card that could never come. Wait (bounded) for both links, then re-read both ids.
+	for (const peer of [from, to]) {
+		const live = await peer.page
+			.waitForFunction(
+				() => {
+					/** @type {any} */ let p;
+					window.__stores.peers.subscribe((v) => (p = v))();
+					return p?.peer?.open && p.peer.id ? p.peer.id : false;
+				},
+				null,
+				{ timeout: 20000 }
+			)
+			.then((r) => r.jsonValue())
+			.catch(() => null);
+		if (live && live !== peer.id) {
+			console.log(`[helpers] ${peer.id} is ${live} now (the id was re-rolled)`);
+			peer.id = live;
+		}
+	}
 	await step(from, 'fill the peer id', () =>
 		from.page.locator('input[placeholder="Enter peer ID to connect"]').fill(to.id)
 	);
diff --git a/tests/e2e/net-drop.test.cjs b/tests/e2e/net-drop.test.cjs
new file mode 100644
index 000000000..9cbb1cab8
--- /dev/null
+++ b/tests/e2e/net-drop.test.cjs
@@ -0,0 +1,227 @@
+// test-health-1 (plans review #29, done/b5-network-stress.md's device smoke): A 5 s CONNECTION DROP
+// MUST NOT TEAR A TWO-PEER SESSION DOWN — no "disconnected" toast, the peer stays in the roster with
+// its locks, and what was edited during the drop arrives afterwards.
+//
+// What a real wifi drop does to a Chromium tab, and how each part is reproduced headless (tc netem
+// needs root and would hit every lane on this box):
+//  * the signaling WebSocket dies (ERR_NETWORK_CHANGED) and nothing new can be fetched until the
+//    network is back — `context.setOffline(true)` on both pages, and the socket closed by hand
+//    (offline emulation leaves an OPEN socket alone);
+//  * the data channels go silent — a page shim HOLDS every message it would deliver and releases
+//    them in order when the drop ends (SCTP retransmits what it buffered once the path is back);
+//  * ICE reports `disconnected` after its consent checks fail, and `connected` again after —
+//    the shim reports both on every RTCPeerConnection.
+// Two shapes, both DROP_MS long (default 5000):
+//  1. QUIET: all of the above. The same conn should simply carry on.
+//  2. HARD (a network CHANGE): the same, plus the peer connection is closed outright at the start, so
+//     the B5 reconnect window has to redial — through a signaling server it cannot reach until the
+//     drop ends. The window is ~15.5 s (checks at 0.5/1/2/4/8 s), so a 5 s drop must fit inside it.
+// Counterfactual: NETDROP_MS=20000 outlasts the window — phase 2 goes red (teardown + toast).
+const h = require('./helpers.cjs');
+
+const DROP_MS = Number(process.env.NETDROP_MS || 5000);
+
+/** runs in the page before any app code: the hold switch + fake ICE state */
+function dropShim() {
+	const D = (window.__drop = { holding: false, queue: /** @type {Function[]} */ ([]), pcs: /** @type {RTCPeerConnection[]} */ ([]), held: 0 });
+	const wrap = (/** @type {Function} */ fn) =>
+		function (/** @type {any} */ event) {
+			// @ts-ignore
+			const self = this;
+			if (D.holding) {
+				D.held++;
+				D.queue.push(() => fn.call(self, event));
+				return;
+			}
+			return fn.call(self, event);
+		};
+	const proto = RTCDataChannel.prototype;
+	const desc = /** @type {PropertyDescriptor} */ (Object.getOwnPropertyDescriptor(proto, 'onmessage'));
+	Object.defineProperty(proto, 'onmessage', {
+		configurable: true,
+		get() {
+			return this.__onmsg ?? null;
+		},
+		set(fn) {
+			this.__onmsg = fn;
+			desc.set?.call(this, typeof fn === 'function' ? wrap(fn) : fn);
+		}
+	});
+	const add = proto.addEventListener;
+	proto.addEventListener = function (/** @type {string} */ type, /** @type {any} */ fn, /** @type {any} */ opts) {
+		return add.call(this, type, type === 'message' && typeof fn === 'function' ? wrap(fn) : fn, opts);
+	};
+	const Real = window.RTCPeerConnection;
+	// @ts-ignore
+	window.RTCPeerConnection = function (/** @type {any[]} */ ...args) {
+		const pc = new Real(...args);
+		D.pcs.push(pc);
+		return pc;
+	};
+	window.RTCPeerConnection.prototype = Real.prototype;
+	Object.setPrototypeOf(window.RTCPeerConnection, Real);
+	/** @param {'disconnected' | null} state null = the real one again */
+	// @ts-ignore
+	D.ice = (state) => {
+		for (const pc of D.pcs) {
+			if (pc.signalingState === 'closed') continue;
+			if (state) Object.defineProperty(pc, 'iceConnectionState', { configurable: true, get: () => state });
+			// @ts-ignore
+			else delete pc.iceConnectionState;
+			pc.dispatchEvent(new Event('iceconnectionstatechange'));
+			// @ts-ignore
+			pc.oniceconnectionstatechange?.(new Event('iceconnectionstatechange'));
+		}
+	};
+	// @ts-ignore
+	D.release = () => {
+		D.holding = false;
+		for (const run of D.queue.splice(0)) {
+			try {
+				run();
+			} catch (e) {
+				setTimeout(() => {
+					throw e;
+				});
+			}
+		}
+	};
+}
+
+h.run(async () => {
+	const browser = await h.launch();
+	const A = await h.setupPage(browser, 'A', { init: dropShim });
+	const B = await h.setupPage(browser, 'B', { init: dropShim });
+	await h.connect(B, A);
+
+	const store = (/** @type {any} */ p, /** @type {string} */ name) =>
+		p.page.evaluate((/** @type {string} */ n) => new Promise((r) => window.__stores[n].subscribe((/** @type {any} */ v) => r(v))()), name);
+	const inRoster = async (/** @type {any} */ p, /** @type {string} */ id) => (await store(p, 'userdata')).some((/** @type {any} */ u) => u[0] === id);
+	const openTo = (/** @type {any} */ p, /** @type {string} */ id) =>
+		p.page.evaluate((/** @type {string} */ pid) => {
+			/** @type {any} */ let pc;
+			window.__stores.peers.subscribe((/** @type {any} */ v) => (pc = v))();
+			return !!pc.connections[pid]?.open && pc.openedPeers.has(pid);
+		}, id);
+	const create = (/** @type {any} */ p, /** @type {string} */ shape) =>
+		p.page.evaluate((/** @type {string} */ s) => {
+			window.__stores.commandsHandler.sceneCommand('/create ' + s);
+			/** @type {any} */ let g;
+			window.__stores.objectsGroup.subscribe((/** @type {any} */ v) => (g = v))();
+			return g.children[g.children.length - 1].uuid;
+		}, shape);
+	const has = (/** @type {any} */ p, /** @type {string} */ uuid) =>
+		p.page.evaluate((/** @type {string} */ u) => {
+			/** @type {any} */ let g;
+			window.__stores.objectsGroup.subscribe((/** @type {any} */ v) => (g = v))();
+			return !!g?.getObjectByProperty('uuid', u);
+		}, uuid);
+	const disconnectToasts = async (/** @type {any} */ p, /** @type {number} */ from) =>
+		(await store(p, 'notifications')).slice(from).filter((/** @type {any} */ n) => /disconnected/.test(String(n.text))).length;
+	const signalingUp = (/** @type {any} */ p) =>
+		p.page.evaluate(() => {
+			/** @type {any} */ let pc;
+			window.__stores.peers.subscribe((/** @type {any} */ v) => (pc = v))();
+			return !!pc.peer && !pc.peer.disconnected && pc.peer.open !== false;
+		});
+
+	await h.eventually(() => openTo(A, B.id), (v) => v, 'premise: A holds an open conn to B');
+	await h.eventually(() => openTo(B, A.id), (v) => v, 'premise: B holds an open conn to A');
+	// a created object is selected = locked by its creator; B always holds one from here on (each
+	// create moves it), and a teardown releases every lock of the departed peer
+	const bLocks = async () => (await store(A, 'lockedObjects')).filter((/** @type {any} */ x) => x[0] === B.id).length;
+	const lockBox = await create(B, 'box');
+	await h.eventually(() => store(A, 'lockedObjects'), (l) => l.some((/** @type {any} */ x) => x[0] === B.id && x[1] === lockBox), "premise: A sees B's lock");
+
+	/** @param {'quiet' | 'hard'} shape */
+	async function drop(shape) {
+		const tag = shape.toUpperCase() + ` ${DROP_MS / 1000}s drop:`;
+		const toastsA = (await store(A, 'notifications')).length;
+		const toastsB = (await store(B, 'notifications')).length;
+		// mark the conns, to tell "the same conn carried on" from "a redial healed it"
+		for (const [p, other] of [[A, B.id], [B, A.id]]) {
+			await p.page.evaluate((/** @type {string} */ id) => {
+				/** @type {any} */ let pc;
+				window.__stores.peers.subscribe((/** @type {any} */ v) => (pc = v))();
+				pc.connections[id].__th1 = 'before';
+			}, other);
+		}
+		// ---- the network goes away
+		for (const p of [A, B]) await p.page.context().setOffline(true);
+		for (const p of [A, B]) {
+			await p.page.evaluate(() => {
+				/** @type {any} */ let pc;
+				window.__stores.peers.subscribe((/** @type {any} */ v) => (pc = v))();
+				// @ts-ignore
+				window.__drop.holding = true;
+				// @ts-ignore
+				window.__drop.ice('disconnected');
+				try {
+					pc.peer._socket._socket?.close();
+				} catch {}
+			});
+		}
+		if (shape === 'hard') {
+			await A.page.evaluate((/** @type {string} */ id) => {
+				/** @type {any} */ let pc;
+				window.__stores.peers.subscribe((/** @type {any} */ v) => (pc = v))();
+				pc.connections[id].peerConnection?.close();
+			}, B.id);
+		}
+		const t0 = Date.now();
+		/** @type {string[]} */
+		const lost = [];
+		const watch = async () => {
+			if (!(await inRoster(A, B.id))) lost.push(`A lost B at ${Date.now() - t0}ms`);
+			if (!(await inRoster(B, A.id))) lost.push(`B lost A at ${Date.now() - t0}ms`);
+			if ((await bLocks()) === 0) lost.push(`A dropped B's lock at ${Date.now() - t0}ms`);
+		};
+		// an edit on each side DURING the drop
+		await A.page.waitForTimeout(Math.min(1500, DROP_MS / 3));
+		const duringA = await create(A, 'sphere');
+		const duringB = await create(B, 'cylinder');
+		while (Date.now() - t0 < DROP_MS) {
+			await watch();
+			await A.page.waitForTimeout(500);
+		}
+		h.check(!(await signalingUp(A)) && !(await signalingUp(B)), `${tag} premise: the signaling link really was down on both pages`);
+		// ---- the network comes back
+		for (const p of [A, B]) await p.page.context().setOffline(false);
+		for (const p of [A, B]) {
+			await p.page.evaluate(() => {
+				// @ts-ignore
+				window.__drop.ice(null);
+				// @ts-ignore
+				window.__drop.release();
+			});
+		}
+		// watch the roster through the rest of the reconnect window (~15.5 s from the drop's start)
+		const healed = { a: false, b: false };
+		while (Date.now() - t0 < Math.max(DROP_MS, 0) + 17000) {
+			await watch();
+			healed.a ||= await openTo(A, B.id);
+			healed.b ||= await openTo(B, A.id);
+			if (healed.a && healed.b && Date.now() - t0 > 16000) break;
+			await A.page.waitForTimeout(500);
+		}
+		h.check(lost.length === 0, `${tag} each peer kept the other in its roster, and B's lock stood, throughout (${lost.slice(0, 2).join(', ') || 'never lost'})`);
+		h.check((await openTo(A, B.id)) && (await openTo(B, A.id)), `${tag} the conn is open both ways again`);
+		h.check((await disconnectToasts(A, toastsA)) === 0 && (await disconnectToasts(B, toastsB)) === 0, `${tag} no "disconnected" toast on either side`);
+		await h.eventually(() => has(B, duringA), (v) => v, `${tag} A's edit made during the drop reaches B`, 15000);
+		await h.eventually(() => has(A, duringB), (v) => v, `${tag} B's edit made during the drop reaches A`, 15000);
+		const afterB = await create(B, 'cone');
+		await h.eventually(() => has(A, afterB), (v) => v, `${tag} an edit after the drop replicates`, 10000);
+		await h.eventually(async () => (await signalingUp(A)) && (await signalingUp(B)), (v) => v, `${tag} both pages are back on the signaling server`, 20000);
+		const same = await A.page.evaluate((/** @type {string} */ id) => {
+			/** @type {any} */ let pc;
+			window.__stores.peers.subscribe((/** @type {any} */ v) => (pc = v))();
+			return pc.connections[id]?.__th1 === 'before';
+		}, B.id);
+		if (shape === 'quiet') h.check(same, `${tag} the SAME conn carried on (no redial was needed)`);
+		else h.check(!same, `${tag} premise: the conn really was replaced by the reconnect window`);
+	}
+
+	await drop('quiet');
+	await drop('hard');
+	await h.finish(browser);
+});
diff --git a/tests/e2e/reload-memory.test.cjs b/tests/e2e/reload-memory.test.cjs
new file mode 100644
index 000000000..717bc4d87
--- /dev/null
+++ b/tests/e2e/reload-memory.test.cjs
@@ -0,0 +1,100 @@
+// test-health-1 (plans review #24, roadmap-42 Follow-ups): RELOADING ONE TAB MUST NOT GROW IT.
+//
+// The report: editor-ui-33 died on its 5th reload in one tab (WebGL context lost / Target crashed)
+// and the heap grew ~29 MB per reload. A reload replaces the document, so anything that grows
+// ACROSS reloads is something the old document left behind: the old document itself (a reference
+// from something that outlives it), or GPU memory the old page's WebGL contexts still held.
+//
+// Per reload, after a forced GC: the JS heap, the number of live Documents (1 = only the current
+// one; more = an old document is retained), and the resident memory of this browser's renderer and
+// GPU processes (ps, so it sees what Chromium's own heap metrics do not: WebGL buffers live in the
+// GPU process). Evidence: EVIDENCE/reload-memory.json.
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+const h = require('./helpers.cjs');
+
+const RELOADS = Number(process.env.RELOADS || 6);
+const SETTLE_MS = Number(process.env.RELOAD_SETTLE_MS || 4000);
+const EVIDENCE = process.env.EVIDENCE || path.join(process.env.HOME || '.', '.code/lanes-30/after-60/60-test-health-1');
+// thresholds: the growth that killed a tab was ~29 MB/reload of JS heap; a steady state after the
+// first reload (caches warm) should be flat within noise
+const MAX_HEAP_MB_PER_RELOAD = Number(process.env.MAX_HEAP_MB_PER_RELOAD || 5);
+const MAX_GPU_MB_PER_RELOAD = Number(process.env.MAX_GPU_MB_PER_RELOAD || 25);
+
+/** RSS (MB) of the renderer + gpu processes under this browser @param {number} rootPid */
+function processRss(rootPid) {
+	const rows = execSync('ps -eo pid=,ppid=,rss=,args=', { encoding: 'utf8', maxBuffer: 64 << 20 })
+		.split('\n')
+		.map((l) => /^\s*(\d+)\s+(\d+)\s+(\d+)\s+(.*)$/.exec(l))
+		.filter((m) => m !== null)
+		.map((m) => ({ pid: +m[1], ppid: +m[2], rss: +m[3], args: m[4] }));
+	const mine = new Set([rootPid]);
+	for (let grew = true; grew; ) {
+		grew = false;
+		for (const r of rows) if (mine.has(r.ppid) && !mine.has(r.pid)) mine.add(r.pid), (grew = true);
+	}
+	const sum = (/** @type {RegExp} */ re) => Math.round(rows.filter((r) => mine.has(r.pid) && re.test(r.args)).reduce((t, r) => t + r.rss, 0) / 1024);
+	return { renderer: sum(/--type=renderer/), gpu: sum(/--type=gpu-process/) };
+}
+
+h.run(async () => {
+	const browser = await h.launch();
+	const rootPid = browser.process?.()?.pid ?? 0;
+	const A = await h.setupPage(browser, 'A');
+	const cdp = await A.page.context().newCDPSession(A.page);
+	await cdp.send('Performance.enable');
+	await cdp.send('HeapProfiler.enable');
+	const sample = async (/** @type {number} */ i) => {
+		await A.page.waitForTimeout(SETTLE_MS);
+		await cdp.send('HeapProfiler.collectGarbage');
+		await cdp.send('HeapProfiler.collectGarbage');
+		const m = Object.fromEntries((await cdp.send('Performance.getMetrics')).metrics.map((/** @type {any} */ x) => [x.name, x.value]));
+		const gl = await A.page.evaluate(() => {
+			/** @type {any} */ let r;
+			window.__stores.renderer?.subscribe?.((/** @type {any} */ v) => (r = v))?.();
+			return r?.info?.memory ?? null;
+		}).catch(() => null);
+		return {
+			reload: i,
+			heapMB: Math.round((m.JSHeapUsedSize / 1048576) * 10) / 10,
+			documents: m.Documents,
+			frames: m.Frames,
+			nodes: m.Nodes,
+			listeners: m.JSEventListeners,
+			gl,
+			...(rootPid ? processRss(rootPid) : {})
+		};
+	};
+	/** @type {any[]} */
+	const rows = [await sample(0)];
+	console.log(JSON.stringify(rows[0]));
+	let crashed = '';
+	for (let i = 1; i <= RELOADS; i++) {
+		try {
+			await h.freshReload(A);
+			await h.answerRestore(A).catch(() => false);
+		} catch (error) {
+			crashed = `reload ${i}: ${String(/** @type {any} */ (error)?.message ?? error).split('\n')[0]}`;
+			break;
+		}
+		rows.push(await sample(i));
+		console.log(JSON.stringify(rows[rows.length - 1]));
+	}
+	fs.mkdirSync(EVIDENCE, { recursive: true });
+	fs.writeFileSync(path.join(EVIDENCE, 'reload-memory.json'), JSON.stringify({ at: new Date().toISOString(), url: h.URL, rows, crashed }, null, 1));
+
+	h.check(!crashed, `the tab survives ${RELOADS} reloads (${crashed || 'all of them'})`);
+	// growth from the FIRST reload on: reload 0 -> 1 warms caches every app has
+	const from = rows[1] ?? rows[0];
+	const last = rows[rows.length - 1];
+	const n = Math.max(1, last.reload - from.reload);
+	const heapPer = (last.heapMB - from.heapMB) / n;
+	h.check(heapPer <= MAX_HEAP_MB_PER_RELOAD, `JS heap after GC grows <= ${MAX_HEAP_MB_PER_RELOAD} MB per reload (${heapPer.toFixed(1)} MB/reload: ${rows.map((r) => r.heapMB).join(' → ')})`);
+	h.check(rows.slice(1).every((r) => r.documents <= 2), `no old document is retained (live Documents per reload: ${rows.map((r) => r.documents).join(', ')})`);
+	if (last.gpu != null && from.gpu != null) {
+		const gpuPer = (last.gpu - from.gpu) / n;
+		h.check(gpuPer <= MAX_GPU_MB_PER_RELOAD, `GPU process RSS grows <= ${MAX_GPU_MB_PER_RELOAD} MB per reload (${gpuPer.toFixed(1)} MB/reload: ${rows.map((r) => r.gpu).join(' → ')})`);
+	}
+	await h.finish(browser);
+});

From 4a79a2a29b9a4b03135f3565750781ce4622b511 Mon Sep 17 00:00:00 2001
From: AlexZ005 <alexz005.info@gmail.com>
Date: Sat, 24 Oct 2026 17:26:27 +0300
Subject: [PATCH 06/46] [test] test-health-1 P4: type debt ratchet -10 (298 ->
 288)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- The reference modules' callbacks get JSDoc types (hello + button: the effect's object / base pose /
  data / clock, the click handler's object, clamp01's value) — the 10 implicit-any errors in
  src/modules/hello + src/modules/button, a fixed step of -10 as the brief asks.
- check-baseline.json 299/39 -> 288/39 (node scripts/check-ratchet.cjs --update). The full error list
  diffed against the base: nothing new, these 10 gone. JSDoc only, no behaviour change.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 check-baseline.json          | 4 ++--
 src/modules/button/module.js | 6 +++---
 src/modules/hello/module.js  | 2 +-
 3 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/check-baseline.json b/check-baseline.json
index b7dfe7ec8..c512987b8 100644
--- a/check-baseline.json
+++ b/check-baseline.json
@@ -1,6 +1,6 @@
 {
 	"comment": "27-I: the svelte-check floor, read ONLY by scripts/check-ratchet.cjs. It used to be hardcoded in release.yml's shell block, where it went stale (362 while the tree measured 359). Ratchet it DOWN whenever a change legitimately removes errors - that is the project convention, and --update does it in one command.",
-	"errors": 299,
+	"errors": 288,
 	"warnings": 39,
-	"measured": "2026-10-11"
+	"measured": "2026-10-24"
 }
diff --git a/src/modules/button/module.js b/src/modules/button/module.js
index a45f6cced..e500b6b7f 100644
--- a/src/modules/button/module.js
+++ b/src/modules/button/module.js
@@ -52,7 +52,7 @@ export default {
 		);
 
 		// clicking the chosen button object presses the node instead of selecting
-		api.registerClickHandler((object) => {
+		api.registerClickHandler((/** @type {import('three').Object3D} */ object) => {
 			const group = api.objectsGroup();
 			if (!group) return false;
 			let top = object;
@@ -67,11 +67,11 @@ export default {
 		});
 
 		// door effect: slide the connected object up while pressed
-		api.registerEffect('buttontrigger', (object, base, data, time) => {
+		api.registerEffect('buttontrigger', /** @param {import('three').Object3D} object @param {{pos: number[], rot: number[], scale: number[]}} base @param {Record<string, any>} data @param {number} time */ (object, base, data, time) => {
 			const height = data.height ?? 2;
 			const duration = Math.max(Math.abs(height) / 2, 0.15); // ~2 m/s
 			const at = data.at ?? 0;
-			const clamp01 = (value) => Math.min(Math.max(value, 0), 1);
+			const clamp01 = (/** @type {number} */ value) => Math.min(Math.max(value, 0), 1);
 			let lift;
 			if (data.pressed) {
 				lift = clamp01((time - at) / duration);
diff --git a/src/modules/hello/module.js b/src/modules/hello/module.js
index 5ae42ef3f..99cb9663d 100644
--- a/src/modules/hello/module.js
+++ b/src/modules/hello/module.js
@@ -24,7 +24,7 @@ export default {
 			]
 		});
 
-		api.registerEffect('wave', (object, base, data, time) => {
+		api.registerEffect('wave', /** @param {import('three').Object3D} object @param {{pos: number[], rot: number[], scale: number[]}} base @param {Record<string, any>} data @param {number} time */ (object, base, data, time) => {
 			const amplitude = data.amplitude ?? 0.4;
 			const speed = data.speed ?? 2;
 			object.rotation.z = base.rot[2] + Math.sin(time * speed) * amplitude;

From b1487f62b7f55468ee86ea7ac14f6085d12bc6b9 Mon Sep 17 00:00:00 2001
From: AlexZ005 <alexz005.info@gmail.com>
Date: Sat, 24 Oct 2026 18:50:39 +0300
Subject: [PATCH 07/46] [test] test-health-1 P2: lock-search re-recorded
 (Storage section + Play here rows)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Only ADDED rows, both intended feat/60 features that did not re-record the fixture: the Settings Storage section (7827405f, 60 Q6: Storage / Storage breakdown / Cached downloads / Cache size limit) and the "Play here — start from the editor camera" shortcut row (7669ad73, 60 Q1). LOCK_RECORD=1 run, fixture diff checked to hold only those rows; then green 11/0 (e2e/v1). Quarantine entry dropped.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 tests/e2e/fixtures/lock/search.json | 29 ++++++++++++++++++++++++-----
 tests/e2e/quarantine.json           |  1 -
 2 files changed, 24 insertions(+), 6 deletions(-)

diff --git a/tests/e2e/fixtures/lock/search.json b/tests/e2e/fixtures/lock/search.json
index eec24d57d..c303cecd5 100644
--- a/tests/e2e/fixtures/lock/search.json
+++ b/tests/e2e/fixtures/lock/search.json
@@ -1,5 +1,5 @@
 {
-	"recordedAt": "2026-10-22T17:48:57.949Z",
+	"recordedAt": "2026-10-24T15:10:13.838Z",
 	"settings": {
 		"Theme": {
 			"rows": [
@@ -1776,10 +1776,12 @@
 		},
 		"Storage used": {
 			"rows": [
+				"Cache size limit",
 				"Storage used"
 			],
 			"sections": [
-				"Explorer"
+				"Explorer",
+				"Storage"
 			]
 		},
 		"Optimize big models automatically": {
@@ -2971,11 +2973,13 @@
 		"network": {
 			"rows": [
 				"Apply changes",
+				"Cached downloads",
 				"Session size",
 				"Signaling server",
 				"Statistics card"
 			],
 			"sections": [
+				"Storage",
 				"VR",
 				"Connection"
 			]
@@ -3105,18 +3109,23 @@
 		},
 		"disk": {
 			"rows": [
+				"Storage breakdown",
 				"Storage used"
 			],
 			"sections": [
-				"Explorer"
+				"Explorer",
+				"Storage"
 			]
 		},
 		"quota": {
 			"rows": [
+				"Cache size limit",
+				"Storage breakdown",
 				"Storage used"
 			],
 			"sections": [
-				"Explorer"
+				"Explorer",
+				"Storage"
 			]
 		},
 		"toolbar": {
@@ -3332,6 +3341,7 @@
 				"Paste at the cursor",
 				"Pinch zoom",
 				"Play / Enter VR·AR (right-click the play button for modes)",
+				"Play here — start from the editor camera",
 				"Previous element mode",
 				"Push to talk while the mic toggle is off",
 				"Race: back on the road",
@@ -3470,6 +3480,8 @@
 		},
 		"files": {
 			"rows": [
+				"Cache size limit",
+				"Cached downloads",
 				"Delete without asking",
 				"Deleted files log",
 				"Download shared files automatically",
@@ -3484,7 +3496,8 @@
 				"Who can unshare a file"
 			],
 			"sections": [
-				"Explorer"
+				"Explorer",
+				"Storage"
 			]
 		},
 		"library": {
@@ -3740,6 +3753,7 @@
 				"Object list: show / bring to front / hide",
 				"Paste at the cursor",
 				"Play / Enter VR·AR (right-click the play button for modes)",
+				"Play here — start from the editor camera",
 				"Previous element mode",
 				"Push to talk while the mic toggle is off",
 				"Race: back on the road",
@@ -3862,6 +3876,7 @@
 				"Object list: show / bring to front / hide",
 				"Paste at the cursor",
 				"Play / Enter VR·AR (right-click the play button for modes)",
+				"Play here — start from the editor camera",
 				"Previous element mode",
 				"Push to talk while the mic toggle is off",
 				"Race: back on the road",
@@ -3985,6 +4000,7 @@
 				"Object list: show / bring to front / hide",
 				"Paste at the cursor",
 				"Play / Enter VR·AR (right-click the play button for modes)",
+				"Play here — start from the editor camera",
 				"Previous element mode",
 				"Push to talk while the mic toggle is off",
 				"Race: back on the road",
@@ -4419,6 +4435,7 @@
 		},
 		"ai": {
 			"rows": [
+				"Cached downloads",
 				"Colocation probe",
 				"Compress textures (KTX2)",
 				"Download shared files automatically",
@@ -4444,6 +4461,7 @@
 				"Reset tips",
 				"Reverse trackpad pan",
 				"Stance",
+				"Storage breakdown",
 				"Storage used",
 				"Teleport",
 				"Texture threshold",
@@ -4457,6 +4475,7 @@
 				"Shortcuts",
 				"Scene",
 				"Explorer",
+				"Storage",
 				"Import",
 				"Export",
 				"VR",
diff --git a/tests/e2e/quarantine.json b/tests/e2e/quarantine.json
index c468d07c3..8355032de 100644
--- a/tests/e2e/quarantine.json
+++ b/tests/e2e/quarantine.json
@@ -37,7 +37,6 @@
 		{"suite": "game-loop-v4", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "game-sky-run", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "kit-instancing", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
-		{"suite": "lock-search", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "mesh-toolbox-redesign", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "model-preview", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "net-stress", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},

From cce8f197f1bc05693c5890222cfa81ed60e63c13 Mon Sep 17 00:00:00 2001
From: AlexZ005 <alexz005.info@gmail.com>
Date: Sat, 24 Oct 2026 18:50:39 +0300
Subject: [PATCH 08/46] [test] test-health-1 P2: panels asserts Save options,
 not the removed .json dropdown
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The save format picker has been the burger's Save options dialog since 41b (15584b1c/27576110/d4176aa4); there is no /json/i button to click. Open #save-options-open and read #save-format's options (Project, Scene — GLTF/JSON are opt-in toggles). Green 13/0 (e2e/v1); quarantine entry dropped.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 tests/e2e/panels.test.cjs | 12 ++++++++----
 tests/e2e/quarantine.json |  1 -
 2 files changed, 8 insertions(+), 5 deletions(-)

diff --git a/tests/e2e/panels.test.cjs b/tests/e2e/panels.test.cjs
index 40e51f876..626d14b42 100644
--- a/tests/e2e/panels.test.cjs
+++ b/tests/e2e/panels.test.cjs
@@ -57,10 +57,14 @@ h.run(async () => {
 	h.check(await A.page.getByText('Objects', { exact: false }).first().isVisible(), 'object list header visible');
 	h.check(await A.page.locator('#object-search').isVisible(), 'search survived the restyle');
 
-	// save dropdown format picker still opens
-	await A.page.getByRole('button', { name: /json/i }).first().click();
-	await A.page.waitForTimeout(300);
-	h.check(await A.page.getByText('GLTF', { exact: true }).isVisible(), 'save format dropdown opens');
+	// the save format picker still opens — Save options (the burger's Save ▾) since 41b replaced the
+	// old .json dropdown; GLTF is behind "Offer GLTF", so assert the two formats it always offers
+	await A.page.evaluate(() => window.__stores.closeMenu.set(false));
+	await A.page.waitForSelector('#save-options-open', { timeout: 5000 });
+	await A.page.locator('#save-options-open').click();
+	await A.page.waitForSelector('#save-options-modal', { state: 'visible', timeout: 5000 });
+	const formats = await A.page.evaluate(() => [...document.querySelectorAll('#save-format .seg-opt')].map((b) => b.textContent?.trim()));
+	h.check(formats.includes('Project') && formats.includes('Scene'), `save format picker opens (${JSON.stringify(formats)})`);
 
 	await h.finish(browser);
 });
diff --git a/tests/e2e/quarantine.json b/tests/e2e/quarantine.json
index 8355032de..c3304f515 100644
--- a/tests/e2e/quarantine.json
+++ b/tests/e2e/quarantine.json
@@ -40,7 +40,6 @@
 		{"suite": "mesh-toolbox-redesign", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "model-preview", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "net-stress", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
-		{"suite": "panels", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "phone-sheets", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "physics-discoverability", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "physics-kinematic", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},

From 3a2199838fd5b9e06a33c300cdcb61127003422b Mon Sep 17 00:00:00 2001
From: AlexZ005 <alexz005.info@gmail.com>
Date: Sat, 24 Oct 2026 18:50:39 +0300
Subject: [PATCH 09/46] [test] test-health-1 P2: physics-discoverability starts
 from bare boxes

95df3a66 makes every /create box dynamic, so the suite's 'nothing has physics yet' premise was false and all 4 checks went red. Delete userData.physics on the three boxes first (editor-modes / fluid-flows / fb-water-sync already do). Green 11/0 (e2e/v1); quarantine entry dropped.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 tests/e2e/physics-discoverability.test.cjs | 2 ++
 tests/e2e/quarantine.json                  | 1 -
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/tests/e2e/physics-discoverability.test.cjs b/tests/e2e/physics-discoverability.test.cjs
index 58405c423..06e4564a0 100644
--- a/tests/e2e/physics-discoverability.test.cjs
+++ b/tests/e2e/physics-discoverability.test.cjs
@@ -29,6 +29,8 @@ h.run(async () => {
 		b1.name = 'PropsBox';
 		b2.name = 'FlowBox';
 		b3.name = 'BareBox';
+		// /create makes every box dynamic since 95df3a66 — this suite needs them bare to start with
+		for (const b of [b1, b2, b3]) delete b.userData.physics;
 		// spread them out — overlapping colliders would explode the fallback sim
 		b1.position.set(0, 0.5, 0);
 		b2.position.set(3, 0.5, 0);
diff --git a/tests/e2e/quarantine.json b/tests/e2e/quarantine.json
index c3304f515..ac87d8ad5 100644
--- a/tests/e2e/quarantine.json
+++ b/tests/e2e/quarantine.json
@@ -41,7 +41,6 @@
 		{"suite": "model-preview", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "net-stress", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "phone-sheets", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
-		{"suite": "physics-discoverability", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "physics-kinematic", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "scene-budget", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "scene-post", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},

From 3fd133b982f8626f865c7bcfbb480c1e865e5a47 Mon Sep 17 00:00:00 2001
From: AlexZ005 <alexz005.info@gmail.com>
Date: Sat, 24 Oct 2026 18:50:39 +0300
Subject: [PATCH 10/46] [test] test-health-1 P2: mesh-toolbox-redesign drives
 the SheetGrip grab bar

58db817a replaced .tbx-sheet-grab with the shared ui/SheetGrip (40 F1). Find the grabber as .tbx-sheet-resize [data-sheet-grip] and dispatch the pointer gesture on it (sheetDrag listens on the grip zone; the handle button is excluded from its interactive filter, so events bubble to it). Green 136/0 (e2e/v1); quarantine entry dropped.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 tests/e2e/mesh-toolbox-redesign.test.cjs | 6 +++---
 tests/e2e/quarantine.json                | 1 -
 2 files changed, 3 insertions(+), 4 deletions(-)

diff --git a/tests/e2e/mesh-toolbox-redesign.test.cjs b/tests/e2e/mesh-toolbox-redesign.test.cjs
index 08bcc31b3..4262d0be5 100644
--- a/tests/e2e/mesh-toolbox-redesign.test.cjs
+++ b/tests/e2e/mesh-toolbox-redesign.test.cjs
@@ -826,7 +826,7 @@ h.run(async () => {
 		const r = el.getBoundingClientRect();
 		const body = el.querySelector('.toolbox-body');
 		const grip = el.querySelector('.dw-resize');
-		const grab = el.querySelector('.tbx-sheet-grab');
+		const grab = el.querySelector('.tbx-sheet-resize [data-sheet-grip]'); // ui/SheetGrip since 58db817a
 		const tabs = el.querySelector('.tbx-tabs');
 		return {
 			left: Math.round(r.left),
@@ -834,7 +834,7 @@ h.run(async () => {
 			bottom: Math.round(r.bottom),
 			top: Math.round(r.top),
 			gripHidden: !grip || getComputedStyle(grip).display === 'none',
-			hasGrabber: !!grab && getComputedStyle(grab.parentElement).display !== 'none',
+			hasGrabber: !!grab && grab.offsetHeight > 0,
 			bodyScrolls: getComputedStyle(body).overflowY === 'auto',
 			// tabs must stay OUT of the scrolling area so they are always reachable
 			tabsPinned: !body.contains(tabs)
@@ -851,7 +851,7 @@ h.run(async () => {
 	// the grabber resizes and the height persists
 	const resized = await M.page.evaluate(async () => {
 		const el = document.querySelector('#mesh-edit-popup');
-		const handle = el.querySelector('.tbx-sheet-resize');
+		const handle = el.querySelector('.tbx-sheet-resize [data-sheet-grip]'); // the gesture is sheetDrag on its zone; events bubble to it
 		const before = Math.round(el.getBoundingClientRect().height);
 		const send = (type, y) =>
 			handle.dispatchEvent(new PointerEvent(type, { bubbles: true, pointerId: 7, clientY: y }));
diff --git a/tests/e2e/quarantine.json b/tests/e2e/quarantine.json
index ac87d8ad5..0774b84da 100644
--- a/tests/e2e/quarantine.json
+++ b/tests/e2e/quarantine.json
@@ -37,7 +37,6 @@
 		{"suite": "game-loop-v4", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "game-sky-run", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "kit-instancing", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
-		{"suite": "mesh-toolbox-redesign", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "model-preview", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "net-stress", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "phone-sheets", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},

From f986e9e5308ba325f2db3d91a327d07b041dbbaf Mon Sep 17 00:00:00 2001
From: AlexZ005 <alexz005.info@gmail.com>
Date: Sat, 24 Oct 2026 18:50:39 +0300
Subject: [PATCH 11/46] [test] test-health-1 P2: model-preview expects the file
 preview window for a library object

R22 round 12 (cefc68ee): double-clicking a library OBJECT opens #image-preview-window with imagePreviewTarget.kind 'object'; ModelPreviewWindow is the prefab shelf's now. Wait for that window (not a fixed 900 ms) and assert the kind. Green 8/0 (e2e/v1); quarantine entry dropped.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 tests/e2e/model-preview.test.cjs | 12 +++++++-----
 tests/e2e/quarantine.json        |  1 -
 2 files changed, 7 insertions(+), 6 deletions(-)

diff --git a/tests/e2e/model-preview.test.cjs b/tests/e2e/model-preview.test.cjs
index 60dd7c587..b23f74de5 100644
--- a/tests/e2e/model-preview.test.cjs
+++ b/tests/e2e/model-preview.test.cjs
@@ -51,12 +51,14 @@ h.run(async () => {
 	await A.page.evaluate(() => window.__stores.enable3dPreview.set(false));
 	await A.page.locator('#explorer-slot').click();
 	await A.page.waitForTimeout(500);
+	// R22 round 12 (cefc68ee): a library OBJECT double-clicks into the file preview window
+	// (#image-preview-window, target kind 'object'); ModelPreviewWindow is the prefab shelf's now
 	await A.page.locator('#explorer-list .explorer-card', { hasText: 'testbox' }).first().dblclick();
-	await A.page.waitForTimeout(900);
-	h.check(
-		(await A.page.locator('#model-preview-window').count()) === 1,
-		'double-click opens the popup even with the toggle off (P1)'
-	);
+	const opened = await A.page
+		.waitForSelector('#image-preview-window', { timeout: 8000 })
+		.then(() => true, () => false);
+	const kind = await A.page.evaluate(() => new Promise((r) => window.__stores.fileWindows.imagePreviewTarget.subscribe((t) => r(t?.kind ?? null))()));
+	h.check(opened && kind === 'object', `double-click opens the preview even with the toggle off (P1) (window ${opened}, kind ${kind})`);
 
 	await h.finish(browser);
 });
diff --git a/tests/e2e/quarantine.json b/tests/e2e/quarantine.json
index 0774b84da..b357746df 100644
--- a/tests/e2e/quarantine.json
+++ b/tests/e2e/quarantine.json
@@ -37,7 +37,6 @@
 		{"suite": "game-loop-v4", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "game-sky-run", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "kit-instancing", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
-		{"suite": "model-preview", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "net-stress", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "phone-sheets", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "physics-kinematic", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},

From 4a695bae52e26e51ed469b91939be8e902b2969a Mon Sep 17 00:00:00 2001
From: AlexZ005 <alexz005.info@gmail.com>
Date: Sat, 24 Oct 2026 18:50:39 +0300
Subject: [PATCH 12/46] =?UTF-8?q?[test]=20test-health-1=20P2:=20five=20sui?=
 =?UTF-8?q?tes=20verified=20green=20after=20e77ca3f7=20=E2=80=94=20quarant?=
 =?UTF-8?q?ine=20entries=20dropped?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

e77ca3f7 carried the fixes unverified; e2e/v1 ran each green on the dev server:
- flow-physics-nodes 10/0 (stale: Base made static, 95df3a66 made every /create box dynamic)
- game-sky-run 57/0 (stale: the vignette is a level since e16c7413 — ON reads 'high')
- game-loop-v4 19/0 (stale: A travels to the Lobby first; rooms are content partitions since R22 round 30/34)
- collider-live 12/0 (timing: waits on the body's speed, not 2500 ms — physics slow-motion on software GL)
- animation-sync 24/0 (timing: bounded poll until both peers ended the once-clip — the third page's frame lag)

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 tests/e2e/quarantine.json | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/tests/e2e/quarantine.json b/tests/e2e/quarantine.json
index b357746df..ae3440be9 100644
--- a/tests/e2e/quarantine.json
+++ b/tests/e2e/quarantine.json
@@ -26,16 +26,11 @@
 		{"suite": "animation-node", "check": "so the door closes rather than restarting", "reason": "~1.7 fps under load: a 900 ms window holds 1-2 frames; 35/0 on a GPU slot (57-clips)", "owner": "test-health (standing lane)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "dock-strip-drop", "check": "6.3 opening an Explorer image brings the docked editor forward", "reason": "red 1/2 on both 1.41 and 1.40 production, green on base in deps-1 ab1 (53-int)", "owner": "test-health (standing lane)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "toolbar-slots-42", "check": "I9: each corner shows ONE", "reason": "known deployed flake (touch reorder, unfolded dark); same 2 reds on production 1.39 (49-int, 53-int)", "owner": "test-health (standing lane)", "since": "2026-10-23", "review": "2026-11-07"},
-		{"suite": "animation-sync", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "behaviours", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "char-controller", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
-		{"suite": "collider-live", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "context-menu-redesign", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "edit-move-games", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "fb-water", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
-		{"suite": "flow-physics-nodes", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
-		{"suite": "game-loop-v4", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
-		{"suite": "game-sky-run", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "kit-instancing", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "net-stress", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "phone-sheets", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},

From b8e60ba98f3d4750d3da6a2c60cd89bc384423e5 Mon Sep 17 00:00:00 2001
From: AlexZ005 <alexz005.info@gmail.com>
Date: Sat, 24 Oct 2026 19:01:42 +0300
Subject: [PATCH 13/46] =?UTF-8?q?[test]=20test-health-1=20P2:=20behaviours?=
 =?UTF-8?q?=20=E2=80=94=20dial=20the=20live=20id,=20and=20let=20B's=20view?=
 =?UTF-8?q?=20tick=20before=20the=20kill?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Two causes. (1) e77ca3f7's helpers.connect dials the live id once both signaling links opened (a re-rolled id on 'unavailable-id' left the suite dialling a dead one). (2) The fired glow is 'changed since this view's FIRST live tick'; on B, the authority, the died handler fires the moment we kill, so a kill that beat B's first 100 ms tick landed in its baseline and never glowed (0 of 10 samples). Wait for B's state nodes to read live values first — the wait A already makes. Green 46/0 (e2e/v2); quarantine entry dropped.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 tests/e2e/behaviours.test.cjs | 4 ++++
 tests/e2e/quarantine.json     | 1 -
 2 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/tests/e2e/behaviours.test.cjs b/tests/e2e/behaviours.test.cjs
index f942d412b..5d6c379a2 100644
--- a/tests/e2e/behaviours.test.cjs
+++ b/tests/e2e/behaviours.test.cjs
@@ -121,6 +121,10 @@ h.run(async () => {
 		s.behaviourViewOpen.set({ id: i, graphId: 'scene' });
 	}, wid);
 	await B.page.waitForSelector('#behaviour-view [data-bview-kind="state"]', { timeout: 10000 });
+	// the glow is "changed since this view's FIRST live tick" — on the authority the died handler
+	// fires the moment we kill, so a kill that beats B's first 100 ms tick lands in its baseline
+	// and never glows (0 of 10 samples). Live values on the state nodes = that tick has run.
+	await h.eventually(() => B.page.$$eval('#behaviour-view [data-bview-kind="state"] [data-bview-value]', (els) => els.map((e) => e.textContent?.trim())), (v) => v.join(',') === '1,2', 'B\'s view is live before the kill (wave 1, alive 2)', 5000);
 	const SAMPLE = () =>
 		new Promise((resolve) => {
 			/** @type {any[]} */
diff --git a/tests/e2e/quarantine.json b/tests/e2e/quarantine.json
index ae3440be9..b68dd259f 100644
--- a/tests/e2e/quarantine.json
+++ b/tests/e2e/quarantine.json
@@ -26,7 +26,6 @@
 		{"suite": "animation-node", "check": "so the door closes rather than restarting", "reason": "~1.7 fps under load: a 900 ms window holds 1-2 frames; 35/0 on a GPU slot (57-clips)", "owner": "test-health (standing lane)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "dock-strip-drop", "check": "6.3 opening an Explorer image brings the docked editor forward", "reason": "red 1/2 on both 1.41 and 1.40 production, green on base in deps-1 ab1 (53-int)", "owner": "test-health (standing lane)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "toolbar-slots-42", "check": "I9: each corner shows ONE", "reason": "known deployed flake (touch reorder, unfolded dark); same 2 reds on production 1.39 (49-int, 53-int)", "owner": "test-health (standing lane)", "since": "2026-10-23", "review": "2026-11-07"},
-		{"suite": "behaviours", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "char-controller", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "context-menu-redesign", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "edit-move-games", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},

From 5ac7d8094307538ff25501cdf3e3a4c1ae39465f Mon Sep 17 00:00:00 2001
From: AlexZ005 <alexz005.info@gmail.com>
Date: Sat, 24 Oct 2026 19:06:39 +0300
Subject: [PATCH 14/46] =?UTF-8?q?[test]=20test-health-1=20P2:=20fb-water?=
 =?UTF-8?q?=20gates=20again=20=E2=80=94=20four=20software-GL=20checks=20qu?=
 =?UTF-8?q?arantined=20by=20name?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The :431 crash (__stores undefined after a load) did not reproduce: e2e/v2 ran the whole suite, 61 pass / 4 fail. The whole-suite entry goes; the four reds get check entries with the root cause:
- a foam body floats high / ...is never swamped / ...upright: rapier keeps real time only down to 7.5 fps (at most 8 substeps of 1/60 s per frame), and software GL renders ~4, so the hull lags waves that follow the session clock. Green needs a GPU slot; nothing in the test can supply the frame rate.
- underwater: aligned: flips run to run (green on the base) — read 1 s after a water-quality switch while the shaders recompile.
NOT fixed: kept visible in the quarantine tier with an owner and a 2026-11-07 review.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 tests/e2e/quarantine.json | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/tests/e2e/quarantine.json b/tests/e2e/quarantine.json
index b68dd259f..ff3f8b593 100644
--- a/tests/e2e/quarantine.json
+++ b/tests/e2e/quarantine.json
@@ -29,7 +29,10 @@
 		{"suite": "char-controller", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "context-menu-redesign", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "edit-move-games", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
-		{"suite": "fb-water", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
+		{"suite": "fb-water", "check": "a foam body floats high", "reason": "software GL (~4 fps): rapier keeps real time only down to 7.5 fps (8 substeps of 1/60 s per frame), so the hull lags waves that follow the session clock — green needs a GPU slot; the test cannot fix the frame rate (test-health-1, e2e/v2)", "owner": "test-health (standing lane)", "since": "2026-10-24", "review": "2026-11-07"},
+		{"suite": "fb-water", "check": "...is never swamped", "reason": "software GL (~4 fps): rapier keeps real time only down to 7.5 fps (8 substeps of 1/60 s per frame), so the hull lags waves that follow the session clock — green needs a GPU slot; the test cannot fix the frame rate (test-health-1, e2e/v2)", "owner": "test-health (standing lane)", "since": "2026-10-24", "review": "2026-11-07"},
+		{"suite": "fb-water", "check": "...upright", "reason": "software GL (~4 fps): rapier keeps real time only down to 7.5 fps (8 substeps of 1/60 s per frame), so the hull lags waves that follow the session clock — green needs a GPU slot; the test cannot fix the frame rate (test-health-1, e2e/v2)", "owner": "test-health (standing lane)", "since": "2026-10-24", "review": "2026-11-07"},
+		{"suite": "fb-water", "check": "underwater: aligned", "reason": "flips run to run (green on the base, 68.9 vs 37.4 px in e2e/v2): outline vs object read 1 s after a water-quality switch, while the shaders recompile at ~4 fps", "owner": "test-health (standing lane)", "since": "2026-10-24", "review": "2026-11-07"},
 		{"suite": "kit-instancing", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "net-stress", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "phone-sheets", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},

From 42e751337116d77c90a83aef2a50904c019f0873 Mon Sep 17 00:00:00 2001
From: AlexZ005 <alexz005.info@gmail.com>
Date: Sat, 24 Oct 2026 19:18:33 +0300
Subject: [PATCH 15/46] [test] test-health-1 P2: scene-post-effects spies the
 per-connection asset send

4.5 spied peers.send for the LUT's assetfile, but assetShare sends per OPEN CONNECTION since 9c81d069 (chunked transfers + the transfer ledger), and nobody has joined yet in section 4. Give the spy an open connection to send on. Green 43/0 (e2e/v3b).

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 tests/e2e/quarantine.json             | 1 -
 tests/e2e/scene-post-effects.test.cjs | 8 +++++++-
 2 files changed, 7 insertions(+), 2 deletions(-)

diff --git a/tests/e2e/quarantine.json b/tests/e2e/quarantine.json
index ff3f8b593..8e46cf237 100644
--- a/tests/e2e/quarantine.json
+++ b/tests/e2e/quarantine.json
@@ -39,7 +39,6 @@
 		{"suite": "physics-kinematic", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "scene-budget", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "scene-post", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
-		{"suite": "scene-post-effects", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "search-menus", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "settings-layout", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "shader-sync", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
diff --git a/tests/e2e/scene-post-effects.test.cjs b/tests/e2e/scene-post-effects.test.cjs
index fc0c4f700..ae5c1513e 100644
--- a/tests/e2e/scene-post-effects.test.cjs
+++ b/tests/e2e/scene-post-effects.test.cjs
@@ -248,7 +248,13 @@ h.run(async () => {
 			let original = null;
 			peers.subscribe((p) => (original = p))();
 			const sent = [];
-			peers.set({ ...original, send: (m) => sent.push(m) });
+			// assetShare sends per OPEN CONNECTION since 9c81d069 (chunked transfers + the ledger), not
+			// through peers.send — and nobody has joined yet in this section, so give it one to send on
+			peers.set({
+				...original,
+				send: (m) => sent.push(m),
+				connections: { ...(original.connections ?? {}), spy: { open: true, send: (m) => sent.push(m) } }
+			});
 			document.querySelector('#post-param-' + id + '-lut').click();
 			await new Promise((r) => setTimeout(r, 300));
 			const rows = [...document.querySelectorAll('.ts-list [role="option"]')];

From c8b1807079a4a72e715a64c46ecd684763a072cf Mon Sep 17 00:00:00 2001
From: AlexZ005 <alexz005.info@gmail.com>
Date: Sat, 24 Oct 2026 19:18:33 +0300
Subject: [PATCH 16/46] [test] test-health-1 P2: post-play-mode measures the
 fill on a chrome-free region
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

2.2 / 4.3 read a constant 20780 px 'off the fill colour' on the full frame: play mode composites the glass bar (PlayBanner, 930ecc44) and the reticle over the canvas — helpers.grabFrame's own rule is that a colour metric looks at a chrome-free region. Clip left of centre, clear of the bar, HUD and reticle (2.1's whole-frame delta unchanged). Green 15/0 (e2e/v3b).

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 tests/e2e/post-play-mode.test.cjs | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/tests/e2e/post-play-mode.test.cjs b/tests/e2e/post-play-mode.test.cjs
index fcd1c2f7b..89721cd26 100644
--- a/tests/e2e/post-play-mode.test.cjs
+++ b/tests/e2e/post-play-mode.test.cjs
@@ -100,7 +100,12 @@ h.run(async () => {
 			(delta.changed ?? -1) +
 			' changed pixels)'
 	);
-	const off = await h.framePixelsOffColor(page, after, FILL_RGB);
+	// colour is measured on a CHROME-FREE region (helpers.grabFrame's rule): play mode composites
+	// the glass bar (PlayBanner, 930ecc44) and the reticle over the canvas, and the full frame read a
+	// constant 20780 px "off the fill" — left of centre, clear of the bar, the HUD and the reticle
+	const view = await page.viewportSize();
+	const fillClip = { x: Math.round(view.width * 0.1), y: Math.round(view.height * 0.35), width: Math.round(view.width * 0.25), height: Math.round(view.height * 0.3) };
+	const off = await h.framePixelsOffColor(page, await h.grabFrame(A, fillClip), FILL_RGB);
 	h.check(
 		off.fraction < 0.02,
 		'2.2 ...and it is the effect that painted it (' +
@@ -177,7 +182,7 @@ h.run(async () => {
 	// and putting the look back brings the composer back
 	await page.evaluate(() => window.__stores.scenePost.addPostEffect('test-play-fill'));
 	await page.waitForTimeout(1200);
-	const restored = await h.grabFrame(A);
+	const restored = await h.grabFrame(A, fillClip);
 	const restoredOff = await h.framePixelsOffColor(page, restored, FILL_RGB);
 	h.check(
 		restoredOff.fraction < 0.02,

From 7ee964333d4a170357fb2dd2aecf0397c9f5e651 Mon Sep 17 00:00:00 2001
From: AlexZ005 <alexz005.info@gmail.com>
Date: Sat, 24 Oct 2026 19:18:33 +0300
Subject: [PATCH 17/46] =?UTF-8?q?[test]=20test-health-1=20P2:=20sound-node?=
 =?UTF-8?q?=20=E2=80=94=20no=20Shared=20folder,=20and=20the=20editor=20fol?=
 =?UTF-8?q?lows=20the=20selection?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Two stale assumptions: pulled bytes go to the shared row's folder or the root since 186248ba (R22 round 9 removed the stray 'Shared' folder); and since flow v2 H1 (b2350b75) the node editor shows the SELECTED object's graph, so after /create box it opened the box's empty flow and '▶ Play' never appeared — deselect first, and let the locator wait instead of 900 ms. Green 7/0 (e2e/v3b); quarantine entry dropped.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 tests/e2e/quarantine.json     |  1 -
 tests/e2e/sound-node.test.cjs | 10 +++++++---
 2 files changed, 7 insertions(+), 4 deletions(-)

diff --git a/tests/e2e/quarantine.json b/tests/e2e/quarantine.json
index 8e46cf237..af4eb39ec 100644
--- a/tests/e2e/quarantine.json
+++ b/tests/e2e/quarantine.json
@@ -42,7 +42,6 @@
 		{"suite": "search-menus", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "settings-layout", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "shader-sync", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
-		{"suite": "sound-node", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "themes", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "timeline-export", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "touch-actions", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
diff --git a/tests/e2e/sound-node.test.cjs b/tests/e2e/sound-node.test.cjs
index 467e377f8..0c2a4445f 100644
--- a/tests/e2e/sound-node.test.cjs
+++ b/tests/e2e/sound-node.test.cjs
@@ -88,7 +88,9 @@ h.run(async () => {
 			}),
 		hash
 	);
-	h.check(bShared === 'Shared', `pulled bytes land in the Shared folder (${bShared})`);
+	// no stray 'Shared' folder since 186248ba (R22 round 9): pulled bytes take the shared row's folder,
+	// and A imported this one at the library root
+	h.check(bShared === null, `pulled bytes land where the shared row says — the root here, no 'Shared' folder (${bShared})`);
 	await h.eventually(
 		() => entriesOn(B.page),
 		(entries) => entries.length === 1 && entries[0].buffered,
@@ -96,9 +98,11 @@ h.run(async () => {
 	);
 
 	// Play toggles through the REAL node button and replicates as node data
+	// the editor shows the SELECTED object's graph since flow v2 H1 (b2350b75), and /create selected
+	// the box — deselect so it opens on the scene graph that holds the sound node
+	await A.page.evaluate(() => window.__stores.objectActions.deselectObject());
 	await A.page.locator('p[title="Node editor (N)"]').click();
-	await A.page.waitForTimeout(900);
-	await A.page.locator('.node-card button', { hasText: '▶ Play' }).click();
+	await A.page.locator('.node-card button', { hasText: '▶ Play' }).click(); // the locator waits for it
 	await A.page.waitForTimeout(900);
 	aEntries = await entriesOn(A.page);
 	h.check(aEntries[0]?.playing === true, 'Play starts the source on A');

From fffefb41ce27b21f48fd424a70224ba6f878c0a6 Mon Sep 17 00:00:00 2001
From: AlexZ005 <alexz005.info@gmail.com>
Date: Sat, 24 Oct 2026 19:18:33 +0300
Subject: [PATCH 18/46] [test] test-health-1 P2: themes expects tailwind 4's
 gray-800
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Dark mode does not remap .bg-gray-800, so the probe reads tailwind's own value — oklch(0.278 0.033 256.848) since f3c8ef62 (tailwind 3.4 -> 4.3), not tailwind 3's rgb(31, 41, 55). Green 12/0 (e2e/v3b); quarantine entry dropped.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 tests/e2e/quarantine.json | 1 -
 tests/e2e/themes.test.cjs | 3 ++-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/e2e/quarantine.json b/tests/e2e/quarantine.json
index af4eb39ec..88ac243a9 100644
--- a/tests/e2e/quarantine.json
+++ b/tests/e2e/quarantine.json
@@ -42,7 +42,6 @@
 		{"suite": "search-menus", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "settings-layout", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "shader-sync", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
-		{"suite": "themes", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "timeline-export", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "touch-actions", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "water-migration", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"}
diff --git a/tests/e2e/themes.test.cjs b/tests/e2e/themes.test.cjs
index 28ca4c9eb..fd9b32170 100644
--- a/tests/e2e/themes.test.cjs
+++ b/tests/e2e/themes.test.cjs
@@ -45,7 +45,8 @@ h.run(async () => {
 
 	const dark = await probe('dark');
 	h.check(
-		dark.dataTheme === 'dark' && dark.dark && dark.surface === 'rgb(31, 41, 55)',
+		// tailwind 4's gray-800 (f3c8ef62, tailwind 3.4 -> 4.3); dark mode does not remap .bg-gray-800
+		dark.dataTheme === 'dark' && dark.dark && dark.surface === 'oklch(0.278 0.033 256.848)',
 		`dark is the authored look (surface ${dark.surface})`
 	);
 

From edcc56d20955a55b51c070857fcc685f00fd61fd Mon Sep 17 00:00:00 2001
From: AlexZ005 <alexz005.info@gmail.com>
Date: Sat, 24 Oct 2026 19:18:33 +0300
Subject: [PATCH 19/46] =?UTF-8?q?[test]=20test-health-1=20P2:=20hud-editor?=
 =?UTF-8?q?=20=E2=80=94=20'hud'=20is=20a=20FLOW=5FFAMILY=20member,=20where?=
 =?UTF-8?q?ver=20it=20sits?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The check pinned it as the SIXTH member; the timeline joined the family after it (896cdb93). Membership is the claim. Green 35/0 (e2e/v3b).

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 tests/e2e/hud-editor.test.cjs | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/tests/e2e/hud-editor.test.cjs b/tests/e2e/hud-editor.test.cjs
index ebcf67712..e84997b11 100644
--- a/tests/e2e/hud-editor.test.cjs
+++ b/tests/e2e/hud-editor.test.cjs
@@ -19,11 +19,12 @@ h.run(async () => {
 	const page = A.page;
 	await page.waitForFunction(() => !!window.__stores?.hudDocs, { timeout: 30000 });
 
-	// ---- 1. it is the 6th FLOW_FAMILY member, opened from the real add-menu --
+	// ---- 1. it is a FLOW_FAMILY member, opened from the real add-menu --------
 	const family = await page.evaluate(() => window.__stores.bottomDock.FLOW_FAMILY);
 	h.check(
-		family.length === 6 && family[5] === 'hud',
-		`'hud' is the sixth FLOW_FAMILY member (${JSON.stringify(family)})`
+		// a position check broke when the timeline joined the family after it (896cdb93)
+		family.includes('hud'),
+		`'hud' is a FLOW_FAMILY member (${JSON.stringify(family)})`
 	);
 	const title = await page.evaluate(() => window.__stores.bottomDock.DOCK_TITLES.hud);
 	h.check(title === 'HUD editor', `and has a dock title (${title})`);

From 1929ebde65dd5af4a2bd910ff93a2c1a431b0a5b Mon Sep 17 00:00:00 2001
From: AlexZ005 <alexz005.info@gmail.com>
Date: Sat, 24 Oct 2026 19:22:21 +0300
Subject: [PATCH 20/46] [test] test-health-1 P2: vr-passthrough compares with
 the preset's own sky

The check held a copy of the studio background (#3b4048) and went stale when c2005ce2 retuned the palette (#363b43; b7d57c72 had already logged it red on pristine 1.25.0). Read ENVIRONMENT_PRESETS[preset].background instead of copying it. Green 14/0 (e2e/v3b).

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 tests/e2e/vr-passthrough.test.cjs | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

diff --git a/tests/e2e/vr-passthrough.test.cjs b/tests/e2e/vr-passthrough.test.cjs
index b938580bd..d5178ee5f 100644
--- a/tests/e2e/vr-passthrough.test.cjs
+++ b/tests/e2e/vr-passthrough.test.cjs
@@ -65,7 +65,15 @@ h.run(async () => {
 				})();
 			})
 	);
-	h.check(restored === '3b4048', `exiting restores the preset sky (#${restored})`);
+	// the preset's OWN background, not a copy of it (c2005ce2 retuned the palette and this went stale)
+	const presetSky = await A.page.evaluate(
+		() =>
+			new Promise((resolve) => {
+				const env = window.__stores.environment;
+				env.environment.subscribe((e) => resolve(String(env.ENVIRONMENT_PRESETS[e?.preset ?? 'studio']?.background ?? '').replace('#', '').toLowerCase()))();
+			})
+	);
+	h.check(restored === presetSky, `exiting restores the preset sky (#${restored}, preset #${presetSky})`);
 	const envAfter = await A.page.evaluate(
 		() =>
 			new Promise((resolve) => {

From aaac2302fa90369605faae71b0a7f054020aa345 Mon Sep 17 00:00:00 2001
From: AlexZ005 <alexz005.info@gmail.com>
Date: Sat, 24 Oct 2026 19:22:21 +0300
Subject: [PATCH 21/46] =?UTF-8?q?[test]=20test-health-1=20P2:=20search-men?=
 =?UTF-8?q?us=20=E2=80=94=20node=20search=20is=20the=20menu's=20filter=20r?=
 =?UTF-8?q?ow?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

26537bb6 moved node search INTO the pane's context menu (its .ctx-filter row, matches as .ctx-match) and deleted the pop-up #node-search-box with its right-drag. Assert the filter row opens and lists matches; the right-drag check goes with the feature it tested. Green 10/0 (e2e/v3b); quarantine entry dropped.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 tests/e2e/quarantine.json       |  1 -
 tests/e2e/search-menus.test.cjs | 19 ++++++++-----------
 2 files changed, 8 insertions(+), 12 deletions(-)

diff --git a/tests/e2e/quarantine.json b/tests/e2e/quarantine.json
index 88ac243a9..0b2f61d46 100644
--- a/tests/e2e/quarantine.json
+++ b/tests/e2e/quarantine.json
@@ -39,7 +39,6 @@
 		{"suite": "physics-kinematic", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "scene-budget", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "scene-post", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
-		{"suite": "search-menus", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "settings-layout", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "shader-sync", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "timeline-export", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
diff --git a/tests/e2e/search-menus.test.cjs b/tests/e2e/search-menus.test.cjs
index 0379f9ef7..b85201f98 100644
--- a/tests/e2e/search-menus.test.cjs
+++ b/tests/e2e/search-menus.test.cjs
@@ -79,21 +79,18 @@ h.run(async () => {
 	h.check((await page.locator('#add-search-input').inputValue()) === '', 'Clear empties the field');
 	await page.keyboard.press('Escape');
 
-	// node search: open flow, right-click pane, type to search, box right-drags
+	// node search: open flow, right-click pane, type to search. Since 26537bb6 the search runs inside
+	// the pane's context menu (its filter row), so the old pop-up box — and its right-drag — are gone
 	await page.locator('p[title="Node editor (N)"]').click();
 	await page.waitForTimeout(600);
 	await page.locator('.svelte-flow__pane').click({ button: 'right', position: { x: 400, y: 120 } });
-	await page.waitForTimeout(300);
+	await page.waitForSelector('.ctx-filter', { state: 'attached', timeout: 5000 });
 	await page.keyboard.type('s');
-	await page.waitForTimeout(300);
-	h.check(await page.locator('#node-search-box').isVisible(), 'node search opens');
-	const nb = await page.locator('#node-search-box').boundingBox();
-	await page.mouse.move(nb.x + 60, nb.y + 70);
-	await page.mouse.down({ button: 'right' });
-	await page.mouse.move(nb.x + 180, nb.y + 140, { steps: 5 });
-	await page.mouse.up({ button: 'right' });
-	const nbAfter = await page.locator('#node-search-box').boundingBox();
-	h.check(nbAfter.x > nb.x + 80, `node search box right-drags (${nb.x} → ${nbAfter.x})`);
+	const opened = await page
+		.waitForSelector('.ctx-filter.on', { timeout: 5000 })
+		.then(() => true, () => false);
+	h.check(opened, 'node search opens (the menu filter row)');
+	h.check((await page.locator('.ctx-match').count()) > 0, 'typing lists matching nodes');
 
 	await ctx.close();
 	await h.finish(browser);

From ecb50e1086d2c0aa3ccc392c2796178d019afd2a Mon Sep 17 00:00:00 2001
From: AlexZ005 <alexz005.info@gmail.com>
Date: Sat, 24 Oct 2026 19:23:16 +0300
Subject: [PATCH 22/46] [fix] test-health-1 P2: a physics action acts on a
 trigger stamp it has not seen, even when the pulse fell between frames
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

flow-physics-actions 6.5: after a peer joined, a trigger no longer hopped the box on A (key press or applyNodeTrigger alike — the suite had recorded it as unexplained, 3 runs of 3). Measured with the new 6.5 diagnostics: the stamp was newer than the history epoch, the sim ran, A was the initiator — the impulse simply never saw a rising edge. Physics actions fire on the rising VALUE of the event's pulse, and a pulse is high for 0.3 s; with a second page rendering, A dropped below ~3.3 fps and the whole pulse fell between two ticks.

PRODUCT FIX (flowRuntime updatePhysicsActions): remember the trigger stamp each action last saw; a NEW stamp is a rising edge even when the value already fell. First sight is not (a pulse from before the node, which staleTrigger refuses anyway), a Toggle with no stamp keeps the value edge, and one pulse still fires once. Affects any device below ~3.3 fps (slow phones, a loaded headset), not just the test box.

Test: 6.5 stamps on the session clock flowRuntime itself stamps with (a correctness tidy-up — NOT the cause; the clocks agreed to 0.15 s), prints the clocks if it goes red again, and 6.7 allows the 'camera' presence stream. Green 37/0 (e2e/v3a); the 6.5 quarantine entry dropped, 2.1/4.3/8.5 kept until a second green.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 src/lib/flowRuntime.js                  | 16 +++++++++--
 tests/e2e/flow-physics-actions.test.cjs | 35 ++++++++++++++++++++++---
 tests/e2e/quarantine.json               |  1 -
 3 files changed, 46 insertions(+), 6 deletions(-)

diff --git a/src/lib/flowRuntime.js b/src/lib/flowRuntime.js
index 619962fa9..411e7ba72 100644
--- a/src/lib/flowRuntime.js
+++ b/src/lib/flowRuntime.js
@@ -129,6 +129,11 @@ const restFired = new Map();
 /** B6: rising-edge map for the physics ACTION nodes (a pulse is high ~0.3 s, so
  * an action must run once per pulse, not once per frame) @type {Map<string, boolean>} */
 const physicsActionEdge = new Map();
+/** test-health-1: the trigger STAMP each physics action last saw. A pulse is high for 0.3 s, so a
+ * frame longer than that (below ~3.3 fps: two pages on software GL, a slow phone) can step over the
+ * whole pulse and the rising VALUE never shows — the trigger stamp still changed, and that is the
+ * event. @type {Map<string, number|null>} */
+const physicsActionStamp = new Map();
 
 // --- 21-E6 follow-up: THE STALE-STAMP GUARD, shared by every trigger-edge family ----
 //
@@ -665,8 +670,14 @@ function updatePhysicsActions(pairs, ctx, time) {
 		if (!target) continue;
 		const was = physicsActionEdge.get(node.id) ?? false;
 		physicsActionEdge.set(node.id, high);
+		const stamp = triggerStampFor(node.id, ctx);
+		const lastStamp = physicsActionStamp.get(node.id);
+		physicsActionStamp.set(node.id, stamp);
+		// a NEW stamp is a rising edge even when the pulse it made fell between two ticks; first sight
+		// (no last stamp) is not — that is a pulse from before this node, and staleTrigger has it
+		const freshStamp = typeof stamp === 'number' && lastStamp !== undefined && stamp !== lastStamp;
 		const continuous = node.type === 'setvelocity' && (data.mode ?? 'once') === 'continuous';
-		if (!continuous && (!high || was)) continue;
+		if (!continuous && !((high && !was) || freshStamp)) continue;
 		if (continuous && !high) continue;
 		// ...and the pulse that made us high may PREDATE this node. This family reads a
 		// rising VALUE rather than a stamp, so its exposure was only the ~0.3s a pulse
@@ -675,7 +686,7 @@ function updatePhysicsActions(pairs, ctx, time) {
 		// behind the pulse is what answers it. A pulse with NO stamp (a Toggle wired into
 		// `trigger`) is never refused, and a continuous Set Velocity keeps running,
 		// because after its first tick every live stamp is newer than the cutoff.
-		if (staleTrigger(node, triggerStampFor(node.id, ctx))) continue;
+		if (staleTrigger(node, stamp)) continue;
 		// a physics action in a scene that is not simulating is a no-op, and used to
 		// be a SILENT one — the graph is right, the key fires, nothing moves
 		// initiator-gated by design, so a NON-initiator doing nothing here is correct
@@ -712,6 +723,7 @@ function updatePhysicsActions(pairs, ctx, time) {
 		}
 	}
 	for (const id of [...physicsActionEdge.keys()]) if (!seen.has(id)) physicsActionEdge.delete(id);
+	for (const id of [...physicsActionStamp.keys()]) if (!seen.has(id)) physicsActionStamp.delete(id);
 }
 
 let lastNoSimWarn = 0;
diff --git a/tests/e2e/flow-physics-actions.test.cjs b/tests/e2e/flow-physics-actions.test.cjs
index 14feb4fe5..76a18000f 100644
--- a/tests/e2e/flow-physics-actions.test.cjs
+++ b/tests/e2e/flow-physics-actions.test.cjs
@@ -495,14 +495,42 @@ h.run(async () => {
 	// or these nodes' logic. Unexplained, and reported as such rather than
 	// papered over — the same key press works before the join and in every
 	// single-peer section.
+	// test-health-1: stamped on the SESSION clock, the one flowRuntime stamps with (syncedNow). The
+	// raw Date.now() this used to pass is a different clock once a peer is in: the join merges B's
+	// trigger log, which sets A's history epoch in session time, so a raw stamp behind it is refused
+	// as somebody else's history (and sits outside the pulse window) — 6.5 red, no hop.
 	await page.evaluate(() => {
-		window.__stores.flowRuntime.applyNodeTrigger('key6', (Date.now() % 86400000) / 1000, true);
+		const s = window.__stores;
+		s.flowRuntime.applyNodeTrigger('key6', (s.connectionState.sessionNow() % 86400000) / 1000, true);
 	});
+	let hopped = false;
 	await h.eventually(
 		async () => (await posOf(page, box))[1],
-		(y) => y > 0.7,
+		(y) => (hopped = y > 0.7),
 		'6.5 (premise) the trigger hops the box on A, the peer running the world'
 	);
+	// a red 6.5 says WHY: which clock the stamp is on, the history epoch, the stamp held
+	if (!hopped)
+		console.log(
+			'  6.5 clocks: ' +
+				JSON.stringify(
+					await page.evaluate(() => {
+						const s = window.__stores;
+						let t = {};
+						s.flowTriggers?.subscribe?.((v) => (t = v))?.();
+						let sim = null;
+						s.physics.simulating.subscribe((v) => (sim = v))();
+						return {
+							rawNow: (Date.now() % 86400000) / 1000,
+							sessionNow: (s.connectionState.sessionNow() % 86400000) / 1000,
+							epoch: s.flowRuntime.triggerHistoryEpoch(),
+							key6: t?.key6 ?? null,
+							simulating: sim,
+							initiator: s.physics.isInitiator?.() ?? null
+						};
+					})
+				)
+		);
 	await h.eventually(
 		async () => (await posOf(B.page, box))[1],
 		(y) => y > beforeHopY + 0.2,
@@ -514,7 +542,8 @@ h.run(async () => {
 	// is that the physics ACTION nodes add nothing of their own
 	const unexpected = types.filter(
 		(t) =>
-			!['move', 'nodetrigger', 'nodechange', 'nodesync', 'nodes', 'simulate', 'objectParameters'].includes(
+			// + `camera`: the presence stream (where a peer is looking), which flows whenever a peer is in
+			!['move', 'nodetrigger', 'nodechange', 'nodesync', 'nodes', 'simulate', 'objectParameters', 'camera'].includes(
 				t
 			)
 	);
diff --git a/tests/e2e/quarantine.json b/tests/e2e/quarantine.json
index 0b2f61d46..354e3d0d8 100644
--- a/tests/e2e/quarantine.json
+++ b/tests/e2e/quarantine.json
@@ -14,7 +14,6 @@
 		{"suite": "net-handshake", "check": "C received the scene", "reason": "third peer handshake timing; red on pristine v1.41.0 and on 904599c1 (50-int r3, 55-invite)", "owner": "test-health (standing lane)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "flow-physics-actions", "check": "2.1 mode 'continuous' KEEPS pushing", "reason": "body at 0 m/s under a held key on a slow frame; flaky in every app x driver cell (deps-1 ab3)", "owner": "test-health (standing lane)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "flow-physics-actions", "check": "4.3 read 'speed' reports real motion", "reason": "as 2.1 (deps-1 ab3)", "owner": "test-health (standing lane)", "since": "2026-10-23", "review": "2026-11-07"},
-		{"suite": "flow-physics-actions", "check": "6.5 (premise) the trigger hops the box", "reason": "two-peer world timing (deps-1 ab3, 49-int)", "owner": "test-health (standing lane)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "flow-physics-actions", "check": "8.5 and the very NEXT press throws the box", "reason": "stale-press guard vs frame timing (pcA, deps-1)", "owner": "test-health (standing lane)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "select-41", "check": "G4 (near) a finger on the crate takes it", "reason": "G4 flick timing: 12/12 green on --local, red under load (deps-1 ab3)", "owner": "test-health (standing lane)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "avatar-feet", "check": "1.3 standing: B's lowest sole is on the floor", "reason": "red 2/4 d3d12, 3/3 llvmpipe, green on rerun (mux-pc-host)", "owner": "test-health (standing lane)", "since": "2026-10-23", "review": "2026-11-07"},

From d02bbc86dc027f0ec72f5fc993738c9a33d897fc Mon Sep 17 00:00:00 2001
From: AlexZ005 <alexz005.info@gmail.com>
Date: Sat, 24 Oct 2026 19:25:09 +0300
Subject: [PATCH 23/46] [test] test-health-1 P2: settings-layout judges a
 squeezed description by rowFit's own floor
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The phone check said a description beside its control must keep half the row (1b6bc72e). 437423c8 (41b H12/H13) then made rows decide by real fit: a compact control stays on the label's row while the text column keeps rowFit TEXT_MIN = 150 px — which settings-row-fit asserts, and which is under half of a 390 px phone row. The two suites contradicted each other; use the product's floor (< 149 px is squeezed). Green 98/0 (e2e/v3b); quarantine entry dropped.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 tests/e2e/quarantine.json          | 1 -
 tests/e2e/settings-layout.test.cjs | 6 ++++--
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/tests/e2e/quarantine.json b/tests/e2e/quarantine.json
index 354e3d0d8..444de3b78 100644
--- a/tests/e2e/quarantine.json
+++ b/tests/e2e/quarantine.json
@@ -38,7 +38,6 @@
 		{"suite": "physics-kinematic", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "scene-budget", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "scene-post", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
-		{"suite": "settings-layout", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "shader-sync", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "timeline-export", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "touch-actions", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
diff --git a/tests/e2e/settings-layout.test.cjs b/tests/e2e/settings-layout.test.cjs
index 046f9b205..622a77a1e 100644
--- a/tests/e2e/settings-layout.test.cjs
+++ b/tests/e2e/settings-layout.test.cjs
@@ -220,13 +220,15 @@ h.run(async () => {
 		await open(P.page, key);
 		const t = await P.page.evaluate(() => {
 			// a description squeezed beside its control (Density's two long options left it a
-			// one-word column) — on a phone the text keeps at least half the row
+			// one-word column). The floor is the product's own: rowFit keeps a control beside its
+			// label only while the text column keeps TEXT_MIN (150 px, 437423c8) — the old "half the
+			// row" rule contradicted that on a 390 px phone (settings-row-fit asserts the product's)
 			const squeezed = [];
 			for (const row of document.querySelectorAll('#settings-sections .setting-row')) {
 				const el = /** @type {HTMLElement} */ (row);
 				const d = el.querySelector('.sr-desc');
 				if (!el.offsetParent || !d || !(d.textContent || '').trim()) continue;
-				if (d.getBoundingClientRect().width < el.getBoundingClientRect().width * 0.5) squeezed.push((el.querySelector('.sr-name')?.textContent || '').trim());
+				if (d.getBoundingClientRect().width < 149) squeezed.push((el.querySelector('.sr-name')?.textContent || '').trim());
 			}
 			const small = [];
 			for (const el of document.querySelectorAll('#settings-sections .seg-opt, #settings-sections .tp-ui.nr, #settings-sections button.btn, #settings-sections .settings-num, #settings-sections .settings-text')) {

From 1f3023edac16eab5fce2e7c69d045b5fb8111349 Mon Sep 17 00:00:00 2001
From: AlexZ005 <alexz005.info@gmail.com>
Date: Sat, 24 Oct 2026 19:26:58 +0300
Subject: [PATCH 24/46] [test] test-health-1 P2: physics-kinematic starts from
 a scenery slab
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

95df3a66 gives every /create primitive userData.physics {mode:'dynamic'}, and a body is only kinematic when it is not dynamic — so the spinning slab fell to the ground (y 0.198, 'dynamic') and all four checks went red from that one cause. Delete the slab's physics (and say so to B), so the spin effect is what makes it the kinematic platform. Green 14/0 (e2e/v3a); quarantine entry dropped.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 tests/e2e/physics-kinematic.test.cjs | 4 ++++
 tests/e2e/quarantine.json            | 1 -
 2 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/tests/e2e/physics-kinematic.test.cjs b/tests/e2e/physics-kinematic.test.cjs
index 2c3c2eb4b..be6884a7d 100644
--- a/tests/e2e/physics-kinematic.test.cjs
+++ b/tests/e2e/physics-kinematic.test.cjs
@@ -51,6 +51,9 @@ h.run(async () => {
 		const group = await new Promise((r) => window.__stores.objectsGroup.subscribe(r)());
 		const [slab, box] = group.children.slice(-2);
 		slab.position.set(0, 1, 0);
+		// /create makes every primitive dynamic since 95df3a66 — the slab must be scenery, so the spin
+		// effect is what makes it a KINEMATIC platform (a dynamic slab just falls to the ground)
+		delete slab.userData.physics;
 		box.position.set(2, 1.75, 0); // resting on the slab top, 2m off-axis
 		// dynamic via Inspector-style userData.physics (NO flow mass node)
 		box.userData.physics = { mode: 'dynamic', mass: 1 };
@@ -58,6 +61,7 @@ h.run(async () => {
 		peer.send({ type: 'move', uuid: slab.uuid, pos: [0, 1, 0], rot: [0, 0, 0], scale: [1, 1, 1] });
 		peer.send({ type: 'move', uuid: box.uuid, pos: [2, 1.75, 0], rot: [0, 0, 0], scale: [1, 1, 1] });
 		peer.send({ type: 'objectParameters', parameter: 'physics', uuid: box.uuid, physics: box.userData.physics });
+		peer.send({ type: 'objectParameters', parameter: 'physics', uuid: slab.uuid, physics: null });
 		// spin effect on the slab -> it becomes a KINEMATIC platform mid-sim
 		const nodes = [
 			{ id: 'sp1', type: 'spin', position: { x: 0, y: 0 }, data: { type: 'spin', axis: 'y', speed: 2 }, class: 'w-[150px]' },
diff --git a/tests/e2e/quarantine.json b/tests/e2e/quarantine.json
index 444de3b78..3b6a6fa99 100644
--- a/tests/e2e/quarantine.json
+++ b/tests/e2e/quarantine.json
@@ -35,7 +35,6 @@
 		{"suite": "kit-instancing", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "net-stress", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "phone-sheets", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
-		{"suite": "physics-kinematic", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "scene-budget", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "scene-post", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "shader-sync", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},

From 51c024f8de984cec9a554f1f3b1525e2348eb6dd Mon Sep 17 00:00:00 2001
From: AlexZ005 <alexz005.info@gmail.com>
Date: Sat, 24 Oct 2026 19:27:46 +0300
Subject: [PATCH 25/46] [test] test-health-1 P2: knock-physics reads the
 prediction over B's own frames
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

2.12 read exactly 0.000 m — on this box AND on the GPU PC (pcbat), so not just a slow renderer: B's prediction moves the ball once per RENDERED frame and is withdrawn after 400 ms of wall clock (PREDICT_MAX_MS), and the check read it after a 60 ms timer plus two round trips, i.e. between frames or after the withdrawal. Take the furthest the ball got over B's next six frames, inside the same evaluate. 2.13 now also requires A's ball to have really moved, so 'both peers still at x≈0' cannot pass as convergence before any authority move ended the prediction (2.14). Green 77/0 (e2e/v3a); the 2.12 quarantine entry dropped.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 tests/e2e/knock-physics.test.cjs | 35 ++++++++++++++++----------------
 tests/e2e/quarantine.json        |  1 -
 2 files changed, 18 insertions(+), 18 deletions(-)

diff --git a/tests/e2e/knock-physics.test.cjs b/tests/e2e/knock-physics.test.cjs
index 469bbe67b..46bb881a2 100644
--- a/tests/e2e/knock-physics.test.cjs
+++ b/tests/e2e/knock-physics.test.cjs
@@ -392,7 +392,7 @@ h.run(async () => {
 		'2.3 (premise) B sees the ball parked at (0,1,0)'
 	);
 
-	const remote = await B.page.evaluate((uuid) => {
+	const remote = await B.page.evaluate(async (uuid) => {
 		const k = window.__stores.knock;
 		k.dropProbe('b');
 		let hits = 0;
@@ -404,7 +404,17 @@ h.run(async () => {
 		let group = null;
 		window.__stores.objectsGroup.subscribe((v) => (group = v))();
 		const object = group.getObjectByProperty('uuid', uuid);
-		return { hits, predicting: k.knockDebug().predictions.includes(uuid), x0: object.position.x, local: k.lastHitOf(uuid) };
+		const x0 = object.position.x;
+		const predicting = k.knockDebug().predictions.includes(uuid);
+		// the prediction moves the ball once per RENDERED frame and is withdrawn after 400 ms of wall
+		// clock (PREDICT_MAX_MS): at ~4 fps a fixed 60 ms read lands between frames or after the
+		// withdrawal (exactly 0.000). Take the furthest it got over B's next few frames.
+		let advanced = 0;
+		for (let i = 0; i < 6; i++) {
+			await new Promise((r) => requestAnimationFrame(r));
+			advanced = Math.max(advanced, object.position.x - x0);
+		}
+		return { hits, predicting, x0, advanced, local: k.lastHitOf(uuid) };
 	}, ball);
 	h.check(remote.hits === 1, '2.4 B\'s 4 m/s sweep registers one knock locally');
 	const message = await B.page.evaluate(() => window.__sent.find((m) => m.type === 'hit') ?? null);
@@ -434,26 +444,17 @@ h.run(async () => {
 	h.check(logs[0]?.by === B.id && logs[1]?.by === B.id, '2.10 both logs name B as the hitter (A says ' + logs[0]?.by + ')');
 	h.check(logs[0] && logs[1] && logs[0].at === logs[1].at && Math.abs(logs[0].speed - logs[1].speed) < 1e-6, '2.11 ...with the SAME stamp and speed on both peers (A2 keys onhit by that stamp)');
 
-	const advanced = await B.page.evaluate(
-		([uuid, x0]) =>
-			new Promise((resolve) =>
-				setTimeout(() => {
-					let group = null;
-					window.__stores.objectsGroup.subscribe((v) => (group = v))();
-					const object = group.getObjectByProperty('uuid', uuid);
-					resolve(object.position.x - x0);
-				}, 60)
-			),
-		[ball, remote.x0]
-	);
-	h.check(advanced > 0.04, '2.12 within 60 ms B\'s rendered ball has moved along the hit (' + advanced.toFixed(3) + ' m) — prediction, or authority already landing on it');
+	const advanced = remote.advanced;
+	h.check(advanced > 0.04, '2.12 within B\'s next rendered frames its ball has moved along the hit (' + advanced.toFixed(3) + ' m) — prediction, or authority already landing on it');
 	await h.eventually(
 		async () => {
 			const a = await posOf(A.page, ball);
 			const b = await posOf(B.page, ball);
-			return Math.hypot(a[0] - b[0], a[1] - b[1], a[2] - b[2]);
+			return { ax: a[0], gap: Math.hypot(a[0] - b[0], a[1] - b[1], a[2] - b[2]) };
 		},
-		(gap) => gap < 0.3,
+		// agreement must come over AUTHORITY's moves (which also end the prediction, 2.14): while A's ball
+		// has not moved yet, both peers reading x≈0 is not convergence
+		(r) => Math.abs(r.ax - remote.x0) > 0.5 && r.gap < 0.3,
 		'2.13 the two peers converge on where the ball came to rest, over the ordinary move stream',
 		12000
 	);
diff --git a/tests/e2e/quarantine.json b/tests/e2e/quarantine.json
index 3b6a6fa99..359230c47 100644
--- a/tests/e2e/quarantine.json
+++ b/tests/e2e/quarantine.json
@@ -19,7 +19,6 @@
 		{"suite": "avatar-feet", "check": "1.3 standing: B's lowest sole is on the floor", "reason": "red 2/4 d3d12, 3/3 llvmpipe, green on rerun (mux-pc-host)", "owner": "test-health (standing lane)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "aquarium-reef", "check": "2.1 every fallback group built its PACK model", "reason": "1 red in 3 on each GPU path: pack fetch vs the wait (mux-pc-host)", "owner": "test-health (standing lane)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "aquarium-reef", "check": "2.2 every group DRAWS a pack level", "reason": "as 2.1 (mux-pc-host)", "owner": "test-health (standing lane)", "since": "2026-10-23", "review": "2026-11-07"},
-		{"suite": "knock-physics", "check": "2.12 within 60 ms B's rendered ball has moved", "reason": "a 60 ms window on a remote frame; pc rerun 3/3 green (mux-pc-host)", "owner": "test-health (standing lane)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "pack-behavior", "check": "7.2 OPEN: the capsule walks through the doorway", "reason": "a fixed 300 ms wait vs charController's lazy physics import; base 1/3 red (59-replace)", "owner": "test-health (standing lane)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "code-workspace", "check": "Save as file binds the node", "reason": "a 2000 ms wait; flaked on both base and lane (50-yjs, 50-window)", "owner": "test-health (standing lane)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "animation-node", "check": "so the door closes rather than restarting", "reason": "~1.7 fps under load: a 900 ms window holds 1-2 frames; 35/0 on a GPU slot (57-clips)", "owner": "test-health (standing lane)", "since": "2026-10-23", "review": "2026-11-07"},

From d092f20d32b38ed73a14200affd6c4770a7425c4 Mon Sep 17 00:00:00 2001
From: AlexZ005 <alexz005.info@gmail.com>
Date: Sat, 24 Oct 2026 19:27:58 +0300
Subject: [PATCH 26/46] [test] test-health-1 P2: code-sidebars S7 reverts the
 room's buffer before its counterfactual
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

S7's counterfactual ('with nothing unsaved, leaving the page does not ask') reopened the file right after 'Don't save' — but since 50 Y1 (6e6c95ca, shared text in the Code tab) 'Don't save' discards THIS view and deliberately leaves the room's shared buffer alone, so the reopen rejoined the edits and the page rightly asked. Revert the shared copy (reloadCodeTab, for everyone) and wait until nothing is unsaved. Green 98/0 (e2e/v3b).

For the owner (not changed): a user who pressed 'Don't save' and reopens the file sees the discarded edits again while a peer is in the room. That is the Y1 design as written; if it reads as a bug, the fix is in discardAllCodeTabs, not here.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 tests/e2e/code-sidebars.test.cjs | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/tests/e2e/code-sidebars.test.cjs b/tests/e2e/code-sidebars.test.cjs
index 0b8cf30ac..8b01db19d 100644
--- a/tests/e2e/code-sidebars.test.cjs
+++ b/tests/e2e/code-sidebars.test.cjs
@@ -471,8 +471,11 @@ h.run(async () => {
 	await page.locator('#code-ws-confirm-all-discard').click();
 	await page.waitForTimeout(400);
 	h.check((await read(page, 'codeWorkspaceClose')) === true && (await read(page, 'codeWorkspace.codeTabs')).every((t) => t.code === t.saved || t.readOnly), 'S7: Don\'t save closes and throws the edits away');
-	await S(page, () => window.__stores.codeWorkspace.openCode({ source: 'script', ref: { nodeId: 'cs-undo', graphId: 'scene' } }));
-	await page.waitForTimeout(600);
+	const reTab = await S(page, () => window.__stores.codeWorkspace.openCode({ source: 'script', ref: { nodeId: 'cs-undo', graphId: 'scene' } }));
+	// 50 Y1 (6e6c95ca): "Don't save" discards THIS view and leaves the room's shared buffer alone, so the
+	// reopen rejoins the edits; revert the shared copy (for everyone) to reach "nothing unsaved"
+	await S(page, (id) => window.__stores.codeWorkspace.reloadCodeTab(id), reTab);
+	await h.eventually(() => read(page, 'codeWorkspace.codeTabs'), (tabs) => tabs.every((t) => t.code === t.saved || t.readOnly), 'S7 (premise) after the revert nothing is unsaved');
 	h.check((await S(page, () => {
 		const ev = new Event('beforeunload', { cancelable: true });
 		window.dispatchEvent(ev);

From 3fdd37c8b283adb4496e0ed4afa3918610aa7f6e Mon Sep 17 00:00:00 2001
From: AlexZ005 <alexz005.info@gmail.com>
Date: Sat, 24 Oct 2026 19:30:01 +0300
Subject: [PATCH 27/46] [test] test-health-1 P2: scene-budget judges the
 objects row, not the worst-of-all dot
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The status-line dot is the WORST tier of every budget (Controls worstTier), and on software GL (p95 333 ms, ~3 fps) frame time alone turns it red whatever the scene holds — so '24 objects reads green' could never pass there, and the 'goes RED' wait returned at once, reading the tooltip before the 3200-object sample landed. Judge budgetRows' objects row; check the dot only when the frame rows leave it to the objects; wait for the tooltip to name the objects. Green 35/0 (e2e/v3b); quarantine entry dropped.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 tests/e2e/quarantine.json       |  1 -
 tests/e2e/scene-budget.test.cjs | 29 ++++++++++++++++++++++-------
 2 files changed, 22 insertions(+), 8 deletions(-)

diff --git a/tests/e2e/quarantine.json b/tests/e2e/quarantine.json
index 359230c47..8007cff17 100644
--- a/tests/e2e/quarantine.json
+++ b/tests/e2e/quarantine.json
@@ -34,7 +34,6 @@
 		{"suite": "kit-instancing", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "net-stress", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "phone-sheets", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
-		{"suite": "scene-budget", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "scene-post", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "shader-sync", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "timeline-export", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
diff --git a/tests/e2e/scene-budget.test.cjs b/tests/e2e/scene-budget.test.cjs
index 2e0f7a916..cca527506 100644
--- a/tests/e2e/scene-budget.test.cjs
+++ b/tests/e2e/scene-budget.test.cjs
@@ -88,9 +88,21 @@ h.run(async () => {
 	h.check(typeof live.ingestBacklog === 'number', 'a registered source (the ingest backlog) reaches the sample');
 
 	// ---- 3. the meter's dot moves with the scene ----------------------------
-	await A.page.waitForTimeout(700);
-	const greenDot = await A.page.getAttribute('#object-budget-dot', 'data-tier');
-	h.check(greenDot === 'green', `24 objects reads green in the status line (${greenDot})`);
+	// the dot is the WORST tier of every budget (Controls worstTier), so on software GL (~3 fps) frame
+	// time alone turns it red whatever the scene holds. Judge the OBJECTS row, and the dot only when the
+	// frame rows leave it to the objects.
+	const tierOf = (/** @type {string} */ key) =>
+		A.page.evaluate((k) => {
+			const b = window.__stores.sceneBudget;
+			let m;
+			b.sceneMetrics.subscribe((v) => (m = v))();
+			return b.budgetRows(m, m?.profile ?? 'desktop').find((r) => r.key === k)?.tier ?? null;
+		}, key);
+	await h.eventually(() => tierOf('objects'), (t) => t === 'green', '24 objects reads green on the objects budget');
+	if ((await tierOf('frameP95')) === 'green') {
+		const greenDot = await A.page.getAttribute('#object-budget-dot', 'data-tier');
+		h.check(greenDot === 'green', `…and in the status line (${greenDot})`);
+	} else console.log('  (frame time is over budget on this renderer — the status-line dot is not the objects reading here)');
 
 	await A.page.evaluate(async () => {
 		const { THREE, objectsGroup, pokeScene } = window.__stores;
@@ -101,15 +113,18 @@ h.run(async () => {
 		for (let i = 0; i < 3200; i++) group.add(new THREE.Mesh(geo, mat));
 		pokeScene();
 	});
+	await h.eventually(() => tierOf('objects'), (t) => t === 'red', 'the objects budget goes RED past the ceiling');
 	await h.eventually(
 		() => A.page.getAttribute('#object-budget-dot', 'data-tier'),
 		(t) => t === 'red',
 		'the status-line dot goes RED when the object budget is exceeded'
 	);
-	const title = await A.page.getAttribute('#object-count', 'title');
-	h.check(
-		/over on/.test(String(title)) && /object/i.test(String(title)),
-		`…and the tooltip names WHAT is over budget (${title})`
+	// the tooltip follows the NEXT sample (the 3200 objects), not the moment the dot went red — read it
+	// once it says so, instead of the instant after a dot that frame time had already turned red
+	await h.eventually(
+		() => A.page.getAttribute('#object-count', 'title'),
+		(t) => /over on/.test(String(t)) && /object/i.test(String(t)),
+		'…and the tooltip names WHAT is over budget'
 	);
 
 	// ---- 4. the panel, through its real entry point --------------------------

From 7aad55249c2aad9031ac771eedaece263cf17f63 Mon Sep 17 00:00:00 2001
From: AlexZ005 <alexz005.info@gmail.com>
Date: Sat, 24 Oct 2026 19:30:01 +0300
Subject: [PATCH 28/46] =?UTF-8?q?[test]=20test-health-1=20P2:=20aquarium-r?=
 =?UTF-8?q?eef=20=E2=80=94=20nose=20over=20the=20moving=20samples,=20and?=
 =?UTF-8?q?=20wait=20for=20the=20failure=20to=20be=20reported?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

1.3 averaged the nose-vs-travel cosine over every 250 ms interval, and an interval with no rendered frame in it (software GL) has no direction and scored 0 — two of eleven gave exactly the 0.82 measured (pcbat on a GPU read 0.99). Skip non-moving intervals, as 1.7 already does, and require six moving ones. 3.2 read the offline levels after a fixed 3 s, but since 974e8be0 (60 Q6 local asset cache) a fresh page's first pack fetch waits for the cache to open first: wait for a failed level to be reported (bounded, statuses printed). Green 30/0 (e2e/v3a). The two 2.x check entries stay (pack-level timing, not touched here).

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 tests/e2e/aquarium-reef.test.cjs | 37 ++++++++++++++++++++------------
 1 file changed, 23 insertions(+), 14 deletions(-)

diff --git a/tests/e2e/aquarium-reef.test.cjs b/tests/e2e/aquarium-reef.test.cjs
index 1bf95eef2..9fd196a82 100644
--- a/tests/e2e/aquarium-reef.test.cjs
+++ b/tests/e2e/aquarium-reef.test.cjs
@@ -100,14 +100,19 @@ h.run(async () => {
 	// midpoint sits on the centre and the closest they get is the minor diameter, 1.0 m
 	const mid = tang.map((t) => Math.hypot((t.a[0] + t.b[0]) / 2 - 0.1, (t.a[2] + t.b[2]) / 2 - 0.05));
 	h.check(Math.max(...mid) < 0.15 && Math.min(...apart) > 0.9, '1.2 the two tangs ride HALF A LAP apart (offset 0.5): midpoint within ' + Math.max(...mid).toFixed(2) + ' m of the loop centre, ' + Math.min(...apart).toFixed(2) + ' m at the closest');
+	// over the samples where the fish MOVED: a 250 ms interval with no rendered frame in it (software
+	// GL, ~4 fps) has no direction and used to score 0 — two of eleven gave exactly 0.82 (1.7 skips them too)
 	let along = 0;
+	let an = 0;
 	for (let i = 1; i < tang.length; i++) {
 		const d = [tang[i].a[0] - tang[i - 1].a[0], tang[i].a[1] - tang[i - 1].a[1], tang[i].a[2] - tang[i - 1].a[2]];
-		const l = Math.hypot(...d) || 1;
+		const l = Math.hypot(...d);
+		if (l < 0.01) continue; // no frame landed between these two samples
 		const n = tang[i].nose;
 		along += (d[0] * n[0] + d[1] * n[1] + d[2] * n[2]) / l;
+		an++;
 	}
-	h.check(along / (tang.length - 1) > 0.85, '1.3 its nose points along the travel (mean cos ' + (along / (tang.length - 1)).toFixed(2) + ')');
+	h.check(an >= 6 && along / an > 0.85, '1.3 its nose points along the travel (mean cos ' + (along / Math.max(1, an)).toFixed(2) + ' over ' + an + ' moving samples)');
 	const maxRoll = Math.max(...tang.map((t) => Math.abs(t.up[0] * t.nose[2] - t.up[2] * t.nose[0]) + Math.abs(Math.hypot(t.up[0], t.up[2]))));
 	h.check(maxRoll > 0.05, '1.4 it BANKS in the bends (top tilts off vertical by up to ' + maxRoll.toFixed(2) + ')');
 	const box = await page.evaluate(() => window.__aq.waterBox());
@@ -224,19 +229,23 @@ h.run(async () => {
 	await B.page.route(/aquarium-kit\/.*\.glb/, (route) => route.abort());
 	await loadScene(B.page, AQUARIUM);
 	await install(B.page);
-	await B.page.evaluate(() => window.__aq.render());
-	await B.page.waitForTimeout(3000);
-	const offline = await B.page.evaluate(() => {
-		window.__aq.render();
-		return window.__aq.fallbackRoots().map((o) => ({
-			name: o.name,
-			current: window.__stores.lodGroup.lodGroupInfo(o.uuid)?.current,
-			trees: window.__stores.lodTrees.lodTreesOf(o).length,
-			failed: (window.__stores.lodGroup.lodGroupInfo(o.uuid)?.levels ?? []).filter((l) => l.status === 'failed').length
-		}));
-	});
+	// the first pack fetch on a fresh page waits for the asset cache to open first (OPFS + the legacy
+	// migration, 974e8be0) — wait for the failure to be REPORTED instead of a fixed 3 s; the statuses
+	// say which it was if it never comes (a slow `loading` vs a level never requested)
+	const offlineProbe = () =>
+		B.page.evaluate(() => {
+			window.__aq.render();
+			return window.__aq.fallbackRoots().map((o) => ({
+				name: o.name,
+				current: window.__stores.lodGroup.lodGroupInfo(o.uuid)?.current,
+				trees: window.__stores.lodTrees.lodTreesOf(o).length,
+				failed: (window.__stores.lodGroup.lodGroupInfo(o.uuid)?.levels ?? []).filter((l) => l.status === 'failed').length,
+				statuses: (window.__stores.lodGroup.lodGroupInfo(o.uuid)?.levels ?? []).map((l) => l.status)
+			}));
+		});
+	await h.eventually(offlineProbe, (o) => o.some((d) => d.failed > 0), '3.2 …and says why on the level (failed levels reported, not thrown)', 20000);
+	const offline = await offlineProbe();
 	h.check(offline.every((d) => d.current === 0 && d.trees === 0), '3.1 pack unreachable: every group draws its STAND-IN (LOD0) — the scene still has its fish, coral and plants');
-	h.check(offline.some((d) => d.failed > 0), '3.2 …and says why on the level (failed levels reported, not thrown)');
 	const offMove = await sample(B.page, () => window.__aq.world('Blue tang 1'), 4, 300);
 	h.check(Math.hypot(offMove[3][0] - offMove[0][0], offMove[3][2] - offMove[0][2]) > 0.1, '3.3 …and the stand-ins still swim');
 	if (SHOTS) await B.page.screenshot({ path: SHOTS + '-offline.png' });

From 755ea56cc1d3c841d310058a54b066254c610a1f Mon Sep 17 00:00:00 2001
From: AlexZ005 <alexz005.info@gmail.com>
Date: Sat, 24 Oct 2026 19:39:35 +0300
Subject: [PATCH 29/46] [fix] test-health-1 P5: reload-memory probe (measured:
 no growth across reloads) + the thumbnail renderer always disposed
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Plans review #24 / roadmap-42 Follow-ups: 'editor-ui-33 dies on its 5th reload; the heap grows ~29 MB per reload'. Measured on the current union, it does not:
- tests/e2e/reload-memory.test.cjs (new in e77ca3f7, made honest here): per reload, after a forced GC, the JS heap (Runtime.getHeapUsage), live documents (Memory.getDOMCounters), renderer.info, and the RSS of this browser's renderer + GPU processes (SystemInfo.getProcessInfo + /proc). The first version read Performance.getMetrics, which on a reloaded target kept answering the first document's numbers (seven identical rows), and browser.process() — Playwright's Browser has none, so it never measured RSS. A premise now proves every sample is a fresh document (timeOrigin).
- e2e/v3local (local slot, 6 reloads): heap 100.8 -> 100.9 MB (0.0 MB/reload), documents 3 throughout, GPU RSS 292 -> 299 MB (+1.0 MB/reload), renderer 496 -> 534 MB (levels off). editor-ui-33 — the suite that used to die — green 36/0 through its reloads (e2e/v3a).
  So: no leak found ACROSS reloads; the 29 MB was most likely heap read without a forced GC on the 1.33 union. Thresholds: heap <= 5 MB/reload, GPU RSS <= 25 MB/reload.
- The one real leak on the way (WITHIN a page): sessions.renderSceneThumbnail returned early on an empty bounding box, or threw, WITHOUT dispose()/forceContextLoss() — a WebGL context per call held until GC, and Chromium caps live contexts at 16. Released in a finally on every exit now.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 src/lib/sessions.js              | 14 +++++---
 tests/e2e/reload-memory.test.cjs | 59 ++++++++++++++++++--------------
 2 files changed, 43 insertions(+), 30 deletions(-)

diff --git a/src/lib/sessions.js b/src/lib/sessions.js
index c7d2d64cf..64292377b 100644
--- a/src/lib/sessions.js
+++ b/src/lib/sessions.js
@@ -162,12 +162,14 @@ export function viewportThumbnail(maxW = 256) {
 
 /** The saved entry's picture. @param {any} group @returns {string|null} */
 function renderSceneThumbnail(group) {
+	/** @type {THREE.WebGLRenderer | null} */
+	let renderer = null;
 	try {
 		if (!group || group.children.length === 0) return null;
 		// the live viewport first — see viewportThumbnail for why
 		const live = viewportThumbnail();
 		if (live) return live;
-		const renderer = new THREE.WebGLRenderer({ antialias: true, alpha: true });
+		renderer = new THREE.WebGLRenderer({ antialias: true, alpha: true });
 		renderer.setSize(256, 160);
 		const scene = new THREE.Scene();
 		scene.background = new THREE.Color('#232a33');
@@ -182,13 +184,15 @@ function renderSceneThumbnail(group) {
 		camera.position.copy(center).add(new THREE.Vector3(size * 0.65, size * 0.5, size * 0.85));
 		camera.lookAt(center);
 		renderer.render(scene, camera);
-		const url = renderer.domElement.toDataURL('image/webp', 0.7);
-		renderer.dispose();
-		renderer.forceContextLoss?.();
-		return url;
+		return renderer.domElement.toDataURL('image/webp', 0.7);
 	} catch (error) {
 		console.log('session thumbnail failed', error);
 		return null;
+	} finally {
+		// every exit, the empty-box early return and a throw included: a renderer that is not
+		// released holds its WebGL context until GC, and Chromium caps live contexts at 16
+		renderer?.dispose();
+		renderer?.forceContextLoss?.();
 	}
 }
 
diff --git a/tests/e2e/reload-memory.test.cjs b/tests/e2e/reload-memory.test.cjs
index 717bc4d87..6deeb6836 100644
--- a/tests/e2e/reload-memory.test.cjs
+++ b/tests/e2e/reload-memory.test.cjs
@@ -11,7 +11,6 @@
 // GPU process). Evidence: EVIDENCE/reload-memory.json.
 const fs = require('fs');
 const path = require('path');
-const { execSync } = require('child_process');
 const h = require('./helpers.cjs');
 
 const RELOADS = Number(process.env.RELOADS || 6);
@@ -22,48 +21,55 @@ const EVIDENCE = process.env.EVIDENCE || path.join(process.env.HOME || '.', '.co
 const MAX_HEAP_MB_PER_RELOAD = Number(process.env.MAX_HEAP_MB_PER_RELOAD || 5);
 const MAX_GPU_MB_PER_RELOAD = Number(process.env.MAX_GPU_MB_PER_RELOAD || 25);
 
-/** RSS (MB) of the renderer + gpu processes under this browser @param {number} rootPid */
-function processRss(rootPid) {
-	const rows = execSync('ps -eo pid=,ppid=,rss=,args=', { encoding: 'utf8', maxBuffer: 64 << 20 })
-		.split('\n')
-		.map((l) => /^\s*(\d+)\s+(\d+)\s+(\d+)\s+(.*)$/.exec(l))
-		.filter((m) => m !== null)
-		.map((m) => ({ pid: +m[1], ppid: +m[2], rss: +m[3], args: m[4] }));
-	const mine = new Set([rootPid]);
-	for (let grew = true; grew; ) {
-		grew = false;
-		for (const r of rows) if (mine.has(r.ppid) && !mine.has(r.pid)) mine.add(r.pid), (grew = true);
+/** RSS (MB) of the renderer + gpu processes of this browser, by type, from Chromium's own process
+ * list (SystemInfo.getProcessInfo — Playwright's Browser has no process(), only a BrowserServer
+ * does, so the first version never measured these). /proc is local only: on a remote slot the
+ * browser runs elsewhere and this answers null. @param {any} bcdp */
+async function processRss(bcdp) {
+	try {
+		const { processInfo } = await bcdp.send('SystemInfo.getProcessInfo');
+		const rss = (/** @type {number} */ pid) => {
+			const m = /VmRSS:\s+(\d+) kB/.exec(fs.readFileSync(`/proc/${pid}/status`, 'utf8'));
+			return m ? +m[1] / 1024 : 0;
+		};
+		const sum = (/** @type {string} */ type) => Math.round(processInfo.filter((/** @type {any} */ p) => p.type === type).reduce((t, /** @type {any} */ p) => t + rss(p.id), 0));
+		return { renderer: sum('renderer'), gpu: sum('GPU') };
+	} catch {
+		return { renderer: null, gpu: null };
 	}
-	const sum = (/** @type {RegExp} */ re) => Math.round(rows.filter((r) => mine.has(r.pid) && re.test(r.args)).reduce((t, r) => t + r.rss, 0) / 1024);
-	return { renderer: sum(/--type=renderer/), gpu: sum(/--type=gpu-process/) };
 }
 
 h.run(async () => {
 	const browser = await h.launch();
-	const rootPid = browser.process?.()?.pid ?? 0;
+	const bcdp = await browser.newBrowserCDPSession();
 	const A = await h.setupPage(browser, 'A');
+	// Runtime.getHeapUsage + Memory.getDOMCounters are read FRESH per call; the first version read
+	// Performance.getMetrics, which on a reloaded target kept answering the first document's
+	// numbers (seven byte-identical rows), so it could not see growth at all
 	const cdp = await A.page.context().newCDPSession(A.page);
-	await cdp.send('Performance.enable');
 	await cdp.send('HeapProfiler.enable');
 	const sample = async (/** @type {number} */ i) => {
 		await A.page.waitForTimeout(SETTLE_MS);
 		await cdp.send('HeapProfiler.collectGarbage');
 		await cdp.send('HeapProfiler.collectGarbage');
-		const m = Object.fromEntries((await cdp.send('Performance.getMetrics')).metrics.map((/** @type {any} */ x) => [x.name, x.value]));
+		const heap = await cdp.send('Runtime.getHeapUsage');
+		const dom = await cdp.send('Memory.getDOMCounters');
 		const gl = await A.page.evaluate(() => {
 			/** @type {any} */ let r;
-			window.__stores.renderer?.subscribe?.((/** @type {any} */ v) => (r = v))?.();
+			window.__stores.globalRenderer.subscribe((/** @type {any} */ v) => (r = v))();
 			return r?.info?.memory ?? null;
 		}).catch(() => null);
+		// the premise: every sample is a FRESH document (an unchanged timeOrigin = no reload happened)
+		const origin = await A.page.evaluate(() => performance.timeOrigin);
 		return {
 			reload: i,
-			heapMB: Math.round((m.JSHeapUsedSize / 1048576) * 10) / 10,
-			documents: m.Documents,
-			frames: m.Frames,
-			nodes: m.Nodes,
-			listeners: m.JSEventListeners,
+			origin,
+			heapMB: Math.round((heap.usedSize / 1048576) * 10) / 10,
+			documents: dom.documents,
+			nodes: dom.nodes,
+			listeners: dom.jsEventListeners,
 			gl,
-			...(rootPid ? processRss(rootPid) : {})
+			...(await processRss(bcdp))
 		};
 	};
 	/** @type {any[]} */
@@ -85,13 +91,16 @@ h.run(async () => {
 	fs.writeFileSync(path.join(EVIDENCE, 'reload-memory.json'), JSON.stringify({ at: new Date().toISOString(), url: h.URL, rows, crashed }, null, 1));
 
 	h.check(!crashed, `the tab survives ${RELOADS} reloads (${crashed || 'all of them'})`);
+	h.check(new Set(rows.map((r) => r.origin)).size === rows.length, `premise: each sample is a fresh document (${new Set(rows.map((r) => r.origin)).size} distinct of ${rows.length})`);
 	// growth from the FIRST reload on: reload 0 -> 1 warms caches every app has
 	const from = rows[1] ?? rows[0];
 	const last = rows[rows.length - 1];
 	const n = Math.max(1, last.reload - from.reload);
 	const heapPer = (last.heapMB - from.heapMB) / n;
 	h.check(heapPer <= MAX_HEAP_MB_PER_RELOAD, `JS heap after GC grows <= ${MAX_HEAP_MB_PER_RELOAD} MB per reload (${heapPer.toFixed(1)} MB/reload: ${rows.map((r) => r.heapMB).join(' → ')})`);
-	h.check(rows.slice(1).every((r) => r.documents <= 2), `no old document is retained (live Documents per reload: ${rows.map((r) => r.documents).join(', ')})`);
+	// an absolute count says little (the page legitimately owns more than one: iframes, an inert
+	// template document); a RETAINED old document shows up as the count climbing reload by reload
+	h.check(last.documents <= from.documents, `no old document is retained (live Documents per reload: ${rows.map((r) => r.documents).join(', ')})`);
 	if (last.gpu != null && from.gpu != null) {
 		const gpuPer = (last.gpu - from.gpu) / n;
 		h.check(gpuPer <= MAX_GPU_MB_PER_RELOAD, `GPU process RSS grows <= ${MAX_GPU_MB_PER_RELOAD} MB per reload (${gpuPer.toFixed(1)} MB/reload: ${rows.map((r) => r.gpu).join(' → ')})`);

From 68cf1ce2df27e98a63adcc7482b5e0b825be53a3 Mon Sep 17 00:00:00 2001
From: AlexZ005 <alexz005.info@gmail.com>
Date: Sat, 24 Oct 2026 19:43:13 +0300
Subject: [PATCH 30/46] [ci] test-health-1 P3: e2e-smoke is a gate now

continue-on-error removed. b4b46abd made the runner step able to fail at all (it used to '|| echo' every red away) and retries a failed suite once (green on the retry = flaky, reported); a known flake goes into tests/e2e/quarantine.json with an owner and a review date. Green on GitHub for bc453ae8 and e77ca3f7 (script-guard first try both times; the one red was b4b46abd, which bc453ae8's diagnostics followed). The header now says why it gates instead of why it did not.

For the owner / orchestrator: add 'e2e-smoke' to the 'main: checks' ruleset once this reaches main (protection/apply.sh carries the line).

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 .github/workflows/ci.yml | 14 ++++++--------
 1 file changed, 6 insertions(+), 8 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 8691b23a3..170e924b0 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -5,11 +5,11 @@
 # enforced by whoever remembered to run it, and a broken main was discovered at release
 # time. Everything below is what a maintainer already does by hand.
 #
-# WHY e2e-smoke IS NOT REQUIRED YET: it renders WebGL through SwiftShader on a GPU-less
-# runner, and this project's own notes measure ~4.5 fps there plus a documented family of
-# timing-sensitive suites. Blocking every PR on that before it has been observed green on
-# GitHub would train people to ignore a red tick, which is worse than not having it. It
-# reports, it does not gate, and the comment below says when to flip it.
+# e2e-smoke GATES since test-health-1 (feat/60). It renders WebGL through SwiftShader on a
+# GPU-less runner (~4.5 fps), so it was report-only until it had been seen green on GitHub:
+# the runner step now really fails (it used to `|| echo` every red away), a failed suite runs
+# once more (green on the retry = flaky, reported), and a known flake is entered in
+# tests/e2e/quarantine.json with an owner and a review date instead of blocking every PR.
 #
 # Two-peer suites stay a MANUAL gate: they meet on the self-hosted signaling box, which a
 # public runner cannot reach and should not be pointed at.
@@ -150,9 +150,7 @@ jobs:
 
   e2e-smoke:
     runs-on: ubuntu-latest
-    # NOT a gate yet — see the header. Flip this to false once it has been green on a few
-    # PRs in a row; until then a red here is a signal to read, not a block.
-    continue-on-error: true
+    # a gate — see the header (green on GitHub for bc453ae8 and e77ca3f7 before the flip)
     steps:
       - uses: actions/checkout@v4
       - uses: actions/setup-node@v4

From d31552ad60e3dd6a6cfa96203957665a0bdf07dd Mon Sep 17 00:00:00 2001
From: AlexZ005 <alexz005.info@gmail.com>
Date: Sat, 24 Oct 2026 19:45:36 +0300
Subject: [PATCH 31/46] [fix] test-health-1 P2: the local feet reading survives
 a slow frame; avatar-feet 1.7 says what it saw
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

localFeet() dropped the walker's feet after a fixed 250 ms. The writer runs once per frame and the camera broadcast reads the previous frame's write, so below ~4 fps (or on any >250 ms hitch) every reading was stale, the camera message went out without feet, and peers hung the body under the head (3a1ec3eb's own fallback). Stale now after max(250 ms, 2 frames) — Scene passes its frame time. This is from code reading (the root-cause pass): no before/after run isolates it.

avatar-feet 1.7 prints the origin y per stride. e2e/v4b: 12.2 3.0 0.7 0.7 0.2 0.2 0.0 0.0 cm — no sinking and no stride without feet, but a 12 cm rise at the start of the walk that settles over ~400 ms on software GL (green on the GPU PC). Source not found: quarantined by name (owner, 2026-11-07 review) rather than loosened.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 src/components/Scene.svelte    | 2 +-
 src/lib/avatars/avatarState.js | 9 ++++++---
 tests/e2e/avatar-feet.test.cjs | 2 +-
 tests/e2e/quarantine.json      | 5 ++++-
 4 files changed, 12 insertions(+), 6 deletions(-)

diff --git a/src/components/Scene.svelte b/src/components/Scene.svelte
index 8ae36b01a..dd72239bb 100644
--- a/src/components/Scene.svelte
+++ b/src/components/Scene.svelte
@@ -395,7 +395,7 @@
 			// so its local position put every walking player 0.9 m into the floor on every peer.
 			camera.current.updateWorldMatrix(true, false);
 			camera.current.matrixWorld.decompose(camContentPos, camContentQuat, camFeetPoint);
-			const feetWorld = localFeet();
+			const feetWorld = localFeet(delta * 1000);
 			const camExtras: Record<string, number> = {};
 			if (feetWorld !== null) {
 				camFeetPoint.set(camContentPos.x, feetWorld, camContentPos.z);
diff --git a/src/lib/avatars/avatarState.js b/src/lib/avatars/avatarState.js
index 256d51dd2..c35cf182e 100644
--- a/src/lib/avatars/avatarState.js
+++ b/src/lib/avatars/avatarState.js
@@ -63,11 +63,14 @@ export function setLocalFeet(y) {
 	feetY = Number.isFinite(y) ? /** @type {number} */ (y) : null;
 	feetAt = typeof performance !== 'undefined' ? performance.now() : 0;
 }
-/** @returns {number | null} */
-export function localFeet() {
+/** @param {number} [frameMs] the reader's frame time: the writer runs once per frame and the reader
+ * sees the previous frame's write, so below ~4 fps a fixed 250 ms called every reading stale and the
+ * body fell under the head on every peer (avatar-feet 1.7; any >250 ms hitch did it too)
+ * @returns {number | null} */
+export function localFeet(frameMs = 0) {
 	if (feetY === null) return null;
 	const now = typeof performance !== 'undefined' ? performance.now() : 0;
-	return now - feetAt > FEET_STALE_MS ? null : feetY;
+	return now - feetAt > Math.max(FEET_STALE_MS, 2 * frameMs) ? null : feetY;
 }
 
 // 37 R22: THIS player is "knocked off" — no input for `knockedAfterSeconds`. The camera broadcast
diff --git a/tests/e2e/avatar-feet.test.cjs b/tests/e2e/avatar-feet.test.cjs
index 21449ee89..5496db9ba 100644
--- a/tests/e2e/avatar-feet.test.cjs
+++ b/tests/e2e/avatar-feet.test.cjs
@@ -89,7 +89,7 @@ h.run(async () => {
 	const hiRun = runSoles.length ? Math.max(...runSoles) : 0;
 	h.check(hiWalk <= FLOOR_TOL, `1.6 ...a walking stance foot stays on it (${walkSoles.length} walk samples, highest lowest-sole ${(hiWalk * 100).toFixed(1)} cm)`);
 	h.check(hiRun <= 0.13, `1.6b ...a run's flight phase stays a hop (${runSoles.length} run samples, highest ${(hiRun * 100).toFixed(1)} cm <= 13)`);
-	h.check(strides.every((s) => Math.abs(s.feet[1]) < 0.02), '1.7 the body origin stays on the floor while walking (no sinking)');
+	h.check(strides.every((s) => Math.abs(s.feet[1]) < 0.02), `1.7 the body origin stays on the floor while walking (no sinking; origin y per stride, cm: ${strides.map((s) => (s?.feet ? (s.feet[1] * 100).toFixed(1) : 'none')).join(' ')})`);
 
 	// ---- 2. a Character Controller on a raised floor (a 0.3 m step) ---------------------------
 	// a REAL Character Controller node (the flow runtime re-declares charControl from the graph
diff --git a/tests/e2e/quarantine.json b/tests/e2e/quarantine.json
index 8007cff17..f7d8cee83 100644
--- a/tests/e2e/quarantine.json
+++ b/tests/e2e/quarantine.json
@@ -17,6 +17,7 @@
 		{"suite": "flow-physics-actions", "check": "8.5 and the very NEXT press throws the box", "reason": "stale-press guard vs frame timing (pcA, deps-1)", "owner": "test-health (standing lane)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "select-41", "check": "G4 (near) a finger on the crate takes it", "reason": "G4 flick timing: 12/12 green on --local, red under load (deps-1 ab3)", "owner": "test-health (standing lane)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "avatar-feet", "check": "1.3 standing: B's lowest sole is on the floor", "reason": "red 2/4 d3d12, 3/3 llvmpipe, green on rerun (mux-pc-host)", "owner": "test-health (standing lane)", "since": "2026-10-23", "review": "2026-11-07"},
+		{"suite": "avatar-feet", "check": "1.7 the body origin stays on the floor while walking", "reason": "software GL: a 12 cm rise at the start of the walk that settles over ~400 ms (origin y per stride 12.2 3.0 0.7 0.7 0.2 0.2 0.0 0.0 cm, e2e/v4b) — not sinking, and the feet are on the wire every stride since the localFeet staleness fix; green on the GPU PC (pcbat). Source of the 12 cm not found", "owner": "test-health (standing lane)", "since": "2026-10-24", "review": "2026-11-07"},
 		{"suite": "aquarium-reef", "check": "2.1 every fallback group built its PACK model", "reason": "1 red in 3 on each GPU path: pack fetch vs the wait (mux-pc-host)", "owner": "test-health (standing lane)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "aquarium-reef", "check": "2.2 every group DRAWS a pack level", "reason": "as 2.1 (mux-pc-host)", "owner": "test-health (standing lane)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "pack-behavior", "check": "7.2 OPEN: the capsule walks through the doorway", "reason": "a fixed 300 ms wait vs charController's lazy physics import; base 1/3 red (59-replace)", "owner": "test-health (standing lane)", "since": "2026-10-23", "review": "2026-11-07"},
@@ -38,6 +39,8 @@
 		{"suite": "shader-sync", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "timeline-export", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "touch-actions", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
-		{"suite": "water-migration", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"}
+		{"suite": "water-migration", "check": "aquarium (saved on 1.22) looks the same", "reason": "looks the same by eye (golden vs today, e2e/migration/*-now.png, test-health-1 2026-10-24); the measured change is a global tone shift (mean sum-of-channels delta 3.8-9.3, identical run to run with autoQuality pinned) plus the pool rim band — render changes since the goldens (bd143435). OWNER DECISION: re-baseline the goldens on today's build (drops the 'rendered by 1.22' provenance) or a perceptual metric; NOT a threshold raise", "owner": "test-health (standing lane) + owner decision", "since": "2026-10-24", "review": "2026-11-07"},
+		{"suite": "water-migration", "check": "pool-party (saved on 1.22) looks the same", "reason": "looks the same by eye (golden vs today, e2e/migration/*-now.png, test-health-1 2026-10-24); the measured change is a global tone shift (mean sum-of-channels delta 3.8-9.3, identical run to run with autoQuality pinned) plus the pool rim band — render changes since the goldens (bd143435). OWNER DECISION: re-baseline the goldens on today's build (drops the 'rendered by 1.22' provenance) or a perceptual metric; NOT a threshold raise", "owner": "test-health (standing lane) + owner decision", "since": "2026-10-24", "review": "2026-11-07"},
+		{"suite": "water-migration", "check": "island-ocean (saved on 1.22) looks the same", "reason": "looks the same by eye (golden vs today, e2e/migration/*-now.png, test-health-1 2026-10-24); the measured change is a global tone shift (mean sum-of-channels delta 3.8-9.3, identical run to run with autoQuality pinned) plus the pool rim band — render changes since the goldens (bd143435). OWNER DECISION: re-baseline the goldens on today's build (drops the 'rendered by 1.22' provenance) or a perceptual metric; NOT a threshold raise", "owner": "test-health (standing lane) + owner decision", "since": "2026-10-24", "review": "2026-11-07"}
 	]
 }

From fec7d8974dbab0de5302cc09072787052825296d Mon Sep 17 00:00:00 2001
From: AlexZ005 <alexz005.info@gmail.com>
Date: Sat, 24 Oct 2026 19:47:10 +0300
Subject: [PATCH 32/46] [test] test-health-1 P2: select-41 waits on the grab
 and the crate, and G14 names what the finger hit
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

G4 (flick): fingerCarry read 'carrying' after a fixed 250 ms and the flick aimed at the crate after a fixed 1.5 s settle — at ~4 fps the light crate was still sliding from the far carry, so the finger landed beside it (taken: null, 0.00 m/s). Wait for the carry to exist and for the crate to come to rest. Green (3.18 m/s throw).
G14 (unfolded): taps wait until the PAGE is 450 ms past the last pointerup (a tap inside 400 ms of page time is a double-tap, which does not deselect), and the check prints the gizmo state at the tap. That showed the real cause — e2e/v4b: [pointerup, axis XYZ, dragging true]: the finger lands on the seated gizmo's centre handle and TransformControls starts a drag, so whether the tap lets go depends on listener order (green in v4b, red in base/v3b). The product fix is the next commit. 56/0 (e2e/v4b).

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 tests/e2e/select-41.test.cjs | 37 ++++++++++++++++++++++++++++++++----
 1 file changed, 33 insertions(+), 4 deletions(-)

diff --git a/tests/e2e/select-41.test.cjs b/tests/e2e/select-41.test.cjs
index bd49b7e91..28f2a8827 100644
--- a/tests/e2e/select-41.test.cjs
+++ b/tests/e2e/select-41.test.cjs
@@ -329,8 +329,10 @@ h.run(async () => {
 		const t0 = await screenOf(P, uuid, dx, dy);
 		const cam0 = (await store(P, 'globalCamera')) ? await P.evaluate(() => { let c; window.__stores.globalCamera.subscribe((v) => (c = v))(); return c.position.toArray(); }) : null;
 		await touch.send('touchStart', t0.x, t0.y);
-		await P.waitForTimeout(250);
-		const taken = await P.evaluate(() => window.__stores.playInteract.playInteractDebug().carrying);
+		// wait for the grab instead of a fixed 250 ms (a frame or two on software GL); the move starts
+		// from a carry that exists, and a carry that never comes still reads as not taken
+		const taken = await P.waitForFunction((u) => window.__stores.playInteract.playInteractDebug().carrying === u, uuid, { timeout: 3000 })
+			.then(() => uuid, () => P.evaluate(() => window.__stores.playInteract.playInteractDebug().carrying));
 		const t1 = await screenOf(P, uuid);
 		const grip0 = t0.local ? await screenOfLocal(P, uuid, t0.local) : null;
 		for (let i = 1; i <= steps; i++) {
@@ -402,7 +404,14 @@ h.run(async () => {
 	h.check(c.hit && c.taken, 'G4 (far) the finger takes the crate 10 m away');
 	h.check(c.jump < 8 && Math.abs(dist1 - dist0) < 0.6, `G4 (far) it stays at its distance (${dist0.toFixed(2)} -> ${dist1.toFixed(2)} m, jump ${c.jump.toFixed(1)} px)`);
 	h.check(c.track < 14, `G4 (far) and follows the finger (off by ${c.track.toFixed(1)} px)`);
-	await P.waitForTimeout(1500);
+	// the flick aims at where the crate IS: wait for the far carry's release to come to rest (a fixed
+	// 1.5 s left a light crate still sliding at ~4 fps, so the finger landed beside it)
+	await h.eventually(
+		() => P.evaluate((u) => window.__stores.physics.bodyVelocityOf(u), crate),
+		(v) => !!v && Math.hypot(...v.linvel) < 0.05,
+		'(premise) the crate is at rest before the flick',
+		15000
+	);
 
 	// a FLICK: released mid-move, the throw is bounded
 	const crateAt2 = (await screenOf(P, crate)).pos;
@@ -419,6 +428,11 @@ h.run(async () => {
 	const U = await h.setupPage(browser, 'unfolded', { context: N6_UNFOLDED, storage: STORAGE });
 	const Q = U.page;
 	const touchU = await touchApi(Q);
+	// a tap within 400 ms of the last one is a DOUBLE-tap (Scene.svelte), which does not deselect — on the
+	// PAGE's clock. A long software-GL frame makes 700 ms of test time less than that in the app, so each
+	// tap below waits until the page itself is 450 ms past the last pointerup
+	await Q.evaluate(() => window.addEventListener('pointerup', () => (window.__lastUp = Date.now()), true));
+	const pastDoubleTap = () => Q.waitForFunction(() => Date.now() - (window.__lastUp ?? 0) > 450);
 	await look(Q, [0, 3, 6], [0, 0.5, 0]);
 	const ua = await make(Q, [-1.2, 0.5, 0]);
 	await rest(Q);
@@ -427,9 +441,24 @@ h.run(async () => {
 	await touchU.tap(at.x, at.y);
 	await Q.waitForTimeout(700);
 	h.check(JSON.stringify(await sel(Q)) === JSON.stringify([ua]), 'G14 (unfolded) a tap selects');
+	await pastDoubleTap();
+	// what the finger lands on: the folded run passes with the same code, and on this larger screen the
+	// seated gizmo may cover the box — a red says whether the tap reached a gizmo handle (axis/dragging)
+	await Q.evaluate(() => {
+		const w = /** @type {any} */ (window);
+		w.__gz = [];
+		const note = (/** @type {string} */ t) => {
+			let tc;
+			w.__stores.TControls?.subscribe?.((/** @type {any} */ v) => (tc = v))?.();
+			w.__gz.push([t, tc?.axis ?? null, !!tc?.dragging]);
+		};
+		for (const t of ['pointerdown', 'pointerup']) window.addEventListener(t, () => note(t), { capture: true, once: true });
+	});
 	await touchU.tap(at.x, at.y);
 	await Q.waitForTimeout(700);
-	h.check((await sel(Q)).length === 0, `G14 (unfolded) a tap on the selected box deselects it (${JSON.stringify(await sel(Q))})`);
+	const gizmo = await Q.evaluate(() => /** @type {any} */ (window).__gz);
+	h.check((await sel(Q)).length === 0, `G14 (unfolded) a tap on the selected box deselects it (${JSON.stringify(await sel(Q))}; gizmo at the tap ${JSON.stringify(gizmo)})`);
+	await pastDoubleTap();
 	await touchU.tap(at.x, at.y);
 	await Q.waitForTimeout(700);
 	const modeCell = '#editor-mode-toggle';

From 62ea2ad4c1a3dbc155ec6bd2d8e66900944b79ec Mon Sep 17 00:00:00 2001
From: AlexZ005 <alexz005.info@gmail.com>
Date: Sat, 24 Oct 2026 19:51:49 +0300
Subject: [PATCH 33/46] [test] test-health-1 P2: helpers.connect opens a
 squeezed connect pill; net-stress runs again
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

44 M14 squeezes the floating connect pill to its status dot on a narrow window, and the dial input shows only after a tap on the dot — helpers.connect never pressed it, so every two-peer suite on a narrow viewport (net-stress's 800 px) died at 'could not fill the peer id' before checking anything (red at base the same way). connect presses #connect-squeeze-dot first when that is what is there.

net-stress (e2e/v4a): the four-peer mesh fills (12/12 pairs, host-only dials), every host message lands (60/60 x3), fan-out bounded, every pair delivered under load, no freeze. Section 5's three rate checks need a GPU (four software-GL pages orbit at 1 fps; the suite says so itself) — quarantined by name, the whole-suite entry dropped.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 tests/e2e/helpers.cjs     | 15 ++++++++++-----
 tests/e2e/quarantine.json |  4 +++-
 2 files changed, 13 insertions(+), 6 deletions(-)

diff --git a/tests/e2e/helpers.cjs b/tests/e2e/helpers.cjs
index 748ef1d3f..740f0cc68 100644
--- a/tests/e2e/helpers.cjs
+++ b/tests/e2e/helpers.cjs
@@ -274,6 +274,10 @@ async function connect(from, to, settleMs = 9000) {
 			peer.id = live;
 		}
 	}
+	// 44 M14: on a narrow window (net-stress's 800 px) the floating pill is SQUEEZED to its status dot,
+	// and the dial input shows only after a tap on it — press it first when it is what is there
+	const squeezedDot = from.page.locator('#connect-squeeze-dot');
+	if (await squeezedDot.isVisible().catch(() => false)) await squeezedDot.click();
 	await step(from, 'fill the peer id', () =>
 		from.page.locator('input[placeholder="Enter peer ID to connect"]').fill(to.id)
 	);
@@ -556,9 +560,9 @@ async function centeredClip(peer, world, size = 360) {
  * @param {any} page @param {Buffer} before @param {Buffer} after @param {number} [threshold]
  * @returns {Promise<{changed: number, total: number, fraction: number, mean: number, max: number, width: number, height: number, error?: string}>}
  */
-async function frameDelta(page, before, after, threshold = 6) {
+async function frameDelta(page, before, after, threshold = 6, skipTop = 0) {
 	return page.evaluate(
-		async ({ a, b, threshold, decodeSource }) => {
+		async ({ a, b, threshold, skipTop, decodeSource }) => {
 			const decode = eval(decodeSource);
 			const A = await decode(a);
 			const B = await decode(b);
@@ -567,7 +571,8 @@ async function frameDelta(page, before, after, threshold = 6) {
 			let changed = 0;
 			let sum = 0;
 			let max = 0;
-			for (let i = 0; i < A.data.length; i += 4) {
+			// skipTop: rows left out of the comparison (chrome a reference image captured over the canvas)
+			for (let i = skipTop * A.width * 4; i < A.data.length; i += 4) {
 				const delta =
 					Math.abs(A.data[i] - B.data[i]) +
 					Math.abs(A.data[i + 1] - B.data[i + 1]) +
@@ -576,7 +581,7 @@ async function frameDelta(page, before, after, threshold = 6) {
 				sum += delta;
 				if (delta > max) max = delta;
 			}
-			const total = A.data.length / 4;
+			const total = A.data.length / 4 - skipTop * A.width;
 			return {
 				changed,
 				total,
@@ -587,7 +592,7 @@ async function frameDelta(page, before, after, threshold = 6) {
 				height: A.height
 			};
 		},
-		{ a: before.toString('base64'), b: after.toString('base64'), threshold, decodeSource: DECODE_FN }
+		{ a: before.toString('base64'), b: after.toString('base64'), threshold, skipTop, decodeSource: DECODE_FN }
 	);
 }
 
diff --git a/tests/e2e/quarantine.json b/tests/e2e/quarantine.json
index f7d8cee83..a7fece556 100644
--- a/tests/e2e/quarantine.json
+++ b/tests/e2e/quarantine.json
@@ -33,7 +33,9 @@
 		{"suite": "fb-water", "check": "...upright", "reason": "software GL (~4 fps): rapier keeps real time only down to 7.5 fps (8 substeps of 1/60 s per frame), so the hull lags waves that follow the session clock — green needs a GPU slot; the test cannot fix the frame rate (test-health-1, e2e/v2)", "owner": "test-health (standing lane)", "since": "2026-10-24", "review": "2026-11-07"},
 		{"suite": "fb-water", "check": "underwater: aligned", "reason": "flips run to run (green on the base, 68.9 vs 37.4 px in e2e/v2): outline vs object read 1 s after a water-quality switch, while the shaders recompile at ~4 fps", "owner": "test-health (standing lane)", "since": "2026-10-24", "review": "2026-11-07"},
 		{"suite": "kit-instancing", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
-		{"suite": "net-stress", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
+		{"suite": "net-stress", "check": "premise: every peer ran well above the 20/s gate", "reason": "section 5 is a RATE claim against display frames and needs a GPU (its own comment): four pages on software GL orbit at 1 fps, so the 20/s gate cannot be exercised (e2e/v4a; sections 1-4 and the freeze check green)", "owner": "test-health (standing lane)", "since": "2026-10-24", "review": "2026-11-07"},
+		{"suite": "net-stress", "check": "premise: the camera stream flows between every pair while orbiting", "reason": "section 5 is a RATE claim against display frames and needs a GPU (its own comment): four pages on software GL orbit at 1 fps, so the 20/s gate cannot be exercised (e2e/v4a; sections 1-4 and the freeze check green)", "owner": "test-health (standing lane)", "since": "2026-10-24", "review": "2026-11-07"},
+		{"suite": "net-stress", "check": "presence is gated, not per frame", "reason": "section 5 is a RATE claim against display frames and needs a GPU (its own comment): four pages on software GL orbit at 1 fps, so the 20/s gate cannot be exercised (e2e/v4a; sections 1-4 and the freeze check green)", "owner": "test-health (standing lane)", "since": "2026-10-24", "review": "2026-11-07"},
 		{"suite": "phone-sheets", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "scene-post", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "shader-sync", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},

From cfcc5e15972d0bf9a1eb4d33f9070e8bf864577e Mon Sep 17 00:00:00 2001
From: AlexZ005 <alexz005.info@gmail.com>
Date: Sat, 24 Oct 2026 20:00:08 +0300
Subject: [PATCH 34/46] [test] test-health-1 P2: water-migration compares the
 scene, not the chrome in its goldens; two scenes wait on an owner call
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Measured, not guessed (e2e/migration/*-now.png beside tests/fixtures/golden-1.22): the 1.22 goldens carry a strip of UI chrome along their top edge (the connect pill sat inside CLIP on that build) — half of every scene's changed pixels. frameDelta takes an optional skipTop (default 0, every other caller unchanged) and the suite skips the golden's chrome rows. The quality governor is pinned too (autoQuality false): a pixel comparison cannot have dpr/shadows/AO changing under it.

e2e/v4mig: aquarium 3.59% -> 1.22% (passes; its quarantine entry dropped). pool-party 5.26% and island-ocean 8.53% stay over the 3% line: by eye the scenes are the same — the change is a global tone shift (mean sum-of-channels delta ~4-9, identical run to run) plus the band along the pool rim, i.e. render changes since bd143435. Kept in the quarantine tier with that evidence and an OWNER DECISION: re-baseline the goldens on today's build (dropping their 'rendered by 1.22' provenance) or move to a perceptual metric. Not a threshold raise.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 tests/e2e/quarantine.json          | 1 -
 tests/e2e/water-migration.test.cjs | 7 +++++--
 2 files changed, 5 insertions(+), 3 deletions(-)

diff --git a/tests/e2e/quarantine.json b/tests/e2e/quarantine.json
index a7fece556..283c93976 100644
--- a/tests/e2e/quarantine.json
+++ b/tests/e2e/quarantine.json
@@ -41,7 +41,6 @@
 		{"suite": "shader-sync", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "timeline-export", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "touch-actions", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
-		{"suite": "water-migration", "check": "aquarium (saved on 1.22) looks the same", "reason": "looks the same by eye (golden vs today, e2e/migration/*-now.png, test-health-1 2026-10-24); the measured change is a global tone shift (mean sum-of-channels delta 3.8-9.3, identical run to run with autoQuality pinned) plus the pool rim band — render changes since the goldens (bd143435). OWNER DECISION: re-baseline the goldens on today's build (drops the 'rendered by 1.22' provenance) or a perceptual metric; NOT a threshold raise", "owner": "test-health (standing lane) + owner decision", "since": "2026-10-24", "review": "2026-11-07"},
 		{"suite": "water-migration", "check": "pool-party (saved on 1.22) looks the same", "reason": "looks the same by eye (golden vs today, e2e/migration/*-now.png, test-health-1 2026-10-24); the measured change is a global tone shift (mean sum-of-channels delta 3.8-9.3, identical run to run with autoQuality pinned) plus the pool rim band — render changes since the goldens (bd143435). OWNER DECISION: re-baseline the goldens on today's build (drops the 'rendered by 1.22' provenance) or a perceptual metric; NOT a threshold raise", "owner": "test-health (standing lane) + owner decision", "since": "2026-10-24", "review": "2026-11-07"},
 		{"suite": "water-migration", "check": "island-ocean (saved on 1.22) looks the same", "reason": "looks the same by eye (golden vs today, e2e/migration/*-now.png, test-health-1 2026-10-24); the measured change is a global tone shift (mean sum-of-channels delta 3.8-9.3, identical run to run with autoQuality pinned) plus the pool rim band — render changes since the goldens (bd143435). OWNER DECISION: re-baseline the goldens on today's build (drops the 'rendered by 1.22' provenance) or a perceptual metric; NOT a threshold raise", "owner": "test-health (standing lane) + owner decision", "since": "2026-10-24", "review": "2026-11-07"}
 	]
diff --git a/tests/e2e/water-migration.test.cjs b/tests/e2e/water-migration.test.cjs
index 550124302..60f300197 100644
--- a/tests/e2e/water-migration.test.cjs
+++ b/tests/e2e/water-migration.test.cjs
@@ -23,10 +23,11 @@ const GATED = ['aquarium', 'pool-party', 'island-ocean'];
 const REPORT = ['jelly-room', 'fluid-tank-toy'];
 const T0 = 1791200000000; // a fixed wall clock: the same water phase on every build
 const CLIP = { x: 190, y: 110, width: 900, height: 500 };
+const GOLDEN_CHROME_ROWS = 28;
 
 h.run(async () => {
 	const browser = await h.launch({ args: h.GPU_ARGS });
-	const A = await h.setupPage(browser, 'A', { context: { viewport: { width: 1280, height: 720 } }, storage: { 'water:quality': 'high' } });
+	const A = await h.setupPage(browser, 'A', { context: { viewport: { width: 1280, height: 720 } }, storage: { 'water:quality': 'high', autoQuality: 'false' } }); // test-health-1: the quality governor lowers dpr / shadows / AO on slow frames — a pixel comparison needs it pinned
 	await A.ctx.addInitScript((t) => {
 		Date.now = () => t;
 	}, T0);
@@ -62,7 +63,9 @@ h.run(async () => {
 			h.check(false, `${slug}: no golden (capture with GOLDEN_WRITE=1 on v1.22.0)`);
 			continue;
 		}
-		const d = await h.frameDelta(A.page, fs.readFileSync(goldFile), png, 24);
+		// the 1.22 goldens carry a strip of UI chrome along their top edge (the connect pill was inside
+		// CLIP on that build): compare the scene below it
+		const d = await h.frameDelta(A.page, fs.readFileSync(goldFile), png, 24, GOLDEN_CHROME_ROWS);
 		rows.push(`| ${slug} | ${(d.fraction * 100).toFixed(2)}% | ${d.mean.toFixed(2)} | ${GATED.includes(slug) ? (d.fraction <= MAX_CHANGED ? 'same' : '**DIFFERENT**') : 'reported'} |`);
 		if (GATED.includes(slug))
 			h.check(d.fraction <= MAX_CHANGED, `${slug} (saved on 1.22) looks the same: ${(d.fraction * 100).toFixed(2)}% of the frame changed (max ${(MAX_CHANGED * 100).toFixed(0)}%)`);

From 7451aad93f9349ce8806fae577f76383f57336c2 Mon Sep 17 00:00:00 2001
From: AlexZ005 <alexz005.info@gmail.com>
Date: Sat, 24 Oct 2026 20:04:30 +0300
Subject: [PATCH 35/46] [fix] test-health-1 P2: a real right-click on the
 viewport opens its menu again; a finger tap on the seated gizmo lets go
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

1) RIGHT-CLICK (play-reentry, carried since 1.41 — its recorded explanation 'after a denied XR session' was wrong): OrbitControls listens on threlte's WRAPPER and captures the pointer on every press, the right button included, so where contextmenu fires on mousedown (Linux; Chromium headless) it is dispatched to the capture element — Scene listened on the canvas and never heard it. A one-off probe on a FRESH page proved it general: 0 menu rows, contextmenu target the wrapper DIV. Scene now hears contextmenu on the wrapper (dom) and acts only for the canvas or the wrapper itself (an overlay inside keeps its own menu). Same probe after: 8 rows (e2e/v5probe); play-reentry's two right-click checks green (e2e/v5a). No passing suite drove a REAL canvas right-click before (context-menu-redesign sets the store directly), which is how this lived.

2) GIZMO TAP (select-41 G14): play-reentry-style diagnostics showed the finger landing on the seated gizmo's centre handle — at pointerup TransformControls reports axis XYZ, dragging true — and Scene's still-tap path bailed on 'dragging', so whether a tap let go of the object depended on which pointerup listener ran first. For a finger, past the still-tap test (<= 5 px, <= 400 ms), 'dragging' set by this same press no longer disqualifies the gizmo tap. By the mechanism shown in e2e/v4b; no run yet shows the race losing and then passing. The unfolded block's other flake (a tap voided by a long frame) is quarantined by name.

play-reentry also: the 4c premise waits for the retry's first attempt (bounded 3 s) instead of a fixed 400 ms; the right-click checks print what the click reached.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 src/components/Scene.svelte     | 17 ++++++++++++++---
 tests/e2e/play-reentry.test.cjs | 33 +++++++++++++++++++++++++++++++--
 tests/e2e/quarantine.json       |  3 +++
 3 files changed, 48 insertions(+), 5 deletions(-)

diff --git a/src/components/Scene.svelte b/src/components/Scene.svelte
index dd72239bb..8d84fd686 100644
--- a/src/components/Scene.svelte
+++ b/src/components/Scene.svelte
@@ -1195,8 +1195,12 @@
 			// a touch gizmo covers most of a small object, which is what the finger aims at
 			const touchTap = event.pointerType === 'touch';
 			// (an object's gizmo only — a mesh / spline session's gizmo keeps every tap)
+			// test-health-1: on a finger, `dragging` set by THIS press is not a drag — we are past the
+			// still-tap test above (<= 5 px, <= 400 ms), and the gizmo's own pointerdown starts a drag on
+			// the handle under the finger, so whether a tap on the seated gizmo let go of the object
+			// depended on which pointerup listener ran first (select-41 G14 unfolded: axis XYZ, dragging)
 			const onGizmo =
-				!!$TControls && !$TControls.dragging && !!$TControls.axis && !event.altKey &&
+				!!$TControls && (touchTap || !$TControls.dragging) && !!$TControls.axis && !event.altKey &&
 				!$editingObject && !$faceEditObject && !$splineEditObject && !$measureMode && !splineToolActive();
 			if ($TControls && ($TControls.dragging || ($TControls.axis && !event.altKey)) && !(touchTap && onGizmo)) return;
 			if (!$objectsGroup) return;
@@ -1422,6 +1426,13 @@
 		});
 
 		const onContextMenu = (event) => {
+			// test-health-1: heard on threlte's WRAPPER (`dom`), not the canvas. OrbitControls listens
+			// there and captures the pointer on every press, right button included, so where
+			// `contextmenu` fires on mousedown (Linux; Chromium headless) it is dispatched to the capture
+			// element and a canvas listener never heard it — a real right-click on the viewport opened
+			// nothing (fresh page: 0 menu rows; play-reentry). Canvas events still bubble here; anything
+			// else inside the wrapper keeps its own menu.
+			if (event.target !== element && event.target !== dom) return;
 			event.preventDefault(); // the browser menu never belongs on the canvas
 			const down = rightDown;
 			rightDown = null;
@@ -1431,7 +1442,7 @@
 			if (moved > 5 || Date.now() - down[2] > 400) return;
 			openViewportMenuAt(event.clientX, event.clientY);
 		};
-		element.addEventListener('contextmenu', onContextMenu);
+		dom.addEventListener('contextmenu', onContextMenu);
 
 		// touch long-press = right-click (touch has no contextmenu). A stationary
 		// ~500ms hold opens the same menu at the touch point.
@@ -1666,7 +1677,7 @@
 			stopClap(); // 31
 			stopVrGameInput(); // 30b
 			element.removeEventListener('pointerdown', onPointerDown);
-			element.removeEventListener('contextmenu', onContextMenu);
+			dom.removeEventListener('contextmenu', onContextMenu);
 			element.removeEventListener('webglcontextlost', onContextLost);
 			element.removeEventListener('webglcontextrestored', onContextRestored);
 			window.removeEventListener('pointerup', onPointerUp);
diff --git a/tests/e2e/play-reentry.test.cjs b/tests/e2e/play-reentry.test.cjs
index 7995c2cec..df6893586 100644
--- a/tests/e2e/play-reentry.test.cjs
+++ b/tests/e2e/play-reentry.test.cjs
@@ -245,7 +245,8 @@ h.run(async () => {
 			return Promise.reject(new Error('refused'));
 		};
 		window.__stores.isLocked.set(true);
-		await new Promise((r) => setTimeout(r, 400));
+		// until the retry has really run once (bounded) — a fixed 400 ms saw 0 attempts under load
+		for (const t0 = Date.now(); calls < 1 && Date.now() - t0 < 3000; ) await new Promise((r) => setTimeout(r, 50));
 		const during = calls;
 		window.__stores.isLocked.set(false);
 		await new Promise((r) => setTimeout(r, 900));
@@ -321,12 +322,40 @@ h.run(async () => {
 	);
 	h.check(onCanvas === 'CANVAS', `premise: that pixel is the canvas, not chrome (${onCanvas})`);
 
+	// test-health-1: record what the right-click reaches — red since 1.41 with no product change in
+	// this path found, so a red says WHICH guard ate it (no event / a slow pair past the 400 ms tap
+	// limit / a blocking store)
+	await X.evaluate(() => {
+		const w = /** @type {any} */ (window);
+		w.__rc = [];
+		const name = (/** @type {any} */ el) => (el ? el.tagName + (el.id ? '#' + el.id : '') + (typeof el.className === 'string' && el.className ? '.' + el.className.trim().split(/\s+/).slice(0, 3).join('.') : '') : null);
+		for (const t of ['pointerdown', 'contextmenu'])
+			window.addEventListener(t, (e) => w.__rc.push([t, name(e.target), name(/** @type {any} */ (e.target)?.parentElement), /** @type {any} */ (e).button, Date.now()]), true);
+	});
+	await X.evaluate((p) => (/** @type {any} */ (window).__rcAt = p), at);
 	await X.mouse.click(at.x, at.y, { button: 'right' });
+	let menuOpened = false;
 	await h.eventually(
 		() => X.evaluate(() => document.querySelectorAll('[role="menuitem"]').length),
-		(n) => n > 0,
+		(n) => (menuOpened = n > 0),
 		'right-click opens the viewport context menu after a denied session'
 	);
+	if (!menuOpened)
+		console.log(
+			'  right-click reached: ' +
+				JSON.stringify(
+					await X.evaluate(() => {
+						const s = window.__stores;
+						const g = (/** @type {string} */ k) => {
+							let v;
+							s[k]?.subscribe?.((/** @type {any} */ x) => (v = x))?.();
+							return v;
+						};
+						const el = document.elementFromPoint(/** @type {any} */ (window).__rcAt?.x ?? 0, /** @type {any} */ (window).__rcAt?.y ?? 0);
+						return { rc: /** @type {any} */ (window).__rc, underNow: el ? el.tagName + '#' + el.id + '.' + String(el.className).slice(0, 60) : null, ...Object.fromEntries(['isLocked', 'isVRMode', 'specatorMode', 'drawMode', 'editingObject', 'measureMode'].map((k) => [k, g(k)])) };
+					})
+				)
+		);
 	await X.keyboard.press('Escape');
 	await X.waitForTimeout(200);
 
diff --git a/tests/e2e/quarantine.json b/tests/e2e/quarantine.json
index 283c93976..5ca8c7497 100644
--- a/tests/e2e/quarantine.json
+++ b/tests/e2e/quarantine.json
@@ -16,6 +16,9 @@
 		{"suite": "flow-physics-actions", "check": "4.3 read 'speed' reports real motion", "reason": "as 2.1 (deps-1 ab3)", "owner": "test-health (standing lane)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "flow-physics-actions", "check": "8.5 and the very NEXT press throws the box", "reason": "stale-press guard vs frame timing (pcA, deps-1)", "owner": "test-health (standing lane)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "select-41", "check": "G4 (near) a finger on the crate takes it", "reason": "G4 flick timing: 12/12 green on --local, red under load (deps-1 ab3)", "owner": "test-health (standing lane)", "since": "2026-10-23", "review": "2026-11-07"},
+		{"suite": "select-41", "check": "G14 (unfolded) a tap selects", "reason": "the unfolded N6 page under load: a tap is a click only if its pointerdown->pointerup handlers run within 400 ms of page time, and a long software-GL frame between them voids it — red in 3 of 4 runs, a different first check each time (base, v3b, v5a; green v4b). The other race in this block (the finger landing on the seated gizmo: axis XYZ, dragging true at pointerup, e2e/v4b) is fixed in Scene.svelte", "owner": "test-health (standing lane)", "since": "2026-10-24", "review": "2026-11-07"},
+		{"suite": "select-41", "check": "G13 (unfolded) Interact deselects", "reason": "the unfolded N6 page under load: a tap is a click only if its pointerdown->pointerup handlers run within 400 ms of page time, and a long software-GL frame between them voids it — red in 3 of 4 runs, a different first check each time (base, v3b, v5a; green v4b). The other race in this block (the finger landing on the seated gizmo: axis XYZ, dragging true at pointerup, e2e/v4b) is fixed in Scene.svelte", "owner": "test-health (standing lane)", "since": "2026-10-24", "review": "2026-11-07"},
+		{"suite": "select-41", "check": "G13 (unfolded) and Edit restores", "reason": "the unfolded N6 page under load: a tap is a click only if its pointerdown->pointerup handlers run within 400 ms of page time, and a long software-GL frame between them voids it — red in 3 of 4 runs, a different first check each time (base, v3b, v5a; green v4b). The other race in this block (the finger landing on the seated gizmo: axis XYZ, dragging true at pointerup, e2e/v4b) is fixed in Scene.svelte", "owner": "test-health (standing lane)", "since": "2026-10-24", "review": "2026-11-07"},
 		{"suite": "avatar-feet", "check": "1.3 standing: B's lowest sole is on the floor", "reason": "red 2/4 d3d12, 3/3 llvmpipe, green on rerun (mux-pc-host)", "owner": "test-health (standing lane)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "avatar-feet", "check": "1.7 the body origin stays on the floor while walking", "reason": "software GL: a 12 cm rise at the start of the walk that settles over ~400 ms (origin y per stride 12.2 3.0 0.7 0.7 0.2 0.2 0.0 0.0 cm, e2e/v4b) — not sinking, and the feet are on the wire every stride since the localFeet staleness fix; green on the GPU PC (pcbat). Source of the 12 cm not found", "owner": "test-health (standing lane)", "since": "2026-10-24", "review": "2026-11-07"},
 		{"suite": "aquarium-reef", "check": "2.1 every fallback group built its PACK model", "reason": "1 red in 3 on each GPU path: pack fetch vs the wait (mux-pc-host)", "owner": "test-health (standing lane)", "since": "2026-10-23", "review": "2026-11-07"},

From 3af68d75c9e3c4124f3a62a3ec3ecb86909f2a17 Mon Sep 17 00:00:00 2001
From: AlexZ005 <alexz005.info@gmail.com>
Date: Sat, 24 Oct 2026 20:05:21 +0300
Subject: [PATCH 36/46] [test] test-health-1 P2: char-controller compares speed
 per moving frame, on a level camera
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Fly moves a fixed step per FRAME (PointerLockControls translates by speed each tick), and the suite compared distances over a wall-clock 1200 ms: on software GL the same window was 20 frames once and 10 the next (2.000 vs 1.000 units — the base's 'PARITY 50% apart'). travel() now counts, in-page, the frames in which the rig moved and reports the MEDIAN step (one settling frame at ~3 fps moved a mean 10%). Section 7 re-levels the camera as section 1 does: a rig left pitched by the sections between measured 0.09/frame (0.1 x cos 26 deg) for the same speed. Move Input's release waits for the zero instead of a fixed 300 ms. Green 55/0 (e2e/v5a); quarantine entry dropped.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 tests/e2e/char-controller.test.cjs | 81 ++++++++++++++++++++++--------
 tests/e2e/quarantine.json          |  1 -
 2 files changed, 61 insertions(+), 21 deletions(-)

diff --git a/tests/e2e/char-controller.test.cjs b/tests/e2e/char-controller.test.cjs
index 8407b24c7..15bb36799 100644
--- a/tests/e2e/char-controller.test.cjs
+++ b/tests/e2e/char-controller.test.cjs
@@ -110,16 +110,53 @@ const values = (page) =>
 const dist = (a, b) => Math.hypot(a.x - b.x, a.y - b.y, a.z - b.z);
 const distXZ = (a, b) => Math.hypot(a.x - b.x, a.z - b.z);
 
-/** Hold a key for `ms` and report how far the rig travelled. */
+/** Hold a key for `ms` and report how far the rig travelled — and over how many FRAMES.
+ * Fly moves a fixed step per frame (PointerLockControls translates by `speed` each tick),
+ * so a wall-clock window measures the frame rate as much as the speed: on software GL the
+ * same 1200 ms was 20 frames once and 10 the next (2.000 vs 1.000 units). `perFrame` (the
+ * median step over the frames in which the rig actually moved, from an in-page rAF
+ * sampler) is the number the speed comparisons below read. */
 async function travel(page, code, ms) {
+	await page.evaluate(() => {
+		let cam = null;
+		window.__stores.playerCam.subscribe((c) => (cam = c))();
+		const V = window.__stores.THREE.Vector3;
+		const w0 = cam ? cam.getWorldPosition(new V()) : null;
+		const s = (window.__travelSampler = { frames: 0, on: true, start: w0, last: w0, moved: 0, steps: [] });
+		const step = () => {
+			if (!s.on) return;
+			const w = cam ? cam.getWorldPosition(new V()) : null;
+			if (w && s.last && w.distanceToSquared(s.last) > 1e-10) {
+				s.frames++;
+				s.moved += w.distanceTo(s.last);
+				s.steps.push(w.distanceTo(s.last));
+			}
+			s.last = w;
+			requestAnimationFrame(step);
+		};
+		requestAnimationFrame(step);
+	});
 	const before = await camWorld(page);
 	await page.keyboard.down(code);
 	await page.waitForTimeout(ms);
 	await page.keyboard.up(code);
 	await page.waitForTimeout(150);
 	const after = await camWorld(page);
-	return { before, after, moved: dist(before, after), movedXZ: distXZ(before, after) };
+	// distance and frame count from the SAME sampler window — reading `before` separately put a frame
+	// on one side of the count and not the other (0.092 vs 0.100 per frame over 5)
+	const sampled = await page.evaluate(() => {
+		window.__travelSampler.on = false;
+		return { frames: window.__travelSampler.frames, moved: window.__travelSampler.moved, steps: window.__travelSampler.steps };
+	});
+	const moved = dist(before, after);
+	const frames = sampled.frames;
+	// the MEDIAN step: one settling frame (the first after the controller goes, a grounding nudge) is
+	// a quarter of the sample at ~3 fps and moved the mean 10 %; the speed is what most frames do
+	const sorted = [...sampled.steps].sort((a, b) => a - b);
+	const median = sorted.length ? (sorted.length % 2 ? sorted[(sorted.length - 1) / 2] : (sorted[sorted.length / 2 - 1] + sorted[sorted.length / 2]) / 2) : 0;
+	return { before, after, moved, movedXZ: distXZ(before, after), frames, perFrame: median };
 }
+const perFrameText = (t) => `${t.perFrame.toFixed(4)}/frame (median) over ${t.frames}`;
 
 // ---- driving the graph ------------------------------------------------------
 // THE SCOPE RESET IS LOAD-BEARING (logic-nodes documents the cost): the editor's scope
@@ -197,12 +234,12 @@ h.run(async () => {
 	const WINDOW = 1200;
 	const builtin = await travel(A.page, 'KeyW', WINDOW);
 	h.check(builtin.moved > 0.5, `built-in fly moves the rig (${builtin.moved.toFixed(3)} units)`);
-	// a 1.2s window at 60fps is ~72 frames x 0.1 = ~7.2 units; a wide band, because the
-	// point here is only that the number is the RIGHT ORDER (a stuck or doubled speed
-	// would fall outside it) and the tight comparison is the A/B below
+	// fly at the default 0.1 is 0.1 per moving frame; the band only says the number is the
+	// RIGHT ORDER (a stuck or doubled speed falls outside it) and the tight comparison is the
+	// A/B below
 	h.check(
-		builtin.moved > 2 && builtin.moved < 12,
-		`and by about speed x frames (${builtin.moved.toFixed(2)} units in ${WINDOW}ms)`
+		builtin.perFrame > 0.07 && builtin.perFrame < 0.14,
+		`and by about speed x frames (${builtin.moved.toFixed(2)} units, ${perFrameText(builtin)})`
 	);
 	const stillNull = await charDebug(A.page);
 	h.check(stillNull.control === null, 'flying with no controller node declares nothing');
@@ -223,11 +260,11 @@ h.run(async () => {
 	h.check(declared.moveSpeed === null, 'with no override yet, so the param is what moves you');
 
 	const noded = await travel(A.page, 'KeyW', WINDOW);
-	const gap = Math.abs(noded.moved - builtin.moved) / builtin.moved;
+	const gap = Math.abs(noded.perFrame - builtin.perFrame) / builtin.perFrame;
 	h.check(
 		gap < 0.05,
 		`PARITY: fly@0.1 as a node matches the built-in within 5% ` +
-			`(${builtin.moved.toFixed(3)} vs ${noded.moved.toFixed(3)}, ${(gap * 100).toFixed(1)}% apart)`
+			`(${perFrameText(builtin)} vs ${perFrameText(noded)}, ${(gap * 100).toFixed(1)}% apart)`
 	);
 
 	// the guard has to be able to FAIL: a different authored speed must move you a
@@ -239,10 +276,10 @@ h.run(async () => {
 		'the speed param reaches the store'
 	);
 	const faster = await travel(A.page, 'KeyW', WINDOW);
-	const ratio = faster.moved / noded.moved;
+	const ratio = faster.perFrame / noded.perFrame;
 	h.check(
 		ratio > 2.4 && ratio < 3.6,
-		`3x the speed is ~3x the distance (${noded.moved.toFixed(2)} -> ${faster.moved.toFixed(2)}, x${ratio.toFixed(2)})`
+		`3x the speed is ~3x the distance (${perFrameText(noded)} -> ${perFrameText(faster)}, x${ratio.toFixed(2)})`
 	);
 
 	// =========================================================================
@@ -502,10 +539,10 @@ h.run(async () => {
 		'and the other Move Speed node reads the new value, not its own param'
 	);
 	const fast = await travel(A.page, 'KeyW', WINDOW);
-	const speedRatio = fast.moved / slow.moved;
+	const speedRatio = fast.perFrame / slow.perFrame;
 	h.check(
 		speedRatio > 2.6 && speedRatio < 4.4,
-		`which actually MOVES you faster (${slow.moved.toFixed(2)} -> ${fast.moved.toFixed(2)}, x${speedRatio.toFixed(2)})`
+		`which actually MOVES you faster (${perFrameText(slow)} -> ${perFrameText(fast)}, x${speedRatio.toFixed(2)})`
 	);
 
 	// the scroll wheel writes through the same store while a controller is declared
@@ -630,11 +667,12 @@ h.run(async () => {
 		landedOnB && theirs && theirs.x === 0 && theirs.y === 0,
 		`and the PEER holding the same graph reads 0 — local by design, never streamed (${JSON.stringify(theirs)})`
 	);
-	await A.page.waitForTimeout(300);
-	const released = (await values(A.page)).mv?.__handles ?? null;
-	h.check(
-		released && released.x === 0 && released.y === 0,
-		`releasing the keys returns it to zero (${JSON.stringify(released)})`
+	// the node value refreshes on the graph's next tick — a fixed 300 ms is a handful of frames
+	// on software GL, so wait for the zero (still red if it never comes)
+	await h.eventually(
+		() => values(A.page).then((v) => v.mv?.__handles ?? null),
+		(r) => !!r && r.x === 0 && r.y === 0,
+		'releasing the keys returns it to zero'
 	);
 
 	// =========================================================================
@@ -648,12 +686,15 @@ h.run(async () => {
 		(d) => d.control === null && d.moveSpeed === null,
 		'deleting the node clears charControl AND the speed override'
 	);
+	// level again, as section 1 did: the sections between turned the camera, and fly moves along its
+	// forward axis — a pitched rig measured 0.09/frame (0.1 x cos 26 deg) for the same 0.1 speed
+	await levelCamera(A.page);
 	const restored = await travel(A.page, 'KeyW', WINDOW);
-	const backGap = Math.abs(restored.moved - builtin.moved) / builtin.moved;
+	const backGap = Math.abs(restored.perFrame - builtin.perFrame) / builtin.perFrame;
 	h.check(
 		backGap < 0.08,
 		`PARITY RESTORED: movement matches the very first measurement ` +
-			`(${builtin.moved.toFixed(3)} vs ${restored.moved.toFixed(3)}, ${(backGap * 100).toFixed(1)}% apart)`
+			`(${perFrameText(builtin)} vs ${perFrameText(restored)}, ${(backGap * 100).toFixed(1)}% apart)`
 	);
 	const noWalker = await charDebug(A.page);
 	h.check(
diff --git a/tests/e2e/quarantine.json b/tests/e2e/quarantine.json
index 5ca8c7497..ed91f3306 100644
--- a/tests/e2e/quarantine.json
+++ b/tests/e2e/quarantine.json
@@ -28,7 +28,6 @@
 		{"suite": "animation-node", "check": "so the door closes rather than restarting", "reason": "~1.7 fps under load: a 900 ms window holds 1-2 frames; 35/0 on a GPU slot (57-clips)", "owner": "test-health (standing lane)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "dock-strip-drop", "check": "6.3 opening an Explorer image brings the docked editor forward", "reason": "red 1/2 on both 1.41 and 1.40 production, green on base in deps-1 ab1 (53-int)", "owner": "test-health (standing lane)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "toolbar-slots-42", "check": "I9: each corner shows ONE", "reason": "known deployed flake (touch reorder, unfolded dark); same 2 reds on production 1.39 (49-int, 53-int)", "owner": "test-health (standing lane)", "since": "2026-10-23", "review": "2026-11-07"},
-		{"suite": "char-controller", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "context-menu-redesign", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "edit-move-games", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "fb-water", "check": "a foam body floats high", "reason": "software GL (~4 fps): rapier keeps real time only down to 7.5 fps (8 substeps of 1/60 s per frame), so the hull lags waves that follow the session clock — green needs a GPU slot; the test cannot fix the frame rate (test-health-1, e2e/v2)", "owner": "test-health (standing lane)", "since": "2026-10-24", "review": "2026-11-07"},

From 6bd61d3f28bfcf9f6d7a5c844114e0cb09df5ba7 Mon Sep 17 00:00:00 2001
From: AlexZ005 <alexz005.info@gmail.com>
Date: Sat, 24 Oct 2026 20:08:09 +0300
Subject: [PATCH 37/46] [test] test-health-1 P2: sessions reads the toast, not
 its screen-reader copy; the accepted-load check is quarantined UNRESOLVED
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

e3edaee5 (a11y live regions) repeats every toast's text in #a11y-live-polite, so getByText(/wants to load session/) matched two elements and the suite crashed in strict mode at :80 — which hid everything after it. The proposal/decline reads and the Accept/Decline presses now target the proposal's own .tp-toast.

That exposed the last check, red in every run since and NOT explained: v5b — the proposer holds a live, uncancelled load job with both links open and nothing cleared (stuck before applySessionNow's replicated clear); v3b — A cleared and added nothing, B applied nothing. A read-only root-cause pass refuted the room-gate, job-liveness and modal hypotheses with file:line evidence. The check now prints each side's link, load job and recent diagnostics on a red; quarantined by name with that evidence (the rest of the suite gates). Possibly a product bug in the session-proposal load; flagged for the owner.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 tests/e2e/quarantine.json   |  1 +
 tests/e2e/sessions.test.cjs | 43 ++++++++++++++++++++++++++++++-------
 2 files changed, 36 insertions(+), 8 deletions(-)

diff --git a/tests/e2e/quarantine.json b/tests/e2e/quarantine.json
index ed91f3306..393b0f54c 100644
--- a/tests/e2e/quarantine.json
+++ b/tests/e2e/quarantine.json
@@ -1,6 +1,7 @@
 {
 	"comment": "test-health-1 — e2e checks that run but do not gate (scripts/ci/quarantine.cjs; the battery reports them in their own tier). perf/budgets.json \"allow\" one domain over: suite + optionally ONE check (a substring of its FAIL label; absent = the whole suite), why, who owns the fix, since, review. A suite red is non-blocking only when EVERY failed check matches an entry (a crash or timeout never is, unless the whole suite is listed). Past-review and now-green entries print as warnings. Remove an entry in the PR that fixes it.",
 	"quarantine": [
+		{"suite": "sessions", "check": "accepted load replaced the scene on both peers", "reason": "UNRESOLVED, possibly a product bug: after Accept the proposer's load never completes — v5b: a live, uncancelled 'SceneOne' job, both links open, nothing cleared (stuck before applySessionNow's replicated clear: the only awaits there are the 'Backup before' saveSession, the library restore and the physics import — idb.js can leave a promise pending forever); v3b: A cleared and added nothing, B applied nothing. Hidden behind the e3edaee5 strict-mode crash since 2026-10-21, so no passing run exists to bisect; needs a run tracing sessions.js (test-health-1 2026-10-24)", "owner": "test-health (standing lane)", "since": "2026-10-24", "review": "2026-11-07"},
 		{"suite": "lock-ux", "check": "B renders a lock highlight box", "reason": "load-sensitive: the Approve toast click is intercepted by the canvas and the toast detaches; green in a quiet slot (75 s vs 131-136 s red), red on v1.42.0 in the same place (57-union, 65-union)", "owner": "test-health (standing lane)", "since": "2026-10-24", "review": "2026-11-07"},
 		{"suite": "ui-fixes-15lmno", "check": "incoming toasts never shift it", "reason": "the toast burst moves the spectator 8 px under load (a fixed sleep); a different row red each run, pristine v1.41.0 3/3 red (50-int r4)", "owner": "test-health (standing lane)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "ui-fixes-15lmno", "check": "the Roughness readout shows the material", "reason": "read before the Inspector re-renders under load (fixed sleep); red on pristine v1.41.0 (50-int r4)", "owner": "test-health (standing lane)", "since": "2026-10-23", "review": "2026-11-07"},
diff --git a/tests/e2e/sessions.test.cjs b/tests/e2e/sessions.test.cjs
index 97c2302ab..0bba9ae95 100644
--- a/tests/e2e/sessions.test.cjs
+++ b/tests/e2e/sessions.test.cjs
@@ -77,30 +77,57 @@ h.run(async () => {
 	await A.page.evaluate((id) => window.__stores.sessions.requestLoadSession(id), target.id);
 	await B.page.waitForTimeout(800);
 	h.check(
-		await B.page.getByText(/wants to load session/).isVisible(),
+		// the TOAST, not its copy in the screen-reader live region (e3edaee5) — getByText matched both
+		await B.page.locator('.tp-toast-text', { hasText: /wants to load session/ }).isVisible(),
 		'B sees the proposal toast'
 	);
-	await B.page.getByRole('button', { name: 'Decline', exact: true }).click();
+	// the proposal's OWN toast's button: another toast's action could share the name
+	await B.page.locator('.tp-toast', { hasText: /wants to load session/ }).getByRole('button', { name: 'Decline', exact: true }).click();
 	await A.page.waitForTimeout(800);
 	h.check(
-		await A.page.getByText(/declined the session load/).isVisible(),
+		await A.page.locator('.tp-toast-text', { hasText: /declined the session load/ }).isVisible(),
 		'A is told about the decline'
 	);
 
 	// then B accepts: the load applies and replicates
 	await A.page.evaluate((id) => window.__stores.sessions.requestLoadSession(id), target.id);
 	await B.page.waitForTimeout(800);
-	await B.page.getByRole('button', { name: 'Accept', exact: true }).click();
+	await B.page.locator('.tp-toast', { hasText: /wants to load session/ }).getByRole('button', { name: 'Accept', exact: true }).click();
+	let replaced = false;
 	await h.eventually(
 		() => Promise.all([objectNames(A.page), objectNames(B.page)]),
 		([a, b]) =>
-			a.filter((n) => n === 'Box').length === 1 &&
-			a.includes('Sphere') &&
-			b.filter((n) => n === 'Box').length === 1 &&
-			b.includes('Sphere'),
+			(replaced =
+				a.filter((n) => n === 'Box').length === 1 &&
+				a.includes('Sphere') &&
+				b.filter((n) => n === 'Box').length === 1 &&
+				b.includes('Sphere')),
 		'accepted load replaced the scene on both peers',
 		15000
 	);
+	// test-health-1: red since the toast check stopped masking it (e3edaee5) and not explained from the
+	// code (A clears and adds nothing, B applies nothing) — a red prints each side's link, load job and
+	// recent net/session diagnostics, so the next run says which path stopped
+	if (!replaced)
+		for (const [name, p, other] of [['A', A, B], ['B', B, A]])
+			console.log(
+				`  ${name} after Accept: ` +
+					JSON.stringify(
+						await p.page.evaluate((otherId) => {
+							const s = window.__stores;
+							let pc;
+							s.peers.subscribe((v) => (pc = v))();
+							const job = s.sceneLoader.currentJob?.();
+							return {
+								id: pc?.peer?.id,
+								openTo: !!pc?.connections?.[otherId]?.open,
+								reconnecting: pc?.reconnecting?.get?.(otherId) ?? null,
+								job: job ? { name: job.name, cancelled: !!job.cancelled, interrupted: !!job.interrupted } : null,
+								log: (s.diagnostics.lines?.() ?? []).filter((l) => /net|session|load|clear|wire/i.test(JSON.stringify(l))).slice(-12)
+							};
+						}, other.id)
+					)
+			);
 
 	await h.finish(browser);
 });

From e5f4010e6500de66d3a051e7a5dfc8ccc375eed2 Mon Sep 17 00:00:00 2001
From: AlexZ005 <alexz005.info@gmail.com>
Date: Sat, 24 Oct 2026 20:09:24 +0300
Subject: [PATCH 38/46] [test] test-health-1 P2: scene-post 9.12 waits for the
 composer and pins the quality governor
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

9.12 read the touch page's post stack after a fixed 1400 ms. Two causes, both measured: the stack is empty until the composer has warmed (postWarm, >10 rendered frames — section 3.2 already waits for it), and even warm the plan was EMPTY (postWarm true, postOk true, plan 0) because the quality governor drops AO on slow frames (Outline filters entries by qualityOverrides.aoOff) and software GL is slow on every page — the check was measuring the governor, not the touch rule. Wait (bounded) for postWarm + 'ao', pin autoQuality off on that page, and print the composer's state on a red. Green 93/0 (e2e/v5a); quarantine entry dropped.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 tests/e2e/quarantine.json     |  1 -
 tests/e2e/scene-post.test.cjs | 20 ++++++++++++++++----
 2 files changed, 16 insertions(+), 5 deletions(-)

diff --git a/tests/e2e/quarantine.json b/tests/e2e/quarantine.json
index 393b0f54c..d7d18bc4b 100644
--- a/tests/e2e/quarantine.json
+++ b/tests/e2e/quarantine.json
@@ -40,7 +40,6 @@
 		{"suite": "net-stress", "check": "premise: the camera stream flows between every pair while orbiting", "reason": "section 5 is a RATE claim against display frames and needs a GPU (its own comment): four pages on software GL orbit at 1 fps, so the 20/s gate cannot be exercised (e2e/v4a; sections 1-4 and the freeze check green)", "owner": "test-health (standing lane)", "since": "2026-10-24", "review": "2026-11-07"},
 		{"suite": "net-stress", "check": "presence is gated, not per frame", "reason": "section 5 is a RATE claim against display frames and needs a GPU (its own comment): four pages on software GL orbit at 1 fps, so the 20/s gate cannot be exercised (e2e/v4a; sections 1-4 and the freeze check green)", "owner": "test-health (standing lane)", "since": "2026-10-24", "review": "2026-11-07"},
 		{"suite": "phone-sheets", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
-		{"suite": "scene-post", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "shader-sync", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "timeline-export", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "touch-actions", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
diff --git a/tests/e2e/scene-post.test.cjs b/tests/e2e/scene-post.test.cjs
index ea5d6b432..cb30918e6 100644
--- a/tests/e2e/scene-post.test.cjs
+++ b/tests/e2e/scene-post.test.cjs
@@ -1005,7 +1005,9 @@ h.run(async () => {
 	// one-switch escape hatch if their driver cannot cope. `(pointer: coarse)` is
 	// emulable with a hasTouch context (unlike the mobile VIEWPORT, which needs
 	// isMobile too).
-	const T = await h.setupPage(browser, 'Touch', { context: { hasTouch: true } });
+	// the quality governor drops AO on slow frames (qualityOverrides.aoOff filters it out of the stack),
+	// and software GL is slow on every page — pin it, or 9.12 measures the governor, not the touch rule
+	const T = await h.setupPage(browser, 'Touch', { context: { hasTouch: true }, storage: { autoQuality: 'false' } });
 	const touch = await T.page.evaluate(async () => {
 		window.__stores.viewMode.set('shaded');
 		window.__stores.scenePost.scenePostRestore({
@@ -1013,20 +1015,30 @@ h.run(async () => {
 			effects: [{ id: 'a', kind: 'ao' }],
 			changedAt: 99
 		});
-		await new Promise((r) => setTimeout(r, 1400));
-		const on = window.__postDebug();
+		// the stack stays empty until the composer has warmed (postWarm, >10 rendered frames —
+		// 0.6-2.5 s at 4-17 fps), the same wait section 3.2 makes; a fixed 1400 ms read it cold
+		const t0 = performance.now();
+		let on = window.__postDebug();
+		while (!(on.postWarm && on.kinds.includes('ao')) && performance.now() - t0 < 20000) {
+			await new Promise((r) => requestAnimationFrame(r));
+			on = window.__postDebug();
+		}
 		window.__stores.viewportOverrides.setRenderLayer('post', false);
 		await new Promise((r) => setTimeout(r, 900));
+		let mode = null;
+		window.__stores.viewMode.subscribe((v) => (mode = v))();
 		return {
 			coarse: window.__stores.inputDevice.coarsePointer(),
 			kinds: on.kinds,
+			// what the composer said, so a red names its reason (warm-up, a skip, an empty plan, the mode)
+			why: { postWarm: on.postWarm, postOk: on.postOk, skipped: on.skipped, plan: (on.plan ?? []).length, stackPasses: on.stackPasses, mode, auto: localStorage.getItem('autoQuality') },
 			afterOff: window.__postDebug().stackPasses
 		};
 	});
 	h.check(touch.coarse === true, '9.11 premise: the touch context really reports a coarse pointer');
 	h.check(
 		touch.kinds.includes('ao'),
-		'9.12 a touch device renders the scene look too — no silent second class of viewer'
+		'9.12 a touch device renders the scene look too — no silent second class of viewer (' + JSON.stringify(touch.kinds) + ' ' + JSON.stringify(touch.why) + ')'
 	);
 	h.check(touch.afterOff === 0, '9.12b ...and the same one-switch escape hatch works there');
 

From 0f3b228379190ec33b5f437b0aba083d4dfc331c Mon Sep 17 00:00:00 2001
From: AlexZ005 <alexz005.info@gmail.com>
Date: Sat, 24 Oct 2026 20:22:39 +0300
Subject: [PATCH 39/46] [fix] test-health-1 P2: a late joiner compiles a shader
 graph whose object arrives after it
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

shader-sync 'and compiles it locally too' (red since the base): the third peer held the graph AND the cube and never compiled. The new diagnostics settled it — no compile errors, and a reconcile run by hand compiled it at once: the graph reply (small) lands before the GLTF that carries the object, the compile finds no target, and the late-joiner reconcile waits on an objectsGroup poke that the object's arrival does not always make.

PRODUCT FIX (shaderGraph compileAndApply): an object-keyed graph with no target yet retries its own compile on a short backoff (0.25 s doubling to 4 s, ~20 s in all); the reconcile still covers anything later; the scene default and edits are unaffected. The test adds the premise that C has the cube (so a red says which half never arrived) and prints the compile errors + a manual reconcile on a red. Green 21/0 (e2e/v6a); quarantine entry dropped.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 src/lib/shaderGraph.js         | 20 ++++++++++++++++++++
 tests/e2e/quarantine.json      |  1 -
 tests/e2e/shader-sync.test.cjs | 27 ++++++++++++++++++++++++++-
 3 files changed, 46 insertions(+), 2 deletions(-)

diff --git a/src/lib/shaderGraph.js b/src/lib/shaderGraph.js
index 7486223bb..945f47673 100644
--- a/src/lib/shaderGraph.js
+++ b/src/lib/shaderGraph.js
@@ -206,6 +206,19 @@ export function registerShaderTargets(fn) {
 	};
 }
 
+/** keys whose target object has not arrived -> retries made @type {Map<string, number>} */
+const missingTries = new Map();
+/** 0.25 s doubling to 4 s, ~20 s in all; then the objectsGroup reconcile alone @param {string} key */
+function retryMissingTarget(key) {
+	const tries = (missingTries.get(key) ?? 0) + 1;
+	if (tries > 8) {
+		missingTries.delete(key);
+		return;
+	}
+	missingTries.set(key, tries);
+	scheduleCompile(key, Math.min(4000, 250 * 2 ** (tries - 1)));
+}
+
 /**
  * Debounced: an editor drag writes many times a second, and a compile per keystroke is
  * wasted work even at inject's 0.4 ms.
@@ -274,6 +287,13 @@ export async function compileAndApply(key) {
 		return { ok: false, errors: result.errors };
 	}
 	const targets = targetsFor(key);
+	// test-health-1: a graph for an OBJECT that has not arrived yet (a late joiner's graph reply is
+	// far smaller than the GLTF that carries the object) compiles nothing — and the reconcile below
+	// waits on an objectsGroup poke the object's arrival does not always make (shader-sync: the
+	// joiner held both graph and cube, never compiled; a manual reconcile compiled it at once).
+	// Retry on its own, briefly; the reconcile still covers anything later.
+	if (!targets.length && key !== SCENE_GRAPH_KEY) retryMissingTarget(key);
+	else missingTries.delete(key);
 	/** @type {string[]} */
 	const errors = [];
 	for (const object of targets) {
diff --git a/tests/e2e/quarantine.json b/tests/e2e/quarantine.json
index d7d18bc4b..1a332683b 100644
--- a/tests/e2e/quarantine.json
+++ b/tests/e2e/quarantine.json
@@ -40,7 +40,6 @@
 		{"suite": "net-stress", "check": "premise: the camera stream flows between every pair while orbiting", "reason": "section 5 is a RATE claim against display frames and needs a GPU (its own comment): four pages on software GL orbit at 1 fps, so the 20/s gate cannot be exercised (e2e/v4a; sections 1-4 and the freeze check green)", "owner": "test-health (standing lane)", "since": "2026-10-24", "review": "2026-11-07"},
 		{"suite": "net-stress", "check": "presence is gated, not per frame", "reason": "section 5 is a RATE claim against display frames and needs a GPU (its own comment): four pages on software GL orbit at 1 fps, so the 20/s gate cannot be exercised (e2e/v4a; sections 1-4 and the freeze check green)", "owner": "test-health (standing lane)", "since": "2026-10-24", "review": "2026-11-07"},
 		{"suite": "phone-sheets", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
-		{"suite": "shader-sync", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "timeline-export", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "touch-actions", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "water-migration", "check": "pool-party (saved on 1.22) looks the same", "reason": "looks the same by eye (golden vs today, e2e/migration/*-now.png, test-health-1 2026-10-24); the measured change is a global tone shift (mean sum-of-channels delta 3.8-9.3, identical run to run with autoQuality pinned) plus the pool rim band — render changes since the goldens (bd143435). OWNER DECISION: re-baseline the goldens on today's build (drops the 'rendered by 1.22' provenance) or a perceptual metric; NOT a threshold raise", "owner": "test-health (standing lane) + owner decision", "since": "2026-10-24", "review": "2026-11-07"},
diff --git a/tests/e2e/shader-sync.test.cjs b/tests/e2e/shader-sync.test.cjs
index 572976e52..593959dbb 100644
--- a/tests/e2e/shader-sync.test.cjs
+++ b/tests/e2e/shader-sync.test.cjs
@@ -189,11 +189,36 @@ h.run(async () => {
 		(n) => n === 2,
 		'a LATE JOINER receives the graph through the handshake'
 	);
+	// the compile needs the OBJECT as well as the document (shaderGraph's reconcile retries when it lands):
+	// a red below says which of the two never arrived on the third page
+	await h.eventually(
+		() => C.page.evaluate((u) => new Promise((r) => window.__stores.objectsGroup.subscribe((g) => r(!!g?.getObjectByProperty('uuid', u)))()), uuid),
+		(has) => has === true,
+		'(premise) the late joiner has the cube the graph drives',
+		20000
+	);
+	let cDriven = false;
 	await h.eventually(
 		() => C.page.evaluate((u) => window.__stores.shaderGraph.isShaderDriven(u), uuid),
-		(driven) => driven === true,
+		(driven) => (cDriven = driven === true),
 		'and compiles it locally too'
 	);
+	// a red says WHY: the compile's own errors, and whether a reconcile run by hand compiles it — if it
+	// does, the object arrived without poking objectsGroup and the late-joiner retry never ran
+	if (!cDriven)
+		console.log(
+			'  C compile: ' +
+				JSON.stringify(
+					await C.page.evaluate(async (u) => {
+						const sg = window.__stores.shaderGraph;
+						let errs = null;
+						sg.shaderErrors?.subscribe?.((e) => (errs = e?.[u] ?? null))?.();
+						sg.reconcileShaderGraphs();
+						await new Promise((r) => setTimeout(r, 1500));
+						return { errors: errs, drivenAfterManualReconcile: sg.isShaderDriven(u) };
+					}, uuid)
+				)
+		);
 
 	// ---- 7. delete replicates ----------------------------------------------
 	await A.page.evaluate((u) => window.__stores.shaderGraph.setShaderGraphFor(u, null), uuid);

From 270ed3c02e54cc0a27bbed66e4425b31f84f3c6d Mon Sep 17 00:00:00 2001
From: AlexZ005 <alexz005.info@gmail.com>
Date: Sat, 24 Oct 2026 20:30:45 +0300
Subject: [PATCH 40/46] =?UTF-8?q?[test]=20test-health-1=20P2:=20timeline-e?=
 =?UTF-8?q?xport=20is=20green=20against=20a=20build=20=E2=80=94=20its=20qu?=
 =?UTF-8?q?arantine=20entry=20says=20so?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Carried as 'red since 1.41'. It is not broken: the in-app exporter reads build/export-manifest.json, which only 'npm run build' (postbuild) writes, so against the dev-server battery it can only fail with ExportUnavailable, by design (battery.json already skips it on CI for this). Run against a production build served by scripts/serve-build.cjs it is green 9/9 (e2e/tlx: the export zip, the sequence in scene.tpscene, the exported game autoplaying through its camera shot, no page errors). The entry keeps it out of the dev-server battery's blocking tier with the real reason and the way to run it.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 tests/e2e/quarantine.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/e2e/quarantine.json b/tests/e2e/quarantine.json
index 1a332683b..c00ec2e8e 100644
--- a/tests/e2e/quarantine.json
+++ b/tests/e2e/quarantine.json
@@ -40,7 +40,7 @@
 		{"suite": "net-stress", "check": "premise: the camera stream flows between every pair while orbiting", "reason": "section 5 is a RATE claim against display frames and needs a GPU (its own comment): four pages on software GL orbit at 1 fps, so the 20/s gate cannot be exercised (e2e/v4a; sections 1-4 and the freeze check green)", "owner": "test-health (standing lane)", "since": "2026-10-24", "review": "2026-11-07"},
 		{"suite": "net-stress", "check": "presence is gated, not per frame", "reason": "section 5 is a RATE claim against display frames and needs a GPU (its own comment): four pages on software GL orbit at 1 fps, so the 20/s gate cannot be exercised (e2e/v4a; sections 1-4 and the freeze check green)", "owner": "test-health (standing lane)", "since": "2026-10-24", "review": "2026-11-07"},
 		{"suite": "phone-sheets", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
-		{"suite": "timeline-export", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
+		{"suite": "timeline-export", "reason": "NOT a flake — ENV: the exporter reads build/export-manifest.json, which a dev server has none of, so on the dev-server battery it can only fail (CI skips it in battery.json for the same reason). Green 9/9 against a production build served by scripts/serve-build.cjs (test-health-1, e2e/tlx, 2026-10-24). Run it there: npm run build && node scripts/serve-build.cjs --port <p>, APP_URL at that port", "owner": "test-health (standing lane)", "since": "2026-10-24", "review": "2026-11-07"},
 		{"suite": "touch-actions", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "water-migration", "check": "pool-party (saved on 1.22) looks the same", "reason": "looks the same by eye (golden vs today, e2e/migration/*-now.png, test-health-1 2026-10-24); the measured change is a global tone shift (mean sum-of-channels delta 3.8-9.3, identical run to run with autoQuality pinned) plus the pool rim band — render changes since the goldens (bd143435). OWNER DECISION: re-baseline the goldens on today's build (drops the 'rendered by 1.22' provenance) or a perceptual metric; NOT a threshold raise", "owner": "test-health (standing lane) + owner decision", "since": "2026-10-24", "review": "2026-11-07"},
 		{"suite": "water-migration", "check": "island-ocean (saved on 1.22) looks the same", "reason": "looks the same by eye (golden vs today, e2e/migration/*-now.png, test-health-1 2026-10-24); the measured change is a global tone shift (mean sum-of-channels delta 3.8-9.3, identical run to run with autoQuality pinned) plus the pool rim band — render changes since the goldens (bd143435). OWNER DECISION: re-baseline the goldens on today's build (drops the 'rendered by 1.22' provenance) or a perceptual metric; NOT a threshold raise", "owner": "test-health (standing lane) + owner decision", "since": "2026-10-24", "review": "2026-11-07"}

From 4f0dd12f873e56da06a4a3397c0c2e4669dc6825 Mon Sep 17 00:00:00 2001
From: AlexZ005 <alexz005.info@gmail.com>
Date: Sat, 24 Oct 2026 20:36:09 +0300
Subject: [PATCH 41/46] =?UTF-8?q?[fix]=20test-health-1=20P2/P5:=20a=20drop?=
 =?UTF-8?q?ped=20peer=20comes=20back=20=E2=80=94=20the=20reconnect=20windo?=
 =?UTF-8?q?w=20heals=20instead=20of=20tearing=20down?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

net-reconnect was red at the base ('the conn to B is re-opened by the backoff', 'B's new object reaches A after the heal'). Each fix below was found by a measured timeline (net-drop prints each side's window per 500 ms on a red), not by reading:
1. A signaling rebuild no longer cuts the peer links. recreatePeer destroy()ed the old Peer, and PeerJS destroy() closes every DataConnection it owns — so a signaling reconnect that stalled (watchOpen, 10 s after a wifi drop) killed every healthy conn with it (net-drop QUIET timeline: the conn died ~15 s in). A Peer that still carries open links is disconnect()ed (server socket only — 'does not close any active connections') and retired; links still negotiating are closed as destroy() did (they needed the old socket).
2. Signaling back = redial now: the window's dials while the link was down never left (peer.connect is undefined then), and its next tick can be the verdict-only one — so on 'open' every peer in the window is redialled at once, replacing a never-opened dial made while the link was down.
3. The final verdict waits out a dial still negotiating, either direction (the higher id heals through an INBOUND dial, tracked in inboundDials), up to VERDICT_GRACE_MS = 20 s: a post-drop redial measured ~12 s to open on a loaded box and the 10 s DIAL_GRACE tore it down a second before it opened.
4. A healed conn re-syncs as one session, not two worlds: its handshake no longer holds for the connect decision (a first-contact question), and its full-state request carries 'arriving' — without both, the far side opened a share-or-stash ask whose gate DROPPED everything we sent (diagnostics: gateHolds true, open both ways, edits lost).
Evidence: net-reconnect green 13/0 (e2e/v9a — red at base, and red in v3-v8 at each stage above); net-drop HARD healed with edits crossing both ways (e2e/v9b); net-handshake green (v7a). The test: B's side must be open before B's edit, heal waits are bounded by the product's own window, the mesh-fill premise by measured negotiation time, and a red prints each side's gate/decision state.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 src/lib/peerHandler.svelte.js    | 125 +++++++++++++++++++++++++------
 tests/e2e/net-reconnect.test.cjs |  39 ++++++++--
 2 files changed, 136 insertions(+), 28 deletions(-)

diff --git a/src/lib/peerHandler.svelte.js b/src/lib/peerHandler.svelte.js
index 73b5fa4de..16262f17d 100644
--- a/src/lib/peerHandler.svelte.js
+++ b/src/lib/peerHandler.svelte.js
@@ -179,6 +179,11 @@ export function createPeer() {
 // remote had already adopted as its send channel. Killing young conns is how
 // mesh formation shredded itself above ~5 peers.
 const DIAL_GRACE_MS = 10000;
+/** test-health-1: what the reconnect window's FINAL verdict gives a dial still negotiating (either
+ * direction). Longer than DIAL_GRACE_MS on purpose: a redial after a 5 s drop starts late (when the
+ * signaling link returns) and measured ~12 s to open on a loaded box — the 10 s grace tore it down a
+ * second before it opened (net-drop HARD). A teardown is the expensive mistake here. */
+const VERDICT_GRACE_MS = 20000;
 // 27-F: the SIGNALING schedule — 800ms doubling to a 8s ceiling, forever, +/-25% so a
 // room full of tabs does not return in lockstep. Separate from the per-peer conn
 // backoff below, which is bounded on purpose (a peer really can be gone).
@@ -282,6 +287,11 @@ export class PeerConnection {
 		 * toast) waits until the backoff exhausts; checkLocks keeps the peer's
 		 * locks and roster entry alive for the window (B5, 172 deferred item 1) */
 		this.reconnecting = new Map();
+		// test-health-1: inbound dials from a peer in the reconnect window, while they negotiate
+		// (the higher id only ever heals through one) — scheduleReconnect's final verdict waits
+		// for them as it waits for its own dial
+		/** @type {Map<string, any>} */
+		this.inboundDials = new Map();
 		/** @type {Set<string>} peers that ANNOUNCED they were leaving (the
 		 * `disconnected` self-message) — their close is expected, don't redial */
 		this.gracefulLeft = new Set();
@@ -393,7 +403,20 @@ export class PeerConnection {
 			cancelTimers();
 			const old = this.peer;
 			if (old) retired.add(old);
-			try { old.destroy(); } catch (e) { /* already gone */ }
+			// test-health-1: rebuilding the SIGNALING link must not cut the PEER links. destroy() closes
+			// every DataConnection the old Peer owns (peerjs _cleanup), and an open DataConnection needs
+			// no server — so a reconnect that stalled (watchOpen, 10 s after a wifi drop) used to end
+			// every live conn with it and push them all into the reconnect window. disconnect() drops the
+			// server socket only ("does not close any active connections"); the old Peer is retired, so
+			// none of its handlers act again. Nothing open to keep -> destroy, as before.
+			const keepLinks = !!old && !old.destroyed && Object.values(this.connections).some((/** @type {any} */ c) => c?.open);
+			try { if (keepLinks) old.disconnect(); else old.destroy(); } catch (e) { /* already gone */ }
+			// …but only the OPEN links survive: a conn still negotiating needed the old socket for its
+			// answer and candidates and can never finish now — close it exactly as destroy() did, so its
+			// close runs the usual paths (reconnect window / mesh restore) instead of wedging
+			if (keepLinks)
+				for (const c of Object.values(this.connections))
+					if (c && !(/** @type {any} */ (c).open)) try { /** @type {any} */ (c).close(); } catch (e) { /* never opened */ }
 			createPeerForMode(!!forcePublic);
 			attachVoiceToPeer(this); // rebind the incoming-call handler to the new peer
 			wire();
@@ -505,6 +528,22 @@ export class PeerConnection {
 			this.signalingNotified = false;
 			peers.update((value) => value); // the dot reads peer.open: tick the store
 			this.reconnectAttempts = 0; // a fresh/re-established server link resets the backoff
+			// test-health-1: the window's dials while the server was unreachable never left
+			// (`peer.connect` is undefined with the link down) — redial NOW, not on the next
+			// backoff tick, which can be the verdict-only one (a 5 s wifi drop: no dial until 7.5 s)
+			// A dial still un-open at this moment was made while the link was down — its offer never
+			// reached the server, yet it holds the slot until its DIAL_GRACE expires, and after a 5 s
+			// drop that is past the window's last dial (net-drop HARD: the session tore down with one
+			// such dial "negotiating" for 15 s). Replace it (delete first, so onConnClose ignores the
+			// close of a conn we no longer hold).
+			for (const peerId of this.reconnecting.keys()) {
+				const stale = this.connections[peerId];
+				if (stale && !stale.open) {
+					delete this.connections[peerId];
+					try { stale.close(); } catch (e) { /* never opened */ }
+				}
+				this.reconnectDial(peerId);
+			}
 			if (this.updateIdFn) this.updateIdFn(id);
 			if (!window.location.hash.slice(1)) return;
 			let connect = window.location.hash.slice(1).toLocaleLowerCase()
@@ -769,6 +808,12 @@ export class PeerConnection {
 				conn.close();
 			}
 
+			// test-health-1: an inbound redial from a peer we are waiting for is a heal in progress
+			if (this.reconnecting.has(conn.peer)) {
+				/** @type {any} */ (conn).__dialedAt = Date.now();
+				this.inboundDials.set(conn.peer, conn);
+			}
+
 			// ADOPT an open inbound conn as our send channel when our outgoing one
 			// is dead (P-A find): the host closes the joiner's original conn before
 			// approving, the close is often never signaled, and the fresh reopen can
@@ -789,8 +834,9 @@ export class PeerConnection {
 				// relationship, or a reconnect resyncing what the blip dropped. A
 				// mesh-fill adoption asking a JOINER for its objects was pure
 				// duplication — and could pop a bogus share-or-stash prompt (B5).
-				const wantState = this.wantsStateFrom.has(conn.peer) || this.reconnecting.has(conn.peer);
-				this.sendHandshake(conn, conn.peer, wantState, this.peer.id);
+				const healing = this.reconnecting.has(conn.peer);
+				const wantState = this.wantsStateFrom.has(conn.peer) || healing;
+				this.sendHandshake(conn, conn.peer, wantState, this.peer.id, { heal: healing });
 			});
 
 			this.wireData(conn);
@@ -1543,8 +1589,9 @@ export class PeerConnection {
 
 	// Send the initial handshake (locks, known hosts, whitelist, object/node sync requests).
 	// Must only be called once the connection is open — messages sent earlier are dropped by peerjs.
-	/** @param {any} conn @param {string} peerId @param {boolean} getobjects @param {string} id */
-	sendHandshake(conn, peerId, getobjects, id) {
+	/** @param {any} conn @param {string} peerId @param {boolean} getobjects @param {string} id
+	 * @param {{heal?: boolean}} [opts] heal: this conn REPLACES one that dropped (the reconnect window) */
+	sendHandshake(conn, peerId, getobjects, id, opts = {}) {
 		// 25-F: an approval dial-back SAYS it is one, ahead of everything else (the roadmap's
 		// "first message"). The metadata already carried it; this is the same answer for a
 		// peer that reads messages rather than metadata, and it is idempotent on a joiner
@@ -1616,7 +1663,10 @@ export class PeerConnection {
 		// DECISION: there is no decision here, and the ask comes back the moment we share or
 		// rejoin (both end in a full-state re-sync of their own).
 		const secret = hostsPrivate;
-		const holdContent = secret || (getobjects && connectDecisionApplies(get(sessionHost) === peerId, myScene()?.scene ?? ''));
+		// test-health-1: the connect decision is a FIRST-CONTACT question; a healed conn is the same
+		// session coming back, so it never holds (it deferred our state for a decision nobody asked:
+		// net-drop HARD healed, open both ways, and no edit crossed)
+		const holdContent = secret || (getobjects && !opts.heal && connectDecisionApplies(get(sessionHost) === peerId, myScene()?.scene ?? ''));
 		if (holdContent && !secret) noteHandshakeDeferred(peerId);
 		if (!holdContent) {
 			conn.send(environmentState())
@@ -1633,7 +1683,10 @@ export class PeerConnection {
 		conn.send(handModelState())
 		conn.send(envPresetsState())
 		conn.send(materialPresetsState())
-		if (getobjects && !holdContent) this.requestFullState(conn)
+		// test-health-1: a HEALED conn re-syncs as `arriving` — what each side holds is the same room's
+		// scene, so it is not two worlds merging: without the flag the far side asked share-or-stash
+		// and its gate DROPPED everything we sent (net-reconnect / net-drop: open both ways, edits lost)
+		if (getobjects && !holdContent) this.requestFullState(conn, opts.heal ? { arriving: true } : {})
 		// singleton PUSH, like environmentState/scenePhysicsState above
 		if (!holdContent) conn.send(gameStatePayload())
 		// 34 R2: the kit document, the same singleton push (its events are NOT sent: history fires nothing)
@@ -1860,6 +1913,24 @@ export class PeerConnection {
 	scheduleReconnect(peerId, attempt) {
 		const delay = backoffDelay(attempt, { base: 500, max: 5 });
 		if (delay === null) {
+			// test-health-1: the verdict waits out a dial that is still negotiating, either way
+			// round (6-12 s measured on a loaded box, VERDICT_GRACE_MS). After a 5 s drop the
+			// first dial that can leave goes out at ~5-7.5 s, so tearing down at 15.5 s killed
+			// heals in flight: "disconnected" toasts and a dead session (net-drop HARD).
+			const inFlight = [this.connections[peerId], this.inboundDials.get(peerId)]
+				.filter((c) => c && !c.open)
+				.map((c) => VERDICT_GRACE_MS - (Date.now() - (c.__dialedAt ?? 0)))
+				.filter((left) => left > 0);
+			if (inFlight.length) {
+				this.reconnecting.set(peerId, attempt); // still in the window, under a fresh token
+				setTimeout(() => {
+					if (this.reconnecting.get(peerId) !== attempt) return; // healed, superseded or left
+					if (this.connections[peerId]?.open) { this.reconnecting.delete(peerId); this.inboundDials.delete(peerId); return; }
+					this.reconnecting.delete(peerId);
+					this.finalizeDisconnect(peerId, true);
+				}, Math.max(...inFlight));
+				return;
+			}
 			this.reconnecting.delete(peerId);
 			this.finalizeDisconnect(peerId, true);
 			return;
@@ -1869,7 +1940,7 @@ export class PeerConnection {
 			if (this.reconnecting.get(peerId) !== attempt) return; // superseded or cancelled
 			if (!this.openedPeers.has(peerId)) { this.reconnecting.delete(peerId); return; } // torn down elsewhere
 			const existing = this.connections[peerId];
-			if (existing?.open) { this.reconnecting.delete(peerId); return; } // healed (redial or adopted inbound)
+			if (existing?.open) { this.reconnecting.delete(peerId); this.inboundDials.delete(peerId); return; } // healed (redial or adopted inbound)
 			// a dial un-open past the dial grace is genuinely wedged — clear it.
 			// Anything younger is just negotiating (measured 6-9s on a loaded
 			// headless box; closing it early poisons the NEXT negotiation too —
@@ -1881,25 +1952,31 @@ export class PeerConnection {
 			// dial (lower id only), unless this is the verdict-only final check —
 			// a dial started now would be torn down before it could ever open
 			const lastCheck = backoffDelay(attempt + 1, { base: 500, max: 5 }) === null;
-			if (!this.connections[peerId] && !lastCheck && this.peer.id < peerId) {
-				const conn = this.peer.connect(peerId, dialOptions());
-				if (conn) {
-					/** @type {any} */ (conn).__dialedAt = Date.now();
-					this.connections[peerId] = conn;
-					conn.on('close', () => this.onConnClose(peerId, conn));
-					conn.on('open', () => {
-						log('info', 'net', 'reconnected', { peer: peerId });
-						this.reconnecting.delete(peerId);
-						peers.update((value) => value);
-						this.sendHandshake(conn, peerId, true, this.peer.id);
-					});
-					this.wireData(conn);
-				}
-			}
+			if (!lastCheck) this.reconnectDial(peerId);
 			this.scheduleReconnect(peerId, attempt + 1);
 		}, delay);
 	}
 
+	/** One reconnect-window dial: the lower id only, and never over a dial already in flight.
+	 * Called from the window's timers and when the signaling link comes back.
+	 * @param {string} peerId */
+	reconnectDial(peerId) {
+		if (this.connections[peerId] || !(this.peer.id < peerId)) return;
+		const conn = this.peer.connect(peerId, dialOptions());
+		if (!conn) return; // the signaling link is down: the next tick (or its return) redials
+		/** @type {any} */ (conn).__dialedAt = Date.now();
+		this.connections[peerId] = conn;
+		conn.on('close', () => this.onConnClose(peerId, conn));
+		conn.on('open', () => {
+			log('info', 'net', 'reconnected', { peer: peerId });
+			this.reconnecting.delete(peerId);
+			this.inboundDials.delete(peerId);
+			peers.update((value) => value);
+			this.sendHandshake(conn, peerId, true, this.peer.id, { heal: true });
+		});
+		this.wireData(conn);
+	}
+
 	// The peer is really gone: full per-peer teardown (self-heal — a relayed
 	// 'disconnected' never reaches the last peer in a 2-peer session, so voice
 	// nodes / VR hands / flow cursors / env presets used to leak, 172). With
@@ -1909,6 +1986,7 @@ export class PeerConnection {
 	/** @param {string} peerId @param {boolean} relay */
 	finalizeDisconnect(peerId, relay) {
 		this.reconnecting.delete(peerId);
+		this.inboundDials.delete(peerId);
 		const conn = this.connections[peerId];
 		if (conn) {
 			delete this.connections[peerId];
@@ -1947,6 +2025,7 @@ export class PeerConnection {
 		this.broadcast({ type: 'disconnected', peerId: this.peer.id });
 		dropPeerUnderlays(null); // 60 Q5: every peer's shared reference images go with the session
 		this.reconnecting.clear(); // pending retry timers see a cleared map and no-op
+		this.inboundDials.clear();
 		this.gracefulLeft.clear();
 		this.wantsStateFrom.clear();
 		// 60 Q2: every fast channel, sequence and owed keyframe goes with the session
diff --git a/tests/e2e/net-reconnect.test.cjs b/tests/e2e/net-reconnect.test.cjs
index 6781f1c99..72be9ba87 100644
--- a/tests/e2e/net-reconnect.test.cjs
+++ b/tests/e2e/net-reconnect.test.cjs
@@ -1,7 +1,8 @@
 // B5 / phase-172 deferred item 1: transient drops heal instead of tearing down.
 //
 // An OPEN conn dropping without a goodbye now gets a bounded redial window
-// (500/1000/2000/4000ms, netBackoff) before any teardown: the peer's roster
+// (checks at 0.5/1.5/3.5/7.5/15.5 s, netBackoff; the last waits out a dial still
+// negotiating, up to DIAL_GRACE_MS) before any teardown: the peer's roster
 // entry, avatar and locks survive a wifi wobble, and no "disconnected" toast
 // fires unless they are really gone. Announced leaves (leaveSession broadcasts
 // the existing `disconnected` message about itself; pagehide does the same
@@ -31,7 +32,8 @@ h.run(async () => {
 			return !!pc.connections[pid]?.open && pc.openedPeers.has(pid);
 		}, id);
 
-	await h.eventually(() => openTo(C, B.id), (v) => v, 'mesh formed: C holds an open conn to B');
+	// a mesh-fill dial negotiates like any other: ~6-12 s on a loaded box, past eventually's 10 s default
+	await h.eventually(() => openTo(C, B.id), (v) => v, 'mesh formed: C holds an open conn to B', 26000);
 
 	// --- a relayed 'disconnected' about a live peer is ignored
 	await C.page.evaluate(([aid, bid]) => {
@@ -69,14 +71,18 @@ h.run(async () => {
 		(await store(A, 'lockedObjects')).some((x) => x[0] === B.id && x[1] === uuid),
 		"B's lock survives the blip"
 	);
-	await h.eventually(() => openTo(A, B.id), (v) => v, 'the conn to B is re-opened by the backoff', 12000);
+	// bounded by the product's own window (15.5 s + a negotiating dial's 10 s grace): a 12 s wait was
+	// shorter than the window it tests, and a redial measured 6-9 s to open on a loaded box
+	await h.eventually(() => openTo(A, B.id), (v) => v, 'the conn to B is re-opened by the backoff', 26000);
 	const notifs = await store(A, 'notifications');
 	h.check(
 		!notifs.slice(notifCountBefore).some((n) => String(n.text).includes('disconnected')),
 		'no disconnect toast fired for a drop that healed'
 	);
 
-	// messages flow again after the heal
+	// messages flow again after the heal — from B, so B's own side must be healed too (A's open conn
+	// is the check above; B adopts the redial, or dials it, on its own schedule)
+	await h.eventually(() => openTo(B, A.id), (v) => v, "(premise) B's side of the conn is open again", 26000);
 	await B.page.evaluate(() => window.__stores.commandsHandler.sceneCommand('/create sphere'));
 	const countOn = (p) =>
 		p.page.evaluate(() => {
@@ -85,7 +91,30 @@ h.run(async () => {
 			return g?.children?.length ?? 0;
 		});
 	const bCount = await countOn(B);
-	await h.eventually(() => countOn(A), (c) => c >= bCount, "B's new object reaches A after the heal", 10000);
+	let reached = false;
+	await h.eventually(() => countOn(A), (c) => (reached = c >= bCount), "B's new object reaches A after the heal", 10000);
+	// both links are open by now, so a red here is past the transport: say whether a share-or-stash ask
+	// (gateHolds — it drops a peer's room content while open) or a connect decision is holding it
+	if (!reached)
+		for (const [name, p, other] of [['A', A, B], ['B', B, A]])
+			console.log(
+				`  ${name} after the heal: ` +
+					JSON.stringify(
+						await p.page.evaluate((o) => {
+							const s = window.__stores;
+							let decision = null;
+							let notes = [];
+							s.connectionState?.pendingConnectDecision?.subscribe?.((v) => (decision = v))?.();
+							s.notifications?.subscribe?.((v) => (notes = v))?.();
+							return {
+								gateHolds: s.sessions?.gateHolds?.(o) ?? null,
+								decision: decision ? Object.keys(decision) : null,
+								objects: (() => { let g; s.objectsGroup.subscribe((v) => (g = v))(); return g?.children?.map((c) => c.name); })(),
+								lastToasts: notes.slice(-3).map((n) => String(n.text).slice(0, 90))
+							};
+						}, other.id)
+					)
+			);
 
 	// --- announced leave tears down promptly, with no redial spam
 	const t0 = Date.now();

From f925429f5b8e4e9de64c37a7325dbf7db0b3d147 Mon Sep 17 00:00:00 2001
From: AlexZ005 <alexz005.info@gmail.com>
Date: Sat, 24 Oct 2026 20:41:06 +0300
Subject: [PATCH 42/46] =?UTF-8?q?[test]=20test-health-1=20P5:=20net-drop?=
 =?UTF-8?q?=20=E2=80=94=20a=205=20s=20connection=20drop=20does=20not=20tea?=
 =?UTF-8?q?r=20a=20two-peer=20session=20down=20(and=20a=2020=20s=20one=20d?=
 =?UTF-8?q?oes)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

New suite (from e77ca3f7, made honest here): QUIET (signaling dies, data held, ICE disconnected) and HARD (the peer connection closed outright, so the window must redial) 5 s drops; per-500 ms timelines of each side's window on a red; the signaling-down premise read at the cut; the shim keeps WebSockets down while the drop holds and lifts its hold before going online. Green 21/0 (e2e/v10). Counterfactual NETDROP_MS=20000: HARD red — teardown at ~20 s + the toast (e2e/v10cf); QUIET stays green by design (a quiet drop never breaks the channel).
lockControl: the 60 s lock sweep released a lock whenever its holder's conn was not open — no reconnect-window guard, unlike checkLocks (B5) — so a sweep landing inside a drop dropped a live peer's locks (v9b: 'A dropped B's lock' mid-drop). Same guard now. Consistent with v9b -> v10; not isolated by its own run.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 src/lib/lockControl.js      |  5 +++-
 tests/e2e/net-drop.test.cjs | 48 +++++++++++++++++++++++++++++++------
 2 files changed, 45 insertions(+), 8 deletions(-)

diff --git a/src/lib/lockControl.js b/src/lib/lockControl.js
index 7512e2d61..c1daf70d8 100644
--- a/src/lib/lockControl.js
+++ b/src/lib/lockControl.js
@@ -101,7 +101,10 @@ export function startLockSweep() {
 			locks.filter((l) => {
 				if (l[0] === peer.peer.id) return true;
 				const conn = peer.connections[l[0]];
-				return !!(conn && conn.open);
+				// test-health-1: mid-blip the holder's conn is down but the reconnect window still runs —
+				// their lock survives until finalizeDisconnect decides (the rule checkLocks keeps, B5).
+				// Without it a sweep landing inside a drop released a live peer's locks (net-drop HARD).
+				return !!(conn && conn.open) || !!peer.reconnecting?.has(l[0]);
 			})
 		);
 	}, 60000);
diff --git a/tests/e2e/net-drop.test.cjs b/tests/e2e/net-drop.test.cjs
index 9cbb1cab8..591015327 100644
--- a/tests/e2e/net-drop.test.cjs
+++ b/tests/e2e/net-drop.test.cjs
@@ -16,7 +16,9 @@
 //  2. HARD (a network CHANGE): the same, plus the peer connection is closed outright at the start, so
 //     the B5 reconnect window has to redial — through a signaling server it cannot reach until the
 //     drop ends. The window is ~15.5 s (checks at 0.5/1/2/4/8 s), so a 5 s drop must fit inside it.
-// Counterfactual: NETDROP_MS=20000 outlasts the window — phase 2 goes red (teardown + toast).
+// Counterfactual: NETDROP_MS=20000 outlasts the window — phase 2 goes red (teardown + toast; measured
+// e2e/v10cf). Phase 1 stays green at 20 s, by design: a QUIET drop never breaks the data channel, so it
+// proves the conn carries on, not the window's length.
 const h = require('./helpers.cjs');
 
 const DROP_MS = Number(process.env.NETDROP_MS || 5000);
@@ -51,6 +53,16 @@ function dropShim() {
 	proto.addEventListener = function (/** @type {string} */ type, /** @type {any} */ fn, /** @type {any} */ opts) {
 		return add.call(this, type, type === 'message' && typeof fn === 'function' ? wrap(fn) : fn, opts);
 	};
+	// the signaling server stays unreachable for the whole drop: offline emulation alone let peerjs's
+	// own reconnect back in mid-drop (A was on the server again at 2.8 s), so a socket opened while
+	// the drop holds goes nowhere
+	const RealWS = window.WebSocket;
+	// @ts-ignore
+	window.WebSocket = function (/** @type {string} */ url, /** @type {any} */ protocols) {
+		return new RealWS(D.holding ? 'wss://127.0.0.1:9/' : url, protocols);
+	};
+	window.WebSocket.prototype = RealWS.prototype;
+	Object.setPrototypeOf(window.WebSocket, RealWS);
 	const Real = window.RTCPeerConnection;
 	// @ts-ignore
 	window.RTCPeerConnection = function (/** @type {any[]} */ ...args) {
@@ -161,6 +173,11 @@ h.run(async () => {
 				} catch {}
 			});
 		}
+		// the premise is read AT THE CUT: whether peerjs's own reconnect later slips past the shim (it did,
+		// now and then) is the app recovering, not the drop failing to happen
+		let cut = false;
+		for (const t = Date.now(); !cut && Date.now() - t < 3000; await A.page.waitForTimeout(150))
+			cut = !(await signalingUp(A)) && !(await signalingUp(B)); // peerjs marks itself down on the socket's close event
 		if (shape === 'hard') {
 			await A.page.evaluate((/** @type {string} */ id) => {
 				/** @type {any} */ let pc;
@@ -171,7 +188,20 @@ h.run(async () => {
 		const t0 = Date.now();
 		/** @type {string[]} */
 		const lost = [];
+		/** what each side's reconnect window is doing, printed if the heal fails @type {string[]} */
+		const timeline = [];
+		const state = (/** @type {any} */ p, /** @type {string} */ id) =>
+			p.page
+				.evaluate((/** @type {string} */ pid) => {
+					/** @type {any} */ let pc;
+					window.__stores.peers.subscribe((/** @type {any} */ v) => (pc = v))();
+					const c = pc.connections[pid];
+					const age = (/** @type {any} */ x) => (x?.__dialedAt ? Math.round((Date.now() - x.__dialedAt) / 100) / 10 + 's' : '-');
+					return `sig=${pc.peer?.open ? 1 : 0} rec=${pc.reconnecting.get(pid) ?? '-'} conn=${c ? (c.open ? 'open' : 'neg ' + age(c)) : 'none'} in=${pc.inboundDials?.has(pid) ? 'neg ' + age(pc.inboundDials.get(pid)) : '-'} opened=${pc.openedPeers.has(pid) ? 1 : 0}`;
+				}, id)
+				.catch((/** @type {any} */ e) => 'err ' + String(e?.message ?? e).slice(0, 60));
 		const watch = async () => {
+			timeline.push(`${((Date.now() - t0) / 1000).toFixed(1)}s A[${await state(A, B.id)}] B[${await state(B, A.id)}]`);
 			if (!(await inRoster(A, B.id))) lost.push(`A lost B at ${Date.now() - t0}ms`);
 			if (!(await inRoster(B, A.id))) lost.push(`B lost A at ${Date.now() - t0}ms`);
 			if ((await bLocks()) === 0) lost.push(`A dropped B's lock at ${Date.now() - t0}ms`);
@@ -184,9 +214,9 @@ h.run(async () => {
 			await watch();
 			await A.page.waitForTimeout(500);
 		}
-		h.check(!(await signalingUp(A)) && !(await signalingUp(B)), `${tag} premise: the signaling link really was down on both pages`);
-		// ---- the network comes back
-		for (const p of [A, B]) await p.page.context().setOffline(false);
+		h.check(cut, `${tag} premise: the signaling link really was down on both pages (at the cut)`);
+		// ---- the network comes back: lift the shim's hold FIRST, so the app's own `online` retry
+		// (fired by setOffline(false)) reaches the real server rather than the held-down socket
 		for (const p of [A, B]) {
 			await p.page.evaluate(() => {
 				// @ts-ignore
@@ -195,9 +225,11 @@ h.run(async () => {
 				window.__drop.release();
 			});
 		}
-		// watch the roster through the rest of the reconnect window (~15.5 s from the drop's start)
+		for (const p of [A, B]) await p.page.context().setOffline(false);
+		// watch the roster through the rest of the reconnect window: ~15.5 s from the drop's start, plus
+		// the up-to-20 s its last check gives a dial still negotiating (VERDICT_GRACE_MS)
 		const healed = { a: false, b: false };
-		while (Date.now() - t0 < Math.max(DROP_MS, 0) + 17000) {
+		while (Date.now() - t0 < Math.max(DROP_MS, 0) + 37000) {
 			await watch();
 			healed.a ||= await openTo(A, B.id);
 			healed.b ||= await openTo(B, A.id);
@@ -205,7 +237,9 @@ h.run(async () => {
 			await A.page.waitForTimeout(500);
 		}
 		h.check(lost.length === 0, `${tag} each peer kept the other in its roster, and B's lock stood, throughout (${lost.slice(0, 2).join(', ') || 'never lost'})`);
-		h.check((await openTo(A, B.id)) && (await openTo(B, A.id)), `${tag} the conn is open both ways again`);
+		const healedBoth = (await openTo(A, B.id)) && (await openTo(B, A.id));
+		if (!healedBoth) console.log(`  ${tag} timeline (A=${A.id} B=${B.id}; the lower id dials):\n    ` + timeline.join('\n    '));
+		h.check(healedBoth, `${tag} the conn is open both ways again`);
 		h.check((await disconnectToasts(A, toastsA)) === 0 && (await disconnectToasts(B, toastsB)) === 0, `${tag} no "disconnected" toast on either side`);
 		await h.eventually(() => has(B, duringA), (v) => v, `${tag} A's edit made during the drop reaches B`, 15000);
 		await h.eventually(() => has(A, duringB), (v) => v, `${tag} B's edit made during the drop reaches A`, 15000);

From 756d58d5f9477689efa1b0842295af1f632b5fc7 Mon Sep 17 00:00:00 2001
From: AlexZ005 <alexz005.info@gmail.com>
Date: Sun, 25 Oct 2026 08:46:08 +0200
Subject: [PATCH 43/46] [test] test-health-1 P3: script-guard counts the slow
 node's runs, not an estimate of frames

e2e-smoke's first run as a gate went red on script-guard, twice (run + retry) on the GitHub runner, and bc453ae8's diagnostics said exactly why: {runs: 29, paused: false} both times. The guard pauses a node on its 30th consecutive slow run (SLOW_FRAMES); the test's wait was a TIME estimate from the measured frame rate, and this node slows the very frames it is measured by, so the timeout ended one run short. Wait for the badge, or for the node to have run 40 times (a real red), bounded at 180 s. Green locally 11/0 (e2e/sg1).

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 tests/e2e/script-guard.test.cjs | 18 ++++++++++--------
 1 file changed, 10 insertions(+), 8 deletions(-)

diff --git a/tests/e2e/script-guard.test.cjs b/tests/e2e/script-guard.test.cjs
index 3e8e74451..41c66d818 100644
--- a/tests/e2e/script-guard.test.cjs
+++ b/tests/e2e/script-guard.test.cjs
@@ -114,8 +114,6 @@ h.run(async () => {
 	// a frozen loop reads 0-1. test-health-1: 3000 ms and >= 3 — a GitHub runner measured exactly 3 in 1800 ms
 	// (ci.yml e2e-smoke, 2026-10-23/24), red at `> 3` with the loop plainly alive.
 	h.check(frames >= 3, `the render loop is still running (${frames} frames in ${FRAME_WINDOW_MS}ms)`);
-	// what one frame costs here, for the waits below that count frames
-	const frameMs = FRAME_WINDOW_MS / Math.max(1, frames);
 
 	// ---- 3. a healthy node beside it still works ---------------------------------------
 	const uuid2 = await makeBox(A);
@@ -160,15 +158,19 @@ h.run(async () => {
 			() => {
 				let v = {};
 				window.__stores.scriptErrors.subscribe((m) => (v = m))();
-				return /too slow/i.test(String(v['slow'] ?? '')) ? v['slow'] : false;
+				if (/too slow/i.test(String(v['slow'] ?? ''))) return v['slow'];
+				// 40 runs and still no badge is a real red (a run under 8 ms resets the streak, so not 31)
+				return /** @type {any} */ (globalThis).__slowRuns >= 40 ? 'NO BADGE' : false;
 			},
-			// the guard pauses after SLOW_FRAMES (30) slow frames in a row, so the wait is counted in FRAMES:
-			// at a runner's ~2 fps (slower still with this node eating each one) 30 s was not 30 frames
-			{ timeout: Math.max(30000, Math.round(30 * frameMs * 3) + 5000) }
+			// the guard pauses on the 30th slow RUN in a row (SLOW_FRAMES), so the wait counts runs: a time
+			// estimate from the measured frame rate ended at exactly 29 runs twice on a GitHub runner (this
+			// node slows the frames it is measured by). Badge, or the node has run well past 30 — bounded.
+			{ timeout: 180000 }
 		)
 		.then((r) => r.jsonValue())
 		.catch(() => null);
-	const slowWhy = slowBadge
+	const badged = !!slowBadge && slowBadge !== 'NO BADGE';
+	const slowWhy = badged
 		? slowBadge
 		: JSON.stringify(
 				await A.page
@@ -181,7 +183,7 @@ h.run(async () => {
 					})
 					.catch((/** @type {any} */ e) => String(e))
 			);
-	h.check(!!slowBadge, `a slow node is paused rather than left to eat the frame (${slowWhy})`);
+	h.check(badged, `a slow node is paused rather than left to eat the frame (${slowWhy})`);
 	h.check(
 		await A.page.evaluate(() => 1 + 1).then((v) => v === 2),
 		'and the page is still responsive after it'

From cbeba841b5da20475f7d6d149ba951255831e7bd Mon Sep 17 00:00:00 2001
From: AlexZ005 <alexz005.info@gmail.com>
Date: Sun, 25 Oct 2026 08:46:08 +0200
Subject: [PATCH 44/46] [test] test-health-1 P5: battery.json runs net-drop and
 reload-memory

The two new suites join the battery (seconds = 2x the desk time until a runner measures them: net-drop 94-175 s desk, reload-memory 73-94 s desk).

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 tests/e2e/battery.json | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/tests/e2e/battery.json b/tests/e2e/battery.json
index c28e0cbeb..e7789eb6b 100644
--- a/tests/e2e/battery.json
+++ b/tests/e2e/battery.json
@@ -228,6 +228,7 @@
 		"modules-phone-jobs": 38,
 		"move-wire-shape": 150,
 		"multiselect-v2": 706,
+		"net-drop": 340,
 		"net-mesh": 30,
 		"net-peer-id": 120,
 		"net-stress": 120,
@@ -291,6 +292,7 @@
 		"quality-toast-preset": 106,
 		"race-vr-shadows": 32,
 		"race-vr-shadows-iwer": 26,
+		"reload-memory": 190,
 		"reset-windows": 26,
 		"resize-observer-loop": 818,
 		"ro-loop-guard": 538,

From ebfbf5ae9c661a4431eac283ece47fb6c3727363 Mon Sep 17 00:00:00 2001
From: AlexZ005 <alexz005.info@gmail.com>
Date: Sun, 25 Oct 2026 09:29:00 +0200
Subject: [PATCH 45/46] =?UTF-8?q?[revert]=20test-health-1:=20the=20gizmo-t?=
 =?UTF-8?q?ap=20change=20from=207451aad9=20did=20not=20fix=20select-41=20G?=
 =?UTF-8?q?14=20=E2=80=94=20reverted,=20check=20quarantined?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

7451aad9 also let a finger's still tap count as a gizmo tap while TransformControls reported 'dragging'. The after battery shows it changed nothing: G14 (unfolded) still red with the same state at the tap (axis XYZ, dragging true). That state is read in the CAPTURE phase; Scene's pointerup listener is on window and runs after TransformControls' own pointerup, so the condition was keyed on something the handler never sees. An unproven change with a commit claiming a fix is worse than none: Scene.svelte's gizmo condition is back as it was (7451aad9's right-click fix stays — it is proven by the probe, 0 -> 8 menu rows). The check is quarantined by name with this evidence: a product race not understood, for the owner.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 src/components/Scene.svelte | 6 +-----
 tests/e2e/quarantine.json   | 1 +
 2 files changed, 2 insertions(+), 5 deletions(-)

diff --git a/src/components/Scene.svelte b/src/components/Scene.svelte
index 8d84fd686..46af1bbd0 100644
--- a/src/components/Scene.svelte
+++ b/src/components/Scene.svelte
@@ -1195,12 +1195,8 @@
 			// a touch gizmo covers most of a small object, which is what the finger aims at
 			const touchTap = event.pointerType === 'touch';
 			// (an object's gizmo only — a mesh / spline session's gizmo keeps every tap)
-			// test-health-1: on a finger, `dragging` set by THIS press is not a drag — we are past the
-			// still-tap test above (<= 5 px, <= 400 ms), and the gizmo's own pointerdown starts a drag on
-			// the handle under the finger, so whether a tap on the seated gizmo let go of the object
-			// depended on which pointerup listener ran first (select-41 G14 unfolded: axis XYZ, dragging)
 			const onGizmo =
-				!!$TControls && (touchTap || !$TControls.dragging) && !!$TControls.axis && !event.altKey &&
+				!!$TControls && !$TControls.dragging && !!$TControls.axis && !event.altKey &&
 				!$editingObject && !$faceEditObject && !$splineEditObject && !$measureMode && !splineToolActive();
 			if ($TControls && ($TControls.dragging || ($TControls.axis && !event.altKey)) && !(touchTap && onGizmo)) return;
 			if (!$objectsGroup) return;
diff --git a/tests/e2e/quarantine.json b/tests/e2e/quarantine.json
index c00ec2e8e..9749685cf 100644
--- a/tests/e2e/quarantine.json
+++ b/tests/e2e/quarantine.json
@@ -18,6 +18,7 @@
 		{"suite": "flow-physics-actions", "check": "8.5 and the very NEXT press throws the box", "reason": "stale-press guard vs frame timing (pcA, deps-1)", "owner": "test-health (standing lane)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "select-41", "check": "G4 (near) a finger on the crate takes it", "reason": "G4 flick timing: 12/12 green on --local, red under load (deps-1 ab3)", "owner": "test-health (standing lane)", "since": "2026-10-23", "review": "2026-11-07"},
 		{"suite": "select-41", "check": "G14 (unfolded) a tap selects", "reason": "the unfolded N6 page under load: a tap is a click only if its pointerdown->pointerup handlers run within 400 ms of page time, and a long software-GL frame between them voids it — red in 3 of 4 runs, a different first check each time (base, v3b, v5a; green v4b). The other race in this block (the finger landing on the seated gizmo: axis XYZ, dragging true at pointerup, e2e/v4b) is fixed in Scene.svelte", "owner": "test-health (standing lane)", "since": "2026-10-24", "review": "2026-11-07"},
+		{"suite": "select-41", "check": "G14 (unfolded) a tap on the selected box deselects it", "reason": "a finger tap on the box lands on the seated gizmo (captured in the capture phase at pointerup: axis XYZ, dragging true) and the box stays selected — red in after-battery and v3b, green in v4b. A fix keyed on that state did NOT change it (reverted): Scene's window pointerup runs after TransformControls' own, so it never sees that state. Product race not understood; owner", "owner": "test-health (standing lane)", "since": "2026-10-25", "review": "2026-11-07"},
 		{"suite": "select-41", "check": "G13 (unfolded) Interact deselects", "reason": "the unfolded N6 page under load: a tap is a click only if its pointerdown->pointerup handlers run within 400 ms of page time, and a long software-GL frame between them voids it — red in 3 of 4 runs, a different first check each time (base, v3b, v5a; green v4b). The other race in this block (the finger landing on the seated gizmo: axis XYZ, dragging true at pointerup, e2e/v4b) is fixed in Scene.svelte", "owner": "test-health (standing lane)", "since": "2026-10-24", "review": "2026-11-07"},
 		{"suite": "select-41", "check": "G13 (unfolded) and Edit restores", "reason": "the unfolded N6 page under load: a tap is a click only if its pointerdown->pointerup handlers run within 400 ms of page time, and a long software-GL frame between them voids it — red in 3 of 4 runs, a different first check each time (base, v3b, v5a; green v4b). The other race in this block (the finger landing on the seated gizmo: axis XYZ, dragging true at pointerup, e2e/v4b) is fixed in Scene.svelte", "owner": "test-health (standing lane)", "since": "2026-10-24", "review": "2026-11-07"},
 		{"suite": "avatar-feet", "check": "1.3 standing: B's lowest sole is on the floor", "reason": "red 2/4 d3d12, 3/3 llvmpipe, green on rerun (mux-pc-host)", "owner": "test-health (standing lane)", "since": "2026-10-23", "review": "2026-11-07"},

From 8cd2578bc801a72b9dfe7ce26822532cc6281f2f Mon Sep 17 00:00:00 2001
From: AlexZ005 <alexz005.info@gmail.com>
Date: Sun, 25 Oct 2026 09:31:22 +0200
Subject: [PATCH 46/46] [test] test-health-1 P2: animation-sync waits for the
 door to reach the third page
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The after battery read the joiner's door after a fixed 1.5 s and found it at x=0.03 (not yet arrived) — then measured a 'hinge drift' against that. Wait (bounded) for the door at its real world place on C first; the check still reports where it was if it never comes. Green 25/0 (e2e/v11a).

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 tests/e2e/animation-sync.test.cjs | 14 +++++++++++++-
 1 file changed, 13 insertions(+), 1 deletion(-)

diff --git a/tests/e2e/animation-sync.test.cjs b/tests/e2e/animation-sync.test.cjs
index d81cfb70b..78d04c9a1 100644
--- a/tests/e2e/animation-sync.test.cjs
+++ b/tests/e2e/animation-sync.test.cjs
@@ -245,7 +245,19 @@ h.run(async () => {
 		ap.updateAnim(obj.uuid, { duration: 1, loop: 'once' });
 		return obj.uuid;
 	});
-	await A.page.waitForTimeout(1500);
+	// the door has to REACH the third page first (a fixed 1.5 s read it at x=0.03 under load) — wait for
+	// it at its real place, bounded; the check below still says where it was if it never came
+	await h.eventually(
+		() => C.page.evaluate((id) => {
+			let g;
+			window.__stores.objectsGroup.subscribe((x) => (g = x))();
+			const obj = g?.getObjectByProperty('uuid', id);
+			return obj ? obj.getWorldPosition(new window.__stores.THREE.Vector3()).x : null;
+		}, doorUuid),
+		(x) => x !== null && Math.abs(x - 3) < 0.01,
+		'(premise) the door arrives on the joiner',
+		15000
+	);
 
 	// where C thinks the hinge is BEFORE the door opens — the invariant to hold
 	const hingeClosed = await C.page.evaluate((id) => {