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:
1 parent
8ddf185aa6
commit
08f01ef363
17 files changed
+26759
-28
No files matched your search
@@ -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
|
||||
Reference in new issue
Block a user