waku 0.12.0 → 0.13.0

package/README.md

@@ -10,6 +10,8 @@ Minimalistic React Framework
 
 ## How to start a new project
 
+Minimum requirement: Node.js 18
+
 ```bash
 npm create waku@latest
 ```
@@ -29,9 +31,8 @@ pnpm create waku # pnpm not working for now
 - [x] `waku start` (production server)
 - [x] Exportable build
 - [x] Static site generation
-- [ ] Client rendering fallback
 - [x] Opt-in router (reference implementation)
-- [ ] Opt-in SSR (HTML generation & hydration)
+- [x] Opt-in SSR (HTML generation only)
 
 ## Tweets
 
@@ -72,6 +73,8 @@ pnpm create waku # pnpm not working for now
 - https://twitter.com/dai_shi/status/1664286329763684353
 - https://twitter.com/dai_shi/status/1664989534889861123
 - https://twitter.com/dai_shi/status/1667545252654366721
+- https://twitter.com/dai_shi/status/1670650381762961408
+- https://twitter.com/dai_shi/status/1671161795061628930
 
 </details>
 

package/dist/cjs/cli.js

@@ -114,12 +114,12 @@ async function runDev(options) {
     const { devServer } = await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("./lib/middleware/devServer.js")));
     const app = express();
     app.use(rsc({
-        mode: "development"
+        command: "dev"
     }));
     if (options?.ssr) {
         const { ssr } = await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("./lib/middleware/ssr.js")));
         app.use(ssr({
-            mode: "development"
+            command: "dev"
         }));
     }
     app.use(devServer());
@@ -139,15 +139,15 @@ async function runStart(options) {
     const { rsc } = await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("./lib/middleware/rsc.js")));
     const app = express();
     app.use(rsc({
-        mode: "production"
+        command: "start"
     }));
     if (options?.ssr) {
         const { ssr } = await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("./lib/middleware/ssr.js")));
         app.use(ssr({
-            mode: "production"
+            command: "start"
         }));
     }
