@wular/pnext 0.0.19 → 0.0.21

package/src/runtime/modules.ts

@@ -19,6 +19,7 @@ import { noteModuleGeneration, noteModuleImported } from './module-generations'
 import {
   rewriteServerSource,
   serverBundleTargetForRuntime,
+  serverBundleConditions,
   serverBundleRequireConditions,
   type ServerBundleTarget,
 } from './loader'
@@ -350,6 +351,59 @@ function graphEdges(config: ResolvedConfig, file: string, source: string) {
   return { imports, packages, client: hasUseClientDirective(source) }
 }
 
+/**
+ * No build ever waits for another build. Compiling a module needs its imports' artifact PATHS, which
+ * are a pure function of the source graph - never their bytes - so a compile registers what it
+ * reaches and moves on. That removes the deadlock class outright: real app graphs are cyclic, and any
+ * scheme where one build awaits another lets two of them each hold what the other needs, which stalls
+ * the request with no error until the socket idles out.
+ *
+ * The one real requirement is temporal and belongs at the boundary: no href may reach `import()`
+ * before everything reachable from it is on disk. An entry therefore waits for quiescence, not for a
+ * closure it can compute: with parents no longer written after their children, an artifact already on
+ * disk says nothing about its imports, so "what this entry reached" is not a set anyone can name.
+ *
+ * The wait runs off an append-only log rather than the in-flight map, so a build that starts AND
+ * settles between two looks is still waited on - and its failure still reaches the caller instead of
+ * disappearing with the map entry.
+ *
+ * Waiting is global; FAILING is not. An entry only rethrows for builds its own walk started or
+ * joined, so one request's broken module cannot 500 an unrelated request that merely overlapped it.
+ */
+const buildLog: Promise<string>[] = []
+const walkBuilds = new WeakMap<Set<string>, Set<Promise<string>>>()
+let drainsActive = 0
+
+/** The builds this walk owns - keyed on the walk's own `visited` set, which already identifies it. */
+function ownedBuilds(visited: Set<string>) {
+  let owned = walkBuilds.get(visited)
+  if (!owned) {
+    owned = new Set()
+    walkBuilds.set(visited, owned)
+  }
+  return owned
+}
+
+function registerBuild(build: Promise<string>) {
+  buildLog.push(build)
+}
+
+async function drainModuleBuilds(visited: Set<string>) {
+  drainsActive += 1
+  try {
+    for (let index = 0; index < buildLog.length;) {
+      const pending = buildLog.slice(index)
+      index = buildLog.length
+      await Promise.allSettled(pending)
+    }
+    await Promise.all([...(walkBuilds.get(visited) ?? [])])
+  } finally {
+    drainsActive -= 1
+    // Nothing in flight and nobody mid-drain: the log has served its purpose and can go.
+    if (drainsActive === 0 && moduleBuilds.size === 0) buildLog.length = 0
+  }
+}
+
 function withBuildSlot<T>(task: () => Promise<T>): Promise<T> {
   return new Promise<T>((resolve, reject) => {
     const run = () => {
@@ -395,21 +449,27 @@ export async function devServerModuleHref(
   const reactServerLayer =
     moduleOptions.reactServerLayer ?? (conditionTarget === 'server' || conditionTarget === 'edge')
   const release = devModuleGraph(config).hold()
-  const compiled = await writeDevModule(config, file, new Set(), {
-    aliases: {
-      ...coreAliases(config, 'server'),
-      ...(reactServerLayer ? getImportAliasExtensions().reactServerLayerAliases(config) : {}),
-    },
-    profile: reactCompatEnabled(config) ? 'compat' : 'server',
-    conditionTarget,
-    reactServerLayer,
-    externalLoadTarget:
-      moduleOptions.externalLoadTarget ?? externalLoadTargetForConditionTarget(conditionTarget),
-    stubClientImports: reactCompatEnabled(config),
-    rewriteExternalServerImports: true,
-    bundleExternalPackages: reactCompatEnabled(config),
-  }).finally(release)
-  return pathToFileHref(compiled)
+  const visited = new Set<string>()
+  try {
+    const compiled = await writeDevModule(config, file, visited, {
+      aliases: {
+        ...coreAliases(config, 'server'),
+        ...(reactServerLayer ? getImportAliasExtensions().reactServerLayerAliases(config) : {}),
+      },
+      profile: reactCompatEnabled(config) ? 'compat' : 'server',
+      conditionTarget,
+      reactServerLayer,
+      externalLoadTarget:
+        moduleOptions.externalLoadTarget ?? externalLoadTargetForConditionTarget(conditionTarget),
+      stubClientImports: reactCompatEnabled(config),
+      rewriteExternalServerImports: true,
+      bundleExternalPackages: reactCompatEnabled(config),
+    })
+    await drainModuleBuilds(visited)
+    return pathToFileHref(compiled)
+  } finally {
+    release()
+  }
 }
 
 export async function devClientModuleHref(
@@ -422,13 +482,19 @@ export async function devClientModuleHref(
   const throughPackage = await packageClientModuleHref(config, file, conditionTarget)
   if (throughPackage) return throughPackage
   const release = devModuleGraph(config).hold()
-  const compiled = await writeDevModule(
-    config,
-    file,
-    new Set(),
-    clientLayerOptions(config, conditionTarget),
-  ).finally(release)
-  return pathToFileHref(compiled)
+  const visited = new Set<string>()
+  try {
+    const compiled = await writeDevModule(
+      config,
+      file,
+      visited,
+      clientLayerOptions(config, conditionTarget),
+    )
+    await drainModuleBuilds(visited)
+    return pathToFileHref(compiled)
+  } finally {
+    release()
+  }
 }
 
 /**
@@ -1056,8 +1122,14 @@ async function writeDevModule(
   // the life of the process.
   if (devArtifactUsable(outFile)) return outFile
 
-  const existing = moduleBuilds.get(outFile)
-  if (existing) return existing
+  // Already being built: its artifact path is all this caller needs, and the entry's drain is what
+  // waits for the bytes. Awaiting it here is what used to deadlock two walks meeting a cycle. The
+  // walk still OWNS it - its graph names that artifact, so its failure is this entry's failure.
+  const inFlight = moduleBuilds.get(outFile)
+  if (inFlight) {
+    ownedBuilds(visited).add(inFlight)
+    return outFile
+  }
 
   visited.add(visitedKey)
   const started = moduleStats ? performance.now() : 0
@@ -1073,15 +1145,16 @@ async function writeDevModule(
       }
       return result
     })
-    .catch(error => {
-      moduleBuilds.delete(outFile)
-      throw error
-    })
     .finally(() => {
-      moduleBuilds.delete(outFile)
+      // Identity-guarded: a rebuild may already have claimed this path.
+      if (moduleBuilds.get(outFile) === next) moduleBuilds.delete(outFile)
     })
+  // Only a drain consumes the rejection; this keeps it from surfacing as an unhandled one meanwhile.
+  next.catch(() => undefined)
+  registerBuild(next)
+  ownedBuilds(visited).add(next)
   moduleBuilds.set(outFile, next)
-  return next
+  return outFile
 }
 
 async function writeDevModuleUncached(
@@ -1160,15 +1233,16 @@ async function writeDevModuleUncached(
     !hasUseClientDirective(shakenSource)
       ? await writeClientReferenceModules(shakenSource, config, file, effectiveOptions.aliases)
       : { specifiers: new Map<string, string>(), files: new Set<string>() }
-  // Compiling this module only needs its imports' *paths*, so it runs while the
-  // targets themselves compile. The write still waits for them: a compiled
-  // module must never become loadable before its edges exist on disk.
+  // Compiling this module only needs its imports' *paths*, so it runs while the targets themselves
+  // compile. Registering the edges is all this awaits; drainModuleBuilds is what holds an href back
+  // until they are on disk.
   const compiled = buildDevModuleSource(
     shakenSource,
     config,
     file,
     clientReferences.specifiers,
     effectiveOptions,
+    visited,
   )
   // The real rejection is reported below; this only keeps it from surfacing as
   // an unhandled rejection while the imports compile.
@@ -1290,8 +1364,7 @@ async function writeShakenDynamicModule(
   if (devArtifactUsable(outFile)) return outFile
 
   const key = `shake\0${outFile}`
-  const existing = moduleBuilds.get(key)
-  if (existing) return existing
+  if (moduleBuilds.has(key)) return outFile
 
   const next = writeShakenDynamicModuleUncached(
     config,
@@ -1300,16 +1373,13 @@ async function writeShakenDynamicModule(
     visited,
     options,
     outFile,
-  )
-    .catch(error => {
-      moduleBuilds.delete(key)
-      throw error
-    })
-    .finally(() => {
-      moduleBuilds.delete(key)
-    })
+  ).finally(() => {
+    if (moduleBuilds.get(key) === next) moduleBuilds.delete(key)
+  })
+  next.catch(() => undefined)
+  registerBuild(next)
   moduleBuilds.set(key, next)
-  return next
+  return outFile
 }
 
 async function writeShakenDynamicModuleUncached(
@@ -1336,32 +1406,37 @@ async function writeShakenDynamicModuleUncached(
       .map(({ target }) => writeDevModule(config, target, visited, options)),
   )
   const externalBundles = await externalBundleSpecifiers(targetSource, config, targetFile, options)
-  const result = await withBuildSlot(() =>
-    build({
-      stdin: {
-        contents: shakenEntrySource(usedExports),
-        loader: 'js',
-        resolveDir: path.dirname(targetFile),
-        sourcefile: `${targetFile}.pnext-shake`,
-      },
-      bundle: true,
-      write: false,
-      format: 'esm',
-      platform: 'neutral',
-      target: 'es2022',
-      jsx: 'automatic',
-      jsxImportSource: 'preact',
-      packages: 'external',
-      logLevel: 'silent',
-      ...serverDefineOptions(),
-      plugins: [
-        shakeEntryPlugin(targetFile, targetSource),
-        serverAssetPlugin(config),
-        ...getBundlerExtensions().serverEsbuildPlugins(config),
-        devModuleResolvePlugin(config, targetFile, new Map(), externalBundles, options),
-      ],
-    }),
-  )
+  const shake = () =>
+    withBuildSlot(() =>
+      build({
+        stdin: {
+          contents: shakenEntrySource(usedExports),
+          loader: 'js',
+          resolveDir: path.dirname(targetFile),
+          sourcefile: `${targetFile}.pnext-shake`,
+        },
+        bundle: true,
+        write: false,
+        format: 'esm',
+        platform: 'neutral',
+        target: 'es2022',
+        jsx: 'automatic',
+        jsxImportSource: 'preact',
+        packages: 'external',
+        logLevel: 'silent',
+        ...serverDefineOptions(),
+        plugins: [
+          shakeEntryPlugin(targetFile, targetSource),
+          serverAssetPlugin(config),
+          ...getBundlerExtensions().serverEsbuildPlugins(config),
+          devModuleResolvePlugin(config, targetFile, new Map(), externalBundles, options, visited),
+        ],
+      }),
+    )
+  // The facade inlines the target outright, so its package imports are always late ones. Same shape
+  // as buildDevModuleSource: vendor off the slot, then shake again, to a fixpoint.
+  let result = await shake()
+  while (await vendorLateExternalPackages(config, options, externalBundles)) result = await shake()
   const output = result.outputFiles[0]
   if (!output) throw new Error(`Failed to tree-shake ${targetFile}`)
   await writeCompiledFile(outFile, addExtensionlessDynamicImportGlobAliases(output.text))
@@ -1460,8 +1535,48 @@ async function buildDevModuleSource(
   file: string,
   clientReferenceSpecifiers: Map<string, string>,
   options: DevModuleOptions,
+  visited: Set<string>,
 ) {
   const externalBundles = await externalBundleSpecifiers(source, config, file, options)
+  let compiled = await compileDevModuleSource(
+    source,
+    config,
+    file,
+    clientReferenceSpecifiers,
+    externalBundles,
+    options,
+    visited,
+  )
+  // Vendoring for a specifier only an INLINED module asked for happens here - between compiles, with
+  // no build slot held - and the module is compiled again with the map filled in. Doing it from the
+  // resolve callback instead would hold a slot for the length of a vendor build.
+  //
+  // To a FIXPOINT, not once: vendoring a specifier changes what the next compile inlines, so round N
+  // can expose a package round N-1 never saw. It terminates because every round records at least one
+  // new key in `externalBundles` and a recorded specifier is never noted again.
+  while (await vendorLateExternalPackages(config, options, externalBundles)) {
+    compiled = await compileDevModuleSource(
+      source,
+      config,
+      file,
+      clientReferenceSpecifiers,
+      externalBundles,
+      options,
+      visited,
+    )
+  }
+  return compiled
+}
+
+async function compileDevModuleSource(
+  source: string,
+  config: ResolvedConfig,
+  file: string,
+  clientReferenceSpecifiers: Map<string, string>,
+  externalBundles: Map<string, string>,
+  options: DevModuleOptions,
+  visited: Set<string>,
+) {
   const transformed = await transformDevModuleSource(
     source,
     config,
@@ -1469,6 +1584,7 @@ async function buildDevModuleSource(
     clientReferenceSpecifiers,
     externalBundles,
     options,
+    visited,
   )
   if (transformed !== undefined) return transformed
   if (moduleStats) esbuildFallbacks.add(`${devModuleProfile(options)}:${file}`)
@@ -1497,7 +1613,14 @@ async function buildDevModuleSource(
         serverAssetPlugin(config),
         ...getBundlerExtensions().serverEsbuildPlugins(config),
         serverClientReferencePlugin(config, options),
-        devModuleResolvePlugin(config, file, clientReferenceSpecifiers, externalBundles, options),
+        devModuleResolvePlugin(
+          config,
+          file,
+          clientReferenceSpecifiers,
+          externalBundles,
+          options,
+          visited,
+        ),
       ],
     }),
   )
@@ -1522,6 +1645,7 @@ async function transformDevModuleSource(
   clientReferenceSpecifiers: Map<string, string>,
   externalBundles: Map<string, string>,
   options: DevModuleOptions,
+  visited: Set<string>,
 ): Promise<string | undefined> {
   // Kill switch: puts every module back on the esbuild build below, for
   // bisecting a suspected transform-path difference.
@@ -1542,6 +1666,7 @@ async function transformDevModuleSource(
       clientReferenceSpecifiers,
       externalBundles,
       options,
+      visited,
     )
     if (target === undefined) return undefined
     if (target !== found.value)
@@ -1563,6 +1688,7 @@ async function devModuleSpecifierTarget(
   clientReferenceSpecifiers: Map<string, string>,
   externalBundles: Map<string, string>,
   options: DevModuleOptions,
+  visited: Set<string>,
 ): Promise<string | undefined> {
   // Same claim `serverAssetPlugin` makes, and in the same order: it is the first
   // onResolve in the build below.
@@ -1583,6 +1709,7 @@ async function devModuleSpecifierTarget(
     options,
     kind,
     file,
+    visited,
   )
   // A non-external result names a namespace the bundler loads inline
   // (`pnext-module-external` facades) or a bare require-alias path.
@@ -1633,6 +1760,7 @@ function devModuleResolvePlugin(
   clientReferenceSpecifiers: Map<string, string>,
   externalBundles: Map<string, string>,
   options: DevModuleOptions,
+  visited: Set<string>,
 ): Plugin {
   return {
     name: 'pnext-dev-module-resolve',
@@ -1648,6 +1776,7 @@ function devModuleResolvePlugin(
           options,
           args.kind,
           args.importer,
+          visited,
         ),
       )
     },
@@ -1719,6 +1848,7 @@ async function resolveDevModuleSpecifier(
   options: DevModuleOptions,
   kind: string,
   importer: string,
+  visited: Set<string>,
 ): Promise<OnResolveResult> {
   // An already-resolved `file://` href is a compiled module on disk; pass it straight through as
   // external instead of re-resolving it. But a file:// href naming a RAW 'use client' source
@@ -1790,6 +1920,12 @@ async function resolveDevModuleSpecifier(
   }
 
   const externalBundle = externalBundles.get(sourcePath)
+  // A miss here is a specifier the pre-compile scan could not have seen (its importer was inlined).
+  // Note it and fall through to the bare-specifier path for THIS compile; the caller vendors it off
+  // the build slot and compiles once more with the map filled in.
+  if (externalBundle === undefined) {
+    noteLateExternalPackage(sourcePath, config, file, importer, options, externalBundles)
+  }
   if (externalBundle && kind === 'require-call') {
     const required = resolvePackageSpecifier(
       config.root,
@@ -1852,12 +1988,12 @@ async function resolveDevModuleSpecifier(
     }
     const externalTarget =
       resolvedExternalLoad ?? externalPackageImportTarget(config.root, file, sourcePath)
+    if (externalTarget) return { path: `${pathToFileHref(externalTarget)}${hash}`, external: true }
+    if (options.rewriteExternalServerImports) {
+      return { path: runtimeServerImportTarget(specifier), external: true }
+    }
     return {
-      path: externalTarget
-        ? `${pathToFileHref(externalTarget)}${hash}`
-        : options.rewriteExternalServerImports
-          ? runtimeServerImportTarget(specifier)
-          : specifier,
+      path: `${offLayerPackageTarget(config, file, sourcePath, kind, options)}${hash}`,
       external: true,
     }
   }
@@ -1909,7 +2045,7 @@ async function resolveDevModuleSpecifier(
     // pointing at the raw source instead would load a SECOND copy of the compat runtime graph and split its
     // module state. writeDevModule dedupes in-flight builds per artifact path, so a module reached from
     // several bundled importers is compiled once.
-    await writeDevModule(config, resolved, new Set(), options)
+    await writeDevModule(config, resolved, visited, options)
   }
   return {
     path: `${pathToFileHref(await devModulePath(config, resolved, options))}${hash}`,
@@ -1917,6 +2053,53 @@ async function resolveDevModuleSpecifier(
   }
 }
 
+/**
+ * THE LAYER RULE. An artifact whose imports the dev PROCESS resolves - anything not rewritten to a
+ * runtime server target - must not carry a bare package specifier, because the process runs under
+ * `--conditions=react-server` and the client-SSR (and pages-SSR) layers are not that layer: `react`
+ * resolves to React 18's `react.shared-subset`, which throws on import, and a package with a
+ * `react-server` export condition hands back its RSC entry.
+ *
+ * Vendoring is the primary answer and has already run for everything eligible (it also rewrites the
+ * package's OWN `react` to this layer's shim). This is the floor beneath it, for the specifiers
+ * vendoring declines - a `serverExternalPackages` opt-out, a core app with react compat off: resolve
+ * the specifier HERE, under this layer's own conditions, and emit that absolute path. Costs nothing
+ * at run time and adds no bytes - it is the same file, named instead of re-resolved.
+ *
+ * A specifier that resolves under NO condition set is left bare: it is unresolvable from this
+ * importer, so the run time reports a resolve error rather than the wrong layer's module.
+ */
+function offLayerPackageTarget(
+  config: ResolvedConfig,
+  file: string,
+  specifier: string,
+  kind: string,
+  options: DevModuleOptions,
+) {
+  if (!isPackageSpecifier(specifier)) return specifier
+  const isRequire = kind === 'require-call'
+  const resolved =
+    resolvePackageSpecifier(
+      config.root,
+      file,
+      specifier,
+      isRequire
+        ? serverBundleRequireConditions(options.conditionTarget)
+        : serverBundleConditions(options.conditionTarget),
+    ) ??
+    resolvePackageSpecifier(
+      config.root,
+      file,
+      specifier,
+      isRequire
+        ? serverBundleConditions(options.conditionTarget)
+        : serverBundleRequireConditions(options.conditionTarget),
+    )
+  if (!resolved) return specifier
+  // `require()` takes a path; only an ESM import takes a file href.
+  return isRequire ? resolved : pathToFileHref(resolved)
+}
+
 function serverRequireAlias(specifier: string, alias: string, options: DevModuleOptions) {
   if (options.conditionTarget === 'client') return alias
   if (specifier === 'next/navigation' && alias.endsWith(`${path.sep}navigation.ts`)) {
@@ -2075,6 +2258,79 @@ async function externalBundleSpecifiers(
   return bundles
 }
 
+// Specifiers one compile asked for and the pre-compile scan had not vendored, keyed on that compile's
+// own `externalBundles` map - already threaded everywhere they are recorded and drained, so nothing
+// new rides through the resolve chain. Value is the importer the specifier resolves from.
+const lateExternalPackages = new WeakMap<Map<string, string>, Map<string, string>>()
+
+/**
+ * Record a package specifier `externalBundleSpecifiers` never saw. That scan reads the compiled
+ * module's OWN source, so a specifier reaching this build from a module esbuild INLINED instead (a
+ * require()d ESM sibling, a bundled compat importer) is missing from the map, and left alone it
+ * survives verbatim into the artifact - where Bun resolves it from the real node_modules under the
+ * server process's own `react-server` condition, and a client-only subtree (MUI -> emotion -> react)
+ * reaches React 18's shared-subset entry and throws.
+ *
+ * Synchronous, and deliberately so. This runs inside esbuild's onResolve, which holds a build slot:
+ * awaiting a vendor bundle here parks one of the few slots for however long that build takes and
+ * heads off every queued module compile behind it. Nothing on this path may await a vendor build, a
+ * module href, or a drain - `vendorLateExternalPackages` does the waiting, between compiles, with no
+ * slot held.
+ */
+function noteLateExternalPackage(
+  specifier: string,
+  config: ResolvedConfig,
+  file: string,
+  importer: string,
+  options: DevModuleOptions,
+  externalBundles: Map<string, string>,
+) {
+  if (!options.bundleExternalPackages) return
+  if (isServerIgnoredAssetSpecifier(specifier)) return
+  const fromFile =
+    importer && !importer.startsWith('<') && path.isAbsolute(importer) ? importer : file
+  if (!shouldBundleExternalPackage(specifier, config, fromFile, options)) return
+  let pending = lateExternalPackages.get(externalBundles)
+  if (!pending) {
+    pending = new Map<string, string>()
+    lateExternalPackages.set(externalBundles, pending)
+  }
+  pending.set(specifier, fromFile)
+}
+
+/**
+ * Vendor what the compile just recorded and fold it into its map, so recompiling rewrites those
+ * specifiers. False when there was nothing to do, which is the overwhelming majority of modules.
+ *
+ * Failures propagate, exactly as they do from the pre-compile scan: the only other outcome is
+ * emitting the bare specifier, which is the runtime `react-server` resolution this seam exists to
+ * prevent - so a swallowed vendor error would silently reproduce the bug it is fixing.
+ */
+async function vendorLateExternalPackages(
+  config: ResolvedConfig,
+  options: DevModuleOptions,
+  externalBundles: Map<string, string>,
+) {
+  const pending = lateExternalPackages.get(externalBundles)
+  if (!pending || pending.size === 0) return false
+  lateExternalPackages.delete(externalBundles)
+  await Promise.all(
+    [...pending].map(async ([specifier, fromFile]) => {
+      externalBundles.set(
+        specifier,
+        await externalServerPackageHref(
+          config,
+          specifier,
+          options.profile === 'client' ? 'client' : 'server',
+          path.dirname(fromFile),
+          options.conditionTarget,
+        ),
+      )
+    }),
+  )
+  return true
+}
+
 function shouldBundleExternalPackage(
   specifier: string,
   config: ResolvedConfig,

package/src/runtime/vendor-build.ts

@@ -26,7 +26,13 @@ import {
   type ServerEsbuildPluginOptions,
 } from '../extensions'
 import { pathToFileHref, type CompatAliasTarget, type ResolvedConfig } from '../config'
-import { devArtifactUsable, devSourceIdentity, noteDevArtifactWritten } from './module-cache'
+import {
+  cacheRoot,
+  devArtifactUsable,
+  devSourceIdentity,
+  noteDevArtifactWritten,
+} from './module-cache'
+import { frameworkFingerprint } from './fingerprint'
 import {
   getExternalPackagePolicy,
   isEsmModuleEntry,
@@ -169,9 +175,21 @@ function vendorArtifactKey(
   conditionTarget: ServerBundleTarget,
   source: string,
 ) {
-  return `${vendorPortablePath(config, config.outPath)}\0${target}\0${conditionTarget}\0${source}`
+  return `${vendorGeneration(config)}\0${vendorPortablePath(config, config.outPath)}\0${target}\0${conditionTarget}\0${source}`
 }
 
+/**
+ * pnext's generation, in every name the vendor cache derives. A vendor bundle is pnext's OWN output
+ * - its CJS interop, its aliases, its defines - so one generation's bundle must never be handed to
+ * the next, exactly as the module cache already refuses one. The same holds for the verdict stores
+ * below, which decide that a demand needs no build at all: a verdict is framework logic, and a
+ * stale one routes today's demand onto yesterday's bytes.
+ *
+ * The fingerprint is content over pnext's shipped tree, memoized per process and recorded next to
+ * the module cache, so an app whose framework did not move keeps every warm hit for free.
+ */
+const vendorGeneration = (config: ResolvedConfig) => frameworkFingerprint(cacheRoot(config.outPath))
+
 const vendorPortablePath = (config: ResolvedConfig, file: string) =>
   devSourceIdentity(file, config.workspaceRoot)
 
@@ -331,7 +349,18 @@ function vendorLayerKey(target: CompatAliasTarget, conditionTarget: ServerBundle
 }
 
 function vendorSharedFile(config: ResolvedConfig) {
-  return path.join(config.outPath, 'cache', 'server', 'vendor', 'layer-shared.json')
+  return vendorStoreFile(config, 'layer-shared')
+}
+
+/** A vendor verdict store, named for the generation whose logic produced it. */
+function vendorStoreFile(config: ResolvedConfig, name: string) {
+  return path.join(
+    config.outPath,
+    'cache',
+    'server',
+    'vendor',
+    `${name}.${vendorGeneration(config)}.json`,
+  )
 }
 
 /** Verdicts from earlier runs, so reuse lands on the first demand of this one. */
@@ -459,7 +488,7 @@ const vendorReuseLoaded = new Set<string>()
 const vendorReuseProbes = new Map<string, Promise<boolean>>()
 
 function vendorReuseFile(config: ResolvedConfig) {
-  return path.join(config.outPath, 'cache', 'server', 'vendor', 'reuse-verdicts.json')
+  return vendorStoreFile(config, 'reuse-verdicts')
 }
 
 function vendorReuseFor(config: ResolvedConfig) {
@@ -754,7 +783,7 @@ function schedulePreplanReport() {
 }
 
 function vendorPreplanFile(config: ResolvedConfig) {
-  return path.join(config.outPath, 'cache', 'server', 'vendor', 'preplan-verdicts.json')
+  return vendorStoreFile(config, 'preplan-verdicts')
 }
 
 function vendorPreplanFor(config: ResolvedConfig) {