waku 0.21.1 → 0.21.2

package/README.md

@@ -1007,7 +1007,7 @@ Note: When rendering in static mode, please be sure to return `render: 'static'`
 
 ```
 npm run build -- --with-cloudflare
-npx wrangler dev # or deploy
+npx wrangler pages dev # or deploy
 ```
 
 ### PartyKit (experimental)

package/dist/client.js

@@ -1,6 +1,6 @@
 /// <reference types="react/canary" />
 'use client';
-import { Component, createContext, createElement, memo, use, useCallback, useEffect, useState, startTransition } from 'react';
+import { Component, createContext, createElement, memo, use, useCallback, useEffect, useState } from 'react';
 import RSDWClient from 'react-server-dom-webpack/client';
 import { encodeInput, encodeActionId } from './lib/renderers/utils.js';
 const { createFromFetch, encodeReply } = RSDWClient;
@@ -62,10 +62,8 @@ const defaultFetchCache = {};
         callServer: (actionId, args)=>callServerRSC(actionId, args, fetchCache)
     });
     fetchCache[ON_FETCH_DATA]?.(data);
-    startTransition(()=>{
-        // FIXME this causes rerenders even if data is empty
-        fetchCache[SET_ELEMENTS]?.((prev)=>mergeElements(prev, data));
-    });
+    // FIXME this causes rerenders even if data is empty
+    fetchCache[SET_ELEMENTS]?.((prev)=>mergeElements(prev, data));
     return (await data)._value;
 };
 const prefetchedParams = new WeakMap();
@@ -126,9 +124,7 @@ export const Root = ({ initialInput, initialParams, fetchCache = defaultFetchCac
         // clear cache entry before fetching
         delete fetchCache[ENTRY];
         const data = fetchRSC(input, params, fetchCache);
-        startTransition(()=>{
-            setElements((prev)=>mergeElements(prev, data));
-        });
+        setElements((prev)=>mergeElements(prev, data));
     }, [
         fetchCache
     ]);

package/dist/lib/builder/build.js

@@ -2,8 +2,9 @@ import { Readable } from 'node:stream';
 import { pipeline } from 'node:stream/promises';
 import { build as buildVite, resolveConfig as resolveViteConfig } from 'vite';
 import viteReact from '@vitejs/plugin-react';
+import { unstable_getPlatformObject } from '../../server.js';
 import { resolveConfig, EXTENSIONS } from '../config.js';
-import { decodeFilePathFromAbsolute, extname, filePathToFileURL, fileURLToFilePath, joinPath } from '../utils/path.js';
+import { decodeFilePathFromAbsolute, extname, filePathToFileURL, fileURLToFilePath, getPathMapping, joinPath } from '../utils/path.js';
 import { appendFile, createWriteStream, existsSync, mkdir, readdir, readFile, rename, unlink, writeFile } from '../utils/node-fs.js';
 import { encodeInput, generatePrefetchCode } from '../renderers/utils.js';
 import { getBuildConfig, getSsrConfig, renderRsc, SERVER_MODULE_MAP } from '../renderers/rsc-renderer.js';
@@ -14,16 +15,16 @@ import { rscAnalyzePlugin } from '../plugins/vite-plugin-rsc-analyze.js';
 import { nonjsResolvePlugin } from '../plugins/vite-plugin-nonjs-resolve.js';
 import { rscTransformPlugin } from '../plugins/vite-plugin-rsc-transform.js';
 import { rscEntriesPlugin } from '../plugins/vite-plugin-rsc-entries.js';
-import { rscServePlugin } from '../plugins/vite-plugin-rsc-serve.js';
 import { rscEnvPlugin } from '../plugins/vite-plugin-rsc-env.js';
 import { rscPrivatePlugin } from '../plugins/vite-plugin-rsc-private.js';
 import { rscManagedPlugin } from '../plugins/vite-plugin-rsc-managed.js';
