vike 0.4.236-commit-e752d12 → 0.4.236-commit-79f1ef0

package/dist/esm/node/vite/plugins/pluginBuild/pluginBuildApp.js

@@ -6,6 +6,34 @@ import { isPrerenderForceExit } from './pluginAutoFullBuild.js';
 import { getVikeConfigInternal } from '../../shared/resolveVikeConfigInternal.js';
 function pluginBuildApp() {
     return [
+        {
+            name: 'vike:build:pluginBuildApp:pre',
+            apply: 'build',
+            enforce: 'pre',
+            config: {
+                order: 'pre',
+                async handler(_config) {
+                    const vikeConfig = await getVikeConfigInternal();
+                    if (!vikeConfig.config.vite6BuilderApp)
+                        return;
+                    return {
+                        builder: {
+                            // Can be overridden by another plugin e.g vike-vercel https://github.com/vikejs/vike/pull/2184#issuecomment-2659425195
+                            async buildApp(builder) {
+                                assert(builder.environments.client);
+                                assert(builder.environments.ssr);
+                                await builder.build(builder.environments.client);
+                                await builder.build(builder.environments.ssr);
+                                if (isPrerenderForceExit()) {
+                                    runPrerender_forceExit();
+                                    assert(false);
+                                }
+                            },
+                        },
+                    };
+                },
+            },
+        },
         {
             name: 'vike:build:pluginBuildApp',
             apply: 'build',
@@ -14,19 +42,6 @@ function pluginBuildApp() {
                 if (!vikeConfig.config.vite6BuilderApp)
                     return;
                 return {
-                    builder: {
-                        // Can be overridden by another plugin e.g vike-vercel https://github.com/vikejs/vike/pull/2184#issuecomment-2659425195
-                        async buildApp(builder) {
-                            assert(builder.environments.client);
-                            assert(builder.environments.ssr);
-                            await builder.build(builder.environments.client);
-                            await builder.build(builder.environments.ssr);
-                            if (isPrerenderForceExit()) {
-                                runPrerender_forceExit();
-                                assert(false);
-                            }
-                        },
-                    },
                     environments: {
                         ssr: {
                             consumer: 'server',

package/dist/esm/node/vite/plugins/pluginBuild/pluginBuildConfig.d.ts

@@ -1,10 +1,8 @@
 export { pluginBuildConfig };
 export { assertRollupInput };
 export { analyzeClientEntries };
-export { manifestTempFile };
 import type { ResolvedConfig, Plugin } from 'vite';
 import type { PageConfigBuildTime } from '../../../../types/PageConfig.js';
-declare const manifestTempFile = "_temp_manifest.json";
 declare function pluginBuildConfig(): Plugin[];
 declare function analyzeClientEntries(pageConfigs: PageConfigBuildTime[], config: ResolvedConfig): {
     hasClientRouting: boolean;

package/dist/esm/node/vite/plugins/pluginBuild/pluginBuildConfig.js

@@ -1,7 +1,6 @@
 export { pluginBuildConfig };
 export { assertRollupInput };
 export { analyzeClientEntries };
-export { manifestTempFile };
 import { assert, addOnBeforeLogHook, removeFileExtension, unique, assertUsage, injectRollupInputs, normalizeRollupInput, onSetupBuild, assertIsImportPathNpmPackage, requireResolveVikeDistFile, } from '../../utils.js';
 import { getVikeConfigInternal } from '../../shared/resolveVikeConfigInternal.js';
 import { findPageFiles } from '../../shared/findPageFiles.js';
@@ -14,7 +13,6 @@ import { isViteServerBuild } from '../../shared/isViteServerBuild.js';
 import { resolveOutDir } from '../../shared/getOutDirs.js';
 import { handleAssetsManifest_assertUsageCssCodeSplit, handleAssetsManifest_getBuildConfig, } from './handleAssetsManifest.js';
 import { resolveIncludeAssetsImportedByServer } from '../../../runtime/renderPage/getPageAssets.js';
-const manifestTempFile = '_temp_manifest.json';
 function pluginBuildConfig() {
     let config;
     return [

package/dist/esm/node/vite/plugins/pluginBuild/pluginDistFileNames.js

@@ -151,13 +151,8 @@ function getEntryFileName(chunkInfo, config, isEntry) {
         return `${name}.${isEntry ? 'mjs' : 'js'}`;
     }
 }
-function removePathSeparators(name, userRootDir) {
+function removePathSeparators(name) {
     assertPosixPath(name);
-    if (name.startsWith(userRootDir)) {
-        name = name.slice(userRootDir.length);
-        if (name.startsWith('/'))
-            name = name.slice(1);
-    }
     assert(!name.startsWith('/'), { name });
     const entryDir = 'entries/';
     const hasEntryDir = name.startsWith(entryDir);
@@ -171,14 +166,24 @@ function removePathSeparators(name, userRootDir) {
     }
     return name;
 }
+function removeUserRootDir(name, userRootDir) {
+    if (name.startsWith(userRootDir)) {
+        name = name.slice(userRootDir.length);
+        if (name.startsWith('/'))
+            name = name.slice(1);
+    }
+    assert(!name.startsWith('/'), { name });
+    return name;
+}
 function clean(name, userRootDir, removePathSep, fixGlob) {
+    name = removeUserRootDir(name, userRootDir);
     name = fixExtractAssetsQuery(name);
     if (fixGlob) {
         name = workaroundGlob(name);
     }
     name = replaceNonLatinCharacters(name);
     if (removePathSep) {
-        name = removePathSeparators(name, userRootDir);
+        name = removePathSeparators(name);
     }
     name = removeLeadingUnderscoreInFilename(name);
     name = removeUnderscoreDoublets(name);

package/dist/esm/node/vite/plugins/pluginBuild/pluginModuleBanner.js

@@ -1,6 +1,6 @@
 export { pluginModuleBanner };
 import MagicString from 'magic-string';
-import { removeVirtualIdTag } from '../../../shared/virtualFiles.js';
+import { removeVirtualFileIdPrefix } from '../../utils.js';
 import { isViteServerBuild_safe } from '../../shared/isViteServerBuild.js';
 // Rollup's banner feature doesn't work with Vite: https://github.com/vitejs/vite/issues/8412
 // But, anyways, we want to prepend the banner at the beginning of each module, not at the beginning of each file (I believe that's what Rollup's banner feature does).
@@ -23,7 +23,7 @@ function pluginModuleBanner() {
                 }
                 if (id.startsWith('\0'))
                     id = id;
-                id = removeVirtualIdTag(id);
+                id = removeVirtualFileIdPrefix(id);
                 if (id.startsWith(config.root))
                     id = id.slice(config.root.length + 1);
                 id = id.replaceAll('*/', '*\\/'); // https://github.com/vikejs/vike/issues/2377

package/dist/esm/node/vite/plugins/pluginCommon.d.ts

@@ -10,4 +10,7 @@ declare module 'vite' {
         _viteConfigFromUserEnhanced?: InlineConfig;
     }
 }
+declare global {
+    var __VIKE__IS_PROCESS_SHARED_WITH_VITE: undefined | true;
+}
 declare function pluginCommon(vikeVitePluginOptions: unknown): Plugin[];

package/dist/esm/node/vite/plugins/pluginCommon.js

@@ -11,6 +11,7 @@ import { getVikeConfigInternal, setVikeConfigContext } from '../shared/resolveVi
 import { assertViteRoot, getViteRoot, normalizeViteRoot } from '../../api/prepareViteApiCall.js';
 import { temp_disablePrerenderAutoRun } from '../../prerender/context.js';
 const pluginName = 'vike:pluginCommon';
+globalThis.__VIKE__IS_PROCESS_SHARED_WITH_VITE = true;
 function pluginCommon(vikeVitePluginOptions) {
     return [
         {

package/dist/esm/node/vite/plugins/pluginDev/determineOptimizeDeps.js

@@ -1,6 +1,6 @@
 export { determineOptimizeDeps };
 import { findPageFiles } from '../../shared/findPageFiles.js';
-import { assert, assertIsImportPathNpmPackage, createDebugger, getNpmPackageName, isArray, unique, } from '../../utils.js';
+import { assert, assertIsImportPathNpmPackage, createDebugger, getNpmPackageName, isArray, isFilePathAbsoluteFilesystem, isVirtualFileId, } from '../../utils.js';
 import { getVikeConfigInternal, isOverridden } from '../../shared/resolveVikeConfigInternal.js';
 import { analyzeClientEntries } from '../pluginBuild/pluginBuildConfig.js';
 import { virtualFileIdEntryClientCR, virtualFileIdEntryClientSR, } from '../../../shared/virtualFiles/virtualFileEntry.js';
@@ -9,38 +9,80 @@ const debug = createDebugger('vike:optimizeDeps');
 async function determineOptimizeDeps(config) {
     const vikeConfig = await getVikeConfigInternal();
     const { _pageConfigs: pageConfigs } = vikeConfig;
-    const { entries, include } = await getPageDeps(config, pageConfigs);
-    {
-        // This actually doesn't work: Vite's dep optimizer doesn't seem to be able to crawl virtual files.
-        //  - Should we make it work? E.g. by creating a temporary file at node_modules/.vike/virtualFiles.js
-        //  - Or should we remove it? And make sure getPageDeps() also works for aliased import paths
-        //    - If we do, then we need to adjust include/entries (maybe by making include === entries -> will Vite complain?)
-        const entriesVirtualFiles = getVirtualFiles(config, pageConfigs);
-        entries.push(...entriesVirtualFiles);
+    const { entriesClient, entriesServer, includeClient, includeServer } = await getPageDeps(config, pageConfigs);
+    config.optimizeDeps.include = add(config.optimizeDeps.include, includeClient);
+    config.optimizeDeps.entries = add(config.optimizeDeps.entries, entriesClient);
+    // Workaround until https://github.com/vitejs/vite-plugin-react/issues/650
+    // - TODO/soon: remove workaround once https://github.com/vitejs/vite/pull/20495 is released
+    includeServer.push('react/jsx-dev-runtime');
+    for (const envName in config.environments) {
+        const env = config.environments[envName];
+        if (env.consumer === 'server' && env.optimizeDeps.noDiscovery === false) {
+            env.optimizeDeps.include = add(env.optimizeDeps.include, includeServer);
+            env.optimizeDeps.entries = add(env.optimizeDeps.entries, entriesServer);
+        }
     }
-    /* Other Vite plugins may populate optimizeDeps, e.g. Cypress: https://github.com/vikejs/vike/issues/386
-    assert(config.optimizeDeps.entries === undefined)
-    */
-    config.optimizeDeps.include = [...include, ...normalizeInclude(config.optimizeDeps.include)];
-    config.optimizeDeps.entries = [...entries, ...normalizeEntries(config.optimizeDeps.entries)];
     if (debug.isActivated)
-        debug('config.optimizeDeps', {
+        debug('optimizeDeps', {
             'config.optimizeDeps.entries': config.optimizeDeps.entries,
             'config.optimizeDeps.include': config.optimizeDeps.include,
+            'config.optimizeDeps.exclude': config.optimizeDeps.exclude,
+            // @ts-ignore Vite doesn't seem to support ssr.optimizeDeps.entries (vite@7.0.6, July 2025)
+            'config.ssr.optimizeDeps.entries': config.ssr.optimizeDeps.entries,
+            'config.ssr.optimizeDeps.include': config.ssr.optimizeDeps.include,
+            'config.ssr.optimizeDeps.exclude': config.ssr.optimizeDeps.exclude,
         });
 }
 async function getPageDeps(config, pageConfigs) {
-    let entries = [];
-    let include = [];
-    const addEntry = (e) => {
+    let entriesClient = [];
+    let entriesServer = [];
+    let includeClient = [];
+    let includeServer = [];
+    const addEntry = (e, configEnv, definedAt) => {
         assert(e);
-        entries.push(e);
+        // optimizeDeps.entries expects filesystem absolute paths
+        assert(isVirtualFileId(e) || isFilePathAbsoluteFilesystem(e));
+        if (isRelevant(e, false, configEnv, definedAt)) {
+            entriesClient.push(e);
+        }
+        if (isRelevant(e, true, configEnv, definedAt)) {
+            entriesServer.push(e);
+        }
     };
-    const addInclude = (e) => {
+    const addInclude = (e, configEnv, definedAt) => {
         assert(e);
-        // Shouldn't be a path alias, as path aliases would need to be added to config.optimizeDeps.entries instead of config.optimizeDeps.include
+        // optimizeDeps.include expects npm packages
+        assert(!e.startsWith('/'));
+        // Shouldn't be a path alias, as path aliases would need to be added to optimizeDeps.entries instead of optimizeDeps.include
         assertIsImportPathNpmPackage(e);
-        include.push(e);
+        if (isRelevant(e, false, configEnv, definedAt)) {
+            includeClient.push(e);
+        }
+        if (isRelevant(e, true, configEnv, definedAt)) {
+            includeServer.push(e);
+        }
+    };
+    const isRelevant = (e, server, configEnv, definedAt) => {
+        if (server) {
+            if (!configEnv || !configEnv.server)
+                return false;
+        }
+        else {
+            if (configEnv && !configEnv.client)
+                return false;
+        }
+        return !isExcluded(e, server, definedAt);
+    };
+    const isExcluded = (e, server, definedAt) => {
+        const exclude = server ? config.ssr.optimizeDeps.exclude : config.optimizeDeps.exclude;
+        if (!exclude)
+            return false;
+        if (definedAt?.importPathAbsolute) {
+            const npmPackageName = getNpmPackageName(definedAt.importPathAbsolute);
+            if (npmPackageName && exclude.includes(npmPackageName))
+                return true;
+        }
+        return exclude.includes(e);
     };
     // V1 design
     {
@@ -52,22 +94,17 @@ async function getPageDeps(config, pageConfigs) {
                     if (!configValueSource.valueIsLoadedWithImport && !configValueSource.valueIsFilePath)
                         return;
                     const { definedAt, configEnv } = configValueSource;
-                    if (!configEnv.client)
-                        return;
                     if (definedAt.definedBy)
                         return;
-                    if (definedAt.importPathAbsolute) {
-                        const npmPackageName = getNpmPackageName(definedAt.importPathAbsolute);
-                        if (npmPackageName && config.optimizeDeps.exclude?.includes(npmPackageName))
-                            return;
-                    }
                     if (definedAt.filePathAbsoluteUserRootDir !== null) {
-                        // Vite expects entries to be filesystem absolute paths (surprisingly so).
-                        addEntry(definedAt.filePathAbsoluteFilesystem);
+                        addEntry(
+                        // optimizeDeps.entries expects filesystem absolute paths
+                        definedAt.filePathAbsoluteFilesystem, configEnv, definedAt);
                     }
                     else {
-                        // Adding definedAtFilePath.filePathAbsoluteFilesystem doesn't work for npm packages, I guess because of Vite's config.server.fs.allow
-                        addInclude(definedAt.importPathAbsolute);
+                        addInclude(
+                        // optimizeDeps.include expects npm packages
+                        definedAt.importPathAbsolute, configEnv, definedAt);
                     }
                 });
             });
@@ -83,32 +120,39 @@ async function getPageDeps(config, pageConfigs) {
             addEntry(filePathAbsoluteFilesystem);
         });
     }
-    entries = unique(entries);
-    include = unique(include);
-    return { entries, include };
-}
-function getVirtualFiles(config, pageConfigs) {
-    const { hasClientRouting, hasServerRouting, clientEntries } = analyzeClientEntries(pageConfigs, config);
-    const entriesVirtualFiles = Object.values(clientEntries);
-    if (hasClientRouting)
-        entriesVirtualFiles.push(virtualFileIdEntryClientCR);
-    if (hasServerRouting)
-        entriesVirtualFiles.push(virtualFileIdEntryClientSR);
-    return entriesVirtualFiles;
+    // Add virtual files.
+    // - This doesn't work: Vite's dep optimizer doesn't seem to be able to crawl virtual files.
+    //   - Should we make it work? E.g. by creating a temporary file at node_modules/.vike/virtualFiles.js
+    //   - Or should we remove it? And make sure getPageDeps() also works for aliased import paths
+    //     - If we do, then we need to adjust include/entries (maybe by making include === entries -> will Vite complain?)
+    {
+        const { hasClientRouting, hasServerRouting, clientEntries } = analyzeClientEntries(pageConfigs, config);
+        Object.values(clientEntries).forEach((e) => addEntry(e));
+        if (hasClientRouting)
+            addEntry(virtualFileIdEntryClientCR);
+        if (hasServerRouting)
+            addEntry(virtualFileIdEntryClientSR);
+    }
+    entriesClient = entriesClient;
+    entriesServer = entriesServer;
+    includeClient = includeClient;
+    includeServer = includeServer;
+    return {
+        entriesClient,
+        entriesServer,
+        includeClient,
+        includeServer,
+    };
 }
-function normalizeEntries(entries) {
-    if (isArray(entries))
-        return entries;
-    if (typeof entries === 'string')
-        return [entries];
-    if (entries === undefined)
-        return [];
-    assert(false);
+function add(input, listAddendum) {
+    const list = !input ? [] : isArray(input) ? unique(input) : [input];
+    listAddendum.forEach((e) => {
+        if (!list.includes(e))
+            list.push(e);
+    });
+    return list;
 }
-function normalizeInclude(include) {
-    if (isArray(include))
-        return include;
-    if (include === undefined)
-        return [];
-    assert(false);
+function unique(arr) {
+    const arrUnique = Array.from(new Set(arr));
+    return arr.length !== arrUnique.length ? arrUnique : arr;
 }

package/dist/esm/node/vite/plugins/pluginExtractAssets.js

@@ -6,8 +6,7 @@
 //  - This approach supports import path aliases `vite.config.js#resolve.alias` https://vitejs.dev/config/#resolve-alias
 export { pluginExtractAssets };
 export { extractAssetsRE };
-import { assert, assertPosixPath, styleFileRE, createDebugger, isScriptFile, assertUsage, rollupSourceMapRemove, } from '../utils.js';
-import { resolveVirtualFileId, isVirtualFileId, getVirtualFileId } from '../../shared/virtualFiles.js';
+import { assert, assertPosixPath, styleFileRE, createDebugger, isScriptFile, assertUsage, rollupSourceMapRemove, addVirtualFileIdPrefix, isVirtualFileId, removeVirtualFileIdPrefix, } from '../utils.js';
 import { extractAssetsAddQuery } from '../../shared/extractAssetsQuery.js';
 import { isAsset } from '../shared/isAsset.js';
 import { getImportStatements } from '../shared/parseEsModule.js';
@@ -124,7 +123,7 @@ function pluginExtractAssets() {
             load(id) {
                 if (!isVirtualFileId(id))
                     return undefined;
-                id = getVirtualFileId(id);
+                id = removeVirtualFileIdPrefix(id);
                 if (id === EMPTY_MODULE_ID) {
                     return '// Erased by vike:pluginExtractAssets';
                 }
@@ -151,7 +150,7 @@ function pluginExtractAssets() {
 }
 function emptyModule(file, importer) {
     debugOperation('NUKED', file, importer);
-    return resolveVirtualFileId(EMPTY_MODULE_ID);
+    return addVirtualFileIdPrefix(EMPTY_MODULE_ID);
 }
 function appendExtractAssetsQuery(file, importer) {
     debugOperation('TRANSFORMED', file, importer);

package/dist/esm/node/vite/plugins/pluginNonRunnableDev.d.ts

@@ -0,0 +1,26 @@
+export { pluginNonRunnableDev };
+import type { Plugin, ViteDevServer } from 'vite';
+import type { ClientDependency } from '../../../shared/getPageFiles/analyzePageClientSide/ClientDependency.js';
+export type ViteRPC = ReturnType<typeof getViteRpcFunctions>;
+declare function getViteRpcFunctions(viteDevServer: ViteDevServer): {
+    transformIndexHtmlRPC(html: string): Promise<string>;
+    retrievePageAssetsDevRPC(clientDependencies: ClientDependency[], clientEntries: string[]): Promise<{
+        clientEntriesSrc: string[];
+        assetUrls: string[];
+    }>;
+    getViteConfigRuntimeRPC(): Promise<{
+        root: string;
+        build: {
+            outDir: string;
+        };
+        _baseViteOriginal: string;
+        vitePluginServerEntry: {
+            inject: boolean | undefined;
+        };
+    }>;
+};
+declare global {
+    var __VIKE__DYNAMIC_IMPORT: (module: string) => Promise<Record<string, unknown>>;
+    var __VIKE__IS_NON_RUNNABLE_DEV: undefined | boolean;
+}
+declare function pluginNonRunnableDev(): Plugin;

package/dist/esm/node/vite/plugins/pluginNonRunnableDev.js

@@ -0,0 +1,49 @@
+export { pluginNonRunnableDev };
+import { createViteRPC, assertIsNotProductionRuntime, requireResolveVikeDistFile, isRunnableDevEnvironment, } from '../utils.js';
+import { resolveClientEntriesDev } from '../shared/resolveClientEntriesDev.js';
+import { retrieveAssetsDev } from '../../runtime/renderPage/getPageAssets/retrieveAssetsDev.js';
+import { getViteConfigRuntime } from '../shared/getViteConfigRuntime.js';
+import { getMagicString } from '../shared/getMagicString.js';
+assertIsNotProductionRuntime();
+function getViteRpcFunctions(viteDevServer) {
+    return {
+        async transformIndexHtmlRPC(html) {
+            return await viteDevServer.transformIndexHtml('/', html);
+        },
+        // TODO/now: dedupe retrievePageAssetsDevRPC and retrievePageAssetsDev()
+        async retrievePageAssetsDevRPC(clientDependencies, clientEntries) {
+            const clientEntriesSrc = clientEntries.map((clientEntry) => resolveClientEntriesDev(clientEntry, viteDevServer));
+            const assetUrls = await retrieveAssetsDev(clientDependencies, viteDevServer);
+            return { clientEntriesSrc, assetUrls };
+        },
+        async getViteConfigRuntimeRPC() {
+            return getViteConfigRuntime(viteDevServer.config);
+        },
+    };
+}
+function pluginNonRunnableDev() {
+    const runtimeGlobalContextFilePath = requireResolveVikeDistFile('dist/esm/node/runtime/globalContext.js');
+    let config;
+    return {
+        name: 'vike:pluginNonRunnableDev',
+        configureServer(viteDevServer) {
+            createViteRPC(viteDevServer, getViteRpcFunctions);
+        },
+        configResolved(config_) {
+            config = config_;
+        },
+        transform(code, id) {
+            if (!config._isDev)
+                return;
+            if (id !== runtimeGlobalContextFilePath)
+                return;
+            const isNonRunnableDev = !isRunnableDevEnvironment(this.environment);
+            const { magicString, getMagicStringResult } = getMagicString(code, id);
+            if (isNonRunnableDev) {
+                magicString.replaceAll('__VIKE__DYNAMIC_IMPORT', 'import');
+            }
+            magicString.replaceAll('__VIKE__IS_NON_RUNNABLE_DEV', JSON.stringify(isNonRunnableDev));
+            return getMagicStringResult();
+        },
+    };
+}

package/dist/esm/node/vite/plugins/pluginVirtualFiles/getVirtualFilePageConfigLazy.js

@@ -1,4 +1,5 @@
 export { getVirtualFilePageConfigLazy };
+// TODO/now: rename file to generateVirtualFileEntryPage.ts
 import { assert, getProjectError } from '../../utils.js';
 import { getVirtualFileIdPageConfigLazy, isVirtualFileIdPageConfigLazy, } from '../../../shared/virtualFiles/virtualFilePageConfigLazy.js';
 import { getVikeConfigInternal } from '../../shared/resolveVikeConfigInternal.js';

package/dist/esm/node/vite/plugins/pluginVirtualFiles/getVirtualFilePageConfigsEager.js

@@ -19,6 +19,10 @@ function getCode(pageConfigs, pageConfigGlobal, isForClientSide, isDev, id, isCl
     lines.push('export const pageConfigGlobalSerialized = {');
     lines.push(getCodePageConfigGlobalSerialized(pageConfigGlobal, isForClientSide, isClientRouting, isDev, importStatements, filesEnv));
     lines.push('};');
+    if (!isForClientSide && isDev) {
+        // https://vite.dev/guide/api-environment-frameworks.html
+        lines.push('if (import.meta.hot) import.meta.hot.accept();');
+    }
     const code = [...importStatements, ...lines].join('\n');
     debug(id, isForClientSide ? 'CLIENT-SIDE' : 'SERVER-SIDE', code);
     return code;

package/dist/esm/node/vite/plugins/pluginVirtualFiles.js

@@ -2,8 +2,7 @@ export { pluginVirtualFiles };
 import { normalizePath } from 'vite';
 import { getVirtualFilePageConfigLazy } from './pluginVirtualFiles/getVirtualFilePageConfigLazy.js';
 import { getVirtualFileEntry } from './pluginVirtualFiles/getVirtualFileEntry.js';
-import { assert, assertPosixPath, isScriptFile } from '../utils.js';
-import { resolveVirtualFileId, isVirtualFileId, getVirtualFileId } from '../../shared/virtualFiles.js';
+import { assert, assertPosixPath, isScriptFile, addVirtualFileIdPrefix, isVirtualFileId, removeVirtualFileIdPrefix, } from '../utils.js';
 import { isVirtualFileIdPageConfigLazy } from '../../shared/virtualFiles/virtualFilePageConfigLazy.js';
 import { isVirtualFileIdEntry } from '../../shared/virtualFiles/virtualFileEntry.js';
 import { reloadVikeConfig, isV1Design, getVikeConfigInternalOptional } from '../shared/resolveVikeConfigInternal.js';
@@ -26,7 +25,7 @@ function pluginVirtualFiles() {
         },
         resolveId(id) {
             if (isVirtualFileId(id)) {
-                return resolveVirtualFileId(id);
+                return addVirtualFileIdPrefix(id);
             }
         },
         async handleHotUpdate(ctx) {
@@ -42,7 +41,7 @@ function pluginVirtualFiles() {
         async load(id, options) {
             if (!isVirtualFileId(id))
                 return undefined;
-            id = getVirtualFileId(id);
+            id = removeVirtualFileIdPrefix(id);
             const isDev = config._isDev;
             assert(typeof isDev === 'boolean');
             if (isVirtualFileIdPageConfigLazy(id)) {

package/dist/esm/node/vite/shared/applyRegExWithMagicString.js

@@ -1,4 +1,5 @@
 export { applyRegExpWithMagicString };
+// TODO/now: replace with .replaceAll() ?
 function applyRegExpWithMagicString(magicString, regExp, replacement) {
     const envStatementRegEx = typeof regExp === 'string' ? new RegExp(regExp, 'g') : regExp;
     let match;

package/dist/esm/node/vite/shared/getMagicString.d.ts

@@ -0,0 +1,9 @@
+export { getMagicString };
+import MagicString from 'magic-string';
+declare function getMagicString(code: string, id: string): {
+    magicString: MagicString;
+    getMagicStringResult: () => {
+        code: string;
+        map: import("magic-string").SourceMap;
+    };
+};

package/dist/esm/node/vite/shared/getMagicString.js

@@ -0,0 +1,13 @@
+export { getMagicString };
+import MagicString from 'magic-string';
+// TODO/now use everywhere
+function getMagicString(code, id) {
+    const magicString = new MagicString(code);
+    const getMagicStringResult = () => {
+        return {
+            code: magicString.toString(),
+            map: magicString.generateMap({ hires: true, source: id }),
+        };
+    };
+    return { magicString, getMagicStringResult };
+}

package/dist/esm/node/vite/shared/getManifestFilePathRelative.d.ts

@@ -0,0 +1,2 @@
+export { getManifestFilePathRelative };
+declare function getManifestFilePathRelative(manifestConfig: string | boolean): string;

package/dist/esm/node/vite/shared/getManifestFilePathRelative.js

@@ -0,0 +1,8 @@
+export { getManifestFilePathRelative };
+import { assert } from '../utils.js';
+function getManifestFilePathRelative(manifestConfig) {
+    assert(['string', 'boolean'].includes(typeof manifestConfig));
+    assert(manifestConfig !== false);
+    const manifestFileRelative = typeof manifestConfig === 'string' ? manifestConfig : '.vite/manifest.json';
+    return manifestFileRelative;
+}

package/dist/esm/node/vite/utils.d.ts

@@ -19,3 +19,4 @@ export * from '../../utils/isDocker.js';
 export * from '../../utils/isVitest.js';
 export * from '../../utils/rollupSourceMap.js';
 export * from '../../utils/isImportPath.js';
+export * from '../../utils/virtualFileId.js';

package/dist/esm/node/vite/utils.js

@@ -26,3 +26,4 @@ export * from '../../utils/isDocker.js';
 export * from '../../utils/isVitest.js';
 export * from '../../utils/rollupSourceMap.js';
 export * from '../../utils/isImportPath.js';
+export * from '../../utils/virtualFileId.js';

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

@@ -9,10 +9,10 @@ import type { GlobalContextServerInternal } from '../node/runtime/globalContext.
 import type { GlobalContextClientInternal } from '../client/runtime-client-routing/globalContext.js';
 import { type Hook } from './hooks/getHook.js';
 declare const getGlobalContextSyncErrMsg = "The global context isn't set yet, call getGlobalContextSync() later or use getGlobalContext() instead.";
-declare function createGlobalContextShared<GlobalContextAdded extends Record<string, any>>(virtualFileExports: unknown, globalObject: {
+declare function createGlobalContextShared<GlobalContextAdded extends Record<string, any>, GlobalContextAddedAsync extends Record<string, any>>(virtualFileExports: unknown, globalObject: {
     globalContext?: Record<string, unknown>;
     onCreateGlobalContextHooks?: Hook[];
-}, addGlobalContext?: (globalContext: GlobalContextBase) => GlobalContextAdded, addGlobalContextTmp?: (globalContext: GlobalContextBase) => Promise<GlobalContextAdded>): Promise<{
+}, addGlobalContext?: (globalContext: GlobalContextBase) => GlobalContextAdded, addGlobalContextTmp?: (globalContext: GlobalContextBase) => Promise<GlobalContextAdded>, addGlobalContextAsync?: (globalContext: GlobalContextBase) => Promise<GlobalContextAddedAsync>): Promise<{
     /**
      * Useful for distinguishing `globalContext` from other objects and narrowing down TypeScript unions.
      *
@@ -35,7 +35,7 @@ declare function createGlobalContextShared<GlobalContextAdded extends Record<str
     pages: {
         [k: string]: import("./page-configs/resolveVikeConfigPublic.js").VikeConfigPublicPageEager;
     };
-} & GlobalContextAdded>;
+} & GlobalContextAdded & GlobalContextAddedAsync>;
 type GlobalContextBasePublic = Pick<GlobalContextBase, 'config' | 'pages' | 'isGlobalContext'>;
 type GlobalContextBase = ReturnType<typeof createGlobalContextBase>;
 declare function createGlobalContextBase(virtualFileExports: unknown): {

package/dist/esm/shared/createGlobalContextShared.js

@@ -9,7 +9,7 @@ import { getHookFromPageConfigGlobalCumulative } from './hooks/getHook.js';
 const getGlobalContextSyncErrMsg = "The global context isn't set yet, call getGlobalContextSync() later or use getGlobalContext() instead.";
 async function createGlobalContextShared(virtualFileExports, globalObject, addGlobalContext, 
 // TO-DO/next-major-release: we'll be able to remove addGlobalContextTmp after loadPageRoutes() is sync (it will be sync after we remove the old design)
-addGlobalContextTmp) {
+addGlobalContextTmp, addGlobalContextAsync) {
     const globalContext = createGlobalContextBase(virtualFileExports);
     let isNewGlobalContext;
     if (!globalObject.globalContext) {
@@ -31,6 +31,10 @@ addGlobalContextTmp) {
         const globalContextAdded = await addGlobalContextTmp?.(globalContext);
         objectAssign(globalContext, globalContextAdded);
     }
+    {
+        const globalContextAddedAsync = await addGlobalContextAsync?.(globalContext);
+        objectAssign(globalContext, globalContextAddedAsync);
+    }
     const onCreateGlobalContextHooks = getHookFromPageConfigGlobalCumulative(globalContext._pageConfigGlobal, 'onCreateGlobalContext');
     let hooksCalled = false;
     if (!hooksAreEqual(globalObject.onCreateGlobalContextHooks ?? [], onCreateGlobalContextHooks)) {

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

@@ -1,4 +1,10 @@
 export { parseVirtualFileExports };
+// TODO/now: rename parseVirtualFileExportsEntryGlobal
+// TODO/now: merge or collocate following both files?
+// ```filesystem
+// vike/packages/vike/shared/getPageFiles/parseVirtualFileExports.ts
+// vike/shared/page-configs/serialize/parsePageConfigs.ts
+// ```
 // TO-DO/next-major-release: remove old design code, and remove all assertions.
 import { assert, hasProp, isCallable, isObject, cast, isArray } from '../utils.js';
 import { assertExportValues } from './assert_exports_old_design.js';

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

@@ -1 +1 @@
-export declare const PROJECT_VERSION: "0.4.236-commit-e752d12";
+export declare const PROJECT_VERSION: "0.4.236-commit-79f1ef0";