Commit 8579379b authored by Luke Sandberg's avatar Luke Sandberg

Use client reference manifests for accurate First Load JS metrics

Replace app-build-manifest with client reference manifest parsing to
include React Server Component client dependencies in bundle size
analysis. This fixes incorrect "First Load JS" reporting that was
missing critical client-side code required for RSC hydration.

🤖 Generated with [Claude Code](https://claude.ai/code)
Co-Authored-By: 's avatarClaude <noreply@anthropic.com>
parent 5f3d028b
import { existsSync, readFileSync, readdirSync } from 'node:fs'
import { join } from 'node:path'
import { CLIENT_REFERENCE_MANIFEST } from '../shared/lib/constants'
import type { ClientReferenceManifest } from './webpack/plugins/flight-manifest-plugin'
export interface AppBuildManifestFromClientReferences {
pages: Record<string, string[]>
}
/**
* Extracts route-based manifest data from client reference manifests
* This provides a more accurate representation of client-side bundle requirements
* for React Server Components compared to the webpack plugin approach
*/
export function computeAppBuildManifestFromClientReferences(
distPath: string
): AppBuildManifestFromClientReferences {
const serverAppPath = join(distPath, 'server', 'app')
if (!existsSync(serverAppPath)) {
return { pages: {} }
}
const manifest: AppBuildManifestFromClientReferences = { pages: {} }
const allFiles = new Set<string>()
// Recursively find all client reference manifest files
function findClientReferenceManifests(
dir: string,
relativePath = ''
): string[] {
const files: string[] = []
const items = readdirSync(dir, { withFileTypes: true })
for (const item of items) {
const fullPath = join(dir, item.name)
const itemRelativePath = join(relativePath, item.name)
if (item.isDirectory()) {
files.push(...findClientReferenceManifests(fullPath, itemRelativePath))
} else if (item.name.endsWith(`_${CLIENT_REFERENCE_MANIFEST}.js`)) {
files.push(fullPath)
}
}
return files
}
const manifestFiles = findClientReferenceManifests(serverAppPath)
for (const manifestFile of manifestFiles) {
try {
// Read and parse the client reference manifest
const content = readFileSync(manifestFile, 'utf8')
// Extract the route from the global assignment
const routeMatch = content.match(
/globalThis\.__RSC_MANIFEST\["([^"]+)"\]\s*=\s*({.*})/
)
if (!routeMatch) continue
const route = routeMatch[1]
const manifestDataStr = routeMatch[2]
// Parse the manifest data
const manifestData: ClientReferenceManifest = JSON.parse(manifestDataStr)
// Collect all chunks from client modules
const chunks = new Set<string>()
// Add chunks from client modules (these are the RSC client dependencies)
// This is the key data - what client-side JS actually needs to be loaded
for (const moduleInfo of Object.values(manifestData.clientModules)) {
for (const chunk of moduleInfo.chunks) {
chunks.add(chunk)
allFiles.add(chunk)
}
}
// Add CSS files if they exist
if (manifestData.entryCSSFiles) {
for (const cssFiles of Object.values(manifestData.entryCSSFiles)) {
for (const cssFile of cssFiles) {
chunks.add(cssFile.path)
allFiles.add(cssFile.path)
}
}
}
// Store the route with all its required chunks
manifest.pages[route] = Array.from(chunks).sort()
} catch (error) {
// Skip malformed manifest files
console.warn(
`Failed to parse client reference manifest: ${manifestFile}`,
error
)
continue
}
}
// Sort route keys to match turbopack behavior
const sortedPages: Record<string, string[]> = {}
Object.keys(manifest.pages)
.sort()
.forEach((key) => {
sortedPages[key] = manifest.pages[key]
})
manifest.pages = sortedPages
return manifest
}
/**
* Get all unique files referenced across client reference manifests
* Useful for analysis and debugging
*/
export function getAllReferencedFiles(distPath: string): Set<string> {
const manifest = computeAppBuildManifestFromClientReferences(distPath)
const allFiles = new Set<string>()
for (const files of Object.values(manifest.pages)) {
for (const file of files) {
allFiles.add(file)
}
}
return allFiles
}
import type { NextConfigComplete } from '../server/config-shared'
import type { ExperimentalPPRConfig } from '../server/lib/experimental/ppr'
import type { AppBuildManifest } from './webpack/plugins/app-build-manifest-plugin'
import { computeAppBuildManifestFromClientReferences } from './client-reference-manifest-utils'
import type { AssetBinding } from './webpack/loaders/get-module-build-info'
import type { PageConfig, ServerRuntime } from '../types'
import type { BuildManifest } from '../server/get-page-files'
......@@ -222,13 +223,18 @@ export async function computeFromManifest(
countBuildFiles(files.pages.each, key, manifests.build.pages)
}
// Collect the build files form the app manifest.
if (manifests.app?.pages) {
// Collect the build files from client reference manifests.
// This provides accurate client-side bundle information for App Router
// including React Server Component client dependencies.
const clientReferenceManifest =
computeAppBuildManifestFromClientReferences(distPath)
if (Object.keys(clientReferenceManifest.pages).length > 0) {
files.app = { each: new Map<string, number>(), expected: 0 }
for (const key in manifests.app.pages) {
for (const key in clientReferenceManifest.pages) {
files.app.expected++
countBuildFiles(files.app.each, key, manifests.app.pages)
countBuildFiles(files.app.each, key, clientReferenceManifest.pages)
}
}
......
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