Commit 6a93d710 authored by Will Binns-Smith's avatar Will Binns-Smith

wip

parent 1c5680e9
......@@ -65,6 +65,7 @@ import {
type ServerFields,
type SetupOpts,
} from '../lib/router-utils/setup-dev-bundler'
import { resetInstrumentationCache } from '../lib/router-utils/instrumentation-globals.external'
import { TurbopackManifestLoader } from '../../shared/lib/turbopack/manifest-loader'
import { findPagePathData } from './on-demand-entry-handler'
import type { RouteDefinition } from '../route-definitions/route-definition'
......@@ -616,24 +617,41 @@ export async function createHotReloaderTurbopack(
entryPage === 'instrumentation.nodeJs'))) &&
writtenEndpoint.type !== 'edge'
// Root entries (middleware/instrumentation) are loaded via require() rather
// than __turbopack_require__. Their entry chunk's exports are cached in
// Node's require.cache and must be cleared when the module changes so that
// the next require() loads the updated code. Dep chunks are preserved so
// that unmodified deps are not re-evaluated.
const isRootEntryChunk =
usesServerHmr &&
writtenEndpoint.type === 'nodejs' &&
entryType === 'root'
const filesToDelete: string[] = []
for (const file of serverPaths) {
clearModuleContext(file)
const relativePath = relative(distDir, file)
if (
// For Pages Router, edge routes, middleware, and manifest files:
// clear the sharedCache in evalManifest(), Node.js require.cache,
// and edge runtime module contexts.
force ||
!usesServerHmr ||
!serverHmrSubscriptions?.has(relativePath)
) {
const inSubscriptions = !!serverHmrSubscriptions?.has(relativePath)
const isEntryChunk =
isRootEntryChunk && relativePath === writtenEndpoint.entryPath
if (force || !usesServerHmr || !inSubscriptions || isEntryChunk) {
filesToDelete.push(file)
}
}
deleteCache(filesToDelete)
// Reset the instrumentation module cache so the next request re-requires
// the updated instrumentation module and re-runs its module-scope globals.
if (entryPage === 'instrumentation.nodeJs') {
resetInstrumentationCache()
}
if (entryType === 'root' && writtenEndpoint.type === 'nodejs') {
console.log(`[dbg-root] key=${entryPage} entryPath=${writtenEndpoint.entryPath} filesToDelete=${filesToDelete.map(f => relative(distDir, f)).join(',')}`)
}
// Reset the fetch patch so patchFetch() can re-wrap on the next request.
if (serverPaths.length > 0) {
resetFetch()
......
......@@ -512,6 +512,8 @@ export function hasEntrypointForKey(
case 'middleware':
return entrypoints.global.middleware != null
case 'instrumentation':
case 'instrumentation.nodeJs':
case 'instrumentation.edge':
return entrypoints.global.instrumentation != null
default:
return false
......@@ -686,6 +688,30 @@ export async function handleEntrypoints({
'actualInstrumentationHookFile',
dev.serverFields.actualInstrumentationHookFile
)
// Subscribe to instrumentation endpoint changes so server HMR picks up
// instrumentation module updates without a full server restart.
const subscribeInstrumentation = (
name: string,
prop: 'nodeJs' | 'edge'
) => {
const key = getEntryKey('root', 'server', name)
dev.hooks.subscribeToChanges(key, false, instrumentation[prop], () => {
void processInstrumentation(name, prop).then(() => {
manifestLoader.loadMiddlewareManifest(
'instrumentation',
'instrumentation'
)
manifestLoader.writeManifests({
devRewrites,
productionRewrites: undefined,
entrypoints: currentEntrypoints,
})
})
})
}
subscribeInstrumentation('instrumentation.nodeJs', 'nodeJs')
subscribeInstrumentation('instrumentation.edge', 'edge')
} else {
dev.serverFields.actualInstrumentationHookFile = undefined
await dev.hooks.propagateServerField(
......
......@@ -79,6 +79,13 @@ export async function instrumentationOnRequestError(
}
let registerInstrumentationPromise: Promise<void> | null = null
export function resetInstrumentationCache() {
cachedInstrumentationModule = undefined as unknown as InstrumentationModule
instrumentationModulePromise = null
registerInstrumentationPromise = null
}
export function ensureInstrumentationRegistered(
projectDir: string,
distDir: string
......
import { ReactNode } from 'react'
import { segmentUtilEvaluatedAt } from './segment-util'
export const _hmrTrigger = 0
// Captured at module evaluation time — used by tests to detect re-evaluation
export const innerLayoutEvaluatedAt = Date.now()
export default function InnerLayout({ children }: { children: ReactNode }) {
return (
<div>
<p id="inner-layout-eval-time">
Inner Layout Evaluated At: {innerLayoutEvaluatedAt}
</p>
<p id="segment-util-eval-time">
Segment Util Evaluated At: {segmentUtilEvaluatedAt}
</p>
{children}
</div>
)
}
export const _hmrTrigger = 0
export default function InnerPage() {
return <p id="inner-page">Inner Page</p>
}
export const _hmrTrigger = 0
export const segmentUtilEvaluatedAt = Date.now()
import { ReactNode } from 'react'
// Captured at module evaluation time — used by tests to detect re-evaluation
export const outerLayoutEvaluatedAt = Date.now()
export default function OuterLayout({ children }: { children: ReactNode }) {
return (
<div>
<p id="outer-layout-eval-time">
Outer Layout Evaluated At: {outerLayoutEvaluatedAt}
</p>
{children}
</div>
)
}
export const runtime = 'nodejs'
import { NextResponse } from 'next/server'
import { depEvaluatedAt } from './middleware-dep'
import { depEvaluatedAt } from './proxy-dep'
export default function middleware() {
const res = NextResponse.next()
......
......@@ -160,7 +160,7 @@ describe('server-hmr', () => {
const initial = await next.fetch('/api/hello')
expect(initial.headers.get('x-middleware-version')).toBe('0')
await next.patchFile('middleware.ts', (content) =>
await next.patchFile('proxy.ts', (content) =>
content.replace("'0'", "'1'")
)
......@@ -182,7 +182,7 @@ describe('server-hmr', () => {
expect(initialDepEvaluatedAt).toMatch(/^\d+$/)
// Change only the middleware, not the dependency
await next.patchFile('middleware.ts', (content) =>
await next.patchFile('proxy.ts', (content) =>
content.replace(`'${initialVersion}'`, `'${initialVersion}-updated'`)
)
......@@ -251,6 +251,107 @@ describe('server-hmr', () => {
)
})
describe('segment-level accept', () => {
// Renders /segment-accept/inner which has two nested layouts:
// OuterLayout (app/segment-accept/layout.tsx) and
// InnerLayout (app/segment-accept/inner/layout.tsx)
itTurbopackDev(
'does not re-evaluate outer layout when inner layout changes',
async () => {
const browser = await next.browser('/segment-accept/inner')
// Wait for initial render
await retry(async () => {
const text = await browser
.elementByCss('#outer-layout-eval-time')
.text()
expect(text).toMatch(/Outer Layout Evaluated At: \d+/)
})
const initialOuterEvalTime = await browser
.elementByCss('#outer-layout-eval-time')
.text()
const initialInnerEvalTime = await browser
.elementByCss('#inner-layout-eval-time')
.text()
// Change the inner layout — only it should be re-evaluated
await next.patchFile(
'app/segment-accept/inner/layout.tsx',
(content) => content.replace('_hmrTrigger = 0', '_hmrTrigger = 1')
)
// Wait until the inner layout is re-evaluated (its timestamp changes)
await retry(async () => {
await browser.refresh()
const newInnerEvalTime = await browser
.elementByCss('#inner-layout-eval-time')
.text()
expect(newInnerEvalTime).not.toBe(initialInnerEvalTime)
})
// The outer layout should NOT have been re-evaluated
const newOuterEvalTime = await browser
.elementByCss('#outer-layout-eval-time')
.text()
expect(newOuterEvalTime).toBe(initialOuterEvalTime)
}
)
itTurbopackDev(
're-evaluates inner layout but not outer when inner segment utility changes',
async () => {
const browser = await next.browser('/segment-accept/inner')
// Wait for initial render
await retry(async () => {
const text = await browser
.elementByCss('#outer-layout-eval-time')
.text()
expect(text).toMatch(/Outer Layout Evaluated At: \d+/)
})
const initialOuterEvalTime = await browser
.elementByCss('#outer-layout-eval-time')
.text()
const initialInnerEvalTime = await browser
.elementByCss('#inner-layout-eval-time')
.text()
const initialUtilEvalTime = await browser
.elementByCss('#segment-util-eval-time')
.text()
// Change the utility imported by the inner layout.
// The inner layout is the nearest segment boundary, so both the utility
// and the inner layout should be re-evaluated. The outer layout should not.
await next.patchFile(
'app/segment-accept/inner/segment-util.ts',
(content) => content.replace('_hmrTrigger = 0', '_hmrTrigger = 1')
)
// Wait until both the utility and inner layout are re-evaluated
await retry(async () => {
await browser.refresh()
const newUtilEvalTime = await browser
.elementByCss('#segment-util-eval-time')
.text()
expect(newUtilEvalTime).not.toBe(initialUtilEvalTime)
const newInnerEvalTime = await browser
.elementByCss('#inner-layout-eval-time')
.text()
expect(newInnerEvalTime).not.toBe(initialInnerEvalTime)
})
// The outer layout should NOT have been re-evaluated
const newOuterEvalTime = await browser
.elementByCss('#outer-layout-eval-time')
.text()
expect(newOuterEvalTime).toBe(initialOuterEvalTime)
}
)
})
describe('route handler hmr', () => {
function getText(res: Response) {
return res.ok
......
......@@ -73,6 +73,25 @@ function emitMessage(msg: { type: string; data: any }): boolean {
}
}
/**
* App Router segment boundary files are natural HMR accept boundaries.
* The route entry loads them dynamically via __next_app_require__ on each
* server request, so it does not need re-instantiation when a segment changes.
* Only the segment file itself (and any transitive dependencies that don't
* self-accept) will be re-instantiated.
*
* Segment boundary files are identified by their conventional filenames inside
* the `app/` directory:
* layout, page, template, error, loading, not-found, forbidden, unauthorized,
* global-error, global-not-found
*/
const SEGMENT_BOUNDARY_MODULE_RE =
/[/\\]app[/\\].*[/\\](layout|page|template|error|loading|not-found|forbidden|unauthorized|global-error|global-not-found)\.[jt]sx?(\?|$)/
function isAppRouterSegmentModule(moduleId: ModuleId): boolean {
return SEGMENT_BOUNDARY_MODULE_RE.test(String(moduleId))
}
/**
* Handles server message updates and applies them to the Node.js runtime.
* Uses shared HMR update logic from hmr-runtime.ts.
......@@ -116,6 +135,9 @@ function handleNodejsUpdate(
moduleFactories,
devModuleCache,
autoAcceptRootModules: true,
// App Router segment files are accept boundaries: the update bubble stops
// at the segment rather than propagating all the way to the route entry.
isAutoAcceptModule: isAppRouterSegmentModule,
})
} catch (e) {
console.error('[Server HMR] Update failed, full reload needed:', e)
......
......@@ -112,10 +112,14 @@ function formatDependencyChain(dependencyChain: ModuleId[]): string {
* @param moduleId - The module that changed
* @param autoAcceptRootModules - If true, root modules auto-accept updates without explicit module.hot.accept().
* This is used for server-side HMR where pages auto-accept at the top level.
* @param isAutoAcceptModule - Optional predicate. If provided and returns true for a module ID, that module
* acts as an HMR accept boundary regardless of its hot.accept() state.
* Use this to define coarser accept boundaries (e.g. segment files in App Router).
*/
function getAffectedModuleEffects(
moduleId: ModuleId,
autoAcceptRootModules: boolean
autoAcceptRootModules: boolean,
isAutoAcceptModule?: (moduleId: ModuleId) => boolean
): ModuleEffect {
const outdatedModules: Set<ModuleId> = new Set()
const outdatedDependencies: Map<ModuleId, Set<ModuleId>> = new Map()
......@@ -165,9 +169,12 @@ function getAffectedModuleEffects(
if (
// The module is not in the cache. Since this is a "modified" update,
// it means that the module was never instantiated before.
!module || // The module accepted itself without invalidating globalThis.
!module ||
// The module accepted itself without invalidating globalThis.
// TODO is that right?
(hotState.selfAccepted && !hotState.selfInvalidated)
(hotState.selfAccepted && !hotState.selfInvalidated) ||
// Caller-defined accept boundary (e.g. App Router segment files).
isAutoAcceptModule?.(moduleId)
) {
continue
}
......@@ -269,10 +276,12 @@ function mergeDependencies(
*
* @param invalidated - The modules that have been invalidated
* @param autoAcceptRootModules - If true, root modules auto-accept updates without explicit module.hot.accept()
* @param isAutoAcceptModule - Optional predicate for caller-defined accept boundaries
*/
function computedInvalidatedModules(
invalidated: Iterable<ModuleId>,
autoAcceptRootModules: boolean
autoAcceptRootModules: boolean,
isAutoAcceptModule?: (moduleId: ModuleId) => boolean
): {
outdatedModules: Set<ModuleId>
outdatedDependencies: Map<ModuleId, Set<ModuleId>>
......@@ -281,7 +290,11 @@ function computedInvalidatedModules(
const outdatedDependencies = new Map<ModuleId, Set<ModuleId>>()
for (const moduleId of invalidated) {
const effect = getAffectedModuleEffects(moduleId, autoAcceptRootModules)
const effect = getAffectedModuleEffects(
moduleId,
autoAcceptRootModules,
isAutoAcceptModule
)
switch (effect.type) {
case 'unaccepted':
......@@ -422,11 +435,13 @@ function createModuleHot(
*
* @param outdatedModules - The current set of outdated modules
* @param autoAcceptRootModules - If true, root modules auto-accept updates without explicit module.hot.accept()
* @param isAutoAcceptModule - Optional predicate for caller-defined accept boundaries
*/
function applyInvalidatedModules(
outdatedModules: Set<ModuleId>,
outdatedDependencies: Map<ModuleId, Set<ModuleId>>,
autoAcceptRootModules: boolean
autoAcceptRootModules: boolean,
isAutoAcceptModule?: (moduleId: ModuleId) => boolean
): {
outdatedModules: Set<ModuleId>
outdatedDependencies: Map<ModuleId, Set<ModuleId>>
......@@ -434,7 +449,8 @@ function applyInvalidatedModules(
if (queuedInvalidatedModules.size > 0) {
const result = computedInvalidatedModules(
queuedInvalidatedModules,
autoAcceptRootModules
autoAcceptRootModules,
isAutoAcceptModule
)
for (const moduleId of result.outdatedModules) {
outdatedModules.add(moduleId)
......@@ -755,12 +771,14 @@ function computeChangedModules(
* @param modified - Map of modified modules
* @param evalModuleEntry - Function to compile module code
* @param autoAcceptRootModules - If true, root modules auto-accept updates without explicit module.hot.accept()
* @param isAutoAcceptModule - Optional predicate for caller-defined accept boundaries
*/
function computeOutdatedModules(
added: Map<ModuleId, EcmascriptModuleEntry | undefined>,
modified: Map<ModuleId, EcmascriptModuleEntry>,
evalModuleEntry: (entry: EcmascriptModuleEntry) => HotModuleFactoryFunction,
autoAcceptRootModules: boolean
autoAcceptRootModules: boolean,
isAutoAcceptModule?: (moduleId: ModuleId) => boolean
): {
outdatedModules: Set<ModuleId>
outdatedDependencies: Map<ModuleId, Set<ModuleId>>
......@@ -778,7 +796,8 @@ function computeOutdatedModules(
// Walk dependency tree to find all modules affected by modifications
const { outdatedModules, outdatedDependencies } = computedInvalidatedModules(
modified.keys(),
autoAcceptRootModules
autoAcceptRootModules,
isAutoAcceptModule
)
// Compile modified modules
......@@ -903,6 +922,7 @@ function applyPhase(
* invalidation, disposal, and application of new modules.
*
* @param autoAcceptRootModules - If true, root modules auto-accept updates without explicit module.hot.accept()
* @param isAutoAcceptModule - Optional predicate for caller-defined accept boundaries
*/
function applyInternal(
outdatedModules: Set<ModuleId>,
......@@ -917,12 +937,14 @@ function applyInternal(
sourceData: SourceData
) => HotModule,
applyModuleFactoryNameFn: (factory: HotModuleFactoryFunction) => void,
autoAcceptRootModules: boolean
autoAcceptRootModules: boolean,
isAutoAcceptModule?: (moduleId: ModuleId) => boolean
) {
;({ outdatedModules, outdatedDependencies } = applyInvalidatedModules(
outdatedModules,
outdatedDependencies,
autoAcceptRootModules
autoAcceptRootModules,
isAutoAcceptModule
))
// Find self-accepted modules to re-instantiate
......@@ -969,7 +991,8 @@ function applyInternal(
devModuleCache,
instantiateModuleFn,
applyModuleFactoryNameFn,
autoAcceptRootModules
autoAcceptRootModules,
isAutoAcceptModule
)
}
}
......@@ -981,6 +1004,10 @@ function applyInternal(
* @param options.autoAcceptRootModules - If true, root modules auto-accept updates without explicit
* module.hot.accept(). Used for server-side HMR where pages
* auto-accept at the top level.
* @param options.isAutoAcceptModule - Optional predicate. If provided and returns true for a module ID,
* that module acts as an HMR accept boundary regardless of its
* hot.accept() state. The update bubble stops there, and only that
* module (and its outdated dependencies) are re-instantiated.
*/
function applyEcmascriptMergedUpdateShared(options: {
added: Map<ModuleId, EcmascriptModuleEntry | undefined>
......@@ -996,6 +1023,7 @@ function applyEcmascriptMergedUpdateShared(options: {
moduleFactories: ModuleFactories
devModuleCache: ModuleCache<HotModule>
autoAcceptRootModules: boolean
isAutoAcceptModule?: (moduleId: ModuleId) => boolean
}) {
const {
added,
......@@ -1007,6 +1035,7 @@ function applyEcmascriptMergedUpdateShared(options: {
moduleFactories,
devModuleCache,
autoAcceptRootModules,
isAutoAcceptModule,
} = options
const { outdatedModules, outdatedDependencies, newModuleFactories } =
......@@ -1014,7 +1043,8 @@ function applyEcmascriptMergedUpdateShared(options: {
added,
modified,
evalModuleEntry,
autoAcceptRootModules
autoAcceptRootModules,
isAutoAcceptModule
)
applyInternal(
......@@ -1026,6 +1056,7 @@ function applyEcmascriptMergedUpdateShared(options: {
devModuleCache,
instantiateModule,
applyModuleFactoryName,
autoAcceptRootModules
autoAcceptRootModules,
isAutoAcceptModule
)
}
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