vike 0.4.228-commit-90cfb1a → 0.4.228-commit-558224a

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

@@ -1,16 +1,22 @@
 export { createPageContextClientSide };
 import { assertUsage, assertWarning, augmentType, objectAssign } from './utils.js';
-import { getPageContextSerializedInHtml } from '../shared/getPageContextSerializedInHtml.js';
+import { getPageContextSerializedInHtml } from '../shared/getJsonSerializedInHtml.js';
 import { loadUserFilesClientSide } from '../shared/loadUserFilesClientSide.js';
 import { getCurrentUrl } from '../shared/getCurrentUrl.js';
-import { getPageConfigsRuntime } from '../../shared/getPageConfigsRuntime.js';
-// @ts-ignore
-import * as virtualFileExports from 'virtual:vike:importUserCode:client:server-routing';
 import { createPageContextShared } from '../../shared/createPageContextShared.js';
-const { pageFilesAll, pageConfigs, pageConfigGlobal } = getPageConfigsRuntime(virtualFileExports);
+import { getGlobalContext } from './globalContext.js';
 const urlFirst = getCurrentUrl({ withoutHash: true });
 async function createPageContextClientSide() {
+    const globalContext = await getGlobalContext();
     const pageContextCreated = {
+        /* Don't spread globalContext for now? Or never spread it as it leads to confusion? The convenience isn't worth the added confusion?
+        ...globalContext, // least precedence
+        */
+        globalContext,
+        _pageFilesAll: globalContext._pageFilesAll,
+        _pageConfigs: globalContext._pageConfigs,
+        _pageConfigGlobal: globalContext._pageConfigGlobal,
+        _allPageIds: globalContext._allPageIds,
         isPrerendering: false,
         isClientSide: true,
         isHydration: true,
@@ -19,8 +25,8 @@ async function createPageContextClientSide() {
         _hasPageContextFromClient: false
     };
     objectAssign(pageContextCreated, getPageContextSerializedInHtml());
-    objectAssign(pageContextCreated, await loadPageUserFiles(pageContextCreated.pageId));
-    const pageContextAugmented = await createPageContextShared(pageContextCreated, pageConfigGlobal);
+    objectAssign(pageContextCreated, await loadPageUserFiles(pageContextCreated.pageId, pageContextCreated));
+    const pageContextAugmented = await createPageContextShared(pageContextCreated, globalContext._pageConfigGlobal);
     augmentType(pageContextCreated, pageContextAugmented);
     assertPristineUrl();
     return pageContextCreated;
@@ -29,15 +35,10 @@ 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 loadPageUserFiles(pageId) {
+async function loadPageUserFiles(pageId, pageContext) {
     const pageContextAddendum = {};
-    objectAssign(pageContextAddendum, {
-        _pageFilesAll: pageFilesAll,
-        _pageConfigs: pageConfigs,
-        _pageConfigGlobal: pageConfigGlobal
-    });
-    objectAssign(pageContextAddendum, await loadUserFilesClientSide(pageId, pageContextAddendum._pageFilesAll, pageContextAddendum._pageConfigs, pageContextAddendum._pageConfigGlobal));
-    pageFilesAll
+    objectAssign(pageContextAddendum, await loadUserFilesClientSide(pageId, pageContext._pageFilesAll, pageContext._pageConfigs, pageContext._pageConfigGlobal));
+    pageContext._pageFilesAll
         .filter((p) => p.fileType !== '.page.server')
         .forEach((p) => {
         assertWarning(!p.fileExports?.onBeforeRender, `export { onBeforeRender } of ${p.filePath} is loaded in the browser but never executed (because you are using Server-side Routing). In order to reduce the size of you browser-side JavaScript, define onBeforeRender() in a .page.server.js file instead, see https://vike.dev/onBeforeRender-isomorphic#server-routing`, { onlyOnce: true });

package/dist/esm/client/server-routing-runtime/globalContext.d.ts

@@ -0,0 +1,13 @@
+export { getGlobalContext };
+export type { GlobalContextClientWithServerRouting };
+import type { GlobalContextSharedPublic } from '../../shared/createGlobalContextShared.js';
+type GlobalContextClientWithServerRouting = GlobalContextSharedPublic & Vike.GlobalContext & {};
+declare const getGlobalContext: () => Promise<{
+    _virtualFileExports: unknown;
+    _pageFilesAll: import("../../shared/getPageFiles.js").PageFile[];
+    _pageConfigs: import("../../__internal/index.js").PageConfig[];
+    _pageConfigGlobal: import("../../shared/page-configs/PageConfig.js").PageConfigGlobalRuntime;
+    _allPageIds: string[];
+    config: import("../../types/index.js").ConfigResolved;
+    pages: import("../../shared/page-configs/getPageConfigUserFriendly.js").PageConfigsUserFriendly;
+} & object>;

package/dist/esm/client/server-routing-runtime/globalContext.js

@@ -0,0 +1,5 @@
+export { getGlobalContext };
+import { createGetGlobalContext } from '../shared/createGetGlobalContext.js';
+// @ts-ignore
+import * as virtualFileExports from 'virtual:vike:importUserCode:client:server-routing';
+const getGlobalContext = createGetGlobalContext(virtualFileExports, false);

package/dist/esm/client/shared/createGetGlobalContext.d.ts

@@ -0,0 +1,11 @@
+export { createGetGlobalContext };
+import { type GlobalContextShared } from '../../shared/createGlobalContextShared.js';
+declare function createGetGlobalContext<GlobalContextAddendum extends object>(virtualFileExports: unknown, isClientRouting: boolean, addGlobalContext?: (globalContext: GlobalContextShared) => Promise<GlobalContextAddendum>): () => Promise<{
+    _virtualFileExports: unknown;
+    _pageFilesAll: import("../../shared/getPageFiles.js").PageFile[];
+    _pageConfigs: import("../../__internal/index.js").PageConfig[];
+    _pageConfigGlobal: import("../../shared/page-configs/PageConfig.js").PageConfigGlobalRuntime;
+    _allPageIds: string[];
+    config: import("../../types/index.js").ConfigResolved;
+    pages: import("../../shared/page-configs/getPageConfigUserFriendly.js").PageConfigsUserFriendly;
+} & Awaited<object & Awaited<GlobalContextAddendum>>>;

package/dist/esm/client/shared/createGetGlobalContext.js

@@ -0,0 +1,29 @@
+export { createGetGlobalContext };
+import { createGlobalContextShared } from '../../shared/createGlobalContextShared.js';
+import { getGlobalContextSerializedInHtml } from './getJsonSerializedInHtml.js';
+import { assert, getGlobalObject, objectAssign } from './utils.js';
+const globalObject = getGlobalObject('createGetGlobalContext.ts', {});
+function createGetGlobalContext(virtualFileExports, isClientRouting, addGlobalContext) {
+    assert(globalObject.isClientRouting === undefined || globalObject.isClientRouting === isClientRouting);
+    globalObject.isClientRouting = isClientRouting;
+    // Eagerly call onCreateGlobalContext() hook
+    getGlobalContext();
+    return getGlobalContext;
+    async function getGlobalContext() {
+        // Cache
+        if (globalObject.globalContext &&
+            // Don't break HMR
+            globalObject.globalContext._virtualFileExports !== virtualFileExports) {
+            return globalObject.globalContext;
+        }
+        // Create
+        const globalContext = await createGlobalContextShared(virtualFileExports, globalObject, async (globalContext) => {
+            const globalContextAddendum = {};
+            objectAssign(globalContextAddendum, getGlobalContextSerializedInHtml());
+            objectAssign(globalContextAddendum, await addGlobalContext?.(globalContext));
+            return globalContextAddendum;
+        });
+        // Return
+        return globalContext;
+    }
+}

package/dist/esm/client/shared/{getPageContextSerializedInHtml.d.ts → getJsonSerializedInHtml.d.ts}

@@ -1,5 +1,7 @@
 export { getPageContextSerializedInHtml };
+export { getGlobalContextSerializedInHtml };
 declare function getPageContextSerializedInHtml(): {
     pageId: string;
     routeParams: Record<string, string>;
 };
+declare function getGlobalContextSerializedInHtml(): object;

package/dist/esm/client/shared/getJsonSerializedInHtml.js

@@ -0,0 +1,29 @@
+export { getPageContextSerializedInHtml };
+export { getGlobalContextSerializedInHtml };
+import { parse } from '@brillout/json-serializer/parse';
+import { hasProp, assert, assertUsage } from './utils.js';
+import { htmlElementId_globalContext, htmlElementId_pageContext } from '../../shared/htmlElementIds.js';
+// elements should exist because:
+// 1. <script id="vike_pageContext" type="application/json"> appears before the <script> that loads Vike's client runtime (which includes this file)
+// 2. <script id="vike_pageContext" type="application/json"> is neither async nor defer
+// See https://github.com/vikejs/vike/pull/1271
+function getPageContextSerializedInHtml() {
+    const pageContextSerializedInHtml = findAndParseJson(htmlElementId_pageContext);
+    assert(hasProp(pageContextSerializedInHtml, 'pageId', 'string'));
+    assert(hasProp(pageContextSerializedInHtml, 'routeParams', 'string{}'));
+    return pageContextSerializedInHtml;
+}
+function getGlobalContextSerializedInHtml() {
+    const globalContextSerializedInHtml = findAndParseJson(htmlElementId_globalContext);
+    return globalContextSerializedInHtml;
+}
+function findAndParseJson(id) {
+    const elem = document.getElementById(id);
+    assertUsage(elem, 
+    // It seems like it can be missing when HTML is malformed: https://github.com/vikejs/vike/issues/913
+    `Couldn't find #${id} (which Vike automatically injects in the HTML): make sure it exists (i.e. don't remove it and make sure your HTML isn't malformed)`);
+    const jsonStr = elem.textContent;
+    assert(jsonStr);
+    const json = parse(jsonStr);
+    return json;
+}

package/dist/esm/client/shared/utils.d.ts

@@ -1,2 +1,5 @@
 export * from '../../utils/assert.js';
 export * from '../../utils/parseUrl.js';
+export * from '../../utils/getGlobalObject.js';
+export * from '../../utils/objectAssign.js';
+export * from '../../utils/hasProp.js';

package/dist/esm/client/shared/utils.js

@@ -1,2 +1,5 @@
 export * from '../../utils/assert.js';
 export * from '../../utils/parseUrl.js';
+export * from '../../utils/getGlobalObject.js';
+export * from '../../utils/objectAssign.js';
+export * from '../../utils/hasProp.js';

package/dist/esm/node/plugin/plugins/build/pluginModuleBanner.js

@@ -26,6 +26,7 @@ function pluginModuleBanner() {
                 id = removeVirtualIdTag(id);
                 if (id.startsWith(config.root))
                     id = id.slice(config.root.length + 1);
+                id = id.replaceAll('*/', '*\\/'); // https://github.com/vikejs/vike/issues/2377
                 const s = new MagicString(code);
                 // Use legal comment so that esbuild doesn't remove it.
                 // - Terser still removes the comment, but I guess users use terser to minify JavaScript so I guess it's a good thing that comment is removed.

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVikeConfig/configDefinitionsBuiltIn.js

@@ -18,7 +18,12 @@ const configDefinitionsBuiltIn = {
         env: { client: true }
     },
     onCreatePageContext: {
-        env: { server: true },
+        env: { server: true, client: true },
+        global: true,
+        cumulative: true
+    },
+    onCreateGlobalContext: {
+        env: { server: true, client: true },
         global: true,
         cumulative: true
     },

package/dist/esm/node/prerender/runPrerender.d.ts

@@ -4,18 +4,31 @@ export { runPrerenderFromAutoRun };
 export { runPrerender_forceExit };
 export type { PrerenderOptions };
 export type { PrerenderContextPublic };
+import type { PageFile } from '../../shared/getPageFiles.js';
+import { type GlobalContextInternal, type GlobalContextServer } from '../runtime/globalContext.js';
 import type { InlineConfig, ResolvedConfig } from 'vite';
 import type { APIOptions } from '../api/types.js';
-import type { PageContextServer } from '../../shared/types.js';
 type ProvidedByHook = null | {
     hookFilePath: string;
     hookName: 'onBeforePrerenderStart' | 'prerender';
 };
+type ProvidedByHookTransformer = null | {
+    hookFilePath: string;
+    hookName: 'onPrerenderStart' | 'onBeforePrerender';
+};
 type PageContextPrerendered = {
     urlOriginal: string;
     _providedByHook?: ProvidedByHook;
     pageId: string;
 };
+type PrerenderedPageContexts = Record<string, PageContextPrerendered>;
+type PrerenderContext = {
+    pageContexts: PageContext[];
+    output: Output;
+    _pageContextInit: Record<string, unknown> | null;
+    _noExtraDir: boolean | null;
+    _prerenderedPageContexts: PrerenderedPageContexts;
+};
 type Output<PageContext = PageContextPrerendered> = {
     filePath: string;
     fileType: FileType;
@@ -23,6 +36,9 @@ type Output<PageContext = PageContextPrerendered> = {
     pageContext: PageContext;
 }[];
 type FileType = 'HTML' | 'JSON';
+type PageContext = Awaited<ReturnType<typeof createPageContextPrerendering>> & {
+    _urlOriginalBeforeHook?: string;
+};
 type PrerenderOptions = APIOptions & {
     /** Initial `pageContext` values */
     pageContextInit?: Record<string, unknown>;
@@ -50,8 +66,287 @@ declare function runPrerenderFromCLIPrerenderCommand(): Promise<void>;
 declare function runPrerenderFromAutoRun(viteConfig: InlineConfig | undefined): Promise<{
     forceExit: boolean;
 }>;
+declare function createPageContextPrerendering(urlOriginal: string, prerenderContext: PrerenderContext, globalContext: GlobalContextInternal, globalContext_public: GlobalContextServer, is404: boolean, pageId: string | undefined, providedByHook: ProvidedByHook): Promise<((({
+    isClientSide: boolean;
+    isPrerendering: boolean;
+} & Pick<import("../../shared/types.js").PageContextBuiltInServerInternal, "urlOriginal" | "headersOriginal"> & {
+    url?: string;
+    headers?: Record<string, string>;
+} & {
+    globalContext: GlobalContextServer;
+    _globalContext: {
+        _virtualFileExports: unknown;
+        _pageFilesAll: PageFile[];
+        _pageConfigs: import("../../shared/page-configs/PageConfig.js").PageConfigRuntime[];
+        _pageConfigGlobal: import("../../shared/page-configs/PageConfig.js").PageConfigGlobalRuntime;
+        _allPageIds: string[];
+        config: import("../../types/index.js").ConfigResolved;
+        pages: import("../../shared/page-configs/getPageConfigUserFriendly.js").PageConfigsUserFriendly;
+    } & ({
+        _isProduction: false;
+        _isPrerendering: false;
+        assetsManifest: null;
+        _viteDevServer: import("vite").ViteDevServer;
+        viteConfig: ResolvedConfig;
+        viteConfigRuntime: {
+            root: string;
+            build: {
+                outDir: string;
+            };
+            _baseViteOriginal: string;
+            vitePluginServerEntry: {
+                inject: boolean | undefined;
+            };
+        };
+        baseServer: string;
+        baseAssets: string;
+        _pageRoutes: import("../../shared/route/loadPageRoutes.js").PageRoutes;
+        _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
+        _virtualFileExports: unknown;
+        _pageFilesAll: PageFile[];
+        _pageConfigs: import("../../shared/page-configs/PageConfig.js").PageConfigRuntime[];
+        _pageConfigGlobal: import("../../shared/page-configs/PageConfig.js").PageConfigGlobalRuntime;
+        _allPageIds: string[];
+        config: import("../../types/index.js").ConfigResolved;
+        pages: import("../../shared/page-configs/getPageConfigUserFriendly.js").PageConfigsUserFriendly;
+    } | {
+        _isPrerendering: true;
+        viteConfig: ResolvedConfig;
+        _isProduction: true;
+        assetsManifest: import("../shared/ViteManifest.js").ViteManifest;
+        _viteDevServer: null;
+        viteConfigRuntime: {
+            root: string;
+            build: {
+                outDir: string;
+            };
+            _baseViteOriginal: string;
+            vitePluginServerEntry: {
+                inject: boolean | undefined;
+            };
+        };
+        _usesClientRouter: boolean;
+        baseServer: string;
+        baseAssets: string;
+        _pageRoutes: import("../../shared/route/loadPageRoutes.js").PageRoutes;
+        _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
+        _virtualFileExports: unknown;
+        _pageFilesAll: PageFile[];
+        _pageConfigs: import("../../shared/page-configs/PageConfig.js").PageConfigRuntime[];
+        _pageConfigGlobal: import("../../shared/page-configs/PageConfig.js").PageConfigGlobalRuntime;
+        _allPageIds: string[];
+        config: import("../../types/index.js").ConfigResolved;
+        pages: import("../../shared/page-configs/getPageConfigUserFriendly.js").PageConfigsUserFriendly;
+    } | {
+        _isPrerendering: false;
+        viteConfig: null;
+        _isProduction: true;
+        assetsManifest: import("../shared/ViteManifest.js").ViteManifest;
+        _viteDevServer: null;
+        viteConfigRuntime: {
+            root: string;
+            build: {
+                outDir: string;
+            };
+            _baseViteOriginal: string;
+            vitePluginServerEntry: {
+                inject: boolean | undefined;
+            };
+        };
+        _usesClientRouter: boolean;
+        baseServer: string;
+        baseAssets: string;
+        _pageRoutes: import("../../shared/route/loadPageRoutes.js").PageRoutes;
+        _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
+        _virtualFileExports: unknown;
+        _pageFilesAll: PageFile[];
+        _pageConfigs: import("../../shared/page-configs/PageConfig.js").PageConfigRuntime[];
+        _pageConfigGlobal: import("../../shared/page-configs/PageConfig.js").PageConfigGlobalRuntime;
+        _allPageIds: string[];
+        config: import("../../types/index.js").ConfigResolved;
+        pages: import("../../shared/page-configs/getPageConfigUserFriendly.js").PageConfigsUserFriendly;
+    });
+    _baseServer: string;
+    _baseAssets: string;
+    _includeAssetsImportedByServer: boolean;
+    _pageFilesAll: PageFile[];
+    _pageConfigs: import("../../shared/page-configs/PageConfig.js").PageConfigRuntime[];
+    _pageConfigGlobal: import("../../shared/page-configs/PageConfig.js").PageConfigGlobalRuntime;
+    _allPageIds: string[];
+    _pageRoutes: import("../../shared/route/loadPageRoutes.js").PageRoutes;
+    _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
+    _pageContextInit: import("../runtime/renderPage.js").PageContextInit;
+    _urlRewrite: null;
+    _urlHandler: ((url: string) => string) | null;
+    isClientSideNavigation: boolean;
+} & {
+    urlParsed: import("../shared/utils.js").UrlPublic;
+    urlPathname: string;
+    url: string;
+} & {
+    headers: Record<string, string> | null;
+} & {
+    config: import("../../types/index.js").ConfigResolved;
+    _source: import("../../shared/page-configs/getPageConfigUserFriendly.js").Source;
+    _sources: import("../../shared/page-configs/getPageConfigUserFriendly.js").Sources;
+    _from: import("../../shared/page-configs/getPageConfigUserFriendly.js").From;
+    _isPageContextObject: boolean;
+} & {
+    _urlHandler: null;
+    _httpRequestId: null;
+    _urlRewrite: null;
+    _noExtraDir: boolean | null;
+    _prerenderContext: PrerenderContext;
+    _providedByHook: ProvidedByHook;
+    _urlOriginalModifiedByHook: ProvidedByHookTransformer;
+    is404: boolean;
+} & import("../../shared/route/index.js").PageContextFromRoute & Record<"pageId", string>) | ({
+    isClientSide: boolean;
+    isPrerendering: boolean;
+} & Pick<import("../../shared/types.js").PageContextBuiltInServerInternal, "urlOriginal" | "headersOriginal"> & {
+    url?: string;
+    headers?: Record<string, string>;
+} & {
+    globalContext: GlobalContextServer;
+    _globalContext: {
+        _virtualFileExports: unknown;
+        _pageFilesAll: PageFile[];
+        _pageConfigs: import("../../shared/page-configs/PageConfig.js").PageConfigRuntime[];
+        _pageConfigGlobal: import("../../shared/page-configs/PageConfig.js").PageConfigGlobalRuntime;
+        _allPageIds: string[];
+        config: import("../../types/index.js").ConfigResolved;
+        pages: import("../../shared/page-configs/getPageConfigUserFriendly.js").PageConfigsUserFriendly;
+    } & ({
+        _isProduction: false;
+        _isPrerendering: false;
+        assetsManifest: null;
+        _viteDevServer: import("vite").ViteDevServer;
+        viteConfig: ResolvedConfig;
+        viteConfigRuntime: {
+            root: string;
+            build: {
+                outDir: string;
+            };
+            _baseViteOriginal: string;
+            vitePluginServerEntry: {
+                inject: boolean | undefined;
+            };
+        };
+        baseServer: string;
+        baseAssets: string;
+        _pageRoutes: import("../../shared/route/loadPageRoutes.js").PageRoutes;
+        _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
+        _virtualFileExports: unknown;
+        _pageFilesAll: PageFile[];
+        _pageConfigs: import("../../shared/page-configs/PageConfig.js").PageConfigRuntime[];
+        _pageConfigGlobal: import("../../shared/page-configs/PageConfig.js").PageConfigGlobalRuntime;
+        _allPageIds: string[];
+        config: import("../../types/index.js").ConfigResolved;
+        pages: import("../../shared/page-configs/getPageConfigUserFriendly.js").PageConfigsUserFriendly;
+    } | {
+        _isPrerendering: true;
+        viteConfig: ResolvedConfig;
+        _isProduction: true;
+        assetsManifest: import("../shared/ViteManifest.js").ViteManifest;
+        _viteDevServer: null;
+        viteConfigRuntime: {
+            root: string;
+            build: {
+                outDir: string;
+            };
+            _baseViteOriginal: string;
+            vitePluginServerEntry: {
+                inject: boolean | undefined;
+            };
+        };
+        _usesClientRouter: boolean;
+        baseServer: string;
+        baseAssets: string;
+        _pageRoutes: import("../../shared/route/loadPageRoutes.js").PageRoutes;
+        _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
+        _virtualFileExports: unknown;
+        _pageFilesAll: PageFile[];
+        _pageConfigs: import("../../shared/page-configs/PageConfig.js").PageConfigRuntime[];
+        _pageConfigGlobal: import("../../shared/page-configs/PageConfig.js").PageConfigGlobalRuntime;
+        _allPageIds: string[];
+        config: import("../../types/index.js").ConfigResolved;
+        pages: import("../../shared/page-configs/getPageConfigUserFriendly.js").PageConfigsUserFriendly;
+    } | {
+        _isPrerendering: false;
+        viteConfig: null;
+        _isProduction: true;
+        assetsManifest: import("../shared/ViteManifest.js").ViteManifest;
+        _viteDevServer: null;
+        viteConfigRuntime: {
+            root: string;
+            build: {
+                outDir: string;
+            };
+            _baseViteOriginal: string;
+            vitePluginServerEntry: {
+                inject: boolean | undefined;
+            };
+        };
+        _usesClientRouter: boolean;
+        baseServer: string;
+        baseAssets: string;
+        _pageRoutes: import("../../shared/route/loadPageRoutes.js").PageRoutes;
+        _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
+        _virtualFileExports: unknown;
+        _pageFilesAll: PageFile[];
+        _pageConfigs: import("../../shared/page-configs/PageConfig.js").PageConfigRuntime[];
+        _pageConfigGlobal: import("../../shared/page-configs/PageConfig.js").PageConfigGlobalRuntime;
+        _allPageIds: string[];
+        config: import("../../types/index.js").ConfigResolved;
+        pages: import("../../shared/page-configs/getPageConfigUserFriendly.js").PageConfigsUserFriendly;
+    });
+    _baseServer: string;
+    _baseAssets: string;
+    _includeAssetsImportedByServer: boolean;
+    _pageFilesAll: PageFile[];
+    _pageConfigs: import("../../shared/page-configs/PageConfig.js").PageConfigRuntime[];
+    _pageConfigGlobal: import("../../shared/page-configs/PageConfig.js").PageConfigGlobalRuntime;
+    _allPageIds: string[];
+    _pageRoutes: import("../../shared/route/loadPageRoutes.js").PageRoutes;
+    _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
+    _pageContextInit: import("../runtime/renderPage.js").PageContextInit;
+    _urlRewrite: null;
+    _urlHandler: ((url: string) => string) | null;
+    isClientSideNavigation: boolean;
+} & {
+    urlParsed: import("../shared/utils.js").UrlPublic;
+    urlPathname: string;
+    url: string;
+} & {
+    headers: Record<string, string> | null;
+} & {
+    config: import("../../types/index.js").ConfigResolved;
+    _source: import("../../shared/page-configs/getPageConfigUserFriendly.js").Source;
+    _sources: import("../../shared/page-configs/getPageConfigUserFriendly.js").Sources;
+    _from: import("../../shared/page-configs/getPageConfigUserFriendly.js").From;
+    _isPageContextObject: boolean;
+} & {
+    _urlHandler: null;
+    _httpRequestId: null;
+    _urlRewrite: null;
+    _noExtraDir: boolean | null;
+    _prerenderContext: PrerenderContext;
+    _providedByHook: ProvidedByHook;
+    _urlOriginalModifiedByHook: ProvidedByHookTransformer;
+    is404: boolean;
+} & {
+    pageId: string;
+    _debugRouteMatches: never[];
+    routeParams: {};
+})) & import("../../shared/getPageFiles.js").PageConfigUserFriendlyOld & {
+    Page: unknown;
+    _isHtmlOnly: boolean;
+    _passToClient: string[];
+    _pageFilePathsLoaded: string[];
+} & {
+    __getPageAssets: () => Promise<import("../runtime/renderPage/getPageAssets.js").PageAsset[]>;
+}) & {
+    _usesClientRouter: boolean;
+}>;
 declare function runPrerender_forceExit(): void;
-type PrerenderContextPublic = {
-    output: Output<PageContextServer>;
-    pageContexts: PageContextServer[];
-};
+type PrerenderContextPublic = Pick<PrerenderContext, 'output' | 'pageContexts'>;