vike 0.4.231 → 0.4.232-commit-134207d

package/dist/cjs/node/runtime/globalContext.js

@@ -3,6 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.vikeConfigErrorRecoverMsg = void 0;
 exports.getGlobalContext = getGlobalContext;
 exports.getGlobalContextSync = getGlobalContextSync;
 exports.getGlobalContextAsync = getGlobalContextAsync;
@@ -30,18 +31,23 @@ exports.updateUserFiles = updateUserFiles;
 //   - globalObject.viteDevServer is used by updateUserFiles() which then sets virtualFileExports
 const utils_js_1 = require("./utils.js");
 const runtime_1 = require("@brillout/vite-plugin-server-entry/runtime");
-const virtualFileImportUserCode_js_1 = require("../shared/virtual-files/virtualFileImportUserCode.js");
+const virtualFileEntry_js_1 = require("../shared/virtualFiles/virtualFileEntry.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const loadPageRoutes_js_1 = require("../../shared/route/loadPageRoutes.js");
 const assertV1Design_js_1 = require("../shared/assertV1Design.js");
 const resolveBase_js_1 = require("../shared/resolveBase.js");
 const createGlobalContextShared_js_1 = require("../../shared/createGlobalContextShared.js");
 const prepareGlobalContextForPublicUsage_js_1 = require("../../shared/prepareGlobalContextForPublicUsage.js");
+const loggerRuntime_js_1 = require("./loggerRuntime.js");
+const getVikeConfigError_js_1 = require("../shared/getVikeConfigError.js");
+const isNewError_js_1 = require("./renderPage/isNewError.js");
 const debug = (0, utils_js_1.createDebugger)('vike:globalContext');
 const globalObject = (0, utils_js_1.getGlobalObject)('runtime/globalContext.ts', getInitialGlobalContext());
 // Trick to break down TypeScript circular dependency
 // https://chat.deepseek.com/a/chat/s/d7e9f90a-c7f3-4108-9cd5-4ad6caed3539
 const globalObjectTyped = globalObject;
+const vikeConfigErrorRecoverMsg = picocolors_1.default.bold(picocolors_1.default.green('Vike config loaded'));
+exports.vikeConfigErrorRecoverMsg = vikeConfigErrorRecoverMsg;
 async function getGlobalContextServerInternal() {
     // getGlobalContextServerInternal() should always be called after initGlobalContext()
     (0, utils_js_1.assert)(globalObject.isInitialized);
@@ -121,22 +127,24 @@ async function setGlobalContext_viteDevServer(viteDevServer) {
     setIsProduction(false);
     // We cannot cache globalObject.viteDevServer because it's fully replaced when the user modifies vite.config.js => Vite's dev server is fully reloaded and a new viteDevServer replaces the previous one.
     if (!globalObject.viteDevServer) {
-        assertIsNotInitilizedYet();
+        assertIsNotInitializedYet();
     }
     (0, utils_js_1.assert)(globalObject.viteConfig);
     globalObject.viteDevServer = viteDevServer;
-    await updateUserFiles();
-    assertGlobalContextIsDefined();
     globalObject.viteDevServerPromiseResolve(viteDevServer);
+    const { success } = await updateUserFiles();
+    if (!success)
+        return;
+    assertGlobalContextIsDefined();
 }
 function setGlobalContext_viteConfig(viteConfig, viteConfigRuntime) {
     if (globalObject.viteConfig)
         return;
-    assertIsNotInitilizedYet();
+    assertIsNotInitializedYet();
     globalObject.viteConfig = viteConfig;
     globalObject.viteConfigRuntime = viteConfigRuntime;
 }
-function assertIsNotInitilizedYet() {
+function assertIsNotInitializedYet() {
     // In development, globalObject.viteDevServer always needs to be awaited for before initializing globalObject.globalContext
     (0, utils_js_1.assert)(!globalObject.globalContext);
 }
@@ -160,7 +168,7 @@ function getViteConfig() {
 }
 async function initGlobalContext_renderPage() {
     debug('initGlobalContext_renderPage()');
-    // `globalObject.isProduction === undefined` when using production server without `vike-server`. (There isn't any reliable signal we can use to determine early whether the environement is production or development.)
+    // `globalObject.isProduction === undefined` when using production server without `vike-server`. (There isn't any reliable signal we can use to determine early whether the environment is production or development.)
     if (globalObject.isProduction === undefined)
         setIsProduction(true);
     await initGlobalContext();
@@ -177,7 +185,7 @@ async function initGlobalContext_runPrerender() {
     // We assume initGlobalContext_runPrerender() to be called before:
     // - initGlobalContext_renderPage()
     // - initGlobalContext_getGlobalContextAsync()
-    assertIsNotInitilizedYet();
+    assertIsNotInitializedYet();
     await initGlobalContext();
 }
 async function initGlobalContext_getGlobalContextAsync() {
@@ -189,24 +197,13 @@ async function initGlobalContext_getPagesAndRoutes() {
     setIsProduction(true);
     await initGlobalContext();
 }
-async function waitForViteDevServer() {
-    debug('waitForViteDevServer()');
-    const waitFor = 20;
-    const timeout = setTimeout(() => {
-        (0, utils_js_1.assertWarning)(false, `Vite's development server still not created after ${waitFor} seconds.`, {
-            onlyOnce: false,
-            showStackTrace: true
-        });
-    }, waitFor * 1000);
-    await globalObject.viteDevServerPromise;
-    clearTimeout(timeout);
-    assertGlobalContextIsDefined();
-}
 async function initGlobalContext() {
     const { isProduction } = globalObject;
     (0, utils_js_1.assert)(typeof isProduction === 'boolean');
     if (!isProduction) {
-        await waitForViteDevServer();
+        await globalObject.viteDevServerPromise;
+        (0, utils_js_1.assert)(globalObject.waitForUserFilesUpdate);
+        await globalObject.waitForUserFilesUpdate;
     }
     else {
         await loadBuildEntry(globalObject.viteConfigRuntime?.build.outDir);
@@ -302,28 +299,72 @@ function assertVersionAtBuildTime(versionAtBuildTime) {
     (0, utils_js_1.assertUsage)(versionAtBuildTime === versionAtRuntime, `Re-build your app (you're using ${pretty(versionAtRuntime)} but your app was built with ${pretty(versionAtBuildTime)})`);
 }
 async function updateUserFiles() {
-    const { promise, resolve } = (0, utils_js_1.genPromise)();
     (0, utils_js_1.assert)(!globalObject.isProduction);
+    const { promise, resolve } = (0, utils_js_1.genPromise)();
     globalObject.waitForUserFilesUpdate = promise;
+    globalObject.waitForUserFilesUpdateResolve ?? (globalObject.waitForUserFilesUpdateResolve = []);
+    globalObject.waitForUserFilesUpdateResolve.push(resolve);
+    const onError = (err) => {
+        if (!(0, isNewError_js_1.hasAlreadyLogged)(err)) {
+            (0, loggerRuntime_js_1.logRuntimeError)(err, null);
+        }
+        (0, getVikeConfigError_js_1.setVikeConfigError)({ errorRuntime: { err } });
+        globalObject.vikeConfigHasRuntimeError = true;
+        return { success: false };
+    };
+    const onSuccess = () => {
+        if (globalObject.vikeConfigHasRuntimeError) {
+            (0, utils_js_1.assert)(loggerRuntime_js_1.logRuntimeInfo); // always defined in dev
+            (0, loggerRuntime_js_1.logRuntimeInfo)(vikeConfigErrorRecoverMsg, null, 'error-recover');
+        }
+        globalObject.vikeConfigHasRuntimeError = false;
+        (0, getVikeConfigError_js_1.setVikeConfigError)({ errorRuntime: false });
+        globalObject.waitForUserFilesUpdateResolve.forEach((resolve) => resolve());
+        globalObject.waitForUserFilesUpdateResolve = [];
+        resolve();
+        return { success: true };
+    };
+    const isOutdated = () => 
+    // There is a newer call — let the new call supersede the old one.
+    // We deliberately swallow the intermetidate state (including any potential error) — it's now outdated and has existed only for a very short period of time.
+    globalObject.waitForUserFilesUpdate !== promise ||
+        // Avoid race condition: abort if there is a new globalObject.viteDevServer (happens when vite.config.js is modified => Vite's dev server is fully reloaded).
+        viteDevServer !== globalObject.viteDevServer;
     const { viteDevServer } = globalObject;
     (0, utils_js_1.assert)(viteDevServer);
+    let hasError = false;
     let virtualFileExports;
+    let err;
     try {
-        virtualFileExports = await viteDevServer.ssrLoadModule(virtualFileImportUserCode_js_1.virtualFileIdImportUserCodeServer);
+        virtualFileExports = await viteDevServer.ssrLoadModule(virtualFileEntry_js_1.virtualFileIdEntryServer);
     }
-    catch (err) {
-        (0, utils_js_1.debugGlob)(`Glob error: ${virtualFileImportUserCode_js_1.virtualFileIdImportUserCodeServer} transpile error: `, err);
-        throw err;
+    catch (err_) {
+        hasError = true;
+        err = err_;
     }
+    if (isOutdated())
+        return { success: false };
+    if (hasError)
+        return onError(err);
     virtualFileExports = virtualFileExports.default || virtualFileExports;
-    (0, utils_js_1.debugGlob)('Glob result: ', virtualFileExports);
-    // Avoid race condition: abort if there is a new globalObject.viteDevServer (happens when vite.config.js is modified => Vite's dev server is fully reloaded).
-    if (viteDevServer !== globalObject.viteDevServer)
-        return;
-    await setGlobalContext(virtualFileExports);
-    resolve();
+    if ((0, getVikeConfigError_js_1.getVikeConfigErrorBuild)()) {
+        return { success: false };
+    }
+    try {
+        await setGlobalContext(virtualFileExports);
+    }
+    catch (err_) {
+        hasError = true;
+        err = err_;
+    }
+    if (isOutdated())
+        return { success: false };
+    if (hasError)
+        return onError(err);
+    return onSuccess();
 }
 async function setGlobalContext(virtualFileExports) {
+    (0, utils_js_1.assert)(!(0, getVikeConfigError_js_1.getVikeConfigErrorBuild)());
     const globalContext = await (0, createGlobalContextShared_js_1.createGlobalContextShared)(virtualFileExports, globalObject, addGlobalContext);
     (0, assertV1Design_js_1.assertV1Design)(
     // pageConfigs is PageConfigRuntime[] but assertV1Design() requires PageConfigBuildTime[]
@@ -338,7 +379,7 @@ async function addGlobalContext(globalContext) {
     const globalContextBase = {
         isClientSide: false,
         _pageRoutes: pageRoutes,
-        _onBeforeRouteHook: onBeforeRouteHook
+        _onBeforeRouteHook: onBeforeRouteHook,
     };
     const { viteDevServer, viteConfig, viteConfigRuntime, isPrerendering, isProduction } = globalObject;
     (0, utils_js_1.assert)(typeof isProduction === 'boolean');
@@ -356,7 +397,7 @@ async function addGlobalContext(globalContext) {
             assetsManifest: null,
             _viteDevServer: viteDevServer,
             viteConfig,
-            viteConfigRuntime
+            viteConfigRuntime,
         };
     }
     else {
@@ -372,21 +413,21 @@ async function addGlobalContext(globalContext) {
             assetsManifest,
             _viteDevServer: null,
             viteConfigRuntime: buildInfo.viteConfigRuntime,
-            _usesClientRouter: buildInfo.usesClientRouter
+            _usesClientRouter: buildInfo.usesClientRouter,
         };
         if (isPrerendering) {
             (0, utils_js_1.assert)(viteConfig);
             return {
                 ...globalContextBase2,
                 _isPrerendering: true,
-                viteConfig
+                viteConfig,
             };
         }
         else {
             return {
                 ...globalContextBase2,
                 _isPrerendering: false,
-                viteConfig: null
+                viteConfig: null,
             };
         }
     }
@@ -400,7 +441,7 @@ function getInitialGlobalContext() {
     const { promise: viteDevServerPromise, resolve: viteDevServerPromiseResolve } = (0, utils_js_1.genPromise)();
     return {
         viteDevServerPromise,
-        viteDevServerPromiseResolve
+        viteDevServerPromiseResolve,
     };
 }
 function resolveBaseRuntime(viteConfigRuntime, config) {

package/dist/cjs/node/runtime/html/injectAssets/getHtmlTags.js

@@ -20,7 +20,7 @@ async function getHtmlTags(pageContext, streamFromReactStreamingPackage, injectF
     (0, utils_js_1.assert)([true, false].includes(pageContext._isHtmlOnly));
     const isHtmlOnly = pageContext._isHtmlOnly;
     const { _isProduction: isProduction } = pageContext._globalContext;
-    const injectScriptsAt = getInjectScriptsAt(pageContext.pageId, pageContext._pageConfigs);
+    const injectScriptsAt = getInjectScriptsAt(pageContext.pageId, pageContext._globalContext._pageConfigs);
     const injectFilterEntries = [];
     pageAssets
         .filter((asset) => {
@@ -28,7 +28,7 @@ async function getHtmlTags(pageContext, streamFromReactStreamingPackage, injectF
             // We could allow the user to change the position of <script> but we currently don't:
             //  - Because of mergeScriptEntries()
             //  - We would need to add HTML_STREAM to to PreloadFilterInject
-            // To suppor this, we should add the JavaScript entry to injectFilterEntries (with an `src` value of `null`)
+            // To support this, we should add the JavaScript entry to injectFilterEntries (with an `src` value of `null`)
             return false;
         }
         return true;
@@ -56,7 +56,7 @@ async function getHtmlTags(pageContext, streamFromReactStreamingPackage, injectF
             ...asset,
             inject,
             // @ts-ignore
-            [stamp]: true
+            [stamp]: true,
         };
         injectFilterEntries.push(entry);
     });
@@ -131,14 +131,14 @@ async function getHtmlTags(pageContext, streamFromReactStreamingPackage, injectF
             htmlTag: () => 
             // Needs to be called after resolvePageContextPromise()
             getPageContextJsonScriptTag(pageContext),
-            position: positionJavaScriptEntry
+            position: positionJavaScriptEntry,
         });
         // <script id="vike_globalContext" type="application/json">
         htmlTags.push({
             htmlTag: () => 
             // Needs to be called after resolvePageContextPromise()
             getGlobalContextJsonScriptTag(pageContext),
-            position: positionJavaScriptEntry
+            position: positionJavaScriptEntry,
         });
     }
     // The JavaScript entry <script> tag
@@ -146,7 +146,7 @@ async function getHtmlTags(pageContext, streamFromReactStreamingPackage, injectF
     if (scriptEntry) {
         htmlTags.push({
             htmlTag: scriptEntry,
-            position: positionJavaScriptEntry
+            position: positionJavaScriptEntry,
         });
     }
     // Preload tags
@@ -221,12 +221,12 @@ function checkForWarnings(injectFilterEntries) {
             //  - https://github.com/vitejs/vite/issues/2282
             //  - https://github.com/vikejs/vike/issues/261
             (0, utils_js_1.assertWarning)(a.inject, `[injectFilter()] We recommend against not injecting ${a.src}`, {
-                onlyOnce: true
+                onlyOnce: true,
             });
         }
         if (a.assetType === 'script') {
             (0, utils_js_1.assertWarning)(a.inject, `[injectFilter()] We recommend against not preloading JavaScript (${a.src})`, {
-                onlyOnce: true
+                onlyOnce: true,
             });
         }
     });

package/dist/cjs/node/runtime/html/injectAssets/getViteDevScript.js

@@ -23,7 +23,7 @@ async function getViteDevScript(pageContext) {
     const viteInjection = fakeHtml.slice(fakeHtmlBegin.length, -1 * fakeHtmlEnd.length);
     (0, utils_js_1.assert)(viteInjection.includes('script'));
     (0, utils_js_1.assertWarning)(!viteInjection.includes('import('), `Unexpected Vite injected HMR code. ${reachOutCTA}`, {
-        onlyOnce: true
+        onlyOnce: true,
     });
     const viteDevScript = viteInjection;
     return viteDevScript;

package/dist/cjs/node/runtime/html/injectAssets/inferHtmlTags.js

@@ -17,7 +17,7 @@ function inferPreloadTag(pageAsset) {
         !assetType ? null : `as="${assetType}"`,
         !mediaType ? null : `type="${mediaType}"`,
         // `crossorigin` is needed for fonts, see https://developer.mozilla.org/en-US/docs/Web/HTML/Link_types/preload#cors-enabled_fetches
-        !isCrossOrigin(pageAsset) ? null : 'crossorigin'
+        !isCrossOrigin(pageAsset) ? null : 'crossorigin',
     ]
         .filter(Boolean)
         .join(' ');

package/dist/cjs/node/runtime/html/injectAssets/injectAssets__public.js

@@ -8,22 +8,22 @@ async function injectAssets__public(htmlString, pageContext) {
     (0, utils_js_1.assertWarning)(false, '`_injectAssets()` is deprecated and will be removed.', { onlyOnce: true, showStackTrace: true });
     (0, utils_js_1.assertUsage)(typeof htmlString === 'string', '[injectAssets(htmlString, pageContext)]: Argument `htmlString` should be a string.', { showStackTrace: true });
     (0, utils_js_1.assertUsage)(pageContext, '[injectAssets(htmlString, pageContext)]: Argument `pageContext` is missing.', {
-        showStackTrace: true
+        showStackTrace: true,
     });
     const errMsg = (body) => '[injectAssets(htmlString, pageContext)]: ' +
         body +
         '. Make sure that `pageContext` is the object that Vike provided to your `render(pageContext)` hook.';
     (0, utils_js_1.assertUsage)((0, utils_js_1.hasProp)(pageContext, 'urlPathname', 'string'), errMsg('`pageContext.urlPathname` should be a string'), {
-        showStackTrace: true
+        showStackTrace: true,
     });
     (0, utils_js_1.assertUsage)((0, utils_js_1.hasProp)(pageContext, 'pageId', 'string'), errMsg('`pageContext.pageId` should be a string'), {
-        showStackTrace: true
+        showStackTrace: true,
     });
     (0, utils_js_1.assertUsage)((0, utils_js_1.hasProp)(pageContext, '__getPageAssets'), errMsg('`pageContext.__getPageAssets` is missing'), {
-        showStackTrace: true
+        showStackTrace: true,
     });
     (0, utils_js_1.assertUsage)((0, utils_js_1.hasProp)(pageContext, '_passToClient', 'string[]'), errMsg('`pageContext._passToClient` is missing'), {
-        showStackTrace: true
+        showStackTrace: true,
     });
     (0, utils_js_1.castProp)(pageContext, '__getPageAssets');
     htmlString = await (0, injectAssets_js_1.injectHtmlTagsToString)([htmlString], pageContext, null);

package/dist/cjs/node/runtime/html/injectAssets/injectHtmlTags.js

@@ -30,7 +30,7 @@ function joinHtmlTags(htmlTags) {
 function injectHtmlFragment(position, htmlFragment, htmlString) {
     if (position === 'HTML_BEGIN') {
         {
-            const res = injectAtPaceholder(htmlFragment, htmlString, true);
+            const res = injectAtPlaceholder(htmlFragment, htmlString, true);
             if (res)
                 return res;
         }
@@ -40,7 +40,7 @@ function injectHtmlFragment(position, htmlFragment, htmlString) {
     }
     if (position === 'HTML_END') {
         {
-            const res = injectAtPaceholder(htmlFragment, htmlString, false);
+            const res = injectAtPlaceholder(htmlFragment, htmlString, false);
             if (res)
                 return res;
         }
@@ -149,7 +149,7 @@ function getTagClosing(tag) {
     const tagClosing = new RegExp(`</${tag}>`, 'i');
     return tagClosing;
 }
-function injectAtPaceholder(htmlFragment, htmlString, isFirst) {
+function injectAtPlaceholder(htmlFragment, htmlString, isFirst) {
     const placeholder = isFirst ? '__VITE_PLUGIN_SSR__ASSETS_FIRST__' : '__VITE_PLUGIN__SSR_ASSETS_LAST__';
     const parts = htmlString.split(placeholder);
     if (parts.length === 1)

package/dist/cjs/node/runtime/html/injectAssets.js

@@ -22,7 +22,7 @@ function injectHtmlTagsToStream(pageContext, streamFromReactStreamingPackage, in
     return {
         injectAtStreamBegin,
         injectAtStreamAfterFirstChunk,
-        injectAtStreamEnd
+        injectAtStreamEnd,
     };
     async function injectAtStreamBegin(htmlPartsBegin) {
         const pageAssets = await pageContext.__getPageAssets();

package/dist/cjs/node/runtime/html/renderHtml.js

@@ -47,7 +47,7 @@ async function renderDocumentHtml(documentHtml, pageContext, onErrorWhileStreami
             const { htmlStream } = render;
             const streamWrapper = await renderHtmlStream(htmlStream, {
                 htmlPartsBegin: render.htmlPartsBegin,
-                htmlPartsEnd: render.htmlPartsEnd
+                htmlPartsEnd: render.htmlPartsEnd,
             }, pageContext, onErrorWhileStreaming, injectFilter);
             return streamWrapper;
         }
@@ -58,7 +58,7 @@ async function renderDocumentHtml(documentHtml, pageContext, onErrorWhileStreami
 async function renderHtmlStream(streamOriginal, injectString, pageContext, onErrorWhileStreaming, injectFilter) {
     const processStreamOptions = {
         onErrorWhileStreaming,
-        enableEagerStreaming: pageContext.enableEagerStreaming
+        enableEagerStreaming: pageContext.enableEagerStreaming,
     };
     if (injectString) {
         let streamFromReactStreamingPackage = null;
@@ -112,8 +112,8 @@ function escapeInject(templateStrings, ...templateVariables) {
     return {
         _template: {
             templateStrings,
-            templateVariables: templateVariables
-        }
+            templateVariables: templateVariables,
+        },
     };
 }
 function dangerouslySkipEscape(alreadyEscapedString) {
@@ -130,7 +130,7 @@ function _dangerouslySkipEscape(arg) {
     }
     (0, utils_js_1.assertWarning)(false, `[dangerouslySkipEscape(${picocolors_1.default.cyan('str')})] Argument ${picocolors_1.default.cyan('str')} should be a string but we got ${picocolors_1.default.cyan(`typeof str === "${typeof arg}"`)}.`, {
         onlyOnce: false,
-        showStackTrace: true
+        showStackTrace: true,
     });
     return { _escaped: String(arg) };
 }
@@ -185,7 +185,7 @@ function renderTemplate(templateContent, pageContext) {
             const nth = (i === 0 && '1st') || (i === 1 && '2nd') || (i === 2 && '3rd') || `${i}-th`;
             return [
                 `The ${nth} HTML variable is ${msg}`,
-                `The HTML was provided by the ${hookName}() hook at ${hookFilePath}.`
+                `The HTML was provided by the ${hookName}() hook at ${hookFilePath}.`,
             ]
                 .filter(Boolean)
                 .join(' ');
@@ -224,13 +224,13 @@ function renderTemplate(templateContent, pageContext) {
     if (htmlStream === null) {
         (0, utils_js_1.assert)(htmlPartsEnd.length === 0);
         return {
-            htmlPartsAll: htmlPartsBegin
+            htmlPartsAll: htmlPartsBegin,
         };
     }
     return {
         htmlStream,
         htmlPartsBegin,
-        htmlPartsEnd
+        htmlPartsEnd,
     };
 }
 async function getHtmlString(htmlRender) {

package/dist/cjs/node/runtime/html/serializeContext.js

@@ -27,7 +27,7 @@ const passToClientBuiltInPageContext = [
     pageContextInitIsPassedToClient_js_1.pageContextInitIsPassedToClient,
     'pageId',
     'routeParams',
-    'data' // for data() hook
+    'data', // for data() hook
 ];
 const pageToClientBuiltInPageContextError = ['pageProps', 'is404', isServerSideError_js_1.isServerSideError];
 function getPageContextClientSerialized(pageContext) {
@@ -78,7 +78,7 @@ function serializeObject(obj, objName, passToClient) {
                 // Non-serializable property set by the user
                 let msg = [
                     `${h(varName)} can't be serialized and, therefore, can't be passed to the client side.`,
-                    `Make sure ${h(varName)} is serializable, or remove ${h(JSON.stringify(prop))} from ${h('passToClient')}.`
+                    `Make sure ${h(varName)} is serializable, or remove ${h(JSON.stringify(prop))} from ${h('passToClient')}.`,
                 ].join(' ');
                 if ((0, stringify_1.isJsonSerializerError)(err)) {
                     msg = `${msg} Serialization error: ${err.messageCore}.`;
@@ -112,7 +112,7 @@ function serializeValue(value, varName) {
 }
 function getPassToClientPageContext(pageContext) {
     let passToClient = [...pageContext._passToClient, ...passToClientBuiltInPageContext];
-    if ((0, error_page_js_1.isErrorPage)(pageContext.pageId, pageContext._pageConfigs)) {
+    if ((0, error_page_js_1.isErrorPage)(pageContext.pageId, pageContext._globalContext._pageConfigs)) {
         (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageContext, 'is404', 'boolean'));
         (0, addIs404ToPageProps_js_1.addIs404ToPageProps)(pageContext);
         passToClient.push(...pageToClientBuiltInPageContextError);
@@ -138,7 +138,7 @@ function getPageContextClientSerializedAbort(pageContext) {
         'abortStatusCode',
         'abortReason',
         'is404',
-        'pageProps'
+        'pageProps',
     ].includes(prop));
     if (!pageContext._isLegacyRenderErrorPage) {
         (0, utils_js_1.assert)(unknownProps.length === 0);
@@ -148,9 +148,9 @@ function getPageContextClientSerializedAbort(pageContext) {
         (0, utils_js_1.assertWarning)(unknownProps.length === 0, [
             "The following pageContext values won't be available on the client-side:",
             unknownProps.map((p) => `  pageContext[${JSON.stringify(p)}]`),
-            'Use `throw render()` instead of `throw RenderErrorPage()`'
+            'Use `throw render()` instead of `throw RenderErrorPage()`',
         ].join('\n'), {
-            onlyOnce: false
+            onlyOnce: false,
         });
     }
     return serializeValue(pageContext);

package/dist/cjs/node/runtime/html/stream.js

@@ -82,7 +82,7 @@ function stringToStreamReadableWeb(str) {
         start(controller) {
             controller.enqueue(encodeForWebStream(str));
             controller.close();
-        }
+        },
     });
     return readableStream;
 }
@@ -126,7 +126,7 @@ async function streamPipeNodeToString(streamPipeNode) {
             else {
                 resolve();
             }
-        }
+        },
     });
     streamPipeNode(writable);
     return promise;
@@ -143,7 +143,7 @@ function streamPipeWebToString(streamPipeWeb) {
         close() {
             str += getClosingChunk();
             resolve(str);
-        }
+        },
     });
     streamPipeWeb(writable);
     return promise;
@@ -217,7 +217,7 @@ function pipeToStreamWritableNode(htmlRender, writable) {
     (0, utils_js_1.checkType)(htmlRender);
     (0, utils_js_1.assert)(false);
 }
-async function processStream(streamOriginal, { injectStringAtBegin, injectStringAfterFirstChunk, injectStringAtEnd, onErrorWhileStreaming, enableEagerStreaming }) {
+async function processStream(streamOriginal, { injectStringAtBegin, injectStringAfterFirstChunk, injectStringAtEnd, onErrorWhileStreaming, enableEagerStreaming, }) {
     const buffer = [];
     let streamOriginalHasStartedEmitting = false;
     let streamOriginalEnded = false;
@@ -315,7 +315,7 @@ async function processStream(streamOriginal, { injectStringAtBegin, injectString
         },
         onFlush() {
             flushStream();
-        }
+        },
     });
     wrapperCreated = true;
     flushBuffer(); // In case onReadyToWrite() was already called (the flushBuffer() of onReadyToWrite() wasn't called because `wrapperCreated === false`)
@@ -378,7 +378,7 @@ async function processStream(streamOriginal, { injectStringAtBegin, injectString
         return !enableEagerStreaming && !streamOriginalHasStartedEmitting;
     }
 }
-async function createStreamWrapper({ streamOriginal, onError, onData, onEnd, onFlush, onReadyToWrite }) {
+async function createStreamWrapper({ streamOriginal, onError, onData, onEnd, onFlush, onReadyToWrite, }) {
     if ((0, react_streaming_js_1.isStreamFromReactStreamingPackage)(streamOriginal)) {
         debug(`onRenderHtml() hook returned ${picocolors_1.default.cyan('react-streaming')} result`);
         const stream = (0, react_streaming_js_1.getStreamOfReactStreamingPackage)(streamOriginal);
@@ -434,13 +434,13 @@ async function createStreamWrapper({ streamOriginal, onError, onData, onEnd, onF
                 }
                 callback(err);
                 endStream();
-            }
+            },
         });
         // Forward the flush() call
         (0, utils_js_1.objectAssign)(writableProxy, {
             flush: () => {
                 onFlush();
-            }
+            },
         });
         (0, utils_js_1.assert)(typeof writableProxy.flush === 'function');
         const pipeOriginal = getStreamPipeNode(streamOriginal);
@@ -497,7 +497,7 @@ async function createStreamWrapper({ streamOriginal, onError, onData, onEnd, onF
                 abort(err) {
                     onError(err);
                     endStream();
-                }
+                },
             });
         }
         else {
@@ -512,7 +512,7 @@ async function createStreamWrapper({ streamOriginal, onError, onData, onEnd, onF
                 async onEnd() {
                     await onEnd();
                     endStream();
-                }
+                },
             });
         }
         const pipeOriginal = getStreamPipeWeb(streamOriginal);
@@ -545,15 +545,15 @@ async function createStreamWrapper({ streamOriginal, onError, onData, onEnd, onF
                     },
                     async onEnd() {
                         await closeStream();
-                    }
+                    },
                 });
             },
             async cancel(...args) {
                 isCancel = true;
                 await readableOriginal.cancel(...args);
-                // If readableOriginal has implemented readableOriginal.cancel() then the onEnd() callback and therfore closeStream() may already have been called at this point
+                // If readableOriginal has implemented readableOriginal.cancel() then the onEnd() callback and therefore closeStream() may already have been called at this point
                 await closeStream();
-            }
+            },
         });
         const writeChunk = (chunk) => {
             if (
@@ -570,7 +570,7 @@ async function createStreamWrapper({ streamOriginal, onError, onData, onEnd, onF
         const flushStream = null;
         return {
             streamWrapper: readableProxy,
-            streamWrapperOperations: { writeChunk, flushStream }
+            streamWrapperOperations: { writeChunk, flushStream },
         };
     }
     if (isStreamReadableNode(streamOriginal)) {
@@ -605,12 +605,12 @@ async function createStreamWrapper({ streamOriginal, onError, onData, onEnd, onF
         });
         return {
             streamWrapper: readableProxy,
-            streamWrapperOperations: { writeChunk, flushStream }
+            streamWrapperOperations: { writeChunk, flushStream },
         };
     }
     (0, utils_js_1.assert)(false);
 }
-async function handleReadableWeb(readable, { onData, onError, onEnd }) {
+async function handleReadableWeb(readable, { onData, onError, onEnd, }) {
     const reader = readable.getReader();
     while (true) {
         let result;
@@ -645,7 +645,7 @@ const __streamPipeWeb = '__streamPipeWeb';
 function pipeWebStream(pipe) {
     (0, utils_js_1.assertWarning)(false, 'pipeWebStream() is outdated, use stampPipe() instead. See https://vike.dev/streaming', {
         onlyOnce: true,
-        showStackTrace: true
+        showStackTrace: true,
     });
     return { [__streamPipeWeb]: pipe };
 }
@@ -680,7 +680,7 @@ const __streamPipeNode = '__streamPipeNode';
 function pipeNodeStream(pipe) {
     (0, utils_js_1.assertWarning)(false, 'pipeNodeStream() is outdated, use stampPipe() instead. See https://vike.dev/streaming', {
         onlyOnce: true,
-        showStackTrace: true
+        showStackTrace: true,
     });
     return { [__streamPipeNode]: pipe };
 }
@@ -712,7 +712,7 @@ function isStreamPipeNode(thing) {
 }
 function stampPipe(pipe, pipeType) {
     (0, utils_js_1.assertUsage)(pipeType, `stampPipe(pipe, pipeType): argument ${picocolors_1.default.cyan('pipeType')} is missing.)`, {
-        showStackTrace: true
+        showStackTrace: true,
     });
     (0, utils_js_1.assertUsage)(['web-stream', 'node-stream'].includes(pipeType), `stampPipe(pipe, pipeType): argument ${picocolors_1.default.cyan('pipeType')} should be either ${picocolors_1.default.cyan("'web-stream'")} or ${picocolors_1.default.cyan("'node-stream'")}.`, { showStackTrace: true });
     if (pipeType === 'node-stream') {