vike 0.4.237 → 0.4.238-commit-3c1a09d

package/dist/esm/node/runtime/renderPage/loadPageConfigsLazyServerSide.js

@@ -1,43 +1,40 @@
-export { loadPageConfigsLazyServerSideAndExecHook };
+export { loadPageConfigsLazyServerSide };
 import { getPageFilesServerSide } from '../../../shared/getPageFiles.js';
-import { resolveVikeConfigPublicPageLazy } from '../../../shared/page-configs/resolveVikeConfigPublic.js';
+import { resolveVikeConfigPublicPageLazyLoaded } from '../../../shared/page-configs/resolveVikeConfigPublic.js';
 import { analyzePageClientSideInit } from '../../../shared/getPageFiles/analyzePageClientSide.js';
-import { assertUsage, assertWarning, hasProp, isArray, isObject, objectAssign } from '../utils.js';
+import { assertUsage, assertWarning, hasProp, isArray, isCallable, isObject, objectAssign, updateType, } from '../utils.js';
 import { getPageAssets } from './getPageAssets.js';
-import { debugPageFiles } from './debugPageFiles.js';
 import { findPageConfig } from '../../../shared/page-configs/findPageConfig.js';
 import { analyzePage } from './analyzePage.js';
-import { loadConfigValues } from '../../../shared/page-configs/loadConfigValues.js';
+import { loadAndParseVirtualFilePageEntry } from '../../../shared/page-configs/loadAndParseVirtualFilePageEntry.js';
 import { execHookServer } from './execHookServer.js';
 import { getCacheControl } from './getCacheControl.js';
