fix: evaluate generateStaticParams under react-server condition

packages/rari/src/router/build/evaluate-static-params.ts

@@ -0,0 +1,66 @@
+import { spawn } from 'node:child_process'
+import process from 'node:process'
+import { pathToFileURL } from 'node:url'
+
+const RESOLVE_HOOK = `
+export async function resolve(specifier, context, nextResolve) {
+  if (specifier === "react-server-dom-rari/server") {
+    return nextResolve("rari/runtime/rsc-references", context);
+  }
+  return nextResolve(specifier, context);
+}
+`
+
+export async function evaluateGenerateStaticParams(compiledPath: string): Promise<unknown> {
+  const href = pathToFileURL(compiledPath).href
+  const resolveHookUrl = `data:text/javascript,${encodeURIComponent(RESOLVE_HOOK)}`
+  const script = `
+import { register } from "node:module";
+register(${JSON.stringify(resolveHookUrl)});
+const mod = await import(${JSON.stringify(href)});
+if (typeof mod.generateStaticParams !== "function") {
+  process.stdout.write("null");
+  process.exit(0);
+}
+const params = await mod.generateStaticParams();
+process.stdout.write(JSON.stringify(params ?? null));
+`
+
+  return new Promise((resolve, reject) => {
+    const child = spawn(
+      process.execPath,
+      ['--conditions=react-server', '--input-type=module', '--eval', script],
+      {
+        stdio: ['ignore', 'pipe', 'pipe'],
+        env: process.env,
+      },
+    )
+
+    let stdout = ''
+    let stderr = ''
+    child.stdout.setEncoding('utf8')
+    child.stderr.setEncoding('utf8')
+    child.stdout.on('data', (chunk: string) => {
+      stdout += chunk
+    })
+    child.stderr.on('data', (chunk: string) => {
+      stderr += chunk
+    })
+    child.on('error', reject)
+    child.on('close', code => {
+      if (code !== 0) {
+        reject(new Error(stderr.trim() || `generateStaticParams worker exited with code ${code}`))
+        return
+      }
+      try {
+        resolve(stdout === '' ? null : JSON.parse(stdout))
+      } catch (error) {
+        reject(
+          new Error(
+            `Failed to parse generateStaticParams result: ${error instanceof Error ? error.message : String(error)}`,
+          ),
+        )
+      }
+    })
+  })
+}

packages/rari/src/router/build/props-extractor.ts

@@ -1,4 +1,5 @@
 import { isRecord, isStaticParamsArray, warnInvalidStaticParams } from '@/shared/utils/type-guards'
+import { evaluateGenerateStaticParams } from './evaluate-static-params'
 
 export interface ServerSidePropsResult {
   props: Record<string, any>
@@ -320,14 +321,10 @@ export function mergeMetadata(
 /* v8 ignore start - requires dynamic imports, better tested in integration/e2e */
 export async function extractStaticParams(componentPath: string): Promise<StaticParamsResult> {
   try {
-    const module = await loadComponentModule(componentPath)
-
-    if (typeof module.generateStaticParams === 'function') {
-      const params = await module.generateStaticParams()
-      if (isStaticParamsArray(params)) return params
-      warnInvalidStaticParams(componentPath)
-    }
-
+    const params = await evaluateGenerateStaticParams(componentPath)
+    if (params == null) return []
+    if (isStaticParamsArray(params)) return params
+    warnInvalidStaticParams(componentPath)
     return []
   } catch (error) {
     console.error(`[rari] Router: Failed to extract static params from ${componentPath}:`, error)

packages/rari/src/router/build/vite-plugin.ts

@@ -12,6 +12,7 @@ import {
   warnInvalidStaticParams,
 } from '@/shared/utils/type-guards'
 import { toRariPlugin } from '@/vite/plugin/types'
+import { evaluateGenerateStaticParams } from './evaluate-static-params'
 import { generateAppRouteManifest } from './routes'
 
 const METADATA_EXPORT_REGEX = /export\s+const\s+metadata\s*(?::\s*\w+\s*)?=\s*(\{[\s\S]*?\n\})/
@@ -489,19 +490,15 @@ export function rariRouter(options: RariRouterPluginOptions = {}): RariPlugin {
           const compiledPath = path.join(serverDir, `${componentId}.js`)
 
           try {
-            const module: unknown = await import(/* @vite-ignore */ compiledPath)
-            if (isRecord(module) && typeof module.generateStaticParams === 'function') {
-              // oxlint-disable-next-line typescript/no-unsafe-type-assertion -- dynamically imported route module
-              const generateStaticParams = module.generateStaticParams as () => unknown
-              const params = await generateStaticParams()
-              if (isStaticParamsArray(params)) {
-                if (params.length > 0) {
-                  route.staticParams = params
-                  updated = true
-                }
-              } else {
-                warnInvalidStaticParams(componentId)
+            const params = await evaluateGenerateStaticParams(compiledPath)
+            if (params == null) continue
+            if (isStaticParamsArray(params)) {
+              if (params.length > 0) {
+                route.staticParams = params
+                updated = true
               }
+            } else {
+              warnInvalidStaticParams(componentId)
             }
           } catch (error) {
             console.warn(