vike 0.4.249-commit-b3b9c55 → 0.4.250-commit-193dea3

package/dist/client/runtime-server-routing/createPageContextClientSide.js

@@ -1,13 +1,7 @@
 export { createPageContextClientSide };
-import { assertUsage, updateType, objectAssign } from './utils.js';
-import { getPageContextSerializedInHtml } from '../shared/getJsonSerializedInHtml.js';
-import { loadPageConfigsLazyClientSide, } from '../shared/loadPageConfigsLazyClientSide.js';
-import { getCurrentUrl } from '../shared/getCurrentUrl.js';
+import { updateType, objectAssign } from './utils.js';
 import { createPageContextObject, createPageContextShared } from '../../shared-server-client/createPageContextShared.js';
 import { getGlobalContextClientInternal } from './getGlobalContextClientInternal.js';
-import { preparePageContextForPublicUsageClient, } from './preparePageContextForPublicUsageClient.js';
-import { execHook } from '../../shared-server-client/hooks/execHook.js';
-const urlFirst = getCurrentUrl({ withoutHash: true });
 async function createPageContextClientSide() {
     const globalContext = await getGlobalContextClientInternal();
     const pageContextCreated = createPageContextObject();
@@ -21,21 +15,7 @@ async function createPageContextClientSide() {
         isHistoryNavigation: null,
         _hasPageContextFromServer: true,
     });
-    objectAssign(pageContextCreated, getPageContextSerializedInHtml());
     // Sets pageContext.config to global configs
     updateType(pageContextCreated, createPageContextShared(pageContextCreated, globalContext._globalConfigPublic));
-    // Sets pageContext.config to local configs (overrides the pageContext.config set above)
-    updateType(pageContextCreated, await loadPageConfigsLazyClientSideAndExecHook(pageContextCreated));
-    assertPristineUrl();
     return pageContextCreated;
 }
-function assertPristineUrl() {
-    const urlCurrent = getCurrentUrl({ withoutHash: true });
-    assertUsage(urlFirst === urlCurrent, `The URL was manipulated before the hydration finished ('${urlFirst}' to '${urlCurrent}'). Ensure the hydration has finished before manipulating the URL. Consider using the onHydrationEnd() hook.`);
-}
-async function loadPageConfigsLazyClientSideAndExecHook(pageContext) {
-    const pageContextAddendum = await loadPageConfigsLazyClientSide(pageContext.pageId, pageContext._pageFilesAll, pageContext._globalContext._pageConfigs, pageContext._globalContext._pageConfigGlobal);
-    objectAssign(pageContext, pageContextAddendum);
-    await execHook('onCreatePageContext', pageContext, preparePageContextForPublicUsageClient);
-    return pageContext;
-}

package/dist/client/runtime-server-routing/entry.js

@@ -2,13 +2,17 @@ import { assertServerRouting } from '../../utils/assertRoutingType.js';
 assertServerRouting();
 import { createPageContextClientSide } from './createPageContextClientSide.js';
 import { execHookOnRenderClient } from '../shared/execHookOnRenderClient.js';
-import { assertSingleInstance_onClientEntryServerRouting } from './utils.js';
+import { assertSingleInstance_onClientEntryServerRouting, assertUsage, objectAssign } from './utils.js';
 import { removeFoucBuster } from '../shared/removeFoucBuster.js';
 import { execHook } from '../../shared-server-client/hooks/execHook.js';
 import { preparePageContextForPublicUsageClient } from './preparePageContextForPublicUsageClient.js';
 import { setVirtualFileExportsGlobalEntry } from '../shared/getGlobalContextClientInternalShared.js';
 // @ts-expect-error
 import * as virtualFileExportsGlobalEntry from 'virtual:vike:global-entry:client:server-routing';
+import { loadPageConfigsLazyClientSide } from '../shared/loadPageConfigsLazyClientSide.js';
+import { getPageContextSerializedInHtml } from '../shared/getJsonSerializedInHtml.js';
+import { getCurrentUrl } from '../shared/getCurrentUrl.js';
+const urlFirst = getCurrentUrl({ withoutHash: true });
 assertSingleInstance_onClientEntryServerRouting(import.meta.env.PROD);
 setVirtualFileExportsGlobalEntry(virtualFileExportsGlobalEntry);
 if (import.meta.env.DEV)
@@ -16,6 +20,16 @@ if (import.meta.env.DEV)
 hydrate();
 async function hydrate() {
     const pageContext = await createPageContextClientSide();
+    objectAssign(pageContext, getPageContextSerializedInHtml());
+    // Sets pageContext.config using local configs — overrides the pageContext.config set using global configs at createPageContextClientSide()
+    const pageContextAddendum = await loadPageConfigsLazyClientSide(pageContext.pageId, pageContext._pageFilesAll, pageContext._globalContext._pageConfigs, pageContext._globalContext._pageConfigGlobal);
+    objectAssign(pageContext, pageContextAddendum);
+    await execHook('onCreatePageContext', pageContext, preparePageContextForPublicUsageClient);
+    assertPristineUrl();
     await execHookOnRenderClient(pageContext, preparePageContextForPublicUsageClient);
     await execHook('onHydrationEnd', pageContext, preparePageContextForPublicUsageClient);
 }
