@modern-js/runtime 2.54.6 → 2.56.0

package/dist/cjs/core/server/stream/createReadableStream.worker.js

@@ -0,0 +1,105 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var createReadableStream_worker_exports = {};
+__export(createReadableStream_worker_exports, {
+  createReadableStreamFromElement: () => createReadableStreamFromElement
+});
+module.exports = __toCommonJS(createReadableStream_worker_exports);
+var import_server = require("react-dom/server");
+var import_isbot = __toESM(require("isbot"));
+var import_constants = require("../../constants");
+var import_common = require("../../../common");
+var import_shared = require("./shared");
+var import_template = require("./template");
+const createReadableStreamFromElement = async (request, rootElement, options) => {
+  let shellChunkStatus = import_shared.ShellChunkStatus.START;
+  const chunkVec = [];
+  const { htmlTemplate, runtimeContext, config, ssrConfig } = options;
+  const { shellBefore, shellAfter } = await (0, import_template.getTemplates)(htmlTemplate, {
+    renderLevel: import_constants.RenderLevel.SERVER_RENDER,
+    runtimeContext,
+    ssrConfig,
+    request,
+    config
+  });
+  try {
+    var _options_onShellReady;
+    const readableOriginal = await (0, import_server.renderToReadableStream)(rootElement, {
+      nonce: config.nonce,
+      onError(error) {
+        var _options_onError;
+        (_options_onError = options.onError) === null || _options_onError === void 0 ? void 0 : _options_onError.call(options, error);
+      }
+    });
+    (_options_onShellReady = options.onShellReady) === null || _options_onShellReady === void 0 ? void 0 : _options_onShellReady.call(options);
+    readableOriginal.allReady.then(() => {
+      var _options_onAllReady;
+      options === null || options === void 0 ? void 0 : (_options_onAllReady = options.onAllReady) === null || _options_onAllReady === void 0 ? void 0 : _options_onAllReady.call(options);
+    });
+    const isbot = (0, import_isbot.default)(request.headers.get("user-agent"));
+    if (isbot) {
+      await readableOriginal.allReady;
+    }
+    const reader = readableOriginal.getReader();
+    const stream = new ReadableStream({
+      start(controller) {
+        async function push() {
+          const { done, value } = await reader.read();
+          if (done) {
+            controller.close();
+            return;
+          }
+          if (shellChunkStatus !== import_shared.ShellChunkStatus.FINISH) {
+            const chunk = new TextDecoder().decode(value);
+            chunkVec.push(chunk);
+            let concatedChunk = chunkVec.join("");
+            if (concatedChunk.endsWith(import_common.ESCAPED_SHELL_STREAM_END_MARK)) {
+              concatedChunk = concatedChunk.replace(import_common.ESCAPED_SHELL_STREAM_END_MARK, "");
+              shellChunkStatus = import_shared.ShellChunkStatus.FINISH;
+              controller.enqueue((0, import_shared.encodeForWebStream)(`${shellBefore}${concatedChunk}${shellAfter}`));
+            }
+          } else {
+            controller.enqueue(value);
+          }
+          push();
+        }
+        push();
+      }
+    });
+    return stream;
+  } catch (e) {
+    const fallbackHtml = `${shellBefore}${shellAfter}`;
+    const stream = (0, import_shared.getReadableStreamFromString)(fallbackHtml);
+    return stream;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createReadableStreamFromElement
+});

package/dist/cjs/core/server/stream/index.js

@@ -0,0 +1,30 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var stream_exports = {};
+__export(stream_exports, {
+  renderStreaming: () => renderStreaming
+});
+module.exports = __toCommonJS(stream_exports);
+var import_createReadableStream = require("./createReadableStream");
+var import_shared = require("./shared");
+const renderStreaming = (0, import_shared.createRenderStreaming)(import_createReadableStream.createReadableStreamFromElement);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  renderStreaming
+});

package/dist/cjs/core/server/stream/shared.js

