vike 0.4.171 → 0.4.172-commit-c1b0884

package/dist/cjs/utils/hasProp.js

@@ -1,23 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.hasProp = void 0;
-// - https://2ality.com/2020/06/type-guards-assertion-functions-typescript.html
-// - https://www.typescriptlang.org/play?#code/GYVwdgxgLglg9mABDAzgFQJ4AcCmdgAUAbgIYA2IOAXIiWBgDSJTbWIDkARnHGTnewCUNUhRzIUibr35gA3AFgAUKEiwEEzLnzFylGnUbNWNdmBABbTjgBOQkXvGpE5q7cUrw0eElRa8hKL6tPRMLLimKFA2MGAA5vaIQU6SUTHxHqreGn6sOskGocYRHOAA1mBwAO5gickSiOWVNZle6r7oeYGOhUbhbGmxcYgAvKVgFdW1wlI8fHSIAN7KiMiExeIjW+OTNeyIgksrq4g2OFAgNkjRlMcAvsdnF1cb+EmOo9v9Hg9KyhAIKK0GhNKajRAAFgATMplCQUChbFACLltIQSEwzJZrHZBIJ-oCZAA6MhwOIEEj4v6eNQ+WgIpEEAFgAAmMHaIImzTAM3hiJsUEkzLZ7SOShOa0QTIQIp8hyelzAx1WUAAFjZqi4cFVEABRGwamwEdgAQQZArpADESDAyEJlHcgA
 const isCallable_js_1 = require("./isCallable.js");
 const isObject_js_1 = require("./isObject.js");
 const isArrayOfStrings_js_1 = require("./isArrayOfStrings.js");
 const isObjectOfStrings_js_1 = require("./isObjectOfStrings.js");
 const isArray_js_1 = require("./isArray.js");
