// Import baseline of the TypeScript reader (R4.1e, plan O12, §B.3): for each // file, a fresh context opens Home and sets the file on the import input; // the run ends at the first of: navigation to /editor, an alert, the inline // import error. Records the duration, the alert and error texts, the final // URL, the browser's summed RSS (before, peak) and, in Chromium, the main // thread's long tasks. One browser per engine, relaunched after a stop. // // PLAYWRIGHT_NODE_MODULES=... node scripts/browser/import-baseline.mjs \ // [--engines chromium,firefox,webkit] [--out ] import { existsSync, mkdtempSync, readFileSync, rmdirSync, unlinkSync, writeFileSync, } from 'node:fs' import { tmpdir } from 'node:os' import { basename, join } from 'node:path' import { pathToFileURL } from 'node:url' import { delay, firstLine, isStop, tagged, timeoutAfter, untilStopped, } from './lib/async.mjs' import { runHarnessCli } from './lib/harness.mjs' import { expandGenerator, filesUnder, isGenerator } from './lib/inputs.mjs' import { FIXTURES_DIR, ORACLES_R4_DIR, relativeToRepo } from './lib/paths.mjs' import { probedPage, readProbe } from './lib/page-probes.mjs' import { closeEngine, launchEngine } from './lib/playwright.mjs' import { sum } from './lib/stats.mjs' const IMPORT_TIMEOUT_MS = 120_000 const SETTLE_MS = 5000 const PICK_LABEL = 'Choisir un fichier' // fr.ts home.import.cta const IMPORT_ERROR = 'input[type="file"] ~ p.text-red-700' const READ_DIR = join(FIXTURES_DIR, 'pdf/r4/read') const isPdf = (path) => path.endsWith('.pdf') const BASE_FILES = [ 'report-v2.full.pdf', 'report-v2.minimal.pdf', 'report-v3.bare.pdf', ] function pdfsIn(group, dir, recursive = false) { const paths = filesUnder(join(FIXTURES_DIR, dir), recursive).filter(isPdf) return paths.map((path) => ({ group, path })) } function fixedGroups() { return [ ...BASE_FILES.map((f) => ({ group: 'base', path: join(FIXTURES_DIR, f) })), ...pdfsIn('r3', 'pdf/r3', true), ...pdfsIn('step6', 'pdf/step6'), ...pdfsIn('tolerance', 'pdf/r4/tolerance'), ] } /** The hostile set as read.json (O7) lists it; absent listed files reported. */ function hostileGroup() { const oraclePath = join(ORACLES_R4_DIR, 'read.json') if (!existsSync(READ_DIR)) { return { inputs: [], missing: ['pdf/r4/read/'], listedBy: null } } const listed = existsSync(oraclePath) ? JSON.parse(readFileSync(oraclePath, 'utf8')).inputs : filesUnder(READ_DIR).map((path) => ({ file: basename(path), kind: null })) const present = listed.filter((i) => existsSync(join(READ_DIR, i.file))) const missing = listed.filter((i) => !present.includes(i)).map((i) => i.file) const inputs = present.map((i) => ({ group: 'read', kind: i.kind, path: join(READ_DIR, i.file), })) return { inputs, missing, listedBy: existsSync(oraclePath) ? relativeToRepo(oraclePath) : 'directory', } } /** A generator description becomes a temporary file, removed after the run. */ function materialise(input, scratch) { if (!isGenerator(input.path)) { return { path: input.path, cleanup: () => undefined } } const path = join(scratch, `${basename(input.path, '.gen.json')}.pdf`) writeFileSync(path, expandGenerator(input.path)) return { path, cleanup: () => unlinkSync(path) } } async function openHome(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) await page.goto(`${baseUrl}/`) const pick = page.getByRole('button', { name: PICK_LABEL }) await pick.and(page.locator(':enabled')).waitFor() return { context, page, events } } /** The first end of an import; the waits start before the file is set. */ function firstEnd(tab, path) { const { page, events } = tab const ends = Promise.race([ tagged('editor', page.waitForURL('**/editor', { timeout: 0 })), tagged('dialog', events.firstDialog), tagged('error_text', page.locator(IMPORT_ERROR).waitFor({ timeout: 0 })), timeoutAfter(IMPORT_TIMEOUT_MS), ]) const set = page.setInputFiles('input[type="file"]', path) return tagged('set', set).then((r) => (r.kind === 'error' ? r : ends)) } /** After an alert the app may still navigate or show its error. */ async function settle(tab, first) { if (first.kind !== 'dialog') return delay(300) const { page } = tab await Promise.race([ tagged('editor', page.waitForURL('**/editor', { timeout: SETTLE_MS })), tagged( 'error_text', page.locator(IMPORT_ERROR).waitFor({ timeout: SETTLE_MS }), ), ]) } function longTasksOf(probe, since) { if (!probe.longTaskSupported) return null const tasks = probe.longTasks.filter((t) => t.start >= since).map((t) => t.ms) return { count: tasks.length, maxMs: tasks.length ? Math.max(...tasks) : 0, totalMs: sum(tasks), } } /** Page clock: the input's change event to the first alert or navigation. */ function pageMsOf(probe) { const ends = [probe.alertAt, probe.navAt].filter((t) => t !== null) if (probe.changeAt === null || ends.length === 0) return null return Math.min(...ends) - probe.changeAt } async function finalState(tab, since) { const { page, events } = tab const errorText = await page .locator(IMPORT_ERROR) .textContent({ timeout: 300 }) .catch(() => null) const probe = await page.evaluate(readProbe) return { finalPath: new URL(page.url()).pathname, errorText, dialogs: events.dialogs.map((d) => d.message), pageMs: pageMsOf(probe), longTasks: longTasksOf(probe, since), cspViolations: probe.csp, pageErrors: events.pageErrors, } } function resultOf(final) { if (final.finalPath === '/editor') return 'editor' if (final.errorText) return 'error' return final.dialogs.length ? 'dialog' : 'none' } /** Before the file was set, and the peak until the import's first end. */ function rssOf(before, after) { return { rssBeforeBytes: before.currentBytes, rssBeforeContentBytes: before.currentContentBytes, rssPeakBytes: after.peakBytes, rssPeakContentBytes: after.peakContentBytes, } } async function measureImport(session, tab, path) { const since = await tab.page.evaluate(() => performance.now()) const before = session.watchdog.snapshot() await session.watchdog.resetPeak() const start = performance.now() const first = await untilStopped(session, firstEnd(tab, path)) const rss = rssOf(before, session.watchdog.snapshot()) const head = { firstEnd: first.kind, durationMs: first.at - start, ...rss } if (isStop(first) || first.kind === 'timeout' || first.kind === 'error') { return { outcome: first.kind, error: first.error ?? null, ...head } } await settle(tab, first) const final = await finalState(tab, since) return { outcome: resultOf(final), ...head, ...final } } async function importRun(session, baseUrl, input, scratch) { const file = materialise(input, scratch) const head = { group: input.group, kind: input.kind ?? null, file: relativeToRepo(input.path), } let tab = null try { tab = await openHome(session, baseUrl) return { ...head, ...(await measureImport(session, tab, file.path)) } } catch (error) { const outcome = session.watchdog.snapshot().stopped ? 'stopped_by_ceiling' : 'error' return { ...head, outcome, error: firstLine(error) } } finally { await tab?.context.close().catch(() => undefined) file.cleanup() } } async function importEngine(pw, { engine, baseUrl, inputs, scratch, log }) { let session = await launchEngine(pw, engine) const runs = [] try { for (const input of inputs) { const run = await importRun(session, baseUrl, input, scratch) runs.push({ engine, engineVersion: session.version, ...run }) const ms = Math.round(run.durationMs ?? 0) log(`import ${engine} ${run.file}: ${run.outcome} ${ms} ms`) if (run.outcome === 'watchdog_failed') throw new Error('watchdog failed') if (run.outcome !== 'stopped_by_ceiling') continue await closeEngine(session) session = await launchEngine(pw, engine) } } finally { await closeEngine(session) } return runs } export async function runImportBaseline(context) { const { pw, baseUrl, engines, filters, log } = context const hostile = hostileGroup() const wanted = (i) => !filters.groups || filters.groups.includes(i.group) const inputs = [...fixedGroups(), ...hostile.inputs].filter(wanted) const scratch = mkdtempSync(join(tmpdir(), 'faunosteo-import-')) const runs = [] try { for (const engine of engines) { runs.push( ...(await importEngine(pw, { engine, baseUrl, inputs, scratch, log })), ) } } finally { rmdirSync(scratch) } return { timeoutMs: IMPORT_TIMEOUT_MS, files: inputs.length, hostile: { listedBy: hostile.listedBy, present: hostile.inputs.length, missing: hostile.missing, }, runs, } } if (import.meta.url === pathToFileURL(process.argv[1]).href) { await runHarnessCli({ import: runImportBaseline }) }