Skip to content

armgit / fx0

Public Imported from GitHub
0

A lightweight design agent built with libfx. Describe a page and an agent writes it as one HTML file.

TypeScript

Merge main and preserve preview load regression coverage

Esteban Suarez1bee5ecb90c1
diff --cc lib/design-artifact.ts
index ff366c4,789447a..f1cb5a1
--- a/lib/design-artifact.ts
+++ b/lib/design-artifact.ts
@@@ -137,12 -124,11 +138,15 @@@ frame.setAttribute('credentialless','')
let readySignals=0;
let consumedSignals=0;
let lastHeartbeat=Date.now();
+// A capture can hold off restores while the design is busy photographing itself (lib/design-capture.ts).
+let holdUntil=0;
+// The capture runtime, bound to each child's own token by the restore that builds that child.
+const captureRuntimeJs=${runtimeJs};
const safe=value=>JSON.stringify(value).replaceAll('<',String.fromCharCode(92)+'u003c');
- const painted=()=>parent.postMessage(preview?{type:'fx0-artifact-painted',protocol:1,sessionId:preview.sessionId,revision:current.revision,documentId,updateReady:hotReady}:{type:'fx0-artifact-painted'},location.origin);
+ // A child's rAF can run before this wrapper finishes loading. Revealing that
+ // still-loading wrapper exposes the app background (black in dark mode).
+ const painted=()=>{if(hasLoaded)parent.postMessage(preview?{type:'fx0-artifact-painted',protocol:1,sessionId:preview.sessionId,revision:current.revision,documentId,updateReady:hotReady}:{type:'fx0-artifact-painted'},location.origin);};
+ addEventListener('load',()=>{hasLoaded=true;if(hasPainted)painted();},{once:true});
const reply=(task,status,reason)=>parent.postMessage({type:'fx0-preview-result',protocol:1,sessionId:preview.sessionId,requestId:task.requestId,documentId:task.documentId,revision:task.payload.revision,status,...(reason?{reason}:{})},location.origin);
const finish=(task,status,reason)=>{if(pending!==task)return;pending=null;task.controller.abort();reply(task,status,reason);};
const restore=()=>{
diff --cc tests/helpers/preview-pane-fixture.mjs
index efe3809,0000000..0739371
mode 100644,000000..100644
--- a/tests/helpers/preview-pane-fixture.mjs
+++ b/tests/helpers/preview-pane-fixture.mjs
@@@ -1,124 -1,0 +1,125 @@@
+import assert from 'node:assert/strict'
+import { execFile } from 'node:child_process'
+import { readFile, realpath, writeFile } from 'node:fs/promises'
+import { registerHooks } from 'node:module'
+import { join } from 'node:path'
+import { fileURLToPath, pathToFileURL } from 'node:url'
+import { promisify } from 'node:util'
+
+// Shared by preview-update.browser.mjs and the live browser runner. This module registers no tests.
+
+// Restore the old JSON-first behavior only in a temporary baseline compile. The candidate
+// runs the current production component unchanged; no benchmark switch enters production.
+export const LEGACY_BASELINE = {
+ marker: 'fx0-perf-baseline-json-first',
+ from: 'if (!shown) {\n loadFull(desired);\n return;\n }',
+ to: '/* fx0-perf-baseline-json-first */',
+}
+
+// Observe real window messages without intercepting any production listener or send.
+export const OBSERVER = `
+window.observed = { paints: [], results: [], boots: [], reports: [], errors: [], frameErrors: [] }
+addEventListener('message', event => {
+ const frames = [...document.querySelectorAll('#active, #preview-pane iframe')], data = event.data
+ if (!data || typeof data !== 'object') return
+ const wrapper = frames.find(frame => event.source === frame.contentWindow)
+ if (wrapper && event.origin === location.origin) {
+ const entry = { ...data, mountUrl: wrapper.getAttribute('src'), observedAt: performance.now() }
+ if (data.type === 'fx0-artifact-painted') observed.paints.push(entry)
+ if (data.type === 'fx0-preview-result') observed.results.push(entry)
+ if (data.type === 'fx0-preview-error') observed.frameErrors.push(entry)
+ }
+ const frame = frames.find(frame => event.source === frame.contentWindow.frames[0])
+ if (frame && data.fixture === 'preview-update') {
+ const entry = { ...data, mountUrl: frame.getAttribute('src') }
+ if (data.kind === 'boot') observed.boots.push(entry)
+ if (data.kind === 'state') { observed.reports.push(entry); if (observed.reports.length > 30) observed.reports.shift() }
+ if (data.kind === 'error') observed.errors.push(data.error)
+ }
+})`
+
+export async function buildPaneFixture(directory, experiment = null, { sessionId = 'preview-browser-session', initialRevision = 101 } = {}) {
+ assert.ok(Number.isSafeInteger(initialRevision) && initialRevision >= 0, 'initialRevision is a non-negative integer')
+ const output = await realpath(directory), root = fileURLToPath(new URL('../../', import.meta.url))
+ // Same narrow compile as html-ui.test.mjs, using this test's Node 24 executable.
+ await promisify(execFile)(process.execPath, [join(root, 'node_modules/typescript/bin/tsc'),
+ '--ignoreConfig', '--outDir', join(output, 'compiled'), '--strict', '--types', 'node',
+ '--jsx', 'react-jsx', '--target', 'esnext', '--module', 'esnext',
+ '--moduleResolution', 'bundler', '--skipLibCheck', '--esModuleInterop', 'components/preview-pane.tsx',
+ ], { cwd: root, maxBuffer: 4 * 1024 * 1024 })
+ if (experiment) {
+ // Perf-only: remove the direct-load guard in the temporary legacy baseline, never in production.
+ const file = join(output, 'compiled/components/preview-pane.js'), source = await readFile(file, 'utf8')
+ assert.equal(source.split(experiment.from).length - 1, 1, 'the baseline matches exactly one compiled guard')
+ await writeFile(file, source.replace(experiment.from, experiment.to))
+ assert.equal((await readFile(file, 'utf8')).split(experiment.marker).length - 1, 1, 'the baseline marker is unique')
+ }
+ await writeFile(join(output, 'package.json'), '{"type":"module"}')
+ // These controls change only the real component's props. No replacement hooks,
+ // updater, transport or slot coordinator is bundled into the fixture.
+ await writeFile(join(output, 'pane-fixture.js'), `
+import { createElement, useEffect, useState } from 'react'
+import PreviewPane from './compiled/components/preview-pane.js'
+import { signalAuthRequired } from './compiled/components/auth-ui.js'
+import { captureFrame } from './compiled/components/design-capture.js'
+export function Fixture() {
+ const [revision, setRevision] = useState(${JSON.stringify(initialRevision)}), [viewing, setViewing] = useState(null)
+ const [sessionId, setSession] = useState(${JSON.stringify(sessionId)}), [draft, setDraft] = useState(null)
+ const [accessAllowed, setAccessAllowed] = useState(true), [capture, setCapture] = useState(null)
+ useEffect(() => {
+ window.captureResults = []
+ window.authErrors = []
+ Object.assign(window, { setRevision, setViewing, setSession, setDraft, setAccessAllowed, setCapture, captureFrame, closeAuthGate: signalAuthRequired, fixtureReady: true })
+ const revoke = event => { window.authErrors.push(event.detail); setAccessAllowed(false); setRevision(0) }
+ window.addEventListener('fx0:auth-required', revoke)
+ return () => window.removeEventListener('fx0:auth-required', revoke)
+ }, [])
+ return createElement(PreviewPane, { source: { kind: 'design', sessionId, revision }, viewing, draft, accessAllowed, intro: false, onClose: () => setRevision(0),
+ capture, onCaptureDone: (cid, answered) => { window.captureResults.push({ cid, answered, observedAt: performance.now() }); setCapture(current => current?.cid === cid ? null : current) },
+ })
+}`)
+ await writeFile(join(output, 'pane-entry.js'), `
+import { createElement } from 'react'
+import { hydrateRoot } from 'react-dom/client'
+import { Fixture } from './pane-fixture.js'
+const root = hydrateRoot(document.getElementById('app'), createElement(Fixture), { onRecoverableError: error => observed.errors.push(error.message) })
+window.unmountFixture = () => root.unmount()
+`)
+ const { default: bundledWebpack } = await import('../../node_modules/next/dist/compiled/webpack/webpack.js')
+ const compiler = bundledWebpack.webpack({
+ // Next's packaged webpack references a terser entry absent in this install.
+ // Production React is still selected; minification is not under test here.
+ mode: 'production', optimization: { minimize: false }, target: 'web', entry: join(output, 'pane-entry.js'),
+ output: { path: join(output, 'browser'), filename: 'bundle.js' },
+ module: { rules: [{ test: /\.js$/, resolve: { fullySpecified: false } }] },
+ resolve: { modules: [join(root, 'node_modules')], extensions: ['.js'], extensionAlias: { '.ts': ['.js'] } },
+ })
+ try {
+ const stats = await promisify(compiler.run.bind(compiler))()
+ assert.equal(stats.hasErrors(), false, stats.toString({ all: false, errors: true }))
+ } finally { await promisify(compiler.close.bind(compiler))() }
+
+ const outputUrl = pathToFileURL(`${output}/`).href, projectUrl = new URL('../../package.json', import.meta.url).href
+ const hooks = registerHooks({ resolve(specifier, context, nextResolve) {
+ if (!context.parentURL?.startsWith(outputUrl)) return nextResolve(specifier, context)
+ if (specifier.startsWith('.')) return nextResolve(/\.js$/.test(specifier) ? specifier : `${specifier.replace(/\.ts$/, '')}.js`, context)
+ return nextResolve(specifier, { ...context, parentURL: projectUrl })
+ } })
+ let markup
+ try {
+ const [{ Fixture }, { createElement }, { renderToString }] = await Promise.all([
+ import(pathToFileURL(join(output, 'pane-fixture.js')).href), import('react'), import('react-dom/server'),
+ ])
+ markup = renderToString(createElement(Fixture))
+ } finally { hooks.deregister() }
+ return {
+ bundle: await readFile(join(output, 'browser/bundle.js')),
+ html: `<!doctype html><html><head><meta charset="utf-8"><title>Real PreviewPane</title><style>
+html,body,#app{margin:0;height:100%}#preview-pane{height:100%;display:flex;flex-direction:column}
+#preview-pane>div:last-of-type{position:relative;flex:1;min-height:720px}
+#preview-pane iframe{position:absolute;inset:0;width:1000px;height:720px;border:0}
+#preview-pane iframe[aria-hidden=true]{z-index:0;pointer-events:none}#preview-pane iframe:not([aria-hidden=true]){z-index:1}
++.relative{position:relative}.absolute{position:absolute}.inset-0{inset:0}.flex{display:flex}.flex-1{flex:1}.min-h-0{min-height:0}.z-20{z-index:20}.opacity-0{opacity:0}.bg-background{background:white}
+</style></head><body><script>${OBSERVER}</script><div id="app">${markup}</div><script defer src="/bundle.js"></script></body></html>`,
+ }
+}
diff --cc tests/preview-update.browser.mjs
index 6d35252,2aff802..c8a3208
--- a/tests/preview-update.browser.mjs
+++ b/tests/preview-update.browser.mjs
@@@ -1214,3 -1025,111 +1214,111 @@@ test('in Chrome, the production previe
await rm(dir, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 })
}
})
+
+ // The real first-generation capture exposed the draft -> published handoff before
+ // the wrapper's load event: 8 black frames at 120 Hz. Hold the wrapper response open
+ // after its scripts run, so its real child paints before the wrapper finishes loading.
+ // No synthetic paint messages or replacement slot coordinator participate.
+ test('first publish waits for wrapper load after child paint', { timeout: 60_000 }, async t => {
+ assert.ok(existsSync(CHROME), `Chrome not found at ${CHROME}; set CHROME_PATH`)
+ const dir = await mkdtemp(join(tmpdir(), 'fx0-first-publish-'))
+ const errors = []
+ const held = []
+ let chrome, cdp, chromeError = ''
- const fixture = await buildPaneFixture(dir, 0)
++ const fixture = await buildPaneFixture(dir, null, { initialRevision: 0 })
+ const house = await readFile(new URL('./fixtures/simple-house.html', import.meta.url), 'utf8')
+ const candidate = payload(1, house)
+ const server = http.createServer((request, response) => {
+ const url = new URL(request.url, 'http://fixture')
+ if (url.pathname === '/') return response.writeHead(200, { 'content-type': 'text/html' }).end(fixture.html.replace('</style>', ':root{color-scheme:light dark}body,.bg-background{background:light-dark(white,black)}</style>'))
+ if (url.pathname === '/bundle.js') return response.writeHead(200, { 'content-type': 'text/javascript' }).end(fixture.bundle)
+ if (url.pathname === '/api/artifact-frame') {
+ if (url.searchParams.get('format') === 'json') return response.writeHead(200, { 'content-type': 'application/json' }).end(JSON.stringify(candidate))
+ const prepared = prepareDesignArtifactHtml(candidate.renderHtml, DESIGN_ARTIFACT_EMBEDDED_CSP, TOKEN)
+ // Observe the real child's message without forwarding, delaying or replacing it.
+ const html = designFrameHtml(prepared, TOKEN, [], candidate).replace('<script>', `<script>
+ window.childPainted = false;
+ addEventListener('message', event => {
+ if (event.source === document.querySelector('#frame-root iframe')?.contentWindow && event.data?.type === 'painted') window.childPainted = true;
+ });`)
+ response.writeHead(200, { 'content-type': 'text/html; charset=utf-8', 'content-security-policy': designFrameCsp() })
+ response.write(html)
+ held.push(response)
+ return
+ }
+ response.writeHead(404).end()
+ })
+ try {
+ await new Promise((resolve, reject) => { server.once('error', reject); server.listen(0, '127.0.0.1', resolve) })
+ chrome = spawn(CHROME, [
+ '--headless=new', '--disable-gpu', '--no-first-run', '--no-default-browser-check', '--no-proxy-server',
+ '--disable-background-networking', '--disable-component-update', '--disable-sync', '--disable-default-apps',
+ '--disable-background-timer-throttling', '--disable-renderer-backgrounding', '--disable-backgrounding-occluded-windows',
+ '--host-resolver-rules=MAP * ~NOTFOUND, EXCLUDE 127.0.0.1',
+ '--remote-debugging-address=127.0.0.1', '--remote-debugging-port=0', `--user-data-dir=${join(dir, 'profile')}`, 'about:blank',
+ ], { stdio: ['ignore', 'ignore', 'pipe'] })
+ let spawnError
+ chrome.on('error', error => { spawnError = error })
+ chrome.stderr.on('data', data => { chromeError = (chromeError + data).slice(-16_384) })
+ const port = await until(async () => {
+ if (spawnError) throw spawnError
+ assert.equal(chrome.exitCode, null, chromeError)
+ try { return (await readFile(join(dir, 'profile', 'DevToolsActivePort'), 'utf8')).split('\n')[0] }
+ catch (error) { if (error.code !== 'ENOENT') throw error }
+ }, 'Chrome debugging port')
+ const targets = await (await fetch(`http://127.0.0.1:${port}/json/list`, { signal: AbortSignal.timeout(8000) })).json()
+ cdp = await connectCdp(targets.find(target => target.type === 'page').webSocketDebuggerUrl, errors)
+ await cdp.call('Emulation.setDeviceMetricsOverride', { width: 1000, height: 720, deviceScaleFactor: 1, mobile: false })
+ const origin = `http://127.0.0.1:${server.address().port}`
+ for (const scheme of ['light', 'dark']) await t.test(scheme, async () => {
+ await cdp.call('Emulation.setEmulatedMedia', { features: [{ name: 'prefers-color-scheme', value: scheme }] })
+ await cdp.call('Page.navigate', { url: `${origin}/?scheme=${scheme}` })
+ await until(() => cdp.evaluate('window.fixtureReady === true'), 'first-generation fixture')
+ try {
+ await cdp.evaluate(`setDraft(${JSON.stringify(house)})`)
+ await until(() => cdp.evaluate(`(() => {
+ const frame = document.querySelector('iframe[title="Design preview while generating"]');
+ return !!frame?.contentDocument?.getElementById('door') && getComputedStyle(frame).opacity === '1';
+ })()`), 'the real house draft is visible')
+ await cdp.evaluate(`window.originalDraft = document.querySelector('iframe[title="Design preview while generating"]'); setRevision(1); setDraft(null)`)
+ await until(() => cdp.evaluate(`!!document.querySelector('iframe[src]')?.contentWindow?.childPainted`), 'the real child paints while its wrapper response is still open')
+ // Let any erroneously forwarded paint reach React before checking its layers.
+ await cdp.evaluate('new Promise(resolve => requestAnimationFrame(() => requestAnimationFrame(resolve)))')
+ const beforeLoad = await cdp.evaluate(`(() => {
+ const wrapper = document.querySelector('iframe[src]');
+ return { readyState: wrapper.contentDocument.readyState, paints: observed.paints.length,
+ draftRetained: originalDraft.isConnected, draftOpacity: getComputedStyle(originalDraft).opacity,
+ wrapperOpacity: getComputedStyle(wrapper).opacity, hidden: wrapper.getAttribute('aria-hidden') };
+ })()`)
+ t.diagnostic(`${scheme} before wrapper load: ${JSON.stringify(beforeLoad)}`)
+ assert.notEqual(beforeLoad.readyState, 'complete', 'the HTTP fixture really delays wrapper load')
+ assert.equal(beforeLoad.paints, 0, 'child paint cannot retire the draft before the wrapper loads')
+ assert.equal(beforeLoad.draftRetained, true)
+ assert.equal(beforeLoad.draftOpacity, '1')
+ assert.equal(beforeLoad.wrapperOpacity, '0')
+ assert.equal(beforeLoad.hidden, 'true')
+ for (const response of held.splice(0)) response.end()
+ await until(() => cdp.evaluate(`observed.paints.length > 0 && !originalDraft.isConnected`), 'wrapper load releases the retained child paint and retires the draft')
+ assert.equal(await cdp.evaluate(`document.querySelector('iframe[title="Design artifact preview"]').contentDocument.readyState`), 'complete')
+ assert.equal(await cdp.evaluate(`document.querySelectorAll('#preview-pane iframe').length`), 1, 'the handoff leaves only the interactive frame')
+ assert.deepEqual(await cdp.evaluate('observed.errors'), [])
+ } finally {
+ for (const response of held.splice(0)) response.end()
+ }
+ })
+ assert.deepEqual(errors, [], 'no browser execution errors')
+ } finally {
+ if (cdp) await cdp.close()
+ if (chrome && chrome.exitCode === null && chrome.signalCode === null) {
+ const exited = new Promise(resolve => chrome.once('exit', resolve))
+ chrome.kill('SIGTERM')
+ await Promise.race([exited, sleep(2000, undefined, { ref: false })])
+ if (chrome.exitCode === null && chrome.signalCode === null) { chrome.kill('SIGKILL'); await exited }
+ }
+ chrome?.stderr.destroy()
+ server.closeAllConnections()
+ await new Promise(resolve => server.close(resolve))
+ for (const response of held) response.destroy()
+ await rm(dir, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 })
+ }
+ })