vike 0.4.225 → 0.4.226-commit-a0035ee

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

@@ -1,4 +1,5 @@
 export { modifyUrl };
+import { type ModifyUrlSameOriginOptions } from './modifyUrlSameOrigin.js';
 /**
  * Modify a URL.
  *
@@ -6,8 +7,7 @@ export { modifyUrl };
  *
  * https://vike.dev/modifyUrl
  */
-declare function modifyUrl(url: string, modify: {
-    pathname?: string;
+declare function modifyUrl(url: string, modify: ModifyUrlSameOriginOptions & {
     hostname?: string;
     port?: number;
     protocol?: string;

package/dist/esm/shared/modifyUrl.js

@@ -1,4 +1,5 @@
 export { modifyUrl };
+import { modifyUrlSameOrigin } from './modifyUrlSameOrigin.js';
 import { createUrlFromComponents, parseUrl } from './utils.js';
 /**
  * Modify a URL.
@@ -8,9 +9,8 @@ import { createUrlFromComponents, parseUrl } from './utils.js';
  * https://vike.dev/modifyUrl
  */
 function modifyUrl(url, modify) {
+    url = modifyUrlSameOrigin(url, modify);
     const urlParsed = parseUrl(url, '/');
-    // Pathname
-    const pathname = modify.pathname ?? urlParsed.pathname;
     // Origin
     const originParts = [
         modify.protocol ?? urlParsed.protocol ?? '',
@@ -21,8 +21,6 @@ function modifyUrl(url, modify) {
         originParts.push(`:${port}`);
     }
     const origin = originParts.join('');
-    const urlModified = createUrlFromComponents(origin, pathname, 
-    // Should we also support modifying search and hash?
-    urlParsed.searchOriginal, urlParsed.hashOriginal);
+    const urlModified = createUrlFromComponents(origin, urlParsed.pathname, urlParsed.searchOriginal, urlParsed.hashOriginal);
     return urlModified;
 }

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

@@ -0,0 +1,9 @@
+export { modifyUrlSameOrigin };
+export { ModifyUrlSameOriginOptions };
+type ModifyUrlSameOriginOptions = {
+    hash?: string | null;
+    search?: Search | null;
+    pathname?: string;
+};
+type Search = Record<string, string | null> | URLSearchParams;
+declare function modifyUrlSameOrigin(url: string, modify: ModifyUrlSameOriginOptions): string;

package/dist/esm/shared/modifyUrlSameOrigin.js

@@ -0,0 +1,40 @@
+export { modifyUrlSameOrigin };
+import { createUrlFromComponents, isNotNullish_keyVal, parseUrl, objectFilter, assertUsageUrlPathnameAbsolute } from './utils.js';
+function modifyUrlSameOrigin(url, modify) {
+    const urlParsed = parseUrl(url, '/');
+    // Pathname
+    const pathname = modify.pathname ?? urlParsed.pathnameOriginal;
+    assertUsageUrlPathnameAbsolute(pathname, 'modify.pathname');
+    // Search
+    let search = modify.search === null ? '' : !modify.search ? urlParsed.searchOriginal : resolveSearch(urlParsed, modify.search);
+    if (search === '?')
+        search = '';
+    // Hash
+    let hash;
+    if (modify.hash === null) {
+        hash = '';
+    }
+    else if (modify.hash === undefined) {
+        hash = urlParsed.hashOriginal ?? '';
+    }
+    else {
+        hash = modify.hash;
+        if (!hash.startsWith('#'))
+            hash = '#' + hash;
+    }
+    const urlModified = createUrlFromComponents(urlParsed.origin, pathname, search, hash);
+    return urlModified;
+}
+function resolveSearch(urlParsed, search) {
+    let searchParams;
+    if (search instanceof URLSearchParams) {
+        // Overwrite
+        searchParams = search;
+    }
+    else {
+        // Merge
+        const searchMap = objectFilter({ ...urlParsed.search, ...search }, (isNotNullish_keyVal));
+        searchParams = new URLSearchParams(searchMap);
+    }
+    return '?' + searchParams.toString();
+}

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

@@ -299,13 +299,15 @@ type ConfigBuiltIn = {
         /**
          * Whether to enable pre-rendering.
          *
-         * Setting `value: null` enables you to set prerender settings without activating pre-rendering. (Useful for Vike extensions.)
+         * Setting `enable: null` enables you to set prerender settings without enabling pre-rendering by default.
          *
-         * https://vike.dev/prerender#value
+         * This is useful, for example, if you want pre-rendering to stay opt-in instead of opt-out while setting pre-render settings globally.
+         *
+         * https://vike.dev/prerender#enable
          *
          * @default true
          */
-        value?: boolean | null;
+        enable?: boolean | null;
     };
     /**
      * Install Vike extensions.
@@ -489,6 +491,12 @@ type ConfigBuiltIn = {
      * https://vike.dev/port
      */
     port?: number;
+    /**
+     * Set the mode to run in.
+     *
+     * https://vike.dev/mode
+     */
+    mode?: string;
     /** Where scripts are injected in the HTML.
      *
      * https://vike.dev/injectScriptsAt

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

@@ -92,12 +92,12 @@ type ConfigValueSources = Record<string, // configName
 ConfigValueSource[]>;
 type ConfigValueSource = {
     configEnv: ConfigEnvInternal;
-    definedAtFilePath: DefinedAtFilePath | DefinedBy;
+    definedAt: DefinedAtFilePath | DefinedBy;
     plusFile: PlusFile | null;
     locationId: LocationId;
     /** Wether the config value is loaded at runtime, for example config.Page or config.onBeforeRender */
     valueIsLoadedWithImport: boolean;
-    /** Whether the config value is a file path, for example config.client */
+    /** Whether the config value is a file path, this is currently only true for +client */
     valueIsFilePath?: true;
     /** Whether the config value is defined by a +{configName}.js file */
     valueIsDefinedByPlusValueFile: boolean;

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

@@ -1,11 +1,13 @@
 export { getConfigDefinedAt };
 export { getConfigDefinedAtOptional };
 export { getDefinedAtString };
+export { getDefinedByString };
 export type { ConfigDefinedAt };
 export type { ConfigDefinedAtOptional };
-import type { DefinedAtData } from './PageConfig.js';
+import type { DefinedAtData, DefinedBy } from './PageConfig.js';
 type ConfigDefinedAtOptional = ConfigDefinedAt | `Config ${string} defined internally`;
 type ConfigDefinedAt = `Config ${string} defined at ${string}`;
 declare function getConfigDefinedAt<SentenceBegin extends 'Config' | 'config', ConfigName extends string>(sentenceBegin: SentenceBegin, configName: ConfigName, definedAtData: NonNullable<DefinedAtData>): `${SentenceBegin} ${ConfigName} defined at ${string}`;
 declare function getConfigDefinedAtOptional<SentenceBegin extends 'Config' | 'config', ConfigName extends string>(sentenceBegin: SentenceBegin, configName: ConfigName, definedAtData: DefinedAtData): `${SentenceBegin} ${ConfigName} defined ${'internally' | `at ${string}`}`;
 declare function getDefinedAtString(definedAtData: NonNullable<DefinedAtData>, configName: string): string;
+declare function getDefinedByString(definedAt: DefinedBy, configName: string): `API call dev({ vikeConfig: { ${string} } })` | `API call build({ vikeConfig: { ${string} } })` | `API call preview({ vikeConfig: { ${string} } })` | `API call prerender({ vikeConfig: { ${string} } })` | `CLI option --${string}` | `environment variable VIKE_CONFIG="{${string}}"`;

package/dist/esm/shared/page-configs/getConfigDefinedAt.js

@@ -1,6 +1,7 @@
 export { getConfigDefinedAt };
 export { getConfigDefinedAtOptional };
 export { getDefinedAtString };
+export { getDefinedByString };
 import { assert, checkType, isArray } from '../utils.js';
 import pc from '@brillout/picocolors';
 import { getExportPath } from './getExportPath.js';
@@ -44,14 +45,14 @@ function getDefinedAtString(definedAtData, configName) {
 }
 function getDefinedByString(definedAt, configName) {
     if (definedAt.definedBy === 'api') {
-        return `API call ${pc.cyan(`${definedAt.operation}({${configName}})`)}`;
+        return `API call ${pc.cyan(`${definedAt.operation}({ vikeConfig: { ${configName} } })`)}`;
     }
     const { definedBy } = definedAt;
     if (definedBy === 'cli') {
         return `CLI option ${pc.cyan(`--${configName}`)}`;
     }
     if (definedBy === 'env') {
-        return `environment variable ${pc.cyan(`VIKE_OPTIONS="{${configName}}"`)}`;
+        return `environment variable ${pc.cyan(`VIKE_CONFIG="{${configName}}"`)}`;
     }
     checkType(definedBy);
     assert(false);

package/dist/esm/shared/page-configs/getConfigValueBuildTime.js

@@ -56,11 +56,11 @@ function mergeCumulative(configValueSources) {
     return { value, definedAtData };
 }
 function getDefinedAt(configValueSource) {
-    const { definedAtFilePath } = configValueSource;
-    if (definedAtFilePath.definedBy)
-        return definedAtFilePath;
+    const { definedAt } = configValueSource;
+    if (definedAt.definedBy)
+        return definedAt;
     return {
-        filePathToShowToUser: definedAtFilePath.filePathToShowToUser,
-        fileExportPathToShowToUser: definedAtFilePath.fileExportPathToShowToUser
+        filePathToShowToUser: definedAt.filePathToShowToUser,
+        fileExportPathToShowToUser: definedAt.fileExportPathToShowToUser
     };
 }

package/dist/esm/shared/page-configs/serialize/serializeConfigValues.js

@@ -47,7 +47,7 @@ function serializeConfigValues(pageConfig, importStatements, filesEnv, isEnvMatc
 function getValueSerializedFromSource(configValueSource, configName, importStatements, filesEnv) {
     let valueData;
     if (configValueSource.valueIsLoaded && !configValueSource.valueIsLoadedWithImport) {
-        valueData = getValueSerializedWithJson(configValueSource.value, configName, configValueSource.definedAtFilePath, importStatements, filesEnv, configValueSource.configEnv);
+        valueData = getValueSerializedWithJson(configValueSource.value, configName, configValueSource.definedAt, importStatements, filesEnv, configValueSource.configEnv);
     }
     else {
         valueData = getValueSerializedWithImport(configValueSource, importStatements, filesEnv, configName);
@@ -98,9 +98,9 @@ function serializeConfigValue(configValueBase, valueData, configName, lines, tab
 }
 function getValueSerializedWithImport(configValueSource, importStatements, filesEnv, configName) {
     assert(!configValueSource.valueIsFilePath);
-    const { valueIsDefinedByPlusValueFile, definedAtFilePath, configEnv } = configValueSource;
-    assert(!definedAtFilePath.definedBy);
-    const { filePathAbsoluteVite, fileExportName } = definedAtFilePath;
+    const { valueIsDefinedByPlusValueFile, definedAt, configEnv } = configValueSource;
+    assert(!definedAt.definedBy);
+    const { filePathAbsoluteVite, fileExportName } = definedAt;
     if (valueIsDefinedByPlusValueFile)
         assert(fileExportName === undefined);
     const { importName } = addImportStatement(importStatements, filePathAbsoluteVite, fileExportName || '*', filesEnv, configEnv, configName);
@@ -227,12 +227,12 @@ function getConfigValuesBase(pageConfig, isEnvMatch, isEager) {
     return [...fromComputed, ...fromSources].filter((r) => r !== 'SKIP');
 }
 function getDefinedAtFileSource(source) {
-    const { definedAtFilePath } = source;
-    if (definedAtFilePath.definedBy)
-        return definedAtFilePath;
+    const { definedAt } = source;
+    if (definedAt.definedBy)
+        return definedAt;
     const definedAtFile = {
-        filePathToShowToUser: definedAtFilePath.filePathToShowToUser,
-        fileExportPathToShowToUser: definedAtFilePath.fileExportPathToShowToUser
+        filePathToShowToUser: definedAt.filePathToShowToUser,
+        fileExportPathToShowToUser: definedAt.fileExportPathToShowToUser
     };
     return definedAtFile;
 }

package/dist/esm/shared/route/abort.d.ts

@@ -100,9 +100,9 @@ declare function logAbortErrorHandled(err: ErrorAbort, isProduction: boolean, pa
 }): void;
 type PageContextFromRewrite = {
     _urlRewrite: string;
-} & Record<string, unknown>;
+};
 type PageContextFromAllRewrites = {
     _urlRewrite: null | string;
-} & Record<string, unknown>;
+};
 declare function getPageContextFromAllRewrites(pageContextsFromRewrite: PageContextFromRewrite[]): PageContextFromAllRewrites;
 declare function assertNoInfiniteAbortLoop(rewriteCount: number, redirectCount: number): void;

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

@@ -138,8 +138,27 @@ type PageContextBuiltInCommon<Data> = {
      */
     isBaseMissing?: true;
 };
-type PageContextBuiltInServer<Data> = PageContextBuiltInCommon<Data> & PageContextUrlServer;
-type PageContextBuiltInClientWithClientRouting<Data> = Partial<PageContextBuiltInCommon<Data>> & Pick<PageContextBuiltInCommon<Data>, 'Page' | 'routeParams' | 'pageExports' | 'config' | 'configEntries' | 'exports' | 'exportsAll' | 'abortReason' | 'data' | 'pageId' | 'source' | 'sources' | 'from'> & {
+type PageContextBuiltInServer<Data> = PageContextBuiltInCommon<Data> & PageContextUrlServer & {
+    /**
+     * Whether the page is being rendered on the client-side, or rendered on the server-side / pre-rendered.
+     *
+     * In order to save client-side KBs, we recommend using `import.meta.env.SSR` whenever possible instead, see https://vike.dev/pageContext
+     */
+    isClientSide: false;
+    /**
+     * Whether the page is being pre-rendered.
+     *
+     * The value is always `false` in development.
+     *
+     * https://vike.dev/pre-rendering
+     * https://vike.dev/pageContext
+     */
+    isPrerendering: boolean;
+    isHydration?: undefined;
+    isBackwardNavigation?: undefined;
+    previousPageContext?: undefined;
+};
+type PageContextBuiltInClientWithClientRouting<Data> = Partial<PageContextBuiltInCommon<Data>> & Pick<PageContextBuiltInCommon<Data>, 'Page' | 'routeParams' | 'pageExports' | 'config' | 'configEntries' | 'exports' | 'exportsAll' | 'abortReason' | 'data' | 'pageId' | 'source' | 'sources' | 'from'> & PageContextClientCommon & {
     /** Whether the current page is already rendered to HTML */
     isHydration: boolean;
     /**
@@ -155,7 +174,7 @@ type PageContextBuiltInClientWithClientRouting<Data> = Partial<PageContextBuiltI
      */
     previousPageContext: PageContextClient<Data> | null;
 } & PageContextUrlClient;
-type PageContextBuiltInClientWithServerRouting<Data> = Partial<PageContextBuiltInCommon<Data>> & Pick<PageContextBuiltInCommon<Data>, 'Page' | 'pageExports' | 'exports' | 'abortReason' | 'pageId' | 'data'> & {
+type PageContextBuiltInClientWithServerRouting<Data> = Partial<PageContextBuiltInCommon<Data>> & Pick<PageContextBuiltInCommon<Data>, 'Page' | 'pageExports' | 'exports' | 'abortReason' | 'pageId' | 'data'> & PageContextClientCommon & {
     /**
      * Whether the current page is already rendered to HTML.
      *
@@ -169,6 +188,23 @@ type PageContextBuiltInClientWithServerRouting<Data> = Partial<PageContextBuiltI
      */
     isBackwardNavigation: null;
 };
+type PageContextClientCommon = {
+    /**
+     * Whether the page is being rendered on the client-side, or rendered on the server-side / pre-rendered.
+     *
+     * In order to save client-side KBs, we recommend using `import.meta.env.SSR` whenever possible instead, see https://vike.dev/pageContext
+     */
+    isClientSide: true;
+    /**
+     * Whether the page is being pre-rendered.
+     *
+     * The value is always `false` in development.
+     *
+     * https://vike.dev/pre-rendering
+     * https://vike.dev/pageContext
+     */
+    isPrerendering: false;
+};
 /** For Vike internal use */
 type PageContextBuiltInServerInternal = Omit<PageContextBuiltInCommon<unknown> & PageContextUrlInternal, 'data'>;
 /** @deprecated

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

@@ -10,7 +10,7 @@ export * from '../utils/isBrowser.js';
 export * from '../utils/hasProp.js';
 export * from '../utils/isPlainObject.js';
 export * from '../utils/compareString.js';
-export * from '../utils/isNotNullish.js';
+export * from '../utils/isNullish.js';
 export * from '../utils/stringifyStringArray.js';
 export * from '../utils/cast.js';
 export * from '../utils/isPropertyGetter.js';
@@ -22,3 +22,4 @@ export * from '../utils/isArray.js';
 export * from '../utils/changeEnumerable.js';
 export * from '../utils/objectDefineProperty.js';
 export * from '../utils/isScriptFile.js';
+export * from '../utils/objectFilter.js';

package/dist/esm/shared/utils.js

@@ -14,7 +14,7 @@ export * from '../utils/isBrowser.js';
 export * from '../utils/hasProp.js';
 export * from '../utils/isPlainObject.js';
 export * from '../utils/compareString.js';
-export * from '../utils/isNotNullish.js';
+export * from '../utils/isNullish.js';
 export * from '../utils/stringifyStringArray.js';
 export * from '../utils/cast.js';
 export * from '../utils/isPropertyGetter.js';
@@ -26,3 +26,4 @@ export * from '../utils/isArray.js';
 export * from '../utils/changeEnumerable.js';
 export * from '../utils/objectDefineProperty.js';
 export * from '../utils/isScriptFile.js';
+export * from '../utils/objectFilter.js';

package/dist/esm/types/index.d.ts

@@ -3,7 +3,6 @@ export type { PageContextServer } from '../shared/types.js';
 export type { PageContextClient } from '../shared/types.js';
 export type { PageContextWithServerRouting } from '../shared/types.js';
 export type { PageContextClientWithServerRouting } from '../shared/types.js';
-export type { ConfigVitePluginServerEntry } from '@brillout/vite-plugin-server-entry/plugin';
 export type { PageContextBuiltInServer } from '../shared/types.js';
 export type { PageContextBuiltInClientWithClientRouting } from '../shared/types.js';
 export type { PageContextBuiltInClientWithServerRouting } from '../shared/types.js';

package/dist/esm/utils/PROJECT_VERSION.d.ts

@@ -1 +1 @@
-export declare const PROJECT_VERSION: "0.4.225";
+export declare const PROJECT_VERSION: "0.4.226-commit-a0035ee";

package/dist/esm/utils/PROJECT_VERSION.js

@@ -1,2 +1,2 @@
 // Automatically updated by @brillout/release-me
-export const PROJECT_VERSION = '0.4.225';
+export const PROJECT_VERSION = '0.4.226-commit-a0035ee';

package/dist/esm/utils/assert.d.ts

@@ -10,8 +10,9 @@ export { isBug };
 export { setAlwaysShowStackTrace };
 type Logger = (msg: string | Error, logType: 'warn' | 'info') => void;
 declare function assert(condition: unknown, debugInfo?: unknown): asserts condition;
-declare function assertUsage(condition: unknown, errMsg: string, { showStackTrace }?: {
+declare function assertUsage(condition: unknown, errMsg: string, { showStackTrace, exitOnError }?: {
     showStackTrace?: true;
+    exitOnError?: boolean;
 }): asserts condition;
 declare function getProjectError(errMsg: string): Error;
 declare function assertWarning(condition: unknown, msg: string, { onlyOnce, showStackTrace }: {

package/dist/esm/utils/assert.js

@@ -42,7 +42,7 @@ function assert(condition, debugInfo) {
         const debugInfoSerialized = typeof debugInfo === 'string' ? debugInfo : JSON.stringify(debugInfo);
         return pc.dim(`Debug info (for Vike maintainers; you can ignore this): ${debugInfoSerialized}`);
     })();
-    const link = pc.blue('https://github.com/vikejs/vike/issues/new?template=bug.yml');
+    const link = pc.underline('https://github.com/vikejs/vike/issues/new?template=bug.yml');
     let errMsg = [
         `You stumbled upon a Vike bug. Go to ${link} and copy-paste this error. A maintainer will fix the bug (usually within 24 hours).`,
         debugStr
@@ -56,7 +56,7 @@ function assert(condition, debugInfo) {
     globalObject.onBeforeLog?.();
     throw internalError;
 }
-function assertUsage(condition, errMsg, { showStackTrace } = {}) {
+function assertUsage(condition, errMsg, { showStackTrace, exitOnError } = {}) {
     if (condition)
         return;
     showStackTrace = showStackTrace || globalObject.alwaysShowStackTrace;
@@ -68,7 +68,13 @@ function assertUsage(condition, errMsg, { showStackTrace } = {}) {
         globalObject.showStackTraceList.add(usageError);
     }
     globalObject.onBeforeLog?.();
-    throw usageError;
+    if (!exitOnError) {
+        throw usageError;
+    }
+    else {
+        console.error(showStackTrace ? usageError : errMsg);
+        process.exit(1);
+    }
 }
 function getProjectError(errMsg) {
     errMsg = addWhitespace(errMsg);
@@ -182,6 +188,7 @@ function overwriteAssertProductionLogger(logger) {
 function isBug(err) {
     return String(err).includes(`[${bugTag}]`);
 }
+// Called upon `DEBUG=vike:error`
 function setAlwaysShowStackTrace() {
     globalObject.alwaysShowStackTrace = true;
 }

package/dist/esm/utils/assertSetup.d.ts

@@ -2,19 +2,19 @@ export { assertIsNotProductionRuntime };
 export { onSetupRuntime };
 export { onSetupBuild };
 export { onSetupPrerender };
+export { onSetupPreview };
 export { setNodeEnvProduction };
 export { markSetup_viteDevServer };
 export { markSetup_vitePreviewServer };
 export { markSetup_vikeVitePlugin };
 export { markSetup_isViteDev };
-export { markSetup_isPrerendering };
 declare function assertIsNotProductionRuntime(): void | undefined;
 declare function onSetupRuntime(): void | undefined;
 declare function onSetupBuild(): void;
 declare function onSetupPrerender(): void;
+declare function onSetupPreview(): void;
 declare function markSetup_viteDevServer(): void | undefined;
 declare function markSetup_vitePreviewServer(): void | undefined;
 declare function markSetup_vikeVitePlugin(): void;
 declare function markSetup_isViteDev(isViteDev: boolean): void;
-declare function markSetup_isPrerendering(): void;
 declare function setNodeEnvProduction(): void | undefined;

package/dist/esm/utils/assertSetup.js

@@ -2,12 +2,12 @@ export { assertIsNotProductionRuntime };
 export { onSetupRuntime };
 export { onSetupBuild };
 export { onSetupPrerender };
+export { onSetupPreview };
 export { setNodeEnvProduction };
 export { markSetup_viteDevServer };
 export { markSetup_vitePreviewServer };
 export { markSetup_vikeVitePlugin };
 export { markSetup_isViteDev };
-export { markSetup_isPrerendering };
 import { assert, assertUsage, assertWarning } from './assert.js';
 import { assertIsNotBrowser } from './assertIsNotBrowser.js';
 import { createDebugger } from './debug.js';
@@ -29,7 +29,7 @@ function onSetupRuntime() {
     if (isTest())
         return;
     assertNodeEnvIsNotUndefinedString();
-    if (!isViteLoaded()) {
+    if (!setup.viteDevServer && setup.isViteDev === undefined) {
         // TODO: make it assertUsage() again once https://github.com/vikejs/vike/issues/1528 is implemented.
         assertWarning(!isNodeEnvDev(), `The ${getEnvDescription()}, which is contradictory because the environment seems to be a production environment (Vite isn't loaded), see https://vike.dev/NODE_ENV`, { onlyOnce: true });
         assertUsage(!setup.vikeVitePlugin, `Loading Vike's Vite plugin (the ${pc.cyan('vike/plugin')} module) is prohibited in production.`);
@@ -37,11 +37,10 @@ function onSetupRuntime() {
         assert(!setup.shouldNotBeProduction);
     }
     else {
-        if (!setup.vitePreviewServer && !setup.isPrerendering) {
+        if (!setup.isPreview && !setup.vitePreviewServer && !setup.isPrerendering) {
             // TODO: make it assertUsage() again once https://github.com/vikejs/vike/issues/1528 is implemented.
             assertWarning(isNodeEnvDev(), `The ${getEnvDescription()}, but Vite is loaded which is prohibited in production, see https://vike.dev/NODE_ENV`, { onlyOnce: true });
         }
-        // These two assert() calls aren't that interesting
         assert(setup.vikeVitePlugin);
         assert(setup.shouldNotBeProduction);
     }
@@ -58,15 +57,16 @@ function onSetupBuild() {
     setNodeEnvProduction()
     */
 }
+// Called by ../node/prerender/runPrerender.ts
 function onSetupPrerender() {
     markSetup_isPrerendering();
     if (getNodeEnv())
         assertUsageNodeEnvIsNotDev('pre-rendering');
     setNodeEnvProduction();
 }
-function isViteLoaded() {
-    // Do we need setup.viteDevServer or setup.vitePreviewServer ?
-    return setup.viteDevServer || setup.vitePreviewServer || setup.isViteDev !== undefined;
+// Called by ../node/api/preview.ts
+function onSetupPreview() {
+    markSetup_isPreview();
 }
 function isTest() {
     return isVitest() || isNodeEnv('test');
@@ -95,12 +95,16 @@ function markSetup_isViteDev(isViteDev) {
         debug('markSetup_isViteDev()', new Error().stack);
     setup.isViteDev = isViteDev;
 }
-// Called by ../node/prerender/runPrerender.ts
 function markSetup_isPrerendering() {
     if (debug.isActivated)
         debug('markSetup_isPrerendering()', new Error().stack);
     setup.isPrerendering = true;
 }
+function markSetup_isPreview() {
+    if (debug.isActivated)
+        debug('markSetup_isPreview()', new Error().stack);
+    setup.isPreview = true;
+}
 function assertUsageNodeEnvIsNotDev(operation) {
     if (!isNodeEnvDev())
         return;

package/dist/esm/utils/assertSingleInstance.js

@@ -11,13 +11,24 @@ import { PROJECT_VERSION } from './PROJECT_VERSION.js';
 /* Use original assertWarning() after all CJS is removed from node_modules/vike/dist/
 import { assertWarning } from './assert.js'
 */
-const globalObject = getGlobalObject('utils/assertSingleInstance.ts', {
-    instances: [],
-    alreadyLogged: new Set()
-});
+let globalObject;
+// getGlobalObjectSafe() can be called before this line
+globalObject ?? (globalObject = genGlobalConfig());
+function genGlobalConfig() {
+    return getGlobalObject('utils/assertSingleInstance.ts', {
+        instances: [],
+        alreadyLogged: new Set()
+    });
+}
+// We need getGlobalObjectSafe() because globalObject is `undefined` when exported functions are called before globalObject is initialized
+function getGlobalObjectSafe() {
+    globalObject ?? (globalObject = genGlobalConfig());
+    return globalObject;
+}
 const clientRuntimesClonflict = 'Client runtime of both Server Routing and Client Routing loaded https://vike.dev/client-runtimes-conflict';
 const clientNotSingleInstance = 'Client runtime loaded twice https://vike.dev/client-runtime-duplicated';
 function assertSingleInstance() {
+    const globalObject = getGlobalObjectSafe();
     {
         const versions = unique(globalObject.instances);
         assertWarning(versions.length <= 1, 
@@ -34,6 +45,7 @@ function assertSingleInstance() {
     }
 }
 function assertSingleInstance_onClientEntryServerRouting(isProduction) {
+    const globalObject = getGlobalObjectSafe();
     assertWarning(globalObject.isClientRouting !== true, clientRuntimesClonflict, {
         onlyOnce: true,
         showStackTrace: true
@@ -48,6 +60,7 @@ function assertSingleInstance_onClientEntryServerRouting(isProduction) {
     assertSingleInstance();
 }
 function assertSingleInstance_onClientEntryClientRouting(isProduction) {
+    const globalObject = getGlobalObjectSafe();
     assertWarning(globalObject.isClientRouting !== false, clientRuntimesClonflict, {
         onlyOnce: true,
         showStackTrace: true
@@ -63,10 +76,12 @@ function assertSingleInstance_onClientEntryClientRouting(isProduction) {
 }
 // Called by utils/assert.ts which is (most certainly) loaded by all entries. That way we don't have to call a callback for every entry. (There are a lot of entries: `client/router/`, `client/`, `node/runtime/`, `node/plugin/`, `node/cli`.)
 function assertSingleInstance_onAssertModuleLoad() {
+    const globalObject = getGlobalObjectSafe();
     globalObject.instances.push(PROJECT_VERSION);
     assertSingleInstance();
 }
 function assertWarning(condition, errorMessage, { onlyOnce, showStackTrace }) {
+    const globalObject = getGlobalObjectSafe();
     if (condition) {
         return;
     }

package/dist/esm/utils/getRandomId.d.ts

@@ -1,2 +1,2 @@
 export { getRandomId };
-declare function getRandomId(length: number): string;
+declare function getRandomId(length?: number): string;

package/dist/esm/utils/getRandomId.js

@@ -1,7 +1,7 @@
 export { getRandomId };
 import { assert } from './assert.js';
 // https://stackoverflow.com/questions/1349404/generate-random-string-characters-in-javascript
-function getRandomId(length) {
+function getRandomId(length = 12) {
     let randomId = '';
     while (randomId.length < length) {
         randomId += Math.random().toString(36).slice(2);

package/dist/esm/utils/isNullish.d.ts

@@ -0,0 +1,3 @@
+export declare function isNullish(val: unknown): val is null | undefined;
+export declare function isNotNullish<T>(p: T | null | undefined): p is T;
+export declare function isNotNullish_keyVal<T>(arg: [string, T | null | undefined]): arg is [string, T];

package/dist/esm/utils/isNullish.js

@@ -0,0 +1,11 @@
+export function isNullish(val) {
+    return val === null || val === undefined;
+}
+// someArray.filter(isNotNullish)
+export function isNotNullish(p) {
+    return !isNullish(p);
+}
+// objectFilter(obj).filter(isNotNullish_keyVal)
+export function isNotNullish_keyVal(arg) {
+    return !isNullish(arg[1]);
+}

package/dist/esm/utils/normalizeHeaders.js

@@ -1,7 +1,7 @@
 export { normalizeHeaders };
 import { isObject } from './isObject.js';
 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.
+/* This type is too strict which is annoying: cannot pass `string[][]` because it doesn't match the more precise type `[string,string][]`.
 headersOriginal ConstructorParameters<typeof Headers>[0]
 */
 headersOriginal) {

package/dist/esm/utils/objectAssign.d.ts

@@ -1,2 +1,2 @@
 export { objectAssign };
-declare function objectAssign<Obj extends object, ObjAddendum extends object | null>(obj: Obj, objAddendum: ObjAddendum): asserts obj is Obj & ObjAddendum;
+declare function objectAssign<Obj extends object, ObjAddendum extends object | null>(obj: Obj, objAddendum: ObjAddendum, objAddendumCanBePageContextObject?: true): asserts obj is Obj & ObjAddendum;

package/dist/esm/utils/objectAssign.js

@@ -3,9 +3,14 @@ import { assert } from './assert.js';
 // Same as Object.assign() but:
 //  - With type inference
 //  - Preserves property descriptors, which we need for preserving the getters added by getPageContextUrlComputed()
-function objectAssign(obj, objAddendum) {
+function objectAssign(obj, objAddendum, objAddendumCanBePageContextObject) {
     if (objAddendum) {
-        assert(!('_isPageContextObject' in objAddendum));
+        if (!objAddendumCanBePageContextObject) {
+            // We only need this assert() in the rare case when the user is expected to mutate `pageContext` after the Vike hook was executed (and its promise resolved).
+            // - The only use case I can think of is the user mutating `pageContext` after the onRenderClient() promise resolved (which can happen when client-side rendering finishes after onRenderClient() resolves). In that case, having Vike await async Vike hooks isn't enough.
+            // - IIRC this assert() was mostly needed for preserving the getters added by getPageContextUrlComputed() but we don't need this anymore.
+            assert(!('_isPageContextObject' in objAddendum));
+        }
         Object.defineProperties(obj, Object.getOwnPropertyDescriptors(objAddendum));
     }
 }