waku 0.11.2 → 0.11.3

package/README.md

@@ -70,6 +70,7 @@ pnpm create waku # pnpm not working for now
 - https://twitter.com/dai_shi/status/1660660331528728578
 - https://twitter.com/dai_shi/status/1661727138746339328
 - https://twitter.com/dai_shi/status/1664286329763684353
+- https://twitter.com/dai_shi/status/1664989534889861123
 
 </details>
 

package/dist/cjs/cli.js

@@ -5,6 +5,8 @@ Object.defineProperty(exports, "__esModule", {
 });
 const _nodefs = /*#__PURE__*/ _interop_require_default(require("node:fs"));
 const _nodepath = /*#__PURE__*/ _interop_require_default(require("node:path"));
+const _nodeutil = require("node:util");
+const _nodemodule = require("node:module");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -49,34 +51,60 @@ function _interop_require_wildcard(obj, nodeInterop) {
     }
     return newObj;
 }
-const cmd = process.argv[2];
-for(let i = 3; i < process.argv.length; ++i){
-    if (process.argv[i] === "--config") {
-        const fname = process.argv[i + 1];
-        if (fname && _nodefs.default.existsSync(fname)) {
-            process.env.CONFIG_FILE = fname;
-        } else {
-            throw new Error("config file does not exist");
+const require1 = (0, _nodemodule.createRequire)(new URL(".", require("url").pathToFileURL(__filename).toString()));
+const { values , positionals  } = (0, _nodeutil.parseArgs)({
+    args: process.argv.splice(2),
+    allowPositionals: true,
+    options: {
+        config: {
+            type: "string"
+        },
+        version: {
+            type: "boolean",
+            short: "v"
+        },
+        help: {
+            type: "boolean",
+            short: "h"
         }
-        ++i;
+    }
+});
+const cmd = positionals[0];
+if (values.config) {
+    if (!_nodefs.default.existsSync(values.config)) {
+        throw new Error("config file does not exist");
+    } else {
+        process.env.CONFIG_FILE = values.config;
     }
 }
-switch(cmd){
-    case "dev":
-        runDev();
-        break;
-    case "build":
-        runBuild();
-        break;
-    case "start":
-        runStart();
-        break;
-    default:
-        throw Error("unknown cmd: " + cmd);
+if (values.version) {
+    const { version  } = require1("../package.json");
+    console.log(version);
+} else if (values.help) {
+    displayUsage();
+} else {
+    switch(cmd){
+        case "dev":
+            runDev();
+            break;
+        case "build":
+            runBuild();
+            break;
+        case "start":
+            runStart();
+            break;
+        default:
+            if (cmd) {
+                console.error("Unknown command:", cmd);
+            }
+            displayUsage();
+            break;
+    }
 }
 async function runDev() {
     const { default: express  } = await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("express")));
-    const { rsc , devServer  } = await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("./lib/middleware.js")));
+    const { rsc  } = await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("./lib/middleware/rsc.js")));
+    const { devServer  } = await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("./lib/middleware/devServer.js")));
     const app = express();
     app.use(rsc({
         mode: "development"
@@ -95,7 +123,7 @@ async function runStart() {
     const { default: express  } = await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("express")));
     const { resolveConfig  } = await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("./lib/config.js")));
     const config = await resolveConfig("serve");
-    const { rsc  } = await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("./lib/middleware.js")));
+    const { rsc  } = await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("./lib/middleware/rsc.js")));
     const app = express();
     app.use(rsc({
         mode: "production"
@@ -107,3 +135,18 @@ async function runStart() {
         console.info("Listening on", port);
     });
 }
+function displayUsage() {
+    console.log(`
+Usage: waku [options] <command>
+
+Commands:
+  dev         Start the development server
+  build       Build the application for production
+  start       Start the production server
+
+Options:
+  -c, --config <path>   Path to the configuration file
+  -v, --version         Display the version number
+  -h, --help            Display this help message
+`);
+}

package/dist/cjs/client.js

@@ -64,6 +64,10 @@ function serve(rscId, basePath = "/RSC/") {
         ];
     });
     const ServerComponent = (props)=>{
+        if (!props) {
+            console.warn("Something went wrong. Please refresh your browser.");
+            return;
+        }
         // FIXME we blindly expect JSON.stringify usage is deterministic
         const serializedProps = JSON.stringify(props);
         const [data, setRerender] = fetchRSC(serializedProps);

package/dist/cjs/lib/builder.js

@@ -11,121 +11,99 @@ 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"));
 const _config = require("./config.js");
-const _rschandler = require("./rsc-handler.js");
-const _vitepluginrsc = require("./vite-plugin-rsc.js");
+const _utils = require("./middleware/rsc/utils.js");
+const _workerapi = require("./middleware/rsc/worker-api.js");
+const _rscindexplugin = require("./vite-plugin/rsc-index-plugin.js");
+const _rscanalyzeplugin = require("./vite-plugin/rsc-analyze-plugin.js");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
 }
