Files
bchanot c84186b032 test(tests): R4.2e browser measurements of the Rust import (module worker page, same perimeter as the TS baseline)
r4-import.mjs runs the 226 baseline files and the hostile classes through a disposable
module worker calling SheetHandle.import_pdf in Chromium 156, Firefox 157 and WebKit 27.2
under the RSS watchdog (not a guaranteed limit); compare-imports.mjs prints TS vs Rust;
serve.mjs gains opt-in mounts (/r4/, /pkg/). Results 2026-10-18-r4-import.json: 666/678
agreements, the 12 others are the 4 declared files; W4 met (max 68 MiB linear); the
1 GiB ceiling traps in every engine.
2026-10-18 16:58:42 +02:00

161 lines
5.4 KiB
JavaScript

import { readFileSync, unlinkSync, writeFileSync } from 'node:fs'
import { join } from 'node:path'
import { deflateSync } from 'node:zlib'
import { nodeSheet } from './core-module.mjs'
import { FIXTURES_DIR } from './paths.mjs'
/**
* The hostile classes of packages/core-wasm/tests/pdf-import.budget.test.ts
* (plan §B.3, W4), built in Node with the same builders, written as
* temporary files for the browser run. The L and CAP envelopes are built
* as that suite builds them: the demo archive read by the shipped module,
* the report swapped in, a fresh `archive.snapshot`.
*/
const MiB = 1024 * 1024
// UTF-8, as the suite's TextEncoder (the envelopes hold accented text).
const ascii = (text) => Buffer.from(text, 'utf8')
/** A PDF holding `streams` as EmbeddedFile objects, Filespecs, the stamp. */
export function pdfWith(streams, padding = 0) {
const parts = [ascii('%PDF-1.7\n%\xE2\xE3\xCF\xD3\n')]
if (padding > 0) parts.push(ascii(`%${'x'.repeat(padding - 2)}\n`))
let n = 1
for (const stream of streams) {
const filter = stream.flate ? ' /Filter /FlateDecode' : ''
const length = stream.bytes.byteLength
parts.push(
ascii(`${n} 0 obj\n<< /Type /EmbeddedFile /Length ${length}${filter}`),
ascii(' >>\nstream\n'),
stream.bytes,
ascii('\nendstream\nendobj\n'),
)
if (stream.name) {
parts.push(
ascii(`${n + 1} 0 obj\n<< /Type /Filespec /F (${stream.name})`),
ascii(` /EF << /F ${n} 0 R >> >>\nendobj\n`),
)
}
n += 2
}
parts.push(
ascii(`${n} 0 obj\n<< /Keywords (faunosteo-archive/1) >>\nendobj\n%%EOF\n`),
)
return Buffer.concat(parts)
}
const zeros = (bytes) => Buffer.alloc(bytes)
const deflate = (bytes) => deflateSync(bytes)
/** `{"version":3,"a":[1,1,…]}` of about `bytes` bytes. */
export function denseNumbers(bytes) {
const head = '{"version":3,"a":['
const count = Math.floor((bytes - head.length - 2) / 2)
return ascii(`${head}${'1,'.repeat(count - 1)}1]}`)
}
/** `{"version":3,"a":["","",…]}`: one string per three bytes. */
function denseStrings(bytes) {
const head = '{"version":3,"a":['
const count = Math.floor((bytes - head.length - 2) / 3)
return ascii(`${head}${'"",'.repeat(count - 1)}""]}`)
}
/** `{"version":3,"a":[[…[1,1,…]…]]}` nested to `depth`. */
function deepArrays(bytes, depth) {
const head = `{"version":3,"a":${'['.repeat(depth - 1)}`
const tail = `${']'.repeat(depth - 1)}}`
const count = Math.floor((bytes - head.length - tail.length) / 2)
return ascii(`${head}${'1,'.repeat(count - 1)}1${tail}`)
}
const named = (bytes, extra = {}) => ({
bytes,
name: 'osteo-report.json',
...extra,
})
/** The demo's envelope with `report` and a fresh snapshot. */
function envelopePdf(sheet, demoArchive, reportFile) {
const report = JSON.parse(readFileSync(join(FIXTURES_DIR, reportFile)))
const input = JSON.stringify({ report })
const snapshot = JSON.parse(sheet.call('archive.snapshot', input))
if (!snapshot.ok) throw new Error(`${reportFile}: ${snapshot.kind}`)
const envelope = { ...demoArchive, report, sheetSnapshot: snapshot.value }
return pdfWith([named(ascii(JSON.stringify(envelope, null, 2)))])
}
async function envelopeClasses(bundle, pkgDir) {
const sheet = await nodeSheet(bundle, pkgDir)
const demo = readFileSync(join(FIXTURES_DIR, 'pdf/r3/demo.fr.logos.pdf'))
const read = JSON.parse(sheet.import_pdf(new Uint8Array(demo)))
if (!read.ok) throw new Error(`demo archive: ${read.kind}`)
const archive = read.value.read.archive
const build = (file) => () => envelopePdf(sheet, archive, file)
return [
{ id: 'L-envelope', build: build('r4/reports/L.json') },
{ id: 'CAP-envelope', build: build('r4/reports/CAP.json') },
]
}
const DENSE = 16 * MiB - 64
const ATTACK_CLASSES = [
{
id: 'dense-numbers-16mib',
build: () => pdfWith([named(denseNumbers(DENSE))]),
},
{
id: 'dense-strings-16mib',
build: () => pdfWith([named(denseStrings(DENSE))]),
},
{
id: 'depth-64-16mib',
build: () => pdfWith([named(deepArrays(DENSE, 64))]),
},
{
id: 'dense-numbers-copy-16mib',
ext: 'json',
build: () => denseNumbers(DENSE),
},
{
id: 'inflation-16mib',
build: () => pdfWith([named(deflate(zeros(16 * MiB)), { flate: true })]),
},
{
id: 'bomb-16mib-plus-1',
build: () =>
pdfWith([named(deflate(zeros(16 * MiB + 1)), { flate: true })]),
},
{
id: 'bombs-32x17mib',
build: () => {
const bomb = { bytes: deflate(zeros(17 * MiB)), flate: true }
const bombs = Array.from({ length: 32 }, () => bomb)
return pdfWith([...bombs, named(ascii('{"version":3}'))])
},
},
{
id: 'file-50mib',
build: () => pdfWith([named(ascii('{"version":3}'))], 50 * MiB - 400),
},
]
/**
* Every class (or the `wanted` ids) built and written under `dir`, the
* envelopes through the shipped build in `pkgDir`; `remove()` deletes them.
*/
export async function writeHostileClasses({ bundle, dir, pkgDir, wanted }) {
const envelopes = await envelopeClasses(bundle, pkgDir)
const all = [...envelopes, ...ATTACK_CLASSES]
const classes = all.filter((c) => !wanted || wanted.includes(c.id))
const written = classes.map((c) => {
const path = join(dir, `${c.id}.${c.ext ?? 'pdf'}`)
const bytes = c.build()
writeFileSync(path, bytes)
return { id: c.id, path, bytes: bytes.length }
})
const remove = () => written.forEach((c) => unlinkSync(c.path))
return { classes: written, remove }
}