// Leak series of the application's import (R4.3d, BDR-058 leak criterion), // through the real Home page and its disposable import worker: // leak per engine, per document (the L envelope, the 16 MiB // dense numbers refused by the value budget, a rescue copy // of the demo report), `--reps` times, a fresh browser per // repetition and ONE tab: Home, the start level, then one // import (init cost, counted apart) and `--imports` more, // each by `page.goto('/')` and the pick button; when the // app asks « Remplacer le bilan en cours ? », « Remplacer » // opens the picker. 2 s idle after each import, 5 s at the // end, the content RSS read after each. Chromium: forced GC // (CDP) + 1 s before each reading; Firefox and WebKit: idle // only (no forced GC there, indicative). Recurring growth = // L7 − L2 (the last 5 imports for 6), tolerance 10 MiB. // webkit-repeat WebKit, one Home page (no navigation), `--webkit-imports` // consecutive picks of the 16 MiB dense document, a worker // per import: the inline lines, page errors, console errors // (page and workers), workers created and closed. // control (opt-in) the series without the pick: the same tab, // `page.goto('/')` steps, idle and readings, to tell the // navigations' own cost from the imports'. // The browser runs under the 4 GiB RSS watchdog (not a guaranteed limit). // // PLAYWRIGHT_NODE_MODULES=... node scripts/browser/r4-app-leak-series.mjs \ // [--engines chromium,firefox,webkit] \ // [--sections leak,webkit-repeat,control] \ // [--reps 3] [--imports 6] [--webkit-imports 20] [--scratch ] \ // [--out ] import { copyFileSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs' import { tmpdir } from 'node:os' import { basename, join } from 'node:path' import { parseArgs } from 'node:util' import { messageKeys } from './compare-imports.mjs' import { IMPORT_ERROR, PICK_LABEL, pageMsOf, settle, } from './import-baseline.mjs' import { checkBuild } from './lib/app-build.mjs' import { delay, firstLine, isStop, tagged, timeoutAfter, untilStopped, } from './lib/async.mjs' import { PKG_DIR, draftBundle } from './lib/core-module.mjs' import { writeHostileClasses } from './lib/hostile-classes.mjs' import { hostFacts, memAvailableBytes } from './lib/host.mjs' import { scratchDir } from './lib/import-inputs.mjs' import { sha256 } from './lib/inputs.mjs' import { countErrorLines, probedPage, readProbe } from './lib/page-probes.mjs' import { FIXTURES_DIR, RESULTS_DIR } from './lib/paths.mjs' import { ENGINES, closeEngine, launchEngine, loadPlaywright, } from './lib/playwright.mjs' import { leakTable } from './lib/r4-memory-summary.mjs' import { IDLE_SETTLE_MS, forcedGc, levelNow } from './lib/r4-runs.mjs' import { resultsJson } from './lib/results-json.mjs' import { spread } from './lib/stats.mjs' import { watchdogFacts } from './lib/watchdog.mjs' import { deltasOf } from './r4-leak-series.mjs' import { startServer } from './serve.mjs' const MiB = 1024 * 1024 const SECTIONS = ['leak', 'webkit-repeat', 'control'] const DEFAULT_SECTIONS = ['leak', 'webkit-repeat'] const CONTROL_ID = 'navigation-only' const HOSTILE_IDS = ['L-envelope', 'dense-numbers-16mib'] const COPY_ID = 'rescue-copy-demo' const COPY_SOURCE = join(FIXTURES_DIR, 'report-v3.demo.json') const COPY_NAME = 'copie-de-secours-demo.json' const WEBKIT_DOCUMENT = 'dense-numbers-16mib' const REPLACE_LABEL = 'Remplacer' // fr.ts session.replace.confirm const REPLACE_TITLE = 'Remplacer le bilan en cours ?' // session.replace.title const IMPORT_TIMEOUT_MS = 120_000 // import-baseline.mjs const STEP_TIMEOUT_MS = 30_000 const BETWEEN_MS = 2000 const FINAL_IDLE_MS = 5000 const MAX_CONSOLE = 40 // The footer's external logo, blocked by img-src (the known CSP violation). const FOOTER_IMAGE_HOST = 'zenquality.fr' const READINGS = 'Readings: content RSS of the browser tree after each import, 2 s idle ' + 'after its end (editor, alert or inline line; the worker is terminated ' + 'by then); Chromium adds a forced GC (CDP HeapProfiler.collectGarbage) ' + '+ 1 s before each reading, Firefox and WebKit are read after idle only ' + '(no forced GC: indicative). Start = Home loaded, before any pick (GC + ' + '1 s, or 5 s idle); final = after 5 s more idle. Init Δ = L1 − L0; ' + 'recurring = L7 − L2 (the last 5 imports). A reading after an import ' + 'that opened the editor includes the editor page (its own core instance).' const today = () => new Date().toISOString().slice(0, 10) const log = (line) => console.error(`[${new Date().toISOString()}] ${line}`) const listOf = (text) => text.split(',').filter(Boolean) const count = (text, name) => { const value = Number(text) if (!Number.isInteger(value) || value < 1) throw new Error(`bad --${name}`) return value } function options() { const { values } = parseArgs({ options: { engines: { type: 'string', default: ENGINES.join(',') }, sections: { type: 'string', default: DEFAULT_SECTIONS.join(',') }, reps: { type: 'string', default: '3' }, imports: { type: 'string', default: '6' }, 'webkit-imports': { type: 'string', default: '20' }, scratch: { type: 'string', default: tmpdir() }, out: { type: 'string', default: join(RESULTS_DIR, `${today()}-r4-app-leak-series.json`), }, }, }) const engines = listOf(values.engines) const sections = listOf(values.sections) const bad = [...engines.filter((e) => !ENGINES.includes(e))] bad.push(...sections.filter((s) => !SECTIONS.includes(s))) if (bad.length) throw new Error(`unknown engines or sections: ${bad}`) return { ...values, engines, sections, reps: count(values.reps, 'reps'), imports: count(values.imports, 'imports'), webkitImports: count(values['webkit-imports'], 'webkit-imports'), } } /** The L envelope and the dense PDF (budget-suite builders), the copy. */ async function writeDocuments(dir) { const hostile = await writeHostileClasses({ bundle: draftBundle(), dir, pkgDir: PKG_DIR, wanted: HOSTILE_IDS, }) const copyPath = join(dir, COPY_NAME) copyFileSync(COPY_SOURCE, copyPath) const copyBytes = readFileSync(copyPath).length const docs = [ ...hostile.classes, { id: COPY_ID, path: copyPath, bytes: copyBytes }, ] const facts = docs.map((d) => ({ id: d.id, name: basename(d.path), bytes: d.bytes, sha256: sha256(readFileSync(d.path)), })) const remove = () => { hostile.remove() unlinkSync(copyPath) } return { docs, facts, remove } } /** The module that built the L envelope, against the one the build ships. */ function envelopeModule(build) { const pkg = sha256(readFileSync(join(PKG_DIR, 'faunosteo_wasm_bg.wasm'))) const dist = build.wasm.sha256 return { pkgWasmSha256: pkg, distWasmSha256: dist, same: pkg === dist } } /** One tab for the whole series; console errors and workers recorded. */ async function openTab(session, baseUrl) { const context = await session.browser.newContext({ locale: 'fr-FR' }) const seed = { draft: null, locale: 'fr', skipDisclaimer: false } const { page, events } = await probedPage(context, seed) const seen = { consoleErrors: [], workers: { created: 0, closed: 0 } } page.on('console', (m) => { if (m.type() !== 'error') return const text = m.text().slice(0, 300) seen.consoleErrors.push({ worker: m.worker() !== null, text }) }) page.on('worker', (w) => { seen.workers.created += 1 w.on('close', () => (seen.workers.closed += 1)) }) const chromium = session.engine === 'chromium' const cdp = chromium ? await context.newCDPSession(page) : null return { context, page, events, seen, cdp, baseUrl } } const pickButton = (page) => page.getByRole('button', { name: PICK_LABEL }) async function goHome(tab) { await tab.page.goto(`${tab.baseUrl}/`) const enabled = pickButton(tab.page).and(tab.page.locator(':enabled')) await enabled.waitFor({ timeout: STEP_TIMEOUT_MS }) } /** * Clicks the pick button; the picker opens at once, or the replace dialog * shows first and « Remplacer » opens it (HomeRoute, ReplaceSessionDialog). */ async function openChooser(page) { const wait = { timeout: STEP_TIMEOUT_MS } const chooser = page.waitForEvent('filechooser', wait) await pickButton(page).click(wait) const replace = page.getByRole('button', { name: REPLACE_LABEL, exact: true }) const first = await Promise.race([ tagged('chooser', chooser), tagged('replace', replace.waitFor(wait)), ]) if (first.kind === 'error') throw new Error(first.error) if (first.kind === 'chooser') return { chooser: first.value, replaced: false } const titled = await page.getByText(REPLACE_TITLE).isVisible() if (!titled) throw new Error(`no « ${REPLACE_TITLE} » beside the button`) await replace.click(wait) return { chooser: await chooser, replaced: true } } /** The first end of one import: editor, alert, inline line, or timeout. */ function importEnd(page, lineShown) { const wait = { timeout: IMPORT_TIMEOUT_MS + 5000 } return Promise.race([ tagged('editor', page.waitForURL('**/editor', wait)), tagged('dialog', page.waitForEvent('dialog', wait)), tagged('error_text', lineShown(wait)), timeoutAfter(IMPORT_TIMEOUT_MS), ]) } const harnessEnd = (end) => isStop(end) || end.kind === 'timeout' || end.kind === 'error' /** One pick of `path` on the current Home, raced, then its row. */ async function pickAndWait(session, tab, path, lineShown) { const { events } = tab const before = { dialogs: events.dialogs.length, pageErrors: events.pageErrors.length, } const { chooser, replaced } = await openChooser(tab.page) const ends = importEnd(tab.page, lineShown) const start = performance.now() await chooser.setFiles(path) const end = await untilStopped(session, ends) const durationMs = end.at - start if (harnessEnd(end)) { return { harness: true, outcome: end.kind, error: end.error, durationMs } } await settle(tab, end) return { replaced, durationMs, before } } /** What the import showed: path, inline line (keyed), alert lines. */ async function importRow(tab, picked, keys) { if (picked.harness) return picked const { page, events } = tab const errorText = await page .locator(IMPORT_ERROR) .textContent({ timeout: 300 }) .catch(() => null) const finalPath = new URL(page.url()).pathname const dialogs = events.dialogs.slice(picked.before.dialogs) let outcome = dialogs.length ? 'dialog' : 'none' if (errorText) outcome = 'error' if (finalPath === '/editor') outcome = 'editor' return { outcome, replaced: picked.replaced, durationMs: picked.durationMs, pageMs: pageMsOf(await page.evaluate(readProbe)), key: errorText && (keys.find((k) => k.re.test(errorText))?.key ?? '?'), errorText, alert: dialogs.map((d) => d.message).join(' | ') || null, pageErrors: events.pageErrors.slice(picked.before.pageErrors), } } const labelOf = (r) => r.harness ? r.outcome : `${r.outcome}${r.replaced ? ' after Remplacer' : ''}` + (r.key ? ` ${r.key}` : '') /** One import by `page.goto('/')` then the pick button. */ async function navigatedImport(session, tab, path, keys) { await goHome(tab) const line = tab.page.locator(IMPORT_ERROR) const picked = await pickAndWait(session, tab, path, (w) => line.waitFor(w)) return importRow(tab, picked, keys) } async function reading(session, tab) { if (tab.cdp) await forcedGc(tab) return levelNow(session) } /** A control step: Home loaded again, nothing picked. */ async function navigationOnly(tab) { await goHome(tab) return { outcome: 'navigation' } } /** ONE tab: start level, the init step, `item.imports` more, final. */ async function measureSeries(session, tab, item, step) { await goHome(tab) if (!tab.cdp) await delay(IDLE_SETTLE_MS) const levels = [await reading(session, tab)] await session.watchdog.resetPeak() const imports = [] for (let i = 0; i <= item.imports; i += 1) { const row = await step() imports.push(row) if (row.harness) return seriesCut(tab, row, imports) await delay(BETWEEN_MS) levels.push(await reading(session, tab)) } await delay(FINAL_IDLE_MS) levels.push(await reading(session, tab)) return seriesRow(session, tab, item, { levels, imports }) } /** Each section's measure of one item in its tab. */ const MEASURES = { leak: (session, tab, item, keys) => measureSeries(session, tab, item, () => navigatedImport(session, tab, item.path, keys), ), control: (session, tab, item) => measureSeries(session, tab, item, () => navigationOnly(tab)), 'webkit-repeat': (session, tab, item, keys) => measureRepetition(session, tab, item, keys), } const seenOf = (tab) => ({ workers: tab.seen.workers, consoleErrors: tab.seen.consoleErrors.slice(0, MAX_CONSOLE), consoleErrorCount: tab.seen.consoleErrors.length, }) function seriesCut(tab, row, imports) { const outcomes = imports.map(labelOf) return { outcome: row.outcome, error: row.error, outcomes, ...seenOf(tab) } } function seriesRow(session, tab, item, { levels, imports }) { const peak = session.watchdog.snapshot() const content = levels.map((l) => l.rssContentBytes) const summed = levels.map((l) => l.rssBytes) return { outcome: 'series', reading: item.reading, outcomes: imports.map(labelOf), imports, levels: { content, summed }, deltas: { content: deltasOf(content, item.imports), summed: deltasOf(summed, item.imports), }, peakBytes: peak.peakBytes, peakContentBytes: peak.peakContentBytes, ...seenOf(tab), } } /** WebKit: consecutive picks on one Home page, no navigation, no idle. */ async function measureRepetition(session, tab, item, keys) { await goHome(tab) await tab.page.evaluate(countErrorLines) await session.watchdog.resetPeak() const imports = [] const content = [] for (let i = 0; i < item.imports; i += 1) { const shown = await tab.page.evaluate(() => window.__errorLines) const lineShown = (wait) => tab.page.waitForFunction((n) => window.__errorLines > n, shown, wait) const picked = await pickAndWait(session, tab, item.path, lineShown) const row = await importRow(tab, picked, keys) imports.push(row) if (row.harness) break content.push(levelNow(session).rssContentBytes) } return repetitionRow(session, tab, item, { imports, content }) } /** Distinct inline lines with their counts. */ function linesOf(imports) { const counts = new Map() for (const r of imports) { const text = r.errorText ?? `(${r.outcome})` counts.set(text, (counts.get(text) ?? 0) + 1) } return [...counts].map(([text, n]) => ({ text, count: n })) } function repetitionRow(session, tab, item, { imports, content }) { const peak = session.watchdog.snapshot() return { outcome: 'repeated', imports: item.imports, outcomes: imports.map(labelOf), durationsMs: imports.map((r) => Math.round(r.durationMs)), lines: linesOf(imports), pageErrors: imports.flatMap((r) => r.pageErrors ?? []), contentLevels: content, contentAfter: { first: content[0], min: Math.min(...content), max: Math.max(...content), last: content[content.length - 1], }, peakBytes: peak.peakBytes, peakContentBytes: peak.peakContentBytes, ...seenOf(tab), } } /** A fresh browser and tab per item (per repetition). */ async function itemRun(pw, engine, item, context) { const session = await launchEngine(pw, engine) const head = { engine, engineVersion: session.version, ...headOf(item) } const measureOf = MEASURES[item.section] let tab = null try { tab = await openTab(session, context.baseUrl) return { ...head, ...(await measureOf(session, tab, item, context.keys)) } } catch (error) { const stopped = session.watchdog.snapshot().stopped const outcome = stopped ? 'stopped_by_ceiling' : 'error' return { ...head, outcome, error: firstLine(error) } } finally { await tab?.context.close().catch(() => undefined) await closeEngine(session) } } const headOf = (item) => ({ section: item.section, class: item.id, fileBytes: item.bytes, ...(item.rep ? { rep: item.rep } : {}), }) function enginePlan(engine, opts, docs) { const reading = engine === 'chromium' ? 'gc + 1 s' : 'idle only' const plan = [] if (opts.sections.includes('leak')) { for (const doc of docs) { for (let rep = 1; rep <= opts.reps; rep += 1) { plan.push({ section: 'leak', ...doc, rep, reading, imports: opts.imports, }) } } } if (opts.sections.includes('control')) { for (let rep = 1; rep <= opts.reps; rep += 1) { const step = { id: CONTROL_ID, bytes: 0, rep, reading } plan.push({ section: 'control', ...step, imports: opts.imports }) } } if (engine === 'webkit' && opts.sections.includes('webkit-repeat')) { const doc = docs.find((d) => d.id === WEBKIT_DOCUMENT) plan.push({ section: 'webkit-repeat', ...doc, imports: opts.webkitImports }) } return plan } function conditions({ build, server, version, documents, opts }) { return { harness: 'scripts/browser/r4-app-leak-series.mjs', startedAt: new Date().toISOString(), watchdog: watchdogFacts(), host: hostFacts(), build, server: { bind: '127.0.0.1', csp: server.csp, envJs: 'local tool' }, playwrightCore: version, documents: documents.facts, envelopeModule: envelopeModule(build), flow: 'leak: page.goto("/"), the pick button, « Remplacer » when the ' + 'replace dialog shows, the picker (filechooser) set to the file; ' + 'webkit-repeat: the same pick on one Home page, no navigation', page: { imports: { init: 1, then: opts.imports, reps: opts.reps }, betweenMs: BETWEEN_MS, finalIdleMs: FINAL_IDLE_MS, webkitImports: opts.webkitImports, browser: 'relaunched for every repetition', }, readings: READINGS, } } function repetitionTable(runs) { const line = (cells) => `| ${cells.join(' | ')} |` const header = [ 'Engine', 'Document', 'Imports', 'Inline lines', 'Page errors', 'Console errors (worker, footer image)', 'Workers created / closed', 'Content after import MiB first / min / max / last', 'Series peak content MiB', 'Node ms median (min–max)', ] const mb = (v) => (v === undefined ? '–' : (v / MiB).toFixed(1)) const rows = runs.map((r) => { const c = r.contentAfter ?? {} const d = spread(r.durationsMs ?? []) ?? {} const errors = r.consoleErrors ?? [] const image = errors.filter((e) => e.text.includes(FOOTER_IMAGE_HOST)) const consoleCell = r.consoleErrors ? `${r.consoleErrorCount} (worker ${errors.filter((e) => e.worker).length}` + `, footer image ${image.length})` : '–' return line([ r.engine, r.class, String(r.outcomes?.length ?? '–'), (r.lines ?? []).map((l) => `${l.count} × ${l.text}`).join('; ') || `${r.outcome} ${r.error ?? ''}`, String(r.pageErrors?.length ?? '–'), consoleCell, r.workers ? `${r.workers.created} / ${r.workers.closed}` : '–', [c.first, c.min, c.max, c.last].map(mb).join(' / '), mb(r.peakContentBytes), `${d.median ?? '–'} (${d.min ?? '–'}–${d.max ?? '–'})`, ]) }) return [line(header), line(header.map(() => '---')), ...rows].join('\n') } function summary(result) { const parts = [result.readings] if (result.leak.runs.length) { parts.push('Leak series (content RSS):', leakTable(result.leak.runs)) } if (result.control.runs.length) { parts.push('Navigation-only control (content RSS, no pick):') parts.push(leakTable(result.control.runs)) } if (result.webkitRepeat.runs.length) { parts.push('WebKit repetition, one Home page:') parts.push(repetitionTable(result.webkitRepeat.runs)) } return parts.join('\n\n') } async function main() { const opts = options() const build = checkBuild() const { pw, version } = loadPlaywright() const keys = await messageKeys() const scratch = scratchDir(opts.scratch) const documents = await writeDocuments(scratch.dir) const server = await startServer() try { const result = conditions({ build, server, version, documents, opts }) const context = { baseUrl: server.url, keys } const runs = [] for (const engine of opts.engines) { for (const item of enginePlan(engine, opts, documents.docs)) { const run = await itemRun(pw, engine, item, context) runs.push(run) log( `${engine} ${run.class} ${run.rep ?? ''}: ${run.outcome} ` + `${run.error ?? (run.outcomes ?? []).join(', ')}`, ) } } result.endedAt = new Date().toISOString() result.host.memAvailableBytesAtEnd = memAvailableBytes() result.engines = Object.fromEntries( runs.map((r) => [r.engine, r.engineVersion]), ) result.leak = { runs: runs.filter((r) => r.section === 'leak') } result.webkitRepeat = { runs: runs.filter((r) => r.section === 'webkit-repeat'), } result.control = { runs: runs.filter((r) => r.section === 'control') } writeFileSync(opts.out, `${resultsJson(result)}\n`) log(`results written to ${opts.out}`) console.log(summary(result)) } finally { server.close() documents.remove() scratch.remove() } } await main()