@modern-js/runtime 2.39.2 → 2.41.0

package/dist/esm/ssr/prefetch.js

@@ -4,33 +4,44 @@ import { jsx as _jsx } from "react/jsx-runtime";
 import { renderToStaticMarkup } from "react-dom/server";
 import { run } from "@modern-js/runtime-utils/node";
 import { ChunkExtractor } from "@loadable/server";
+import { time } from "@modern-js/runtime-utils/time";
+import { SSRTimings, SSRErrors } from "./serverRender/tracker";
 var prefetch = function() {
-  var _ref = _async_to_generator(function(App, context, config) {
+  var _ref = _async_to_generator(function(App, context, config, tracker) {
     return _ts_generator(this, function(_state) {
       return [
         2,
         run(context.ssrContext.request.headers, /* @__PURE__ */ _async_to_generator(function() {
-          var _context_store, ssrContext, loadableStats, extractor, loadersData;
+          var _context_store, ssrContext, loadableStats, end, extractor, cost, error, loadersData, end1, cost1, e, error1;
           return _ts_generator(this, function(_state2) {
             switch (_state2.label) {
               case 0:
                 ssrContext = context.ssrContext;
                 loadableStats = ssrContext.loadableStats;
                 if (!config.disablePrerender) {
-                  if (loadableStats) {
-                    extractor = new ChunkExtractor({
-                      stats: loadableStats,
-                      entrypoints: [
-                        ssrContext.entryName
-                      ].filter(Boolean)
-                    });
-                    renderToStaticMarkup(extractor.collectChunks(/* @__PURE__ */ _jsx(App, {
-                      context
-                    })));
-                  } else {
-                    renderToStaticMarkup(/* @__PURE__ */ _jsx(App, {
-                      context
-                    }));
+                  try {
+                    end = time();
+                    if (loadableStats) {
+                      extractor = new ChunkExtractor({
+                        stats: loadableStats,
+                        entrypoints: [
+                          ssrContext.entryName
+                        ].filter(Boolean)
+                      });
+                      renderToStaticMarkup(extractor.collectChunks(/* @__PURE__ */ _jsx(App, {
+                        context
+                      })));
+                    } else {
+                      renderToStaticMarkup(/* @__PURE__ */ _jsx(App, {
+                        context
+                      }));
+                    }
+                    cost = end();
+                    tracker.trackTiming(SSRTimings.PRERENDER, cost);
+                  } catch (e2) {
+                    error = e2;
+                    tracker.trackError(SSRErrors.PRERENDER, error);
+                    throw e2;
                   }
                 }
                 if (!context.loaderManager.hasPendingLoaders()) {
@@ -42,12 +53,34 @@ var prefetch = function() {
                     }
                   ];
                 }
+                loadersData = {};
+                _state2.label = 1;
+              case 1:
+                _state2.trys.push([
+                  1,
+                  3,
+                  ,
+                  4
+                ]);
+                end1 = time();
                 return [
                   4,
                   context.loaderManager.awaitPendingLoaders()
                 ];
-              case 1:
+              case 2:
                 loadersData = _state2.sent();
+                cost1 = end1();
+                tracker.trackTiming(SSRTimings.USE_LOADER, cost1);
+                return [
+                  3,
+                  4
+                ];
+              case 3:
+                e = _state2.sent();
+                error1 = e;
+                tracker.trackError(SSRErrors.USE_LOADER, error1);
+                throw e;
+              case 4:
                 Object.keys(loadersData).forEach(function(id) {
                   var data = loadersData[id];
                   if (data._error) {
@@ -72,7 +105,7 @@ var prefetch = function() {
       ];
     });
   });
-  return function prefetch2(App, context, config) {
+  return function prefetch2(App, context, config, tracker) {
     return _ref.apply(this, arguments);
   };
 }();

package/dist/esm/ssr/serverRender/renderToStream/buildTemplate.after.js

@@ -3,7 +3,11 @@ import { serializeJson } from "@modern-js/runtime-utils/node";
 import { attributesToString } from "../utils";
 import { buildTemplate } from "./buildTemplate.share";
 function buildShellAfterTemplate(afterAppTemplate, options) {
-  var injectSSRDataScript = function injectSSRDataScript2(template) {
+  var callbacks = [
+    injectSSRDataScript
+  ];
+  return buildTemplate(afterAppTemplate, callbacks);
+  function injectSSRDataScript(template) {
     var ssrDataScript = buildSSRDataScript();
     return template.replace("<!--<?- SSRDataScript ?>-->", ssrDataScript);
     function buildSSRDataScript() {
@@ -36,11 +40,7 @@ function buildShellAfterTemplate(afterAppTemplate, options) {
       });
       return "\n      <script".concat(attrsStr, ">window._SSR_DATA = ").concat(serializeJson(SSRData), "</script>\n      ");
     }
-  };
-  var callbacks = [
-    injectSSRDataScript
-  ];
-  return buildTemplate(afterAppTemplate, callbacks);
+  }
 }
 export {
   buildShellAfterTemplate

package/dist/esm/ssr/serverRender/renderToStream/bulidTemplate.before.js

@@ -6,7 +6,20 @@ import helmetReplace from "../helmet";
 import { CSS_CHUNKS_PLACEHOLDER } from "../utils";
 import { HEAD_REG_EXP, buildTemplate } from "./buildTemplate.share";
 function getHeadTemplate(beforeEntryTemplate, context) {
-  var injectCss = function injectCss2(headTemplate2) {
+  var callbacks = [
+    function(headTemplate2) {
+      var helmetData = ReactHelmet.renderStatic();
+      return helmetData ? helmetReplace(headTemplate2, helmetData) : headTemplate2;
+    },
+    // @TODO: prefetch scripts of lazy component
+    injectCss
+  ];
+  var _ref = _sliced_to_array(beforeEntryTemplate.match(HEAD_REG_EXP) || [], 1), tmp = _ref[0], headTemplate = tmp === void 0 ? "" : tmp;
+  if (!headTemplate.length) {
+    return "";
+  }
+  return buildTemplate(headTemplate, callbacks);
+  function injectCss(headTemplate2) {
     return headTemplate2.replace(CSS_CHUNKS_PLACEHOLDER, getCssChunks());
     function getCssChunks() {
       var routeManifest = context.routeManifest, routerContext = context.routerContext, routes = context.routes;
@@ -38,20 +51,7 @@ function getHeadTemplate(beforeEntryTemplate, context) {
       });
       return "".concat(styleLinks.join(""));
     }
-  };
-  var callbacks = [
-    function(headTemplate2) {
-      var helmetData = ReactHelmet.renderStatic();
-      return helmetData ? helmetReplace(headTemplate2, helmetData) : headTemplate2;
-    },
-    // @TODO: prefetch scripts of lazy component
-    injectCss
-  ];
-  var _ref = _sliced_to_array(beforeEntryTemplate.match(HEAD_REG_EXP) || [], 1), tmp = _ref[0], headTemplate = tmp === void 0 ? "" : tmp;
-  if (!headTemplate.length) {
-    return "";
   }
-  return buildTemplate(headTemplate, callbacks);
 }
 function buildShellBeforeTemplate(beforeAppTemplate, context) {
   var headTemplate = getHeadTemplate(beforeAppTemplate, context);

package/dist/esm/ssr/serverRender/renderToStream/index.js

@@ -29,11 +29,11 @@ var render = function(param) {
             ssrContext.cacheConfig = cacheConfig;
           }
           var cost = end();
-          tracker.trackTiming(SSRTimings.SSR_RENDER_SHELL, cost);
+          tracker.trackTiming(SSRTimings.RENDER_SHELL, cost);
         },
         onAllReady: function onAllReady() {
           var cost = end();
-          tracker.trackTiming(SSRTimings.SSR_RENDER_TOTAL, cost);
+          tracker.trackTiming(SSRTimings.RENDER_HTML, cost);
         },
         onShellError: function onShellError(e) {
           tracker.trackError(SSRErrors.RENDER_SHELL, e);

package/dist/esm/ssr/serverRender/renderToStream/renderToPipe.js

@@ -11,7 +11,7 @@ var ShellChunkStatus;
   ShellChunkStatus2[ShellChunkStatus2["FINIESH"] = 1] = "FINIESH";
 })(ShellChunkStatus || (ShellChunkStatus = {}));
 function renderToPipe(rootElement, context, options) {
-  var shellChunkStatus = ShellChunkStatus.START;
+  var shellChunkStatus = 0;
   var ssrContext = context.ssrContext;
   var chunkVec = [];
   var forUserPipe = function(stream) {
@@ -30,12 +30,12 @@ function renderToPipe(rootElement, context, options) {
           var injectableTransform = new Transform({
             transform: function transform(chunk, _encoding, callback) {
               try {
-                if (shellChunkStatus !== ShellChunkStatus.FINIESH) {
+                if (shellChunkStatus !== 1) {
                   chunkVec.push(chunk.toString());
                   var concatedChunk = chunkVec.join("");
                   if (concatedChunk.endsWith(ESCAPED_SHELL_STREAM_END_MARK)) {
                     concatedChunk = concatedChunk.replace(ESCAPED_SHELL_STREAM_END_MARK, "");
-                    shellChunkStatus = ShellChunkStatus.FINIESH;
+                    shellChunkStatus = 1;
                     this.push("".concat(shellBefore).concat(concatedChunk).concat(shellAfter));
                   }
                 } else {

package/dist/esm/ssr/serverRender/renderToStream/renderToPipe.worker.js

@@ -12,7 +12,7 @@ var ShellChunkStatus;
   ShellChunkStatus2[ShellChunkStatus2["FINIESH"] = 1] = "FINIESH";
 })(ShellChunkStatus || (ShellChunkStatus = {}));
 function renderToPipe(rootElement, context, options) {
-  var shellChunkStatus = ShellChunkStatus.START;
+  var shellChunkStatus = 0;
   var chunkVec = [];
   var ssrContext = context.ssrContext;
   var forUserPipe = function() {
@@ -70,13 +70,13 @@ function renderToPipe(rootElement, context, options) {
                               2
                             ];
                           }
-                          if (shellChunkStatus !== ShellChunkStatus.FINIESH) {
+                          if (shellChunkStatus !== 1) {
                             chunk = new TextDecoder().decode(value);
                             chunkVec.push(chunk);
                             concatedChunk = chunkVec.join("");
                             if (concatedChunk.endsWith(ESCAPED_SHELL_STREAM_END_MARK)) {
                               concatedChunk = concatedChunk.replace(ESCAPED_SHELL_STREAM_END_MARK, "");
-                              shellChunkStatus = ShellChunkStatus.FINIESH;
+                              shellChunkStatus = 1;
                               controller.enqueue(encodeForWebStream("".concat(shellBefore).concat(concatedChunk).concat(shellAfter)));
                             }
                           } else {

package/dist/esm/ssr/serverRender/renderToString/entry.js

@@ -41,7 +41,8 @@ var buildTemplateData = function(context, data, renderLevel, tracker) {
     renderLevel
   };
 };
-var Entry = /* @__PURE__ */ function() {
+var Entry;
+Entry = /* @__PURE__ */ function() {
   "use strict";
   function Entry2(options) {
     _class_call_check(this, Entry2);
@@ -152,41 +153,35 @@ var Entry = /* @__PURE__ */ function() {
       value: function prefetch1(context) {
         var _this = this;
         return _async_to_generator(function() {
-          var prefetchData, end, prefetchCost, e;
+          var prefetchData, e;
           return _ts_generator(this, function(_state) {
             switch (_state.label) {
               case 0:
-                end = time();
-                _state.label = 1;
-              case 1:
                 _state.trys.push([
-                  1,
-                  3,
+                  0,
+                  2,
                   ,
-                  4
+                  3
                 ]);
                 return [
                   4,
-                  prefetch(_this.App, context, _this.pluginConfig)
+                  prefetch(_this.App, context, _this.pluginConfig, _this.tracker)
                 ];
-              case 2:
+              case 1:
                 prefetchData = _state.sent();
                 _this.result.renderLevel = RenderLevel.SERVER_PREFETCH;
-                prefetchCost = end();
-                _this.tracker.trackTiming(SSRTimings.SSR_PREFETCH, prefetchCost);
                 return [
                   3,
-                  4
+                  3
                 ];
-              case 3:
+              case 2:
                 e = _state.sent();
                 _this.result.renderLevel = RenderLevel.CLIENT_RENDER;
-                _this.tracker.trackError(SSRErrors.PREFETCH, e);
                 return [
                   3,
-                  4
+                  3
                 ];
-              case 4:
+              case 3:
                 return [
                   2,
                   prefetchData || {}
@@ -236,7 +231,7 @@ var Entry = /* @__PURE__ */ function() {
               case 2:
                 html = _state.sent();
                 cost = end();
-                _this.tracker.trackTiming(SSRTimings.SSR_RENDER_HTML, cost);
+                _this.tracker.trackTiming(SSRTimings.RENDER_HTML, cost);
                 _this.result.renderLevel = RenderLevel.SERVER_RENDER;
                 return [
                   3,

package/dist/esm/ssr/serverRender/renderToString/index.js

@@ -1,15 +1,13 @@
 import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
 import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
 import { run } from "@modern-js/runtime-utils/node";
-import { time } from "@modern-js/runtime-utils/time";
 import { PreRender } from "../../react/prerender";
-import { SSRTimings } from "../tracker";
 import SSREntry from "./entry";
 var render = function(param) {
   var App = param.App, context = param.context, config = param.config;
   var ssrContext = context.ssrContext;
   return run(ssrContext.request.headers, /* @__PURE__ */ _async_to_generator(function() {
-    var entry, end, html, cost, cacheConfig;
+    var entry, html, cacheConfig;
     return _ts_generator(this, function(_state) {
       switch (_state.label) {
         case 0:
@@ -19,15 +17,12 @@ var render = function(param) {
             config
           });
           entry.metrics.emitCounter("app.visit.count", 1);
-          end = time();
           return [
             4,
             entry.renderToHtml(context)
           ];
         case 1:
           html = _state.sent();
-          cost = end();
-          entry.tracker.trackTiming(SSRTimings.SSR_RENDER_TOTAL, cost);
           cacheConfig = PreRender.config();
           if (cacheConfig) {
             context.ssrContext.cacheConfig = cacheConfig;

package/dist/esm/ssr/serverRender/renderToString/loadable.js

@@ -31,6 +31,36 @@ var checkIsInline = function(chunk, enableInline) {
     return false;
   }
 };
+var readAsset = function() {
+  var _ref = _async_to_generator(function(chunk) {
+    var fs, path, filepath;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          return [
+            4,
+            import("fs/promises")
+          ];
+        case 1:
+          fs = _state.sent();
+          return [
+            4,
+            import("path")
+          ];
+        case 2:
+          path = _state.sent();
+          filepath = path.resolve(__dirname, chunk.filename);
+          return [
+            2,
+            fs.readFile(filepath, "utf-8")
+          ];
+      }
+    });
+  });
+  return function readAsset2(chunk) {
+    return _ref.apply(this, arguments);
+  };
+}();
 var checkIsNode = function() {
   var _process_release;
   return typeof process !== "undefined" && ((_process_release = process.release) === null || _process_release === void 0 ? void 0 : _process_release.name) === "node";
@@ -151,40 +181,27 @@ var LoadableCollector = /* @__PURE__ */ function() {
                     return !jsChunkReg.test(template) && !((_this_existsAssets = _this.existsAssets) === null || _this_existsAssets === void 0 ? void 0 : _this_existsAssets.includes(chunk.path));
                   }).map(function() {
                     var _ref = _async_to_generator(function(chunk) {
-                      var fs, filepath;
+                      var script;
                       return _ts_generator(this, function(_state2) {
-                        switch (_state2.label) {
-                          case 0:
-                            if (!(checkIsInline(chunk, enableInlineScripts) && checkIsNode()))
-                              return [
-                                3,
-                                2
-                              ];
-                            return [
-                              4,
-                              import("node:fs/promises")
-                            ];
-                          case 1:
-                            fs = _state2.sent();
-                            filepath = chunk.path;
-                            return [
-                              2,
-                              fs.readFile(filepath, "utf-8").then(function(content) {
-                                return "<script>".concat(content, "</script>");
-                              }).catch(function(_) {
-                                return "";
-                              })
-                            ];
-                          case 2:
-                            return [
-                              2,
-                              "<script".concat(attributes, ' src="').concat(chunk.url, '"></script>')
-                            ];
-                          case 3:
-                            return [
-                              2
-                            ];
+                        script = "<script".concat(attributes, ' src="').concat(chunk.url, '"></script>');
+                        if (checkIsInline(chunk, enableInlineScripts) && checkIsNode()) {
+                          return [
+                            2,
+                            readAsset(chunk).then(function(content) {
+                              return "<script>".concat(content, "</script>");
+                            }).catch(function(_) {
+                              return script;
+                            })
+                          ];
+                        } else {
+                          return [
+                            2,
+                            script
+                          ];
                         }
+                        return [
+                          2
+                        ];
                       });
                     });
                     return function(chunk) {
@@ -224,39 +241,27 @@ var LoadableCollector = /* @__PURE__ */ function() {
                     return !cssChunkReg.test(template) && !((_this_existsAssets = _this.existsAssets) === null || _this_existsAssets === void 0 ? void 0 : _this_existsAssets.includes(chunk.path));
                   }).map(function() {
                     var _ref = _async_to_generator(function(chunk) {
-                      var fs;
+                      var link;
                       return _ts_generator(this, function(_state2) {
-                        switch (_state2.label) {
-                          case 0:
-                            if (!(checkIsInline(chunk, enableInlineStyles) && checkIsNode()))
-                              return [
-                                3,
-                                2
-                              ];
-                            return [
-                              4,
-                              import("node:fs/promises")
-                            ];
-                          case 1:
-                            fs = _state2.sent();
-                            return [
-                              2,
-                              fs.readFile(chunk.path).then(function(content) {
-                                return "<style>".concat(content, "</style>");
-                              }).catch(function(_) {
-                                return "";
-                              })
-                            ];
-                          case 2:
-                            return [
-                              2,
-                              "<link".concat(atrributes, ' href="').concat(chunk.url, '" rel="stylesheet" />')
-                            ];
-                          case 3:
-                            return [
-                              2
-                            ];
+                        link = "<link".concat(atrributes, ' href="').concat(chunk.url, '" rel="stylesheet" />');
+                        if (checkIsInline(chunk, enableInlineStyles) && checkIsNode()) {
+                          return [
+                            2,
+                            readAsset(chunk).then(function(content) {
+                              return "<style>".concat(content, "</style>");
+                            }).catch(function(_) {
+                              return link;
+                            })
+                          ];
+                        } else {
+                          return [
+                            2,
+                            link
+                          ];
                         }
+                        return [
+                          2
+                        ];
                       });
                     });
                     return function(chunk) {

package/dist/esm/ssr/serverRender/tracker.js

@@ -1,52 +1,56 @@
 import { _ as _define_property } from "@swc/helpers/_/_define_property";
 var SSRTimings;
 (function(SSRTimings2) {
-  SSRTimings2[SSRTimings2["SSR_RENDER_TOTAL"] = 0] = "SSR_RENDER_TOTAL";
-  SSRTimings2[SSRTimings2["SSR_PREFETCH"] = 1] = "SSR_PREFETCH";
-  SSRTimings2[SSRTimings2["SSR_RENDER_HTML"] = 2] = "SSR_RENDER_HTML";
-  SSRTimings2[SSRTimings2["SSR_RENDER_SHELL"] = 3] = "SSR_RENDER_SHELL";
+  SSRTimings2[SSRTimings2["PRERENDER"] = 0] = "PRERENDER";
+  SSRTimings2[SSRTimings2["RENDER_HTML"] = 1] = "RENDER_HTML";
+  SSRTimings2[SSRTimings2["RENDER_SHELL"] = 2] = "RENDER_SHELL";
+  SSRTimings2[SSRTimings2["USE_LOADER"] = 3] = "USE_LOADER";
 })(SSRTimings || (SSRTimings = {}));
 var SSRErrors;
 (function(SSRErrors2) {
-  SSRErrors2[SSRErrors2["PREFETCH"] = 0] = "PREFETCH";
-  SSRErrors2[SSRErrors2["RENDER_HTML"] = 1] = "RENDER_HTML";
-  SSRErrors2[SSRErrors2["RENDER_STREAM"] = 2] = "RENDER_STREAM";
-  SSRErrors2[SSRErrors2["RENDER_SHELL"] = 3] = "RENDER_SHELL";
+  SSRErrors2[SSRErrors2["PRERENDER"] = 0] = "PRERENDER";
+  SSRErrors2[SSRErrors2["USE_LOADER"] = 1] = "USE_LOADER";
+  SSRErrors2[SSRErrors2["RENDER_HTML"] = 2] = "RENDER_HTML";
+  SSRErrors2[SSRErrors2["RENDER_STREAM"] = 3] = "RENDER_STREAM";
+  SSRErrors2[SSRErrors2["RENDER_SHELL"] = 4] = "RENDER_SHELL";
 })(SSRErrors || (SSRErrors = {}));
 var _obj;
-var errors = (_obj = {}, _define_property(_obj, SSRErrors.PREFETCH, {
-  reporter: "SSR Error - App Prefetch Render",
-  logger: "App Prefetch Render",
-  metrics: "app.prefetch.render.error"
-}), _define_property(_obj, SSRErrors.RENDER_HTML, {
+var errors = (_obj = {}, _define_property(_obj, 0, {
+  reporter: "SSR Error - App Prerender",
+  logger: "App Prerender",
+  metrics: "app.prerender.error"
+}), _define_property(_obj, 1, {
+  reporter: "SSR Error - App run useLoader",
+  logger: "App run useLoader",
+  metrics: "app.useloader.error"
+}), _define_property(_obj, 2, {
   reporter: "SSR Error - App Render To HTML",
   logger: "App Render To HTML",
   metrics: "app.render.html.error"
-}), _define_property(_obj, SSRErrors.RENDER_STREAM, {
+}), _define_property(_obj, 3, {
   reporter: "SSR Error - App Render To Streaming",
   logger: "An error occurs during streaming SSR",
   metrics: "app.render.streaming.error"
-}), _define_property(_obj, SSRErrors.RENDER_SHELL, {
+}), _define_property(_obj, 4, {
   metrics: "app.render.streaming.shell.error"
 }), _obj);
 var _obj1;
-var timings = (_obj1 = {}, _define_property(_obj1, SSRTimings.SSR_PREFETCH, {
-  reporter: "ssr-prefetch",
-  serverTiming: "ssr-prefetch",
-  metrics: "app.prefeth.cost",
-  logger: "App Prefetch cost = %d ms"
-}), _define_property(_obj1, SSRTimings.SSR_RENDER_HTML, {
+var timings = (_obj1 = {}, _define_property(_obj1, 0, {
+  reporter: "ssr-prerender",
+  serverTiming: "ssr-prerender",
+  metrics: "app.prerender.cost",
+  logger: "App Prerender cost = %d ms"
+}), _define_property(_obj1, 1, {
   reporter: "ssr-render-html",
   serverTiming: "ssr-render-html",
   metrics: "app.render.html.cost",
   logger: "App Render To HTML cost = %d ms"
-}), _define_property(_obj1, SSRTimings.SSR_RENDER_TOTAL, {
-  reporter: "ssr-render-total",
-  serverTiming: "ssr-render-total",
-  metrics: "app.render.cost",
-  logger: "App Render Total cost = %d ms"
-}), _define_property(_obj1, SSRTimings.SSR_RENDER_SHELL, {
+}), _define_property(_obj1, 2, {
   reporter: "ssr-render-shell"
+}), _define_property(_obj1, 3, {
+  reporter: "use-loader",
+  serverTiming: "use-loader",
+  logger: "App run useLoader cost = %d ms"
 }), _obj1);
 function createSSRTracker(param) {
   var reporter = param.reporter, serverTiming = param.serverTiming, metrics = param.metrics, logger = param.logger;

package/dist/esm/state/cli/index.js

@@ -58,19 +58,6 @@ var statePlugin = function() {
             plugins
           };
         },
-        validateSchema: function validateSchema() {
-          return [
-            {
-              target: "runtime.state",
-              schema: {
-                type: [
-                  "boolean",
-                  "object"
-                ]
-              }
-            }
-          ];
-        },
         addRuntimeExports: function addRuntimeExports() {
           pluginsExportsUtils.addExport("export { default as state } from '@modern-js/runtime/model'");
         }

package/dist/esm-node/cli/index.js

@@ -1,5 +1,5 @@
 import path from "path";
-import { isReact18, cleanRequireCache, ENTRY_NAME_PATTERN } from "@modern-js/utils";
+import { isReact18, cleanRequireCache } from "@modern-js/utils";
 import { statePlugin } from "../state/cli";
 import { ssrPlugin } from "../ssr/cli";
 import { routerPlugin } from "../router/cli";
@@ -51,29 +51,6 @@ const runtimePlugin = () => ({
           }
         };
       },
-      validateSchema() {
-        return [
-          {
-            target: "runtime",
-            schema: {
-              type: "object",
-              additionalProperties: false
-            }
-          },
-          {
-            target: "runtimeByEntries",
-            schema: {
-              type: "object",
-              patternProperties: {
-                [ENTRY_NAME_PATTERN]: {
-                  type: "object"
-                }
-              },
-              additionalProperties: false
-            }
-          }
-        ];
-      },
       async beforeRestart() {
         cleanRequireCache([
           require.resolve("../state/cli"),