vike 0.4.143 → 0.4.144-commit-68c730d

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

@@ -20,6 +20,7 @@ import { preparePageContextForUserConsumptionServerSide } from './preparePageCon
 import { executeGuardHook } from '../../../shared/route/executeGuardHook.js';
 import { loadPageRoutes } from '../../../shared/route/loadPageRoutes.js';
 import pc from '@brillout/picocolors';
+import { getConfigValueFilePathToShowToUser } from '../../../shared/page-configs/utils.js';
 async function renderPageAlreadyRouted(pageContext) {
     // pageContext._pageId can either be the:
     //  - ID of the page matching the routing, or the
@@ -166,9 +167,9 @@ function assertNonMixedDesign(pageFilesAll, pageConfigs) {
     const indent = '- ';
     const v1Files = unique(pageConfigs
         .map((p) => Object.values(p.configValues)
-        .map(({ definedAtInfo }) => definedAtInfo)
+        .map(getConfigValueFilePathToShowToUser)
         .filter(isNotNullish)
-        .map((definedAtInfo) => indent + definedAtInfo.filePath))
+        .map((filePathToShowToUser) => indent + filePathToShowToUser))
         .flat(2));
     assertUsage(false, [
         'Mixing the new V1 design with the old V0.4 design is forbidden.',

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

@@ -305,7 +305,7 @@ function getRequestId() {
 }
 function skipRequest(urlOriginal) {
     const isViteClientRequest = urlOriginal.endsWith('/@vite/client') || urlOriginal.startsWith('/@fs/');
-    assertWarning(!isViteClientRequest, `The vike middleware renderPage() was called with the URL ${urlOriginal} which is unexpected because the HTTP request should have already been handled by Vite's development middleware. Make sure to 1. install Vite's development middleware and 2. add Vite's middleware *before* vike's middleware, see https://vike.dev/renderPage`, { onlyOnce: true });
+    assertWarning(!isViteClientRequest, `The vike middleware renderPage() was called with the URL ${urlOriginal} which is unexpected because the HTTP request should have already been handled by Vite's development middleware. Make sure to 1. install Vite's development middleware and 2. add Vite's middleware *before* Vike's middleware, see https://vike.dev/renderPage`, { onlyOnce: true });
     return (urlOriginal.endsWith('/__vite_ping') ||
         urlOriginal.endsWith('/favicon.ico') ||
         !isParsable(urlOriginal) ||

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

@@ -1,3 +1,3 @@
 export { getClientEntryFilePath };
-import type { PageConfig, PageConfigBuildTime } from '../../shared/page-configs/PageConfig.js';
-declare function getClientEntryFilePath(pageConfig: PageConfig | PageConfigBuildTime): null | string;
+import type { PageConfigRuntime, PageConfigBuildTime } from '../../shared/page-configs/PageConfig.js';
+declare function getClientEntryFilePath(pageConfig: PageConfigRuntime | PageConfigBuildTime): null | string;

package/dist/esm/node/shared/getClientEntryFilePath.js

@@ -1,15 +1,9 @@
 export { getClientEntryFilePath };
-import { getConfigDefinedAtInfo, getConfigValue } from '../../shared/page-configs/utils.js';
-import { assert } from './utils.js';
+import { getConfigValue } from '../../shared/page-configs/utils.js';
 function getClientEntryFilePath(pageConfig) {
     const configName = 'client';
     const configValue = getConfigValue(pageConfig, configName, 'string');
     if (!configValue)
         return null;
-    const definedAtInfo = getConfigDefinedAtInfo(pageConfig, configName);
-    const { value } = configValue;
-    // Users should be able to suppress client entry by setting its value to null
-    assert(value !== null);
-    const clientEntryFilePath = definedAtInfo.filePath;
-    return clientEntryFilePath;
+    return configValue.value;
 }

package/dist/esm/shared/addIs404ToPageProps.d.ts

@@ -1,7 +1,7 @@
 export { addIs404ToPageProps };
-import type { PageConfig } from './page-configs/PageConfig.js';
+import type { PageConfigRuntime } from './page-configs/PageConfig.js';
 declare function addIs404ToPageProps(pageContext: Record<string, unknown> & PageContextAssertIs404): void;
 type PageContextAssertIs404 = {
     _pageId: string;
-    _pageConfigs: PageConfig[];
+    _pageConfigs: PageConfigRuntime[];
 };

package/dist/esm/shared/addUrlComputedProps.d.ts

@@ -4,7 +4,8 @@ export type { PageContextUrlComputedPropsInternal };
 export type { PageContextUrlComputedPropsClient };
 export type { PageContextUrlComputedPropsServer };
 export type { PageContextUrlSources };
-type UrlParsed = {
+export type { Url };
+type Url = {
     /** The URL origin, e.g. `https://example.com` of `https://example.com/product/42?details=yes#reviews` */
     origin: null | string;
     /** The URL pathname, e.g. `/product/42` of `https://example.com/product/42?details=yes#reviews` */
@@ -34,8 +35,9 @@ type PageContextUrlComputedPropsClient = {
     /** The URL pathname, e.g. `/product/42` of `https://example.com/product/42?details=yes#reviews` */
     urlPathname: string;
     /** Parsed information about the current URL */
-    urlParsed: UrlParsed;
+    urlParsed: Url;
 };
+/** For Vike internal use */
 type PageContextUrlComputedPropsInternal = PageContextUrlComputedPropsClient & {
     _urlRewrite: string | null;
 };

package/dist/esm/shared/assertPageContextProvidedByUser.js

@@ -10,6 +10,6 @@ function assertPageContextProvidedByUser(pageContextProvidedByUser, { hookName,
     assertUsage(!('_objectCreatedByVike' in pageContextProvidedByUser), `${errPrefix} shouldn't be the whole ${pc.cyan('pageContext')} object, see https://vike.dev/pageContext-manipulation#do-not-return-entire-pagecontext`);
     // In principle, it's possible to use onBeforeRoute()` to override and define the whole routing.
     // Is that a good idea to allow users to do this? Beyond deep integration with Vue Router or React Router, is there a use case for this?
-    assertWarning(!('_pageId' in pageContextProvidedByUser), `${errPrefix} sets ${pc.cyan('pageContext._pageId')} which means that vike's routing is overriden. This is an experimental feature: make sure to contact a vike maintainer before using this.`, { onlyOnce: true });
+    assertWarning(!('_pageId' in pageContextProvidedByUser), `${errPrefix} sets ${pc.cyan('pageContext._pageId')} which means that Vike's routing is overriden. This is an experimental feature: make sure to contact a vike maintainer before using this.`, { onlyOnce: true });
     assertUsage(!('is404' in pageContextProvidedByUser), `${errPrefix} sets ${pc.cyan('pageContext.is404')} which is forbidden, use ${pc.cyan('throw render()')} instead, see https://vike.dev/render`);
 }

package/dist/esm/shared/error-page.d.ts

@@ -1,8 +1,8 @@
 export { getErrorPageId };
 export { isErrorPageId };
 export { isErrorPage };
-import type { PageConfig } from './page-configs/PageConfig.js';
+import type { PageConfigRuntime } from './page-configs/PageConfig.js';
 import type { PageFile } from './getPageFiles.js';
-declare function getErrorPageId(pageFilesAll: PageFile[], pageConfigs: PageConfig[]): string | null;
+declare function getErrorPageId(pageFilesAll: PageFile[], pageConfigs: PageConfigRuntime[]): string | null;
 declare function isErrorPageId(pageId: string, _isV1Design: false): boolean;
-declare function isErrorPage(pageId: string, pageConfigs: PageConfig[]): boolean;
+declare function isErrorPage(pageId: string, pageConfigs: PageConfigRuntime[]): boolean;

package/dist/esm/shared/error-page.js

@@ -30,7 +30,7 @@ function isErrorPage(pageId, pageConfigs) {
     if (pageConfigs.length > 0) {
         const pageConfig = pageConfigs.find((p) => p.pageId === pageId);
         assert(pageConfig);
-        return pageConfig.isErrorPage;
+        return !!pageConfig.isErrorPage;
     }
     else {
         return isErrorPageId(pageId, false);

package/dist/esm/shared/getPageFiles/analyzeClientSide.d.ts

@@ -1,7 +1,7 @@
 export { analyzeClientSide };
-import type { PageConfig } from '../page-configs/PageConfig.js';
+import type { PageConfigRuntime } from '../page-configs/PageConfig.js';
 import type { PageFile } from './getPageFileObject.js';
-declare function analyzeClientSide(pageConfig: PageConfig | null, pageFilesAll: PageFile[], pageId: string): {
+declare function analyzeClientSide(pageConfig: PageConfigRuntime | null, pageFilesAll: PageFile[], pageId: string): {
     isClientSideRenderable: boolean;
     isClientRouting: boolean;
 };

package/dist/esm/shared/getPageFiles/getExports.d.ts

@@ -4,18 +4,17 @@ export type { ExportsAll };
 export type { PageContextExports };
 export type { ConfigEntries };
 import type { FileType } from './fileTypes.js';
-import type { PageConfigLoaded } from './../page-configs/PageConfig.js';
+import type { PageConfigRuntimeLoaded } from './../page-configs/PageConfig.js';
 import type { PageFile } from './getPageFileObject.js';
 type ExportsAll = Record<string, {
     exportValue: unknown;
     exportSource: string;
+    filePath: string | null;
     /** @deprecated */
     _fileType: FileType | null;
     /** @deprecated */
     _isFromDefaultExport: boolean | null;
     /** @deprecated */
-    filePath: string | null;
-    /** @deprecated */
     _filePath: string | null;
 }[]>;
 /** All the config's values (including overriden ones) and where they come from.
@@ -35,5 +34,5 @@ type PageContextExports = {
     /** @deprecated */
     pageExports: Record<string, unknown>;
 };
-declare function getExports(pageFiles: PageFile[], pageConfig: PageConfigLoaded | null): PageContextExports;
+declare function getExports(pageFiles: PageFile[], pageConfig: PageConfigRuntimeLoaded | null): PageContextExports;
 declare function getExportUnion(exportsAll: ExportsAll, propName: string): string[];

package/dist/esm/shared/getPageFiles/getExports.js

@@ -2,8 +2,8 @@ export { getExportUnion };
 export { getExports };
 import { isScriptFile, isTemplateFile } from '../../utils/isScriptFile.js';
 import { assert, hasProp, isObject, assertWarning, assertUsage, makeLast, isBrowser } from '../utils.js';
-import { assertDefaultExports, forbiddenDefaultExports } from './assertExports.js';
-import { getConfigDefinedAtString } from '../page-configs/utils.js';
+import { assertDefaultExports, forbiddenDefaultExports } from './assert_exports_old_design.js';
+import { getConfigDefinedAtString, getConfigValueFilePathToShowToUser } from '../page-configs/utils.js';
 import pc from '@brillout/picocolors';
 function getExports(pageFiles, pageConfig) {
     const configEntries = {};
@@ -29,11 +29,8 @@ function getExports(pageFiles, pageConfig) {
     // V1 design
     if (pageConfig) {
         Object.entries(pageConfig.configValues).forEach(([configName, configValue]) => {
-            const { value, definedAtInfo } = configValue;
-            let filePath = null;
-            if (definedAtInfo) {
-                filePath = definedAtInfo.filePath;
-            }
+            const { value } = configValue;
+            const configValueFilePathToShowToUser = getConfigValueFilePathToShowToUser(configValue);
             const configDefinedAt = getConfigDefinedAtString(configName, configValue, true);
             config[configName] = config[configName] ?? value;
             configEntries[configName] = configEntries[configName] ?? [];
@@ -42,7 +39,7 @@ function getExports(pageFiles, pageConfig) {
             configEntries[configName].push({
                 configValue: value,
                 configDefinedAt,
-                configDefinedByFile: filePath
+                configDefinedByFile: configValueFilePathToShowToUser
             });
             // TODO/v1-release: remove
             const exportName = configName;
@@ -50,8 +47,8 @@ function getExports(pageFiles, pageConfig) {
             exportsAll[exportName].push({
                 exportValue: value,
                 exportSource: configDefinedAt,
-                filePath,
-                _filePath: filePath,
+                filePath: configValueFilePathToShowToUser,
+                _filePath: configValueFilePathToShowToUser,
                 _fileType: null,
                 _isFromDefaultExport: null
             });

package/dist/esm/shared/getPageFiles/parseGlobResults.d.ts

@@ -1,8 +1,8 @@
 export { parseGlobResults };
 import { type PageFile } from './getPageFileObject.js';
-import type { PageConfig, PageConfigGlobal } from '../page-configs/PageConfig.js';
+import type { PageConfigRuntime, PageConfigGlobalRuntime } from '../page-configs/PageConfig.js';
 declare function parseGlobResults(pageFilesExports: unknown): {
     pageFiles: PageFile[];
-    pageConfigs: PageConfig[];
-    pageConfigGlobal: PageConfigGlobal;
+    pageConfigs: PageConfigRuntime[];
+    pageConfigGlobal: PageConfigGlobalRuntime;
 };

package/dist/esm/shared/getPageFiles/parseGlobResults.js

@@ -1,10 +1,10 @@
 export { parseGlobResults };
 import { assert, hasProp, isCallable, isObject, cast, assertUsage } from '../utils.js';
-import { assertExportValues } from './assertExports.js';
+import { assertExportValues } from './assert_exports_old_design.js';
 import { getPageFileObject } from './getPageFileObject.js';
 import { fileTypes } from './fileTypes.js';
-import { assertPageConfigGlobal, assertPageConfigs } from './assertPageConfigs.js';
-import { parse } from '@brillout/json-serializer/parse';
+import { assertPageConfigGlobalSerialized, assertPageConfigsSerialized } from '../page-configs/serialize/assertPageConfigs.js';
+import { parsePageConfigs } from '../page-configs/serialize/parsePageConfigs.js';
 function parseGlobResults(pageFilesExports) {
     assert(hasProp(pageFilesExports, 'isGeneratedFile'));
     assert(pageFilesExports.isGeneratedFile !== false, `vike was re-installed(/re-built). Restart your app.`);
@@ -16,12 +16,12 @@ function parseGlobResults(pageFilesExports) {
     assert(hasProp(pageFilesExports.pageFilesLazy, '.page'));
     assert(hasProp(pageFilesExports.pageFilesLazy, '.page.client') || hasProp(pageFilesExports.pageFilesLazy, '.page.server'));
     assert(hasProp(pageFilesExports, 'pageFilesList', 'string[]'));
-    assert(hasProp(pageFilesExports, 'pageConfigs'));
-    assert(hasProp(pageFilesExports, 'pageConfigGlobal'));
-    const { pageConfigs, pageConfigGlobal } = pageFilesExports;
-    assertPageConfigs(pageConfigs);
-    parsePageConfigs(pageConfigs);
-    assertPageConfigGlobal(pageConfigGlobal);
+    assert(hasProp(pageFilesExports, 'pageConfigsSerialized'));
+    assert(hasProp(pageFilesExports, 'pageConfigGlobalSerialized'));
+    const { pageConfigsSerialized, pageConfigGlobalSerialized } = pageFilesExports;
+    assertPageConfigsSerialized(pageConfigsSerialized);
+    assertPageConfigGlobalSerialized(pageConfigGlobalSerialized);
+    const { pageConfigs, pageConfigGlobal } = parsePageConfigs(pageConfigsSerialized, pageConfigGlobalSerialized);
     const pageFilesMap = {};
     parseGlobResult(pageFilesExports.pageFilesLazy).forEach(({ filePath, pageFile, globValue }) => {
         pageFile = pageFilesMap[filePath] = pageFilesMap[filePath] ?? pageFile;
@@ -88,37 +88,3 @@ function parseGlobResult(globObject) {
 function assertLoadModule(globValue) {
     assert(isCallable(globValue));
 }
-function parsePageConfigs(pageConfigs) {
-    pageConfigs.forEach((pageConfig) => {
-        Object.entries(pageConfig.configValues).forEach(([configName, configValue]) => {
-            {
-                const { valueSerialized } = configValue;
-                if (valueSerialized !== undefined) {
-                    configValue.value = parse(valueSerialized);
-                }
-            }
-            /*
-            if (configName === 'route') {
-              assertRouteConfigValue(configElement)
-            }
-            */
-        });
-    });
-}
-// TODO: use again
-// function assertRouteConfigValue(configElement: ConfigElement) {
-//   assert(hasProp(configElement, 'configValue')) // route files are eagerly loaded
-//   const { configValue } = configElement
-//   const configValueType = typeof configValue
-//   assertUsage(
-//     configValueType === 'string' || isCallable(configValue),
-//     `${configElement.configDefinedAt} has an invalid type '${configValueType}': it should be a string or a function instead, see https://vike.dev/route`
-//   )
-//   /* We don't do that to avoid unnecessarily bloating the client-side bundle when using Server Routing
-//    *  - When using Server Routing, this file is loaded as well
-//    *  - When using Server Routing, client-side validation is superfluous as Route Strings only need to be validated on the server-side
-//   if (typeof configValue === 'string') {
-//     assertRouteString(configValue, `${configElement.configDefinedAt} defines an`)
-//   }
-//   */
-// }

package/dist/esm/shared/getPageFiles/setPageFiles.d.ts

@@ -2,12 +2,12 @@ export { setPageFiles };
 export { setPageFilesAsync };
 export { getPageFilesAll };
 import type { PageFile } from './getPageFileObject.js';
-import type { PageConfig, PageConfigGlobal } from '../page-configs/PageConfig.js';
+import type { PageConfigRuntime, PageConfigGlobalRuntime } from '../page-configs/PageConfig.js';
 declare function setPageFiles(pageFilesExports: unknown): void;
 declare function setPageFilesAsync(getPageFilesExports: () => Promise<unknown>): void;
 declare function getPageFilesAll(isClientSide: boolean, isProduction?: boolean): Promise<{
     pageFilesAll: PageFile[];
     allPageIds: string[];
-    pageConfigs: PageConfig[];
-    pageConfigGlobal: PageConfigGlobal;
+    pageConfigs: PageConfigRuntime[];
+    pageConfigGlobal: PageConfigGlobalRuntime;
 }>;

package/dist/esm/shared/hooks/getHook.js

@@ -11,7 +11,9 @@ function getHook(pageContext, hookName) {
     assert(file.exportValue === hookFn);
     if (hookFn === null)
         return null;
-    const hookFilePath = file.exportSource;
+    const hookFilePath = file.filePath;
+    assert(hookFilePath);
+    assert(!hookFilePath.endsWith(' '));
     assertHookFn(hookFn, { hookName, hookFilePath });
     return { hookFn, hookName, hookFilePath };
 }

package/dist/esm/shared/page-configs/Config.d.ts

@@ -3,15 +3,202 @@ export type { ConfigBuiltIn };
 export type { ConfigNameBuiltIn };
 export type { ConfigMeta };
 export type { HookName };
+export type { GuardAsync };
+export type { GuardSync };
+export type { OnBeforePrerenderStartAsync };
+export type { OnBeforePrerenderStartSync };
+export type { OnBeforeRenderAsync };
+export type { OnBeforeRenderSync };
+export type { OnBeforeRouteAsync };
+export type { OnBeforeRouteSync };
+export type { OnHydrationEndAsync };
+export type { OnHydrationEndSync };
+export type { OnPageTransitionEndAsync };
+export type { OnPageTransitionEndSync };
+export type { OnPageTransitionStartAsync };
+export type { OnPageTransitionStartSync };
+export type { OnPrerenderStartAsync };
+export type { OnPrerenderStartSync };
+export type { OnRenderClientAsync };
+export type { OnRenderClientSync };
+export type { OnRenderHtmlAsync };
+export type { OnRenderHtmlSync };
+export type { RouteAsync };
+export type { RouteSync };
 import type { PrefetchStaticAssets } from '../../client/client-routing-runtime/prefetch/getPrefetchSettings.js';
 import type { ConfigDefinition } from '../../node/plugin/plugins/importUserCode/v1-design/getVikeConfig/configDefinitionsBuiltIn.js';
+import type { DocumentHtml } from '../../node/runtime/html/renderHtml.js';
 import type { ConfigVikeUserProvided } from '../ConfigVike.js';
 import type { Vike, VikePackages } from '../VikeNamespace.js';
+import type { PageContextClient, PageContextServer } from '../types.js';
 type HookName = 'onHydrationEnd' | 'onBeforePrerender' | 'onBeforePrerenderStart' | 'onBeforeRender' | 'onBeforeRoute' | 'onPageTransitionStart' | 'onPageTransitionEnd' | 'onPrerenderStart' | 'onRenderHtml' | 'onRenderClient' | 'guard' | 'render';
-type ConfigNameBuiltInPublic = Exclude<keyof Config, keyof ConfigVikeUserProvided | 'onBeforeRoute' | 'onPrerenderStart'> | 'prerender';
-type ConfigNameBuiltInInternal = 'isClientSideRenderable' | 'onBeforeRenderEnv';
-type ConfigNameBuiltIn = ConfigNameBuiltInPublic | ConfigNameBuiltInInternal;
+type ConfigNameBuiltIn = Exclude<keyof Config, keyof ConfigVikeUserProvided | 'onBeforeRoute' | 'onPrerenderStart'> | 'prerender' | 'isClientSideRenderable' | 'onBeforeRenderEnv';
 type Config = ConfigBuiltIn & Vike.Config & (VikePackages.ConfigVikeReact | VikePackages.ConfigVikeVue | VikePackages.ConfigVikeSolid | VikePackages.ConfigVikeSvelte);
+/** Protect page(s), e.g. forbid unauthorized access.
+ *
+ *  https://vike.dev/guard
+ */
+type GuardAsync = (pageContext: PageContextServer) => Promise<void>;
+/** Protect page(s), e.g. forbid unauthorized access.
+ *
+ *  https://vike.dev/guard
+ */
+type GuardSync = (pageContext: PageContextServer) => void;
+/** Global Hook called before the whole pre-rendering process starts.
+ *
+ * https://vike.dev/onBeforePrerenderStart
+ */
+type OnBeforePrerenderStartAsync = () => Promise<(string | {
+    url: string;
+    pageContext: Partial<Vike.PageContext>;
+})[]>;
+/** Global Hook called before the whole pre-rendering process starts.
+ *
+ * https://vike.dev/onBeforePrerenderStart
+ */
+type OnBeforePrerenderStartSync = () => (string | {
+    url: string;
+    pageContext: Partial<Vike.PageContext>;
+})[];
+/** Hook called before the page is rendered, usually for fetching data.
+ *
+ *  https://vike.dev/onBeforeRender
+ */
+type OnBeforeRenderAsync = (pageContext: PageContextServer) => Promise<{
+    pageContext: Partial<Vike.PageContext>;
+} | void>;
+/** Hook called before the page is rendered, usually for fetching data.
+ *
+ *  https://vike.dev/onBeforeRender
+ */
+type OnBeforeRenderSync = (pageContext: PageContextServer) => {
+    pageContext: Partial<Vike.PageContext>;
+} | void;
+/** Hook called before the URL is routed to a page.
+ *
+ * https://vike.dev/onBeforeRoute
+ */
+type OnBeforeRouteAsync = (pageContext: PageContextServer) => Promise<{
+    pageContext: Partial<{
+        /** The URL you provided to Vike when calling `renderPage({ urlOriginal })` in your server middleware.
+         *
+         * https://vike.dev/renderPage
+         */
+        urlOriginal: string;
+    } | Vike.PageContext>;
+}>;
+/** Hook called before the URL is routed to a page.
+ *
+ * https://vike.dev/onBeforeRoute
+ */
+type OnBeforeRouteSync = (pageContext: PageContextServer) => {
+    pageContext: Partial<{
+        /** The URL you provided to Vike when calling `renderPage({ urlOriginal })` in your server middleware.
+         *
+         * https://vike.dev/renderPage
+         */
+        urlOriginal: string;
+    } | Vike.PageContext>;
+};
+/** Hook called after the page is hydrated.
+ *
+ * https://vike.dev/clientRouting
+ */
+type OnHydrationEndAsync = (pageContext: PageContextClient) => Promise<void>;
+/** Hook called after the page is hydrated.
+ *
+ * https://vike.dev/clientRouting
+ */
+type OnHydrationEndSync = (pageContext: PageContextClient) => void;
+/** Hook called after the user navigates to a new page.
+ *
+ * https://vike.dev/clientRouting
+ */
+type OnPageTransitionEndAsync = (pageContext: PageContextClient) => Promise<void>;
+/** Hook called after the user navigates to a new page.
+ *
+ * https://vike.dev/clientRouting
+ */
+type OnPageTransitionEndSync = (pageContext: PageContextClient) => void;
+/** Hook called before the user navigates to a new page.
+ *
+ * https://vike.dev/clientRouting
+ */
+type OnPageTransitionStartAsync = (pageContext: PageContextClient) => Promise<void>;
+/** Hook called before the user navigates to a new page.
+ *
+ * https://vike.dev/clientRouting
+ */
+type OnPageTransitionStartSync = (pageContext: PageContextClient) => void;
+/** Page Hook called when pre-rendering starts.
+ *
+ * https://vike.dev/onPrerenderStart
+ */
+type OnPrerenderStartAsync = (prerenderContext: {
+    pageContexts: PageContextServer[];
+}) => Promise<{
+    prerenderContext: {
+        pageContexts: PageContextServer[];
+    };
+}>;
+/** Page Hook called when pre-rendering starts.
+ *
+ * https://vike.dev/onPrerenderStart
+ */
+type OnPrerenderStartSync = (prerenderContext: {
+    pageContexts: PageContextServer[];
+}) => {
+    prerenderContext: {
+        pageContexts: PageContextServer[];
+    };
+};
+/** Hook called when page is rendered on the client-side.
+ *
+ * https://vike.dev/onRenderClient
+ */
+type OnRenderClientAsync = (pageContext: PageContextClient) => Promise<void>;
+/** Hook called when page is rendered on the client-side.
+ *
+ * https://vike.dev/onRenderClient
+ */
+type OnRenderClientSync = (pageContext: PageContextClient) => void;
+/** Hook called when page is rendered to HTML on the server-side.
+ *
+ * https://vike.dev/onRenderHtml
+ */
+type OnRenderHtmlAsync = (pageContext: PageContextServer) => Promise<DocumentHtml | {
+    documentHtml: DocumentHtml;
+    pageContext: OnRenderHtmlPageContextReturn | (() => Promise<OnRenderHtmlPageContextReturn> | OnRenderHtmlPageContextReturn);
+}>;
+/** Hook called when page is rendered to HTML on the server-side.
+ *
+ * https://vike.dev/onRenderHtml
+ */
+type OnRenderHtmlSync = (pageContext: PageContextServer) => DocumentHtml | {
+    documentHtml: DocumentHtml;
+    pageContext: OnRenderHtmlPageContextReturn | (() => Promise<OnRenderHtmlPageContextReturn> | OnRenderHtmlPageContextReturn);
+};
+type OnRenderHtmlPageContextReturn = Partial<Vike.PageContext & {
+    /** See https://vike.dev/stream */
+    enableEagerStreaming: boolean;
+}>;
+/** @deprecated Use a sync route() with an async guard() instead */
+type RouteAsync = (pageContext: PageContextServer | PageContextClient) => Promise<{
+    routeParams?: Record<string, string>;
+    precedence?: number;
+} | boolean>;
+/** The page's URL(s).
+ *
+ *  https://vike.dev/route
+ */
+type RouteSync = (pageContext: PageContextServer | PageContextClient) => {
+    routeParams?: Record<string, string>;
+    precedence?: number;
+} | boolean;
+/** The page's URL(s).
+ *
+ *  https://vike.dev/route
+ */
 /** Page configuration.
  *
  * https://vike.dev/config
@@ -23,12 +210,12 @@ type ConfigBuiltIn = {
      *
      *  https://vike.dev/route
      */
-    route?: string | Function | ImportString;
+    route?: string | RouteAsync | RouteSync | ImportString;
     /** Protect page(s), e.g. forbid unauthorized access.
      *
      *  https://vike.dev/guard
      */
-    guard?: Function | ImportString;
+    guard?: GuardAsync | GuardSync | ImportString;
     /**
      * Whether to pre-render the page(s).
      *
@@ -45,7 +232,7 @@ type ConfigBuiltIn = {
      *
      *  https://vike.dev/onBeforeRender
      */
-    onBeforeRender?: Function | ImportString | null;
+    onBeforeRender?: OnBeforeRenderAsync | OnBeforeRenderSync | ImportString | null;
     /** Determines what pageContext properties are sent to the client-side.
      *
      * https://vike.dev/passToClient
@@ -55,12 +242,12 @@ type ConfigBuiltIn = {
      *
      * https://vike.dev/onRenderClient
      */
-    onRenderClient?: Function | ImportString;
+    onRenderClient?: OnRenderClientAsync | OnRenderClientSync | ImportString;
     /** Hook called when page is rendered to HTML on the server-side.
      *
      * https://vike.dev/onRenderHtml
      */
-    onRenderHtml?: Function | ImportString;
+    onRenderHtml?: OnRenderHtmlAsync | OnRenderHtmlSync | ImportString;
     /** Enable async Route Functions.
      *
      * https://vike.dev/route-function#async
@@ -75,32 +262,32 @@ type ConfigBuiltIn = {
      *
      * https://vike.dev/onPrerenderStart
      */
-    onPrerenderStart?: Function | ImportString;
+    onPrerenderStart?: OnPrerenderStartAsync | OnPrerenderStartSync | ImportString;
     /** Global Hook called before the whole pre-rendering process starts.
      *
      * https://vike.dev/onBeforePrerenderStart
      */
-    onBeforePrerenderStart?: Function | ImportString;
+    onBeforePrerenderStart?: OnBeforePrerenderStartAsync | OnBeforePrerenderStartSync | ImportString;
     /** Hook called before the URL is routed to a page.
      *
      * https://vike.dev/onBeforeRoute
      */
-    onBeforeRoute?: Function | ImportString;
+    onBeforeRoute?: OnBeforeRouteAsync | OnBeforeRouteSync | ImportString;
     /** Hook called after the page is hydrated.
      *
      * https://vike.dev/clientRouting
      */
-    onHydrationEnd?: Function | ImportString;
+    onHydrationEnd?: OnHydrationEndAsync | OnHydrationEndSync | ImportString;
     /** Hook called before the user navigates to a new page.
      *
      * https://vike.dev/clientRouting
      */
-    onPageTransitionStart?: Function | ImportString;
+    onPageTransitionStart?: OnPageTransitionStartAsync | OnPageTransitionStartSync | ImportString;
     /** Hook called after the user navigates to a new page.
      *
      * https://vike.dev/clientRouting
      */
-    onPageTransitionEnd?: Function | ImportString;
+    onPageTransitionEnd?: OnPageTransitionEndAsync | OnPageTransitionEndSync | ImportString;
     /** Whether the UI framework (React/Vue/Solid/...) allows the page's hydration to be aborted.
      *
      * https://vike.dev/clientRouting