-async function loadPageConfigsLazyServerSideAndExecHook(pageContext) {
-    const pageContextAddendum = await loadPageConfigsLazyServerSide(pageContext);
-    objectAssign(pageContext, pageContextAddendum);
+import { addCspHeader, resolvePageContextCspNone } from '../csp.js';
+async function loadPageConfigsLazyServerSide(pageContext) {
+    objectAssign(pageContext, {
+        _pageConfig: findPageConfig(pageContext._globalContext._pageConfigs, pageContext.pageId),
+    });
+    // Load the page's + files
+    updateType(pageContext, await loadPageUserFiles(pageContext));
+    // Resolve new computed pageContext properties
+    updateType(pageContext, await resolvePageContext(pageContext));
+    // Execute +onCreatePageContext
     await execHookServer('onCreatePageContext', pageContext);
     return pageContext;
 }
-// TODO/now: define new function resolveAfterLoad() ?
-async function loadPageConfigsLazyServerSide(pageContext) {
-    const pageConfig = findPageConfig(pageContext._globalContext._pageConfigs, pageContext.pageId); // Make pageConfig globally available as pageContext._pageConfig ?
-    const globalContext = pageContext._globalContext;
-    const [{ pageFilesLoaded, configPublicPageLazy }] = await Promise.all([
-        loadPageConfigFiles(pageContext._globalContext._pageFilesAll, pageConfig, globalContext._pageConfigGlobal, pageContext.pageId, !globalContext._isProduction),
-        analyzePageClientSideInit(pageContext._globalContext._pageFilesAll, pageContext.pageId, {
-            sharedPageFilesAlreadyLoaded: true,
-        }),
-    ]);
-    const { isHtmlOnly, isClientRouting, clientEntries, clientDependencies, pageFilesClientSide, pageFilesServerSide } = await analyzePage(pageContext._globalContext._pageFilesAll, pageConfig, pageContext.pageId, globalContext);
-    const isV1Design = !!pageConfig;
+async function resolvePageContext(pageContext) {
+    const { isHtmlOnly, clientEntries, clientDependencies } = analyzePage(pageContext);
     const passToClient = [];
     const errMsgSuffix = ' should be an array of strings.';
+    const isV1Design = !!pageContext._pageConfig;
     if (!isV1Design) {
-        configPublicPageLazy.exportsAll.passToClient?.forEach((e) => {
+        pageContext.exportsAll.passToClient?.forEach((e) => {
             assertUsage(hasProp(e, 'exportValue', 'string[]'), `${e.exportSource}${errMsgSuffix}`);
             passToClient.push(...e.exportValue);
         });
     }
     else {
-        configPublicPageLazy.from.configsCumulative.passToClient?.values.forEach((v) => {
+        pageContext.from.configsCumulative.passToClient?.values.forEach((v) => {
             const { value, definedAt } = v;
             const errMsg = `+passToClient value defined at ${definedAt}${errMsgSuffix}`;
             //*/ TO-DO/next-major-release: remove the passToClient once setting from the public API
@@ -57,16 +54,14 @@ async function loadPageConfigsLazyServerSide(pageContext) {
             passToClient.push(...valS);
         });
     }
-    const pageContextAddendum = {};
-    objectAssign(pageContextAddendum, configPublicPageLazy);
-    objectAssign(pageContextAddendum, {
-        Page: configPublicPageLazy.exports.Page,
+    objectAssign(pageContext, await resolvePageContextCspNone(pageContext));
+    objectAssign(pageContext, {
+        Page: pageContext.exports.Page,
         _isHtmlOnly: isHtmlOnly,
         _passToClient: passToClient,
-        _pageFilePathsLoaded: pageFilesLoaded.map((p) => p.filePath),
-        headersResponse: resolveHeadersResponse(pageContext, pageContextAddendum),
+        headersResponse: await resolveHeadersResponse(pageContext),
     });
-    objectAssign(pageContextAddendum, {
+    objectAssign(pageContext, {
         __getPageAssets: async () => {
             if ('_pageAssets' in pageContext) {
                 return pageContext._pageAssets;
@@ -79,14 +74,14 @@ async function loadPageConfigsLazyServerSide(pageContext) {
         },
     });
     // TO-DO/next-major-release: remove
-    Object.assign(pageContextAddendum, {
+    Object.assign(pageContext, {
         _getPageAssets: async () => {
             assertWarning(false, 'pageContext._getPageAssets() deprecated, see https://vike.dev/preloading', {
                 onlyOnce: true,
                 showStackTrace: true,
             });
             const pageAssetsOldFormat = [];
-            (await pageContextAddendum.__getPageAssets()).forEach((p) => {
+            (await pageContext.__getPageAssets()).forEach((p) => {
                 if (p.assetType === 'script' && p.isEntry) {
                     pageAssetsOldFormat.push({
                         src: p.src,
@@ -105,43 +100,55 @@ async function loadPageConfigsLazyServerSide(pageContext) {
             return pageAssetsOldFormat;
         },
     });
-    debugPageFiles({
-        pageContext,
-        isHtmlOnly,
-        isClientRouting,
-        pageFilesLoaded,
-        pageFilesClientSide,
-        pageFilesServerSide,
-        clientEntries,
-        clientDependencies,
-    });
-    return pageContextAddendum;
+    return pageContext;
+}
+async function loadPageUserFiles(pageContext) {
+    const [{ configPublicPageLazy }] = await Promise.all([
+        loadPageUserFiles_v1Design(pageContext),
+        analyzePageClientSideInit(pageContext._globalContext._pageFilesAll, pageContext.pageId, {
+            sharedPageFilesAlreadyLoaded: true,
+        }),
+    ]);
+    objectAssign(pageContext, configPublicPageLazy);
+    return pageContext;
 }
-async function loadPageConfigFiles(pageFilesAll, pageConfig, pageConfigGlobal, pageId, isDev) {
-    const pageFilesServerSide = getPageFilesServerSide(pageFilesAll, pageId);
-    const pageConfigLoaded = !pageConfig ? null : await loadConfigValues(pageConfig, isDev);
+async function loadPageUserFiles_v1Design(pageContext) {
+    const pageFilesServerSide = getPageFilesServerSide(pageContext._pageFilesAll, pageContext.pageId);
+    const isDev = !pageContext._globalContext._isProduction;
+    const pageConfigLoaded = !pageContext._pageConfig
+        ? null
+        : await loadAndParseVirtualFilePageEntry(pageContext._pageConfig, isDev);
     await Promise.all(pageFilesServerSide.map((p) => p.loadFile?.()));
-    const configPublicPageLazy = resolveVikeConfigPublicPageLazy(pageFilesServerSide, pageConfigLoaded, pageConfigGlobal);
+    const configPublicPageLazy = resolveVikeConfigPublicPageLazyLoaded(pageFilesServerSide, pageConfigLoaded, pageContext._globalContext._pageConfigGlobal);
     return {
         configPublicPageLazy,
         pageFilesLoaded: pageFilesServerSide,
     };
 }
-function resolveHeadersResponse(pageContext, pageContextAddendum) {
-    const headersResponse = mergeHeaders(pageContextAddendum.config.headersResponse);
+// TODO/now: move all response headers code to headersResponse.ts
+async function resolveHeadersResponse(pageContext) {
+    const headersResponse = await mergeHeaders(pageContext);
     if (!headersResponse.get('Cache-Control')) {
         const cacheControl = getCacheControl(pageContext.pageId, pageContext._globalContext._pageConfigs);
         if (cacheControl)
             headersResponse.set('Cache-Control', cacheControl);
     }
+    addCspHeader(pageContext, headersResponse);
     return headersResponse;
 }
-function mergeHeaders(headersList = []) {
+async function mergeHeaders(pageContext) {
     const headersMerged = new Headers();
-    headersList.forEach((headers) => {
-        new Headers(headers).forEach((value, key) => {
+    await Promise.all((pageContext.config.headersResponse ?? []).map(async (headers) => {
+        let headersInit;
+        if (isCallable(headers)) {
+            headersInit = await headers(pageContext);
+        }
+        else {
+            headersInit = headers;
+        }
+        new Headers(headersInit).forEach((value, key) => {
             headersMerged.append(key, value);
         });
-    });
+    }));
     return headersMerged;
 }

package/dist/esm/node/runtime/renderPage/preparePageContextForPublicUsageServer.d.ts

@@ -1,10 +1,10 @@
 export { preparePageContextForPublicUsageServer };
 export type { PageContextForPublicUsageServer };
 import type { PageContextUrlInternal } from '../../../shared/getPageContextUrlComputed.js';
-import type { VikeConfigPublicPageLazy } from '../../../shared/page-configs/resolveVikeConfigPublic.js';
+import type { VikeConfigPublicPageLazyLoaded } from '../../../shared/page-configs/resolveVikeConfigPublic.js';
 import type { PageContextInternalServer } from '../../../types/PageContext.js';
 import type { GlobalContextServerInternal } from '../globalContext.js';
-type PageContextForPublicUsageServer = PageContextInternalServer & VikeConfigPublicPageLazy & {
+type PageContextForPublicUsageServer = PageContextInternalServer & VikeConfigPublicPageLazyLoaded & {
     urlOriginal: string;
     /** @deprecated */
     url: string;

package/dist/esm/node/runtime/renderPage/{renderPageAlreadyRouted.d.ts → renderPageAfterRoute.d.ts}

@@ -1,4 +1,4 @@
-export { renderPageAlreadyRouted };
+export { renderPageAfterRoute };
 export { prerenderPage };
 export type { PageContextAfterRender };
 import { type PageContextUrlInternal } from '../../../shared/getPageContextUrlComputed.js';
@@ -10,7 +10,7 @@ type PageContextAfterRender = {
     httpResponse: HttpResponse;
     errorWhileRendering: null | Error;
 };
-declare function renderPageAlreadyRouted<PageContext extends {
+declare function renderPageAfterRoute<PageContext extends {
     pageId: string;
     _pageContextAlreadyProvidedByOnPrerenderHook?: true;
     is404: null | boolean;
@@ -42,7 +42,7 @@ declare function prerenderPage(pageContext: PageContextCreated & PageConfigsLazy
         _globalContext: {
             isGlobalContext: true;
             _isOriginalObject: true;
-            _virtualFileExports: unknown;
+            _virtualFileExportsGlobalEntry: unknown;
             _pageFilesAll: import("../../../shared/getPageFiles.js").PageFile[];
             _pageConfigs: import("../../../types/PageConfig.js").PageConfigRuntime[];
             _pageConfigGlobal: import("../../../types/PageConfig.js").PageConfigGlobalRuntime;
@@ -55,7 +55,7 @@ declare function prerenderPage(pageContext: PageContextCreated & PageConfigsLazy
             };
             config: import("../../../types/index.js").ConfigResolved;
             pages: {
-                [k: string]: import("../../../shared/page-configs/resolveVikeConfigPublic.js").VikeConfigPublicPageEager;
+                [k: string]: import("../../../shared/page-configs/resolveVikeConfigPublic.js").VikeConfigPublicPageEagerLoaded;
             };
         } & (({
             _isProduction: false;
@@ -118,11 +118,21 @@ declare function prerenderPage(pageContext: PageContextCreated & PageConfigsLazy
         url: string;
     } & {
         headers: Record<string, string> | null;
-    } & import("../../../shared/getPageFiles.js").VikeConfigPublicPageLazy & {
+    } & import("../../../shared/route/index.js").PageContextAfterRoute & {
+        is404: boolean | null;
+        pageId: string;
+    } & {
+        _pageConfig: import("../../../types/PageConfig.js").PageConfigRuntime | null;
+    } & {
+        _pageConfig: null | import("../../../types/PageConfig.js").PageConfigRuntime;
+    } & import("../../../shared/getPageFiles.js").VikeConfigPublicPageLazyLoaded & {
+        _pageConfig: null | import("../../../types/PageConfig.js").PageConfigRuntime;
+    } & {
+        cspNonce: string;
+    } & {
         Page: unknown;
         _isHtmlOnly: boolean;
         _passToClient: import("../html/serializeContext.js").PassToClient;
-        _pageFilePathsLoaded: string[];
         headersResponse: Headers;
     } & {
         __getPageAssets: () => Promise<import("./getPageAssets.js").PageAsset[]>;
@@ -153,7 +163,7 @@ declare function prerenderPage(pageContext: PageContextCreated & PageConfigsLazy
         _globalContext: {
             isGlobalContext: true;
             _isOriginalObject: true;
-            _virtualFileExports: unknown;
+            _virtualFileExportsGlobalEntry: unknown;
             _pageFilesAll: import("../../../shared/getPageFiles.js").PageFile[];
             _pageConfigs: import("../../../types/PageConfig.js").PageConfigRuntime[];
             _pageConfigGlobal: import("../../../types/PageConfig.js").PageConfigGlobalRuntime;
@@ -166,7 +176,7 @@ declare function prerenderPage(pageContext: PageContextCreated & PageConfigsLazy
             };
             config: import("../../../types/index.js").ConfigResolved;
             pages: {
-                [k: string]: import("../../../shared/page-configs/resolveVikeConfigPublic.js").VikeConfigPublicPageEager;
+                [k: string]: import("../../../shared/page-configs/resolveVikeConfigPublic.js").VikeConfigPublicPageEagerLoaded;
             };
         } & (({
             _isProduction: false;
@@ -229,11 +239,21 @@ declare function prerenderPage(pageContext: PageContextCreated & PageConfigsLazy
         url: string;
     } & {
         headers: Record<string, string> | null;
-    } & import("../../../shared/getPageFiles.js").VikeConfigPublicPageLazy & {
+    } & import("../../../shared/route/index.js").PageContextAfterRoute & {
+        is404: boolean | null;
+        pageId: string;
+    } & {
+        _pageConfig: import("../../../types/PageConfig.js").PageConfigRuntime | null;
+    } & {
+        _pageConfig: null | import("../../../types/PageConfig.js").PageConfigRuntime;
+    } & import("../../../shared/getPageFiles.js").VikeConfigPublicPageLazyLoaded & {
+        _pageConfig: null | import("../../../types/PageConfig.js").PageConfigRuntime;
+    } & {
+        cspNonce: string;
+    } & {
         Page: unknown;
         _isHtmlOnly: boolean;
         _passToClient: import("../html/serializeContext.js").PassToClient;
-        _pageFilePathsLoaded: string[];
         headersResponse: Headers;
     } & {
         __getPageAssets: () => Promise<import("./getPageAssets.js").PageAsset[]>;

package/dist/esm/node/runtime/renderPage/{renderPageAlreadyRouted.js → renderPageAfterRoute.js}

@@ -1,11 +1,11 @@
-export { renderPageAlreadyRouted };
+export { renderPageAfterRoute };
 export { prerenderPage };
 import { getErrorPageId } from '../../../shared/error-page.js';
 import { getHtmlString } from '../html/renderHtml.js';
-import { assert, assertUsage, augmentType, hasProp, objectAssign } from '../utils.js';
+import { assert, assertUsage, updateType, hasProp, objectAssign } from '../utils.js';
 import { getPageContextClientSerialized } from '../html/serializeContext.js';
 import { createHttpResponsePage, createHttpResponsePageContextJson } from './createHttpResponse.js';
-import { loadPageConfigsLazyServerSideAndExecHook, } from './loadPageConfigsLazyServerSide.js';
+import { loadPageConfigsLazyServerSide, } from './loadPageConfigsLazyServerSide.js';
 import { execHookOnRenderHtml } from './execHookOnRenderHtml.js';
 import { execHookDataAndOnBeforeRender } from './execHookDataAndOnBeforeRender.js';
 import { logRuntimeError } from '../loggerRuntime.js';
@@ -14,8 +14,7 @@ import { preparePageContextForPublicUsageServer } from './preparePageContextForP
 import { execHookGuard } from '../../../shared/route/execHookGuard.js';
 import pc from '@brillout/picocolors';
 import { isServerSideError } from '../../../shared/misc/isServerSideError.js';
-// TODO/now: rename?
-async function renderPageAlreadyRouted(pageContext) {
+async function renderPageAfterRoute(pageContext) {
     // pageContext.pageId can either be the:
     //  - ID of the page matching the routing, or the
     //  - ID of the error page `_error.page.js`.
@@ -24,7 +23,7 @@ async function renderPageAlreadyRouted(pageContext) {
     assert(isError ===
         (pageContext.pageId ===
             getErrorPageId(pageContext._globalContext._pageFilesAll, pageContext._globalContext._pageConfigs)));
-    augmentType(pageContext, await loadPageConfigsLazyServerSideAndExecHook(pageContext));
+    updateType(pageContext, await loadPageConfigsLazyServerSide(pageContext));
     if (!isError) {
         await execHookGuard(pageContext, (pageContext) => preparePageContextForPublicUsageServer(pageContext));
     }

package/dist/esm/node/runtime/renderPage.d.ts

@@ -6,6 +6,12 @@ import { type GlobalContextServerInternal } from './globalContext.js';
 import { type HttpResponse } from './renderPage/createHttpResponse.js';
 import type { PageContextServer } from '../../types/index.js';
 import type { PageContextInternalServer } from '../../types/PageContext.js';
+declare const globalObject: {
+    httpRequestsCount: number;
+    asyncHookWrapper: <PageContext>(_httpRequestId: number, ret: () => Promise<PageContext>) => Promise<{
+        pageContextReturn: Awaited<PageContext>;
+    }>;
+};
 type PageContextInit = Pick<PageContextInternalServer, 'urlOriginal' | 'headersOriginal'> & {
     /** @deprecated Set `pageContextInit.urlOriginal` instead  */ url?: string;
     /** @deprecated Set pageContextInit.headersOriginal instead */ headers?: Record<string, string>;
@@ -14,10 +20,7 @@ type PageContextBegin = ReturnType<typeof getPageContextBegin>;
 declare function renderPage<PageContextUserAdded extends {}, PageContextInitUser extends PageContextInit>(pageContextInit: PageContextInitUser): Promise<PageContextInitUser & {
     httpResponse: HttpResponse;
 } & Partial<PageContextServer & PageContextUserAdded>>;
-declare let asyncHookWrapper: <PageContext>(_httpRequestId: number, ret: () => Promise<PageContext>) => Promise<{
-    pageContextReturn: Awaited<PageContext>;
-}>;
-declare function renderPage_addAsyncHookwrapper(wrapper: typeof asyncHookWrapper): void;
+declare function renderPage_addAsyncHookwrapper(wrapper: typeof globalObject.asyncHookWrapper): void;
 declare function getPageContextBegin(pageContextInit: PageContextInit, globalContext: GlobalContextServerInternal, httpRequestId: number): {
     _isOriginalObject: true;
     isPageContext: true;
@@ -31,7 +34,7 @@ declare function getPageContextBegin(pageContextInit: PageContextInit, globalCon
     _globalContext: {
         isGlobalContext: true;
         _isOriginalObject: true;
-        _virtualFileExports: unknown;
+        _virtualFileExportsGlobalEntry: unknown;
         _pageFilesAll: import("../../shared/getPageFiles.js").PageFile[];
         _pageConfigs: import("../../types/PageConfig.js").PageConfigRuntime[];
         _pageConfigGlobal: import("../../types/PageConfig.js").PageConfigGlobalRuntime;
@@ -44,7 +47,7 @@ declare function getPageContextBegin(pageContextInit: PageContextInit, globalCon
         };
         config: import("../../types/index.js").ConfigResolved;
         pages: {
-            [k: string]: import("../../shared/page-configs/resolveVikeConfigPublic.js").VikeConfigPublicPageEager;
+            [k: string]: import("../../shared/page-configs/resolveVikeConfigPublic.js").VikeConfigPublicPageEagerLoaded;
         };
     } & (({
         _isProduction: false;

package/dist/esm/node/runtime/renderPage.js

@@ -1,9 +1,9 @@
 export { renderPage };
 export { renderPage_addAsyncHookwrapper };
-import { renderPageAlreadyRouted } from './renderPage/renderPageAlreadyRouted.js';
+import { renderPageAfterRoute } from './renderPage/renderPageAfterRoute.js';
 import { createPageContextServerSide, createPageContextServerSideWithoutGlobalContext, } from './renderPage/createPageContextServerSide.js';
 import { route } from '../../shared/route/index.js';
-import { assert, hasProp, objectAssign, isUrl, parseUrl, onSetupRuntime, assertWarning, getGlobalObject, checkType, assertUsage, normalizeUrlPathname, removeBaseServer, modifyUrlPathname, prependBase, removeUrlOrigin, setUrlOrigin, isUri, getUrlPretty, augmentType, } from './utils.js';
+import { assert, hasProp, objectAssign, isUrl, parseUrl, onSetupRuntime, assertWarning, getGlobalObject, checkType, assertUsage, normalizeUrlPathname, removeBaseServer, modifyUrlPathname, prependBase, removeUrlOrigin, setUrlOrigin, isUri, getUrlPretty, updateType, } from './utils.js';
 import { assertNoInfiniteAbortLoop, getPageContextFromAllRewrites, isAbortError, logAbortErrorHandled, } from '../../shared/route/abort.js';
 import { getGlobalContextServerInternal, initGlobalContext_renderPage, } from './globalContext.js';
 import { handlePageContextRequestUrl } from './renderPage/handlePageContextRequestUrl.js';
@@ -16,10 +16,13 @@ import pc from '@brillout/picocolors';
 import { getPageContextClientSerializedAbort, getPageContextClientSerialized } from './html/serializeContext.js';
 import { getErrorPageId } from '../../shared/error-page.js';
 import { handleErrorWithoutErrorPage } from './renderPage/handleErrorWithoutErrorPage.js';
-import { loadPageConfigsLazyServerSideAndExecHook } from './renderPage/loadPageConfigsLazyServerSide.js';
+import { loadPageConfigsLazyServerSide } from './renderPage/loadPageConfigsLazyServerSide.js';
 import { resolveRedirects } from './renderPage/resolveRedirects.js';
 import { getVikeConfigError } from '../shared/getVikeConfigError.js';
-const globalObject = getGlobalObject('runtime/renderPage.ts', { httpRequestsCount: 0 });
+const globalObject = getGlobalObject('runtime/renderPage.ts', {
+    httpRequestsCount: 0,
+    asyncHookWrapper: getFallbackAsyncHookWrapper(),
+});
 // `renderPage()` calls `renderPageNominal()` while ensuring that errors are `console.error(err)` instead of `throw err`, so that Vike never triggers a server shut down. (Throwing an error in an Express.js middleware shuts down the whole Express.js server.)
 async function renderPage(pageContextInit) {
     assertArguments(...arguments);
@@ -32,19 +35,21 @@ async function renderPage(pageContextInit) {
     const httpRequestId = getRequestId();
     const urlOriginalPretty = getUrlPretty(pageContextInit.urlOriginal);
     logHttpRequest(urlOriginalPretty, httpRequestId);
-    const { pageContextReturn } = await asyncHookWrapper(httpRequestId, () => renderPagePrepare(pageContextInit, httpRequestId));
+    const { pageContextReturn } = await globalObject.asyncHookWrapper(httpRequestId, () => renderPagePrepare(pageContextInit, httpRequestId));
     logHttpResponse(urlOriginalPretty, httpRequestId, pageContextReturn);
     checkType(pageContextReturn);
     assert(pageContextReturn.httpResponse);
     return pageContextReturn;
 }
-// Fallback wrapper if node:async_hooks isn't available
-let asyncHookWrapper = async (_httpRequestId, ret) => ({
-    pageContextReturn: await ret(),
-});
 // Add node:async_hooks wrapper
 function renderPage_addAsyncHookwrapper(wrapper) {
-    asyncHookWrapper = wrapper;
+    globalObject.asyncHookWrapper = wrapper;
+}
+// Fallback wrapper if node:async_hooks isn't available
+function getFallbackAsyncHookWrapper() {
+    return async (_httpRequestId, ret) => ({
+        pageContextReturn: await ret(),
+    });
 }
 async function renderPagePrepare(pageContextInit, httpRequestId) {
     // Invalid config
@@ -148,7 +153,7 @@ async function renderPageAlreadyPrepared(pageContextBegin, globalContext, httpRe
 async function renderPageOnError(errNominalPage, pageContextBegin, pageContextNominalPageBegin, globalContext, httpRequestId, pageContextsFromRewrite) {
     assert(pageContextNominalPageBegin);
     assert(hasProp(pageContextNominalPageBegin, 'urlOriginal', 'string'));
-    const pageContextErrorPageInit = await getPageContextErrorPageInit(pageContextBegin, errNominalPage, pageContextNominalPageBegin);
+    const pageContextErrorPageInit = await getPageContextErrorPageInit(pageContextBegin, errNominalPage);
     // Handle `throw redirect()` and `throw render()` while rendering nominal page
     if (isAbortError(errNominalPage)) {
         const handled = await handleAbortError(errNominalPage, pageContextsFromRewrite, pageContextBegin, pageContextNominalPageBegin, httpRequestId, pageContextErrorPageInit, globalContext);
@@ -173,7 +178,7 @@ async function renderPageOnError(errNominalPage, pageContextBegin, pageContextNo
     }
     let pageContextErrorPage;
     try {
-        pageContextErrorPage = await renderPageAlreadyRouted(pageContextErrorPageInit);
+        pageContextErrorPage = await renderPageAfterRoute(pageContextErrorPageInit);
     }
     catch (errErrorPage) {
         // Handle `throw redirect()` and `throw render()` while rendering error page
@@ -288,11 +293,11 @@ async function renderPageNominal(pageContext) {
     assert(hasProp(pageContext, 'pageId', 'string'));
     assert(pageContext.errorWhileRendering === null);
     // Render
-    const pageContextAfterRender = await renderPageAlreadyRouted(pageContext);
+    const pageContextAfterRender = await renderPageAfterRoute(pageContext);
     assert(pageContext === pageContextAfterRender);
     return pageContextAfterRender;
 }
-async function getPageContextErrorPageInit(pageContextBegin, errNominalPage, pageContextNominalPagePartial) {
+async function getPageContextErrorPageInit(pageContextBegin, errNominalPage) {
     const pageContext = forkPageContext(pageContextBegin);
     assert(errNominalPage);
     objectAssign(pageContext, {
@@ -300,9 +305,6 @@ async function getPageContextErrorPageInit(pageContextBegin, errNominalPage, pag
         errorWhileRendering: errNominalPage,
         routeParams: {},
     });
-    objectAssign(pageContext, {
-        _debugRouteMatches: pageContextNominalPagePartial._debugRouteMatches || 'ROUTING_ERROR',
-    });
     assert(pageContext.errorWhileRendering);
     return pageContext;
 }
@@ -418,7 +420,7 @@ pageContextNominalPageBegin, httpRequestId, pageContextErrorPageInit, globalCont
             objectAssign(pageContext, { pageId: errorPageId });
             objectAssign(pageContext, pageContextAbort);
             objectAssign(pageContext, pageContextErrorPageInit, true);
-            augmentType(pageContext, await loadPageConfigsLazyServerSideAndExecHook(pageContext));
+            updateType(pageContext, await loadPageConfigsLazyServerSide(pageContext));
             // We include pageContextInit: we don't only serialize pageContextAbort because the error page may need to access pageContextInit
             pageContextSerialized = getPageContextClientSerialized(pageContext, false);
         }

package/dist/esm/node/runtime/utils.d.ts

@@ -44,7 +44,7 @@ export * from '../../utils/isHtml.js';
 export * from '../../utils/warnIfErrorIsNotObject.js';
 export * from '../../utils/virtualFileId.js';
 export * from '../../utils/stripAnsi.js';
-export * from '../../utils/getTerminWidth.js';
+export * from '../../utils/getTerminalWidth.js';
 export * from '../../utils/truncateString.js';
 export * from '../../utils/formatHintLog.js';
 export * from '../../utils/joinEnglish.js';
@@ -55,8 +55,9 @@ export * from '../../utils/isVikeReactApp.js';
 export * from '../../utils/getPropAccessNotation.js';
 export * from '../../utils/PROJECT_VERSION.js';
 export * from '../../utils/genPromise.js';
-export * from '../../utils/augmentType.js';
+export * from '../../utils/updateType.js';
 export * from '../../utils/changeEnumerable.js';
 export * from '../../utils/getViteRPC.js';
 export * from '../../utils/isRunnableDevEnvironment.js';
 export * from '../../utils/assertIsNotBrowser.js';
+export * from '../../utils/isNonRunnableDev.js';

package/dist/esm/node/runtime/utils.js

@@ -48,7 +48,7 @@ export * from '../../utils/isHtml.js';
 export * from '../../utils/warnIfErrorIsNotObject.js';
 export * from '../../utils/virtualFileId.js';
 export * from '../../utils/stripAnsi.js';
-export * from '../../utils/getTerminWidth.js';
+export * from '../../utils/getTerminalWidth.js';
 export * from '../../utils/truncateString.js';
 export * from '../../utils/formatHintLog.js';
 export * from '../../utils/joinEnglish.js';
@@ -59,8 +59,9 @@ export * from '../../utils/isVikeReactApp.js';
 export * from '../../utils/getPropAccessNotation.js';
 export * from '../../utils/PROJECT_VERSION.js';
 export * from '../../utils/genPromise.js';
-export * from '../../utils/augmentType.js';
+export * from '../../utils/updateType.js';
 export * from '../../utils/changeEnumerable.js';
 export * from '../../utils/getViteRPC.js';
 export * from '../../utils/isRunnableDevEnvironment.js';
 export * from '../../utils/assertIsNotBrowser.js';
+export * from '../../utils/isNonRunnableDev.js';

package/dist/esm/node/runtime-dev/createDevMiddleware.d.ts

@@ -1,9 +1,9 @@
 export { createDevMiddleware };
 import type { ResolvedConfig, Connect, ViteDevServer } from 'vite';
-import type { APIOptions } from '../api/types.js';
+import type { ApiOptions } from '../api/types.js';
 declare function createDevMiddleware(options?: {
     root?: string;
-} & APIOptions): Promise<{
+} & ApiOptions): Promise<{
     devMiddleware: Connect.Server;
     viteServer: ViteDevServer;
     viteConfig: ResolvedConfig;

package/dist/esm/node/runtime-dev/createDevMiddleware.js

@@ -1,14 +1,12 @@
 export { createDevMiddleware };
 import { createServer } from 'vite';
 import { prepareViteApiCall } from '../api/prepareViteApiCall.js';
-import { setGlobalContext_isProduction } from '../runtime/globalContext.js';
 /*
  * Create server middleware for development with HMR and lazy-transpiling.
  *
  * https://vike.dev/createDevMiddleware
  */
 async function createDevMiddleware(options = {}) {
-    setGlobalContext_isProduction(false, true);
     const optionsMod = {
         ...options,
         viteConfig: {

package/dist/esm/node/shared/virtualFileId.d.ts

@@ -0,0 +1,28 @@
+export { parseVirtualFileId };
+export { generateVirtualFileId };
+export { virtualFileIdGlobalEntryServer };
+export { virtualFileIdGlobalEntryClientSR };
+export { virtualFileIdGlobalEntryClientCR };
+declare const virtualFileIdGlobalEntryServer = "virtual:vike:global-entry:server";
+declare const virtualFileIdGlobalEntryClientSR = "virtual:vike:global-entry:client:server-routing";
+declare const virtualFileIdGlobalEntryClientCR = "virtual:vike:global-entry:client:client-routing";
+type VirtualFileIdEntryParsed = {
+    type: 'global-entry';
+    isForClientSide: boolean;
+    isClientRouting: boolean;
+} | {
+    type: 'page-entry';
+    isForClientSide: boolean;
+    pageId: string;
+    isExtractAssets: boolean;
+};
+declare function parseVirtualFileId(id: string): false | VirtualFileIdEntryParsed;
+declare function generateVirtualFileId(args: {
+    type: 'global-entry';
+    isForClientSide: boolean;
+    isClientRouting: boolean;
+} | {
+    type: 'page-entry';
+    pageId: string;
+    isForClientSide: boolean;
+}): string;