@bleedingdev/modern-js-runtime 3.2.0-ultramodern.0

package/dist/esm-node/cli/ssr/index.mjs

@@ -0,0 +1,192 @@
+import __rslib_shim_module__ from "node:module";
+const require = /*#__PURE__*/ __rslib_shim_module__.createRequire(/*#__PURE__*/ (()=>import.meta.url)());
+import { LOADABLE_STATS_FILE, isUseSSRBundle } from "@modern-js/utils";
+import path from "path";
+import loadable_bundler_plugin from "./loadable-bundler-plugin.mjs";
+import { resolveSSRMode } from "./mode.mjs";
+const getRspackPlugins = (rspackConfig)=>{
+    if (!rspackConfig) return [];
+    const rspackEntries = Array.isArray(rspackConfig) ? rspackConfig : [
+        rspackConfig
+    ];
+    const plugins = [];
+    for (const entry of rspackEntries){
+        if (!entry || 'function' == typeof entry || 'object' != typeof entry) continue;
+        const maybePlugins = entry.plugins;
+        if (Array.isArray(maybePlugins)) {
+            for (const plugin of maybePlugins)if (plugin) plugins.push(plugin);
+        }
+    }
+    return plugins;
+};
+const getRspackPluginName = (plugin)=>{
+    if ('string' == typeof plugin) return plugin;
+    if ('function' == typeof plugin) return plugin.name;
+    if (Array.isArray(plugin)) {
+        const [first] = plugin;
+        if (!first) return;
+        if ('string' == typeof first) return first;
+        if ('function' == typeof first) return first.name;
+        if ('object' == typeof first) return first.name || first.constructor?.name;
+        return;
+    }
+    return plugin.name || plugin.constructor?.name;
+};
+const hasServerRenderingConfig = (userConfig)=>{
+    const { output, server } = userConfig;
+    if (output?.ssg) return true;
+    if (output?.ssgByEntries && Object.keys(output.ssgByEntries).length > 0) return true;
+    if (server?.ssr) return true;
+    if (server?.ssrByEntries && Object.keys(server.ssrByEntries).length > 0) return true;
+    return false;
+};
+const isModuleFederationAppSSREnabledInConfig = (ssr)=>{
+    if (!ssr || 'object' != typeof ssr) return false;
+    return true === ssr.moduleFederationAppSSR;
+};
+const isModuleFederationAppSSREnabled = (userConfig)=>{
+    if (isModuleFederationAppSSREnabledInConfig(userConfig.server?.ssr)) return true;
+    if (userConfig.server?.ssrByEntries && 'object' == typeof userConfig.server.ssrByEntries) return Object.values(userConfig.server.ssrByEntries).some(isModuleFederationAppSSREnabledInConfig);
+    return false;
+};
+const checkUseStringSSR = (config, appDirectory, entrypoints)=>{
+    if (entrypoints && entrypoints.length > 0) {
+        for (const entrypoint of entrypoints){
+            const ssrMode = resolveSSRMode({
+                entry: entrypoint.entryName,
+                config,
+                appDirectory,
+                nestedRoutesEntry: entrypoint.nestedRoutesEntry
+            });
+            if ('string' === ssrMode) return true;
+        }
+        return false;
+    }
+    return true;
+};
+const isModuleFederationRspackPlugin = (plugin)=>{
+    const candidate = getRspackPluginName(plugin);
+    return 'string' == typeof candidate && /modulefederation/i.test(candidate);
+};
+const hasModuleFederationMarker = (config)=>{
+    if ('true' === process.env.MF_SSR_PRJ) return true;
+    const define = config.source?.define || {};
+    if ('REMOTE_IP_STRATEGY' in define || 'FEDERATION_IPV4' in define) return true;
+    const plugins = getRspackPlugins(config.tools?.rspack);
+    return plugins.some(isModuleFederationRspackPlugin);
+};
+const isNodeEnvironmentTarget = (target)=>'string' == typeof target && ('node' === target || 'async-node' === target || target.startsWith('node'));
+const shouldUseModuleFederationNodeOutput = (config)=>isNodeEnvironmentTarget(config.output?.target) && hasModuleFederationMarker(config);
+const ssrBuilderPlugin = (modernAPI, outputModule, exportLoadablePath)=>({
+        name: '@modern-js/builder-plugin-ssr',
+        setup (api) {
+            api.modifyEnvironmentConfig((config, { name, mergeEnvironmentConfig })=>{
+                const isServerEnvironment = isNodeEnvironmentTarget(config.output.target) || 'workerSSR' === name;
+                const userConfig = modernAPI.getNormalizedConfig();
+                const hasServerRendering = hasServerRenderingConfig(userConfig);
+                const hasModuleFederationRuntimeMarker = hasServerRendering && shouldUseModuleFederationNodeOutput(config);
+                const hasExplicitMfSsrFlag = isModuleFederationAppSSREnabled(userConfig);
+                const requireExplicitMfSsrFlag = 'true' === process.env.MODERN_MF_APP_SSR_REQUIRE_EXPLICIT;
+                if (hasServerRendering && hasModuleFederationRuntimeMarker && !hasExplicitMfSsrFlag) {
+                    const warningMessage = '[modernjs][mf-ssr] Module Federation SSR was auto-detected from runtime markers. Set server.ssr.moduleFederationAppSSR=true explicitly in host and remotes to avoid heuristic drift.';
+                    if (requireExplicitMfSsrFlag) throw new Error(`${warningMessage} (enforced by MODERN_MF_APP_SSR_REQUIRE_EXPLICIT=true)`);
+                    console.warn(warningMessage);
+                }
+                const isModuleFederationAppSSR = hasServerRendering && hasExplicitMfSsrFlag;
+                const useModuleFederationNodeOutput = hasServerRendering && isModuleFederationAppSSR && isNodeEnvironmentTarget(config.output.target);
+                const ssrEnv = userConfig.deploy?.worker?.ssr || userConfig.server?.rsc ? 'edge' : 'node';
+                const appContext = modernAPI.getAppContext();
+                const { appDirectory, entrypoints } = appContext;
+                const serverBundlerChain = useModuleFederationNodeOutput ? (chain)=>{
+                    chain.target('async-node');
+                    chain.output.module(false);
+                    chain.output.chunkFormat('commonjs');
+                    chain.output.chunkLoading('async-node');
+                    chain.output.library({
+                        ...chain.output.get('library') || {},
+                        type: 'commonjs-module'
+                    });
+                } : void 0;
+                const useLoadablePlugin = isUseSSRBundle(userConfig) && !isServerEnvironment && checkUseStringSSR(userConfig, appDirectory, entrypoints);
+                const outputConfig = {
+                    module: isServerEnvironment && !useModuleFederationNodeOutput && outputModule
+                };
+                const useLoadableComponents = isUseSSRBundle(userConfig) && checkUseStringSSR(userConfig, appDirectory, entrypoints);
+                return mergeEnvironmentConfig(config, {
+                    source: {
+                        define: {
+                            'process.env.MODERN_TARGET': isServerEnvironment ? JSON.stringify('node') : JSON.stringify('browser'),
+                            'process.env.MODERN_SSR_ENV': JSON.stringify(ssrEnv),
+                            'process.env.MODERN_MF_APP_SSR': JSON.stringify(isModuleFederationAppSSR)
+                        }
+                    },
+                    output: outputConfig,
+                    tools: {
+                        bundlerChain: serverBundlerChain || (useLoadablePlugin ? (chain)=>{
+                            chain.plugin('loadable').use(loadable_bundler_plugin, [
+                                {
+                                    filename: LOADABLE_STATS_FILE
+                                }
+                            ]);
+                        } : void 0),
+                        swc: useLoadableComponents ? {
+                            jsc: {
+                                experimental: {
+                                    plugins: [
+                                        [
+                                            require.resolve('@swc/plugin-loadable-components'),
+                                            {
+                                                signatures: [
+                                                    {
+                                                        name: 'default',
+                                                        from: '@loadable/component'
+                                                    },
+                                                    {
+                                                        name: 'lazy',
+                                                        from: '@loadable/component'
+                                                    },
+                                                    {
+                                                        name: 'default',
+                                                        from: exportLoadablePath
+                                                    },
+                                                    {
+                                                        name: 'lazy',
+                                                        from: exportLoadablePath
+                                                    }
+                                                ]
+                                            }
+                                        ]
+                                    ]
+                                }
+                            }
+                        } : void 0
+                    }
+                });
+            });
+        }
+    });
+const ssrPlugin = ()=>({
+        name: '@modern-js/plugin-ssr',
+        required: [
+            '@modern-js/runtime'
+        ],
+        setup: (api)=>{
+            const appContext = api.getAppContext();
+            const exportLoadablePath = `@${appContext.metaName}/runtime/loadable`;
+            const runtimeUtilsPath = require.resolve('@modern-js/runtime-utils/node');
+            const aliasPath = runtimeUtilsPath.replace(`${path.sep}cjs${path.sep}`, `${path.sep}esm${path.sep}`).replace(/\.js$/, '.mjs');
+            api.config(()=>({
+                    builderPlugins: [
+                        ssrBuilderPlugin(api, 'module' === appContext.moduleType, exportLoadablePath)
+                    ],
+                    resolve: {
+                        alias: {
+                            '@modern-js/runtime-utils/node$': aliasPath
+                        }
+                    }
+                }));
+        }
+    });
+const cli_ssr = ssrPlugin;
+export default cli_ssr;
+export { shouldUseModuleFederationNodeOutput, ssrPlugin };