-const createVercelOutput = (config, clientFiles, rscFiles, htmlFiles)=>{
-    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");
-    for (const file of [
-        ...clientFiles,
-        ...rscFiles,
-        ...htmlFiles
-    ]){
-        const dstFile = _nodepath.default.join(dstDir, "static", _nodepath.default.relative(srcDir, file));
-        if (!_nodefs.default.existsSync(dstFile)) {
-            _nodefs.default.mkdirSync(_nodepath.default.dirname(dstFile), {
-                recursive: true
-            });
-            _nodefs.default.symlinkSync(_nodepath.default.relative(_nodepath.default.dirname(dstFile), file), dstFile);
-        }
-    }
-    const overrides = Object.fromEntries([
-        ...rscFiles.filter((file)=>!_nodepath.default.extname(file)).map((file)=>[
-                _nodepath.default.relative(srcDir, file),
-                {
-                    contentType: "text/plain"
-                }
-            ]),
-        ...htmlFiles.filter((file)=>!_nodepath.default.extname(file)).map((file)=>[
-                _nodepath.default.relative(srcDir, file),
-                {
-                    contentType: "text/html"
-                }
-            ])
-    ]);
-    const configJson = {
-        version: 3,
-        overrides
-    };
-    _nodefs.default.mkdirSync(dstDir, {
-        recursive: true
-    });
-    _nodefs.default.writeFileSync(_nodepath.default.join(dstDir, "config.json"), JSON.stringify(configJson, null, 2));
-};
-const resolveFileName = (fname)=>{
-    for (const ext of [
-        ".js",
-        ".ts",
-        ".tsx",
-        ".jsx"
-    ]){
-        const resolvedName = fname.slice(0, fname.length - _nodepath.default.extname(fname).length) + ext;
-        if (_nodefs.default.existsSync(resolvedName)) {
-            return resolvedName;
-        }
+// Upstream issue: https://github.com/rollup/rollup/issues/4699
+const onwarn = (warning, warn)=>{
+    if (warning.code === "MODULE_LEVEL_DIRECTIVE" && /"use (client|server)"/.test(warning.message)) {
+        return;
+    } else if (warning.code === "SOURCEMAP_ERROR" && warning.loc?.file?.endsWith(".tsx") && warning.loc?.column === 0 && warning.loc?.line === 1) {
+        return;
     }
-    return "";
+    warn(warning);
 };
-async function build() {
-    const config = await (0, _config.resolveConfig)("build");
-    const indexHtmlFile = _nodepath.default.join(config.root, config.framework.indexHtml);
-    const distEntriesFile = _nodepath.default.join(config.root, config.build.outDir, config.framework.entriesJs);
-    let entriesFile = _nodepath.default.join(config.root, config.framework.entriesJs);
-    if (entriesFile.endsWith(".js")) {
-        entriesFile = resolveFileName(entriesFile) || entriesFile;
-    }
-    const require1 = (0, _nodemodule.createRequire)(require("url").pathToFileURL(__filename).toString());
+const hash = (fname)=>new Promise((resolve)=>{
+        const sha256 = (0, _nodecrypto.createHash)("sha256");
+        sha256.on("readable", ()=>{
+            const data = sha256.read();
+            if (data) {
+                resolve(data.toString("hex").slice(0, 9));
+            }
+        });
+        _nodefs.default.createReadStream(fname).pipe(sha256);
+    });
+const analyzeEntries = async (entriesFile)=>{
     const clientEntryFileSet = new Set();
     const serverEntryFileSet = new Set();
     await (0, _vite.build)({
         ..._config.configFileConfig,
         plugins: [
-            (0, _vitepluginrsc.rscAnalyzePlugin)((id)=>clientEntryFileSet.add(id), (id)=>serverEntryFileSet.add(id))
+            (0, _rscanalyzeplugin.rscAnalyzePlugin)((id)=>clientEntryFileSet.add(id), (id)=>serverEntryFileSet.add(id))
         ],
         ssr: {
-            // FIXME Without this, waku/router isn't considered to have client
-            // entries, and "No client entry" error occurs.
-            // Unless we fix this, RSC-capable packages aren't supported.
-            // This also seems to cause problems with pnpm.
-            noExternal: [
-                "waku"
+            noExternal: /^(?!node:)/,
+            // FIXME this is very adhoc.
+            external: [
+                "react",
+                "minimatch"
+            ]
+        },
+        resolve: {
+            conditions: [
+                "react-server"
             ]
         },
         build: {
             write: false,
             ssr: true,
             rollupOptions: {
+                onwarn,
                 input: {
                     entries: entriesFile
                 }
             }
         }
     });
-    const clientEntryFiles = Object.fromEntries(Array.from(clientEntryFileSet).map((fname, i)=>[
-            `rsc${i}`,
+    const clientEntryFiles = Object.fromEntries(await Promise.all(Array.from(clientEntryFileSet).map(async (fname, i)=>[
+            `rsc${i}-${await hash(fname)}`,
             fname
-        ]));
+        ])));
     const serverEntryFiles = Object.fromEntries(Array.from(serverEntryFileSet).map((fname, i)=>[
             `rsf${i}`,
             fname
         ]));
+    return {
+        clientEntryFiles,
+        serverEntryFiles
+    };
+};
+const buildServerBundle = async (config, entriesFile, clientEntryFiles, serverEntryFiles)=>{
     const serverBuildOutput = await (0, _vite.build)({
         ..._config.configFileConfig,
         ssr: {
-            noExternal: Array.from(clientEntryFileSet).map(// FIXME this might not work with pnpm
+            noExternal: Object.values(clientEntryFiles).map(// FIXME this might not work with pnpm
             (fname)=>_nodepath.default.relative(_nodepath.default.join(config.root, "node_modules"), fname).split("/")[0])
         },
+        resolve: {
+            conditions: [
+                "react-server"
+            ]
+        },
         build: {
             ssr: true,
             rollupOptions: {
+                onwarn,
                 input: {
                     entries: entriesFile,
                     ...clientEntryFiles,
@@ -135,10 +113,10 @@ async function build() {
                     banner: (chunk)=>{
                         // HACK to bring directives to the front
                         let code = "";
-                        if (chunk.moduleIds.some((id)=>clientEntryFileSet.has(id))) {
+                        if (chunk.moduleIds.some((id)=>Object.values(clientEntryFiles).includes(id))) {
                             code += '"use client";';
                         }
-                        if (chunk.moduleIds.some((id)=>serverEntryFileSet.has(id))) {
+                        if (chunk.moduleIds.some((id)=>Object.values(serverEntryFiles).includes(id))) {
                             code += '"use server";';
                         }
                         return code;
@@ -156,43 +134,140 @@ async function build() {
     if (!("output" in serverBuildOutput)) {
         throw new Error("Unexpected vite server build output");
     }
+    return serverBuildOutput;
+};
+const buildClientBundle = async (config, clientEntryFiles)=>{
+    const indexHtmlFile = _nodepath.default.join(config.root, config.framework.indexHtml);
     const clientBuildOutput = await (0, _vite.build)({
         ..._config.configFileConfig,
         plugins: [
-            // @ts-ignore
+            // @ts-expect-error This expression is not callable.
             (0, _pluginreact.default)(),
-            (0, _vitepluginrsc.rscIndexPlugin)()
+            (0, _rscindexplugin.rscIndexPlugin)()
         ],
         build: {
             outDir: _nodepath.default.join(config.build.outDir, config.framework.outPublic),
             rollupOptions: {
+                onwarn,
                 input: {
                     main: indexHtmlFile,
                     ...clientEntryFiles
                 },
-                preserveEntrySignatures: "exports-only"
+                preserveEntrySignatures: "exports-only",
+                output: {
+                    entryFileNames: (chunkInfo)=>{
+                        if (clientEntryFiles[chunkInfo.name]) {
+                            return "assets/[name].js";
+                        }
+                        return "assets/[name]-[hash].js";
+                    }
+                }
             }
         }
     });
     if (!("output" in clientBuildOutput)) {
         throw new Error("Unexpected vite client build output");
     }
-    const clientEntries = {};
-    for (const item of clientBuildOutput.output){
-        const { name , fileName  } = item;
-        const entryFile = name && serverBuildOutput.output.find((item)=>"moduleIds" in item && item.moduleIds.includes(clientEntryFiles[name]))?.fileName;
-        if (entryFile) {
-            clientEntries[entryFile] = fileName;
+    return clientBuildOutput;
+};
+const emitRscFiles = async (config)=>{
+    const pathMap = await (0, _workerapi.getBuilderRSC)();
+    const clientModuleMap = new Map();
+    const addClientModule = (rscId, serializedProps, id)=>{
+        const key = rscId + "/" + serializedProps;
+        let idSet = clientModuleMap.get(key);
+        if (!idSet) {
+            idSet = new Set();
+            clientModuleMap.set(key, idSet);
         }
-    }
-    console.log("clientEntries", clientEntries);
-    _nodefs.default.appendFileSync(distEntriesFile, `export const clientEntries=${JSON.stringify(clientEntries)};`);
-    const absoluteClientEntries = Object.fromEntries(Object.entries(clientEntries).map(([key, val])=>[
-            _nodepath.default.join(_nodepath.default.dirname(entriesFile), config.build.outDir, key),
-            config.base + val
-        ]));
-    await (0, _rschandler.setClientEntries)(absoluteClientEntries);
-    const buildOutput = await (0, _rschandler.buildRSC)();
+        idSet.add(id);
+    };
+    const getClientModules = (rscId, serializedProps)=>{
+        const key = rscId + "/" + serializedProps;
+        const idSet = clientModuleMap.get(key);
+        return Array.from(idSet || []);
+    };
+    const rscFileSet = new Set(); // XXX could be implemented better
+    await Promise.all(Object.entries(pathMap).map(async ([, { elements  }])=>{
+        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}`));
+            if (!rscFileSet.has(destFile)) {
+                rscFileSet.add(destFile);
+                _nodefs.default.mkdirSync(_nodepath.default.dirname(destFile), {
+                    recursive: true
+                });
+                const pipeable = (0, _workerapi.renderRSC)({
+                    rscId,
+                    props
+                }, (id)=>addClientModule(rscId, serializedProps, id));
+                await new Promise((resolve, reject)=>{
+                    const stream = _nodefs.default.createWriteStream(destFile);
+                    stream.on("finish", resolve);
+                    stream.on("error", reject);
+                    pipeable.pipe(stream);
+                });
+            }
+        }
+    }));
+    return {
+        pathMap,
+        getClientModules,
+        rscFiles: Array.from(rscFileSet)
+    };
+};
+const emitHtmlFiles = async (config, pathMap, 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 publicIndexHtml = _nodefs.default.readFileSync(publicIndexHtmlFile, {
+        encoding: "utf8"
+    });
+    const htmlFiles = await Promise.all(Object.entries(pathMap).map(async ([pathStr, { elements , customCode  }])=>{
+        const destFile = _nodepath.default.join(config.root, config.build.outDir, config.framework.outPublic, pathStr, pathStr.endsWith("/") ? "index.html" : "");
+        let data = "";
+        if (_nodefs.default.existsSync(destFile)) {
+            data = _nodefs.default.readFileSync(destFile, {
+                encoding: "utf8"
+            });
+        } else {
+            _nodefs.default.mkdirSync(_nodepath.default.dirname(destFile), {
+                recursive: true
+            });
+            data = publicIndexHtml;
+        }
+        const code = (0, _utils.generatePrefetchCode)(basePrefix, Array.from(elements || []).flatMap(([rscId, props, skipPrefetch])=>{
+            if (skipPrefetch) {
+                return [];
+            }
+            return [
+                [
+                    rscId,
+                    props
+                ]
+            ];
+        }), Array.from(elements || []).flatMap(([rscId, props])=>{
+            // FIXME we blindly expect JSON.stringify usage is deterministic
+            const serializedProps = JSON.stringify(props);
+            return getClientModules(rscId, serializedProps);
+        })) + (customCode || "");
+        if (code) {
+            // HACK is this too naive to inject script code?
+            data = data.replace(/<\/body>/, `<script>${code}</script></body>`);
+        }
+        _nodefs.default.writeFileSync(destFile, data, {
+            encoding: "utf8"
+        });
+        return destFile;
+    }));
+    return {
+        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,
@@ -205,8 +280,72 @@ async function build() {
         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");
+    for (const file of [
+        ...clientFiles,
+        ...rscFiles,
+        ...htmlFiles
+    ]){
+        const dstFile = _nodepath.default.join(dstDir, "static", _nodepath.default.relative(srcDir, file));
+        if (!_nodefs.default.existsSync(dstFile)) {
+            _nodefs.default.mkdirSync(_nodepath.default.dirname(dstFile), {
+                recursive: true
+            });
+            _nodefs.default.symlinkSync(_nodepath.default.relative(_nodepath.default.dirname(dstFile), file), dstFile);
+        }
+    }
+    const overrides = Object.fromEntries([
+        ...rscFiles.filter((file)=>!_nodepath.default.extname(file)).map((file)=>[
+                _nodepath.default.relative(srcDir, file),
+                {
+                    contentType: "text/plain"
+                }
+            ]),
+        ...htmlFiles.filter((file)=>!_nodepath.default.extname(file)).map((file)=>[
+                _nodepath.default.relative(srcDir, file),
+                {
+                    contentType: "text/html"
+                }
+            ])
+    ]);
+    const configJson = {
+        version: 3,
+        overrides
+    };
+    _nodefs.default.mkdirSync(dstDir, {
+        recursive: true
+    });
+    _nodefs.default.writeFileSync(_nodepath.default.join(dstDir, "config.json"), JSON.stringify(configJson, null, 2));
+};
+const resolveFileName = (fname)=>{
+    for (const ext of [
+        ".js",
+        ".ts",
+        ".tsx",
+        ".jsx"
+    ]){
+        const resolvedName = fname.slice(0, fname.length - _nodepath.default.extname(fname).length) + ext;
+        if (_nodefs.default.existsSync(resolvedName)) {
+            return resolvedName;
+        }
+    }
+    return fname; // returning the default one
+};
+async function build() {
+    const config = await (0, _config.resolveConfig)("build");
+    const entriesFile = resolveFileName(_nodepath.default.join(config.root, config.framework.entriesJs));
+    const { clientEntryFiles , serverEntryFiles  } = await analyzeEntries(entriesFile);
+    await buildServerBundle(config, entriesFile, clientEntryFiles, serverEntryFiles);
+    const clientBuildOutput = await buildClientBundle(config, clientEntryFiles);
+    const { pathMap , getClientModules , rscFiles  } = await emitRscFiles(config);
+    const { htmlFiles  } = await emitHtmlFiles(config, pathMap, getClientModules);
+    emitPackageJson(config);
     // https://vercel.com/docs/build-output-api/v3
     // So far, only static sites are supported.
-    createVercelOutput(config, clientBuildOutput.output.map(({ fileName  })=>_nodepath.default.join(config.root, config.build.outDir, config.framework.outPublic, fileName)), buildOutput.rscFiles, buildOutput.htmlFiles);
-    await (0, _rschandler.shutdown)();
+    emitVercelOutput(config, clientBuildOutput, rscFiles, htmlFiles);
+    await (0, _workerapi.shutdown)();
 }

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

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "devServer", {
+    enumerable: true,
+    get: function() {
+        return devServer;
+    }
+});
+const _nodepath = /*#__PURE__*/ _interop_require_default(require("node:path"));
+const _vite = require("vite");
+const _pluginreact = /*#__PURE__*/ _interop_require_default(require("@vitejs/plugin-react"));
+const _config = require("../config.js");
+const _workerapi = require("./rsc/worker-api.js");
+const _rscindexplugin = require("../vite-plugin/rsc-index-plugin.js");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function devServer() {
+    const vitePromise = (0, _vite.createServer)({
+        ..._config.configFileConfig,
+        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)()
+        ],
+        server: {
+            middlewareMode: true
+        }
+    });
+    vitePromise.then((vite)=>{
+        (0, _workerapi.registerReloadCallback)((type)=>vite.ws.send({
+                type
+            }));
+    });
+    return async (req, res, next)=>{
+        const vite = await vitePromise;
+        if (req.url?.startsWith("/node_modules/")) {
+            // HACK re-export "?v=..." URL to avoid dual module hazard.
+            const fname = _nodepath.default.join(vite.config.root, req.url);
+            for (const item of vite.moduleGraph.idToModuleMap.values()){
+                if (item.file === fname && item.url !== req.url) {
+                    res.setHeader("Content-Type", "application/javascript");
+                    res.statusCode = 200;
+                    res.end(`export * from "${item.url}";`, "utf8");
+                    return;
+                }
+            }
+        }
+        vite.middlewares(req, res, next);
+    };
+}