waku 0.19.2 → 0.19.3

package/README.md

@@ -31,22 +31,14 @@ npm create waku@latest
 
 ## Rendering
 
-While there's a bit of a learning curve to modern React rendering, it introduces powerful new patterns of composability that are only possible with the advent of React [server components](https://github.com/reactjs/rfcs/blob/main/text/0188-server-components.md).
+While there's a bit of a learning curve to modern React rendering, it introduces powerful new patterns of full-stack composability that are only possible with the advent of [server components](https://github.com/reactjs/rfcs/blob/main/text/0188-server-components.md).
 
-So please don't be intimidated by the `'use client'` directive! Once you get the hang of it, you'll appreciate how awesome it is to flexibly move server-client boundaries with a single line of code as your full-stack React codebase evolves over time.
+So please don't be intimidated by the `'use client'` directive! Once you get the hang of it, you'll appreciate how awesome it is to flexibly move server-client boundaries with a single line of code as your full-stack React codebase evolves over time. It's way simpler than maintaining separate codebases for your backend and frontend.
 
-And please don't fret about client components! Even if you only lightly optimize towards server components, your client bundle size will be smaller than traditional React frameworks, which are 100% client components.
+And please don't fret about client components! Even if you only lightly optimize towards server components, your client bundle size will be smaller than traditional React frameworks, which are always 100% client components.
 
 > Future versions of Waku may provide additional opt-in APIs to abstract some of the complexity away for an improved developer experience.
 
-#### Overview
-
-Each layout and page in Waku is composed of a React component heirarchy.
-
-It begins with a server component at the top of the tree. Then at points down the heirarchy, you'll eventually import a component that needs client component APIs. Mark this file with a `'use client'` directive at the top. When imported into a server component, it will create a server-client boundary. Below this point all imported components are hydrated and will run in the browser as well.
-
-Server components can still be rendered below this boundary, but only via composition (e.g., `children` props).
-
 #### Server components
 
 Server components can be made async and can securely perform server-side logic and data fetching. Feel free to access the local file-system and import heavy dependencies since they aren't included in the client bundle. They have no state, interactivity, or access to browser APIs since they run exclusively on the server.