@@ -0,0 +1,112 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var shared_exports = {};
+__export(shared_exports, {
+  ShellChunkStatus: () => ShellChunkStatus,
+  createRenderStreaming: () => createRenderStreaming,
+  encodeForWebStream: () => encodeForWebStream,
+  getReadableStreamFromString: () => getReadableStreamFromString
+});
+module.exports = __toCommonJS(shared_exports);
+var import_time = require("@modern-js/runtime-utils/time");
+var import_request = require("@modern-js/runtime-utils/universal/request");
+var import_node = require("@modern-js/runtime-utils/node");
+var import_react = __toESM(require("react"));
+var import_tracer = require("../tracer");
+var import_utils = require("../utils");
+var ShellChunkStatus;
+(function(ShellChunkStatus2) {
+  ShellChunkStatus2[ShellChunkStatus2["START"] = 0] = "START";
+  ShellChunkStatus2[ShellChunkStatus2["FINISH"] = 1] = "FINISH";
+})(ShellChunkStatus || (ShellChunkStatus = {}));
+let encoder;
+function encodeForWebStream(thing) {
+  if (!encoder) {
+    encoder = new TextEncoder();
+  }
+  if (typeof thing === "string") {
+    return encoder.encode(thing);
+  }
+  return thing;
+}
+function getReadableStreamFromString(content) {
+  const readableStream = new ReadableStream({
+    start(controller) {
+      controller.enqueue(encodeForWebStream(content));
+      controller.close();
+    }
+  });
+  return readableStream;
+}
+function createRenderStreaming(createReadableStreamFromElement) {
+  return async (request, serverRoot, options) => {
+    const headersData = (0, import_request.parseHeaders)(request);
+    return (0, import_node.run)(headersData, async () => {
+      const end = (0, import_time.time)();
+      const { runtimeContext, config, resource, staticGenerate } = options;
+      const onError = (0, import_tracer.createOnError)(options.onError);
+      const onTiming = (0, import_tracer.createOnTiming)(options.onTiming);
+      const { htmlTemplate, entryName } = resource;
+      const ssrConfig = (0, import_utils.getSSRConfigByEntry)(entryName, config.ssr, config.ssrByEntries, staticGenerate);
+      const rootElement = import_react.default.cloneElement(serverRoot, {
+        _internal_context: Object.assign(runtimeContext, {
+          ssr: true
+        })
+      });
+      const stream = await createReadableStreamFromElement(request, rootElement, {
+        config,
+        htmlTemplate,
+        runtimeContext,
+        ssrConfig,
+        onShellReady() {
+          const cost = end();
+          onTiming(import_tracer.SSRTimings.RENDER_SHELL, cost);
+        },
+        onAllReady() {
+          const cost = end();
+          onTiming(import_tracer.SSRTimings.RENDER_HTML, cost);
+        },
+        onShellError(error) {
+          onError(import_tracer.SSRErrors.RENDER_SHELL, error);
+        },
+        onError(error) {
+          onError(import_tracer.SSRErrors.RENDER_STREAM, error);
+        }
+      });
+      return stream;
+    });
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ShellChunkStatus,
+  createRenderStreaming,
+  encodeForWebStream,
+  getReadableStreamFromString
+});

package/dist/cjs/{ssr/serverRender/renderToStream → core/server/stream}/template.js

@@ -21,17 +21,13 @@ __export(template_exports, {
   getTemplates: () => getTemplates
 });
 module.exports = __toCommonJS(template_exports);
-var import_buildTemplate = require("./buildTemplate.after");
-var import_bulidTemplate = require("./bulidTemplate.before");
+var import_beforeTemplate = require("./beforeTemplate");
+var import_afterTemplate = require("./afterTemplate");
 const HTML_SEPARATOR = "<!--<?- html ?>-->";
