vike 0.4.221 → 0.4.222-commit-6647d1e

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

@@ -5,7 +5,7 @@ export { getPageContextFromClientHooks };
 export { setPageContextInitIsPassedToClient };
 export type { PageContextFromServerHooks };
 export type { PageContextFromClientHooks };
-import type { PageConfigUserFriendly, PageFile } from '../../shared/getPageFiles.js';
+import type { PageConfigUserFriendlyOld, PageFile } from '../../shared/getPageFiles.js';
 import type { PageConfigRuntime } from '../../shared/page-configs/PageConfig.js';
 type PageContext = {
     urlOriginal: string;
@@ -21,9 +21,9 @@ declare function getPageContextFromHooks_serialized(): PageContextSerialized & {
     routeParams: Record<string, string>;
     _hasPageContextFromServer: true;
 };
-declare function getPageContextFromHooks_isHydration(pageContext: PageContextSerialized & PageContext & PageConfigUserFriendly & {
+declare function getPageContextFromHooks_isHydration(pageContext: PageContextSerialized & PageContext & PageConfigUserFriendlyOld & {
     _hasPageContextFromServer: true;
-}): Promise<PageContextSerialized & PageContext & PageConfigUserFriendly & {
+}): Promise<PageContextSerialized & PageContext & PageConfigUserFriendlyOld & {
     _hasPageContextFromServer: true;
 } & {
     _hasPageContextFromClient: boolean;
@@ -45,5 +45,5 @@ type PageContextFromClientHooks = {
 declare function getPageContextFromClientHooks(pageContext: {
     pageId: string;
     _hasPageContextFromServer: boolean;
-} & PageContext & PageConfigUserFriendly, isErrorPage: boolean): Promise<PageContextFromClientHooks>;
+} & PageContext & PageConfigUserFriendlyOld, isErrorPage: boolean): Promise<PageContextFromClientHooks>;
 declare function setPageContextInitIsPassedToClient(pageContext: Record<string, unknown>): void;

package/dist/esm/client/client-routing-runtime/prefetch/getPrefetchSettings.d.ts

@@ -1,10 +1,10 @@
 export { getPrefetchSettings };
 export { PAGE_CONTEXT_MAX_AGE_DEFAULT };
 export type { PrefetchSettingResolved };
-import type { PageConfigUserFriendly } from '../../../shared/getPageFiles.js';
+import type { PageConfigUserFriendlyOld } from '../../../shared/getPageFiles.js';
 declare const PAGE_CONTEXT_MAX_AGE_DEFAULT = 5000;
 type PrefetchSettingResolved = {
     staticAssets: false | 'hover' | 'viewport';
     pageContext: false | number;
 };
-declare function getPrefetchSettings(pageContext: PageConfigUserFriendly, linkTag: null | HTMLElement): PrefetchSettingResolved;
+declare function getPrefetchSettings(pageContext: PageConfigUserFriendlyOld, linkTag: null | HTMLElement): PrefetchSettingResolved;

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

@@ -6,7 +6,7 @@ export { addLinkPrefetchHandlers };
 export { addLinkPrefetchHandlers_watch };
 export { addLinkPrefetchHandlers_unwatch };
 import { type PageContextFromServerHooks, getPageContextFromServerHooks } from './getPageContextFromHooks.js';
-import type { PageConfigUserFriendly, PageFile } from '../../shared/getPageFiles.js';
+import type { PageConfigUserFriendlyOld, PageFile } from '../../shared/getPageFiles.js';
 import { type PageConfigRuntime } from '../../shared/page-configs/PageConfig.js';
 type ResultPageContextFromServer = Awaited<ReturnType<typeof getPageContextFromServerHooks>>;
 type PageContextForPrefetch = {
@@ -19,7 +19,7 @@ type PageContextForPrefetch = {
 };
 declare function getPageContextPrefetched(pageContext: {
     urlPathname: string;
-} & PageConfigUserFriendly): null | PageContextFromServerHooks;
+} & PageConfigUserFriendlyOld): null | PageContextFromServerHooks;
 declare function populatePageContextPrefetchCache(pageContext: PageContextForPrefetch, result: ResultPageContextFromServer): void;
 /**
  * Programmatically prefetch client assets.

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

@@ -45,7 +45,7 @@ function getPageContextPrefetched(pageContext) {
 }
 async function prefetchAssets(pageContextLink) {
     try {
-        await loadUserFilesClientSide(pageContextLink.pageId, pageContextLink._pageFilesAll, pageContextLink._pageConfigs);
+        await loadUserFilesClientSide(pageContextLink.pageId, pageContextLink._pageFilesAll, pageContextLink._pageConfigs, pageContextLink._pageConfigGlobal);
     }
     catch (err) {
         if (isErrorFetchingStaticAssets(err)) {
@@ -60,8 +60,8 @@ async function prefetchPageContextFromServerHooks(pageContextLink, resultMaxAge)
     const result = await getPageContextFromServerHooks(pageContextLink, false);
     setPageContextPrefetchCache(pageContextLink, result, resultMaxAge);
 }
-function populatePageContextPrefetchCache(pageContext /*& PageConfigUserFriendly*/, result) {
-    // TODO/pageContext-prefetch: replace with using pageContext.config.prerender instead. (For being able to do that: eager configs need to be accessible without have to use PageConfigUserFriendly as it isn't available here.)
+function populatePageContextPrefetchCache(pageContext /*& PageConfigUserFriendlyOld*/, result) {
+    // TODO/pageContext-prefetch: replace with using pageContext.config.prerender instead. (For being able to do that: eager configs need to be accessible without have to use PageConfigUserFriendlyOld as it isn't available here.)
     if (!isBrilloutDocpress())
         return;
     setPageContextPrefetchCache(pageContext, result, null);

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

@@ -17,5 +17,10 @@ type RenderArgs = {
     pageContextInitClient?: Record<string, unknown>;
 };
 declare function renderPageClientSide(renderArgs: RenderArgs): Promise<void>;
+declare global {
+    var _vike: {
+        fullyRenderedUrl?: string;
+    };
+}
 declare function disableClientRouting(err: unknown, log: boolean): void;
 declare function getRenderCount(): number;

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

@@ -131,7 +131,7 @@ async function renderPageClientSide(renderArgs) {
             objectAssign(pageContext, pageContextFromRoute);
         }
         try {
-            objectAssign(pageContext, await loadUserFilesClientSide(pageContext.pageId, pageContext._pageFilesAll, pageContext._pageConfigs));
+            objectAssign(pageContext, await loadUserFilesClientSide(pageContext.pageId, pageContext._pageFilesAll, pageContext._pageConfigs, pageContext._pageConfigGlobal));
         }
         catch (err) {
             if (handleErrorFetchingStaticAssets(err, pageContext, isFirstRender)) {
@@ -336,7 +336,7 @@ async function renderPageClientSide(renderArgs) {
             return;
         }
         try {
-            objectAssign(pageContext, await loadUserFilesClientSide(pageContext.pageId, pageContext._pageFilesAll, pageContext._pageConfigs));
+            objectAssign(pageContext, await loadUserFilesClientSide(pageContext.pageId, pageContext._pageFilesAll, pageContext._pageConfigs, pageContext._pageConfigGlobal));
         }
         catch (err) {
             if (handleErrorFetchingStaticAssets(err, pageContext, isFirstRender)) {
@@ -484,8 +484,15 @@ async function renderPageClientSide(renderArgs) {
         // Add link prefetch handlers
         addLinkPrefetchHandlers_watch();
         addLinkPrefetchHandlers();
+        stampFinished(urlOriginal);
     }
 }
+// For Vike tests (but also potentially for Vike users)
+// https://github.com/vikejs/vike/blob/ffbc5cf16407bcc075f414447e50d997c87c0c94/test/playground/pages/nested-layout/e2e-test.ts#L59
+function stampFinished(urlOriginal) {
+    window._vike ?? (window._vike = {});
+    window._vike.fullyRenderedUrl = urlOriginal;
+}
 function changeUrl(url, overwriteLastHistoryEntry) {
     if (getCurrentUrl() === url)
         return;

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

@@ -10,6 +10,7 @@ declare function getPageContext(): Promise<{
 } & {
     _pageFilesAll: import("../../shared/getPageFiles.js").PageFile[];
     _pageConfigs: import("../../__internal/index.js").PageConfig[];
-} & import("../../shared/getPageFiles.js").PageConfigUserFriendly & {
+    _pageConfigGlobal: import("../../shared/page-configs/PageConfig.js").PageConfigGlobalRuntime;
+} & import("../../shared/getPageFiles.js").PageConfigUserFriendlyOld & {
     _pageFilesLoaded: import("../../shared/getPageFiles.js").PageFile[];
 }>;

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

@@ -6,7 +6,7 @@ import { getCurrentUrl } from '../shared/getCurrentUrl.js';
 import { getPageConfigsRuntime } from '../../shared/getPageConfigsRuntime.js';
 // @ts-ignore
 import * as virtualFileExports from 'virtual:vike:importUserCode:client:server-routing';
-const { pageFilesAll, pageConfigs } = getPageConfigsRuntime(virtualFileExports);
+const { pageFilesAll, pageConfigs, pageConfigGlobal } = getPageConfigsRuntime(virtualFileExports);
 const urlFirst = getCurrentUrl({ withoutHash: true });
 async function getPageContext() {
     const pageContext = getPageContextSerializedInHtml();
@@ -28,9 +28,10 @@ async function loadPageUserFiles(pageId) {
     const pageContextAddendum = {};
     objectAssign(pageContextAddendum, {
         _pageFilesAll: pageFilesAll,
-        _pageConfigs: pageConfigs
+        _pageConfigs: pageConfigs,
+        _pageConfigGlobal: pageConfigGlobal
     });
-    objectAssign(pageContextAddendum, await loadUserFilesClientSide(pageId, pageContextAddendum._pageFilesAll, pageContextAddendum._pageConfigs));
+    objectAssign(pageContextAddendum, await loadUserFilesClientSide(pageId, pageContextAddendum._pageFilesAll, pageContextAddendum._pageConfigs, pageContextAddendum._pageConfigGlobal));
     pageFilesAll
         .filter((p) => p.fileType !== '.page.server')
         .forEach((p) => {

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

@@ -1,6 +1,6 @@
 export { executeOnRenderClientHook };
 export type { PageContextBeforeRenderClient };
-import type { PageFile, PageConfigUserFriendly } from '../../shared/getPageFiles.js';
+import type { PageFile, PageConfigUserFriendlyOld } from '../../shared/getPageFiles.js';
 import { type PageContextForUserConsumptionClientSide } from './preparePageContextForUserConsumptionClientSide.js';
 import type { PageConfigRuntime } from '../../shared/page-configs/PageConfig.js';
 type PageContextBeforeRenderClient = {
@@ -9,5 +9,5 @@ type PageContextBeforeRenderClient = {
     urlPathname?: string;
     pageId: string;
     _pageConfigs: PageConfigRuntime[];
-} & PageConfigUserFriendly & PageContextForUserConsumptionClientSide;
+} & PageConfigUserFriendlyOld & PageContextForUserConsumptionClientSide;
 declare function executeOnRenderClientHook<PC extends PageContextBeforeRenderClient>(pageContext: PC, isClientRouting: boolean): Promise<void>;

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

@@ -1,14 +1,15 @@
 export { loadUserFilesClientSide };
 export { isErrorFetchingStaticAssets };
 export type { PageContextUserFiles };
-import { type PageFile, type PageConfigUserFriendly } from '../../shared/getPageFiles.js';
-import type { PageConfigRuntime } from '../../shared/page-configs/PageConfig.js';
-type PageContextUserFilesLoaded = PageConfigUserFriendly & {
+import { type PageFile, type PageConfigUserFriendlyOld } from '../../shared/getPageFiles.js';
+import type { PageConfigGlobalRuntime, PageConfigRuntime } from '../../shared/page-configs/PageConfig.js';
+type PageContextUserFilesLoaded = PageConfigUserFriendlyOld & {
     _pageFilesLoaded: PageFile[];
 };
 type PageContextUserFiles = {
     _pageFilesAll: PageFile[];
     _pageConfigs: PageConfigRuntime[];
+    _pageConfigGlobal: PageConfigGlobalRuntime;
 };
-declare function loadUserFilesClientSide(pageId: string, pageFilesAll: PageFile[], pageConfigs: PageConfigRuntime[]): Promise<PageContextUserFilesLoaded>;
+declare function loadUserFilesClientSide(pageId: string, pageFilesAll: PageFile[], pageConfigs: PageConfigRuntime[], pageConfigGlobal: PageConfigGlobalRuntime): Promise<PageContextUserFilesLoaded>;
 declare function isErrorFetchingStaticAssets(err: unknown): boolean;

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

@@ -1,12 +1,12 @@
 export { loadUserFilesClientSide };
 export { isErrorFetchingStaticAssets };
 import { getPageFilesClientSide } from '../../shared/getPageFiles.js';
-import { getPageConfigUserFriendlyOld } from '../../shared/page-configs/getPageConfigUserFriendly.js';
+import { getPageConfigUserFriendly_oldDesign } from '../../shared/page-configs/getPageConfigUserFriendly.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) {
+async function loadUserFilesClientSide(pageId, pageFilesAll, pageConfigs, pageConfigGlobal) {
     const pageFilesClientSide = getPageFilesClientSide(pageFilesAll, pageId);
     const pageConfig = findPageConfig(pageConfigs, pageId);
     let pageConfigLoaded;
@@ -30,7 +30,7 @@ async function loadUserFilesClientSide(pageId, pageFilesAll, pageConfigs) {
         }
         throw err;
     }
-    const pageContextExports = getPageConfigUserFriendlyOld(pageFilesClientSide, pageConfigLoaded);
+    const pageContextExports = getPageConfigUserFriendly_oldDesign(pageFilesClientSide, pageConfigLoaded, pageConfigGlobal);
     const pageContextAddendum = {};
     objectAssign(pageContextAddendum, pageContextExports);
     objectAssign(pageContextAddendum, { _pageFilesLoaded: pageFilesClientSide });

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

@@ -1,9 +1,9 @@
 export { preparePageContextForUserConsumptionClientSide };
 export type { PageContextForUserConsumptionClientSide };
-import type { PageConfigUserFriendly } from '../../shared/getPageFiles.js';
+import type { PageConfigUserFriendlyOld } from '../../shared/getPageFiles.js';
 import type { PageConfigRuntime } from '../../shared/page-configs/PageConfig.js';
 import { PageContextForPassToClientWarning } from './getPageContextProxyForUser.js';
-type PageContextForUserConsumptionClientSide = PageConfigUserFriendly & PageContextForPassToClientWarning & {
+type PageContextForUserConsumptionClientSide = PageConfigUserFriendlyOld & PageContextForPassToClientWarning & {
     pageId: string;
     _pageConfigs: PageConfigRuntime[];
 };

package/dist/esm/node/api/prepareViteApiCall.d.ts

@@ -5,10 +5,10 @@ export { normalizeViteRoot };
 import type { InlineConfig, ResolvedConfig } from 'vite';
 import type { Operation } from './types.js';
 import { type VikeConfigObject } from '../plugin/plugins/importUserCode/v1-design/getVikeConfig.js';
-declare function prepareViteApiCall(viteConfig: InlineConfig | undefined, operation: Operation): Promise<{
+declare function prepareViteApiCall(viteConfigFromOptions: InlineConfig | undefined, operation: Operation): Promise<{
     vikeConfig: VikeConfigObject;
     viteConfigEnhanced: InlineConfig | undefined;
 }>;
-declare function getViteRoot(operation: 'build' | 'dev' | 'preview' | 'prerender'): Promise<string>;
+declare function getViteRoot(operation: Operation): Promise<string>;
 declare function normalizeViteRoot(root: string): string;
 declare function assertViteRoot(root: string, config: ResolvedConfig): void;

package/dist/esm/node/api/prepareViteApiCall.js

@@ -11,18 +11,18 @@ import { assert, assertUsage, getGlobalObject, isObject, toPosixPath } from './u
 import pc from '@brillout/picocolors';
 import { clearGlobalContext } from '../runtime/globalContext.js';
 const globalObject = getGlobalObject('prepareViteApiCall.ts', {});
-async function prepareViteApiCall(viteConfig, operation) {
+async function prepareViteApiCall(viteConfigFromOptions, operation) {
     clear();
     setContextApiOperation(operation);
-    return enhanceViteConfig(viteConfig, operation);
+    return enhanceViteConfig(viteConfigFromOptions, operation);
 }
 // For subsequent API calls, e.g. calling prerender() after build()
 function clear() {
     clearContextApiOperation();
     clearGlobalContext();
 }
-async function enhanceViteConfig(viteConfig, operation) {
-    const viteInfo = await getInfoFromVite(viteConfig, operation);
+async function enhanceViteConfig(viteConfigFromOptions, operation) {
+    const viteInfo = await getInfoFromVite(viteConfigFromOptions, operation);
     await assertViteRoot2(viteInfo.root, viteInfo.viteConfigEnhanced, operation);
     const vikeConfig = await getVikeConfig2(viteInfo.root, operation === 'dev', viteInfo.vikeVitePluginOptions);
     const viteConfigEnhanced = addViteSettingsSetByVikeConfig(viteInfo.viteConfigEnhanced, vikeConfig);
@@ -38,6 +38,7 @@ function addViteSettingsSetByVikeConfig(viteConfigEnhanced, vikeConfig) {
     viteConfigs.values.forEach((v) => {
         assertUsage(isObject(v.value), `${v.definedAt} should be an object`);
         viteConfigEnhanced = mergeConfig(viteConfigEnhanced ?? {}, v.value);
+        assertUsage(!findVikeVitePlugin(v.value), "Using the +vite setting to add Vike's Vite plugin is forbidden");
     });
     return viteConfigEnhanced;
 }
@@ -47,13 +48,14 @@ async function getViteRoot(operation) {
     assert(globalObject.root);
     return globalObject.root;
 }
-async function getInfoFromVite(viteConfig, operation) {
-    const viteConfigFromFile = await loadViteConfigFile(viteConfig, operation);
-    const root = normalizeViteRoot(viteConfigFromFile?.root ?? viteConfig?.root ?? process.cwd());
+async function getInfoFromVite(viteConfigFromOptions, operation) {
+    const viteConfigFromUserViteFile = await loadViteConfigFile(viteConfigFromOptions, operation);
+    const root = normalizeViteRoot(viteConfigFromUserViteFile?.root ?? viteConfigFromOptions?.root ?? process.cwd());
     globalObject.root = root;
     let vikeVitePluginOptions;
-    let viteConfigEnhanced = viteConfig;
-    const found = findVikeVitePlugin([...(viteConfig?.plugins ?? []), ...(viteConfigFromFile?.plugins ?? [])]);
+    let viteConfigEnhanced = viteConfigFromOptions;
+    // If Vike's Vite plugin is found in both viteConfigFromOptions and viteConfigFromUserViteFile then Vike will later throw an error
+    const found = findVikeVitePlugin(viteConfigFromOptions) || findVikeVitePlugin(viteConfigFromUserViteFile);
     if (found) {
         vikeVitePluginOptions = found.vikeVitePluginOptions;
     }
@@ -62,20 +64,20 @@ async function getInfoFromVite(viteConfig, operation) {
         // Using a dynamic import because the script calling the Vike API may not live in the same place as vite.config.js, thus vike/plugin may resolved to two different node_modules/vike directories.
         const { plugin: vikePlugin } = await import('../plugin/index.js');
         viteConfigEnhanced = {
-            ...viteConfig,
-            plugins: [...(viteConfig?.plugins ?? []), vikePlugin()]
+            ...viteConfigFromOptions,
+            plugins: [...(viteConfigFromOptions?.plugins ?? []), vikePlugin()]
         };
-        const res = findVikeVitePlugin(viteConfigEnhanced.plugins);
+        const res = findVikeVitePlugin(viteConfigEnhanced);
         assert(res);
         vikeVitePluginOptions = res.vikeVitePluginOptions;
     }
     assert(vikeVitePluginOptions);
     return { root, vikeVitePluginOptions, viteConfigEnhanced };
 }
-function findVikeVitePlugin(plugins) {
+function findVikeVitePlugin(viteConfig) {
     let vikeVitePluginOptions;
     let vikeVitePuginFound = false;
-    plugins.forEach((p) => {
+    viteConfig?.plugins?.forEach((p) => {
         if (p && '__vikeVitePluginOptions' in p) {
             vikeVitePuginFound = true;
             const options = p.__vikeVitePluginOptions;
@@ -88,8 +90,8 @@ function findVikeVitePlugin(plugins) {
     return { vikeVitePluginOptions };
 }
 // Copied from https://github.com/vitejs/vite/blob/4f5845a3182fc950eb9cd76d7161698383113b18/packages/vite/src/node/config.ts#L961-L1005
-async function loadViteConfigFile(viteConfig, operation) {
-    const [inlineConfig, command, defaultMode, _defaultNodeEnv, isPreview] = getResolveConfigArgs(viteConfig, operation);
+async function loadViteConfigFile(viteConfigFromOptions, operation) {
+    const [inlineConfig, command, defaultMode, _defaultNodeEnv, isPreview] = getResolveConfigArgs(viteConfigFromOptions, operation);
     let config = inlineConfig;
     let mode = inlineConfig.mode || defaultMode;
     const configEnv = {

package/dist/esm/node/plugin/index.d.ts

@@ -4,7 +4,10 @@ export { plugin as ssr };
 export type { VikeVitePluginOptions as UserConfig };
 export type { VikeVitePluginOptions };
 export { PROJECT_VERSION as version } from './utils.js';
-declare function plugin(vikeVitePluginOptions?: VikeVitePluginOptions): any;
+type PluginInterop = Record<string, unknown> & {
+    name: string;
+};
+declare function plugin(vikeVitePluginOptions?: VikeVitePluginOptions): PluginInterop[];
 /** @deprecated Define Vike settings in +config.js instead of vite.config.js */
 type VikeVitePluginOptions = {
     /** @deprecated Define Vike settings in +config.js instead of vite.config.js */

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

@@ -29,7 +29,7 @@ import { workaroundVite6HmrRegression } from './plugins/workaroundVite6HmrRegres
 import { buildApp } from './plugins/buildApp.js';
 // We don't call this in ./onLoad.ts to avoid a cyclic dependency with utils.ts
 setResolveClientEntriesDev(resolveClientEntriesDev);
-// Return as `any` to avoid Plugin type mismatches when there are multiple Vite versions installed
+// Return `PluginInterop` instead of `Plugin` to avoid type mismatch upon different Vite versions
 function plugin(vikeVitePluginOptions = {}) {
     const plugins = [
         ...commonConfig(vikeVitePluginOptions),

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

@@ -1,5 +1,5 @@
 export { baseUrls };
-import { resolveBase, resolveBaseFromResolvedConfig } from '../../shared/resolveBase.js';
+import { resolveBase } from '../../shared/resolveBase.js';
 import { assert } from '../utils.js';
 import { getVikeConfig } from './importUserCode/v1-design/getVikeConfig.js';
 function baseUrls() {
@@ -38,3 +38,8 @@ function baseUrls() {
         }
     };
 }
+function resolveBaseFromResolvedConfig(baseServer, baseAssets, config) {
+    let baseViteOriginal = config._baseViteOriginal;
+    assert(baseViteOriginal === null || typeof baseViteOriginal == 'string');
+    return resolveBase(baseViteOriginal, baseServer, baseAssets);
+}

package/dist/esm/node/plugin/plugins/buildConfig/fixServerAssets.d.ts

@@ -2,7 +2,6 @@ export { fixServerAssets };
 export { fixServerAssets_isEnabled };
 export { fixServerAssets_assertCssCodeSplit };
 export { fixServerAssets_assertCssTarget };
-export { fixServerAssets_assertCssTarget_populate };
 import { ViteManifest } from '../../../shared/ViteManifest.js';
 import { ResolvedConfig } from 'vite';
 /**
@@ -18,5 +17,4 @@ declare function fixServerAssets(config: ResolvedConfig): Promise<{
     serverManifestMod: ViteManifest;
 }>;
 declare function fixServerAssets_assertCssCodeSplit(config: ResolvedConfig): void;
-declare function fixServerAssets_assertCssTarget_populate(config: ResolvedConfig): void;
 declare function fixServerAssets_assertCssTarget(config: ResolvedConfig): Promise<void>;

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

@@ -2,7 +2,6 @@ export { fixServerAssets };
 export { fixServerAssets_isEnabled };
 export { fixServerAssets_assertCssCodeSplit };
 export { fixServerAssets_assertCssTarget };
-export { fixServerAssets_assertCssTarget_populate };
 import fs from 'fs/promises';
 import fs_sync from 'fs';
 import path from 'path';
@@ -195,17 +194,15 @@ function fixServerAssets_assertCssCodeSplit(config) {
     assertWarning(config.build.cssCodeSplit, `${pc.cyan('build.cssCodeSplit')} shouldn't be set to ${pc.cyan('false')} (https://github.com/vikejs/vike/issues/1993)`, { onlyOnce: true });
 }
 const targets = [];
-function fixServerAssets_assertCssTarget_populate(config) {
-    const isServerSide = viteIsSSR(config);
-    assert(typeof isServerSide === 'boolean');
-    assert(config.build.target !== undefined);
-    targets.push({ global: config.build.target, css: config.build.cssTarget, isServerSide });
-}
 async function fixServerAssets_assertCssTarget(config) {
     if (!fixServerAssets_isEnabled())
         return;
     if (!(await isV1Design(config)))
         return;
+    const isServerSide = viteIsSSR(config);
+    assert(typeof isServerSide === 'boolean');
+    assert(config.build.target !== undefined);
+    targets.push({ global: config.build.target, css: config.build.cssTarget, isServerSide });
     const targetsServer = targets.filter((t) => t.isServerSide);
     const targetsClient = targets.filter((t) => !t.isServerSide);
     targetsClient.forEach((targetClient) => {
@@ -213,9 +210,10 @@ async function fixServerAssets_assertCssTarget(config) {
         targetsServer.forEach((targetServer) => {
             const targetCssResolvedServer = resolveCssTarget(targetServer);
             assertWarning(isEqualStringList(targetCssResolvedClient, targetCssResolvedServer), [
-                'The CSS browser target should be the same for both client-side and server-side (https://github.com/vikejs/vike/issues/1815#issuecomment-2507002979) but we got:',
-                `Client-side: ${pc.cyan(JSON.stringify(targetCssResolvedClient))}`,
-                `Server-side: ${pc.cyan(JSON.stringify(targetCssResolvedServer))}`
+                'The CSS browser target should be the same for both client and server, but we got:',
+                `Client: ${pc.cyan(JSON.stringify(targetCssResolvedClient))}`,
+                `Server: ${pc.cyan(JSON.stringify(targetCssResolvedServer))}`,
+                `Different targets lead to CSS duplication, see ${pc.underline('https://github.com/vikejs/vike/issues/1815#issuecomment-2507002979')} for more information.`
             ].join('\n'), {
                 showStackTrace: true,
                 onlyOnce: 'different-css-target'

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

@@ -10,7 +10,7 @@ import { extractAssetsAddQuery } from '../../shared/extractAssetsQuery.js';
 import { createRequire } from 'module';
 import fs from 'fs/promises';
 import path from 'path';
-import { fixServerAssets, fixServerAssets_assertCssCodeSplit, fixServerAssets_assertCssTarget, fixServerAssets_assertCssTarget_populate, fixServerAssets_isEnabled } from './buildConfig/fixServerAssets.js';
+import { fixServerAssets, fixServerAssets_assertCssCodeSplit, fixServerAssets_assertCssTarget, fixServerAssets_isEnabled } from './buildConfig/fixServerAssets.js';
 import { set_ASSETS_MANIFEST } from './buildEntry/index.js';
 import { prependEntriesDir } from '../../shared/prependEntriesDir.js';
 import { getFilePathResolved } from '../shared/getFilePath.js';
@@ -48,7 +48,6 @@ function buildConfig() {
                             config.build.ssrEmitAssets = true;
                             // Required if `ssrEmitAssets: true`, see https://github.com/vitejs/vite/pull/11430#issuecomment-1454800934
                             config.build.cssMinify = 'esbuild';
-                            fixServerAssets_assertCssTarget_populate(config);
                             fixServerAssets_assertCssCodeSplit(config);
                         }
                     }

package/dist/esm/node/plugin/plugins/commonConfig.d.ts

@@ -11,6 +11,7 @@ declare module 'vite' {
         _viteConfigEnhanced?: InlineConfig;
         vike?: {
             config: VikeConfigObject['global']['config'];
+            pages: VikeConfigObject['pages'];
             prerenderContext?: PrerenderContextPublic;
         };
     }

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

@@ -30,7 +30,10 @@ function commonConfig(vikeVitePluginOptions) {
                         _isDev: isDev,
                         _root: root,
                         _vikeVitePluginOptions: vikeVitePluginOptions,
-                        vike: { config: vikeConfig.global.config },
+                        vike: {
+                            pages: vikeConfig.pages,
+                            config: vikeConfig.global.config
+                        },
                         // TODO/v1-release: remove https://github.com/vikejs/vike/issues/2122
                         configVikePromise: Promise.resolve({
                             prerender: isPrerenderEnabled(vikeConfig)

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

@@ -10,8 +10,8 @@ import { vikeConfigDependencies, reloadVikeConfig, isV1Design, getVikeConfig } f
 import pc from '@brillout/picocolors';
 import { logConfigInfo } from '../../shared/loggerNotProd.js';
 import { getModuleFilePathAbsolute } from '../../shared/getFilePath.js';
-import { getPlusFileValueConfigName } from './v1-design/getVikeConfig/getPlusFilesAll.js';
 import { updateUserFiles } from '../../../runtime/globalContext.js';
+import { isPlusFile } from './v1-design/getVikeConfig/crawlPlusFiles.js';
 function importUserCode() {
     let config;
     let vikeConfig;
@@ -68,50 +68,55 @@ function handleFileAddRemove(server, config) {
     return;
     function listener(file, isRemove) {
         file = normalizePath(file);
-        const isVikeConfig = isVikeConfigModule(file) || isVikeConfigFile(file);
-        if (isVikeConfig) {
-            const virtualModules = getVirtualModules(server);
-            virtualModules.forEach((mod) => {
-                server.moduleGraph.invalidateModule(mod);
-            });
+        if (isPlusFile(file) || isVikeConfigDependency(file, server.moduleGraph)?.modifiesVikeVirtualFiles) {
+            invalidateVikeVirtualFiles(server);
             reloadConfig(file, config, isRemove ? 'removed' : 'created');
         }
     }
 }
+function invalidateVikeVirtualFiles(server) {
+    const vikeVirtualFiles = getVikeVirtualFiles(server);
+    vikeVirtualFiles.forEach((mod) => {
+        server.moduleGraph.invalidateModule(mod);
+    });
+}
 function handleHotUpdate(ctx, config) {
     const { file, server } = ctx;
-    const isVikeConfig = isVikeConfigModule(file);
-    const isViteModule = ctx.modules.length > 0;
-    /* Should we show this?
-    // - Can be useful for server files that aren't processed by Vite.
-    // - Can be annoying for files that obviously aren't processed by Vite.
-    if (!isVikeConfig && !isViteModule) {
-      logViteAny(
-        `${msg} — ${pc.cyan('no HMR')}, see https://vike.dev/on-demand-compiler`,
-        'info',
-        null,
-        true
-      )
-      return
-    }
-    //*/
-    // It can hide an error it shouldn't hide (because the error isn't shown again), but it's ok since users can reload the page and the error will be shown again (Vite transpilation errors are shown again upon a page reload).
-    if (!isVikeConfig && isViteModule) {
-        return;
-    }
+    const isVikeConfig = isVikeConfigDependency(ctx.file, ctx.server.moduleGraph);
     if (isVikeConfig) {
-        /* Tailwind breaks this assertion, see https://github.com/vikejs/vike/discussions/1330#discussioncomment-7787238
-        assert(!isViteModule)
-        */
-        reloadConfig(file, config, 'modified');
-        const virtualModules = getVirtualModules(server);
-        return virtualModules;
+        if (isVikeConfig.modifiesVikeVirtualFiles) {
+            /* Tailwind breaks this assertion, see https://github.com/vikejs/vike/discussions/1330#discussioncomment-7787238
+            const isViteModule = ctx.modules.length > 0
+            assert(!isViteModule)
+            */
+            // Ensure server.ssrLoadModule() loads fresh Vike virtual files (`reloadConfig()` > `updateUserFiles()` > `server.ssrLoadModule()`)
+            invalidateVikeVirtualFiles(server);
+            reloadConfig(file, config, 'modified');
+            // Triggers a full page reload
+            const vikeVirtualFiles = getVikeVirtualFiles(server);
+            return vikeVirtualFiles;
+        }
+        else {
+            // Ensure we invalidate `file` *before* server.ssrLoadModule() in updateUserFiles()
+            // Vite already invalidates it, but possibly *after* handleHotUpdate() and thus after server.ssrLoadModule()
+            ctx.modules.forEach((mod) => server.moduleGraph.invalidateModule(mod));
+            updateUserFiles();
+        }
     }
 }
-function isVikeConfigModule(filePathAbsoluteFilesystem) {
+function isVikeConfigDependency(filePathAbsoluteFilesystem, moduleGraph) {
+    // Check config-only files, for example all pages/+config.js dependencies. (There aren't part of Vite's module graph.)
     assertPosixPath(filePathAbsoluteFilesystem);
     vikeConfigDependencies.forEach((f) => assertPosixPath(f));
-    return vikeConfigDependencies.has(filePathAbsoluteFilesystem);
+    if (vikeConfigDependencies.has(filePathAbsoluteFilesystem))
+        return { modifiesVikeVirtualFiles: true };
+    // Check using Vite's module graph, for example all +htmlAttributes dependencies.
+    // Alternatively, simply call updateUserFiles() on every handleHotUpdate() call.
+    const importers = getImporters(filePathAbsoluteFilesystem, moduleGraph);
+    const isPlusValueFileDependency = Array.from(importers).some((importer) => importer.file && isPlusFile(importer.file));
+    if (isPlusValueFileDependency)
+        return { modifiesVikeVirtualFiles: false };
+    return null;
 }
 function reloadConfig(filePath, config, op) {
     {
@@ -122,16 +127,45 @@ function reloadConfig(filePath, config, op) {
     reloadVikeConfig(config);
     updateUserFiles();
 }
-function getVirtualModules(server) {
-    const virtualModules = Array.from(server.moduleGraph.urlToModuleMap.keys())
+function getVikeVirtualFiles(server) {
+    const vikeVirtualFiles = Array.from(server.moduleGraph.urlToModuleMap.keys())
         .filter((url) => isVirtualFileIdPageConfigValuesAll(url) || isVirtualFileIdImportUserCode(url))
         .map((url) => {
         const mod = server.moduleGraph.urlToModuleMap.get(url);
         assert(mod);
         return mod;
     });
-    return virtualModules;
+    return vikeVirtualFiles;
+}
+// Get all transitive importers (including the module itself)
+function getImporters(file, moduleGraph) {
+    const importers = new Set();
+    const mods = moduleGraph.getModulesByFile(file);
+    if (!mods)
+        return importers;
+    for (const mod of mods) {
+        getModuleImporters(mod).forEach((importer) => {
+            if (importer)
+                importers.add(importer);
+        });
+    }
+    return importers;
 }
-function isVikeConfigFile(filePath) {
-    return !!getPlusFileValueConfigName(filePath);
+function getModuleImporters(mod, seen = new Set()) {
+    if (seen.has(mod))
+        return new Set();
+    seen.add(mod);
+    const importers = new Set();
+    if (mod.id)
+        importers.add(mod);
+    // Traverse through the importers (modules that import this module)
+    for (const importer of mod.importers) {
+        if (importer.id)
+            importers.add(importer);
+        getModuleImporters(importer, seen).forEach((importerTransitive) => {
+            if (importerTransitive)
+                importers.add(importerTransitive);
+        });
+    }
+    return importers;
 }