chore: establish YCode replication baseline and TODO

scripts/rea/css-capture-regression.mjs

@@ -0,0 +1,183 @@
+import assert from 'node:assert/strict'
+import { createHash } from 'node:crypto'
+import { mkdtemp, realpath, rm, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join, resolve } from 'node:path'
+import { fileURLToPath, pathToFileURL } from 'node:url'
+
+const projectRoot = resolve(fileURLToPath(new URL('../..', import.meta.url)))
+const runtimeModule = join(projectRoot, '.tmp/rea-css-runtime/dist/browser/CdpElectronStyles.js')
+const { captureElectronStyles, ingestElectronStyleEvent } = await import(pathToFileURL(runtimeModule))
+const authorizedFrameIds = new Set(['frame-main'])
+const noCompletenessWrites = { exclude() { assert.fail('CSS capture must not write into the old completeness sections') } }
+const limitations = []
+const styles = new Map()
+const addStyle = (styleSheetId, header) => ingestElectronStyleEvent({ method: 'CSS.styleSheetAdded', params: { header: { styleSheetId, ...header } } }, styles)
+const removeStyle = styleSheetId => ingestElectronStyleEvent({ method: 'CSS.styleSheetRemoved', params: { styleSheetId } }, styles)
+
+const fixtureRoot = await mkdtemp(join(tmpdir(), 'rea-css-fixtures-'))
+const cssFile = join(fixtureRoot, 'authorized.css')
+await writeFile(cssFile, 'body { color: red; }\n')
+const cssUrl = pathToFileURL(cssFile).href
+addStyle('file-style', { frameId: 'frame-main', sourceURL: cssUrl, origin: 'regular' })
+addStyle('inline-style', { frameId: 'frame-main', sourceURL: '', origin: 'regular', isInline: true })
+addStyle('constructed-style', { frameId: 'frame-main', sourceURL: '', origin: 'regular', isConstructed: true })
+addStyle('remote-style', { frameId: 'frame-main', sourceURL: 'https://example.invalid/site.css', origin: 'regular' })
+addStyle('other-frame-style', { frameId: 'frame-other', sourceURL: cssUrl, origin: 'regular' })
+addStyle('user-agent-style', { frameId: 'frame-main', sourceURL: cssUrl, origin: 'user-agent' })
+addStyle('injected-style', { frameId: 'frame-main', sourceURL: cssUrl, origin: 'injected' })
+addStyle('inspector-style', { frameId: 'frame-main', sourceURL: cssUrl, origin: 'inspector' })
+addStyle('unknown-origin-style', { frameId: 'frame-main', sourceURL: cssUrl, origin: 'unknown' })
+addStyle('unattributed-style', { frameId: 'frame-main', sourceURL: '', origin: 'regular' })
+addStyle('removed-style', { frameId: 'frame-main', sourceURL: cssUrl, origin: 'regular' })
+removeStyle('removed-style')
+assert.equal(styles.has('removed-style'), false)
+removeStyle('missing-style')
+
+const bodyTexts = new Map([
+  ['file-style', 'body { color: red; }\n'],
+  ['inline-style', '.inline { display: block; }'],
+  ['constructed-style', '.constructed { display: grid; }']
+])
+const calls = []
+const connection = {
+  async send(method, params, sessionId, signal) {
+    calls.push({ method, params, sessionId, signal })
+    if (method !== 'CSS.getStyleSheetText') throw new Error(`Unexpected command: ${method}`)
+    return { text: bodyTexts.get(params.styleSheetId) }
+  }
+}
+const included = await captureElectronStyles({
+  connection,
+  sessionId: 'private-session-1',
+  signal: undefined,
+  styles,
+  frameIds: authorizedFrameIds,
+  request: { include_style_sources: true },
+  completeness: noCompletenessWrites,
+  limitations
+})
+assert.equal(included.total, 10)
+assert.equal(included.excluded, 7)
+assert.equal(included.source_failures, 0)
+assert.equal(included.truncated, false)
+assert.equal(included.items.length, 3)
+assert.equal(calls.length, 3)
+assert.ok(calls.every(call => call.method === 'CSS.getStyleSheetText' && call.sessionId === 'private-session-1'))
+assert.deepEqual(included.limits, { max_sheets: 1024, max_sheet_bytes: 8 * 1024 * 1024, max_total_bytes: 64 * 1024 * 1024 })
+const fileItem = included.items.find(item => item.style_sheet_id === 'file-style')
+assert.equal(fileItem.file_path, await realpath(cssFile))
+assert.equal(fileItem.source.included, true)
+assert.equal(fileItem.source.artifact.media_type, 'text/css')
+assert.equal(fileItem.source.artifact.text, bodyTexts.get('file-style'))
+assert.equal(fileItem.source.artifact.bytes, Buffer.byteLength(bodyTexts.get('file-style'), 'utf8'))
+assert.equal(fileItem.source.artifact.sha256, createHash('sha256').update(bodyTexts.get('file-style')).digest('hex'))
+assert.match(fileItem.style_sheet_key, /^electron_stylesheet_[a-f0-9]{64}$/)
+assert.equal(included.items.find(item => item.style_sheet_id === 'inline-style').file_path, null)
+assert.equal(included.items.find(item => item.style_sheet_id === 'inline-style').is_inline, true)
+assert.equal(included.items.find(item => item.style_sheet_id === 'constructed-style').is_constructed, true)
+assert.doesNotMatch(JSON.stringify(included), /example\.invalid/)
+
+const unselectedCalls = []
+const unselected = await captureElectronStyles({
+  connection: { async send(...args) { unselectedCalls.push(args); throw new Error('CSS body must not be requested') } },
+  sessionId: 'private-session-1',
+  styles,
+  frameIds: authorizedFrameIds,
+  request: { include_style_sources: false },
+  completeness: noCompletenessWrites,
+  limitations: []
+})
+assert.equal(unselected.total, 10)
+assert.equal(unselected.items.length, 0)
+assert.equal(unselected.excluded, 7)
+assert.equal(unselectedCalls.length, 0)
+
+const failingStyles = new Map()
+addStyleTo(failingStyles, 'throwing-style', { frameId: 'frame-main', sourceURL: cssUrl, origin: 'regular' })
+addStyleTo(failingStyles, 'invalid-style', { frameId: 'frame-main', sourceURL: '', origin: 'regular', isInline: true })
+addStyleTo(failingStyles, 'surviving-style', { frameId: 'frame-main', sourceURL: '', origin: 'regular', isConstructed: true })
+const failures = await captureElectronStyles({
+  connection: { async send(_method, params) {
+    if (params.styleSheetId === 'throwing-style') throw new Error('stylesheet was removed')
+    if (params.styleSheetId === 'invalid-style') return { text: 3 }
+    return { text: '.still-captured{}' }
+  } },
+  sessionId: 'private-session-2',
+  styles: failingStyles,
+  frameIds: authorizedFrameIds,
+  request: { include_style_sources: true },
+  completeness: noCompletenessWrites,
+  limitations: []
+})
+assert.equal(failures.items.length, 3)
+assert.equal(failures.source_failures, 2)
+assert.equal(failures.truncated, false)
+assert.equal(failures.items.find(item => item.style_sheet_id === 'throwing-style').source.reason, 'CSS.getStyleSheetText failed')
+assert.equal(failures.items.find(item => item.style_sheet_id === 'invalid-style').source.reason, 'CSS.getStyleSheetText returned invalid text')
+assert.equal(failures.items.find(item => item.style_sheet_id === 'surviving-style').source.included, true)
+
+const oversizedStyles = new Map()
+addStyleTo(oversizedStyles, 'oversized', { frameId: 'frame-main', sourceURL: '', origin: 'regular', isInline: true })
+const oversized = await captureElectronStyles({
+  connection: { async send() { return { text: 'x'.repeat(8 * 1024 * 1024 + 1) } } },
+  sessionId: 'private-session-3',
+  styles: oversizedStyles,
+  frameIds: authorizedFrameIds,
+  request: { include_style_sources: true },
+  completeness: noCompletenessWrites,
+  limitations: []
+})
+assert.equal(oversized.source_failures, 1)
+assert.equal(oversized.truncated, true)
+assert.equal(oversized.items[0].source.included, false)
+assert.match(oversized.items[0].source.reason, /per-stylesheet byte limit/)
+
+const aggregateStyles = new Map()
+const aggregateText = 'a'.repeat(8 * 1024 * 1024)
+for (let index = 0; index < 8; index += 1) {
+  addStyleTo(aggregateStyles, `aggregate-${String(index).padStart(2, '0')}`, { frameId: 'frame-main', sourceURL: '', origin: 'regular', isInline: true })
+}
+addStyleTo(aggregateStyles, 'aggregate-overflow', { frameId: 'frame-main', sourceURL: '', origin: 'regular', isInline: true })
+const aggregate = await captureElectronStyles({
+  connection: { async send(_method, params) { return { text: params.styleSheetId === 'aggregate-overflow' ? 'overflow' : aggregateText } } },
+  sessionId: 'private-session-4',
+  styles: aggregateStyles,
+  frameIds: authorizedFrameIds,
+  request: { include_style_sources: true },
+  completeness: noCompletenessWrites,
+  limitations: []
+})
+assert.equal(aggregate.source_failures, 1)
+assert.equal(aggregate.truncated, true)
+assert.equal(aggregate.items.filter(item => item.source.included).length, 8)
+assert.equal(aggregate.items.find(item => item.style_sheet_id === 'aggregate-overflow').source.included, false)
+assert.match(aggregate.items.find(item => item.style_sheet_id === 'aggregate-overflow').source.reason, /aggregate stylesheet source byte limit/)
+
+const countLimitedStyles = new Map()
+for (let index = 0; index < 1025; index += 1) {
+  addStyleTo(countLimitedStyles, `sheet-${String(index).padStart(4, '0')}`, { frameId: 'frame-main', sourceURL: '', origin: 'regular', isConstructed: true })
+}
+let countRequests = 0
+const countLimited = await captureElectronStyles({
+  connection: { async send() { countRequests += 1; return { text: '' } } },
+  sessionId: 'private-session-5',
+  styles: countLimitedStyles,
+  frameIds: authorizedFrameIds,
+  request: { include_style_sources: true },
+  completeness: noCompletenessWrites,
+  limitations: []
+})
+assert.equal(countLimited.total, 1025)
+assert.equal(countLimited.items.length, 1025)
+assert.equal(countLimited.source_failures, 1)
+assert.equal(countLimited.truncated, true)
+assert.equal(countRequests, 1024)
+assert.equal(countLimited.items.filter(item => item.source.included).length, 1024)
+
+await rm(fixtureRoot, { recursive: true, force: true })
+console.log('REA Electron CSS capture regression checks passed')
+
+function addStyleTo(styleMap, styleSheetId, header) {
+  ingestElectronStyleEvent({ method: 'CSS.styleSheetAdded', params: { header: { styleSheetId, ...header } } }, styleMap)
+}