package/dist/esm-node/cli/ssr/loadable-bundler-plugin.mjs

@@ -0,0 +1,88 @@
+import "node:module";
+import { fs } from "@modern-js/utils";
+import path_0 from "path";
+const normalizeChunkId = (id)=>'string' == typeof id && /^\d+$/.test(id) ? Number(id) : id;
+const normalizeChunkGroup = (group)=>({
+        ...group,
+        chunks: (group.chunks || []).map(normalizeChunkId)
+    });
+class LoadablePlugin {
+    apply(compiler) {
+        this.compiler = compiler;
+        compiler.options.output.chunkLoadingGlobal = this.opts.chunkLoadingGlobal;
+        if (this.opts.outputAsset || this.opts.writeToDisk) compiler.hooks.make.tap(LoadablePlugin.name, (compilation)=>{
+            compilation.hooks.processAssets.tap({
+                name: LoadablePlugin.name,
+                stage: compiler.webpack.Compilation.PROCESS_ASSETS_STAGE_REPORT
+            }, ()=>{
+                const asset = this.handleEmit(compilation);
+                if (asset) compilation.emitAsset(this.opts.filename, asset);
+            });
+        });
+    }
+    handleEmit(compilation) {
+        const stats = compilation.getStats().toJson({
+            all: false,
+            assets: true,
+            cachedAssets: true,
+            chunks: true,
+            chunkGroups: true,
+            entrypoints: true,
+            chunkGroupChildren: true,
+            hash: true,
+            ids: true,
+            outputPath: true,
+            publicPath: true
+        });
+        const namedChunkGroups = {};
+        for (const [name, group] of Object.entries(stats.namedChunkGroups || {}))namedChunkGroups[name] = normalizeChunkGroup(group);
+        const entrypoints = {};
+        for (const [name, ep] of Object.entries(stats.entrypoints || {}))entrypoints[name] = normalizeChunkGroup(ep);
+        const output = {
+            ...stats,
+            namedChunkGroups,
+            entrypoints,
+            generator: 'loadable-components',
+            chunks: [
+                ...stats.chunks || []
+            ].map((chunk)=>({
+                    id: normalizeChunkId(chunk.id),
+                    files: [
+                        ...chunk.files || []
+                    ]
+                }))
+        };
+        const result = JSON.stringify(output, null, 2);
+        if (this.opts.writeToDisk) this.writeAssetsFile(result);
+        if (this.opts.outputAsset) return {
+            source () {
+                return result;
+            },
+            size () {
+                return result.length;
+            }
+        };
+        return null;
+    }
+    writeAssetsFile(manifest) {
+        const outputFolder = this.compiler?.options.output.path;
+        const outputFile = path_0.resolve(outputFolder || '', this.opts.filename);
+        fs.outputFileSync(outputFile, manifest);
+    }
+    constructor({ filename = 'loadable-stats.json', path, writeToDisk, outputAsset = true, chunkLoadingGlobal = '__LOADABLE_LOADED_CHUNKS__' } = {
+        filename: 'loadable-stats.json',
+        outputAsset: true,
+        chunkLoadingGlobal: '__LOADABLE_LOADED_CHUNKS__'
+    }){
+        this.opts = {
+            filename,
+            path,
+            writeToDisk,
+            outputAsset,
+            chunkLoadingGlobal
+        };
+        this.compiler = null;
+    }
+}
+const loadable_bundler_plugin = LoadablePlugin;
+export default loadable_bundler_plugin;