@@ -127,7 +119,17 @@ export const Providers = ({ children }) => {
 
 #### Server-side rendering
 
-Waku provides static prerendering (SSG) or server-side rendering (SSR) options for layouts and pages including both their server and client components.
+SSR is a distinct concept from RSC. Waku provides static prerendering (SSG) or server-side rendering (SSR) options for both layouts and pages including all of their server _and_ client components.
+
+#### tl;dr:
+
+Each layout and page in Waku is composed of a React component heirarchy.
+
+It begins with a server component at the top of the tree. Then at points down the heirarchy, you'll eventually import a component that needs client component APIs. Mark this file with a `'use client'` directive at the top. When imported into a server component, it will create a server-client boundary. Below this point in the component heirarchy, all imported components are hydrated and will run in the browser as well.
+
+Server components can still be rendered below this boundary, but only via composition (e.g., `children` props). They form [a new layer](https://github.com/reactwg/server-components/discussions/4) that run _before_ any client code.
+
+Client components are still server-side rendered. SSR is seperate from RSC. See the [linked diagrams](https://github.com/reactwg/server-components/discussions/4) for a helpful visual.
 
 #### Further reading
 
@@ -647,6 +649,27 @@ Adding the `--with-vercel-static` flag to the build script will produce static s
 }
 ```
 
+### Netlify
+
+Waku projects can be deployed to Netlify with the [Netlify CLI](https://docs.netlify.com/cli/get-started/).
+
+```
+npm run build -- --with-netlify
+netlify deploy --dir=dist/public
+```
+
+#### Pure SSG
+
+Adding the `--with-netlify-static` flag to the build script will produce static sites without Netlify functions.
+
+```
+{
+  "scripts": {
+    "build": "waku build --with-ssr --with-netlify-static"
+  }
+}
+```
+
 ### Cloudflare (experimental)
 
 ```
@@ -661,13 +684,6 @@ npm run build -- --with-deno
 DENO_DEPLOY_TOKEN=... deployctl deploy --project=... --prod dist/serve.js --exclude node_modules
 ```
 
-### Netlify Deploy (experimental)
-
-```
-npm run build -- --with-netlify
-netlify deploy
-```
-
 ### AWS Lambda (experimental)
 
 ```

package/dist/cli.js

@@ -1,5 +1,5 @@
 import path from 'node:path';
-import { existsSync, readFileSync, writeFileSync, unlinkSync } from 'node:fs';
+import { existsSync, writeFileSync, unlinkSync } from 'node:fs';
 import { pathToFileURL } from 'node:url';
 import { parseArgs } from 'node:util';
 import { createRequire } from 'node:module';
@@ -8,11 +8,18 @@ import { Hono } from 'hono';
 import { serve } from '@hono/node-server';
 import { serveStatic } from '@hono/node-server/serve-static';
 import * as swc from '@swc/core';
+import * as dotenv from 'dotenv';
 import { resolveConfig } from './lib/config.js';
 import { honoMiddleware as honoDevMiddleware } from './lib/middleware/hono-dev.js';
 import { honoMiddleware as honoPrdMiddleware } from './lib/middleware/hono-prd.js';
 import { build } from './lib/builder/build.js';
 const require = createRequire(new URL('.', import.meta.url));
+dotenv.config({
+    path: [
+        '.env.local',
+        '.env'
+    ]
+});
 const { values, positionals } = parseArgs({
     args: process.argv.slice(2),
     allowPositionals: true,
@@ -51,7 +58,6 @@ const { values, positionals } = parseArgs({
         }
     }
 });
-loadEnv();
 const config = await loadConfig();
 const cmd = positionals[0];
 if (values.version) {
@@ -100,7 +106,7 @@ async function runBuild(options) {
         ...options,
         config,
         env: process.env,
-        deploy: (values['with-vercel'] ?? !!process.env.VERCEL ? values['with-vercel-static'] ? 'vercel-static' : 'vercel-serverless' : undefined) || (values['with-cloudflare'] ? 'cloudflare' : undefined) || (values['with-deno'] ? 'deno' : undefined) || (values['with-netlify'] ? values['with-netlify-static'] ? 'netlify-static' : 'netlify-functions' : undefined) || (values['with-aws-lambda'] ? 'aws-lambda' : undefined)
+        deploy: (values['with-vercel'] ?? !!process.env.VERCEL ? values['with-vercel-static'] ? 'vercel-static' : 'vercel-serverless' : undefined) || (values['with-cloudflare'] ? 'cloudflare' : undefined) || (values['with-deno'] ? 'deno' : undefined) || (values['with-netlify'] ?? !!process.env.NETLIFY ? values['with-netlify-static'] ? 'netlify-static' : 'netlify-functions' : undefined) || (values['with-aws-lambda'] ? 'aws-lambda' : undefined)
     });
 }
 async function runStart(options) {
@@ -155,23 +161,6 @@ Options:
   -h, --help            Display this help message
 `);
 }
-// TODO consider using a library such as `dotenv`
-function loadEnv() {
-    if (existsSync('.env.local')) {
-        for (const line of readFileSync('.env.local', 'utf8').split('\n')){
-            const [key, value] = line.split('=');
-            if (key && value) {
-                if (value.startsWith('"') && value.endsWith('"')) {
-                    process.env[key.trim()] = value.slice(1, -1);
-                } else if (value.startsWith("'") && value.endsWith("'")) {
-                    process.env[key.trim()] = value.slice(1, -1);
-                } else {
-                    process.env[key.trim()] = value.trim();
-                }
-            }
-        }
-    }
-}
 // TODO is this a good idea?
 async function loadConfig() {
     if (!existsSync('waku.config.ts')) {

package/dist/client.d.ts

@@ -5,7 +5,7 @@ declare global {
     }
 }
 type Elements = Promise<Record<string, ReactNode>>;
-type SetElements = (fn: (prev: Elements) => Elements) => void;
+type SetElements = (updater: Elements | ((prev: Elements) => Elements)) => void;
 type CacheEntry = [
     input: string,
     searchParamsString: string,

package/dist/client.js

@@ -2,7 +2,7 @@
 'use client';
 import { createContext, createElement, memo, use, useCallback, useState, startTransition } from 'react';
 import RSDWClient from 'react-server-dom-webpack/client';
-import { encodeInput } from './lib/renderers/utils.js';
+import { encodeInput, encodeActionId } from './lib/renderers/utils.js';
 const { createFromFetch, encodeReply } = RSDWClient;
 const BASE_PATH = `${import.meta.env?.WAKU_CONFIG_BASE_PATH}${import.meta.env?.WAKU_CONFIG_RSC_PATH}/`;
 const checkStatus = async (responsePromise)=>{
@@ -37,7 +37,7 @@ export const fetchRSC = (input, searchParamsString, setElements, cache = fetchCa
     }
     const options = {
         async callServer (actionId, args) {
-            const response = fetch(BASE_PATH + encodeInput(encodeURIComponent(actionId)), {
+            const response = fetch(BASE_PATH + encodeInput(encodeActionId(actionId)), {
                 method: 'POST',
                 body: await encodeReply(args)
             });

package/dist/config.d.ts

@@ -27,6 +27,11 @@ export interface Config {
      * Defaults to "assets".
      */
     assetsDir?: string;
+    /**
+     * The SSR directory relative to distDir.
+     * Defaults to "ssr".
+     */
+    ssrDir?: string;
     /**
      * The index.html file for any directories.
      * Defaults to "index.html".

package/dist/lib/builder/build.js

@@ -5,7 +5,7 @@ import { build as buildVite, resolveConfig as resolveViteConfig } from 'vite';
 import viteReact from '@vitejs/plugin-react';
 import { resolveConfig } from '../config.js';
 import { joinPath, extname, filePathToFileURL, fileURLToFilePath, decodeFilePathFromAbsolute } from '../utils/path.js';
-import { createReadStream, createWriteStream, existsSync, rename, mkdir, readFile, writeFile, appendFile, unlink } from '../utils/node-fs.js';
+import { createReadStream, createWriteStream, existsSync, copyFile, rename, mkdir, readFile, writeFile, appendFile, unlink } from '../utils/node-fs.js';
 import { encodeInput, generatePrefetchCode } from '../renderers/utils.js';
 import { RSDW_SERVER_MODULE, RSDW_SERVER_MODULE_VALUE, renderRsc, getBuildConfig, getSsrConfig } from '../renderers/rsc-renderer.js';
 import { renderHtml } from '../renderers/html-renderer.js';
@@ -51,6 +51,7 @@ const analyzeEntries = async (entriesFile)=>{
             rscAnalyzePlugin(commonFileSet, clientFileSet, serverFileSet)
         ],
         ssr: {
+            target: 'webworker',
             resolve: {
                 conditions: [
                     'react-server',
@@ -92,18 +93,17 @@ const analyzeEntries = async (entriesFile)=>{
         serverEntryFiles
     };
 };
-const buildServerBundle = async (rootDir, config, entriesFile, distEntriesFile, commonEntryFiles, clientEntryFiles, serverEntryFiles, ssr, serve)=>{
+// For RSC
+const buildServerBundle = async (rootDir, config, entriesFile, distEntriesFile, commonEntryFiles, clientEntryFiles, serverEntryFiles, ssr, serve, isNodeCompatible)=>{
     const serverBuildOutput = await buildVite({
         plugins: [
             nonjsResolvePlugin(),
             rscTransformPlugin({
                 isBuild: true,
                 assetsDir: config.assetsDir,
-                clientEntryFiles: {
-                    // FIXME this seems very ad-hoc
-                    [WAKU_CLIENT]: decodeFilePathFromAbsolute(joinPath(fileURLToFilePath(import.meta.url), '../../../client.js')),
-                    ...clientEntryFiles
-                },
+                wakuClientId: WAKU_CLIENT,
+                wakuClientPath: decodeFilePathFromAbsolute(joinPath(fileURLToFilePath(import.meta.url), '../../../client.js')),
+                clientEntryFiles,
                 serverEntryFiles
             }),
             rscEnvPlugin({
@@ -114,11 +114,12 @@ const buildServerBundle = async (rootDir, config, entriesFile, distEntriesFile,
                     ...config,
                     entriesFile,
                     srcServeFile: decodeFilePathFromAbsolute(joinPath(fileURLToFilePath(import.meta.url), `../serve-${serve}.js`)),
-                    ssr
+                    ssr,
+                    serve
                 })
             ] : []
         ],
-        ssr: {
+        ssr: isNodeCompatible ? {
             resolve: {
                 conditions: [
                     'react-server',
@@ -129,11 +130,22 @@ const buildServerBundle = async (rootDir, config, entriesFile, distEntriesFile,
                     'workerd'
                 ]
             },
-            external: serve === 'cloudflare' && [
-                'hono',
-                'hono/cloudflare-workers'
-            ] || [],
             noExternal: /^(?!node:)/
+        } : {
+            target: 'webworker',
+            resolve: {
+                conditions: [
+                    'react-server',
+                    'workerd',
+                    'worker'
+                ],
+                externalConditions: [
+                    'react-server',
+                    'workerd',
+                    'worker'
+                ]
+            },
+            noExternal: true
         },
         define: {
             'process.env.NODE_ENV': JSON.stringify('production')
@@ -169,7 +181,8 @@ const buildServerBundle = async (rootDir, config, entriesFile, distEntriesFile,
     if (!('output' in serverBuildOutput)) {
         throw new Error('Unexpected vite server build output');
     }
-    const psDir = joinPath(config.publicDir, config.assetsDir);
+    // TODO If ssr === false, we don't need to write ssr entries.
+    const ssrAssetsDir = joinPath(config.ssrDir, config.assetsDir);
     const code = `
 export function loadModule(id) {
   switch (id) {
@@ -177,16 +190,16 @@ export function loadModule(id) {
       return import('./${RSDW_SERVER_MODULE}.js');
 ${Object.keys(CLIENT_MODULE_MAP).map((key)=>`
     case '${CLIENT_PREFIX}${key}':
-      return import('./${psDir}/${key}.js');
+      return import('./${ssrAssetsDir}/${key}.js');
   `).join('')}
-    case '${psDir}/${WAKU_CLIENT}.js':
-      return import('./${psDir}/${WAKU_CLIENT}.js');
+    case '${ssrAssetsDir}/${WAKU_CLIENT}.js':
+      return import('./${ssrAssetsDir}/${WAKU_CLIENT}.js');
+${Object.entries(clientEntryFiles || {}).map(([k])=>`
+    case '${ssrAssetsDir}/${k}.js':
+      return import('./${ssrAssetsDir}/${k}.js');`).join('')}
 ${Object.entries(serverEntryFiles || {}).map(([k])=>`
     case '${config.assetsDir}/${k}.js':
       return import('./${config.assetsDir}/${k}.js');`).join('')}
-${Object.entries(clientEntryFiles || {}).map(([k])=>`
-    case '${psDir}/${k}.js':
-      return import('./${psDir}/${k}.js');`).join('')}
     default:
       throw new Error('Cannot find module: ' + id);
   }
@@ -195,6 +208,71 @@ ${Object.entries(clientEntryFiles || {}).map(([k])=>`
     await appendFile(distEntriesFile, code);
     return serverBuildOutput;
 };
+// For SSR (render client components on server to generate HTML)
+const buildSsrBundle = async (rootDir, config, commonEntryFiles, clientEntryFiles, serverBuildOutput, isNodeCompatible)=>{
+    const mainJsFile = joinPath(rootDir, config.srcDir, config.mainJs);
+    const cssAssets = serverBuildOutput.output.flatMap(({ type, fileName })=>type === 'asset' && fileName.endsWith('.css') ? [
+            fileName
+        ] : []);
+    await buildVite({
+        base: config.basePath,
+        plugins: [
+            rscIndexPlugin({
+                ...config,
+                cssAssets
+            }),
+            rscEnvPlugin({
+                config,
+                hydrate: true
+            })
+        ],
+        ssr: isNodeCompatible ? {
+            noExternal: /^(?!node:)/
+        } : {
+            target: 'webworker',
+            resolve: {
+                conditions: [
+                    'worker'
+                ],
+                externalConditions: [
+                    'worker'
+                ]
+            },
+            noExternal: true
+        },
+        define: {
+            'process.env.NODE_ENV': JSON.stringify('production')
+        },
+        publicDir: false,
+        build: {
+            ssr: true,
+            outDir: joinPath(rootDir, config.distDir, config.ssrDir),
+            rollupOptions: {
+                onwarn,
+                input: {
+                    main: mainJsFile,
+                    ...CLIENT_MODULE_MAP,
+                    ...commonEntryFiles,
+                    ...clientEntryFiles
+                },
+                output: {
+                    entryFileNames: (chunkInfo)=>{
+                        if (CLIENT_MODULE_MAP[chunkInfo.name] || commonEntryFiles[chunkInfo.name] || clientEntryFiles[chunkInfo.name]) {
+                            return config.assetsDir + '/[name].js';
+                        }
+                        return config.assetsDir + '/[name]-[hash].js';
+                    }
+                }
+            }
+        }
+    });
+    for (const cssAsset of cssAssets){
+        const from = joinPath(rootDir, config.distDir, cssAsset);
+        const to = joinPath(rootDir, config.distDir, config.ssrDir, cssAsset);
+        await copyFile(from, to);
+    }
+};
+// For Browsers
 const buildClientBundle = async (rootDir, config, commonEntryFiles, clientEntryFiles, serverBuildOutput, ssr)=>{
     const mainJsFile = joinPath(rootDir, config.srcDir, config.mainJs);
     const cssAssets = serverBuildOutput.output.flatMap(({ type, fileName })=>type === 'asset' && fileName.endsWith('.css') ? [
@@ -219,14 +297,16 @@ const buildClientBundle = async (rootDir, config, commonEntryFiles, clientEntryF
                 onwarn,
                 input: {
                     main: mainJsFile,
-                    ...CLIENT_MODULE_MAP,
+                    [WAKU_CLIENT]: CLIENT_MODULE_MAP[WAKU_CLIENT],
                     ...commonEntryFiles,
                     ...clientEntryFiles
                 },
                 preserveEntrySignatures: 'exports-only',
                 output: {
                     entryFileNames: (chunkInfo)=>{
-                        if (CLIENT_MODULE_MAP[chunkInfo.name] || commonEntryFiles[chunkInfo.name] || clientEntryFiles[chunkInfo.name]) {
+                        if ([
+                            WAKU_CLIENT
+                        ].includes(chunkInfo.name) || commonEntryFiles[chunkInfo.name] || clientEntryFiles[chunkInfo.name]) {
                             return config.assetsDir + '/[name].js';
                         }
                         return config.assetsDir + '/[name]-[hash].js';
@@ -356,13 +436,11 @@ const emitHtmlFiles = async (rootDir, config, distEntriesFile, distEntries, buil
                     pathname,
                     searchParams,
                     isDev: false,
-                    entries: distEntries,
-                    isBuild: true
+                    entries: distEntries
                 }),
             loadClientModule: (key)=>distEntries.loadModule(CLIENT_PREFIX + key),
             isDev: false,
-            loadModule: distEntries.loadModule,
-            isBuild: true
+            loadModule: distEntries.loadModule
         });
         await mkdir(joinPath(destHtmlFile, '..'), {
             recursive: true
@@ -399,8 +477,12 @@ export async function build(options) {
     const rootDir = (await resolveViteConfig({}, 'build', 'production', 'production')).root;
     const entriesFile = resolveFileName(joinPath(rootDir, config.srcDir, config.entriesJs));
     const distEntriesFile = resolveFileName(joinPath(rootDir, config.distDir, config.entriesJs));
+    const isNodeCompatible = options.deploy !== 'cloudflare' && options.deploy !== 'deno';
     const { commonEntryFiles, clientEntryFiles, serverEntryFiles } = await analyzeEntries(entriesFile);
-    const serverBuildOutput = await buildServerBundle(rootDir, config, entriesFile, distEntriesFile, commonEntryFiles, clientEntryFiles, serverEntryFiles, !!options.ssr, (options.deploy === 'vercel-serverless' ? 'vercel' : false) || (options.deploy === 'cloudflare' ? 'cloudflare' : false) || (options.deploy === 'deno' ? 'deno' : false) || (options.deploy === 'netlify-functions' ? 'netlify' : false) || (options.deploy === 'aws-lambda' ? 'aws-lambda' : false));
+    const serverBuildOutput = await buildServerBundle(rootDir, config, entriesFile, distEntriesFile, commonEntryFiles, clientEntryFiles, serverEntryFiles, !!options.ssr, (options.deploy === 'vercel-serverless' ? 'vercel' : false) || (options.deploy === 'cloudflare' ? 'cloudflare' : false) || (options.deploy === 'deno' ? 'deno' : false) || (options.deploy === 'netlify-functions' ? 'netlify' : false) || (options.deploy === 'aws-lambda' ? 'aws-lambda' : false), isNodeCompatible);
+    if (options.ssr) {
+        await buildSsrBundle(rootDir, config, commonEntryFiles, clientEntryFiles, serverBuildOutput, isNodeCompatible);
+    }
     await buildClientBundle(rootDir, config, commonEntryFiles, clientEntryFiles, serverBuildOutput, !!options.ssr);
     const distEntries = await import(filePathToFileURL(distEntriesFile));
     const buildConfig = await getBuildConfig({

package/dist/lib/builder/output-netlify.js

@@ -1,27 +1,17 @@
 import path from 'node:path';
-import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { mkdirSync, writeFileSync } from 'node:fs';
 export const emitNetlifyOutput = async (rootDir, config, type)=>{
     if (type === 'functions') {
-        const functionsDir = path.join(rootDir, 'functions');
+        const functionsDir = path.join(rootDir, 'netlify/functions');
         mkdirSync(functionsDir, {
             recursive: true
         });
         writeFileSync(path.join(functionsDir, 'serve.js'), `
-export { default } from '../${config.distDir}/${config.serveJs}';
+export { default } from '../../${config.distDir}/${config.serveJs}';
 export const config = {
   preferStatic: true,
   path: ['/', '/*'],
 };
 `);
     }
-    const netlifyTomlFile = path.join(rootDir, 'netlify.toml');
-    if (!existsSync(netlifyTomlFile)) {
-        writeFileSync(netlifyTomlFile, `
-[build]                             
-  publish = "${config.distDir}/${config.publicDir}"
-` + (type === 'functions' ? `
-[functions]                             
-  directory = "functions"       
-` : ''));
-    }
 };

package/dist/lib/builder/serve-cloudflare.d.ts

@@ -1,5 +1,5 @@
 import { Hono } from 'hono';
-declare const app: Hono<import("hono").Env, {}, "/">;
+declare const app: Hono<import("hono").Env, import("hono/types").BlankSchema, "/">;
 declare const _default: {
     fetch(request: Request, env: Record<string, string>, ctx: Parameters<typeof app.fetch>[2]): Promise<Response>;
 };

package/dist/lib/builder/serve-cloudflare.js

@@ -1,12 +1,16 @@
 import { Hono } from 'hono';
 import { serveStatic } from 'hono/cloudflare-workers';
+// @ts-expect-error no types
+// eslint-disable-next-line import/no-unresolved
+import manifest from '__STATIC_CONTENT_MANIFEST';
 import { honoMiddleware } from '../middleware/hono-prd.js';
 const ssr = !!import.meta.env.WAKU_BUILD_SSR;
 const loadEntries = ()=>import(import.meta.env.WAKU_ENTRIES_FILE);
 let serveWaku;
 const app = new Hono();
 app.use('*', serveStatic({
-    root: './'
+    root: './',
+    manifest
 }));
 app.use('*', (c, next)=>serveWaku(c, next));
 export default {

package/dist/lib/config.d.ts

@@ -9,6 +9,7 @@ export declare function resolveConfig(config: Config): Promise<{
     distDir: string;
     publicDir: string;
     assetsDir: string;
+    ssrDir: string;
     indexHtml: string;
     mainJs: string;
     entriesJs: string;

package/dist/lib/config.js

@@ -10,6 +10,7 @@ export async function resolveConfig(config) {
         distDir: 'dist',
         publicDir: 'public',
         assetsDir: 'assets',
+        ssrDir: 'ssr',
         indexHtml: 'index.html',
         mainJs: 'main.tsx',
         entriesJs: 'entries.js',

package/dist/lib/handlers/dev-worker-api.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" resolution-mode="require"/>
 import type { Worker as WorkerType } from 'node:worker_threads';
 import type { ResolvedConfig } from '../config.js';
-import type { ModuleImportResult } from '../plugins/vite-plugin-rsc-hmr.js';
+import type { HotUpdatePayload } from '../plugins/vite-plugin-rsc-hmr.js';
 export type RenderRequest = {
     input: string;
     searchParamsString: string;
@@ -28,13 +28,8 @@ export type MessageReq = ({
     searchParamsString: string;
 };
 export type MessageRes = {
-    type: 'full-reload';
-} | {
-    type: 'hot-import';
-    source: string;
-} | {
-    type: 'module-import';
-    result: ModuleImportResult;
+    type: 'hot-update';
+    payload: HotUpdatePayload;
 } | {
     id: number;
     type: 'start';
@@ -60,9 +55,7 @@ export type MessageRes = {
     type: 'noSsrConfig';
 };
 export declare function initializeWorker(config: ResolvedConfig): void;
-export declare function registerReloadCallback(fn: (type: 'full-reload') => void): Promise<() => WorkerType>;
-export declare function registerImportCallback(fn: (source: string) => void): Promise<() => WorkerType>;
-export declare function registerModuleCallback(fn: (result: ModuleImportResult) => void): Promise<() => WorkerType>;
+export declare function registerHotUpdateCallback(fn: (payload: HotUpdatePayload) => void): Promise<() => WorkerType>;
 export declare function renderRscWithWorker<Context>(rr: RenderRequest): Promise<readonly [ReadableStream, Context]>;
 export declare function getSsrConfigWithWorker(config: ResolvedConfig, pathname: string, searchParams: URLSearchParams): Promise<{
     input: string;

package/dist/lib/handlers/dev-worker-api.js

@@ -43,31 +43,11 @@ const getWorker = ()=>{
     }
     return workerPromise;
 };
-export async function registerReloadCallback(fn) {
+export async function registerHotUpdateCallback(fn) {
     const worker = await getWorker();
     const listener = (mesg)=>{
-        if (mesg.type === 'full-reload') {
-            fn(mesg.type);
-        }
-    };
-    worker.on('message', listener);
-    return ()=>worker.off('message', listener);
-}
-export async function registerImportCallback(fn) {
-    const worker = await getWorker();
-    const listener = (mesg)=>{
-        if (mesg.type === 'hot-import') {
-            fn(mesg.source);
-        }
-    };
-    worker.on('message', listener);
-    return ()=>worker.off('message', listener);
-}
-export async function registerModuleCallback(fn) {
-    const worker = await getWorker();
-    const listener = (mesg)=>{
-        if (mesg.type === 'module-import') {
-            fn(mesg.result);
+        if (mesg.type === 'hot-update') {
+            fn(mesg.payload);
         }
     };
     worker.on('message', listener);

package/dist/lib/handlers/dev-worker-impl.js

@@ -4,13 +4,12 @@ import { parentPort, getEnvironmentData } from 'node:worker_threads';
 import { Server } from 'node:http';
 import { createServer as createViteServer } from 'vite';
 import viteReact from '@vitejs/plugin-react';
-import { joinPath, fileURLToFilePath } from '../utils/path.js';
+import { joinPath, fileURLToFilePath, encodeFilePathToAbsolute } from '../utils/path.js';
 import { deepFreeze, hasStatusCode } from '../renderers/utils.js';
 import { renderRsc, getSsrConfig } from '../renderers/rsc-renderer.js';
 import { nonjsResolvePlugin } from '../plugins/vite-plugin-nonjs-resolve.js';
 import { rscTransformPlugin } from '../plugins/vite-plugin-rsc-transform.js';
 import { rscEnvPlugin } from '../plugins/vite-plugin-rsc-env.js';
-import { rscReloadPlugin } from '../plugins/vite-plugin-rsc-reload.js';
 import { rscDelegatePlugin } from '../plugins/vite-plugin-rsc-delegate.js';
 import { mergeUserViteConfig } from '../utils/merge-vite-config.js';
 const { default: module } = await import('node:module');
@@ -21,6 +20,11 @@ if (HAS_MODULE_REGISTER) {
 globalThis.__WAKU_PRIVATE_ENV__ = getEnvironmentData('__WAKU_PRIVATE_ENV__');
 const configSrcDir = getEnvironmentData('CONFIG_SRC_DIR');
 const configEntriesJs = getEnvironmentData('CONFIG_ENTRIES_JS');
+const resolveClientEntryForDev = (id, config)=>{
+    const filePath = id.startsWith('file://') ? fileURLToFilePath(id) : id;
+    // HACK this relies on Vite's internal implementation detail.
+    return config.basePath + '@fs' + encodeFilePathToAbsolute(filePath);
+};
 const handleRender = async (mesg)=>{
     const { id, type: _removed, hasModuleIdCallback, ...rest } = mesg;
     const rr = rest;
@@ -46,6 +50,7 @@ const handleRender = async (mesg)=>{
             moduleIdCallback: rr.moduleIdCallback,
             isDev: true,
             customImport: loadServerFile,
+            resolveClientEntry: (id)=>resolveClientEntryForDev(id, rr.config),
             entries: await loadEntries(rr.config)
         });
         const mesg = {
@@ -79,6 +84,7 @@ const handleGetSsrConfig = async (mesg)=>{
             pathname,
             searchParams,
             isDev: true,
+            resolveClientEntry: (id)=>resolveClientEntryForDev(id, config),
             entries: await loadEntries(config)
         });
         const mesg = ssrConfig ? {
@@ -105,7 +111,6 @@ const handleGetSsrConfig = async (mesg)=>{
     }
 };
 const dummyServer = new Server(); // FIXME we hope to avoid this hack
-const moduleImports = new Set();
 const mergedViteConfig = await mergeUserViteConfig({
     plugins: [
         viteReact(),
@@ -121,22 +126,10 @@ const mergedViteConfig = await mergeUserViteConfig({
         rscTransformPlugin({
             isBuild: false
         }),
-        rscReloadPlugin(moduleImports, (type)=>{
-            const mesg = {
-                type
-            };
-            parentPort.postMessage(mesg);
-        }),
-        rscDelegatePlugin(moduleImports, (source)=>{
-            const mesg = {
-                type: 'hot-import',
-                source
-            };
-            parentPort.postMessage(mesg);
-        }, (result)=>{
+        rscDelegatePlugin((payload)=>{
             const mesg = {
-                type: 'module-import',
-                result
+                type: 'hot-update',
+                payload
             };
             parentPort.postMessage(mesg);
         })