-const getTemplates = async (context, renderLevel, pluginConfig, styledComponentsStyleTags) => {
-  const { ssrContext } = context;
-  const [beforeAppTemplate = "", afterAppHtmlTemplate = ""] = ssrContext.template.split(HTML_SEPARATOR) || [];
-  const builtBeforeTemplate = await (0, import_bulidTemplate.buildShellBeforeTemplate)(beforeAppTemplate, context, pluginConfig, styledComponentsStyleTags);
-  const builtAfterTemplate = await (0, import_buildTemplate.buildShellAfterTemplate)(afterAppHtmlTemplate, {
-    context,
-    renderLevel
-  });
+const getTemplates = async (htmlTemplate, options) => {
+  const [beforeAppTemplate = "", afterAppHtmlTemplate = ""] = htmlTemplate.split(HTML_SEPARATOR) || [];
+  const builtBeforeTemplate = await (0, import_beforeTemplate.buildShellBeforeTemplate)(beforeAppTemplate, options);
+  const builtAfterTemplate = await (0, import_afterTemplate.buildShellAfterTemplate)(afterAppHtmlTemplate, options);
   return {
     shellBefore: builtBeforeTemplate,
     shellAfter: builtAfterTemplate

package/dist/cjs/core/server/string/index.js

@@ -0,0 +1,152 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var string_exports = {};
+__export(string_exports, {
+  renderString: () => renderString
+});
+module.exports = __toCommonJS(string_exports);
+var import_react_helmet = __toESM(require("react-helmet"));
+var import_server = __toESM(require("react-dom/server"));
+var import_react = __toESM(require("react"));
+var import_time = require("@modern-js/runtime-utils/time");
+var import_node = require("@modern-js/runtime-utils/node");
+var import_request = require("@modern-js/runtime-utils/universal/request");
+var import_helmet = require("../helmet");
+var import_utils = require("../utils");
+var import_constants = require("../constants");
+var import_shared = require("../shared");
+var import_tracer = require("../tracer");
+var import_constants2 = require("../../constants");
+var import_ssrData = require("./ssrData");
+var import_loadable = require("./loadable");
+var import_styledComponent = require("./styledComponent");
+var import_prefetch = require("./prefetch");
+const renderString = async (request, serverRoot, options) => {
+  const headersData = (0, import_request.parseHeaders)(request);
+  return (0, import_node.run)(headersData, async () => {
+    var _runtimeContext_ssrContext;
+    const { resource, runtimeContext, config, onError, onTiming, staticGenerate } = options;
+    const tracer = {
+      onError: (0, import_tracer.createOnError)(onError),
+      onTiming: (0, import_tracer.createOnTiming)(onTiming)
+    };
+    const routerContext = runtimeContext.routerContext;
+    const { htmlTemplate, entryName, loadableStats, routeManifest } = resource;
+    const ssrConfig = (0, import_utils.getSSRConfigByEntry)(entryName, config.ssr, config.ssrByEntries, staticGenerate);
+    const chunkSet = {
+      renderLevel: import_constants2.RenderLevel.CLIENT_RENDER,
+      ssrScripts: "",
+      jsChunk: "",
+      cssChunk: ""
+    };
+    let prefetchData = {};
+    try {
+      prefetchData = await (0, import_prefetch.prefetch)(serverRoot, request, options, ssrConfig, tracer);
+      chunkSet.renderLevel = import_constants2.RenderLevel.SERVER_PREFETCH;
+    } catch (e) {
+      chunkSet.renderLevel = import_constants2.RenderLevel.CLIENT_RENDER;
+    }
+    const collectors = [
+      new import_styledComponent.StyledCollector(chunkSet),
+      new import_loadable.LoadableCollector({
+        stats: loadableStats,
+        nonce: config.nonce,
+        routeManifest,
+        template: htmlTemplate,
+        entryName,
+        chunkSet,
+        config
+      }),
+      new import_ssrData.SSRDataCollector({
+        request,
+        prefetchData,
+        ssrConfig,
+        ssrContext: runtimeContext.ssrContext,
+        chunkSet,
+        routerContext,
+        nonce: config.nonce
+      })
+    ];
+    const rootElement = import_react.default.cloneElement(serverRoot, {
+      _internal_context: Object.assign(runtimeContext, {
+        ssr: true
+      })
+    });
+    const html = await generateHtml(rootElement, htmlTemplate, chunkSet, collectors, ((_runtimeContext_ssrContext = runtimeContext.ssrContext) === null || _runtimeContext_ssrContext === void 0 ? void 0 : _runtimeContext_ssrContext.htmlModifiers) || [], tracer);
+    return html;
+  });
+};
+async function generateHtml(App, htmlTemplate, chunkSet, collectors, htmlModifiers, { onError, onTiming }) {
+  const end = (0, import_time.time)();
+  let html = "";
+  let helmetData;
+  if (chunkSet.renderLevel >= import_constants2.RenderLevel.SERVER_PREFETCH) {
+    try {
+      const finalApp = collectors.reduce((pre, creator) => {
+        var _creator_collect;
+        return ((_creator_collect = creator.collect) === null || _creator_collect === void 0 ? void 0 : _creator_collect.call(creator, pre)) || pre;
+      }, App);
+      html = import_server.default.renderToString(finalApp);
+      helmetData = import_react_helmet.default.renderStatic();
+      chunkSet.renderLevel = import_constants2.RenderLevel.SERVER_RENDER;
+      await Promise.all(collectors.map((component) => component.effect()));
+      const cost = end();
+      onTiming(import_tracer.SSRTimings.RENDER_HTML, cost);
+    } catch (e) {
+      chunkSet.renderLevel = import_constants2.RenderLevel.CLIENT_RENDER;
+      onError(import_tracer.SSRErrors.RENDER_HTML, e);
+    }
+  }
+  const { ssrScripts, cssChunk, jsChunk } = chunkSet;
+  const finalHtml = await (0, import_shared.buildHtml)(htmlTemplate, [
+    createReplaceHtml(html),
+    createReplaceChunkJs(jsChunk),
+    createReplaceChunkCss(cssChunk),
+    createReplaceSSRDataScript(ssrScripts),
+    (0, import_helmet.createReplaceHelemt)(helmetData),
+    ...htmlModifiers
+  ]);
+  return finalHtml;
+}
+function createReplaceHtml(html) {
+  return (template) => (0, import_utils.safeReplace)(template, import_constants.HTML_PLACEHOLDER, html);
+}
+function createReplaceSSRDataScript(data) {
+  return (template) => (0, import_utils.safeReplace)(template, import_constants.SSR_DATA_PLACEHOLDER, data);
+}
+function createReplaceChunkJs(js) {
+  return (template) => (0, import_utils.safeReplace)(template, import_constants.CHUNK_JS_PLACEHOLDER, js);
+}
+function createReplaceChunkCss(css) {
+  return (template) => (0, import_utils.safeReplace)(template, import_constants.CHUNK_CSS_PLACEHOLDER, css);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  renderString
+});

package/dist/cjs/{ssr/serverRender/renderToString → core/server/string}/loadable.js

@@ -28,7 +28,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var loadable_exports = {};
 __export(loadable_exports, {
-  createLoadableCollector: () => createLoadableCollector
+  LoadableCollector: () => LoadableCollector
 });
 module.exports = __toCommonJS(loadable_exports);
 var import_server = require("@loadable/server");
@@ -94,13 +94,12 @@ class LoadableCollector {
     if (!check(scripts)) {
       return;
     }
-    const { result: { chunksMap } } = this.options;
+    const { chunkSet } = this.options;
     const s = scripts.split("</script>").slice(0, 2).map((i) => `${i}</script>`).join("");
-    chunksMap.js += s;
+    chunkSet.jsChunk += s;
   }
   async emitScriptAssets(chunks) {
-    const { template, config, nonce, result } = this.options;
-    const { chunksMap } = result;
+    const { template, nonce, chunkSet, config } = this.options;
     const { scriptLoading = "defer", enableInlineScripts } = config;
     const scriptLoadingAtr = {
       defer: scriptLoading === "defer" ? true : void 0,
@@ -125,10 +124,11 @@ class LoadableCollector {
         return script;
       }
     }));
-    chunksMap.js += scripts.filter((script) => Boolean(script)).join("");
+    chunkSet.jsChunk += scripts.filter((script) => Boolean(script)).join("");
   }
   async emitStyleAssets(chunks) {
-    const { template, result: { chunksMap }, config: { enableInlineStyles } } = this.options;
+    const { template, chunkSet, config } = this.options;
+    const { enableInlineStyles } = config;
     const atrributes = (0, import_utils.attributesToString)(this.generateAttributes());
     const css = await Promise.all(chunks.filter((chunk) => {
       var _this_existsAssets;
@@ -144,7 +144,7 @@ class LoadableCollector {
         return link;
       }
     }));
-    chunksMap.css += css.filter((css2) => Boolean(css2)).join("");
+    chunkSet.jsChunk += css.filter((css2) => Boolean(css2)).join("");
   }
   generateAttributes(extraAtr = {}) {
     const { config } = this.options;
@@ -162,10 +162,7 @@ class LoadableCollector {
     this.options = options;
   }
 }