package/dist/esm-node/cli/ssr/mode.mjs

@@ -0,0 +1,15 @@
+import "node:module";
+function resolveSSRMode(params) {
+    const { entry, config, appDirectory, nestedRoutesEntry } = params;
+    const isSsgEnabled = config.output?.ssg || config.output?.ssgByEntries && (entry ? !!config.output.ssgByEntries[entry] : Object.keys(config.output.ssgByEntries).length > 0);
+    if (isSsgEnabled) if (nestedRoutesEntry) return 'stream';
+    else return 'string';
+    const ssr = entry ? config.server?.ssrByEntries?.[entry] || config.server?.ssr : config.server?.ssr;
+    if (void 0 !== ssr) {
+        if (!ssr) return false;
+        if ('boolean' == typeof ssr) return ssr ? 'stream' : false;
+        return 'string' === ssr.mode ? 'string' : 'stream';
+    }
+    return false;
+}
+export { resolveSSRMode };

package/dist/esm-node/cli/template.mjs

@@ -0,0 +1,212 @@
+import "node:module";
+import { JS_EXTENSIONS, findExists, formatImportPath } from "@modern-js/utils";
+import path_0 from "path";
+import { ENTRY_POINT_RUNTIME_GLOBAL_CONTEXT_FILE_NAME, ENTRY_POINT_RUNTIME_REGISTER_FILE_NAME } from "./constants.mjs";
+const genRenderStatement = ({ enableRsc, mountId, isNestedRouter })=>{
+    if (enableRsc) {
+        if (!isNestedRouter) return `render(<ModernRoot>
+                  <RscClientRoot rscPayload={data} />
+                </ModernRoot>, '${mountId || 'root'}');`;
+        return `render(<ModernRoot rscPayload={data} />, '${mountId || 'root'}');`;
+    }
+    return `render(<ModernRoot />, '${mountId || 'root'}');`;
+};
+const genRenderCode = ({ srcDirectory, internalSrcAlias, metaName, entry, customEntry, mountId, enableRsc, isNestedRouter })=>{
+    if (customEntry) return `import '${formatImportPath(entry.replace(srcDirectory, internalSrcAlias))}'`;
+    return `import { createRoot } from '@${metaName}/runtime/react';
+import { render } from '@${metaName}/runtime/browser';
+
+${enableRsc ? `import { RscClientRoot, createFromReadableStream, rscStream, callServer, setServerCallback } from '@${metaName}/runtime/rsc/client';` : ''}
+
+${enableRsc ? "setServerCallback(callServer);" : ''}
+
+${enableRsc ? `const data = createFromReadableStream(rscStream, {
+    callServer: callServer,
+  });` : ''}
+
+const ModernRoot = createRoot();
+
+${genRenderStatement({
+        enableRsc,
+        mountId,
+        isNestedRouter
+    })}`;
+};
+const entryForCSRWithRSC = ({ metaName, entryName, urlPath = '/', mountId = 'root', isNestedRouter })=>`
+  import '@${metaName}/runtime/registry/${entryName}';
+  import { render } from '@${metaName}/runtime/browser';
+  import { createRoot } from '@${metaName}/runtime/react';
+
+  import {
+    RscClientRoot,
+    createFromFetch,
+    isRedirectResponse,
+    rscStream,
+    callServer,
+    setServerCallback,
+    createFromReadableStream
+  } from '@${metaName}/runtime/rsc/client';
+
+  setServerCallback(callServer);
+
+  const handleRedirectResponse = (res) => {
+    const { headers } = res;
+    const location = headers.get('X-Modernjs-Redirect');
+    const baseUrl = headers.get('X-Modernjs-BaseUrl');
+    if (location) {
+      if (baseUrl !== '/') {
+        window.location.replace(baseUrl + location);
+      } else {
+        window.location.replace(location);
+      }
+      return;
+    }
+    return res;
+  };
+
+  ${process.env.MODERN_DISABLE_INJECT_RSC_DATA ? `
+      const data = createFromFetch(
+        fetch(location.pathname, {
+          headers: {
+            'x-rsc-tree': 'true',
+          },
+        }).then(handleRedirectResponse),
+      )
+      ` : `
+      const data = createFromReadableStream(rscStream, {
+        callServer: callServer,
+      });
+      `}
+
+  const ModernRoot = createRoot();
+
+  ${isNestedRouter ? `
+      render(
+        <ModernRoot rscPayload={data}>
+        </ModernRoot>,
+        '${mountId}',
+      );
+      ` : `
+      render(
+        <ModernRoot>
+          <RscClientRoot rscPayload={data} />
+        </ModernRoot>,
+        '${mountId}',
+      );
+      `}
+  `;
+const index = ({ srcDirectory, internalSrcAlias, metaName, entry, entryName, customEntry, mountId, enableRsc, isNestedRouter })=>`import '@${metaName}/runtime/registry/${entryName}';
+${genRenderCode({
+        srcDirectory,
+        internalSrcAlias,
+        metaName,
+        entry,
+        customEntry,
+        mountId,
+        enableRsc,
+        isNestedRouter
+    })}
+`;
+const register = ()=>`import './${ENTRY_POINT_RUNTIME_GLOBAL_CONTEXT_FILE_NAME}';
+import './${ENTRY_POINT_RUNTIME_REGISTER_FILE_NAME}';
+`;
+const getImportRuntimeConfigCode = (srcDirectory, internalSrcAlias, runtimeConfigFile)=>{
+    if (runtimeConfigFile && findExists(JS_EXTENSIONS.map((ext)=>path_0.resolve(srcDirectory, `${runtimeConfigFile}${ext}`)))) return `import modernRuntime from '${internalSrcAlias}/${runtimeConfigFile}';
+const runtimeConfig = typeof modernRuntime === 'function' ? modernRuntime(getCurrentEntryName()) : modernRuntime`;
+    return "let runtimeConfig;";
+};
+const getRegisterRuntimePluginCode = (entryName, configName, config)=>`plugins.push(${configName}Plugin(mergeConfig(${JSON.stringify(config)}, (runtimeConfig || {})['${configName}'])));`;
+const runtimeRegister = ({ entryName, srcDirectory, internalSrcAlias, metaName, runtimeConfigFile, runtimePlugins })=>`import { registerPlugin, mergeConfig } from '@${metaName}/runtime/plugin';
+import { getGlobalLayoutApp, getCurrentEntryName } from '@${metaName}/runtime/context';
+
+${getImportRuntimeConfigCode(srcDirectory, internalSrcAlias, runtimeConfigFile)}
+
+const plugins = [];
+
+${runtimePlugins.map(({ name, path, config })=>`import { ${name}Plugin } from '${path}';
+
+${getRegisterRuntimePluginCode(entryName, name, config)}
+`).join('\n')}
+registerPlugin(plugins, runtimeConfig);
+`;
+const runtimeGlobalContext = ({ entryName, srcDirectory, internalSrcAlias, metaName, entry, customEntry, basename })=>`import { setGlobalContext } from '@${metaName}/runtime/context'
+
+import App from '${formatImportPath(customEntry ? entry.replace(/entry\.[tj]sx/, 'App').replace(srcDirectory, internalSrcAlias) : entry.replace(srcDirectory, internalSrcAlias).replace(/\.[tj]sx/, ''))}';
+
+const entryName = '${entryName}';
+const basename = '${basename || '/'}';
+setGlobalContext({
+  entryName,
+  App,
+  basename,
+});`;
+const runtimeGlobalContextForRSCServer = ({ metaName })=>`
+  import { createElement, Fragment } from 'react';
+  import { setGlobalContext } from '@${metaName}/runtime/context';
+  import AppProxy from './AppProxy';
+
+  const DefaultRoot = ({ children }) =>
+    createElement(Fragment, null, children);
+
+
+  setGlobalContext({
+    App: DefaultRoot,
+    RSCRoot: AppProxy,
+  });`;
+const runtimeGlobalContextForRSCClient = ({ metaName, customEntry })=>`
+   ${customEntry ? `import {
+     RscClientRoot,
+     createFromFetch,
+     createFromReadableStream,
+     isRedirectResponse,
+     rscStream,
+     callServer,
+     setServerCallback,
+   } from '@${metaName}/runtime/rsc/client';` : ''}
+   import { createElement, Fragment } from 'react';
+   import { setGlobalContext } from '@${metaName}/runtime/context';
+
+   ${customEntry ? 'setServerCallback(callServer);' : ''}
+
+   ${customEntry ? `const handleRedirectResponse = (res) => {
+     const { headers } = res;
+     const location = headers.get('X-Modernjs-Redirect');
+     const baseUrl = headers.get('X-Modernjs-BaseUrl');
+     if (location) {
+       if (baseUrl && baseUrl !== '/') {
+         window.location.replace(baseUrl + location);
+       } else {
+         window.location.replace(location);
+       }
+       return res;
+     }
+     return res;
+   };
+
+   const data = ${process.env.MODERN_DISABLE_INJECT_RSC_DATA ? `createFromFetch(
+     fetch(location.pathname, {
+       headers: {
+         'x-rsc-tree': 'true',
+       },
+     }).then(handleRedirectResponse),
+   )` : `createFromReadableStream(rscStream, {
+     callServer: callServer,
+   })`};` : ''}
+
+   const DefaultRoot = ({ children }) =>
+     createElement(Fragment, null, children);
+
+   ${customEntry ? 'const RSCRoot = () => createElement(RscClientRoot, { rscPayload: data });' : ''}
+
+   setGlobalContext({
+     App: ${customEntry ? 'RSCRoot' : 'DefaultRoot'}
+   });`;
+const AppProxyForRSC = ({ srcDirectory, internalSrcAlias, entry, customEntry })=>`
+  import App from '${formatImportPath(customEntry ? entry.replace(/entry\.[tj]sx/, 'App').replace(srcDirectory, internalSrcAlias) : entry.replace(srcDirectory, internalSrcAlias).replace('.tsx', ''))}';
+  import React from 'react';
+
+  export default function Root() {
+    return React.createElement(App, null);
+  }
+  `;
+export { AppProxyForRSC, entryForCSRWithRSC, index, register, runtimeGlobalContext, runtimeGlobalContextForRSCClient, runtimeGlobalContextForRSCServer, runtimeRegister };