-import { emitVercelOutput } from './output-vercel.js';
-import { emitNetlifyOutput } from './output-netlify.js';
-import { emitCloudflareOutput } from './output-cloudflare.js';
-import { emitPartyKitOutput } from './output-partykit.js';
-import { emitAwsLambdaOutput } from './output-aws-lambda.js';
-import { DIST_ENTRIES_JS, DIST_SERVE_JS, DIST_PUBLIC, DIST_ASSETS, DIST_SSR } from './constants.js';
+import { DIST_ENTRIES_JS, DIST_PUBLIC, DIST_ASSETS, DIST_SSR } from './constants.js';
+import { deployVercelPlugin } from '../plugins/vite-plugin-deploy-vercel.js';
+import { deployNetlifyPlugin } from '../plugins/vite-plugin-deploy-netlify.js';
+import { deployCloudflarePlugin } from '../plugins/vite-plugin-deploy-cloudflare.js';
+import { deployDenoPlugin } from '../plugins/vite-plugin-deploy-deno.js';
+import { deployPartykitPlugin } from '../plugins/vite-plugin-deploy-partykit.js';
+import { deployAwsLambdaPlugin } from '../plugins/vite-plugin-deploy-aws-lambda.js';
 // TODO this file and functions in it are too long. will fix.
 // Upstream issue: https://github.com/rollup/rollup/issues/4699
 const onwarn = (warning, defaultHandler)=>{
@@ -34,6 +35,14 @@ const onwarn = (warning, defaultHandler)=>{
     }
     defaultHandler(warning);
 };