-function hasProp(obj, prop, type = 'unknown') {
+function hasProp(obj, prop, type) {
     if (!(0, isObject_js_1.isObject)(obj))
         return false;
     if (!(prop in obj)) {
         return type === 'undefined';
     }
-    if (type === 'unknown') {
+    if (type === undefined) {
         return true;
     }
     const propValue = obj[prop];
+    if (type === 'undefined') {
+        return propValue === undefined;
+    }
     if (type === 'array') {
         return (0, isArray_js_1.isArray)(propValue);
     }
@@ -39,9 +40,6 @@ function hasProp(obj, prop, type = 'unknown') {
     if (type === 'null') {
         return propValue === null;
     }
-    if (type === 'undefined') {
-        return propValue === undefined;
-    }
     if (type === 'true') {
         return propValue === true;
     }

package/dist/cjs/utils/normalizeHeaders.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeHeaders = void 0;
+function normalizeHeaders(
+/* This type is precise, too precise which can be annoying: e.g. cannot pass a string[][] argument because it doesn't match the more precise [string,string][] type.
+headersOriginal ConstructorParameters<typeof Headers>[0]
+*/
+headersOriginal) {
+    const headersStandard = new Headers(headersOriginal);
+    const headers = Object.fromEntries(headersStandard.entries());
+    return headers;
+}
+exports.normalizeHeaders = normalizeHeaders;

package/dist/cjs/utils/objectAssign.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.objectAssign = void 0;
 // Same as Object.assign() but:
 //  - With type inference
-//  - Preserves property descriptors, which we need for preserving the getters added by addUrlComputedProps()
+//  - Preserves property descriptors, which we need for preserving the getters added by getPageContextUrlComputed()
 function objectAssign(obj, objAddendum) {
     if (objAddendum) {
         Object.defineProperties(obj, Object.getOwnPropertyDescriptors(objAddendum));

package/dist/cjs/utils/objectDefineProperty.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.objectDefineProperty = void 0;
+/** Like Object.defineProperty() but with type inference */
+function objectDefineProperty(obj, prop, { get, ...args }) {
+    Object.defineProperty(obj, prop, { ...args, get });
+}
+exports.objectDefineProperty = objectDefineProperty;

package/dist/cjs/utils/objectKeys.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.objectKeys = exports.objectFromEntries = exports.objectEntries = void 0;
+// export { forEach }
 // https://stackoverflow.com/questions/60141960/typescript-key-value-relation-preserving-object-entries-type/75337277#75337277
 /** Same as Object.entries() but with type inference */
 function objectEntries(obj) {
@@ -19,8 +20,11 @@ function objectKeys(obj) {
     return Object.keys(obj);
 }
 exports.objectKeys = objectKeys;
-/*
-function objectKeys2<T extends Record<string, unknown>>(obj: T): Array<keyof T> {
-  return Object.keys(obj)
+/* Not used yet, but can be quite useful.
+function forEach<Obj extends object>(
+  obj: Obj,
+  iterator: <Key extends keyof Obj>(key: Key, val: Obj[Key]) => void
+): void {
+  Object.entries(obj).forEach(([key, val]) => iterator(key as keyof Obj, val))
 }
-*/
+//*/

package/dist/cjs/utils/projectInfo.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PROJECT_VERSION = exports.projectInfo = void 0;
-const PROJECT_VERSION = '0.4.171';
+const PROJECT_VERSION = '0.4.172-commit-c1b0884';
 exports.PROJECT_VERSION = PROJECT_VERSION;
 const projectInfo = {
     projectName: 'Vike',

package/dist/esm/client/client-routing-runtime/createPageContext.d.ts

@@ -5,12 +5,14 @@ declare function createPageContext(urlOriginal: string): Promise<{
     _urlHandler: null;
     _urlRewrite: null;
     _baseServer: string;
-    _pageFilesAll: import("../../shared/getPageFiles/getPageFileObject.js").PageFile[];
-    _pageConfigs: import("../../shared/page-configs/PageConfig.js").PageConfigRuntime[];
+    _pageFilesAll: import("../../shared/getPageFiles.js").PageFile[];
+    _pageConfigs: import("../../__internal/index.js").PageConfig[];
     _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;
-} & import("../../shared/addUrlComputedProps.js").PageContextUrlComputedPropsClient & {
-    _urlRewrite: string | null;
+} & {
+    urlParsed: import("../../shared/getPageContextUrlComputed.js").Url;
+    urlPathname: string;
+    url: string;
 }>;

package/dist/esm/client/client-routing-runtime/createPageContext.js

@@ -1,9 +1,9 @@
 export { createPageContext };
-import { addUrlComputedProps } from '../../shared/addUrlComputedProps.js';
+import { getPageContextUrlComputed } from '../../shared/getPageContextUrlComputed.js';
 import { getPageFilesAll } from '../../shared/getPageFiles.js';
 import { loadPageRoutes } from '../../shared/route/loadPageRoutes.js';
 import { getBaseServer } from './getBaseServer.js';
-import { assert, isBaseServer, getGlobalObject } from './utils.js';
+import { assert, isBaseServer, getGlobalObject, objectAssign } from './utils.js';
 const globalObject = getGlobalObject('createPageContext.ts', {});
 async function createPageContext(urlOriginal) {
     if (!globalObject.pageFilesData) {
@@ -26,6 +26,7 @@ async function createPageContext(urlOriginal) {
         _pageRoutes: pageRoutes,
         _onBeforeRouteHook: onBeforeRouteHook
     };
-    addUrlComputedProps(pageContext);
+    const pageContextUrlComputed = getPageContextUrlComputed(pageContext);
+    objectAssign(pageContext, pageContextUrlComputed);
     return pageContext;
 }

package/dist/esm/client/client-routing-runtime/getPageContextFromHooks.js

@@ -10,7 +10,7 @@ import { preparePageContextForUserConsumptionClientSide } from '../shared/prepar
 import { removeBuiltInOverrides } from './getPageContext/removeBuiltInOverrides.js';
 import { getPageContextRequestUrl } from '../../shared/getPageContextRequestUrl.js';
 import { getPageConfig } from '../../shared/page-configs/helpers.js';
-import { getConfigValue } from '../../shared/page-configs/getConfigValue.js';
+import { getConfigValueRuntime } from '../../shared/page-configs/getConfigValue.js';
 import { assertOnBeforeRenderHookReturn } from '../../shared/assertOnBeforeRenderHookReturn.js';
 import { executeGuardHook } from '../../shared/route/executeGuardHook.js';
 import { AbortRender, isAbortPageContext } from '../../shared/route/abort.js';
@@ -32,7 +32,9 @@ async function getPageContextFromHooks_isHydration(pageContext) {
         _hasPageContextFromServer: true
     };
     for (const hookName of ['data', 'onBeforeRender']) {
-        const pageContextForHook = { ...pageContext, ...pageContextFromHooks };
+        const pageContextForHook = {};
+        objectAssign(pageContextForHook, pageContext);
+        objectAssign(pageContextForHook, pageContextFromHooks);
         if (hookClientOnlyExists(hookName, pageContextForHook)) {
             const pageContextFromHook = await executeHookClientSide(hookName, pageContextForHook);
             Object.assign(pageContextFromHooks, pageContextFromHook);
@@ -45,6 +47,9 @@ async function getPageContextFromHooks_isNotHydration(pageContext, isErrorPage)
         isHydration: false,
         _hasPageContextFromClient: false
     };
+    const pageContextForCondition = {};
+    objectAssign(pageContextForCondition, pageContext);
+    objectAssign(pageContextForCondition, pageContextFromHooks);
     let hasPageContextFromServer = false;
     // If pageContextInit has some client data or if one of the hooks guard(), data() or onBeforeRender() is server-side
     // only, then we need to fetch pageContext from the server.
@@ -53,7 +58,7 @@ async function getPageContextFromHooks_isNotHydration(pageContext, isErrorPage)
     // For the error page, we cannot fetch pageContext from the server because the pageContext JSON request is based on the URL
     !isErrorPage &&
         // true if pageContextInit has some client data or at least one of the data() and onBeforeRender() hooks is server-side only:
-        (await hasPageContextServer({ ...pageContext, ...pageContextFromHooks }))) {
+        (await hasPageContextServer(pageContextForCondition))) {
         const res = await fetchPageContextFromServer(pageContext);
         if ('is404ServerSideRouted' in res)
             return { is404ServerSideRouted: true };
@@ -70,11 +75,10 @@ async function getPageContextFromHooks_isNotHydration(pageContext, isErrorPage)
     // Note: for the error page, we also execute the client-side data() and onBeforeRender() hooks, but maybe we
     // shouldn't? The server-side does it as well (but maybe it shouldn't).
     for (const hookName of ['guard', 'data', 'onBeforeRender']) {
-        const pageContextForHook = {
-            _hasPageContextFromServer: hasPageContextFromServer,
-            ...pageContext,
-            ...pageContextFromHooks
-        };
+        const pageContextForHook = {};
+        objectAssign(pageContextForHook, { _hasPageContextFromServer: hasPageContextFromServer });
+        objectAssign(pageContextForHook, pageContext);
+        objectAssign(pageContextForHook, pageContextFromHooks);
         if (hookName === 'guard') {
             if (!isErrorPage &&
                 // We don't need to call guard() on the client-side if we fetch pageContext from the server side. (Because the `${url}.pageContext.json` HTTP request will already trigger the routing and guard() hook on the server-side.)
@@ -108,7 +112,7 @@ async function executeHookClientSide(hookName, pageContext) {
         return null;
     }
     const pageContextForUserConsumption = preparePageContextForUserConsumptionClientSide(pageContext, true);
-    const hookResult = await executeHook(() => hook.hookFn(pageContextForUserConsumption), hook);
+    const hookResult = await executeHook(() => hook.hookFn(pageContextForUserConsumption), hook, pageContext);
     const pageContextFromHook = {};
     if (hookName === 'onBeforeRender') {
         assertOnBeforeRenderHookReturn(hookResult, hook.hookFilePath);
@@ -165,7 +169,7 @@ async function hookServerOnlyExists(hookName, pageContext) {
     if (pageContext._pageConfigs.length > 0) {
         // V1
         const pageConfig = getPageConfig(pageContext._pageId, pageContext._pageConfigs);
-        const hookEnv = getConfigValue(pageConfig, `${hookName}Env`)?.value ?? {};
+        const hookEnv = getConfigValueRuntime(pageConfig, `${hookName}Env`)?.value ?? {};
         assert(isObject(hookEnv));
         return !!hookEnv.server && !hookEnv.client;
     }
@@ -189,7 +193,7 @@ function hookClientOnlyExists(hookName, pageContext) {
     if (pageContext._pageConfigs.length > 0) {
         // V1
         const pageConfig = getPageConfig(pageContext._pageId, pageContext._pageConfigs);
-        const hookEnv = getConfigValue(pageConfig, `${hookName}Env`)?.value ?? {};
+        const hookEnv = getConfigValueRuntime(pageConfig, `${hookName}Env`)?.value ?? {};
         assert(isObject(hookEnv));
         return !!hookEnv.client && !hookEnv.server;
     }
@@ -221,7 +225,7 @@ async function fetchPageContextFromServer(pageContext) {
     }
     // Is there a reason for having two different properties? Can't we use only one property? I guess/think the isServerSideError property was an attempt (a bad idea really) for rendering the error page even though an error occured on the server-side (which is a bad idea because the added complexity is non-negligible while the added value is minuscule since the error page usually doesn't have any (meaningful / server-side) hooks).
     if ('serverSideError' in pageContextFromServer || isServerSideError in pageContextFromServer) {
-        throw getProjectError(`The pageContext object couldn't be fetched from the server as an error occurred on the server-side. Check your server logs.`);
+        throw getProjectError(`pageContext couldn't be fetched from server: an error occurred on the server-side (see your server logs)`);
     }
     assert(hasProp(pageContextFromServer, '_pageId', 'string'));
     processPageContextFromServer(pageContextFromServer);

package/dist/esm/client/client-routing-runtime/installClientRouter.js

@@ -7,22 +7,30 @@ import { onLinkClick } from './onLinkClick.js';
 import { setupNativeScrollRestoration } from './scrollRestoration.js';
 import { autoSaveScrollPosition } from './setScrollPosition.js';
 async function installClientRouter() {
-    setupNativeScrollRestoration();
-    initHistoryState();
-    autoSaveScrollPosition();
-    monkeyPatchHistoryPushState();
-    // First initial render
+    // Init navigation history and scroll restoration
+    initHistoryAndScroll();
+    // Render initial page
+    const renderPromise = render();
+    // Intercept <a> clicks
+    onLinkClick();
+    // Preserve stack track
+    await renderPromise;
+}
+function render() {
     assert(getRenderCount() === 0);
-    const promise = renderPageClientSide({
+    const renderPromise = renderPageClientSide({
         scrollTarget: 'preserve-scroll',
         isBackwardNavigation: null,
         isClientSideNavigation: false
     });
     assert(getRenderCount() === 1);
-    // Intercept <a> links
-    onLinkClick();
+    return renderPromise;
+}
+function initHistoryAndScroll() {
+    setupNativeScrollRestoration();
+    initHistoryState();
+    autoSaveScrollPosition();
+    monkeyPatchHistoryPushState();
     // Handle back-/forward navigation
     onBrowserHistoryNavigation();
-    // Only for full stack straces
-    await promise;
 }

package/dist/esm/client/client-routing-runtime/renderPageClientSide.js

@@ -51,7 +51,7 @@ async function renderPageClientSide(renderArgs) {
                     const hook = onPageTransitionStartHook;
                     const { hookFn } = hook;
                     try {
-                        await executeHook(() => hookFn(pageContext), hook);
+                        await executeHook(() => hookFn(pageContext), hook, pageContext);
                     }
                     catch (err) {
                         await onError(err);
@@ -353,7 +353,7 @@ async function renderPageClientSide(renderArgs) {
             if (hook) {
                 const { hookFn } = hook;
                 try {
-                    await executeHook(() => hookFn(pageContext), hook);
+                    await executeHook(() => hookFn(pageContext), hook, pageContext);
                 }
                 catch (err) {
                     await onError(err);
@@ -377,7 +377,7 @@ async function renderPageClientSide(renderArgs) {
             if (hook) {
                 const { hookFn } = hook;
                 try {
-                    await executeHook(() => hookFn(pageContext), hook);
+                    await executeHook(() => hookFn(pageContext), hook, pageContext);
                 }
                 catch (err) {
                     await onError(err);

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

@@ -8,8 +8,8 @@ declare function getPageContext(): Promise<{
     _hasPageContextFromServer: true;
     _hasPageContextFromClient: false;
 } & {
-    _pageFilesAll: import("../../shared/getPageFiles/getPageFileObject.js").PageFile[];
-    _pageConfigs: import("../../shared/page-configs/PageConfig.js").PageConfigRuntime[];
-} & import("../../shared/getPageFiles/getExports.js").PageContextExports & {
-    _pageFilesLoaded: import("../../shared/getPageFiles/getPageFileObject.js").PageFile[];
+    _pageFilesAll: import("../../shared/getPageFiles.js").PageFile[];
+    _pageConfigs: import("../../__internal/index.js").PageConfig[];
+} & import("../../shared/getPageFiles.js").PageContextExports & {
+    _pageFilesLoaded: import("../../shared/getPageFiles.js").PageFile[];
 }>;

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

@@ -12,3 +12,4 @@ export * from '../../utils/parseUrl.js';
 export * from '../../utils/projectInfo.js';
 export * from '../../utils/slice.js';
 export * from '../../utils/unique.js';
+export * from '../../utils/getPropAccessNotation.js';

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

@@ -16,3 +16,4 @@ export * from '../../utils/parseUrl.js';
 export * from '../../utils/projectInfo.js';
 export * from '../../utils/slice.js';
 export * from '../../utils/unique.js'; // Only used by Server Routing (not needed for Client Routing)
+export * from '../../utils/getPropAccessNotation.js';

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

@@ -45,7 +45,7 @@ async function executeOnRenderClientHook(pageContext, isClientRouting) {
     const renderHook = hook.hookFn;
     assert(hookName);
     // We don't use a try-catch wrapper because rendering errors are usually handled by the UI framework. (E.g. React's Error Boundaries.)
-    const hookResult = await executeHook(() => renderHook(pageContextForUserConsumption), hook);
+    const hookResult = await executeHook(() => renderHook(pageContextForUserConsumption), hook, pageContext);
     assertUsage(hookResult === undefined, `The ${hookName}() hook defined by ${hook.hookFilePath} isn't allowed to return a value`);
 }
 function getUrlToShowToUser(pageContext) {

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

@@ -5,7 +5,8 @@ type PageContextForPassToClientWarning = {
     _hasPageContextFromClient: boolean;
 };
 /**
- * - Throw error when pageContext value isn't serializable
- * - Throw error when pageContext prop is missing in passToClient
+ * Throw error when pageContext value isn't:
+ * - serializable, or
+ * - defined.
  */
 declare function getPageContextProxyForUser<PageContext extends Record<string, unknown> & PageContextForPassToClientWarning>(pageContext: PageContext): PageContext;

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

@@ -1,10 +1,11 @@
 export { getPageContextProxyForUser };
-import { assert, assertUsage, assertWarning, getGlobalObject } from '../server-routing-runtime/utils.js';
+import { assert, assertUsage, assertWarning, getGlobalObject, getPropAccessNotation } from '../server-routing-runtime/utils.js';
 import { notSerializable } from '../../shared/notSerializable.js';
 const globalObject = getGlobalObject('getPageContextProxyForUser.ts', {});
 /**
- * - Throw error when pageContext value isn't serializable
- * - Throw error when pageContext prop is missing in passToClient
+ * Throw error when pageContext value isn't:
+ * - serializable, or
+ * - defined.
  */
 function getPageContextProxyForUser(pageContext) {
     assert([true, false].includes(pageContext._hasPageContextFromServer));
@@ -12,66 +13,45 @@ function getPageContextProxyForUser(pageContext) {
     return new Proxy(pageContext, {
         get(_, prop) {
             const val = pageContext[prop];
-            const propName = JSON.stringify(prop);
-            assertUsage(val !== notSerializable, `pageContext[${propName}] couldn't be serialized and, therefore, is missing on the client-side. Check the server logs for more information.`);
-            assertIsDefined(pageContext, prop);
+            const propName = getPropAccessNotation(prop);
+            assertUsage(val !== notSerializable, `pageContext${propName} couldn't be serialized and, therefore, is missing on the client-side. Check the server logs for more information.`);
+            passToClientHint(pageContext, prop, propName);
             return val;
         }
     });
 }
-function assertIsDefined(pageContext, prop) {
-    // We disable assertIsDefined() for the next attempt to read `prop`, because of how Vue's reactivity work. When changing a reactive object:
-    //  - Vue tries to read its old value first. This triggers a `assertIsDefined()` failure if e.g. `pageContextOldReactive.routeParams = pageContextNew.routeParams` and `pageContextOldReactive` has no `routeParams`.
-    //  - Vue seems to read __v_raw before reading the property
-    if (globalObject.prev === prop || globalObject.prev === '__v_raw')
+function passToClientHint(pageContext, prop, propName) {
+    if (handleVueReactivity(prop))
         return;
-    ignoreNextRead(prop);
+    // `prop in pageContext` is the trick we use to know the passToClient value on the client-side, as we set a value to all passToClient props, even `undefined` ones:
+    // ```html
+    // <script id="vike_pageContext" type="application/json">{"pageProps":"!undefined"}</script>
+    // ```
     if (prop in pageContext)
         return;
-    if (isExpected(prop))
+    if (isWhitelisted(prop))
         return;
-    // - If no pageContext was fetchd from the server, then adding props to passToClient is useless.
-    // - Showing a warning, even though no pageContext was fetched from the server, is actually erroneous as the client runtime cannot deduce the passToClient list.
+    // The trick described above (`prop in pageContext`) doesn't work if Vike doesn't fetch any pageContext from the server.
+    // - There would still be some value to show a warning, but it isn't worth it because of the confusion that the first recommendation (adding `prop` to `passToClient`) wouldn't actually remove the warning, and only the second recommendation (using `prop in pageContext` instead of `pageContext[prop]`) would work.
     if (!pageContext._hasPageContextFromServer)
         return;
-    const propName = JSON.stringify(prop);
-    /* This handling would be the clearest but, unfortunately, it's fundamentally problematic:
-     *  - It would force the pageContext value consumer to be synchronized with the pageContext value provider. For example, if vike-react wants to conditionally do something dependening on wehther some optional pageContext value was provided by some optional vike-react-* integration package.
-     *  - If a pageContext value is set by an optional hook, then it's expected that the value is undefined if the hook doesn't exist.
-    const errMsg = `pageContext[${propName}] is \`undefined\` on the client-side. If it's defined on the server-side then add ${propName} to passToClient (https://vike.dev/passToClient), otherwise make sure your client-side hooks always define it (e.g. set it to \`null\` instead of \`undefined\`).`
-    assertUsage(false, errMsg)
-    */
-    if (!pageContext._hasPageContextFromClient) {
-        // We can safely assume that the property is missing in passToClient, because the server-side defines all passToClient properties even if they have an undefined value:
-        // ```
-        // <script id="vike_pageContext" type="application/json">{"_pageId":"/pages/admin","user":"!undefined","pageProps":"!undefined","title":"!undefined","abortReason":"!undefined","_urlRewrite":null}</script>
-        // ```
-        // Note how properties have "!undefined" values => we can tell whether an undefined pageContext value exists in passToClient.
-        assertUsage(false, `pageContext[${propName}] isn't available on the client-side because ${propName} is missing in passToClient, see https://vike.dev/passToClient`);
+    const errMsg = `pageContext${propName} isn't defined on the client-side, see https://vike.dev/passToClient#error`;
+    if (
+    // TODO/next-major-release always make it an error.
+    // - Remove pageContext._hasPageContextFromClient logic (IIRC this is its only use case).
+    pageContext._hasPageContextFromClient) {
+        assertWarning(false, errMsg, { onlyOnce: false, showStackTrace: true });
     }
     else {
-        // Do nothing, not even a warning, because we don't know whether the user expects that the pageContext value can be undefined. (E.g. a pageContext value that is defined by an optional hook.)
-        // TODO/next-major-release make it an assertUsage()
-        assertWarning(false, [
-            `pageContext[${propName}] isn't defined on the client-side:`,
-            `1. if it's defined by the server-side then add ${propName} to passToClient (https://vike.dev/passToClient), or`,
-            `2. if it's expected that it may not be defined:`,
-            '   ```js',
-            '   // ❌ Replace code like this:',
-            `   const val = pageContext[${propName}] ?? someDefaultValue`,
-            '   // ✅ With that:',
-            `   const val = ${propName} in pageContext ? pageContext[${propName}] : someDefaultValue`,
-            '   ```',
-            `See stack track below to find where pageContext[${propName}] is being accessed.`
-        ].join('\n'), { showStackTrace: true, onlyOnce: false });
+        assertUsage(false, errMsg);
     }
 }
-const IGNORE_LIST = [
+const WHITELIST = [
     'then',
-    'toJSON' // Vue tries to get `toJSON`
+    'toJSON' // Vue triggers `toJSON`
 ];
-function isExpected(prop) {
-    if (IGNORE_LIST.includes(prop))
+function isWhitelisted(prop) {
+    if (WHITELIST.includes(prop))
         return true;
     if (typeof prop === 'symbol')
         return true; // Vue tries to access some symbols
@@ -81,9 +61,16 @@ function isExpected(prop) {
         return true; // Vue internals upon `reactive(pageContext)`
     return false;
 }
-function ignoreNextRead(prop) {
+// Handle Vue's reactivity.
+// When changing a reactive object:
+// - Vue tries to read its old value first. This triggers a `assertIsDefined()` failure if e.g. `pageContextReactive.routeParams = pageContextNew.routeParams` and `pageContextReactive` has no `routeParams`.
+// - Vue seems to read __v_raw before reading the property.
+function handleVueReactivity(prop) {
+    if (globalObject.prev === prop || globalObject.prev === '__v_raw')
+        return true;
     globalObject.prev = prop;
     window.setTimeout(() => {
         globalObject.prev = undefined;
     }, 0);
+    return false;
 }

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

@@ -3,6 +3,7 @@ export { isErrorFetchingStaticAssets };
 import { getPageFilesClientSide, getPageContextExports } from '../../shared/getPageFiles.js';
 import { findPageConfig } from '../../shared/page-configs/findPageConfig.js';
 import { loadConfigValues } from '../../shared/page-configs/loadConfigValues.js';
+import { objectAssign } from '../server-routing-runtime/utils.js';
 const stamp = '__whileFetchingAssets';
 async function loadUserFilesClientSide(pageId, pageFilesAll, pageConfigs) {
     const pageFilesClientSide = getPageFilesClientSide(pageFilesAll, pageId);
@@ -29,10 +30,9 @@ async function loadUserFilesClientSide(pageId, pageFilesAll, pageConfigs) {
         throw err;
     }
     const pageContextExports = getPageContextExports(pageFilesClientSide, pageConfigLoaded);
-    const pageContextAddendum = {
-        ...pageContextExports,
-        _pageFilesLoaded: pageFilesClientSide
-    };
+    const pageContextAddendum = {};
+    objectAssign(pageContextAddendum, pageContextExports);
+    objectAssign(pageContextAddendum, { _pageFilesLoaded: pageFilesClientSide });
     return pageContextAddendum;
 }
 function isErrorFetchingStaticAssets(err) {

package/dist/esm/node/plugin/index.js

@@ -24,9 +24,12 @@ import { baseUrls } from './plugins/baseUrls.js';
 import { envVarsPlugin } from './plugins/envVars.js';
 import pc from '@brillout/picocolors';
 import { fileEnv } from './plugins/fileEnv.js';
+import { setResolveClientEntriesDev } from '../runtime/renderPage/getPageAssets.js';
+import { resolveClientEntriesDev } from './resolveClientEntriesDev.js';
 assertNodeEnv_onVikePluginLoad();
 markEnvAsVikePluginLoaded();
 assertViteVersion();
+setResolveClientEntriesDev(resolveClientEntriesDev);
 // Return as `any` to avoid Plugin type mismatches when there are multiple Vite versions installed
 function plugin(vikeConfig) {
     const plugins = [

package/dist/esm/node/plugin/plugins/buildConfig.js

@@ -4,19 +4,18 @@ export { analyzeClientEntries };
 export { manifestTempFile };
 import { assert, resolveOutDir, viteIsSSR, addOnBeforeLogHook, removeFileExtention, unique, assertUsage, injectRollupInputs, normalizeRollupInput, getOutDirs, assertNodeEnv_build, assertIsNpmPackageImport } from '../utils.js';
 import { getVikeConfig, isV1Design } from './importUserCode/v1-design/getVikeConfig.js';
-import { getConfigValue } from '../../../shared/page-configs/getConfigValue.js';
 import { findPageFiles } from '../shared/findPageFiles.js';
 import { getConfigVike } from '../../shared/getConfigVike.js';
 import { getVirtualFileIdPageConfigValuesAll } from '../../shared/virtual-files/virtualFilePageConfigValuesAll.js';
 import { extractAssetsAddQuery } from '../../shared/extractAssetsQuery.js';
 import { createRequire } from 'module';
-import { getClientEntry } from '../../shared/getClientEntry.js';
 import fs from 'fs/promises';
 import path from 'path';
 import { fixServerAssets, fixServerAssets_isEnabled } from './buildConfig/fixServerAssets.js';
 import { set_constant_ASSETS_MAP } from './importBuild/index.js';
 import { prependEntriesDir } from '../../shared/prependEntriesDir.js';
 import { getFilePathResolved } from '../shared/getFilePath.js';
+import { getConfigValueBuildTime } from '../../../shared/page-configs/getConfigValueBuildTime.js';
 // @ts-ignore Shimmed by dist-cjs-fixup.js for CJS build.
 const importMetaUrl = import.meta.url;
 const require_ = createRequire(importMetaUrl);
@@ -152,7 +151,7 @@ function analyzeClientEntries(pageConfigs, config) {
     let clientEntries = {};
     let clientEntryList = [];
     pageConfigs.forEach((pageConfig) => {
-        const configValue = getConfigValue(pageConfig, 'clientRouting', 'boolean');
+        const configValue = getConfigValueBuildTime(pageConfig, 'clientRouting', 'boolean');
         if (configValue?.value) {
             hasClientRouting = true;
         }
@@ -165,7 +164,7 @@ function analyzeClientEntries(pageConfigs, config) {
             clientEntries[entryName] = entryTarget;
         }
         {
-            const clientEntry = getClientEntry(pageConfig);
+            const clientEntry = getConfigValueBuildTime(pageConfig, 'client', 'string')?.value ?? null;
             if (clientEntry) {
                 clientEntryList.push(clientEntry);
             }

package/dist/esm/node/plugin/plugins/config/index.js

@@ -20,15 +20,16 @@ async function getConfigVikPromise(vikeConfig, config) {
     const fromPluginOptions = (vikeConfig ?? {});
     const fromViteConfig = (config.vike ?? {});
     const configs = [fromPluginOptions, fromViteConfig];
-    const { globalVikeConfig: fromPlusConfigFile } = await getVikeConfig(config, isDev2(config));
+    assertVikeConfig(fromViteConfig, ({ prop, errMsg }) => `vite.config.js#vike.${prop} ${errMsg}`);
+    // TODO/v1-release: deprecate this
+    assertVikeConfig(fromPluginOptions, ({ prop, errMsg }) => `vite.config.js > vike option ${prop} ${errMsg}`);
+    const crawlWithGit = fromPluginOptions.crawl?.git ?? null;
+    const { globalVikeConfig: fromPlusConfigFile } = await getVikeConfig(config, isDev2(config), { crawlWithGit });
     configs.push(fromPlusConfigFile);
     assertVikeConfig(fromPlusConfigFile, ({ prop, errMsg }) => {
         // TODO: add config file path ?
         return `config ${pc.cyan(prop)} ${errMsg}`;
     });
-    assertVikeConfig(fromViteConfig, ({ prop, errMsg }) => `vite.config.js#vike.${prop} ${errMsg}`);
-    // TODO/v1-release: deprecate this
-    assertVikeConfig(fromPluginOptions, ({ prop, errMsg }) => `vite.config.js > vike option ${prop} ${errMsg}`);
     const { baseServer, baseAssets } = resolveBase(configs, config);
     const configVike = {
         disableAutoFullBuild: pickFirst(configs.map((c) => c.disableAutoFullBuild)) ?? null,
@@ -38,7 +39,10 @@ async function getConfigVikPromise(vikeConfig, config) {
         baseAssets,
         redirects: merge(configs.map((c) => c.redirects)) ?? {},
         disableUrlNormalization: pickFirst(configs.map((c) => c.disableUrlNormalization)) ?? false,
-        trailingSlash: pickFirst(configs.map((c) => c.trailingSlash)) ?? false
+        trailingSlash: pickFirst(configs.map((c) => c.trailingSlash)) ?? false,
+        crawl: {
+            git: crawlWithGit
+        }
     };
     return configVike;
 }