package/dist/esm-node/cli/template.server.mjs

@@ -0,0 +1,127 @@
+import "node:module";
+import { formatImportPath } from "@modern-js/utils";
+const SERVER_ENTRY = `
+import {
+  #render,
+  createRequestHandler,
+} from '@#metaName/runtime/ssr/server';
+
+const handleRequest = async (request, ServerRoot, options) => {
+
+  const body = await #render(request, <ServerRoot />, options);
+
+  return new Response(body, {
+    headers: {
+      'content-type': 'text/html; charset=utf-8'
+    },
+  })
+};
+
+export const requestHandler = createRequestHandler(handleRequest);
+`;
+const SERVER_ENTRY_RSC = `
+import {
+  renderStreaming,
+  createRequestHandler,
+} from '@#metaName/runtime/ssr/server';
+import { RSCServerSlot } from '@#metaName/runtime/rsc/client';
+import { renderRsc } from '@#metaName/runtime/rsc/server';
+export { handleAction } from '@#metaName/runtime/rsc/server';
+
+const handleRequest = async (request, ServerRoot, options) => {
+
+  const body = await renderStreaming(request,
+    <ServerRoot>
+      <RSCServerSlot />
+    </ServerRoot>,
+    {
+      ...options,
+      rscRoot: options.rscRoot,
+    },
+  );
+
+  return new Response(body, {
+    headers: {
+      'content-type': 'text/html; charset=utf-8'
+    },
+  })
+};
+
+export const requestHandler = createRequestHandler(handleRequest, {
+  enableRsc: true
+});
+
+const handleRSCRequest = async (request, ServerRoot, options) => {
+  const { serverPayload } = options;
+  const stream = renderRsc({
+    element: options.rscRoot
+  });
+
+  return new Response(stream);
+}
+
+
+export const rscPayloadHandler = createRequestHandler(handleRSCRequest, {
+  enableRsc: true
+});
+`;
+const serverIndex = (options)=>{
+    const { metaName = 'modern-js', entryName } = options;
+    return `
+    import '@${metaName}/runtime/registry/${entryName}';
+    ${genHandlerCode(options)}
+  `;
+};
+const entryForCSRWithRSC = ({ metaName, entryName })=>`
+  import '@${metaName}/runtime/registry/${entryName}';
+  import {
+    createRequestHandler,
+  } from '@${metaName}/runtime/ssr/server';
+  import { renderCSRWithRSC, renderRsc } from '@${metaName}/runtime/rsc/server';
+  export { handleAction } from '@${metaName}/runtime/rsc/server';
+
+  const handleCSRRender = async (request, ServerRoot, options) => {
+    return renderCSRWithRSC({
+      html: options.html,
+      rscRoot: options.rscRoot,
+    });
+  }
+
+  export const renderRscStreamHandler = createRequestHandler(handleCSRRender, {
+    enableRsc: true
+  });
+
+  const handleRequest = async (request, ServerRoot, options) => {
+    const stream = renderRsc({
+            element: options.rscRoot,
+    });
+
+    return new Response(stream);
+  }
+
+  export const rscPayloadHandler = createRequestHandler(handleRequest, {
+    enableRsc: true
+  });
+`;
+function genHandlerCode({ mode, metaName, customServerEntry, srcDirectory, internalSrcAlias, enableRsc }) {
+    if (customServerEntry) {
+        const realEntryPath = formatImportPath(customServerEntry.replace(srcDirectory, internalSrcAlias));
+        return `
+      export * from '${realEntryPath}';
+      export { default as requestHandler } from '${realEntryPath}'`;
+    }
+    {
+        const entrySource = enableRsc ? SERVER_ENTRY_RSC : SERVER_ENTRY;
+        const serverEntry = transformServerEntry(entrySource, {
+            metaName: metaName || 'modern-js',
+            mode
+        });
+        return serverEntry;
+    }
+}
+function transformServerEntry(source, options) {
+    const { metaName = 'modern-js', mode } = options;
+    const output = source.replace(/#metaName/g, metaName).replace(/#render/g, 'string' === mode ? 'renderString' : 'renderStreaming');
+    return output;
+}
+export { entryForCSRWithRSC, serverIndex };

package/dist/esm-node/common.mjs

@@ -0,0 +1,5 @@
+import "node:module";
+const isBrowser = ()=>"u" > typeof window && 'nodejs' !== window.name;
+const JSX_SHELL_STREAM_END_MARK = '<!--<?- SHELL_STREAM_END ?>-->';
+const ESCAPED_SHELL_STREAM_END_MARK = '&lt;!--&lt;?- SHELL_STREAM_END ?&gt;--&gt;';
+export { ESCAPED_SHELL_STREAM_END_MARK, JSX_SHELL_STREAM_END_MARK, isBrowser };