+function assertPristineUrl() {
+    const urlCurrent = getCurrentUrl({ withoutHash: true });
+    assertUsage(urlFirst === urlCurrent, `The URL was manipulated before the hydration finished ('${urlFirst}' to '${urlCurrent}'). Ensure the hydration has finished before manipulating the URL. Consider using the onHydrationEnd() hook.`);
+}

package/dist/client/shared/execHookOnRenderClient.d.ts

@@ -3,11 +3,14 @@ export type { PageContextBeforeRenderClient };
 import type { PageFile, PageContextConfig } from '../../shared-server-client/getPageFiles.js';
 import type { PageContextForPublicUsageClientShared } from './preparePageContextForPublicUsageClientShared.js';
 import type { GlobalContextClientInternalShared } from './getGlobalContextClientInternalShared.js';
+import type { PageContextCreatedClient } from '../runtime-client-routing/createPageContextClientSide.js';
+import type { PageContextCreatedClient_ServerRouting } from '../runtime-server-routing/createPageContextClientSide.js';
+type PageContextCreatedClientShared = PageContextCreatedClient | PageContextCreatedClient_ServerRouting;
 type PageContextBeforeRenderClient = {
     _pageFilesLoaded: PageFile[];
     urlOriginal?: string;
     urlPathname?: string;
     pageId: string;
     _globalContext: GlobalContextClientInternalShared;
-} & PageContextConfig & PageContextForPublicUsageClientShared;
+} & PageContextCreatedClientShared & PageContextConfig & PageContextForPublicUsageClientShared;
 declare function execHookOnRenderClient<PageContext extends PageContextBeforeRenderClient>(pageContext: PageContext, prepareForPublicUsage: (pageConfig: PageContext) => PageContext): Promise<void>;

package/dist/node/vite/shared/loggerDev.d.ts

@@ -2,11 +2,11 @@ export { logVite };
 export { logConfigInfo };
 export { logErrorServerDev };
 export type { LogType };
-export type { AddTagsDev };
+export type { AddAssertTagsDev };
 import { type PageContext_logRuntime } from '../../../server/runtime/loggerRuntime.js';
 type LogType = 'info' | 'warn' | 'error' | 'error-resolve';
 declare function logConfigInfo(msg: string, logType: LogType): void;
 declare function logVite(msg: string, logType: LogType, requestId: number | null, prependViteTag: boolean): void;
 declare function logErrorServerDev(err: unknown, pageContext: PageContext_logRuntime, errorComesFromVite?: boolean): void;
-type AddTagsDev = typeof addTagsDev;
-declare function addTagsDev<TagVike extends string, TagType extends string>(tagVike: TagVike, tagType: TagType): `1:37:00 PM ${TagVike}[request(n)]${TagType}`;
+type AddAssertTagsDev = typeof addAssertTagsDev;
+declare function addAssertTagsDev<TagVike extends string, TagType extends string>(tagVike: TagVike, tagType: TagType): `1:37:00 PM ${TagVike}[request(n)]${TagType}`;

package/dist/node/vite/shared/loggerDev.js

@@ -12,7 +12,7 @@ export { logErrorServerDev };
 import { isAbortError } from '../../../shared-server-client/route/abort.js';
 import { getViteConfig } from '../../../server/runtime/globalContext.js';
 import { assertPageContext_logRuntime, setLogRuntimeDev, } from '../../../server/runtime/loggerRuntime.js';
-import { setAssertOnBeforeErr, assert, assertIsNotProductionRuntime, colorVike, colorVite, formatHintLog, hasGreen, hasProp, hasRed, hasYellow, isDebugError, stripAnsi, colorError, colorWarning, setAssertAddTagsDev, } from '../utils.js';
+import { setAssertOnBeforeErr, assert, assertIsNotProductionRuntime, colorVike, colorVite, formatHintLog, hasGreen, hasProp, hasRed, hasYellow, isDebugError, stripAnsi, colorError, colorWarning, setAssertAddAssertTagsDev, } from '../utils.js';
 import { isErrorWithCodeSnippet, getPrettyErrorWithCodeSnippet } from './loggerDev/errorWithCodeSnippet.js';
 import { getConfigExecutionErrorIntroMsg, getConfigBuildErrorFormatted, } from './resolveVikeConfigInternal/transpileAndExecuteFile.js';
 import pc from '@brillout/picocolors';
@@ -27,7 +27,7 @@ setAssertOnBeforeErr((err) => {
     // We must directly apply vite.ssrFixStacktrace() to `assertWarning(..., { showStackTrace: true })` because warnings aren't caught by the try-catch of renderPageServer()
     applyViteSourceMap(err);
 });
-setAssertAddTagsDev(addTagsDev);
+setAssertAddAssertTagsDev(addAssertTagsDev);
 // Note shown to user when Vike completely modifies the error message (which is somewhat risky)
 const errorDebugNote = pc.dim(formatHintLog("Error isn't helpful? See https://vike.dev/debug#verbose-errors"));
 function logRuntimeInfoDev(msg, pageContext, logType) {
@@ -186,7 +186,7 @@ function getTagSourceOuter(tagSource) {
     const tagSourceOuter = (!tagSource ? '' : pc.dim(`[${tagSource}]`));
     return tagSourceOuter;
 }
-function addTagsDev(tagVike, tagType) {
+function addAssertTagsDev(tagVike, tagType) {
     const timestamp = getTagTimestamp();
     const tagSource = getTagSource();
     const tagSourceOuter = getTagSourceOuter(tagSource);

package/dist/node/vite/shared/resolveVikeConfigInternal/configDefinitionsBuiltIn.js

@@ -2,6 +2,7 @@ export { configDefinitionsBuiltIn };
 import { assert, assertUsage } from '../../utils.js';
 import { getConfigDefinedAt, } from '../../../../shared-server-client/page-configs/getConfigDefinedAt.js';
 import { getConfigValueSourceRelevantAnyEnv, getConfigValueSourcesRelevant, isConfigSourceValueNull, } from '../../plugins/pluginVirtualFiles/getConfigValueSourcesRelevant.js';
+import { getFileSuffixes } from '../../../../shared-server-node/getFileSuffixes.js';
 const configDefinitionsBuiltIn = {
     onRenderHtml: {
         env: { server: true },
@@ -117,7 +118,7 @@ const configDefinitionsBuiltIn = {
                 // Exclude `.ssr.js` hooks (they don't require pageContext.json requests)
                 .filter((source) => {
                 const { definedAt } = source;
-                if ('filePathAbsoluteVite' in definedAt && definedAt.filePathAbsoluteVite.includes('.ssr.')) {
+                if ('fileName' in definedAt && getFileSuffixes(definedAt.fileName).includes('ssr')) {
                     return false;
                 }
                 return true;

package/dist/server/onLoad.js

@@ -1,7 +1,7 @@
 export { onLoad };
 import { assertIsNotBrowser } from '../utils/assertIsNotBrowser.js';
 import { assertNodeVersion } from '../utils/assertNodeVersion.js';
-import { setAlwaysShowStackTrace } from '../utils/assert.js';
+import { setAssertAlwaysShowStackTrace } from '../utils/assert.js';
 import { installRequireShim } from '@brillout/require-shim';
 import { isDebugError } from '../utils/debug.js';
 function onLoad() {
@@ -10,7 +10,7 @@ function onLoad() {
     if (isDebugError()) {
         // Is also executed upon `$ vike build` because node/vite/utils.ts imports server/utils.ts
         Error.stackTraceLimit = Infinity;
-        setAlwaysShowStackTrace();
+        setAssertAlwaysShowStackTrace();
     }
     addEcosystemStamp();
     installRequireShim();

package/dist/server/runtime/logErrorServer.d.ts

@@ -1,5 +1,5 @@
 export { logErrorServer };
 export { hasAlreadyLogged };
-import { type PageContext_logRuntime } from './loggerRuntime.js';
-declare function logErrorServer(err: unknown, pageContext: PageContext_logRuntime): void;
+import type { PageContextCreatedServerMinimum } from './renderPageServer/createPageContextServerSide.js';
+declare function logErrorServer(err: unknown, pageContext: PageContextCreatedServerMinimum | null): void;
 declare function hasAlreadyLogged(err: unknown): boolean;

package/dist/server/runtime/logErrorServer.js

@@ -3,7 +3,6 @@ export { hasAlreadyLogged };
 import pc from '@brillout/picocolors';
 import { assertIsNotBrowser, assertWarning, getGlobalObject, hasRed, isDebugError, isObject } from '../utils.js';
 import { execHookOnError } from './renderPageServer/execHookOnError.js';
-import { assertPageContext_logRuntime } from './loggerRuntime.js';
 import { addErrorHint } from './renderPageServer/addErrorHint.js';
 import { isAbortError } from '../../shared-server-client/route/abort.js';
 assertIsNotBrowser();
@@ -11,7 +10,6 @@ const globalObject = getGlobalObject('server/runtime/logErrorServer.ts', {
     wasAlreadyLogged: new WeakSet(),
 });
 function logErrorServer(err, pageContext) {
-    assertPageContext_logRuntime(pageContext);
     if (isAbortError(err) && !isDebugError())
         return;
     // I don't think there is a use case for printing the same error object twice? Reloading page throwing error => the same error is printed a second time but it's a different error object.

package/dist/server/runtime/loggerRuntime.d.ts

@@ -4,10 +4,11 @@ export { setLogRuntimeDev };
 export { assertPageContext_logRuntime };
 export type { PageContext_logRuntime };
 import type { LogType } from '../../node/vite/shared/loggerDev.js';
+import type { PageContextCreatedServerMinimum } from './renderPageServer/createPageContextServerSide.js';
 type LogRuntimeInfo = (msg: string, pageContext: PageContext_logRuntime, logType: LogType) => void;
 type LogRuntimeError = (err: unknown, pageContext: PageContext_logRuntime) => void;
-type PageContext_logRuntime = null | {
+type PageContext_logRuntime = null | (PageContextCreatedServerMinimum & {
     _requestId: number;
-};
+});
 declare function setLogRuntimeDev(logRuntimeErrorDev: LogRuntimeError, logRuntimeInfoDev: LogRuntimeInfo): void;
 declare function assertPageContext_logRuntime(pageContext: PageContext_logRuntime): void;

package/dist/server/runtime/renderPageServer/createHttpResponse.d.ts

@@ -1,7 +1,8 @@
 export { createHttpResponsePage };
-export { createHttpResponsePageContextJson };
+export { createHttpResponsePageJson };
 export { createHttpResponseErrorFallback };
 export { createHttpResponseErrorFallback_noGlobalContext };
+export { createHttpResponseErrorFallbackJson };
 export { createHttpResponseRedirect };
 export { createHttpResponse404 };
 export { createHttpResponseBaseIsMissing };
@@ -36,5 +37,6 @@ declare function createHttpResponseErrorFallback(pageContext: {
     _globalContext: GlobalContextServerInternal;
 }): HttpResponse;
 declare function createHttpResponseErrorFallback_noGlobalContext(): HttpResponse;
-declare function createHttpResponsePageContextJson(pageContextSerialized: string): Promise<HttpResponse>;
+declare function createHttpResponseErrorFallbackJson(): HttpResponse;
+declare function createHttpResponsePageJson(pageContextSerialized: string): Promise<HttpResponse>;
 declare function createHttpResponseRedirect({ url, statusCode }: UrlRedirect, pageContextInit: PageContextBegin): HttpResponse;

package/dist/server/runtime/renderPageServer/createHttpResponse.js

@@ -1,7 +1,8 @@
 export { createHttpResponsePage };
-export { createHttpResponsePageContextJson };
+export { createHttpResponsePageJson };
 export { createHttpResponseErrorFallback };
 export { createHttpResponseErrorFallback_noGlobalContext };
+export { createHttpResponseErrorFallbackJson };
 export { createHttpResponseRedirect };
 export { createHttpResponse404 };
 export { createHttpResponseBaseIsMissing };
@@ -11,6 +12,9 @@ import { getHttpResponseBody, getHttpResponseBodyStreamHandlers } from './getHtt
 import { getEarlyHints } from './getEarlyHints.js';
 import { assertNoInfiniteHttpRedirect } from './createHttpResponse/assertNoInfiniteHttpRedirect.js';
 import { resolveHeadersResponseFinal } from './headersResponse.js';
+import { stringify } from '@brillout/json-serializer/stringify';
+const contentTypeJson = 'application/json';
+const contentTypeHtml = 'text/html;charset=utf-8';
 async function createHttpResponsePage(htmlRender, renderHook, pageContext) {
     let statusCode = pageContext.abortStatusCode;
     if (!statusCode) {
@@ -29,17 +33,17 @@ async function createHttpResponsePage(htmlRender, renderHook, pageContext) {
     }
     const earlyHints = getEarlyHints(await pageContext.__getPageAssets());
     const headers = resolveHeadersResponseFinal(pageContext, statusCode);
-    return createHttpResponse(statusCode, 'text/html;charset=utf-8', headers, htmlRender, earlyHints, renderHook);
+    return createHttpResponse(statusCode, contentTypeHtml, headers, htmlRender, earlyHints, renderHook);
 }
 function createHttpResponse404(errMsg404) {
-    const httpResponse = createHttpResponse(404, 'text/html;charset=utf-8', [], `<p>${errMsg404}.</p><script>console.log('This HTML was generated by Vike.')</script>`);
+    const httpResponse = createHttpResponse(404, contentTypeHtml, [], `<p>${errMsg404}.</p><script>console.log('This HTML was generated by Vike.')</script>`);
     return httpResponse;
 }
 function createHttpResponseBaseIsMissing(urlOriginal, baseServer) {
     const httpResponse = createHttpResponse(
     // We use the error code `500` to signal a failing state because this HTTP response should never be used, see https://vike.dev/base-url#setup
     // In other words: this HTTP response is expected to be generated but isn't expected to be actually used.
-    500, 'text/html;charset=utf-8', [], `
+    500, contentTypeHtml, [], `
 <h1>Error: Base URL is missing</h1>
 <p>
   <a href="https://vike.dev/renderPage"><code>renderPage(pageContextInit)</code></a> called with <code>pageContextInit.urlOriginal===${JSON.stringify(urlOriginal)}</code> which doesn't start with the Base URL <code>${baseServer}</code>.
@@ -74,11 +78,15 @@ function createHttpResponseErrorFallback_noGlobalContext() {
     return createHttpResponseError_('no error page (https://vike.dev/error-page) could be rendered');
 }
 function createHttpResponseError_(reason) {
-    const httpResponse = createHttpResponse(500, 'text/html;charset=utf-8', [], `<p>An error occurred.</p><script>console.log(${JSON.stringify(`This HTML was generated by Vike. Vike returned this HTML because ${reason}.`)})</script>`);
+    const httpResponse = createHttpResponse(500, contentTypeHtml, [], `<p>An error occurred.</p><script>console.log(${JSON.stringify(`This HTML was generated by Vike. Vike returned this HTML because ${reason}.`)})</script>`);
     return httpResponse;
 }
-async function createHttpResponsePageContextJson(pageContextSerialized) {
-    const httpResponse = createHttpResponse(200, 'application/json', [], pageContextSerialized, [], null);
+function createHttpResponseErrorFallbackJson() {
+    const httpResponse = createHttpResponse(500, contentTypeJson, [], stringify({ serverSideError: true }));
+    return httpResponse;
+}
+async function createHttpResponsePageJson(pageContextSerialized) {
+    const httpResponse = createHttpResponse(200, contentTypeJson, [], pageContextSerialized, [], null);
     return httpResponse;
 }
 function createHttpResponseRedirect({ url, statusCode }, pageContextInit) {
@@ -87,7 +95,7 @@ function createHttpResponseRedirect({ url, statusCode }, pageContextInit) {
     assert(statusCode);
     assert(300 <= statusCode && statusCode <= 399);
     const headers = [['Location', url]];
-    return createHttpResponse(statusCode, 'text/html;charset=utf-8', headers, 
+    return createHttpResponse(statusCode, contentTypeHtml, headers, 
     // For bots / programmatic crawlig: show what's going on.
     // For users: showing a blank page is probably better than a flickering text.
     `<p style="display: none">Redirecting to ${escapeHtml(url)}</p><script>console.log('This HTML was generated by Vike.')</script>`);

package/dist/server/runtime/renderPageServer/createPageContextServerSide.d.ts

@@ -1,9 +1,11 @@
 export { createPageContextServerSide };
 export { createPageContextServerSideWithoutGlobalContext };
-export type { PageContextCreated };
+export type { PageContextCreatedServer };
+export type { PageContextCreatedServerMinimum };
 import type { GlobalContextServerInternal } from '../globalContext.js';
 import type { PageContextInit } from '../renderPageServer.js';
-type PageContextCreated = Awaited<ReturnType<typeof createPageContextServerSide>>;
+type PageContextCreatedServerMinimum = ReturnType<typeof createPageContextServerSideWithoutGlobalContext>;
+type PageContextCreatedServer = Awaited<ReturnType<typeof createPageContextServerSide>>;
 declare function createPageContextServerSide(pageContextInit: PageContextInit, globalContext: GlobalContextServerInternal, args: {
     requestId: number;
 } & ({
@@ -146,6 +148,7 @@ declare function createPageContextServerSide(pageContextInit: PageContextInit, g
 } & {
     headers: Record<string, string> | null;
 };
+/** Use this as last resort — prefer passing richer `pageContext` objects to the runtime logger */
 declare function createPageContextServerSideWithoutGlobalContext(pageContextInit: PageContextInit, requestId: number): {
     _isOriginalObject: true;
     isPageContext: true;

package/dist/server/runtime/renderPageServer/createPageContextServerSide.js

@@ -41,6 +41,7 @@ function createPageContextServerSide(pageContextInit, globalContext, args) {
     updateType(pageContextCreated, pageContextAugmented);
     return pageContextCreated;
 }
+/** Use this as last resort — prefer passing richer `pageContext` objects to the runtime logger */
 function createPageContextServerSideWithoutGlobalContext(pageContextInit, requestId) {
     const pageContext = createPageContext(pageContextInit, false, requestId);
     return pageContext;

package/dist/server/runtime/renderPageServer/execHookOnError.d.ts

@@ -1,3 +1,3 @@
 export { execHookOnError };
-import type { PageContext_logRuntime } from '../loggerRuntime.js';
-declare function execHookOnError(err: unknown, pageContext: PageContext_logRuntime): void;
+import type { PageContextCreatedServerMinimum } from './createPageContextServerSide.js';
+declare function execHookOnError(err: unknown, pageContext: PageContextCreatedServerMinimum | null): void;

package/dist/server/runtime/renderPageServer/handleErrorWithoutErrorPage.d.ts

@@ -1,12 +1,12 @@
 export { handleErrorWithoutErrorPage };
 import type { GlobalContextServerInternal } from '../globalContext.js';
-import type { PageContextCreated } from './createPageContextServerSide.js';
-declare function handleErrorWithoutErrorPage<PageContext extends PageContextCreated & {
+import type { PageContextCreatedServer } from './createPageContextServerSide.js';
+declare function handleErrorWithoutErrorPage<PageContext extends PageContextCreatedServer & {
     errorWhileRendering: null | Error;
     is404: null | boolean;
     pageId: null;
     _globalContext: GlobalContextServerInternal;
     urlOriginal: string;
-}>(pageContext: PageContext): Promise<PageContext & {
+}>(pageContext: PageContext): PageContext & {
     httpResponse: import("./createHttpResponse.js").HttpResponse;
-}>;
+};

package/dist/server/runtime/renderPageServer/handleErrorWithoutErrorPage.js

@@ -1,10 +1,9 @@
 export { handleErrorWithoutErrorPage };
-import { stringify } from '@brillout/json-serializer/stringify';
 import { assert, assertWarning, objectAssign } from '../../utils.js';
-import { createHttpResponsePage, createHttpResponseErrorFallback } from './createHttpResponse.js';
+import { createHttpResponseErrorFallback, createHttpResponseErrorFallbackJson } from './createHttpResponse.js';
 import pc from '@brillout/picocolors';
 // When the user hasn't defined _error.page.js
-async function handleErrorWithoutErrorPage(pageContext) {
+function handleErrorWithoutErrorPage(pageContext) {
     assert(pageContext.pageId === null);
     assert(pageContext.errorWhileRendering || pageContext.is404);
     {
@@ -19,7 +18,7 @@ async function handleErrorWithoutErrorPage(pageContext) {
     else {
         const __getPageAssets = async () => [];
         objectAssign(pageContext, { __getPageAssets });
-        const httpResponse = await createHttpResponsePage(stringify({ serverSideError: true }), null, pageContext);
+        const httpResponse = createHttpResponseErrorFallbackJson();
         objectAssign(pageContext, { httpResponse });
         return pageContext;
     }

package/dist/server/runtime/renderPageServer/html/serializeContext.d.ts

@@ -6,10 +6,10 @@ export type { PassToClient };
 export type { PassToClientPublic };
 import type { UrlRedirect } from '../../../../shared-server-client/route/abort.js';
 import type { GlobalContextServerInternal } from '../../globalContext.js';
-import type { PageContextCreated } from '../createPageContextServerSide.js';
+import type { PageContextCreatedServer } from '../createPageContextServerSide.js';
 import type { PageContextBegin } from '../../renderPageServer.js';
 import type { PageContextCspNonce } from '../csp.js';
-type PageContextSerialization = PageContextCreated & {
+type PageContextSerialization = PageContextCreatedServer & {
     pageId: string;
     routeParams: Record<string, string>;
     _passToClient: PassToClient;

package/dist/server/runtime/renderPageServer/loadPageConfigsLazyServerSide.d.ts

@@ -8,8 +8,8 @@ import { type PageAsset } from './getPageAssets.js';
 import type { PageConfigRuntime } from '../../../types/PageConfig.js';
 import type { PassToClient } from './html/serializeContext.js';
 import type { PageContextAfterRoute } from '../../../shared-server-client/route/index.js';
-import type { PageContextCreated } from './createPageContextServerSide.js';
-type PageContext_loadPageConfigsLazyServerSide = PageContextCreated & PageContextAfterRoute & {
+import type { PageContextCreatedServer } from './createPageContextServerSide.js';
+type PageContext_loadPageConfigsLazyServerSide = PageContextCreatedServer & PageContextAfterRoute & {
     is404: boolean | null;
     pageId: string;
 };

package/dist/server/runtime/renderPageServer/log404/index.d.ts

@@ -2,8 +2,8 @@ export { log404 };
 export { getRoutesInfo };
 import type { PageRoutes } from '../../../../shared-server-client/route/index.js';
 import type { GlobalContextServerInternal } from '../../globalContext.js';
-import type { PageContextCreated } from '../createPageContextServerSide.js';
-declare function log404(pageContext: PageContextCreated & {
+import type { PageContextCreatedServer } from '../createPageContextServerSide.js';
+declare function log404(pageContext: PageContextCreatedServer & {
     urlPathname: string;
     errorWhileRendering: null | Error;
     _globalContext: GlobalContextServerInternal;

package/dist/server/runtime/renderPageServer/renderPageServerAfterRoute.d.ts

@@ -5,7 +5,7 @@ export type { PageContextAfterRender };
 import { type PageContextUrlInternal } from '../../../shared-server-client/getPageContextUrlComputed.js';
 import { HttpResponse } from './createHttpResponse.js';
 import { type PageContext_loadPageConfigsLazyServerSide, type PageConfigsLazy } from './loadPageConfigsLazyServerSide.js';
-import type { PageContextCreated } from './createPageContextServerSide.js';
+import type { PageContextCreatedServer } from './createPageContextServerSide.js';
 import type { PageContextBegin } from '../renderPageServer.js';
 type PageContextAfterRender = {
     httpResponse: HttpResponse;
@@ -18,7 +18,7 @@ declare function renderPageServerAfterRoute<PageContext extends {
     routeParams: Record<string, string>;
     errorWhileRendering: null | Error;
     _requestId: number;
-} & PageContextCreated & PageContextBegin & PageContextUrlInternal & PageContext_loadPageConfigsLazyServerSide>(pageContext: PageContext): Promise<PageContext & PageContextAfterRender>;
+} & PageContextCreatedServer & PageContextBegin & PageContextUrlInternal & PageContext_loadPageConfigsLazyServerSide>(pageContext: PageContext): Promise<PageContext & PageContextAfterRender>;
 declare function prerenderPage(pageContext: Parameters<typeof prerenderPageEntry>[0]): Promise<{
     documentHtml: string;
     pageContextSerialized: null;
@@ -348,7 +348,7 @@ declare function prerenderPage(pageContext: Parameters<typeof prerenderPageEntry
         pageContextsAborted: never[];
     };
 }>;
-declare function prerenderPageEntry(pageContext: PageContextCreated & PageConfigsLazy & {
+declare function prerenderPageEntry(pageContext: PageContextCreatedServer & PageConfigsLazy & {
     routeParams: Record<string, string>;
     pageId: string;
     _requestId: number;

package/dist/server/runtime/renderPageServer/renderPageServerAfterRoute.js

@@ -5,7 +5,7 @@ import { getErrorPageId } from '../../../shared-server-client/error-page.js';
 import { getHtmlString } from './html/renderHtml.js';
 import { assert, assertUsage, updateType, hasProp, objectAssign, isSameErrorMessage } from '../../utils.js';
 import { getPageContextClientSerialized } from './html/serializeContext.js';
-import { createHttpResponsePage, createHttpResponsePageContextJson } from './createHttpResponse.js';
+import { createHttpResponsePage, createHttpResponsePageJson } from './createHttpResponse.js';
 import { loadPageConfigsLazyServerSide, } from './loadPageConfigsLazyServerSide.js';
 import { execHookOnRenderHtml } from './execHookOnRenderHtml.js';
 import { execHookDataAndOnBeforeRender } from './execHookDataAndOnBeforeRender.js';
@@ -46,7 +46,7 @@ async function renderPageServerAfterRoute(pageContext) {
             objectAssign(pageContext, { [isServerSideError]: true });
         }
         const pageContextSerialized = getPageContextClientSerialized(pageContext, false);
-        const httpResponse = await createHttpResponsePageContextJson(pageContextSerialized);
+        const httpResponse = await createHttpResponsePageJson(pageContextSerialized);
         objectAssign(pageContext, { httpResponse });
         return pageContext;
     }

package/dist/server/runtime/renderPageServer.js

@@ -6,7 +6,7 @@ import { assert, hasProp, objectAssign, isUrl, parseUrl, onSetupRuntime, assertW
 import { getPageContextAddendumAbort, isAbortError, logAbort, addNewPageContextAborted, } from '../../shared-server-client/route/abort.js';
 import { getGlobalContextServerInternal, initGlobalContext_renderPage, } from './globalContext.js';
 import { handlePageContextRequestUrl } from './renderPageServer/handlePageContextRequestUrl.js';
-import { createHttpResponse404, createHttpResponseRedirect, createHttpResponsePageContextJson, createHttpResponseErrorFallback, createHttpResponseErrorFallback_noGlobalContext, createHttpResponseBaseIsMissing, } from './renderPageServer/createHttpResponse.js';
+import { createHttpResponse404, createHttpResponseRedirect, createHttpResponsePageJson, createHttpResponseErrorFallback, createHttpResponseErrorFallback_noGlobalContext, createHttpResponseBaseIsMissing, } from './renderPageServer/createHttpResponse.js';
 import { logRuntimeError, logRuntimeInfo } from './loggerRuntime.js';
 import { assertArguments } from './renderPageServer/assertArguments.js';
 import { log404 } from './renderPageServer/log404/index.js';
@@ -40,7 +40,7 @@ async function renderPageServer(pageContextInit) {
     const pageContextFinish = !asyncLocalStorage ? await render() : await asyncLocalStorage.run(asyncStore, render);
     logHttpResponse(urlOriginalPretty, pageContextFinish);
     checkType(pageContextFinish);
-    assert(pageContextFinish.httpResponse);
+    assertPageContextFinish(pageContextFinish);
     return pageContextFinish;
 }
 async function renderPageServerEntryOnce(pageContextInit, requestId, asyncStore) {
@@ -63,8 +63,8 @@ async function renderPageServerEntryOnce(pageContextInit, requestId, asyncStore)
         //   ```
         // - initGlobalContext_renderPage() depends on +onCreateGlobalContext hooks
         assert(!isAbortError(err));
-        const pageContext_logRuntime = getPageContext_logRuntimeEarly(pageContextInit, requestId);
-        logRuntimeError(err, pageContext_logRuntime);
+        const pageContext = createPageContextServerSideWithoutGlobalContext(pageContextInit, requestId);
+        logRuntimeError(err, pageContext);
         const pageContextHttpErrorFallback = getPageContextHttpErrorFallback_noGlobalContext(err, pageContextInit, requestId);
         return pageContextHttpErrorFallback;
     }
@@ -131,7 +131,7 @@ async function renderPageServerEntryRecursive(pageContextBegin, globalContext, r
         const errorPageId = getErrorPageId(pageContextNominalPageBegin._globalContext._pageFilesAll, pageContextNominalPageBegin._globalContext._pageConfigs);
         if (!errorPageId) {
             assert(hasProp(pageContextNominalPageBegin, 'pageId', 'null')); // Help TS
-            return await handleErrorWithoutErrorPage(pageContextNominalPageBegin);
+            return handleErrorWithoutErrorPage(pageContextNominalPageBegin);
         }
         objectAssign(pageContextNominalPageBegin, { pageId: errorPageId });
     }
@@ -182,7 +182,7 @@ async function renderPageServerEntryRecursive_onError(err, pageContextBegin, pag
         const errorPageId = getErrorPageId(globalContext._pageFilesAll, globalContext._pageConfigs);
         if (!errorPageId) {
             objectAssign(pageContextErrorPageInit, { pageId: null });
-            return await handleErrorWithoutErrorPage(pageContextErrorPageInit);
+            return handleErrorWithoutErrorPage(pageContextErrorPageInit);
         }
         objectAssign(pageContextErrorPageInit, { pageId: errorPageId });
     }
@@ -216,8 +216,8 @@ async function renderPageServerEntryRecursive_onError(err, pageContextBegin, pag
     return pageContextErrorPage;
 }
 function logHttpRequest(urlOriginal, pageContextInit, requestId) {
-    const pageContext_logRuntime = getPageContext_logRuntimeEarly(pageContextInit, requestId);
-    logRuntimeInfo?.(getRequestInfoMessage(urlOriginal), pageContext_logRuntime, 'info');
+    const pageContext = createPageContextServerSideWithoutGlobalContext(pageContextInit, requestId);
+    logRuntimeInfo?.(getRequestInfoMessage(urlOriginal), pageContext, 'info');
 }
 /* Alternative icons:
 const arrowRight = pc.dim('»')
@@ -430,7 +430,7 @@ pageContextNominalPageBegin, requestId, pageContextErrorPageInit, globalContext)
         else {
             pageContextSerialized = getPageContextClientSerializedAbort(pageContextAbort, false);
         }
-        const httpResponse = await createHttpResponsePageContextJson(pageContextSerialized);
+        const httpResponse = await createHttpResponsePageJson(pageContextSerialized);
         objectAssign(pageContext, { httpResponse });
         return { pageContextReturn: pageContext };
     }
@@ -486,19 +486,11 @@ function getPageContextSkipRequest(pageContextInit, requestId) {
     return pageContext;
 }
 function getPageContextInvalidVikeConfig(err, pageContextInit, requestId) {
-    const pageContext_logRuntime = getPageContext_logRuntimeEarly(pageContextInit, requestId);
-    logRuntimeInfo?.(pc.bold(pc.red('Error loading Vike config — see error above')), pageContext_logRuntime, 'error');
+    const pageContext = createPageContextServerSideWithoutGlobalContext(pageContextInit, requestId);
+    logRuntimeInfo?.(pc.bold(pc.red('Error loading Vike config — see error above')), pageContext, 'error');
     const pageContextHttpErrorFallback = getPageContextHttpErrorFallback_noGlobalContext(err, pageContextInit, requestId);
     return pageContextHttpErrorFallback;
 }
-/** Use this as last resort — prefer passing richer `pageContext` objects to the runtime logger */
-function getPageContext_logRuntimeEarly(pageContextInit, requestId) {
-    const pageContext_logRuntime = {
-        ...pageContextInit,
-        _requestId: requestId,
-    };
-    return pageContext_logRuntime;
-}
 function fork(pageContext) {
     const pageContextNew = forkPageContext(pageContext);
     if (pageContext._asyncStore)
@@ -506,3 +498,11 @@ function fork(pageContext) {
     assert(pageContextNew._asyncStore === pageContext._asyncStore);
     return pageContextNew;
 }
+function assertPageContextFinish(pageContextFinish) {
+    assert(pageContextFinish.httpResponse);
+    if (pageContextFinish.isClientSideNavigation) {
+        const headers = new Headers(pageContextFinish.httpResponse.headers);
+        const contentType = headers.get('Content-Type');
+        assert(contentType?.toLowerCase() === 'application/json');
+    }
+}

package/dist/shared-server-client/hooks/execHook.d.ts

@@ -18,7 +18,11 @@ import type { PageContextForPublicUsageServer } from '../../server/runtime/rende
 import type { PageContextForPublicUsageClientShared } from '../../client/shared/preparePageContextForPublicUsageClientShared.js';
 import { type PageContextPrepareMinimum } from '../preparePageContextForPublicUsage.js';
 import type { GlobalContextPrepareMinimum } from '../prepareGlobalContextForPublicUsage.js';
-type PageContextExecHook = PageContextConfig & PageContextForPublicUsage;
+import type { PageContextCreatedClient } from '../../client/runtime-client-routing/createPageContextClientSide.js';
+import type { PageContextCreatedServer } from '../../server/runtime/renderPageServer/createPageContextServerSide.js';
+import type { PageContextCreatedClient_ServerRouting } from '../../client/runtime-server-routing/createPageContextClientSide.js';
+type PageContextExecHook = PageContextCreated & PageContextConfig & PageContextForPublicUsage;
+type PageContextCreated = PageContextCreatedServer | PageContextCreatedClient | PageContextCreatedClient_ServerRouting;
 type PageContextForPublicUsage = PageContextForPublicUsageServer | PageContextForPublicUsageClientShared;
 type HookWithResult = Hook & {
     hookReturn: unknown;

package/dist/utils/PROJECT_VERSION.d.ts

@@ -1 +1 @@
-export declare const PROJECT_VERSION: "0.4.249-commit-b3b9c55";
+export declare const PROJECT_VERSION: "0.4.250-commit-193dea3";

package/dist/utils/PROJECT_VERSION.js

@@ -1,2 +1,2 @@
 // Automatically updated by @brillout/release-me
-export const PROJECT_VERSION = '0.4.249-commit-b3b9c55';
+export const PROJECT_VERSION = '0.4.250-commit-193dea3';

package/dist/utils/assert.d.ts

@@ -6,9 +6,9 @@ export { getProjectError };
 export { isVikeBug };
 export { setAssertOnBeforeLog };
 export { setAssertOnBeforeErr };
-export { setAlwaysShowStackTrace };
-export { setAssertAddTagsDev };
-import type { AddTagsDev } from '../node/vite/shared/loggerDev.js';
+export { setAssertAlwaysShowStackTrace };
+export { setAssertAddAssertTagsDev };
+import type { AddAssertTagsDev } from '../node/vite/shared/loggerDev.js';
 declare function assert(condition: unknown, debugInfo?: unknown): asserts condition;
 declare function assertUsage(condition: unknown, errMsg: string, { showStackTrace, exitOnError }?: {
     showStackTrace?: true;
@@ -24,6 +24,6 @@ declare function assertInfo(condition: unknown, msg: string, { onlyOnce }: {
 }): void;
 declare function setAssertOnBeforeLog(onBeforeAssertLog: () => void): void;
 declare function setAssertOnBeforeErr(onBeforeAssertErr: (err: unknown) => void): void;
-declare function setAssertAddTagsDev(addTagsDev: AddTagsDev): void;
+declare function setAssertAddAssertTagsDev(addAssertTagsDev: AddAssertTagsDev): void;
 declare function isVikeBug(err: unknown): boolean;
-declare function setAlwaysShowStackTrace(): void;
+declare function setAssertAlwaysShowStackTrace(): void;