-function createLoadableCollector(options) {
-  return new LoadableCollector(options);
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  createLoadableCollector
+  LoadableCollector
 });

package/dist/cjs/core/server/string/prefetch.js

@@ -0,0 +1,112 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var prefetch_exports = {};
+__export(prefetch_exports, {
+  prefetch: () => prefetch
+});
+module.exports = __toCommonJS(prefetch_exports);
+var import_server = require("react-dom/server");
+var import_node = require("@modern-js/runtime-utils/node");
+var import_server2 = require("@loadable/server");
+var import_time = require("@modern-js/runtime-utils/time");
+var import_request = require("@modern-js/runtime-utils/universal/request");
+var import_react = __toESM(require("react"));
+var import_tracer = require("../tracer");
+const prefetch = async (App, request, options, ssrConfig, { onError, onTiming }) => {
+  const headersData = (0, import_request.parseHeaders)(request);
+  const { runtimeContext: context, resource } = options;
+  const { entryName, loadableStats } = resource;
+  return (0, import_node.run)(headersData, async () => {
+    var _context_store;
+    if (typeof ssrConfig === "boolean" || !ssrConfig.disablePrerender) {
+      try {
+        const end = (0, import_time.time)();
+        if (loadableStats) {
+          const extractor = new import_server2.ChunkExtractor({
+            stats: loadableStats,
+            entrypoints: [
+              entryName
+            ].filter(Boolean)
+          });
+          (0, import_server.renderToStaticMarkup)(extractor.collectChunks(/* @__PURE__ */ import_react.default.cloneElement(App, {
+            _internal_context: Object.assign(context, {
+              ssr: false
+            })
+          })));
+        } else {
+          (0, import_server.renderToStaticMarkup)(/* @__PURE__ */ import_react.default.cloneElement(App, {
+            _internal_context: Object.assign(context, {
+              ssr: false
+            })
+          }));
+        }
+        const cost = end();
+        onTiming(import_tracer.SSRTimings.PRERENDER, cost);
+      } catch (e) {
+        const error = e;
+        onError(import_tracer.SSRErrors.PRERENDER, error);
+        throw e;
+      }
+    }
+    if (!context.loaderManager.hasPendingLoaders()) {
+      return {
+        initialData: context.initialData,
+        i18nData: context.__i18nData__
+      };
+    }
+    let loadersData = {};
+    try {
+      const end = (0, import_time.time)();
+      loadersData = await context.loaderManager.awaitPendingLoaders();
+      const cost = end();
+      onTiming(import_tracer.SSRTimings.USE_LOADER, cost);
+    } catch (e) {
+      onError(import_tracer.SSRErrors.USE_LOADER, e);
+      throw e;
+    }
+    Object.keys(loadersData).forEach((id) => {
+      const data = loadersData[id];
+      if (data._error) {
+        onError(import_tracer.SSRErrors.USE_LOADER, data._error);
+        delete data._error;
+      }
+    });
+    return {
+      loadersData,
+      initialData: context.initialData,
+      i18nData: context.__i18nData__,
+      // todo: move to plugin state
+      storeState: context === null || context === void 0 ? void 0 : (_context_store = context.store) === null || _context_store === void 0 ? void 0 : _context_store.getState()
+    };
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  prefetch
+});