test(tests): R4.3d browser proofs on the production build: app import baseline on the Rust path, CSP with and without the keyword, leak series, WebKit repetition

Same perimeter as the TS baseline (226 files, 3 engines, real Home page): 666/678 outcome
and message agreements, the 12 others the 4 declared files; W5 0 long tasks (TS 91 and
173 ms); 50 MiB file in WebKit 145/126 MiB against 324 with the worker read and 76 for the
TS. CSP: editor opens with the keyword, the engine message without, in 3 engines, the
worker's wasm-eval refusal reported by Chromium and Firefox. Leak series on the app:
Chromium ≤ 2 MiB per import after init, Firefox GC sawtooth reclaimed, WebKit grows with
same-tab navigations (control too) and levels off on one page; 20/20 WebKit workers closed.
This commit is contained in:
bchanot committed 2026-10-18 19:48:31 +02:00
1 parent 8ddf185aa6
commit 08f01ef363
17 files changed
+26759 -28

No files matched your search

+281
View File
@@ -0,0 +1,281 @@
// The application's import, TypeScript reader (R4.1) vs Rust import worker
// (R4.3): two results files of import-baseline.mjs, so the same Home page,
// files, groups, engines, RSS metrics and watchdog; only the build differs.
// Per engine and group: outcome and message agreement, median Node-clock
// durations, max summed and content RSS growth, the longest Chromium long
// task (W5: none over 50 ms). Per file, the outcome (editor, inline error)
// and the message shown (the alert lines after an import, the inline error
// text) must be identical, except the declared differences (plan §A.3:
// OD-3, OD-4), each expected with its own message in every engine. Any
// other difference is printed as NOT DECLARED and the exit code is 1. The
// `read` group's files of 10 MiB and more get their own table.
//
// node scripts/browser/compare-app-imports.mjs <ts-app.json> <rust-app.json>
import { readFileSync } from 'node:fs'
import { join } from 'node:path'
import { DECLARED, messageKeys, slugOf } from './compare-imports.mjs'
import { inputBytes } from './lib/import-inputs.mjs'
import { REPO_ROOT } from './lib/paths.mjs'
import { median } from './lib/stats.mjs'
const MiB = 1024 * 1024
const LARGE_BYTES = 10 * MiB
const FIXTURES = 'apps/app/tests/fixtures/'
/** The message each declared file shows on the Rust side (plan §B.1.8). */
const DECLARED_KEYS = {
'values-1m': 'error_attachment_stripped',
'surrogate-content-overwritten': 'error_lone_surrogate',
'surrogate-version-overwritten': 'error_lone_surrogate',
'two-files-decoy-first': 'error_lone_surrogate',
}
const orDash = (format) => (value) =>
value === null || value === undefined ? '–' : format(value)
const mb = orDash((bytes) => (bytes / MiB).toFixed(1))
const ms = orDash((value) => value.toFixed(0))
const shortFile = (file) => file.replace(FIXTURES, '')
const short = (text) => text.replace(/\s+/g, ' ').slice(0, 60)
function table(header, rows) {
const line = (cells) => `| ${cells.join(' | ')} |`
const rule = line(header.map(() => '---'))
return [line(header), rule, ...rows.map(line)].join('\n')
}
/** What the practitioner sees: the outcome and the message, keyed. */
function verdictOf(run, keys) {
const keyOf = (text) => keys.find((k) => k.re.test(text))?.key ?? '?'
if (run.outcome === 'editor' || run.outcome === 'dialog') {
const message = (run.dialogs ?? []).join(' | ')
const label = message ? `${run.outcome} «${short(message)}»` : run.outcome
return { verdict: run.outcome, message, label }
}
if (run.outcome === 'error' && run.errorText) {
const key = keyOf(run.errorText)
const label = `error ${key}`
return { verdict: 'error', message: run.errorText, label, key }
}
const message = run.error ?? ''
return { verdict: `harness ${run.outcome}`, message, label: run.outcome }
}
/** One row per (engine, file) present on either side. */
function pairs(tsRuns, rustRuns, keys) {
const index = (runs) => new Map(runs.map((r) => [`${r.engine} ${r.file}`, r]))
const ts = index(tsRuns)
const rust = index(rustRuns)
return [...new Set([...ts.keys(), ...rust.keys()])].map((id) => {
const t = ts.get(id)
const r = rust.get(id)
const run = t ?? r
return {
engine: run.engine,
group: run.group,
file: run.file,
ts: t ?? null,
rust: r ?? null,
tsV: t ? verdictOf(t, keys) : null,
rustV: r ? verdictOf(r, keys) : null,
}
})
}
const sameOutcome = (p) => p.tsV && p.rustV && p.tsV.verdict === p.rustV.verdict
const sameMessage = (p) => sameOutcome(p) && p.tsV.message === p.rustV.message
const growth = (r) => r.rssPeakBytes - r.rssBeforeBytes
const contentGrowth = (r) => r.rssPeakContentBytes - r.rssBeforeContentBytes
const finite = (list) => list.filter(Number.isFinite)
const maxOf = (list) => (finite(list).length ? Math.max(...finite(list)) : null)
const longest = (runs) => maxOf(runs.map((r) => r.longTasks?.maxMs ?? null))
const pair = (a, b) => `${mb(a)} / ${mb(b)}`
function groupRow([key, list]) {
const [engine, group] = key.split(' ')
const ts = list.map((p) => p.ts).filter(Boolean)
const rust = list.map((p) => p.rust).filter(Boolean)
const withLongTask = rust.filter((r) => r.longTasks?.count > 0).length
return [
engine,
group,
String(list.length),
String(list.filter(sameOutcome).length),
String(list.filter(sameMessage).length),
ms(median(finite(ts.map((r) => r.durationMs)))),
ms(median(finite(rust.map((r) => r.durationMs)))),
pair(maxOf(ts.map(growth)), maxOf(ts.map(contentGrowth))),
pair(maxOf(rust.map(growth)), maxOf(rust.map(contentGrowth))),
ms(longest(ts)),
ms(longest(rust)),
engine === 'chromium' ? String(withLongTask) : '–',
]
}
function groupTable(rows) {
const groups = new Map()
for (const p of rows) {
const key = `${p.engine} ${p.group}`
groups.set(key, [...(groups.get(key) ?? []), p])
}
const header = [
'Engine',
'Group',
'Files',
'Same outcome',
'Same message',
'TS median ms',
'Rust median ms',
'TS max growth summed / content MiB',
'Rust max growth summed / content MiB',
'TS longest long task ms',
'Rust longest long task ms',
'Rust runs with a long task',
]
return table(header, [...groups].map(groupRow))
}
/** The `read` files of 10 MiB and more: TS beside Rust, per engine. */
function largeTable(rows) {
const large = rows.filter(
(p) =>
p.group === 'read' && inputBytes(join(REPO_ROOT, p.file)) >= LARGE_BYTES,
)
const header = [
'File',
'MiB',
'Engine',
'TS outcome',
'Rust outcome',
'TS ms',
'Rust ms',
'TS growth summed / content MiB',
'Rust growth summed / content MiB',
]
const cells = (p) => [
shortFile(p.file).replace('pdf/r4/read/', ''),
mb(inputBytes(join(REPO_ROOT, p.file))),
p.engine,
p.tsV?.label ?? 'not run',
p.rustV?.label ?? 'not run',
ms(p.ts?.durationMs),
ms(p.rust?.durationMs),
p.ts ? pair(growth(p.ts), contentGrowth(p.ts)) : '–',
p.rust ? pair(growth(p.rust), contentGrowth(p.rust)) : '–',
]
return table(header, large.map(cells))
}
/** Every outcome or message difference, grouped by file, declared apart. */
function differences(rows) {
const byFile = new Map()
for (const p of rows.filter((row) => !sameMessage(row))) {
const what =
`TS ${p.tsV?.label ?? 'not run'} / Rust ${p.rustV?.label ?? 'not run'}` +
(sameOutcome(p) ? ' (same outcome, message differs)' : '')
const key = `${p.file}\u0000${what}`
byFile.set(key, [...(byFile.get(key) ?? []), p.engine])
}
return [...byFile].map(([key, engines]) => {
const [file, what] = key.split('\u0000')
const declared = DECLARED[slugOf(file)]
const tag = declared ? `declared (${declared})` : 'NOT DECLARED'
const line = `- ${shortFile(file)} [${engines.join(', ')}]: ${what}: ${tag}`
return { line, declared }
})
}
/** Each declared file, in every engine: TS editor, Rust its own message. */
function declaredCheck(rows, engines) {
return Object.entries(DECLARED_KEYS).map(([slug, key]) => {
const cells = engines.map((engine) => {
const p = rows.find((r) => r.engine === engine && slugOf(r.file) === slug)
if (!p?.tsV || !p.rustV) return { ok: false, text: `${engine}: missing` }
const ok = p.tsV.verdict === 'editor' && p.rustV.key === key
const text = `${engine}: TS ${p.tsV.label} / Rust ${p.rustV.label}`
return { ok, text: ok ? text : `${text} NOT AS DECLARED` }
})
const ok = cells.every((c) => c.ok)
const line = `- ${slug} (expected ${key}): ${cells.map((c) => c.text).join('; ')}`
return { ok, line }
})
}
function perimeterLines(rows) {
const only = (side, list) =>
list.map((p) => `- only in ${side}: ${p.engine} ${shortFile(p.file)}`)
return [
...only(
'TS',
rows.filter((p) => !p.rust),
),
...only(
'Rust',
rows.filter((p) => !p.ts),
),
]
}
function headLines(ts, rust, rows) {
const versions = (r) =>
Object.entries(r.engines)
.map(([e, v]) => `${e} ${v}`)
.join(', ')
const build = (r) =>
`build ${r.build?.headCommit ?? '?'} (${r.build?.builtAt ?? '?'}, ` +
`${r.build?.wasm?.name ?? 'no wasm'})`
return [
`TS app: started ${ts.startedAt}, ${versions(ts)}, ${build(ts)}.`,
`Rust app: started ${rust.startedAt}, ${versions(rust)}, ${build(rust)}.`,
`Watchdog: ${rust.watchdog.caveat}`,
`Same outcome: ${rows.filter(sameOutcome).length} of ${rows.length}; ` +
`same outcome and message: ${rows.filter(sameMessage).length}.`,
]
}
function readResults([tsPath, rustPath]) {
if (!tsPath || !rustPath) {
throw new Error(
'usage: compare-app-imports.mjs <ts-app.json> <rust-app.json>',
)
}
const read = (path) => JSON.parse(readFileSync(path, 'utf8'))
return { ts: read(tsPath), rust: read(rustPath) }
}
function comparison(ts, rust, rows) {
const engines = [...new Set(rows.map((p) => p.engine))]
const diffs = differences(rows)
const undeclared = diffs.filter((d) => !d.declared)
const declared = declaredCheck(rows, engines)
const failedDeclared = declared.filter((d) => !d.ok)
const perimeter = perimeterLines(rows)
const parts = [
...headLines(ts, rust, rows),
'TS app vs Rust app by engine and group:',
groupTable(rows),
'Large files of the read group (10 MiB and more):',
largeTable(rows),
perimeter.length
? `PERIMETER DIFFERS (${perimeter.length}):\n${perimeter.join('\n')}`
: 'Perimeter: every (engine, file) pair is on both sides.',
`Differences (${diffs.length}; not declared: ${undeclared.length}):`,
diffs.map((d) => d.line).join('\n') || 'none',
'Declared differences, per engine:',
declared.map((d) => d.line).join('\n'),
]
const failures = undeclared.length + failedDeclared.length + perimeter.length
if (failures) {
parts.push(
`WARNING: ${undeclared.length} undeclared difference(s), ` +
`${failedDeclared.length} declared file(s) not as declared, ` +
`${perimeter.length} perimeter difference(s).`,
)
}
return { text: parts.join('\n\n'), failures }
}
const { ts, rust } = readResults(process.argv.slice(2))
const rows = pairs(ts.import.runs, rust.import.runs, await messageKeys())
const { text, failures } = comparison(ts, rust, rows)
console.log(text)
if (failures) process.exitCode = 1