-    app.use(express.static(_nodepath.default.join(config.root, config.framework.outPublic)));
+    app.use(express.static(_nodepath.default.join(config.root, config.framework.distDir, config.framework.publicDir)));
     express.static.mime.default_type = "";
     const port = process.env.PORT || 8080;
     app.listen(port, ()=>{

package/dist/cjs/client.js

@@ -1,4 +1,4 @@
-/// <reference types="react/next" />
+/// <reference types="react/canary" />
 "use strict";
 Object.defineProperty(exports, "__esModule", {
     value: true

package/dist/cjs/config.js

@@ -2,12 +2,34 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-Object.defineProperty(exports, "defineConfig", {
-    enumerable: true,
-    get: function() {
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    defineConfig: function() {
         return defineConfig;
+    },
+    unstable_setRootDir: function() {
+        return unstable_setRootDir;
+    },
+    unstable_rootDir: function() {
+        return unstable_rootDir;
     }
 });
 function defineConfig(config) {
     return config;
 }
+function unstable_setRootDir(root) {
+    // FIXME it would be better to use a module variable or async local storage
+    globalThis.WAKU_CONFIG_ROOT_DIR = root;
+}
+function unstable_rootDir() {
+    const resolvedRootDir = globalThis.WAKU_CONFIG_ROOT_DIR;
+    if (typeof resolvedRootDir !== "string") {
+        throw new Error("rootDir() is called before resolved");
+    }
+    return resolvedRootDir;
+}

package/dist/cjs/lib/builder.js

@@ -10,7 +10,6 @@ Object.defineProperty(exports, "build", {
 });
 const _nodepath = /*#__PURE__*/ _interop_require_default(require("node:path"));
 const _nodefs = /*#__PURE__*/ _interop_require_default(require("node:fs"));
-const _nodemodule = require("node:module");
 const _nodecrypto = require("node:crypto");
 const _vite = require("vite");
 const _pluginreact = /*#__PURE__*/ _interop_require_default(require("@vitejs/plugin-react"));
@@ -101,8 +100,10 @@ const buildServerBundle = async (config, entriesFile, clientEntryFiles, serverEn
                 "react-server"
             ]
         },
+        publicDir: false,
         build: {
             ssr: true,
+            outDir: config.framework.distDir,
             rollupOptions: {
                 onwarn,
                 input: {
@@ -138,7 +139,7 @@ const buildServerBundle = async (config, entriesFile, clientEntryFiles, serverEn
     return serverBuildOutput;
 };
 const buildClientBundle = async (config, clientEntryFiles)=>{
-    const indexHtmlFile = _nodepath.default.join(config.root, config.framework.indexHtml);
+    const indexHtmlFile = _nodepath.default.join(config.root, config.framework.srcDir, config.framework.indexHtml);
     const clientBuildOutput = await (0, _vite.build)({
         ..._config.configFileConfig,
         plugins: [
@@ -146,8 +147,9 @@ const buildClientBundle = async (config, clientEntryFiles)=>{
             (0, _pluginreact.default)(),
             (0, _rscindexplugin.rscIndexPlugin)()
         ],
+        root: _nodepath.default.join(config.root, config.framework.srcDir),
         build: {
-            outDir: _nodepath.default.join(config.build.outDir, config.framework.outPublic),
+            outDir: _nodepath.default.join(config.root, config.framework.distDir, config.framework.publicDir),
             rollupOptions: {
                 onwarn,
                 input: {
@@ -189,22 +191,24 @@ const emitRscFiles = async (config)=>{
         return Array.from(idSet || []);
     };
     const rscFileSet = new Set(); // XXX could be implemented better
-    await Promise.all(Object.entries(buildConfig).map(async ([, { elements }])=>{
+    await Promise.all(Object.entries(buildConfig).map(async ([, { elements, ctx }])=>{
         for (const [rscId, props] of elements || []){
             // FIXME we blindly expect JSON.stringify usage is deterministic
             const serializedProps = JSON.stringify(props);
             const searchParams = new URLSearchParams();
             searchParams.set("props", serializedProps);
-            const destFile = _nodepath.default.join(config.root, config.build.outDir, config.framework.outPublic, config.framework.rscPrefix + decodeURIComponent(rscId), decodeURIComponent(`${searchParams}`));
+            const destFile = _nodepath.default.join(config.root, config.framework.distDir, config.framework.publicDir, config.framework.rscPrefix + decodeURIComponent(rscId), decodeURIComponent(`${searchParams}`));
             if (!rscFileSet.has(destFile)) {
                 rscFileSet.add(destFile);
                 _nodefs.default.mkdirSync(_nodepath.default.dirname(destFile), {
                     recursive: true
                 });
-                const pipeable = (0, _workerapi.renderRSC)({
+                const [pipeable] = await (0, _workerapi.renderRSC)({
                     rscId,
                     props
                 }, {
+                    command: "build",
+                    ctx,
                     moduleIdCallback: (id)=>addClientModule(rscId, serializedProps, id)
                 });
                 await new Promise((resolve, reject)=>{
@@ -222,27 +226,30 @@ const emitRscFiles = async (config)=>{
         rscFiles: Array.from(rscFileSet)
     };
 };
-const renderHtml = async (config, pathStr, htmlStr)=>{
-    const ssrConfig = await (0, _workerapi.getSsrConfigRSC)(pathStr);
+const renderHtml = async (config, pathStr, htmlStr, ctx)=>{
+    const ssrConfig = await (0, _workerapi.getSsrConfigRSC)(pathStr, "build");
     if (!ssrConfig) {
         return null;
     }
     const { splitHTML, getFallback } = config.framework.ssr;
     const [rscId, props] = ssrConfig.element;
-    const pipeable = (0, _workerapi.renderRSC)({
+    const [pipeable] = await (0, _workerapi.renderRSC)({
         rscId,
         props
+    }, {
+        command: "build",
+        ctx
     });
     return (0, _utils1.renderHtmlToReadable)(htmlStr, pipeable, splitHTML, getFallback);
 };
 const emitHtmlFiles = async (config, buildConfig, getClientModules)=>{
     const basePrefix = config.base + config.framework.rscPrefix;
-    const publicIndexHtmlFile = _nodepath.default.join(config.root, config.build.outDir, config.framework.outPublic, config.framework.indexHtml);
+    const publicIndexHtmlFile = _nodepath.default.join(config.root, config.framework.distDir, config.framework.publicDir, config.framework.indexHtml);
     const publicIndexHtml = _nodefs.default.readFileSync(publicIndexHtmlFile, {
         encoding: "utf8"
     });
-    const htmlFiles = await Promise.all(Object.entries(buildConfig).map(async ([pathStr, { elements, customCode, skipSsr }])=>{
-        const destFile = _nodepath.default.join(config.root, config.build.outDir, config.framework.outPublic, pathStr, pathStr.endsWith("/") ? "index.html" : "");
+    const htmlFiles = await Promise.all(Object.entries(buildConfig).map(async ([pathStr, { elements, customCode, ctx, skipSsr }])=>{
+        const destFile = _nodepath.default.join(config.root, config.framework.distDir, config.framework.publicDir, pathStr, pathStr.endsWith("/") ? "index.html" : "");
         let data = "";
         if (_nodefs.default.existsSync(destFile)) {
             data = _nodefs.default.readFileSync(destFile, {
@@ -272,9 +279,9 @@ const emitHtmlFiles = async (config, buildConfig, getClientModules)=>{
         const code = (0, _utils.generatePrefetchCode)(basePrefix, elementsForPrefetch, moduleIdsForPrefetch) + (customCode || "");
         if (code) {
             // HACK is this too naive to inject script code?
-            data = data.replace(/<\/body>/, `<script>${code}</script></body>`);
+            data = data.replace(/<\/head>/, `<script>${code}</script></head>`);
         }
-        const htmlReadable = !skipSsr && await renderHtml(config, pathStr, data);
+        const htmlReadable = !skipSsr && await renderHtml(config, pathStr, data, ctx);
         if (htmlReadable) {
             await new Promise((resolve, reject)=>{
                 const stream = _nodefs.default.createWriteStream(destFile);
@@ -293,25 +300,10 @@ const emitHtmlFiles = async (config, buildConfig, getClientModules)=>{
         htmlFiles
     };
 };
-const emitPackageJson = (config)=>{
-    const require1 = (0, _nodemodule.createRequire)(require("url").pathToFileURL(__filename).toString());
-    const origPackageJson = require1(_nodepath.default.join(config.root, "package.json"));
-    const packageJson = {
-        name: origPackageJson.name,
-        version: origPackageJson.version,
-        private: true,
-        type: "module",
-        scripts: {
-            start: "waku start"
-        },
-        dependencies: origPackageJson.dependencies
-    };
-    _nodefs.default.writeFileSync(_nodepath.default.join(config.root, config.build.outDir, "package.json"), JSON.stringify(packageJson, null, 2));
-};
 const emitVercelOutput = (config, clientBuildOutput, rscFiles, htmlFiles)=>{
-    const clientFiles = clientBuildOutput.output.map(({ fileName })=>_nodepath.default.join(config.root, config.build.outDir, config.framework.outPublic, fileName));
-    const srcDir = _nodepath.default.join(config.root, config.build.outDir, config.framework.outPublic);
-    const dstDir = _nodepath.default.join(config.root, config.build.outDir, ".vercel", "output");
+    const clientFiles = clientBuildOutput.output.map(({ fileName })=>_nodepath.default.join(config.root, config.framework.distDir, config.framework.publicDir, fileName));
+    const srcDir = _nodepath.default.join(config.root, config.framework.distDir, config.framework.publicDir);
+    const dstDir = _nodepath.default.join(config.root, config.framework.distDir, ".vercel", "output");
     for (const file of [
         ...clientFiles,
         ...rscFiles,
@@ -364,13 +356,12 @@ const resolveFileName = (fname)=>{
 };
 async function build() {
     const config = await (0, _config.resolveConfig)("build");
-    const entriesFile = resolveFileName(_nodepath.default.join(config.root, config.framework.entriesJs));
+    const entriesFile = resolveFileName(_nodepath.default.join(config.root, config.framework.srcDir, config.framework.entriesJs));
     const { clientEntryFiles, serverEntryFiles } = await analyzeEntries(entriesFile);
     await buildServerBundle(config, entriesFile, clientEntryFiles, serverEntryFiles);
     const clientBuildOutput = await buildClientBundle(config, clientEntryFiles);
     const { buildConfig, getClientModules, rscFiles } = await emitRscFiles(config);
     const { htmlFiles } = await emitHtmlFiles(config, buildConfig, getClientModules);
-    emitPackageJson(config);
     // https://vercel.com/docs/build-output-api/v3
     // So far, only static sites are supported.
     emitVercelOutput(config, clientBuildOutput, rscFiles, htmlFiles);

package/dist/cjs/lib/config.js

@@ -18,16 +18,21 @@ _export(exports, {
 });
 const _vite = require("vite");
 const splitHTML = (htmlStr)=>{
-    const startStr = "<!--placeholder-->";
-    const endStr = "<!--/placeholder-->";
-    const splitted = htmlStr.split(new RegExp(startStr + "[\\s\\S]*" + endStr));
-    if (splitted.length !== 2) {
+    const P1 = [
+        "<!--placeholder1-->\\s*<div[^>]*>",
+        "</div>\\s*<!--/placeholder1-->"
+    ];
+    const P2 = [
+        "<!--placeholder2-->",
+        "<!--/placeholder2-->"
+    ];
+    const anyRE = "[\\s\\S]*";
+    const match = htmlStr.match(new RegExp(// prettier-ignore
+    "^(" + anyRE + P1[0] + ")" + anyRE + "(" + P1[1] + anyRE + P2[0] + ")" + anyRE + "(" + P2[1] + anyRE + ")$"));
+    if (match?.length !== 1 + 3) {
         throw new Error("Failed to split HTML");
     }
-    return [
-        splitted[0] + startStr,
-        endStr + splitted[1]
-    ];
+    return match.slice(1);
 };
 const getFallback = (id)=>{
     if (id.endsWith("#Waku_SSR_Capable_Link")) {
@@ -42,9 +47,11 @@ async function resolveConfig(command) {
     const origConfig = await (0, _vite.resolveConfig)(configFileConfig, command);
     const origFramework = origConfig.framework;
     const framework = {
+        srcDir: "src",
+        distDir: "dist",
+        publicDir: "public",
         indexHtml: "index.html",
         entriesJs: "entries.js",
-        outPublic: "public",
         rscPrefix: "RSC/",
         ...origFramework,
         ssr: {

package/dist/cjs/lib/middleware/devServer.js

@@ -20,27 +20,29 @@ function _interop_require_default(obj) {
     };
 }
 function devServer() {
-    const vitePromise = (0, _vite.createServer)({
-        ..._config.configFileConfig,
-        optimizeDeps: {
-            include: [
-                "react-server-dom-webpack/client"
+    const configPromise = (0, _config.resolveConfig)("serve");
+    const vitePromise = configPromise.then((config)=>(0, _vite.createServer)({
+            ..._config.configFileConfig,
+            root: _nodepath.default.join(config.root, config.framework.srcDir),
+            optimizeDeps: {
+                include: [
+                    "react-server-dom-webpack/client"
+                ],
+                // FIXME without this, waku router has dual module hazard,
+                // and "Uncaught Error: Missing Router" happens.
+                exclude: [
+                    "waku"
+                ]
+            },
+            plugins: [
+                // @ts-expect-error This expression is not callable.
+                (0, _pluginreact.default)(),
+                (0, _rscindexplugin.rscIndexPlugin)()
             ],
-            // FIXME without this, waku router has dual module hazard,
-            // and "Uncaught Error: Missing Router" happens.
-            exclude: [
-                "waku"
-            ]
-        },
-        plugins: [
-            // @ts-expect-error This expression is not callable.
-            (0, _pluginreact.default)(),
-            (0, _rscindexplugin.rscIndexPlugin)()
-        ],
-        server: {
-            middlewareMode: true
-        }
-    });
+            server: {
+                middlewareMode: true
+            }
+        }));
     vitePromise.then((vite)=>{
         (0, _workerapi.registerReloadCallback)((type)=>vite.ws.send({
                 type

package/dist/cjs/lib/middleware/rsc/utils.js

@@ -20,6 +20,9 @@ _export(exports, {
     },
     transformRsfId: function() {
         return transformRsfId;
+    },
+    deepFreeze: function() {
+        return deepFreeze;
     }
 });
 const _nodebuffer = require("node:buffer");
@@ -75,3 +78,11 @@ const transformRsfId = (prefixToRemove)=>new _nodestream.Transform({
             callback(null, changed ? _nodebuffer.Buffer.from(lines.join("\n")) : chunk);
         }
     });
+const deepFreeze = (x)=>{
+    if (typeof x === "object" && x !== null) {
+        Object.freeze(x);
+        for (const value of Object.values(x)){
+            deepFreeze(value);
+        }
+    }
+};

package/dist/cjs/lib/middleware/rsc/worker-api.js

@@ -60,32 +60,56 @@ function shutdown() {
 let nextId = 1;
 function renderRSC(input, options) {
     const id = nextId++;
-    const passthrough = new _nodestream.PassThrough();
-    messageCallbacks.set(id, (mesg)=>{
-        if (mesg.type === "buf") {
-            passthrough.write(Buffer.from(mesg.buf, mesg.offset, mesg.len));
-        } else if (mesg.type === "moduleId") {
-            options?.moduleIdCallback?.(mesg.moduleId);
-        } else if (mesg.type === "end") {
-            passthrough.end();
-            messageCallbacks.delete(id);
-        } else if (mesg.type === "err") {
-            const err = mesg.err instanceof Error ? mesg.err : new Error(String(mesg.err));
-            if (mesg.statusCode) {
-                err.statusCode = mesg.statusCode;
+    let started = false;
+    return new Promise((resolve, reject)=>{
+        const passthrough = new _nodestream.PassThrough();
+        messageCallbacks.set(id, (mesg)=>{
+            if (mesg.type === "start") {
+                if (!started) {
+                    started = true;
+                    resolve([
+                        passthrough,
+                        mesg.ctx
+                    ]);
+                } else {
+                    throw new Error("already started");
+                }
+            } else if (mesg.type === "buf") {
+                if (!started) {
+                    throw new Error("not yet started");
+                }
+                passthrough.write(Buffer.from(mesg.buf, mesg.offset, mesg.len));
+            } else if (mesg.type === "moduleId") {
+                options.moduleIdCallback?.(mesg.moduleId);
+            } else if (mesg.type === "end") {
+                if (!started) {
+                    throw new Error("not yet started");
+                }
+                passthrough.end();
+                messageCallbacks.delete(id);
+            } else if (mesg.type === "err") {
+                const err = mesg.err instanceof Error ? mesg.err : new Error(String(mesg.err));
+                if (mesg.statusCode) {
+                    err.statusCode = mesg.statusCode;
+                }
+                if (!started) {
+                    reject(err);
+                } else {
+                    passthrough.destroy(err);
+                }
+                messageCallbacks.delete(id);
             }
-            passthrough.destroy(err);
-            messageCallbacks.delete(id);
-        }
+        });
+        const mesg = {
+            id,
+            type: "render",
+            input,
+            command: options.command,
+            ctx: options.ctx ?? null,
+            moduleIdCallback: !!options.moduleIdCallback
+        };
+        worker.postMessage(mesg);
     });
-    const mesg = {
-        id,
-        type: "render",
-        input,
-        moduleIdCallback: !!options?.moduleIdCallback
-    };
-    worker.postMessage(mesg);
-    return passthrough;
 }
 function getBuildConfigRSC() {
     return new Promise((resolve, reject)=>{
@@ -106,7 +130,7 @@ function getBuildConfigRSC() {
         worker.postMessage(mesg);
     });
 }
-function getSsrConfigRSC(pathStr) {
+function getSsrConfigRSC(pathStr, command) {
     return new Promise((resolve, reject)=>{
         const id = nextId++;
         messageCallbacks.set(id, (mesg)=>{
@@ -121,7 +145,8 @@ function getSsrConfigRSC(pathStr) {
         const mesg = {
             id,
             type: "getSsrConfig",
-            pathStr
+            pathStr,
+            command
         };
         worker.postMessage(mesg);
     });

package/dist/cjs/lib/middleware/rsc/worker-impl.js

@@ -19,9 +19,11 @@ function _interop_require_default(obj) {
 }
 const { renderToPipeableStream } = _server.default;
 const handleRender = async (mesg)=>{
-    const { id, input, moduleIdCallback } = mesg;
+    const { id, input, command, ctx, moduleIdCallback } = mesg;
     try {
-        const options = {};
+        const options = {
+            command
+        };
         if (moduleIdCallback) {
             options.moduleIdCallback = (moduleId)=>{
                 const mesg = {
@@ -32,7 +34,15 @@ const handleRender = async (mesg)=>{
                 _nodeworker_threads.parentPort.postMessage(mesg);
             };
         }
-        const pipeable = await renderRSC(input, options);
+        const { runWithContext } = await loadServerFile("waku/server");
+        const pipeable = await runWithContext(ctx, ()=>renderRSC(input, options));
+        const mesg = {
+            id,
+            type: "start",
+            ctx
+        };
+        _nodeworker_threads.parentPort.postMessage(mesg);
+        (0, _utils.deepFreeze)(ctx);
         const writable = new _nodestream.Writable({
             write (chunk, encoding, callback) {
                 if (encoding !== "buffer") {
@@ -93,9 +103,9 @@ const handleGetBuildConfig = async (mesg)=>{
     }
 };
 const handleGetSsrConfig = async (mesg)=>{
-    const { id, pathStr } = mesg;
+    const { id, pathStr, command } = mesg;
     try {
-        const output = await getSsrConfigRSC(pathStr);
+        const output = await getSsrConfigRSC(pathStr, command);
         const mesg = {
             id,
             type: "ssrConfig",
@@ -158,55 +168,39 @@ _nodeworker_threads.parentPort.on("message", (mesg)=>{
         handleGetSsrConfig(mesg);
     }
 });
-// FIXME using mutable module variable doesn't seem nice. Let's revisit this.
-let resolvedConfig;
-const getEntriesFile = async ()=>{
-    if (!resolvedConfig) {
-        throw new Error("config is not ready");
-    }
-    const config = resolvedConfig;
-    if (config.command === "build") {
-        return _nodepath.default.join(config.root, config.build.outDir, config.framework.entriesJs);
-    }
-    return _nodepath.default.join(config.root, config.framework.entriesJs);
+const getEntriesFile = async (config, command)=>{
+    return _nodepath.default.join(config.root, command === "dev" ? config.framework.srcDir : config.framework.distDir, config.framework.entriesJs);
 };
-const getFunctionComponent = async (rscId)=>{
-    const entriesFile = await getEntriesFile();
-    const { default: { getEntry } } = await loadServerFile(entriesFile);
-    const mod = await getEntry(rscId);
-    if (typeof mod === "function") {
-        return mod;
-    }
-    if (typeof mod?.default === "function") {
-        return mod?.default;
-    }
-    const err = new Error("No function component found");
-    err.statusCode = 404; // HACK our convention for NotFound
-    throw err;
-};
-const resolveClientEntry = (filePath)=>{
-    if (!resolvedConfig) {
-        throw new Error("config is not ready");
-    }
-    const config = resolvedConfig;
-    if (config.command === "build") {
-        return config.base + _nodepath.default.relative(_nodepath.default.join(config.root, config.build.outDir), filePath);
-    }
-    if (config.mode === "development" && !filePath.startsWith(config.root)) {
+const resolveClientEntry = (filePath, config, command)=>{
+    const root = _nodepath.default.join(config.root, command === "dev" ? config.framework.srcDir : config.framework.distDir);
+    if (command === "dev" && !filePath.startsWith(root)) {
         // HACK this relies on Vite's internal implementation detail.
         return config.base + "@fs" + filePath;
     }
-    return config.base + _nodepath.default.relative(config.root, filePath);
+    return config.base + _nodepath.default.relative(root, filePath);
 };
 async function renderRSC(input, options) {
-    if (!resolvedConfig) {
-        resolvedConfig = await (0, _config.resolveConfig)("serve");
-    }
-    const config = resolvedConfig;
+    const config = await (0, _config.resolveConfig)(options.command === "build" ? "build" : "serve");
+    const { unstable_setRootDir } = await loadServerFile("waku/config");
+    unstable_setRootDir(config.root);
+    const getFunctionComponent = async (rscId)=>{
+        const entriesFile = await getEntriesFile(config, options.command);
+        const { default: { getEntry } } = await loadServerFile(entriesFile);
+        const mod = await getEntry(rscId);
+        if (typeof mod === "function") {
+            return mod;
+        }
+        if (typeof mod?.default === "function") {
+            return mod?.default;
+        }
+        const err = new Error("No function component found");
+        err.statusCode = 404; // HACK our convention for NotFound
+        throw err;
+    };
     const bundlerConfig = new Proxy({}, {
         get (_target, encodedId) {
             const [filePath, name] = encodedId.split("#");
-            const id = resolveClientEntry(filePath);
+            const id = resolveClientEntry(filePath, config, options.command);
             options?.moduleIdCallback?.(id);
             return {
                 id,
@@ -235,22 +229,27 @@ async function renderRSC(input, options) {
     throw new Error("Unexpected input");
 }
 async function getBuildConfigRSC() {
-    if (!resolvedConfig) {
-        resolvedConfig = await (0, _config.resolveConfig)("build");
-    }
-    const config = resolvedConfig;
-    const distEntriesFile = await getEntriesFile();
-    const { default: { getBuildConfig } } = await loadServerFile(distEntriesFile);
+    const config = await (0, _config.resolveConfig)("build");
+    const { unstable_setRootDir } = await loadServerFile("waku/config");
+    unstable_setRootDir(config.root);
+    const entriesFile = await getEntriesFile(config, "build");
+    const { default: { getBuildConfig } } = await loadServerFile(entriesFile);
     if (!getBuildConfig) {
         console.warn("getBuildConfig is undefined. It's recommended for optimization and sometimes required.");
         return {};
     }
-    const output = await getBuildConfig(config.root, renderRSC);
+    const output = await getBuildConfig((input, options)=>renderRSC(input, {
+            ...options,
+            command: "build"
+        }));
     return output;
 }
-async function getSsrConfigRSC(pathStr) {
-    const distEntriesFile = await getEntriesFile();
-    const { default: { getSsrConfig } } = await loadServerFile(distEntriesFile);
+async function getSsrConfigRSC(pathStr, command) {
+    const config = await (0, _config.resolveConfig)(command === "build" ? "build" : "serve");
+    const { unstable_setRootDir } = await loadServerFile("waku/config");
+    unstable_setRootDir(config.root);
+    const entriesFile = await getEntriesFile(config, command);
+    const { default: { getSsrConfig } } = await loadServerFile(entriesFile);
     if (!getSsrConfig) {
         return null;
     }