Unverified Commit d2313e4c authored by Will Binns-Smith's avatar Will Binns-Smith Committed by GitHub

[lts-active] Reload on missed Turbopack startup CSS updates (#100619)

Backports [Reload on missed Turbopack startup CSS updates
(#99963)](https://github.com/vercel/next.js/pull/99963) to
`releases/lts/active`.

<!-- NEXT_JS_LLM -->
parent 2b29bc84
...@@ -201,6 +201,7 @@ export function createProcessTurbopackMessage( ...@@ -201,6 +201,7 @@ export function createProcessTurbopackMessage(
'@vercel/turbopack-ecmascript-runtime/browser/dev/hmr-client/hmr-client.ts' '@vercel/turbopack-ecmascript-runtime/browser/dev/hmr-client/hmr-client.ts'
).then(({ connect }) => { ).then(({ connect }) => {
connect({ connect({
initialHmrVersion: self.__nextHmrInitialVersion,
addMessageListener(cb: (msg: TurbopackMessageSentToBrowser) => void) { addMessageListener(cb: (msg: TurbopackMessageSentToBrowser) => void) {
callback = cb callback = cb
......
...@@ -43,6 +43,7 @@ initialize({ ...@@ -43,6 +43,7 @@ initialize({
} }
connect({ connect({
initialHmrVersion: self.__nextHmrInitialVersion,
addMessageListener(cb: (message: TurbopackMessageSentToBrowser) => void) { addMessageListener(cb: (message: TurbopackMessageSentToBrowser) => void) {
devClient.addTurbopackMessageListener(cb) devClient.addTurbopackMessageListener(cb)
}, },
......
...@@ -34,11 +34,10 @@ export function pageBootstrap(assetPrefix: string) { ...@@ -34,11 +34,10 @@ export function pageBootstrap(assetPrefix: string) {
error.stack = errorObject.stack error.stack = errorObject.stack
throw error throw error
} }
case HMR_MESSAGE_SENT_TO_BROWSER.RELOAD_PAGE: { case HMR_MESSAGE_SENT_TO_BROWSER.RELOAD_PAGE:
reloading = true // Already handled by hot-middleware-client's guarded listener, even
window.location.reload() // before hydration. A second reload here can restart that navigation.
break break
}
case HMR_MESSAGE_SENT_TO_BROWSER.DEV_PAGES_MANIFEST_UPDATE: { case HMR_MESSAGE_SENT_TO_BROWSER.DEV_PAGES_MANIFEST_UPDATE: {
fetch( fetch(
`${assetPrefix}/_next/static/development/_devPagesManifest.json` `${assetPrefix}/_next/static/development/_devPagesManifest.json`
......
...@@ -910,6 +910,7 @@ export class NextScript extends React.Component<OriginProps> { ...@@ -910,6 +910,7 @@ export class NextScript extends React.Component<OriginProps> {
assetQueryString, assetQueryString,
disableOptimizedLoading, disableOptimizedLoading,
crossOrigin, crossOrigin,
initialHmrVersion,
} = this.context } = this.context
const disableRuntimeJS = unstable_runtimeJS === false const disableRuntimeJS = unstable_runtimeJS === false
...@@ -929,6 +930,18 @@ export class NextScript extends React.Component<OriginProps> { ...@@ -929,6 +930,18 @@ export class NextScript extends React.Component<OriginProps> {
return ( return (
<> <>
{!disableRuntimeJS &&
this.context.isDevelopment &&
// Only turbopack configures this.
initialHmrVersion !== undefined ? (
<script
nonce={this.props.nonce || this.context.nonce}
crossOrigin={this.props.crossOrigin || crossOrigin}
dangerouslySetInnerHTML={{
__html: `var __nextHmrInitialVersion=${htmlEscapeJsonString(JSON.stringify(initialHmrVersion))};`,
}}
/>
) : null}
{!disableRuntimeJS && buildManifest.devFiles {!disableRuntimeJS && buildManifest.devFiles
? buildManifest.devFiles.map((file: string) => ( ? buildManifest.devFiles.map((file: string) => (
<script <script
......
...@@ -298,6 +298,7 @@ import { isReactLargeShellError } from './react-large-shell-error' ...@@ -298,6 +298,7 @@ import { isReactLargeShellError } from './react-large-shell-error'
import type { GlobalErrorComponent } from '../../client/components/builtin/global-error' import type { GlobalErrorComponent } from '../../client/components/builtin/global-error'
import { normalizeConventionFilePath } from './segment-explorer-path' import { normalizeConventionFilePath } from './segment-explorer-path'
import { getRequestMeta } from '../request-meta' import { getRequestMeta } from '../request-meta'
import { htmlEscapeJsonString } from '../../shared/lib/htmlescape'
import { import {
getDynamicParam, getDynamicParam,
interpolateParallelRouteParams, interpolateParallelRouteParams,
...@@ -426,6 +427,7 @@ export type AppRenderContext = { ...@@ -426,6 +427,7 @@ export type AppRenderContext = {
assetPrefix: string assetPrefix: string
isNotFoundPath: boolean isNotFoundPath: boolean
nonce: string | undefined nonce: string | undefined
initialHmrVersion?: string
res: BaseNextResponse res: BaseNextResponse
/** /**
* For now, the implicit tags are common for the whole route. If we ever start * For now, the implicit tags are common for the whole route. If we ever start
...@@ -2746,6 +2748,7 @@ async function prepareAppPageRender( ...@@ -2746,6 +2748,7 @@ async function prepareAppPageRender(
) )
const ctx: AppRenderContext = { const ctx: AppRenderContext = {
initialHmrVersion: getRequestMeta(req, 'initialHmrVersion'),
componentMod: ComponentMod, componentMod: ComponentMod,
url, url,
renderOpts, renderOpts,
...@@ -3645,6 +3648,13 @@ async function renderToStream( ...@@ -3645,6 +3648,13 @@ async function renderToStream(
bootstrapScriptContent = `self.__next_r=${JSON.stringify( bootstrapScriptContent = `self.__next_r=${JSON.stringify(
requestId ?? crypto.randomUUID() requestId ?? crypto.randomUUID()
)}` )}`
const initialHmrVersion = ctx.initialHmrVersion
if (initialHmrVersion !== undefined) {
// Only the dev server with Turbopack HMR supplies this captured baseline.
bootstrapScriptContent += `;var __nextHmrInitialVersion=${htmlEscapeJsonString(
JSON.stringify(initialHmrVersion)
)};`
}
} else if ( } else if (
buildManifest.pagesChunkGroupBootstrapParams && buildManifest.pagesChunkGroupBootstrapParams &&
buildManifest.chunkLoadingGlobal buildManifest.chunkLoadingGlobal
......
...@@ -450,6 +450,11 @@ export default abstract class Server< ...@@ -450,6 +450,11 @@ export default abstract class Server<
return undefined return undefined
} }
/** Available only on the dev server with Turbopack HMR. */
protected getClientHmrVersion(): string | undefined {
return undefined
}
protected abstract loadEnvConfig(params: { protected abstract loadEnvConfig(params: {
dev: boolean dev: boolean
forceReload: boolean forceReload: boolean
...@@ -2444,6 +2449,12 @@ export default abstract class Server< ...@@ -2444,6 +2449,12 @@ export default abstract class Server<
}: RequestContext<ServerRequest, ServerResponse>, }: RequestContext<ServerRequest, ServerResponse>,
{ components, query }: FindComponentsResult { components, query }: FindComponentsResult
): Promise<ResponsePayload | null> { ): Promise<ResponsePayload | null> {
if (this.dev && getRequestMeta(req, 'initialHmrVersion') === undefined) {
// Snapshot before rendering/streaming HTML. Reading the live version at
// script insertion or socket connection can hide an intervening CSS edit.
addRequestMeta(req, 'initialHmrVersion', this.getClientHmrVersion())
}
if (pathname === UNDERSCORE_NOT_FOUND_ROUTE) { if (pathname === UNDERSCORE_NOT_FOUND_ROUTE) {
pathname = '/404' pathname = '/404'
} }
......
...@@ -999,14 +999,22 @@ export async function createHotReloaderTurbopack( ...@@ -999,14 +999,22 @@ export async function createHotReloaderTurbopack(
} }
const sendEnqueuedMessagesDebounce = debounce(sendEnqueuedMessages, 2) const sendEnqueuedMessagesDebounce = debounce(sendEnqueuedMessages, 2)
function markClientHmrChange() {
if (!clientHmrEventHappened) {
clientHmrVersion++
clientHmrEventHappened = true
}
}
const sendHmr: SendHmr = (id: string, message: HmrMessageSentToBrowser) => { const sendHmr: SendHmr = (id: string, message: HmrMessageSentToBrowser) => {
pendingBuilding.flush() pendingBuilding.flush()
if (message.type === HMR_MESSAGE_SENT_TO_BROWSER.CLIENT_CHANGES) {
// Pages already observes client output before a browser subscribes.
markClientHmrChange()
}
if (message.type === HMR_MESSAGE_SENT_TO_BROWSER.SERVER_COMPONENT_CHANGES) { if (message.type === HMR_MESSAGE_SENT_TO_BROWSER.SERVER_COMPONENT_CHANGES) {
if (!clientHmrEventHappened) { markClientHmrChange()
clientHmrVersion++
clientHmrEventHappened = true
}
message.hmrVersion = String(clientHmrVersion) message.hmrVersion = String(clientHmrVersion)
} }
...@@ -1036,14 +1044,58 @@ export async function createHotReloaderTurbopack( ...@@ -1036,14 +1044,58 @@ export async function createHotReloaderTurbopack(
clientStates.get(client)?.turbopackUpdates.push(payload) clientStates.get(client)?.turbopackUpdates.push(payload)
} }
if (!clientHmrEventHappened) { markClientHmrChange()
clientHmrVersion++
clientHmrEventHappened = true
}
hmrEventHappened = true hmrEventHappened = true
sendEnqueuedMessagesDebounce() sendEnqueuedMessagesDebounce()
} }
async function subscribeToClientHmrChanges(
key: EntryKey,
endpoint: Endpoint
) {
const existing = changeSubscriptions.get(key)
if (existing) {
// Its owner handles setup failures using the existing HMR error path.
await existing.catch(() => {})
return
}
const changedPromise = endpoint.clientChanged()
changeSubscriptions.set(key, changedPromise)
let changed: Awaited<typeof changedPromise>
try {
// Resolves after the native baseline is established, not when consumption
// ends. HTML must not be served while listening is still being set up.
changed = await changedPromise
} catch (error) {
changeSubscriptions.delete(key)
sendHmr(key, {
type: HMR_MESSAGE_SENT_TO_BROWSER.RELOAD_PAGE,
data: `error in ${key} client subscription: ${error}`,
})
return
}
void (async () => {
try {
for await (const _change of changed) {
// No browser message or server cache invalidation: connected clients
// still receive ordinary CSS/JS HMR through their chunk subscriptions.
markClientHmrChange()
}
} catch (error) {
sendHmr(key, {
type: HMR_MESSAGE_SENT_TO_BROWSER.RELOAD_PAGE,
data: `error in ${key} client subscription: ${error}`,
})
} finally {
if (changeSubscriptions.get(key) === changedPromise) {
changeSubscriptions.delete(key)
}
}
})()
}
async function subscribeToClientChanges( async function subscribeToClientChanges(
key: EntryKey, key: EntryKey,
includeIssues: boolean, includeIssues: boolean,
...@@ -1826,6 +1878,10 @@ export async function createHotReloaderTurbopack( ...@@ -1826,6 +1878,10 @@ export async function createHotReloaderTurbopack(
} }
}, },
getClientHmrVersion() {
return String(clientHmrVersion)
},
getServerComponentsHmrRefreshHash() { getServerComponentsHmrRefreshHash() {
// Only a change subscription advances the refresh version, so reloads // Only a change subscription advances the refresh version, so reloads
// and config invalidations leave cache keys stable until a real edit. // and config invalidations leave cache keys stable until a real edit.
...@@ -2158,6 +2214,9 @@ export async function createHotReloaderTurbopack( ...@@ -2158,6 +2214,9 @@ export async function createHotReloaderTurbopack(
subscribeToChanges: subscribeToChanges subscribeToChanges: subscribeToChanges
? subscribeToClientChanges ? subscribeToClientChanges
: ((async () => {}) as StartChangeSubscription), : ((async () => {}) as StartChangeSubscription),
subscribeToClientHmrChanges: subscribeToChanges
? subscribeToClientHmrChanges
: undefined,
handleServerComponentChanges, handleServerComponentChanges,
handleWrittenEndpoint: (id, result, forceDeleteCache) => { handleWrittenEndpoint: (id, result, forceDeleteCache) => {
currentWrittenEntrypoints.set(id, result.value) currentWrittenEntrypoints.set(id, result.value)
......
...@@ -348,6 +348,8 @@ export interface NextJsHotReloaderInterface { ...@@ -348,6 +348,8 @@ export interface NextJsHotReloaderInterface {
* them for code that changed while the server was down. * them for code that changed while the server was down.
*/ */
getServerComponentsHmrRefreshHash(): string getServerComponentsHmrRefreshHash(): string
/** The client HMR baseline, available only with Turbopack HMR. */
getClientHmrVersion?(): string
setCacheStatus(status: ServerCacheStatus, htmlRequestId: string): void setCacheStatus(status: ServerCacheStatus, htmlRequestId: string): void
setReactDebugChannel( setReactDebugChannel(
debugChannel: ReactDebugChannelForBrowser, debugChannel: ReactDebugChannelForBrowser,
......
...@@ -258,6 +258,10 @@ export default class DevServer extends Server { ...@@ -258,6 +258,10 @@ export default class DevServer extends Server {
return this.serverComponentsHmrCache return this.serverComponentsHmrCache
} }
protected override getClientHmrVersion(): string | undefined {
return this.bundlerService.getClientHmrVersion()
}
protected override getServerComponentsHmrRefreshHash(): string | undefined { protected override getServerComponentsHmrRefreshHash(): string | undefined {
return this.bundlerService.getServerComponentsHmrRefreshHash() return this.bundlerService.getServerComponentsHmrRefreshHash()
} }
......
...@@ -141,6 +141,10 @@ export type ClientStateMap = WeakMap<ws, ClientState> ...@@ -141,6 +141,10 @@ export type ClientStateMap = WeakMap<ws, ClientState>
type HandleRouteTypeHooks = { type HandleRouteTypeHooks = {
handleWrittenEndpoint: HandleWrittenEndpoint handleWrittenEndpoint: HandleWrittenEndpoint
subscribeToChanges: StartChangeSubscription subscribeToChanges: StartChangeSubscription
subscribeToClientHmrChanges?: (
key: EntryKey,
endpoint: Endpoint
) => Promise<void>
handleServerComponentChanges?: () => void handleServerComponentChanges?: () => void
} }
...@@ -191,6 +195,14 @@ export async function handleRouteType({ ...@@ -191,6 +195,14 @@ export async function handleRouteType({
const key = getEntryKey('pages', 'server', '_app') const key = getEntryKey('pages', 'server', '_app')
const writtenEndpoint = await entrypoints.global.app.writeToDisk() const writtenEndpoint = await entrypoints.global.app.writeToDisk()
if (dev) {
// Page client chunks exclude modules already provided by _app, so
// its global CSS needs its own baseline before we serve the HTML.
await hooks?.subscribeToClientHmrChanges?.(
getEntryKey('pages', 'client', '_app'),
entrypoints.global.app
)
}
documentOrAppChanged ||= documentOrAppChanged ||=
hooks?.handleWrittenEndpoint(key, writtenEndpoint, false) ?? false hooks?.handleWrittenEndpoint(key, writtenEndpoint, false) ?? false
processIssues( processIssues(
...@@ -294,6 +306,12 @@ export async function handleRouteType({ ...@@ -294,6 +306,12 @@ export async function handleRouteType({
} }
} }
) )
// Reuse the existing Pages client observer, but wait for its baseline
// before HTML can be delivered to an initially unsubscribed browser.
await hooks?.subscribeToClientHmrChanges?.(
clientKey,
route.htmlEndpoint
)
if (entrypoints.global.document) { if (entrypoints.global.document) {
hooks?.subscribeToChanges( hooks?.subscribeToChanges(
getEntryKey('pages', 'server', '_document'), getEntryKey('pages', 'server', '_document'),
...@@ -351,6 +369,13 @@ export async function handleRouteType({ ...@@ -351,6 +369,13 @@ export async function handleRouteType({
hooks?.handleWrittenEndpoint(key, writtenEndpoint, false) hooks?.handleWrittenEndpoint(key, writtenEndpoint, false)
if (dev) { if (dev) {
// Establish client-output observation before serving HTML. Unlike the
// RSC/server observer, this includes CSS edits made before the browser
// has installed its first chunk-list subscription.
await hooks?.subscribeToClientHmrChanges?.(
getEntryKey('app', 'client', page),
route.htmlEndpoint
)
// TODO subscriptions should only be caused by the WebSocket connections // TODO subscriptions should only be caused by the WebSocket connections
// otherwise we don't known when to unsubscribe and this leaking // otherwise we don't known when to unsubscribe and this leaking
hooks?.subscribeToChanges( hooks?.subscribeToChanges(
......
...@@ -70,6 +70,10 @@ export class DevBundlerService { ...@@ -70,6 +70,10 @@ export class DevBundlerService {
) )
} }
public getClientHmrVersion(): string | undefined {
return this.bundler.hotReloader.getClientHmrVersion?.()
}
public getServerComponentsHmrRefreshHash(): string | undefined { public getServerComponentsHmrRefreshHash(): string | undefined {
return this.bundler.hotReloader.getServerComponentsHmrRefreshHash() return this.bundler.hotReloader.getServerComponentsHmrRefreshHash()
} }
......
...@@ -1487,6 +1487,9 @@ export async function renderToHTMLImpl( ...@@ -1487,6 +1487,9 @@ export async function renderToHTMLImpl(
locales, locales,
} = renderOpts } = renderOpts
const htmlProps: HtmlProps = { const htmlProps: HtmlProps = {
initialHmrVersion: process.env.__NEXT_DEV_SERVER
? getRequestMeta(req, 'initialHmrVersion')
: undefined,
__NEXT_DATA__: { __NEXT_DATA__: {
props, // The result of getInitialProps props, // The result of getInitialProps
page: pathname, // The rendered page page: pathname, // The rendered page
......
...@@ -116,6 +116,9 @@ export interface RequestMeta { ...@@ -116,6 +116,9 @@ export interface RequestMeta {
*/ */
hmrRefreshHash?: string hmrRefreshHash?: string
/** Client HMR version captured before rendering dev-server HTML. */
initialHmrVersion?: string
/** /**
* Equals the segment path that was used for the prefetch RSC request. * Equals the segment path that was used for the prefetch RSC request.
*/ */
......
...@@ -9,6 +9,7 @@ import { createContext, useContext, type JSX } from 'react' ...@@ -9,6 +9,7 @@ import { createContext, useContext, type JSX } from 'react'
export type HtmlProps = { export type HtmlProps = {
__NEXT_DATA__: NEXT_DATA __NEXT_DATA__: NEXT_DATA
nonce?: string nonce?: string
initialHmrVersion?: string
dangerousAsPath: string dangerousAsPath: string
docComponentsRendered: { docComponentsRendered: {
Html?: boolean Html?: boolean
......
...@@ -149,6 +149,8 @@ interface ImportMeta { ...@@ -149,6 +149,8 @@ interface ImportMeta {
} }
interface Window { interface Window {
/** @internal - Initial document baseline, supplied only by Turbopack dev HMR. */
__nextHmrInitialVersion?: string
MSInputMethodContext?: unknown MSInputMethodContext?: unknown
/** @internal */ /** @internal */
__NEXT_HMR_CB?: null | ((message?: string) => void) __NEXT_HMR_CB?: null | ((message?: string) => void)
......
.race-target {
color: rgb(1, 2, 3);
}
import type { ReactNode } from 'react'
import './globals.css'
export default function Root({ children }: { children: ReactNode }) {
return (
<html>
<body>{children}</body>
</html>
)
}
'use client'
import { useState } from 'react'
export default function Page() {
const [count, setCount] = useState(0)
return (
<>
<p className="race-target race-added">hello</p>
<button id="counter" onClick={() => setCount(count + 1)}>
{count}
</button>
</>
)
}
import { nextTestSetup } from 'e2e-utils'
import { gate } from 'next-test-utils'
import { assertCssHmrStartupRecovery } from '../../lib/css-hmr-initial-load-race'
const stylesheet = 'app/globals.css'
// Regression coverage for https://github.com/vercel/next.js/pull/99893.
// These repeated App/Pages races are complemented by a fresh Pages-only fixture
// so an already ensured App route cannot mask missing global Pages observation.
describe('css-hmr-initial-load-race', () => {
const { next } = nextTestSetup({ files: __dirname })
for (const [attempt, pathname] of ['/', '/legacy', '/'].entries()) {
// Requires a local file edit and a development HMR stream.
// @force-gate dev && turbopack
it(`reloads a missed startup CSS edit on ${pathname} (attempt ${attempt}), then preserves ordinary CSS HMR`, async () => {
await next.fetch(pathname)
await assertCssHmrStartupRecovery(next, pathname, stylesheet)
})
}
// @force-gate dev && turbopack
it('recovers a Pages race when the first greeting arrives after hydration', async () => {
await next.fetch('/legacy')
await assertCssHmrStartupRecovery(next, '/legacy', stylesheet, {
delayGreetingUntilHydrated: true,
})
})
// @force-gate dev && turbopack
it('does not reload or refetch CSS on an unchanged initial load', async () => {
let documentRequests = 0
let cssRequests = 0
const browser = await next.browser('/', {
async beforePageLoad(page) {
page.on('request', (request) => {
if (
request.isNavigationRequest() &&
request.frame() === page.mainFrame()
) {
documentRequests++
}
if (new URL(request.url()).pathname.endsWith('.css')) cssRequests++
})
},
})
await browser.elementByCss('#counter').click()
expect(await browser.elementByCss('#counter').text()).toBe('1')
expect(await browser.eval('window.__nextHmrInitialVersion')).toMatch(
/^\d+$/
)
expect(documentRequests).toBe(1)
expect(cssRequests).toBe(1)
})
it('emits the initial baseline only in dev-server HTML with Turbopack HMR', async () => {
const hasHmr = await gate('dev && turbopack')
for (const path of ['/', '/legacy']) {
const response = await next.fetch(path)
expect(response.status).toBe(200)
const html = await response.text()
if (hasHmr) {
expect(html).toMatch(/var __nextHmrInitialVersion="\d+";/)
} else {
expect(html).not.toContain('__nextHmrInitialVersion')
}
const browser = await next.browser(path)
const version = await browser.eval('window.__nextHmrInitialVersion')
if (hasHmr) expect(version).toMatch(/^\d+$/)
else expect(version).toBeUndefined()
await browser.elementByCss('#counter').click()
expect(await browser.elementByCss('#counter').text()).toBe('1')
}
})
// CSP nonce extraction is meaningful on the self-hosted dev server.
// @force-gate dev && turbopack
it('reuses the bootstrap CSP nonce for the inline baseline', async () => {
const policy = "script-src 'self' 'nonce-hmr-baseline-test' 'unsafe-eval'"
for (const path of ['/', '/legacy']) {
const response = await next.fetch(path, {
headers: { 'Content-Security-Policy': policy },
})
const html = await response.text()
const scripts = Array.from(
html.matchAll(/<script\b([^>]*)>([\s\S]*?)<\/script>/g)
)
const baseline = scripts.find(([, , content]) =>
content.includes('var __nextHmrInitialVersion=')
)
expect(baseline).toBeDefined()
expect(baseline[1]).toContain('nonce="hmr-baseline-test"')
}
})
})
import type { NextConfig } from 'next'
const nextConfig: NextConfig = {}
export default nextConfig
import type { AppProps } from 'next/app'
import '../app/globals.css'
export default function App({ Component, pageProps }: AppProps) {
return <Component {...pageProps} />
}
export { default } from '../app/page'
import { nextTestSetup } from 'e2e-utils'
import { assertCssHmrStartupRecovery } from '../../lib/css-hmr-initial-load-race'
import {
gate,
getRedboxDescription,
retry,
waitForNoRedbox,
waitForRedbox,
} from 'next-test-utils'
// No App directory or prewarmed route: the first browser loads Pages' global CSS
// through _app. An App route observer must not mask this independent regression.
describe('css-hmr-pages-initial-load-race', () => {
const { next } = nextTestSetup({ files: __dirname })
// Requires a local file edit and a development HMR stream.
// @force-gate dev && turbopack
it('reloads a missed global CSS edit on the very first Pages navigation', async () => {
await assertCssHmrStartupRecovery(next, '/', 'global.css')
})
// @force-gate dev && turbopack
it('recovers when the first greeting is delivered only after hydration', async () => {
await assertCssHmrStartupRecovery(next, '/', 'global.css', {
delayGreetingUntilHydrated: true,
})
})
// @force-gate dev && turbopack
it('observes replacement global CSS after ensuring another Page', async () => {
const originalApp = await next.readFile('pages/_app.tsx')
let documents = 0
const browser = await next.browser('/', {
async beforePageLoad(page) {
await page.addInitScript(() => {
;(window as any).__appObserverDocument = crypto.randomUUID()
})
page.on('request', (request) => {
if (
request.isNavigationRequest() &&
request.frame() === page.mainFrame()
) {
documents++
}
})
},
})
const documentId = await browser.eval('window.__appObserverDocument')
try {
await browser.elementByCss('#other').click()
await retry(async () => {
expect(new URL(await browser.url()).pathname).toBe('/other')
})
await browser.elementByCss('#counter').click()
expect(await browser.elementByCss('#counter').text()).toBe('1')
await next.patchFile(
'pages/_app.tsx',
originalApp.replace('original-app', 'edited-app')
)
await retry(async () => {
expect(await browser.elementByCss('#app-label').text()).toBe(
'edited-app'
)
})
expect(await browser.elementByCss('#counter').text()).toBe('1')
expect(await browser.eval('window.__appObserverDocument')).toBe(
documentId
)
expect(documents).toBe(1)
await next.patchFile(
'pages/_app.tsx',
originalApp
.replace('original-app', 'edited-app')
.replace('../global.css', '../replacement.css')
)
await retry(async () => {
expect(await browser.elementByCss('#app-label').text()).toBe(
'edited-app'
)
})
// Removing one CSS dependency and adding another already triggers runtime
// reloads without this observer. Check the new dependency is live, rather
// than promising state preservation for that structural change.
await retry(async () => {
const hrefs = await browser.eval<string[]>(
`Array.from(document.querySelectorAll('link[rel="stylesheet"]')).map((link) => link.getAttribute('href'))`
)
const css = (
await Promise.all(
hrefs.map(async (href) => (await next.fetch(href)).text())
)
).join('\n')
expect(css).toContain('.replacement-marker')
})
// No subscribed browser may detect this edit on behalf of the global
// observer. Its changed CSS dependency must be watched before new HTML.
await browser.close()
await assertCssHmrStartupRecovery(next, '/other', 'replacement.css')
} finally {
await browser.close()
await next.patchFile('pages/_app.tsx', originalApp)
}
})
// @force-gate dev && turbopack
it('keeps global _app compile/runtime issues visible and recovers without a reload loop', async () => {
const originalApp = await next.readFile('pages/_app.tsx')
let documents = 0
const browser = await next.browser('/', {
async beforePageLoad(page) {
page.on('request', (request) => {
if (
request.isNavigationRequest() &&
request.frame() === page.mainFrame()
) {
documents++
}
})
},
})
try {
await browser.elementByCss('#counter').click()
await next.patchFile(
'pages/_app.tsx',
`${originalApp}\ninvalid syntax !\n`
)
await waitForRedbox(browser)
// Another ensure must not let observer setup alone clear the global error.
expect((await next.fetch('/other')).status).toBe(500)
await waitForRedbox(browser)
expect(documents).toBe(1)
await next.patchFile('pages/_app.tsx', originalApp)
await waitForNoRedbox(browser)
expect(await browser.elementByCss('#counter').text()).toBe('1')
expect(documents).toBe(1)
await next.patchFile(
'pages/_app.tsx',
originalApp.replace(
' return (',
" throw new Error('global-app-runtime-error')\n return ("
)
)
await waitForRedbox(browser)
expect(await getRedboxDescription(browser)).toContain(
'global-app-runtime-error'
)
await next.patchFile('pages/_app.tsx', originalApp)
await waitForNoRedbox(browser)
expect(await browser.elementByCss('#app-label').text()).toBe(
'original-app'
)
expect(documents).toBe(1)
await browser.close()
await assertCssHmrStartupRecovery(next, '/', 'global.css')
} finally {
await browser.close()
await next.patchFile('pages/_app.tsx', originalApp)
}
})
// @force-gate dev && turbopack
it('establishes a fresh global baseline after configuration replacement', async () => {
const originalConfig = await next.readFile('next.config.ts')
try {
await next.patchFile(
'next.config.ts',
`export default {
async headers() {
return [{ source: '/:path*', headers: [{ key: 'x-observer-config', value: 'replaced' }] }]
}
}`
)
await retry(async () => {
const response = await next.fetch('/')
expect(response.status).toBe(200)
expect(response.headers.get('x-observer-config')).toBe('replaced')
}, 30_000)
await assertCssHmrStartupRecovery(next, '/', 'global.css')
} finally {
await next.patchFile('next.config.ts', originalConfig)
}
})
it('only emits the Pages baseline for actual dev Turbopack HMR', async () => {
const hasHmr = await gate('dev && turbopack')
const response = await next.fetch('/')
expect(response.status).toBe(200)
const html = await response.text()
if (hasHmr) expect(html).toMatch(/var __nextHmrInitialVersion="\d+";/)
else expect(html).not.toContain('__nextHmrInitialVersion')
})
// @force-gate dev && turbopack
it('keeps an unchanged Pages load at one document and one CSS request', async () => {
let documents = 0
let stylesheets = 0
let greeting: string | undefined
let firstSubscription: string | undefined
const browser = await next.browser('/', {
async beforePageLoad(page) {
page.on('request', (request) => {
if (
request.isNavigationRequest() &&
request.frame() === page.mainFrame()
) {
documents++
}
if (new URL(request.url()).pathname.endsWith('.css')) stylesheets++
})
await page.routeWebSocket(/\/_next\/hmr/, (clientSocket) => {
const serverSocket = clientSocket.connectToServer()
serverSocket.onMessage((payload) => {
if (typeof payload === 'string') {
const message = JSON.parse(payload)
if (message.type === 'turbopack-connected') {
greeting ??= message.data.hmrVersion
}
}
clientSocket.send(payload)
})
clientSocket.onMessage((payload) => {
if (typeof payload === 'string') {
const message = JSON.parse(payload)
if (message.type === 'turbopack-subscribe') {
firstSubscription ??= message.hmrVersion
}
}
serverSocket.send(payload)
})
})
},
})
await retry(async () => {
expect(greeting).toMatch(/^\d+$/)
expect(firstSubscription).toMatch(/^\d+$/)
})
expect(greeting).toBe(await browser.eval('window.__nextHmrInitialVersion'))
expect(firstSubscription).toBe(greeting)
await browser.elementByCss('#counter').click()
expect(await browser.elementByCss('#counter').text()).toBe('1')
expect(documents).toBe(1)
expect(stylesheets).toBe(1)
})
})
.race-target {
color: rgb(1, 2, 3);
}
import type { AppProps } from 'next/app'
import '../global.css'
export default function App({ Component, pageProps }: AppProps) {
return (
<>
<p id="app-label">original-app</p>
<Component {...pageProps} />
</>
)
}
import { useState } from 'react'
import Link from 'next/link'
export default function Page() {
const [count, setCount] = useState(0)
return (
<>
<p className="race-target race-added">hello</p>
<button id="counter" onClick={() => setCount(count + 1)}>
{count}
</button>
<Link id="other" href="/other" prefetch={false}>
other
</Link>
</>
)
}
.race-target {
color: rgb(1, 2, 3);
}
.replacement-marker {
color: rgb(1, 2, 3);
}
import { retry } from 'next-test-utils'
import type { Page } from 'playwright'
import type { NextInstance } from './next-modes/base'
const editedColor = 'rgb(9, 9, 9)'
const laterColor = 'rgb(4, 5, 6)'
// Hold JavaScript until the old CSS body finishes and the local edit completes.
// The helper's watcher delay is safe here: no browser subscription can start yet.
export async function assertCssHmrStartupRecovery(
next: NextInstance,
pathname: string,
stylesheet: string,
{ delayGreetingUntilHydrated = false } = {}
) {
const originalCss = await next.readFile(stylesheet)
let releaseJavaScript!: () => void
const javaScriptGate = new Promise<void>((resolve) => {
releaseJavaScript = resolve
})
let releaseGreeting = () => {}
const bufferedGreetingFrames: (string | Buffer)[] = []
let firstSocket = true
let socketOpened = false
let firstGreetingReceived = false
let edit: Promise<void> | undefined
let originalDocumentId = ''
let initialVersion: string | undefined
let connectionVersion: string | undefined
let latestConnectionVersion: string | undefined
let reconnectHmr = () => {}
let closeBrowser = async () => {}
const subscriptionVersions: (string | undefined)[] = []
let initialCss = ''
let documentRequests = 0
const browserErrors: string[] = []
try {
const browser = await next.browser(pathname, {
async beforePageLoad(page: Page) {
await page.addInitScript(() => {
;(window as any).__cssRaceDocumentId = crypto.randomUUID()
})
page.on('pageerror', (error) => browserErrors.push(error.message))
page.on('console', (message) => {
if (/\[HMR\].*connected/.test(message.text())) socketOpened = true
})
page.on('request', (request) => {
if (
request.isNavigationRequest() &&
request.frame() === page.mainFrame()
) {
documentRequests++
}
})
await page.routeWebSocket(/\/_next\/hmr/, (clientSocket) => {
const serverSocket = clientSocket.connectToServer()
let bufferDelivery = firstSocket && delayGreetingUntilHydrated
firstSocket = false
const deliver = (payload: string | Buffer) => {
if (typeof payload === 'string') {
const message = JSON.parse(payload)
if (message.type === 'turbopack-connected') {
// Never replace a malformed/missing first version with a later
// greeting. Recovery/reconnect must not manufacture our proof.
if (!firstGreetingReceived) {
firstGreetingReceived = true
connectionVersion = message.data.hmrVersion
}
latestConnectionVersion = message.data.hmrVersion
}
}
clientSocket.send(payload)
}
serverSocket.onMessage((payload) => {
if (bufferDelivery) bufferedGreetingFrames.push(payload)
else deliver(payload)
})
clientSocket.onMessage((payload) => {
if (typeof payload === 'string') {
const message = JSON.parse(payload)
if (message.type === 'turbopack-subscribe') {
subscriptionVersions.push(message.hmrVersion)
}
}
serverSocket.send(payload)
})
if (bufferDelivery) {
releaseGreeting = () => {
bufferDelivery = false
for (const payload of bufferedGreetingFrames.splice(0)) {
deliver(payload)
}
}
}
reconnectHmr = () => serverSocket.close()
})
await page.route('**/*.js*', async (route) => {
const response = await route.fetch()
await javaScriptGate
await route.fulfill({ response })
})
page.on('response', (response) => {
if (edit || !new URL(response.url()).pathname.endsWith('.css')) return
edit = (async () => {
try {
await response.finished()
initialCss = await response.text()
const snapshot = await page.evaluate(() => ({
documentId: (window as any).__cssRaceDocumentId,
version: (window as any).__nextHmrInitialVersion,
}))
originalDocumentId = snapshot.documentId
initialVersion = snapshot.version
await next.patchFile(
stylesheet,
`${originalCss}\n.race-added { color: ${editedColor}; }\n`
)
} finally {
releaseJavaScript()
}
})()
})
},
})
closeBrowser = () => browser.close()
expect(edit).toBeDefined()
await edit
expect(initialCss).toContain('.race-target')
expect(initialCss).not.toContain('.race-added')
expect(originalDocumentId).not.toBe('')
expect(initialVersion).toMatch(/^\d+$/)
if (delayGreetingUntilHydrated) {
// A real server greeting exists, but has not been delivered to the page.
// The onopen diagnostic proves socket readiness independently of greeting
// receipt. Check React interactivity rather than treating next.browser()
// returning or the document load event as proof of hydration.
await retry(async () => {
expect(
bufferedGreetingFrames.some(
(payload) =>
typeof payload === 'string' &&
JSON.parse(payload).type === 'turbopack-connected'
)
).toBe(true)
expect(socketOpened).toBe(true)
})
await browser.elementByCss('#counter').click()
await retry(async () => {
expect(await browser.elementByCss('#counter').text()).toBe('1')
})
expect(firstGreetingReceived).toBe(false)
expect(connectionVersion).toBeUndefined()
expect(documentRequests).toBe(1)
releaseGreeting()
}
// Hydration and socket open do not guarantee that the greeting callback has
// run. Wait for actual first-message evidence, preserving values on timeout.
await retry(async () => {
expect({
initialVersion,
firstGreeting: connectionVersion,
firstSubscription: subscriptionVersions[0],
}).toEqual({
initialVersion,
firstGreeting: expect.stringMatching(/^\d+$/),
firstSubscription: expect.stringMatching(/^\d+$/),
})
})
expect(Number(connectionVersion)).toBeGreaterThan(Number(initialVersion))
expect(subscriptionVersions[0]).toBe(initialVersion)
const readColor = () =>
browser.eval<string>(
`getComputedStyle(document.querySelector('.race-target')).color`
)
const readDocumentId = () =>
browser.eval<string>('window.__cssRaceDocumentId')
await retry(async () => {
// Recovery may still navigate after the old document's hydration. Read
// the current stylesheet URLs again on every retry.
const hrefs = await browser.eval<string[]>(
`Array.from(document.querySelectorAll('link[rel="stylesheet"]')).map((link) => link.getAttribute('href'))`
)
expect(hrefs?.length).toBeGreaterThan(0)
const servedCss = (
await Promise.all(
hrefs.map(async (href) => (await next.fetch(href)).text())
)
).join('\n')
expect(servedCss).toContain('.race-added')
})
await retry(async () => {
expect(await readColor()).toBe(editedColor)
expect(documentRequests).toBe(2)
})
expect(await readDocumentId()).not.toBe(originalDocumentId)
const recoveredDocumentId = await readDocumentId()
await browser.elementByCss('#counter').click()
expect(await browser.elementByCss('#counter').text()).toBe('1')
await next.patchFile(
stylesheet,
`${originalCss}\n.race-added { color: ${laterColor}; }\n`
)
await retry(async () => {
expect(await readColor()).toBe(laterColor)
})
expect(await browser.elementByCss('#counter').text()).toBe('1')
expect(await readDocumentId()).toBe(recoveredDocumentId)
expect(documentRequests).toBe(2)
// Force real resubscription after ordinary HMR: its applied version must
// match the server, not lag behind an observer-only version increment.
const subscriptionsBeforeReconnect = subscriptionVersions.length
reconnectHmr()
await retry(async () => {
expect(subscriptionVersions.length).toBeGreaterThan(
subscriptionsBeforeReconnect
)
expect(subscriptionVersions[subscriptionVersions.length - 1]).toBe(
latestConnectionVersion
)
}, 10_000)
expect(await readDocumentId()).toBe(recoveredDocumentId)
expect(await browser.elementByCss('#counter').text()).toBe('1')
expect(documentRequests).toBe(2)
expect(browserErrors).toEqual([])
} finally {
releaseJavaScript()
releaseGreeting()
// Remove this browser's native chunk subscriptions before restoring files
// or starting another race; only the server's early observer may detect it.
await closeBrowser()
await next.patchFile(stylesheet, originalCss)
}
}
/** @jest-environment jsdom */
import type {
ClientOptions,
WebSocketMessage,
} from '../../../turbopack/crates/turbopack-ecmascript-runtime/js/src/browser/dev/hmr-client/hmr-client'
const listenersGlobal = '__HMR_BASELINE_TEST_LISTENERS'
type HmrClient =
typeof import('../../../turbopack/crates/turbopack-ecmascript-runtime/js/src/browser/dev/hmr-client/hmr-client')
function setup(initialHmrVersion?: string, greeting?: string) {
jest.resetModules()
const client: HmrClient = require('../../../turbopack/crates/turbopack-ecmascript-runtime/js/src/browser/dev/hmr-client/hmr-client')
let receive!: (message: WebSocketMessage) => void
const sent: { type: string; path: string; hmrVersion?: string }[] = []
const callback = jest.fn()
const hooks = {
beforeRefresh: jest.fn(),
refresh: jest.fn(),
buildOk: jest.fn(),
issues: jest.fn(),
}
client.setHooks(hooks)
;(globalThis as any)[listenersGlobal] = [['entry.js', callback]]
const options: ClientOptions = {
initialHmrVersion,
addMessageListener(listener) {
receive = listener
if (greeting !== undefined) {
listener({
type: 'turbopack-connected',
data: { hmrVersion: greeting },
})
}
},
sendMessage: (message) => sent.push(JSON.parse(message)),
onUpdateError: jest.fn(),
chunkUpdateListenersGlobal: listenersGlobal,
}
client.connect(options)
return {
client,
receive: (message: WebSocketMessage) => receive(message),
sent,
options,
hooks,
callback,
}
}
afterEach(() => {
delete (globalThis as any)[listenersGlobal]
})
describe('initial document HMR baseline', () => {
it('uses the initial version for listeners registered before the socket greeting', () => {
const { receive, sent, hooks } = setup('3')
expect(sent).toEqual([
{ type: 'turbopack-subscribe', path: 'entry.js', hmrVersion: '3' },
])
receive({ type: 'turbopack-connected', data: { hmrVersion: '4' } })
expect(sent[1].hmrVersion).toBe('3')
for (const hook of Object.values(hooks)) expect(hook).not.toHaveBeenCalled()
})
it('keeps the HTML fallback when a newer greeting is synchronously replayed', () => {
const { sent } = setup('3', '4')
expect(sent[0].hmrVersion).toBe('3')
})
it('subscribes without manufacturing a mismatch when HTML and greeting match', () => {
const { sent } = setup('0', '0')
expect(sent[0].hmrVersion).toBe('0')
})
it('retains the connection baseline for documents without the marker', () => {
const { sent, receive } = setup()
expect(sent[0].hmrVersion).toBeUndefined()
receive({ type: 'turbopack-connected', data: { hmrVersion: '4' } })
expect(sent[1].hmrVersion).toBe('4')
receive({ type: 'turbopack-connected', data: { hmrVersion: '5' } })
expect(sent[2].hmrVersion).toBe('4')
})
it('retains a previously observed socket version across reconnections', () => {
const { sent, receive } = setup('3', '3')
receive({ type: 'server-component-changes', hmrVersion: '4' })
receive({ type: 'turbopack-connected', data: { hmrVersion: '5' } })
expect(sent[sent.length - 1].hmrVersion).toBe('4')
})
it('does not reset observed state to the HTML fallback if connect is called again', () => {
const { client, sent, receive, options } = setup('3', '3')
receive({ type: 'server-component-changes', hmrVersion: '4' })
;(globalThis as any)[listenersGlobal] = [['another-entry.js', jest.fn()]]
client.connect(options)
expect(sent[sent.length - 1].hmrVersion).toBe('4')
})
it('still forwards issue messages without treating initialization as a successful refresh', () => {
const { receive, hooks } = setup('3', '3')
receive({
type: 'turbopack-message',
hmrVersion: '3',
data: {
type: 'issues',
resource: { path: 'entry.js' },
issues: [{ severity: 'error', title: 'Compilation failed' }],
},
})
expect(hooks.issues).toHaveBeenCalled()
expect(hooks.buildOk).not.toHaveBeenCalled()
expect(hooks.beforeRefresh).not.toHaveBeenCalled()
expect(hooks.refresh).not.toHaveBeenCalled()
})
})
// Exercise source at runtime without importing Next's entire source type graph
// into the root test tsconfig. Core source is checked by Next's own types task.
const { handleRouteType, hasEntrypointForKey } = jest.requireActual(
'../../../packages/next/src/server/dev/turbopack-utils'
)
import { getEntryKey } from '../../../packages/next/src/shared/lib/turbopack/entry-key'
import type { EntryKey } from '../../../packages/next/src/shared/lib/turbopack/entry-key'
import type {
Endpoint,
TurbopackResult,
WrittenEndpoint,
} from '../../../packages/next/dist/build/swc/types'
async function* changes() {}
function createEndpoint() {
const written: TurbopackResult<WrittenEndpoint> = {
value: {
type: 'nodejs',
entryPath: 'page.js',
serverHmrEntryPaths: [],
clientPaths: [],
serverPaths: [],
config: {},
},
issues: [],
}
return {
writeToDisk: jest.fn().mockResolvedValue(written),
clientChanged: jest.fn().mockResolvedValue(changes()),
serverChanged: jest.fn().mockResolvedValue(changes()),
} satisfies Endpoint
}
function setup() {
const app = createEndpoint()
const html = createEndpoint()
const observe = jest.fn(async (_key: EntryKey, endpoint: Endpoint) => {
await endpoint.clientChanged()
})
const options = {
dev: true,
page: '/',
pathname: '/',
route: { type: 'page', htmlEndpoint: html, dataEndpoint: createEndpoint() },
currentEntryIssues: new Map(),
entrypoints: {
global: {
app,
document: undefined,
error: undefined,
middleware: undefined,
instrumentation: undefined,
},
page: new Map(),
app: new Map(),
},
manifestLoader: {
loadBuildManifest: jest.fn(),
loadPagesManifest: jest.fn(),
loadClientBuildManifest: jest.fn(),
loadFontManifest: jest.fn(),
deleteMiddlewareManifest: jest.fn(),
writeManifests: jest.fn(),
},
devRewrites: undefined,
productionRewrites: undefined,
logErrors: false,
hooks: {
handleWrittenEndpoint: jest.fn().mockReturnValue(false),
subscribeToChanges: jest.fn().mockResolvedValue(undefined),
subscribeToClientHmrChanges: observe,
},
}
return { options, app, html, observe }
}
describe('Pages global client observation', () => {
it('awaits the written global _app baseline before writing the page HTML', async () => {
const { options, app, html, observe } = setup()
let started!: () => void
const setupStarted = new Promise<void>((resolve) => {
started = resolve
})
let ready!: (iterator: ReturnType<typeof changes>) => void
app.clientChanged.mockImplementation(() => {
started()
return new Promise((resolve) => {
ready = resolve
})
})
const ensure = handleRouteType(options)
await setupStarted
expect(app.writeToDisk).toHaveBeenCalledTimes(1)
expect(observe).toHaveBeenCalledWith(
getEntryKey('pages', 'client', '_app'),
app
)
expect(html.writeToDisk).not.toHaveBeenCalled()
ready(changes())
await ensure
expect(html.writeToDisk).toHaveBeenCalledTimes(1)
expect(observe).toHaveBeenLastCalledWith(
getEntryKey('pages', 'client', '/'),
html
)
})
it('uses one dedicated global key across distinct ensured Pages', async () => {
const { options, app, observe } = setup()
await handleRouteType(options)
await handleRouteType({ ...options, page: '/other', pathname: '/other' })
const globalKeys = observe.mock.calls
.filter(([, endpoint]) => endpoint === app)
.map(([key]) => key)
// The real owner deduplicates by this key in changeSubscriptions. This unit
// checks the caller's keys, not the native subscription owner's internals.
expect(globalKeys).toEqual([
getEntryKey('pages', 'client', '_app'),
getEntryKey('pages', 'client', '_app'),
])
})
it.each(['production', 'one-shot'] as const)(
'does not observe the global endpoint for %s compilation',
async (mode) => {
const { options, app, html, observe } = setup()
if (mode === 'production') options.dev = false
else options.hooks!.subscribeToClientHmrChanges = undefined
await handleRouteType(options)
expect(observe).not.toHaveBeenCalled()
expect(app.clientChanged).not.toHaveBeenCalled()
expect(html.clientChanged).not.toHaveBeenCalled()
expect(html.writeToDisk).toHaveBeenCalledTimes(1)
}
)
it('leaves a rejected setup visible to the caller', async () => {
const { options, app, html } = setup()
app.clientChanged.mockRejectedValue(new Error('client setup failed'))
await expect(handleRouteType(options)).rejects.toThrow(
'client setup failed'
)
expect(html.writeToDisk).not.toHaveBeenCalled()
})
it('observes only the page when there is no global _app endpoint', async () => {
const { options, app, html, observe } = setup()
options.entrypoints.global.app = undefined
await handleRouteType(options)
expect(app.writeToDisk).not.toHaveBeenCalled()
expect(observe.mock.calls).toEqual([
[getEntryKey('pages', 'client', '/'), html],
])
})
it('recognizes the global client key for existing map cleanup', () => {
const { options } = setup()
const key = getEntryKey('pages', 'client', '_app')
expect(hasEntrypointForKey(options.entrypoints, key, undefined)).toBe(true)
options.entrypoints.global.app = undefined
expect(hasEntrypointForKey(options.entrypoints, key, undefined)).toBe(false)
})
})
...@@ -24,6 +24,7 @@ export type ClientOptions = { ...@@ -24,6 +24,7 @@ export type ClientOptions = {
sendMessage: SendMessage sendMessage: SendMessage
onUpdateError: (err: unknown) => void onUpdateError: (err: unknown) => void
chunkUpdateListenersGlobal: string chunkUpdateListenersGlobal: string
initialHmrVersion?: string
} }
export const TURBOPACK_CHUNK_UPDATE_LISTENERS_GLOBAL = export const TURBOPACK_CHUNK_UPDATE_LISTENERS_GLOBAL =
...@@ -36,7 +37,12 @@ export function connect({ ...@@ -36,7 +37,12 @@ export function connect({
sendMessage, sendMessage,
onUpdateError = console.error, onUpdateError = console.error,
chunkUpdateListenersGlobal, chunkUpdateListenersGlobal,
initialHmrVersion,
}: ClientOptions) { }: ClientOptions) {
// Initialize before replaying socket messages or draining queued listeners.
// A previously observed socket version takes priority on reconnection.
lastSeenHmrVersion ??= initialHmrVersion
addMessageListener((msg) => { addMessageListener((msg) => {
switch (msg.type) { switch (msg.type) {
case 'turbopack-connected': case 'turbopack-connected':
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment