vike 0.4.250 → 0.4.251-commit-9c5fb90

package/dist/server/runtime/renderPageServer.js

@@ -1,12 +1,24 @@
+import '../assertEnvServer.js';
 export { renderPageServer };
+export { getRequestTag };
 import { renderPageServerAfterRoute } from './renderPageServer/renderPageServerAfterRoute.js';
-import { createPageContextServerSide, createPageContextServerSideWithoutGlobalContext, } from './renderPageServer/createPageContextServerSide.js';
+import { createPageContextServer, createPageContextServerWithoutGlobalContext, } from './renderPageServer/createPageContextServer.js';
 import { route } from '../../shared-server-client/route/index.js';
-import { assert, hasProp, objectAssign, isUrl, parseUrl, onSetupRuntime, assertWarning, getGlobalObject, checkType, assertUsage, normalizeUrlPathname, removeBaseServer, modifyUrlPathname, prependBase, removeUrlOrigin, setUrlOrigin, isUri, getUrlPretty, updateType, catchInfiniteLoop, isSameErrorMessage, } from '../utils.js';
+import { assert, assertWarning, assertUsage } from '../../utils/assert.js';
+import { onSetupRuntime } from '../../utils/assertSetup.js';
+import { catchInfiniteLoop } from '../../utils/catchInfiniteLoop.js';
+import { checkType } from '../../utils/checkType.js';
+import { getGlobalObject } from '../../utils/getGlobalObject.js';
+import { hasProp } from '../../utils/hasProp.js';
+import { isSameErrorMessage } from '../../utils/isSameErrorMessage.js';
+import { objectAssign } from '../../utils/objectAssign.js';
+import { normalizeUrlPathname, removeBaseServer, modifyUrlPathname, prependBase, removeUrlOrigin, setUrlOrigin, getUrlPretty, } from '../../utils/parseUrl-extras.js';
+import { isUrl, parseUrl, isUri } from '../../utils/parseUrl.js';
+import { updateType } from '../../utils/updateType.js';
 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 +52,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 +75,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 = createPageContextServerWithoutGlobalContext(pageContextInit, requestId);
+        logRuntimeError(err, pageContext);
         const pageContextHttpErrorFallback = getPageContextHttpErrorFallback_noGlobalContext(err, pageContextInit, requestId);
         return pageContextHttpErrorFallback;
     }
@@ -101,7 +113,7 @@ async function renderPageServerEntryOnce(pageContextInit, requestId, asyncStore)
     return await renderPageServerEntryRecursive(pageContextBegin, globalContext, requestId);
 }
 async function renderPageServerEntryRecursive(pageContextBegin, globalContext, requestId) {
-    catchInfiniteLoop('renderPageServerEntryRecursive()');
+    catchInfiniteLoop(`[${getRequestTag(requestId)}] renderPageServerEntryRecursive()`);
     const pageContextNominalPageBegin = fork(pageContextBegin);
     const pageContextAddendumAbort = getPageContextAddendumAbort(pageContextBegin.pageContextsAborted);
     objectAssign(pageContextNominalPageBegin, pageContextAddendumAbort);
@@ -131,7 +143,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 +194,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 +228,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 = createPageContextServerWithoutGlobalContext(pageContextInit, requestId);
+    logRuntimeInfo?.(getRequestInfoMessage(urlOriginal), pageContext, 'info');
 }
 /* Alternative icons:
 const arrowRight = pc.dim('»')
@@ -288,7 +300,7 @@ function getPageContextHttpErrorFallback(err, pageContextBegin) {
     return pageContextHttpErrorFallback;
 }
 function getPageContextHttpErrorFallback_noGlobalContext(err, pageContextInit, requestId) {
-    const pageContextHttpErrorFallback = createPageContextServerSideWithoutGlobalContext(pageContextInit, requestId);
+    const pageContextHttpErrorFallback = createPageContextServerWithoutGlobalContext(pageContextInit, requestId);
     const httpResponse = createHttpResponseErrorFallback_noGlobalContext();
     objectAssign(pageContextHttpErrorFallback, {
         httpResponse,
@@ -298,7 +310,7 @@ function getPageContextHttpErrorFallback_noGlobalContext(err, pageContextInit, r
 }
 function getPageContextBegin(pageContextInit, globalContext, requestId, asyncStore) {
     const { isClientSideNavigation, _urlHandler, _isPageContextJsonRequest } = handlePageContextUrl(pageContextInit.urlOriginal);
-    const pageContextBegin = createPageContextServerSide(pageContextInit, globalContext, {
+    const pageContextBegin = createPageContextServer(pageContextInit, globalContext, {
         isPrerendering: false,
         urlHandler: _urlHandler,
         isClientSideNavigation,
@@ -430,7 +442,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 };
     }
@@ -479,26 +491,18 @@ function getPageContextSkipRequest(pageContextInit, requestId) {
     }
     if (!errMsg404)
         return;
-    const pageContext = createPageContextServerSideWithoutGlobalContext(pageContextInit, requestId);
+    const pageContext = createPageContextServerWithoutGlobalContext(pageContextInit, requestId);
     const httpResponse = createHttpResponse404(errMsg404);
     objectAssign(pageContext, { httpResponse });
     checkType(pageContext);
     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 = createPageContextServerWithoutGlobalContext(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 +510,14 @@ 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');
+    }
+}
+function getRequestTag(requestId) {
+    return `request-${requestId}`;
+}

package/dist/server/runtime/universal-middleware.d.ts

@@ -1 +1,3 @@
-export default function universalVikeHandler(request: Request, context: Record<string, unknown>, runtime: Record<string, unknown>): Promise<Response>;
+import '../assertEnvServer.js';
+export default universalVikeHandler;
+declare function universalVikeHandler(request: Request, context: Record<string, unknown>, runtime: Record<string, unknown>): Promise<Response>;

package/dist/server/runtime/universal-middleware.js

@@ -1,5 +1,7 @@
+import '../assertEnvServer.js';
+export default universalVikeHandler;
 import { renderPageServer } from './renderPageServer.js';
-export default async function universalVikeHandler(request, context, runtime) {
+async function universalVikeHandler(request, context, runtime) {
     const pageContextInit = {
         ...context,
         ...runtime,

package/dist/shared-server-client/addIs404ToPageProps.js

@@ -1,5 +1,6 @@
 export { addIs404ToPageProps };
-import { assertWarning, isObject } from './utils.js';
+import { assertWarning } from '../utils/assert.js';
+import { isObject } from '../utils/isObject.js';
 function addIs404ToPageProps(pageContext) {
     addIs404(pageContext);
 }

package/dist/shared-server-client/assertHookReturnedObject.js

@@ -1,5 +1,6 @@
 export { assertHookReturnedObject };
-import { assert, assertUsage, stringifyStringArray } from './utils.js';
+import { assert, assertUsage } from '../utils/assert.js';
+import { stringifyStringArray } from '../utils/stringifyStringArray.js';
 function assertHookReturnedObject(obj, keysExpected, errPrefix) {
     assert(!errPrefix.endsWith(' '));
     const keysUnknown = [];

package/dist/shared-server-client/assertOnBeforeRenderHookReturn.js

@@ -1,5 +1,6 @@
 export { assertOnBeforeRenderHookReturn };
-import { assertUsage, isPlainObject } from './utils.js';
+import { assertUsage } from '../utils/assert.js';
+import { isPlainObject } from '../utils/isPlainObject.js';
 import { assertPageContextProvidedByUser } from './assertPageContextProvidedByUser.js';
 import { assertHookReturnedObject } from './assertHookReturnedObject.js';
 import pc from '@brillout/picocolors';

package/dist/shared-server-client/assertPageContextProvidedByUser.js

@@ -1,5 +1,6 @@
 export { assertPageContextProvidedByUser };
-import { assert, assertUsage, assertWarning, isObject } from './utils.js';
+import { assert, assertUsage, assertWarning } from '../utils/assert.js';
+import { isObject } from '../utils/isObject.js';
 import pc from '@brillout/picocolors';
 function assertPageContextProvidedByUser(pageContextProvidedByUser, { hookName, hookFilePath, }) {
     if (pageContextProvidedByUser === undefined || pageContextProvidedByUser === null)

package/dist/shared-server-client/assertVirtualFileExports.js

@@ -1,5 +1,5 @@
 export { assertVirtualFileExports };
-import { assert } from './utils.js';
+import { assert } from '../utils/assert.js';
 function assertVirtualFileExports(moduleExports, test, moduleId) {
     if (!moduleExports || !test(moduleExports)) {
         /* https://github.com/vikejs/vike/issues/2903#issuecomment-3642285811

package/dist/shared-server-client/createGlobalContextShared.d.ts

@@ -5,14 +5,14 @@ export type { GlobalContextBasePublic };
 export type GlobalContextInternal = GlobalContextServerInternal | GlobalContextClientInternal;
 import type { PageFile } from './getPageFiles.js';
 import type { PageConfigRuntime } from '../types/PageConfig.js';
-import { type GlobalContextPrepareMinimum } from './prepareGlobalContextForPublicUsage.js';
+import { type GlobalContextPublicMinimum } from './getGlobalContextPublicShared.js';
 import type { GlobalContextServerInternal } from '../server/runtime/globalContext.js';
 import type { GlobalContextClientInternal } from '../client/runtime-client-routing/getGlobalContextClientInternal.js';
 import { type Hook } from './hooks/getHook.js';
 declare const getGlobalContextSyncErrMsg = "The global context isn't set yet, call getGlobalContextSync() later or use getGlobalContext() instead.";
 declare function createGlobalContextShared<GlobalContextAdded extends {}, GlobalContextAddedAsync extends {}>(virtualFileExportsGlobalEntry: unknown, globalObject: {
     globalContext?: {};
-    onCreateGlobalContextHooks?: Hook<GlobalContextPrepareMinimum>[];
+    onCreateGlobalContextHooks?: Hook<GlobalContextPublicMinimum>[];
     previousCreateGlobalContextPromise?: Promise<void>;
 }, addGlobalContext?: (globalContext: GlobalContextBase) => GlobalContextAdded, addGlobalContextTmp?: (globalContext: GlobalContextBase) => Promise<GlobalContextAdded>, addGlobalContextAsync?: (globalContext: GlobalContextBase) => Promise<GlobalContextAddedAsync>): Promise<{
     _globalConfigPublic: {

package/dist/shared-server-client/createGlobalContextShared.js

@@ -1,11 +1,16 @@
 export { createGlobalContextShared };
 export { getGlobalContextSyncErrMsg };
-import { assert, changeEnumerable, genPromise, objectAssign, objectReplace, unique } from './utils.js';
+import { assert } from '../utils/assert.js';
+import { objectReplace } from '../utils/objectReplace.js';
+import { changeEnumerable } from '../utils/changeEnumerable.js';
+import { genPromise } from '../utils/genPromise.js';
+import { objectAssign } from '../utils/objectAssign.js';
+import { unique } from '../utils/unique.js';
 import { parseVirtualFileExportsGlobalEntry } from './getPageFiles/parseVirtualFileExportsGlobalEntry.js';
 import { resolveGlobalContextConfig } from './page-configs/resolveVikeConfigPublic.js';
 import { execHookGlobal } from './hooks/execHook.js';
-import { prepareGlobalContextForPublicUsage, } from './prepareGlobalContextForPublicUsage.js';
-import { getHookFromPageConfigGlobalCumulative } from './hooks/getHook.js';
+import { getGlobalContextPublicShared } from './getGlobalContextPublicShared.js';
+import { getHooksFromPageConfigGlobalCumulative } from './hooks/getHook.js';
 const getGlobalContextSyncErrMsg = "The global context isn't set yet, call getGlobalContextSync() later or use getGlobalContext() instead.";
 // TO-DO/eventually use flat globalContext — like flat pageContext
 async function createGlobalContextShared(virtualFileExportsGlobalEntry, globalObject, addGlobalContext, 
@@ -50,11 +55,11 @@ addGlobalContextTmp, addGlobalContextAsync) {
             const globalContextAddedAsync = await addGlobalContextAsync?.(globalContext);
             objectAssign(globalContext, globalContextAddedAsync);
         }
-        const onCreateGlobalContextHooks = getHookFromPageConfigGlobalCumulative(globalContext._pageConfigGlobal, 'onCreateGlobalContext');
+        const onCreateGlobalContextHooks = getHooksFromPageConfigGlobalCumulative(globalContext._pageConfigGlobal, 'onCreateGlobalContext');
         let hooksCalled = false;
         if (!hooksAreEqual(globalObject.onCreateGlobalContextHooks ?? [], onCreateGlobalContextHooks)) {
             globalObject.onCreateGlobalContextHooks = onCreateGlobalContextHooks;
-            await execHookGlobal('onCreateGlobalContext', globalContext._pageConfigGlobal, null, globalContext, prepareGlobalContextForPublicUsage);
+            await execHookGlobal('onCreateGlobalContext', globalContext, getGlobalContextPublicShared);
             hooksCalled = true;
         }
         if (isNewGlobalContext) {

package/dist/shared-server-client/createPageContextShared.d.ts

@@ -1,8 +1,15 @@
 export { createPageContextShared };
 export { createPageContextObject };
+export type { PageContextCreated };
 import type { GlobalConfigPublic } from './page-configs/resolveVikeConfigPublic.js';
-import { type PageContextPrepareMinimum } from './preparePageContextForPublicUsage.js';
-declare function createPageContextShared<T extends PageContextPrepareMinimum>(pageContextCreated: T, globalConfigPublic: GlobalConfigPublic): T & GlobalConfigPublic;
+import type { GlobalContextPublicMinimum } from './getGlobalContextPublicShared.js';
+type PageContextCreated = {
+    _isOriginalObject: true;
+    isPageContext: true;
+    isClientSide: boolean;
+    _globalContext: GlobalContextPublicMinimum;
+};
+declare function createPageContextShared<T extends Record<string, unknown>>(pageContextCreated: T, globalConfigPublic: GlobalConfigPublic): T & GlobalConfigPublic;
 declare function createPageContextObject(): {
     _isOriginalObject: true;
     isPageContext: true;

package/dist/shared-server-client/createPageContextShared.js

@@ -1,6 +1,7 @@
 export { createPageContextShared };
 export { createPageContextObject };
-import { changeEnumerable, objectAssign } from './utils.js';
+import { changeEnumerable } from '../utils/changeEnumerable.js';
+import { objectAssign } from '../utils/objectAssign.js';
 function createPageContextShared(pageContextCreated, globalConfigPublic) {
     objectAssign(pageContextCreated, globalConfigPublic);
     return pageContextCreated;

package/dist/shared-server-client/determinePageIdOld.js

@@ -1,5 +1,6 @@
 export { determinePageIdOld };
-import { slice, assert } from './utils.js';
+import { assert } from '../utils/assert.js';
+import { slice } from '../utils/slice.js';
 // TO-DO/next-major-release: remove
 function determinePageIdOld(filePath) {
     const pageSuffix = '.page.';

package/dist/shared-server-client/error-page.js

@@ -2,7 +2,8 @@ export { getErrorPageId };
 export { isErrorPageId };
 export { isErrorPage };
 // TO-DO/next-major-release: consider loading this file only for Client Routing
-import { assert, assertUsage, unique } from './utils.js';
+import { assert, assertUsage } from '../utils/assert.js';
+import { unique } from '../utils/unique.js';
 function getErrorPageId(pageFilesAll, pageConfigs) {
     if (pageConfigs.length > 0) {
         const errorPageConfigs = pageConfigs.filter((p) => p.isErrorPage);

package/dist/shared-server-client/forkPageContext.js

@@ -1,5 +1,5 @@
 export { forkPageContext };
-import { objectAssign } from './utils.js';
+import { objectAssign } from '../utils/objectAssign.js';
 // Create pageContext forks to avoid leaks: upon an error (bug or abort) a brand new pageContext object is created, in order to avoid previous pageContext modifications that are now obsolete to leak to the new pageContext object.
 function forkPageContext(pageContext) {
     const pageContextNew = {};

package/dist/shared-server-client/getGlobalContextPublicShared.d.ts

@@ -0,0 +1,14 @@
+export { getGlobalContextPublicShared };
+export type { GlobalContextPublicMinimum };
+import type { PageConfigGlobalRuntime } from '../types/PageConfig.js';
+type GlobalContextPublicMinimum = {
+    _isOriginalObject: true;
+    isGlobalContext: true;
+    _pageConfigGlobal: PageConfigGlobalRuntime;
+};
+declare function getGlobalContextPublicShared<GlobalContext extends GlobalContextPublicMinimum>(globalContext: GlobalContext): GlobalContext & {
+    _isProxyObject: true;
+    _originalObject: GlobalContext;
+} & {
+    dangerouslyUseInternals: import("./getPublicProxy.js").DangerouslyUseInternals<GlobalContext>;
+};

package/dist/shared-server-client/getGlobalContextPublicShared.js

@@ -0,0 +1,8 @@
+export { getGlobalContextPublicShared };
+import { getPublicProxy } from './getPublicProxy.js';
+import { assert } from '../utils/assert.js';
+function getGlobalContextPublicShared(globalContext) {
+    assert(globalContext._isOriginalObject); // ensure we preserve the original object reference
+    const globalContextPublic = getPublicProxy(globalContext, 'globalContext');
+    return globalContextPublic;
+}

package/dist/shared-server-client/getPageContextPublicShared.d.ts

@@ -0,0 +1,12 @@
+export { getPageContextPublicShared };
+export { assertPropertyGetters };
+export type { PageContextPublicMinimum };
+import type { PageContextCreated } from './createPageContextShared.js';
+type PageContextPublicMinimum = PageContextCreated;
+declare function getPageContextPublicShared<PageContext extends PageContextPublicMinimum>(pageContext: PageContext): PageContext & {
+    _isProxyObject: true;
+    _originalObject: PageContext;
+} & {
+    dangerouslyUseInternals: import("./getPublicProxy.js").DangerouslyUseInternals<PageContext>;
+};
+declare function assertPropertyGetters(pageContext: Record<string, unknown>): void;

package/dist/shared-server-client/{preparePageContextForPublicUsage.js → getPageContextPublicShared.js}

@@ -1,10 +1,12 @@
-export { preparePageContextForPublicUsage };
+export { getPageContextPublicShared };
 export { assertPropertyGetters };
-import { assert, assertWarning, compareString, isPropertyGetter } from './utils.js';
+import { assert, assertWarning } from '../utils/assert.js';
+import { compareString } from '../utils/compareString.js';
+import { isPropertyGetter } from '../utils/isPropertyGetter.js';
 import { addIs404ToPageProps } from './addIs404ToPageProps.js';
-import { prepareGlobalContextForPublicUsage, } from './prepareGlobalContextForPublicUsage.js';
-import { getProxyForPublicUsage } from './getProxyForPublicUsage.js';
-function preparePageContextForPublicUsage(pageContext) {
+import { getGlobalContextPublicShared } from './getGlobalContextPublicShared.js';
+import { getPublicProxy } from './getPublicProxy.js';
+function getPageContextPublicShared(pageContext) {
     assert(!pageContext._isProxyObject);
     assert(!pageContext.globalContext); // pageContext.globalContext should only be available to users — Vike itself should use pageContext._globalContext instead
     assert(pageContext._isOriginalObject); // ensure we preserve the original object reference
@@ -24,8 +26,8 @@ function preparePageContextForPublicUsage(pageContext) {
     }
     // For a more readable `console.log(pageContext)` output
     sortPageContext(pageContext);
-    const globalContextPublic = prepareGlobalContextForPublicUsage(pageContext._globalContext);
-    const pageContextPublic = getProxyForPublicUsage(pageContext, 'pageContext', 
+    const globalContextPublic = getGlobalContextPublicShared(pageContext._globalContext);
+    const pageContextPublic = getPublicProxy(pageContext, 'pageContext', 
     // We must skip it in the client-side because of the reactivity mechanism of UI frameworks like Solid.
     // - TO-DO/soon/proxy: double check whether that's true
     true, (prop) => {

package/dist/shared-server-client/getPageContextUrlComputed.d.ts

@@ -3,8 +3,9 @@ export type { PageContextUrlInternal };
 export type { PageContextUrlClient };
 export type { PageContextUrlServer };
 export type { PageContextUrlSource };
-import { type PageContextPrepareMinimum } from './preparePageContextForPublicUsage.js';
-import { type UrlPublic } from './utils.js';
+import type { UrlPublic } from '../utils/parseUrl.js';
+import type { PageContextCreated } from './createPageContextShared.js';
+import type { PageContextExecHook } from './hooks/execHook.js';
 type PageContextUrlComputed = {
     /** Parsed information about the current URL */
     urlParsed: UrlPublic;
@@ -17,7 +18,7 @@ type PageContextUrl = {
     /** The URL of the HTTP request */
     urlOriginal: string;
 } & PageContextUrlComputed;
-type PageContextUrlInternal = PageContextPrepareMinimum & PageContextUrl & {
+type PageContextUrlInternal = PageContextUrl & PageContextCreated & PageContextExecHook & {
     _urlRewrite?: string;
 };
 type PageContextUrlClient = PageContextUrl;

package/dist/shared-server-client/getPageContextUrlComputed.js

@@ -4,8 +4,11 @@ export { getPageContextUrlComputed };
 // URLs need to be computed, because the user can modify the URL e.g. with onBeforeRoute() for i18n.
 // =====================
 import { objectDefineProperty } from '../utils/objectDefineProperty.js';
-import { assertPropertyGetters } from './preparePageContextForPublicUsage.js';
-import { assert, parseUrl, assertWarning, isBrowser, changeEnumerable } from './utils.js';
+import { assertPropertyGetters } from './getPageContextPublicShared.js';
+import { assert, assertWarning } from '../utils/assert.js';
+import { changeEnumerable } from '../utils/changeEnumerable.js';
+import { isBrowser } from '../utils/isBrowser.js';
+import { parseUrl } from '../utils/parseUrl.js';
 function getPageContextUrlComputed(pageContext) {
     assert(typeof pageContext.urlOriginal === 'string');
     assertPropertyGetters(pageContext);

package/dist/shared-server-client/getPageFiles/analyzePageClientSide/analyzeExports.js

@@ -1,6 +1,6 @@
 export { analyzeExports };
 import { getExportNames } from './getExportNames.js';
-import { assertUsage } from '../../utils.js';
+import { assertUsage } from '../../../utils/assert.js';
 // TO-DO/next-major-release: remove
 function analyzeExports({ pageFilesClientSide, pageFilesServerSide, pageId, }) {
     return { isHtmlOnly: isHtmlOnly(), isClientRouting: isClientRouting() };

package/dist/shared-server-client/getPageFiles/analyzePageClientSide/getExportNames.js

@@ -1,5 +1,5 @@
 export { getExportNames };
-import { assert } from '../../utils.js';
+import { assert } from '../../../utils/assert.js';
 function getExportNames(p) {
     if (p.fileType === '.css') {
         return [];

package/dist/shared-server-client/getPageFiles/analyzePageClientSide.js

@@ -4,7 +4,7 @@ import { analyzeExports } from './analyzePageClientSide/analyzeExports.js';
 import { determineClientEntry } from './analyzePageClientSide/determineClientEntry.js';
 import { getPageFilesClientSide } from './getAllPageIdFiles.js';
 import { getPageFilesServerSide } from './getAllPageIdFiles.js';
-import { assert } from '../utils.js';
+import { assert } from '../../utils/assert.js';
 import { getExportNames } from './analyzePageClientSide/getExportNames.js';
 // TO-DO/next-major-release: remove analyzePageClientSide(), use analyzeClientSide() instead
 function analyzePageClientSide(pageFilesAll, pageId) {

package/dist/shared-server-client/getPageFiles/analyzePageServerSide.js

@@ -1,5 +1,5 @@
 export { analyzePageServerSide };
-import { assert } from '../utils.js';
+import { assert } from '../../utils/assert.js';
 import { getPageFilesServerSide } from './getAllPageIdFiles.js';
 async function analyzePageServerSide(pageFilesAll, pageId) {
     const pageFilesServerSide = getPageFilesServerSide(pageFilesAll, pageId);

package/dist/shared-server-client/getPageFiles/assert_exports_old_design.js

@@ -2,7 +2,7 @@
 export { assertDefaultExports };
 export { assertExportValues };
 export { forbiddenDefaultExports };
-import { assert, assertUsage } from '../utils.js';
+import { assert, assertUsage } from '../../utils/assert.js';
 const enforceTrue = ['clientRouting'];
 function assertExportValues(pageFile) {
     enforceTrue.forEach((exportName) => {

package/dist/shared-server-client/getPageFiles/fileTypes.js

@@ -2,7 +2,7 @@
 export { fileTypes };
 export { isValidFileType };
 export { determineFileType };
-import { assert } from '../utils.js';
+import { assert } from '../../utils/assert.js';
 import { isScriptFile } from '../../utils/isScriptFile.js';
 const fileTypes = [
     '.page',

package/dist/shared-server-client/getPageFiles/getAllPageIdFiles.js

@@ -1,7 +1,8 @@
 // TO-DO/next-major-release: remove this file
 export { getPageFilesClientSide };
 export { getPageFilesServerSide };
-import { assert, assertUsage, isNotNullish } from '../utils.js';
+import { assert, assertUsage } from '../../utils/assert.js';
+import { isNotNullish } from '../../utils/isNullish.js';
 function getPageFilesClientSide(pageFilesAll, pageId) {
     return determine(pageFilesAll, pageId, true);
 }

package/dist/shared-server-client/getPageFiles/getPageFileObject.js

@@ -2,7 +2,8 @@
 export { getPageFileObject };
 import { determinePageIdOld } from '../determinePageIdOld.js';
 import { isErrorPageId } from '../error-page.js';
-import { assert, slice } from '../utils.js';
+import { assert } from '../../utils/assert.js';
+import { slice } from '../../utils/slice.js';
 import { determineFileType } from './fileTypes.js';
 function getPageFileObject(filePath) {
     const isRelevant = (pageId) => pageFile.pageId === pageId ||

package/dist/shared-server-client/getPageFiles/parseVirtualFileExportsGlobalEntry.js

@@ -1,6 +1,11 @@
 export { parseVirtualFileExportsGlobalEntry };
 // TO-DO/next-major-release: remove old design code, and remove all assertions.
-import { assert, hasProp, isCallable, isObject, cast, isArray } from '../utils.js';
+import { assert } from '../../utils/assert.js';
+import { cast } from '../../utils/cast.js';
+import { hasProp } from '../../utils/hasProp.js';
+import { isArray } from '../../utils/isArray.js';
+import { isCallable } from '../../utils/isCallable.js';
+import { isObject } from '../../utils/isObject.js';
 import { assertExportValues } from './assert_exports_old_design.js';
 import { getPageFileObject } from './getPageFileObject.js';
 import { fileTypes } from './fileTypes.js';

package/dist/shared-server-client/getPublicProxy.d.ts

@@ -0,0 +1,12 @@
+export { getPublicProxy };
+export type { DangerouslyUseInternals };
+type ObjProxy<Obj> = Obj & {
+    _isProxyObject: true;
+    _originalObject: Obj;
+};
+declare function getPublicProxy<Obj extends Record<string | symbol, unknown>>(obj: Obj, objName: 'pageContext' | 'globalContext' | 'prerenderContext' | 'vikeConfig', skipOnInternalProp?: boolean, fallback?: (prop: string | symbol) => unknown): ObjProxy<Obj> & {
+    /** https://vike.dev/warning/internals */
+    dangerouslyUseInternals: DangerouslyUseInternals<Obj>;
+};
+/** https://vike.dev/warning/internals */
+type DangerouslyUseInternals<Obj> = ObjProxy<Obj>;

package/dist/shared-server-client/{getProxyForPublicUsage.js → getPublicProxy.js}

@@ -1,4 +1,4 @@
-export { getProxyForPublicUsage };
+export { getPublicProxy };
 // We use a proxy instead of property getters.
 // - The issue with property getters is that they can't be `writable: true` but we do want the user to be able to modify the value of internal properties.
 //   ```console
@@ -7,8 +7,10 @@ export { getProxyForPublicUsage };
 // - Previous implementation using property getters: https://github.com/vikejs/vike/blob/4dbb354b0bcec04e862041fc9183fc4691bb8711/vike/utils/makePublicCopy.ts
 // Show warning when user is accessing internal `_` properties.
 import { NOT_SERIALIZABLE } from './NOT_SERIALIZABLE.js';
-import { assert, assertUsage, assertWarning, getPropAccessNotation, isBrowser } from './utils.js';
-function getProxyForPublicUsage(obj, objName, skipOnInternalProp, fallback) {
+import { assert, assertUsage, assertWarning } from '../utils/assert.js';
+import { getPropAccessNotation } from '../utils/getPropAccessNotation.js';
+import { isBrowser } from '../utils/isBrowser.js';
+function getPublicProxy(obj, objName, skipOnInternalProp, fallback) {
     return new Proxy(obj, {
         get: (_, prop) => getProp(prop, obj, objName, skipOnInternalProp, fallback),
     });
@@ -19,8 +21,8 @@ function getProp(prop, ...args) {
     if (prop === '_isProxyObject')
         return true;
     if (prop === 'dangerouslyUseInternals') {
-        args[2] = true;
-        return getProxyForPublicUsage(...args);
+        args[2] = true; // skipOnInternalProp
+        return getPublicProxy(...args);
     }
     if (!skipOnInternalProp) {
         if (!globalThis.__VIKE__IS_CLIENT)