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.
314 lines
11 KiB
JavaScript
314 lines
11 KiB
JavaScript
// TypeScript import baseline vs Rust import (R4.2e): markdown tables from
|
||
// a results file of import-baseline.mjs / ts-baseline.mjs and one of
|
||
// r4-import.mjs, on the same perimeter (same files, groups, engines, RSS
|
||
// metrics). Per engine and group: median durations, max summed and content
|
||
// RSS growth, the per-file outcome agreement (TS `editor` ↔ Rust `ok`, a
|
||
// TS refusal ↔ a Rust refusal or worker failure); every disagreeing file is
|
||
// listed with both outcomes, the declared differences (plan §A.3, OD-3,
|
||
// OD-4) apart, and any other one flagged loudly. A finer check compares
|
||
// the message each side would show (TS alert text ↔ Rust kind through the
|
||
// plan §B.1.8 table).
|
||
//
|
||
// node scripts/browser/compare-imports.mjs <ts.json> <r4-import.json>
|
||
import { readFileSync } from 'node:fs'
|
||
import { join } from 'node:path'
|
||
import { pathToFileURL } from 'node:url'
|
||
import { REPO_ROOT } from './lib/paths.mjs'
|
||
import { median } from './lib/stats.mjs'
|
||
|
||
const MiB = 1024 * 1024
|
||
const FIXTURES = 'apps/app/tests/fixtures/'
|
||
const FR_DICT = join(REPO_ROOT, 'apps/app/src/i18n/fr.ts')
|
||
|
||
/** Plan §A.3: the only accepted outcome differences, by file slug. */
|
||
export const DECLARED = {
|
||
'values-1m': 'OD-3 value cap: a token-dense attachment is refused',
|
||
'surrogate-content-overwritten':
|
||
'OD-4: overwritten duplicate with a lone surrogate → lone_surrogate',
|
||
'surrogate-version-overwritten':
|
||
'OD-4: overwritten duplicate with a lone surrogate → lone_surrogate',
|
||
'two-files-decoy-first':
|
||
'OD-4: overwritten duplicate with a lone surrogate → lone_surrogate',
|
||
}
|
||
|
||
/** Plan §B.1.8: the message key each Rust outcome shows, per route. */
|
||
const PDF_KEYS = {
|
||
invalid_pdf: 'error_invalid_pdf',
|
||
file_too_large: 'error_invalid_pdf',
|
||
no_attachment: 'error_no_attachment',
|
||
attachment_stripped: 'error_attachment_stripped',
|
||
incompatible_version: 'error_incompatible_version',
|
||
lone_surrogate: 'error_lone_surrogate',
|
||
invalid: 'error_generic',
|
||
internal: 'error_core_unavailable',
|
||
core_unavailable: 'error_core_unavailable',
|
||
}
|
||
const COPY_REFUSALS = [
|
||
'file_too_large',
|
||
'invalid_utf8',
|
||
'invalid',
|
||
'unsupported_version',
|
||
'lone_surrogate',
|
||
]
|
||
|
||
const mb = (bytes) => (bytes === null ? '–' : (bytes / MiB).toFixed(1))
|
||
const ms = (value) => (value === null ? '–' : value.toFixed(0))
|
||
const shortFile = (file) => file.replace(FIXTURES, '')
|
||
export const slugOf = (file) =>
|
||
file
|
||
.split('/')
|
||
.pop()
|
||
.replace(/\.(pdf|bin|gen\.json)$/, '')
|
||
|
||
function table(header, rows) {
|
||
const line = (cells) => `| ${cells.join(' | ')} |`
|
||
const rule = line(header.map(() => '---'))
|
||
return [line(header), rule, ...rows.map(line)].join('\n')
|
||
}
|
||
|
||
/** French message text → its `home.import.*` key ({version} as a wildcard). */
|
||
export async function messageKeys() {
|
||
const { fr } = await import(pathToFileURL(FR_DICT).href)
|
||
const entries = Object.entries(fr).filter(([k]) =>
|
||
k.startsWith('home.import.error_'),
|
||
)
|
||
return entries.map(([key, text]) => {
|
||
const parts = text.split('{version}').map(RegExp.escape)
|
||
return {
|
||
key: key.slice('home.import.'.length),
|
||
re: new RegExp(`^${parts.join('.*')}$`),
|
||
}
|
||
})
|
||
}
|
||
|
||
function tsVerdict(run, keys) {
|
||
if (run.outcome === 'editor') return { verdict: 'accepted', label: 'editor' }
|
||
if (run.outcome === 'error' && run.errorText) {
|
||
const key = keys.find((k) => k.re.test(run.errorText))?.key ?? '?'
|
||
return { verdict: 'refused', label: `error ${key}`, key }
|
||
}
|
||
return { verdict: `harness ${run.outcome}`, label: run.outcome }
|
||
}
|
||
|
||
function rustKey(run) {
|
||
if (run.route === 'copy') {
|
||
if (run.outcome === 'refused' && COPY_REFUSALS.includes(run.resultKind)) {
|
||
return 'error_invalid_copy'
|
||
}
|
||
return 'error_core_unavailable'
|
||
}
|
||
if (run.outcome === 'failed') return 'error_generic'
|
||
return PDF_KEYS[run.resultKind] ?? `?${run.resultKind}`
|
||
}
|
||
|
||
function rustVerdict(run) {
|
||
if (run.outcome === 'ok') return { verdict: 'accepted', label: 'ok' }
|
||
if (run.outcome === 'refused' || run.outcome === 'failed') {
|
||
const what = run.outcome === 'failed' ? `failed ${run.phase}` : 'refused'
|
||
const label = `${what} ${run.resultKind ?? run.detail ?? ''}`.trim()
|
||
return { verdict: 'refused', label, key: rustKey(run) }
|
||
}
|
||
return { verdict: `harness ${run.outcome}`, 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)
|
||
const all = new Set([...ts.keys(), ...rust.keys()])
|
||
return [...all].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 ? tsVerdict(t, keys) : null,
|
||
rustV: r ? rustVerdict(r) : null,
|
||
}
|
||
})
|
||
}
|
||
|
||
const agrees = (p) => p.tsV && p.rustV && p.tsV.verdict === p.rustV.verdict
|
||
const growth = (r) => r.rssPeakBytes - r.rssBeforeBytes
|
||
const contentGrowth = (r) => r.rssPeakContentBytes - r.rssBeforeContentBytes
|
||
const maxOf = (list) => (list.length ? Math.max(...list) : null)
|
||
const finite = (list) => list.filter(Number.isFinite)
|
||
|
||
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 agreeing = list.filter(agrees).length
|
||
return [
|
||
engine,
|
||
group,
|
||
String(list.length),
|
||
String(agreeing),
|
||
String(list.length - agreeing),
|
||
ms(median(finite(ts.map((r) => r.durationMs)))),
|
||
ms(median(finite(rust.map((r) => r.durationMs)))),
|
||
ms(median(finite(rust.map((r) => r.pageMs)))),
|
||
mb(maxOf(finite(ts.map(growth)))),
|
||
mb(maxOf(finite(rust.map(growth)))),
|
||
mb(maxOf(finite(ts.map(contentGrowth)))),
|
||
mb(maxOf(finite(rust.map(contentGrowth)))),
|
||
]
|
||
}
|
||
|
||
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',
|
||
'Agree',
|
||
'Disagree',
|
||
'TS median ms',
|
||
'Rust median ms',
|
||
'Rust median page ms',
|
||
'TS max RSS growth MiB',
|
||
'Rust max RSS growth MiB',
|
||
'TS max content growth MiB',
|
||
'Rust max content growth MiB',
|
||
]
|
||
return table(header, [...groups].map(groupRow))
|
||
}
|
||
|
||
/** Disagreements grouped by file and outcome pair, engines listed. */
|
||
function disagreementLines(rows) {
|
||
const byFile = new Map()
|
||
for (const p of rows.filter((row) => !agrees(row))) {
|
||
const tsLabel = p.tsV?.label ?? 'not run'
|
||
const what = `TS ${tsLabel} / Rust ${p.rustV?.label ?? 'not run'}`
|
||
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'
|
||
return {
|
||
file,
|
||
line: `- ${shortFile(file)} [${engines.join(', ')}]: ${what}: ${tag}`,
|
||
declared,
|
||
}
|
||
})
|
||
}
|
||
|
||
/** Every declared difference must show up, in every engine. */
|
||
function declaredCheck(rows, engines) {
|
||
return Object.keys(DECLARED).map((slug) => {
|
||
const cells = engines.map((engine) => {
|
||
const p = rows.find((r) => r.engine === engine && slugOf(r.file) === slug)
|
||
if (!p) return `${engine}: missing`
|
||
if (agrees(p)) return `${engine}: AGREES (expected a difference)`
|
||
const tsLabel = p.tsV?.label ?? 'not run'
|
||
return `${engine}: TS ${tsLabel} / Rust ${p.rustV?.label ?? 'not run'}`
|
||
})
|
||
return `- ${slug}: ${cells.join('; ')}`
|
||
})
|
||
}
|
||
|
||
/** Both sides refuse, but would not show the same message. */
|
||
function messageLines(rows) {
|
||
const differ = rows.filter(
|
||
(p) =>
|
||
agrees(p) && p.tsV.verdict === 'refused' && p.tsV.key !== p.rustV.key,
|
||
)
|
||
const byFile = new Map()
|
||
for (const p of differ) {
|
||
const what = `TS ${p.tsV.key} / Rust ${p.rustV.key} (${p.rustV.label})`
|
||
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')
|
||
return `- ${shortFile(file)} [${engines.join(', ')}]: ${what}`
|
||
})
|
||
}
|
||
|
||
function perimeterLines(rows) {
|
||
const onlyTs = rows.filter((p) => !p.rust)
|
||
const onlyRust = rows.filter((p) => !p.ts)
|
||
const lines = []
|
||
for (const p of onlyTs)
|
||
lines.push(`- only in TS: ${p.engine} ${shortFile(p.file)}`)
|
||
for (const p of onlyRust)
|
||
lines.push(`- only in Rust: ${p.engine} ${shortFile(p.file)}`)
|
||
return lines
|
||
}
|
||
|
||
function headLines(ts, rust, rows) {
|
||
const versions = (r) =>
|
||
Object.entries(r.engines)
|
||
.map(([e, v]) => `${e} ${v}`)
|
||
.join(', ')
|
||
const agreeing = rows.filter(agrees).length
|
||
return [
|
||
`TS baseline: started ${ts.startedAt}, ${versions(ts)}, ` +
|
||
`build ${ts.build?.headCommit ?? '?'}.`,
|
||
`Rust import: started ${rust.startedAt}, ${versions(rust)}, ` +
|
||
`module sha256 ${rust.module.pkg.wasmSha256} ` +
|
||
`(HEAD ${rust.module.headCommit}).`,
|
||
`Perimeter: ${rust.perimeter}.`,
|
||
`Watchdog: ${rust.watchdog.caveat}`,
|
||
`Outcome agreement: ${agreeing} of ${rows.length} (engine, file) pairs.`,
|
||
]
|
||
}
|
||
|
||
function readResults([tsPath, rustPath]) {
|
||
if (!tsPath || !rustPath) {
|
||
throw new Error(
|
||
'usage: compare-imports.mjs <ts-baseline.json> <r4-import.json>',
|
||
)
|
||
}
|
||
const ts = JSON.parse(readFileSync(tsPath, 'utf8'))
|
||
const rust = JSON.parse(readFileSync(rustPath, 'utf8'))
|
||
return { ts, rust }
|
||
}
|
||
|
||
function comparison(ts, rust, rows) {
|
||
const engines = [...new Set(rows.map((p) => p.engine))]
|
||
const disagreements = disagreementLines(rows)
|
||
const undeclared = disagreements.filter((d) => !d.declared)
|
||
const perimeter = perimeterLines(rows)
|
||
const messages = messageLines(rows)
|
||
const parts = [
|
||
...headLines(ts, rust, rows),
|
||
'TS vs Rust by engine and group:',
|
||
groupTable(rows),
|
||
perimeter.length
|
||
? `PERIMETER DIFFERS (${perimeter.length}):\n${perimeter.join('\n')}`
|
||
: 'Perimeter: every (engine, file) pair is on both sides.',
|
||
`Disagreements (${disagreements.length}; ` +
|
||
`not declared: ${undeclared.length}):`,
|
||
disagreements.map((d) => d.line).join('\n') || 'none',
|
||
'Declared differences, per engine:',
|
||
declaredCheck(rows, engines).join('\n'),
|
||
`Both refuse, different message (${messages.length}):`,
|
||
messages.join('\n') || 'none',
|
||
]
|
||
if (undeclared.length) {
|
||
const count = `${undeclared.length} disagreement(s)`
|
||
parts.push(`WARNING: ${count} outside the declared differences.`)
|
||
}
|
||
return parts
|
||
}
|
||
|
||
async function main() {
|
||
const { ts, rust } = readResults(process.argv.slice(2))
|
||
const rows = pairs(ts.import.runs, rust.import.runs, await messageKeys())
|
||
console.log(comparison(ts, rust, rows).join('\n\n'))
|
||
}
|
||
|
||
if (import.meta.url === pathToFileURL(process.argv[1]).href) await main()
|