feat(rsc): implement manifest-based viteRsc.import for custom entryFileNames

Replace hardcoded output filenames with a manifest approach that supports
custom entryFileNames config. The manifest uses static import functions
for proper bundler analysis.

Changes:
- Transform emits manifest lookup instead of markers
- resolveId marks manifest as external during build
- generateBundle tracks resolvedId → outputFileName mapping
- writeEnvironmentImportsManifest generates manifest after all builds
- Split entry injection for bidirectional support (RSC↔SSR)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: hi-ogawa

packages/plugin-rsc/docs/notes/2026-01-16-vitersc-import.md

@@ -281,8 +281,7 @@ Transform emits manifest lookup:
 ```ts
 // Original:
 await import.meta.viteRsc
-  .import('./entry.ssr', { environment: 'ssr' })
-  (
+  .import('./entry.ssr', { environment: 'ssr' })(
     // Build transform to:
     await import('./__vite_rsc_env_imports_manifest.js'),
   )
@@ -439,12 +438,12 @@ export default {
 2. [x] Clean up `import-environment.ts`: add imports, parameterize with manager
 3. [x] Implement transform to discover and track imports
 4. [x] Inject discovered entries into target environment's input
-5. [ ] **Fix**: Move entry injection to AFTER both scans (currently after RSC scan only)
-6. [ ] Update transform to emit manifest lookup (build mode)
-7. [ ] Remove renderChunk marker replacement
-8. [ ] Add `environmentImportOutputMap` to track resolvedId → outputFileName
-9. [ ] Add generateBundle hook to populate output map (in both RSC and SSR)
-10. [ ] Add `writeEnvironmentImportsManifest` in buildApp (per source environment)
-11. [ ] Test with basic example (RSC → SSR)
+5. [x] Split entry injection: after RSC scan (RSC → other), after SSR scan (SSR → other)
+6. [x] Update transform to emit manifest lookup (build mode)
+7. [x] Remove renderChunk marker replacement, add resolveId to mark manifest as external
+8. [x] Add `environmentImportOutputMap` to track resolvedId → outputFileName
+9. [x] Add generateBundle hook to populate output map (in both RSC and SSR)
+10. [x] Add `writeEnvironmentImportsManifest` in buildApp (per source environment)
+11. [x] Test with basic example (RSC → SSR) - all 38 starter tests pass
 12. [ ] Test bidirectional (SSR → RSC) if applicable
 13. [ ] Update documentation

packages/plugin-rsc/src/plugin.ts

@@ -27,7 +27,10 @@ import { crawlFrameworkPkgs } from 'vitefu'
 import vitePluginRscCore from './core/plugin'
 import { cjsModuleRunnerPlugin } from './plugins/cjs'
 import { vitePluginFindSourceMapURL } from './plugins/find-source-map-url'
-import { vitePluginImportEnvironment } from './plugins/import-environment'
+import {
+  ENV_IMPORTS_MANIFEST_NAME,
+  vitePluginImportEnvironment,
+} from './plugins/import-environment'
 import {
   vitePluginResolvedIdProxy,
   withResolvedIdProxy,
@@ -131,6 +134,8 @@ class RscPluginManager {
       entryName: string
     }
   > = {}
+  // Maps resolvedId to output fileName (populated in generateBundle)
+  environmentImportOutputMap: Record<string, string> = {}
 
   stabilize(): void {
     // sort for stable build
@@ -156,6 +161,47 @@ class RscPluginManager {
       fs.writeFileSync(manifestPath, assetsManifestCode)
     }
   }
+
+  writeEnvironmentImportsManifest(): void {
+    if (Object.keys(this.environmentImportMetaMap).length === 0) {
+      return
+    }
+
+    // Group imports by source environment
+    const bySourceEnv: Record<string, typeof this.environmentImportMetaMap> = {}
+    for (const [resolvedId, meta] of Object.entries(
+      this.environmentImportMetaMap,
+    )) {
+      bySourceEnv[meta.sourceEnv] ??= {}
+      bySourceEnv[meta.sourceEnv]![resolvedId] = meta
+    }
+
+    // Write manifest to each source environment's output
+    for (const [sourceEnv, imports] of Object.entries(bySourceEnv)) {
+      const sourceOutDir = this.config.environments[sourceEnv]!.build.outDir
+      const manifestPath = path.join(sourceOutDir, ENV_IMPORTS_MANIFEST_NAME)
+
+      let code = 'export default {\n'
+      for (const [resolvedId, meta] of Object.entries(imports)) {
+        const outputFileName = this.environmentImportOutputMap[resolvedId]
+        if (!outputFileName) {
+          console.warn(
+            `[vite-rsc] missing output for environment import: ${resolvedId}`,
+          )
+          continue
+        }
+        const targetOutDir =
+          this.config.environments[meta.targetEnv]!.build.outDir
+        const relativePath = normalizeRelativePath(
+          path.relative(sourceOutDir, path.join(targetOutDir, outputFileName)),
+        )
+        code += `  ${JSON.stringify(resolvedId)}: () => import(${JSON.stringify(relativePath)}),\n`
+      }
+      code += '}\n'
+
+      fs.writeFileSync(manifestPath, code)
+    }
+  }
 }
 
 export type RscPluginOptions = {
@@ -381,6 +427,7 @@ export default function vitePluginRsc(
       logStep('[4/4] build client environment...')
       await builder.build(builder.environments.client!)
       manager.writeAssetsManifest(['rsc'])
+      manager.writeEnvironmentImportsManifest()
       return
     }
 
@@ -412,8 +459,9 @@ export default function vitePluginRsc(
     logStep('[1/5] analyze client references...')
     await builder.build(builder.environments.rsc!)
 
-    // Inject discovered environment imports into target environment's input
-    // This must happen after RSC scan discovers them
+    // TODO: let's configuere dummy input e.g. __vite_rsc_xxx: "virtual:..."
+    // Inject RSC → other environment imports discovered during RSC scan
+    // This must happen before SSR scan so SSR has input
     for (const meta of Object.values(manager.environmentImportMetaMap)) {
       const targetEnv = builder.environments[meta.targetEnv]
       if (targetEnv) {
@@ -425,14 +473,32 @@ export default function vitePluginRsc(
       }
     }
 
-    if (
-      hasSsrInput ||
-      Object.keys(manager.environmentImportMetaMap).length > 0
-    ) {
+    // Check if we need SSR scan (has input or discovered imports targeting SSR)
+    // TODO: no need of optimization yet. just leave it as future follow TODO.
+    const ssrInputAfterRsc = builder.environments.ssr!.config.build
+      .rollupOptions.input as Record<string, string> | undefined
+    const hasSsrInputAfterRsc =
+      ssrInputAfterRsc && Object.keys(ssrInputAfterRsc).length > 0
+
+    if (hasSsrInput || hasSsrInputAfterRsc) {
       builder.environments.ssr!.config.build.write = false
       logStep('[2/5] analyze server references...')
       await builder.build(builder.environments.ssr!)
+
+      // Inject SSR → other environment imports discovered during SSR scan
+      // (for bidirectional support)
+      for (const meta of Object.values(manager.environmentImportMetaMap)) {
+        const targetEnv = builder.environments[meta.targetEnv]
+        if (targetEnv) {
+          const input = (targetEnv.config.build.rollupOptions.input ??=
+            {}) as Record<string, string>
+          if (!(meta.entryName in input)) {
+            input[meta.entryName] = meta.resolvedId
+          }
+        }
+      }
     }
+
     manager.isScanBuild = false
     builder.environments.rsc!.config.build.write = true
     builder.environments.ssr!.config.build.write = true
@@ -465,6 +531,7 @@ export default function vitePluginRsc(
     }
 
     manager.writeAssetsManifest(['ssr', 'rsc'])
+    manager.writeEnvironmentImportsManifest()
   }
 
   let hasReactServerDomWebpack = false

packages/plugin-rsc/src/plugins/import-environment.ts

@@ -3,9 +3,10 @@ import path from 'node:path'
 import MagicString from 'magic-string'
 import { stripLiteral } from 'strip-literal'
 import type { Plugin, ResolvedConfig, ViteDevServer } from 'vite'
-import { normalizeRelativePath } from './utils'
 import { evalValue } from './vite-utils'
 
+export const ENV_IMPORTS_MANIFEST_NAME = '__vite_rsc_env_imports_manifest.js'
+
 export type EnvironmentImportMeta = {
   resolvedId: string
   targetEnv: string
@@ -18,12 +19,23 @@ interface PluginManager {
   server: ViteDevServer
   config: ResolvedConfig
   environmentImportMetaMap: Record<string, EnvironmentImportMeta>
+  environmentImportOutputMap: Record<string, string>
 }
 
 export function vitePluginImportEnvironment(manager: PluginManager): Plugin[] {
   return [
     {
       name: 'rsc:import-environment',
+      resolveId(source) {
+        // Mark manifest imports as external during build
+        // The actual file is generated in buildApp after all builds complete
+        if (
+          this.environment.mode === 'build' &&
+          source.endsWith(ENV_IMPORTS_MANIFEST_NAME)
+        ) {
+          return { id: './' + ENV_IMPORTS_MANIFEST_NAME, external: true }
+        }
+      },
       transform: {
         async handler(code, id) {
           if (!code.includes('import.meta.viteRsc.import')) return
@@ -93,16 +105,9 @@ export function vitePluginImportEnvironment(manager: PluginManager): Plugin[] {
             if (this.environment.mode === 'dev') {
               replacement = `globalThis.__VITE_ENVIRONMENT_RUNNER_IMPORT__(${JSON.stringify(environmentName)}, ${JSON.stringify(resolvedId)})`
             } else {
-              // Build: emit marker that will be resolved in renderChunk
-              replacement = JSON.stringify(
-                `__vite_rsc_import_env_start__:` +
-                  JSON.stringify({
-                    fromEnv: this.environment.name,
-                    toEnv: environmentName,
-                    entryName,
-                  }) +
-                  `:__vite_rsc_import_env_end__`,
-              )
+              // Build: emit manifest lookup with static import
+              // The manifest is generated in buildApp after all builds complete
+              replacement = `(await import(${JSON.stringify('./' + ENV_IMPORTS_MANIFEST_NAME)})).default[${JSON.stringify(resolvedId)}]()`
             }
 
             const [start, end] = match.indices![0]!
@@ -118,47 +123,15 @@ export function vitePluginImportEnvironment(manager: PluginManager): Plugin[] {
         },
       },
 
-      renderChunk(code, chunk) {
-        if (!code.includes('__vite_rsc_import_env')) return
-
-        const { config } = manager
-        const s = new MagicString(code)
-
-        for (const match of code.matchAll(
-          /[`'"]__vite_rsc_import_env_start__:([\s\S]*?):__vite_rsc_import_env_end__[`'"]/dg,
-        )) {
-          const markerString = evalValue(match[0])
-          const { fromEnv, toEnv, entryName } = JSON.parse(
-            markerString.slice(
-              '__vite_rsc_import_env_start__:'.length,
-              -':__vite_rsc_import_env_end__'.length,
-            ),
-          )
-
-          const targetFileName = `${entryName}.js`
-          const importPath = normalizeRelativePath(
-            path.relative(
-              path.join(
-                config.environments[fromEnv!]!.build.outDir,
-                chunk.fileName,
-                '..',
-              ),
-              path.join(
-                config.environments[toEnv!]!.build.outDir,
-                targetFileName,
-              ),
-            ),
-          )
-
-          const replacement = `(import(${JSON.stringify(importPath)}))`
-          const [start, end] = match.indices![0]!
-          s.overwrite(start, end, replacement)
-        }
-
-        if (s.hasChanged()) {
-          return {
-            code: s.toString(),
-            map: s.generateMap({ hires: 'boundary' }),
+      generateBundle(_options, bundle) {
+        // Track output filenames for discovered environment imports
+        // This runs in both RSC and SSR builds to capture all outputs
+        for (const [fileName, chunk] of Object.entries(bundle)) {
+          if (chunk.type === 'chunk' && chunk.isEntry && chunk.facadeModuleId) {
+            const resolvedId = chunk.facadeModuleId
+            if (resolvedId in manager.environmentImportMetaMap) {
+              manager.environmentImportOutputMap[resolvedId] = fileName
+            }
           }
         }
       },