+const deployPlugins = (config)=>[
+        deployVercelPlugin(config),
+        deployNetlifyPlugin(config),
+        deployCloudflarePlugin(config),
+        deployDenoPlugin(config),
+        deployPartykitPlugin(config),
+        deployAwsLambdaPlugin(config)
+    ];
 const analyzeEntries = async (rootDir, config)=>{
     const wakuClientDist = decodeFilePathFromAbsolute(joinPath(fileURLToFilePath(import.meta.url), '../../../client.js'));
     const clientFileSet = new Set([
@@ -131,7 +140,7 @@ const analyzeEntries = async (rootDir, config)=>{
     };
 };
 // For RSC
-const buildServerBundle = async (rootDir, env, config, clientEntryFiles, serverEntryFiles, serverModuleFiles, serve, isNodeCompatible, partial)=>{
+const buildServerBundle = async (rootDir, env, config, clientEntryFiles, serverEntryFiles, serverModuleFiles, isNodeCompatible, partial)=>{
     const serverBuildOutput = await buildVite({
         plugins: [
             nonjsResolvePlugin(),
@@ -174,15 +183,7 @@ const buildServerBundle = async (rootDir, env, config, clientEntryFiles, serverE
                         ]))
                 }
             }),
-            ...serve ? [
-                rscServePlugin({
-                    ...config,
-                    distServeJs: DIST_SERVE_JS,
-                    distPublic: DIST_PUBLIC,
-                    srcServeFile: decodeFilePathFromAbsolute(joinPath(fileURLToFilePath(import.meta.url), `../serve-${serve}.js`)),
-                    serve
-                })
-            ] : []
+            ...deployPlugins(config)
         ],
         ssr: isNodeCompatible ? {
             resolve: {
@@ -429,6 +430,29 @@ const pathSpec2pathname = (pathSpec)=>{
     }
     return '/' + pathSpec.map(({ name })=>name).join('/');
 };
+const willEmitPublicIndexHtml = async (env, config, distEntries, buildConfig)=>{
+    const hasConfig = buildConfig.some(({ pathname })=>{
+        const pathSpec = typeof pathname === 'string' ? pathname2pathSpec(pathname) : pathname;
+        return !!getPathMapping(pathSpec, '/');
+    });
+    if (!hasConfig) {
+        return false;
+    }
+    try {
+        return !!await getSsrConfig({
+            env,
+            config,
+            pathname: '/',
+            searchParams: new URLSearchParams()
+        }, {
+            isDev: false,
+            entries: distEntries
+        });
+    } catch  {
+        // HACK to pass e2e tests
+        return false;
+    }
+};
 const emitHtmlFiles = async (rootDir, env, config, distEntriesFile, distEntries, buildConfig, getClientModules, clientBuildOutput)=>{
     const nonJsAssets = clientBuildOutput.output.flatMap(({ type, fileName })=>type === 'asset' && !fileName.endsWith('.js') ? [
             fileName
@@ -439,8 +463,7 @@ const emitHtmlFiles = async (rootDir, env, config, distEntriesFile, distEntries,
     const publicIndexHtml = await readFile(publicIndexHtmlFile, {
         encoding: 'utf8'
     });
-    if (buildConfig.length) {
-        // Delete the default index.html file unless buildConfig is empty.
+    if (await willEmitPublicIndexHtml(env, config, distEntries, buildConfig)) {
         await unlink(publicIndexHtmlFile);
     }
     const publicIndexHtmlHead = publicIndexHtml.replace(/.*?<head>(.*?)<\/head>.*/s, '$1');
@@ -525,16 +548,70 @@ export const publicIndexHtml = ${JSON.stringify(publicIndexHtml)};
 `;
     await appendFile(distEntriesFile, code);
 };
+// For Deploy
+const buildDeploy = async (rootDir, config)=>{
+    const DUMMY = 'dummy-entry';
+    await buildVite({
+        plugins: [
+            {
+                // FIXME This is too hacky. There must be a better way.
+                name: 'dummy-entry-plugin',
+                resolveId (source) {
+                    if (source === DUMMY) {
+                        return source;
+                    }
+                },
+                load (id) {
+                    if (id === DUMMY) {
+                        return '';
+                    }
+                },
+                generateBundle (_options, bundle) {
+                    Object.entries(bundle).forEach(([key, value])=>{
+                        if (value.name === DUMMY) {
+                            delete bundle[key];
+                        }
+                    });
+                }
+            },
+            ...deployPlugins(config)
+        ],
+        publicDir: false,
+        build: {
+            emptyOutDir: false,
+            ssr: true,
+            rollupOptions: {
+                onwarn: (warning, warn)=>{
+                    if (!warning.message.startsWith('Generated an empty chunk:')) {
+                        warn(warning);
+                    }
+                },
+                input: {
+                    [DUMMY]: DUMMY
+                }
+            },
+            outDir: joinPath(rootDir, config.distDir)
+        }
+    });
+};
 export async function build(options) {
     const env = options.env || {};
     const config = await resolveConfig(options.config);
     const rootDir = (await resolveViteConfig({}, 'build', 'production', 'production')).root;
     const distEntriesFile = joinPath(rootDir, config.distDir, DIST_ENTRIES_JS);
     const isNodeCompatible = options.deploy !== 'cloudflare' && options.deploy !== 'partykit' && options.deploy !== 'deno';
+    const platformObject = unstable_getPlatformObject();
+    platformObject.buildOptions ||= {};
+    platformObject.buildOptions.deploy = options.deploy;
+    platformObject.buildOptions.unstable_phase = 'analyzeEntries';
     const { clientEntryFiles, serverEntryFiles, serverModuleFiles } = await analyzeEntries(rootDir, config);
-    const serverBuildOutput = await buildServerBundle(rootDir, env, config, clientEntryFiles, serverEntryFiles, serverModuleFiles, (options.deploy === 'vercel-serverless' ? 'vercel' : false) || (options.deploy === 'netlify-functions' ? 'netlify' : false) || (options.deploy === 'cloudflare' ? 'cloudflare' : false) || (options.deploy === 'partykit' ? 'partykit' : false) || (options.deploy === 'deno' ? 'deno' : false) || (options.deploy === 'aws-lambda' ? 'aws-lambda' : false), isNodeCompatible, !!options.partial);
+    platformObject.buildOptions.unstable_phase = 'buildServerBundle';
+    const serverBuildOutput = await buildServerBundle(rootDir, env, config, clientEntryFiles, serverEntryFiles, serverModuleFiles, isNodeCompatible, !!options.partial);
+    platformObject.buildOptions.unstable_phase = 'buildSsrBundle';
     await buildSsrBundle(rootDir, env, config, clientEntryFiles, serverEntryFiles, serverBuildOutput, isNodeCompatible, !!options.partial);
+    platformObject.buildOptions.unstable_phase = 'buildClientBundle';
     const clientBuildOutput = await buildClientBundle(rootDir, env, config, clientEntryFiles, serverEntryFiles, serverBuildOutput, !!options.partial);
+    delete platformObject.buildOptions.unstable_phase;
     const distEntries = await import(filePathToFileURL(distEntriesFile));
     // TODO: Add progress indication for static builds.
     const buildConfig = await getBuildConfig({
@@ -543,18 +620,10 @@ export async function build(options) {
     }, {
         entries: distEntries
     });
-    await appendFile(distEntriesFile, `export const buildConfig = ${JSON.stringify(buildConfig)};`);
     const { getClientModules } = await emitRscFiles(rootDir, env, config, distEntries, buildConfig);
     await emitHtmlFiles(rootDir, env, config, distEntriesFile, distEntries, buildConfig, getClientModules, clientBuildOutput);
-    if (options.deploy?.startsWith('vercel-')) {
-        await emitVercelOutput(rootDir, config, DIST_SERVE_JS, options.deploy.slice('vercel-'.length));
-    } else if (options.deploy?.startsWith('netlify-')) {
-        await emitNetlifyOutput(rootDir, config, DIST_SERVE_JS, options.deploy.slice('netlify-'.length));
-    } else if (options.deploy === 'cloudflare') {
-        await emitCloudflareOutput(rootDir, config, DIST_SERVE_JS);
-    } else if (options.deploy === 'partykit') {
-        await emitPartyKitOutput(rootDir, config, DIST_SERVE_JS);
-    } else if (options.deploy === 'aws-lambda') {
-        await emitAwsLambdaOutput(config);
-    }
+    platformObject.buildOptions.unstable_phase = 'buildDeploy';
+    await buildDeploy(rootDir, config);
+    delete platformObject.buildOptions.unstable_phase;
+    await appendFile(distEntriesFile, `export const buildData = ${JSON.stringify(platformObject.buildData)};`);
 }

package/dist/lib/middleware/dev-server-impl.js

@@ -127,15 +127,17 @@ const createMainViteServer = (env, configPromise)=>{
         return vite;
     });
     const loadServerModuleMain = async (idOrFileURL)=>{
+        const vite = await vitePromise;
         if (idOrFileURL === 'waku' || idOrFileURL.startsWith('waku/')) {
             // HACK `external: ['waku']` doesn't do the same
             return import(/* @vite-ignore */ idOrFileURL);
         }
         if (idOrFileURL.startsWith('file://') && idOrFileURL.includes('/node_modules/')) {
             // HACK node_modules should be externalized
-            return import(/* @vite-ignore */ fileURLToFilePath(idOrFileURL));
+            const file = fileURLToFilePath(idOrFileURL);
+            const fileWithAbsolutePath = file.startsWith('/') ? file : joinPath(vite.config.root, file);
+            return import(/* @vite-ignore */ fileWithAbsolutePath);
         }
-        const vite = await vitePromise;
         return vite.ssrLoadModule(idOrFileURL.startsWith('file://') ? fileURLToFilePath(idOrFileURL) : idOrFileURL);
     };
     const transformIndexHtml = async (pathname)=>{

package/dist/lib/middleware/rsc.js

@@ -15,7 +15,7 @@ export const rsc = (options)=>{
         if (ctx.req.url.pathname.startsWith(basePrefix)) {
             const { headers } = ctx.req;
             try {
-                const input = decodeInput(ctx.req.url.pathname.slice(basePrefix.length));
+                const input = decodeInput(decodeURI(ctx.req.url.pathname.slice(basePrefix.length)));
                 const args = {
                     env,
                     config,

package/dist/lib/plugins/vite-plugin-deploy-aws-lambda.d.ts

@@ -0,0 +1,5 @@
+import type { Plugin } from 'vite';
+export declare function deployAwsLambdaPlugin(opts: {
+    srcDir: string;
+    distDir: string;
+}): Plugin;

package/dist/lib/plugins/vite-plugin-deploy-aws-lambda.js

@@ -0,0 +1,52 @@
+import path from 'node:path';
+import { existsSync, writeFileSync } from 'node:fs';
+import { normalizePath } from 'vite';
+// HACK: Depending on a different plugin isn't ideal.
+// Maybe we could put in vite config object?
+import { SRC_ENTRIES } from './vite-plugin-rsc-managed.js';
+import { unstable_getPlatformObject } from '../../server.js';
+import { EXTENSIONS } from '../config.js';
+import { decodeFilePathFromAbsolute, extname, fileURLToFilePath, joinPath } from '../utils/path.js';
+import { DIST_SERVE_JS, DIST_PUBLIC } from '../builder/constants.js';
+const resolveFileName = (fname)=>{
+    for (const ext of EXTENSIONS){
+        const resolvedName = fname.slice(0, -extname(fname).length) + ext;
+        if (existsSync(resolvedName)) {
+            return resolvedName;
+        }
+    }
+    return fname; // returning the default one
+};
+const srcServeFile = decodeFilePathFromAbsolute(joinPath(fileURLToFilePath(import.meta.url), '../../builder/serve-aws-lambda.js'));
+export function deployAwsLambdaPlugin(opts) {
+    const platformObject = unstable_getPlatformObject();
+    return {
+        name: 'deploy-aws-lambda-plugin',
+        config (viteConfig) {
+            const { deploy, unstable_phase } = platformObject.buildOptions || {};
+            if (unstable_phase !== 'buildServerBundle' || deploy !== 'aws-lambda') {
+                return;
+            }
+            // FIXME This seems too hacky (The use of viteConfig.root, '.', path.resolve and resolveFileName)
+            const entriesFile = normalizePath(resolveFileName(path.resolve(viteConfig.root || '.', opts.srcDir, SRC_ENTRIES + '.jsx')));
+            const { input } = viteConfig.build?.rollupOptions ?? {};
+            if (input && !(typeof input === 'string') && !(input instanceof Array)) {
+                input[DIST_SERVE_JS.replace(/\.js$/, '')] = srcServeFile;
+            }
+            viteConfig.define = {
+                ...viteConfig.define,
+                'import.meta.env.WAKU_ENTRIES_FILE': JSON.stringify(entriesFile),
+                'import.meta.env.WAKU_CONFIG_PUBLIC_DIR': JSON.stringify(DIST_PUBLIC)
+            };
+        },
+        closeBundle () {
+            const { deploy, unstable_phase } = platformObject.buildOptions || {};
+            if (unstable_phase !== 'buildDeploy' || deploy !== 'aws-lambda') {
+                return;
+            }
+            writeFileSync(path.join(opts.distDir, 'package.json'), JSON.stringify({
+                type: 'module'
+            }, null, 2));
+        }
+    };
+}

package/dist/lib/plugins/vite-plugin-deploy-cloudflare.d.ts

@@ -0,0 +1,7 @@
+import type { Plugin } from 'vite';
+export declare function deployCloudflarePlugin(opts: {
+    srcDir: string;
+    distDir: string;
+    rscPath: string;
+    privateDir: string;
+}): Plugin;

package/dist/lib/plugins/vite-plugin-deploy-cloudflare.js

@@ -0,0 +1,143 @@
+import path from 'node:path';
+import { existsSync, mkdirSync, readdirSync, renameSync, rmSync, writeFileSync } from 'node:fs';
+import { normalizePath } from 'vite';
+// HACK: Depending on a different plugin isn't ideal.
+// Maybe we could put in vite config object?
+import { SRC_ENTRIES } from './vite-plugin-rsc-managed.js';
+import { unstable_getPlatformObject } from '../../server.js';
+import { EXTENSIONS } from '../config.js';
+import { decodeFilePathFromAbsolute, extname, fileURLToFilePath, joinPath } from '../utils/path.js';
+import { DIST_SERVE_JS, DIST_PUBLIC } from '../builder/constants.js';
+const resolveFileName = (fname)=>{
+    for (const ext of EXTENSIONS){
+        const resolvedName = fname.slice(0, -extname(fname).length) + ext;
+        if (existsSync(resolvedName)) {
+            return resolvedName;
+        }
+    }
+    return fname; // returning the default one
+};
+const srcServeFile = decodeFilePathFromAbsolute(joinPath(fileURLToFilePath(import.meta.url), '../../builder/serve-cloudflare.js'));
+const getFiles = (dir, files = [])=>{
+    const entries = readdirSync(dir, {
+        withFileTypes: true
+    });
+    for (const entry of entries){
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            getFiles(fullPath, files);
+        } else {
+            files.push(fullPath);
+        }
+    }
+    return files;
+};
+const WORKER_JS_NAME = '_worker.js';
+const ROUTES_JSON_NAME = '_routes.json';
+const HEADERS_NAME = '_headers';
+export function deployCloudflarePlugin(opts) {
+    const platformObject = unstable_getPlatformObject();
+    let rootDir;
+    return {
+        name: 'deploy-cloudflare-plugin',
+        config (viteConfig) {
+            const { deploy, unstable_phase } = platformObject.buildOptions || {};
+            if (unstable_phase !== 'buildServerBundle' || deploy !== 'cloudflare') {
+                return;
+            }
+            // FIXME This seems too hacky (The use of viteConfig.root, '.', path.resolve and resolveFileName)
+            const entriesFile = normalizePath(resolveFileName(path.resolve(viteConfig.root || '.', opts.srcDir, SRC_ENTRIES + '.jsx')));
+            const { input } = viteConfig.build?.rollupOptions ?? {};
+            if (input && !(typeof input === 'string') && !(input instanceof Array)) {
+                input[DIST_SERVE_JS.replace(/\.js$/, '')] = srcServeFile;
+            }
+            viteConfig.define = {
+                ...viteConfig.define,
+                'import.meta.env.WAKU_ENTRIES_FILE': JSON.stringify(entriesFile)
+            };
+        },
+        configResolved (config) {
+            rootDir = config.root;
+        },
+        closeBundle () {
+            const { deploy, unstable_phase } = platformObject.buildOptions || {};
+            if (unstable_phase !== 'buildDeploy' || deploy !== 'cloudflare') {
+                return;
+            }
+            const outDir = path.join(rootDir, opts.distDir);
+            // Advanced-mode Cloudflare Pages imports _worker.js
+            // and can be configured with _routes.json to serve other static root files
+            mkdirSync(path.join(outDir, WORKER_JS_NAME));
+            const outPaths = readdirSync(outDir);
+            for (const p of outPaths){
+                if (p === WORKER_JS_NAME) {
+                    continue;
+                }
+                renameSync(path.join(outDir, p), path.join(outDir, WORKER_JS_NAME, p));
+            }
+            const workerEntrypoint = path.join(outDir, WORKER_JS_NAME, 'index.js');
+            if (!existsSync(workerEntrypoint)) {
+                writeFileSync(workerEntrypoint, `
+import server from './${DIST_SERVE_JS}'
+
+export default {
+  ...server
+}
+`);
+            }
+            // Create _routes.json if one doesn't already exist in the public dir
+            // https://developers.cloudflare.com/pages/functions/routing/#functions-invocation-routes
+            const routesFile = path.join(outDir, ROUTES_JSON_NAME);
+            const publicDir = path.join(outDir, WORKER_JS_NAME, DIST_PUBLIC);
+            if (!existsSync(path.join(publicDir, ROUTES_JSON_NAME))) {
+                // exclude strategy
+                const staticPaths = [
+                    '/assets/*'
+                ];
+                const paths = getFiles(publicDir);
+                for (const p of paths){
+                    const basePath = path.dirname(p.replace(publicDir, '')) || '/';
+                    const name = path.basename(p);
+                    const entry = name === 'index.html' ? basePath + (basePath !== '/' ? '/' : '') : path.join(basePath, name.replace(/\.html$/, ''));
+                    if (entry.startsWith('/assets/') || entry.startsWith('/' + WORKER_JS_NAME + '/') || entry === '/' + WORKER_JS_NAME || entry === '/' + ROUTES_JSON_NAME || entry === '/' + HEADERS_NAME) {
+                        continue;
+                    }
+                    if (!staticPaths.includes(entry)) {
+                        staticPaths.push(entry);
+                    }
+                }
+                const MAX_CLOUDFLARE_RULES = 100;
+                if (staticPaths.length + 1 > MAX_CLOUDFLARE_RULES) {
+                    throw new Error(`The number of static paths exceeds the limit of ${MAX_CLOUDFLARE_RULES}. ` + `You need to create a custom ${ROUTES_JSON_NAME} file in the public folder. ` + `See https://developers.cloudflare.com/pages/functions/routing/#functions-invocation-routes`);
+                }
+                const staticRoutes = {
+                    version: 1,
+                    include: [
+                        '/*'
+                    ],
+                    exclude: staticPaths
+                };
+                writeFileSync(routesFile, JSON.stringify(staticRoutes));
+            }
+            // Move the public files to the root of the dist folder
+            const publicPaths = readdirSync(path.join(outDir, WORKER_JS_NAME, DIST_PUBLIC));
+            for (const p of publicPaths){
+                renameSync(path.join(outDir, WORKER_JS_NAME, DIST_PUBLIC, p), path.join(outDir, p));
+            }
+            rmSync(path.join(outDir, WORKER_JS_NAME, DIST_PUBLIC), {
+                recursive: true,
+                force: true
+            });
+            const wranglerTomlFile = path.join(rootDir, 'wrangler.toml');
+            if (!existsSync(wranglerTomlFile)) {
+                writeFileSync(wranglerTomlFile, `
+# See https://developers.cloudflare.com/pages/functions/wrangler-configuration/
+name = "waku-project"
+compatibility_date = "2024-04-03"
+compatibility_flags = [ "nodejs_als" ]
+pages_build_output_dir = "./dist"
+`);
+            }
+        }
+    };
+}

package/dist/lib/plugins/vite-plugin-deploy-deno.d.ts

@@ -0,0 +1,5 @@
+import type { Plugin } from 'vite';
+export declare function deployDenoPlugin(opts: {
+    srcDir: string;
+    distDir: string;
+}): Plugin;

package/dist/lib/plugins/{vite-plugin-rsc-serve.js → vite-plugin-deploy-deno.js}

@@ -1,11 +1,13 @@
-import { existsSync } from 'node:fs';
 import path from 'node:path';
+import { existsSync } from 'node:fs';
 import { normalizePath } from 'vite';
 // HACK: Depending on a different plugin isn't ideal.
 // Maybe we could put in vite config object?
 import { SRC_ENTRIES } from './vite-plugin-rsc-managed.js';
+import { unstable_getPlatformObject } from '../../server.js';
 import { EXTENSIONS } from '../config.js';
-import { extname } from '../utils/path.js';
+import { decodeFilePathFromAbsolute, extname, fileURLToFilePath, joinPath } from '../utils/path.js';
+import { DIST_SERVE_JS, DIST_PUBLIC } from '../builder/constants.js';
 const resolveFileName = (fname)=>{
     for (const ext of EXTENSIONS){
         const resolvedName = fname.slice(0, -extname(fname).length) + ext;
@@ -15,32 +17,28 @@ const resolveFileName = (fname)=>{
     }
     return fname; // returning the default one
 };
-export function rscServePlugin(opts) {
+const srcServeFile = decodeFilePathFromAbsolute(joinPath(fileURLToFilePath(import.meta.url), '../../builder/serve-deno.js'));
+export function deployDenoPlugin(opts) {
+    const platformObject = unstable_getPlatformObject();
     return {
-        name: 'rsc-serve-plugin',
+        name: 'deploy-deno-plugin',
         config (viteConfig) {
+            const { deploy, unstable_phase } = platformObject.buildOptions || {};
+            if (unstable_phase !== 'buildServerBundle' || deploy !== 'deno') {
+                return;
+            }
             // FIXME This seems too hacky (The use of viteConfig.root, '.', path.resolve and resolveFileName)
             const entriesFile = normalizePath(resolveFileName(path.resolve(viteConfig.root || '.', opts.srcDir, SRC_ENTRIES + '.jsx')));
             const { input } = viteConfig.build?.rollupOptions ?? {};
             if (input && !(typeof input === 'string') && !(input instanceof Array)) {
-                input[opts.distServeJs.replace(/\.js$/, '')] = opts.srcServeFile;
+                input[DIST_SERVE_JS.replace(/\.js$/, '')] = srcServeFile;
             }
             viteConfig.define = {
                 ...viteConfig.define,
                 'import.meta.env.WAKU_ENTRIES_FILE': JSON.stringify(entriesFile),
                 'import.meta.env.WAKU_CONFIG_DIST_DIR': JSON.stringify(opts.distDir),
-                'import.meta.env.WAKU_CONFIG_PUBLIC_DIR': JSON.stringify(opts.distPublic)
+                'import.meta.env.WAKU_CONFIG_PUBLIC_DIR': JSON.stringify(DIST_PUBLIC)
             };
-            if (opts.serve === 'partykit') {
-                viteConfig.build ||= {};
-                viteConfig.build.rollupOptions ||= {};
-                viteConfig.build.rollupOptions.external ||= [];
-                if (Array.isArray(viteConfig.build.rollupOptions.external)) {
-                    viteConfig.build.rollupOptions.external.push('hono');
-                } else {
-                    throw new Error('Unsupported: build.rollupOptions.external is not an array');
-                }
-            }
         }
     };
 }

package/dist/lib/plugins/vite-plugin-deploy-netlify.d.ts

@@ -0,0 +1,6 @@
+import type { Plugin } from 'vite';
+export declare function deployNetlifyPlugin(opts: {
+    srcDir: string;
+    distDir: string;
+    privateDir: string;
+}): Plugin;

package/dist/lib/plugins/vite-plugin-deploy-netlify.js

@@ -0,0 +1,78 @@
+import path from 'node:path';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { normalizePath } from 'vite';
+// HACK: Depending on a different plugin isn't ideal.
+// Maybe we could put in vite config object?
+import { SRC_ENTRIES } from './vite-plugin-rsc-managed.js';
+import { unstable_getPlatformObject } from '../../server.js';
+import { EXTENSIONS } from '../config.js';
+import { decodeFilePathFromAbsolute, extname, fileURLToFilePath, joinPath } from '../utils/path.js';
+import { DIST_SERVE_JS, DIST_PUBLIC } from '../builder/constants.js';
+const resolveFileName = (fname)=>{
+    for (const ext of EXTENSIONS){
+        const resolvedName = fname.slice(0, -extname(fname).length) + ext;
+        if (existsSync(resolvedName)) {
+            return resolvedName;
+        }
+    }
+    return fname; // returning the default one
+};
+const srcServeFile = decodeFilePathFromAbsolute(joinPath(fileURLToFilePath(import.meta.url), '../../builder/serve-netlify.js'));
+export function deployNetlifyPlugin(opts) {
+    const platformObject = unstable_getPlatformObject();
+    let rootDir;
+    return {
+        name: 'deploy-netlify-plugin',
+        config (viteConfig) {
+            const { deploy, unstable_phase } = platformObject.buildOptions || {};
+            if (unstable_phase !== 'buildServerBundle' || deploy !== 'netlify-functions' && deploy !== 'netlify-static') {
+                return;
+            }
+            // FIXME This seems too hacky (The use of viteConfig.root, '.', path.resolve and resolveFileName)
+            const entriesFile = normalizePath(resolveFileName(path.resolve(viteConfig.root || '.', opts.srcDir, SRC_ENTRIES + '.jsx')));
+            const { input } = viteConfig.build?.rollupOptions ?? {};
+            if (input && !(typeof input === 'string') && !(input instanceof Array)) {
+                input[DIST_SERVE_JS.replace(/\.js$/, '')] = srcServeFile;
+            }
+            viteConfig.define = {
+                ...viteConfig.define,
+                'import.meta.env.WAKU_ENTRIES_FILE': JSON.stringify(entriesFile)
+            };
+        },
+        configResolved (config) {
+            rootDir = config.root;
+        },
+        closeBundle () {
+            const { deploy, unstable_phase } = platformObject.buildOptions || {};
+            if (unstable_phase !== 'buildDeploy' || deploy !== 'netlify-functions' && deploy !== 'netlify-static') {
+                return;
+            }
+            if (deploy === 'netlify-functions') {
+                const functionsDir = path.join(rootDir, 'netlify/functions');
+                mkdirSync(functionsDir, {
+                    recursive: true
+                });
+                const notFoundFile = path.join(rootDir, opts.distDir, DIST_PUBLIC, '404.html');
+                const notFoundHtml = existsSync(notFoundFile) ? readFileSync(notFoundFile, 'utf8') : null;
+                writeFileSync(path.join(functionsDir, 'serve.js'), `
+globalThis.__WAKU_NOT_FOUND_HTML__ = ${JSON.stringify(notFoundHtml)};
+export { default } from '../../${opts.distDir}/${DIST_SERVE_JS}';
+export const config = {
+  preferStatic: true,
+  path: ['/', '/*'],
+};
+`);
+            }
+            const netlifyTomlFile = path.join(rootDir, 'netlify.toml');
+            if (!existsSync(netlifyTomlFile)) {
+                writeFileSync(netlifyTomlFile, `
+[build]
+  command = "npm run build -- --with-netlify"
+  publish = "${opts.distDir}/${DIST_PUBLIC}"
+[functions]
+  included_files = ["${opts.privateDir}/**"]
+`);
+            }
+        }
+    };
+}

package/dist/lib/plugins/vite-plugin-deploy-partykit.d.ts

@@ -0,0 +1,5 @@
+import type { Plugin } from 'vite';
+export declare function deployPartykitPlugin(opts: {
+    srcDir: string;
+    distDir: string;
+}): Plugin;