vike 0.4.256-commit-85a5a9e → 0.4.257-commit-c6e29ea

package/dist/node/api/preview.js

@@ -9,6 +9,7 @@ import { isCallable } from '../../utils/isCallable.js';
 import pc from '@brillout/picocolors';
 import path from 'node:path';
 import { getVikeConfigInternal } from '../vite/shared/resolveVikeConfigInternal.js';
+import { isUniversalDeployVitePreview } from '../vite/plugins/pluginUniversalDeploy/getServerConfig.js';
 import './assertEnvApiDev.js';
 /**
  * Programmatically trigger `$ vike preview`
@@ -18,14 +19,22 @@ import './assertEnvApiDev.js';
 async function preview(options = {}) {
     onSetupPreview();
     const { viteConfigFromUserResolved, viteConfigResolved } = await prepareViteApiCall(options, 'preview');
-    const cliPreview = await resolveCliPreviewConfig();
-    assertUsage(cliPreview !== false, `${pc.cyan('$ vike preview')} isn't supported`);
-    const useVite = cliPreview === 'vite' || (cliPreview === undefined && !viteConfigResolved.vitePluginServerEntry?.inject);
-    if (!useVite) {
+    const vikeConfig = await getVikeConfigInternal();
+    const cliPreviewConfig = await resolveCliPreviewConfig(vikeConfig);
+    assertUsage(cliPreviewConfig !== false, `${pc.cyan('$ vike preview')} isn't supported`);
+    const isUDVitePreview = isUniversalDeployVitePreview(vikeConfig, viteConfigResolved);
+    const useVitePreviewServer = cliPreviewConfig === 'vite' ||
+        (cliPreviewConfig === undefined &&
+            // dist/server/index.mjs exists when using @brillout/vite-plugin-server-entry inject mode; otherwise it's missing -> we must use Vite's preview server
+            (!viteConfigResolved.vitePluginServerEntry?.inject ||
+                // dist/server/index.mjs doesn't exist with some deployment plugins such as vite-plugin-vercel -> we must use Vite's preview server
+                isUDVitePreview));
+    if (!useVitePreviewServer) {
         // Dynamically import() server production entry dist/server/index.js
         const outDir = getOutDirs(viteConfigResolved, undefined).outDirRoot;
         const { outServerIndex } = await importServerProductionIndex({ outDir });
         const outServerIndexRelative = path.relative(viteConfigResolved.root, outServerIndex);
+        // TODO/after-PR-merge: always show a warning
         assertWarning(false, `Never run ${pc.cyan('$ vike preview')} in production, run ${pc.cyan(`$ node ${outServerIndexRelative}`)} instead (or Bun/Deno).`, { onlyOnce: true });
         return {
             viteConfig: viteConfigResolved,
@@ -40,8 +49,7 @@ async function preview(options = {}) {
         };
     }
 }
-async function resolveCliPreviewConfig() {
-    const vikeConfig = await getVikeConfigInternal();
+async function resolveCliPreviewConfig(vikeConfig) {
     const val = vikeConfig.config.cli?.preview;
     if (!isCallable(val)) {
         return val;

package/dist/node/vite/plugins/pluginDev/optimizeDeps.js

@@ -55,8 +55,9 @@ const optimizeDeps = {
             exclude: [
                 '@brillout/import',
                 '@brillout/json-serializer',
-                // FIXME Breaks @cloudflare/vite-plugin. Remove me if CI passes
-                // '@brillout/picocolors',
+                /* Adding @brillout/picocolors breaks the UD + Cloudflare test, we don't know why. TO-DO/eventually: re-add it and see if Vike's CI is green.
+                '@brillout/picocolors',
+                */
                 '@brillout/vite-plugin-server-entry',
                 'vike',
             ],

package/dist/node/vite/plugins/pluginUniversalDeploy/common.d.ts

@@ -1,6 +1,7 @@
+export { pluginCommon };
 import type { Plugin } from 'vite';
 import '../../assertEnvVite.js';
-export declare const pluginCommon: {
+declare const pluginCommon: {
     applyToEnvironment(env: {
         name: string;
         getTopLevelConfig(): import("vite").ResolvedConfig;

package/dist/node/vite/plugins/pluginUniversalDeploy/common.js

@@ -1,5 +1,6 @@
+export { pluginCommon };
 import '../../assertEnvVite.js';
-export const pluginCommon = {
+const pluginCommon = {
     applyToEnvironment(env) {
         return env.config.consumer === 'server';
     },

package/dist/node/vite/plugins/pluginUniversalDeploy/detectDeprecated.d.ts

@@ -1,3 +1,4 @@
+export { hasVikeServerOrVikePhoton };
 import type { VikeConfigInternal } from '../../shared/resolveVikeConfigInternal.js';
 import '../../assertEnvVite.js';
-export declare function hasVikeServerOrVikePhoton(vikeConfig: VikeConfigInternal): true | undefined;
+declare function hasVikeServerOrVikePhoton(vikeConfig: VikeConfigInternal): true | undefined;

package/dist/node/vite/plugins/pluginUniversalDeploy/detectDeprecated.js

@@ -1,15 +1,21 @@
-import { assertWarning } from '../../../../utils/assert.js';
+export { hasVikeServerOrVikePhoton };
+import { assert, assertWarning } from '../../../../utils/assert.js';
 import pc from '@brillout/picocolors';
 import '../../assertEnvVite.js';
-export function hasVikeServerOrVikePhoton(vikeConfig) {
-    const vikeExtendsNames = new Set(vikeConfig._extensions.map((plusFile) => ('fileExportsByConfigName' in plusFile ? plusFile.fileExportsByConfigName : {}).name));
-    const vikeServerOrVikePhoton = vikeExtendsNames.has('vike-server')
+function hasVikeServerOrVikePhoton(vikeConfig) {
+    const vikeExtensionNames = vikeConfig._extensions.map((plusFile) => {
+        assert(plusFile.isConfigFile);
+        const { name } = plusFile.fileExportsByConfigName;
+        assert(typeof name === 'string');
+        return name;
+    });
+    const vikeServerOrVikePhoton = vikeExtensionNames.includes('vike-server')
         ? 'vike-server'
-        : vikeExtendsNames.has('vike-photon')
+        : vikeExtensionNames.includes('vike-photon')
             ? 'vike-photon'
             : null;
     if (vikeServerOrVikePhoton) {
-        assertWarning(false, `${pc.cyan(vikeServerOrVikePhoton)} is deprecated, see ${pc.underline('https://vike.dev/migration/universal-deploy')}`, { onlyOnce: true });
+        assertWarning(false, `${pc.cyan(vikeServerOrVikePhoton)} is deprecated, see ${pc.underline('https://vike.dev/migration/server')}`, { onlyOnce: true });
         return true;
     }
 }

package/dist/node/vite/plugins/pluginUniversalDeploy/getDeployConfig.d.ts

@@ -0,0 +1,10 @@
+export { getDeployConfig };
+import { fromVike } from 'convert-route/vike';
+import type { PageConfigPublicWithRoute } from '../../../../shared-server-client/page-configs/resolveVikeConfigPublic.js';
+import '../../assertEnvVite.js';
+import type { Vercel } from '../../../../types/Config.js';
+type RouteIr = ReturnType<typeof fromVike>;
+declare function getDeployConfig(pageId: string, page: PageConfigPublicWithRoute): null | {
+    route: RouteIr[];
+    vercel: Vercel;
+};

package/dist/node/vite/plugins/pluginUniversalDeploy/{getDeployConfigs.js → getDeployConfig.js}

@@ -1,9 +1,11 @@
-export { getDeployConfigs };
+export { getDeployConfig };
+import { fromVike } from 'convert-route/vike';
 import { assert, assertUsage, assertWarning } from '../../../../utils/assert.js';
 import { isObject } from '../../../../utils/isObject.js';
 import '../../assertEnvVite.js';
 import { isCallable } from '../../../../utils/isCallable.js';
-function getDeployConfigs(pageId, page) {
+import { pageContextJsonFileExtension } from '../../../../shared-server-client/getPageContextRequestUrl.js';
+function getDeployConfig(pageId, page) {
     const { route } = page;
     if (!route)
         return null;
@@ -32,14 +34,14 @@ function getDeployConfigs(pageId, page) {
         assertWarning(!edge, errMsg('+edge'), { onlyOnce: true });
         return null;
     }
+    const routeIr = fromVike(route);
     return {
-        route,
-        // route: [...new Set([...toRou3(routeIr), ...getRoutePageContextJson(routeIr)])],
+        route: [routeIr, getRouteIrPageContextJson(routeIr)].filter((r) => r !== undefined),
         // Supported by vite-plugin-vercel@11
         vercel: { isr, edge },
     };
 }
-export function getRoutePageContextJson(routeIr) {
+function getRouteIrPageContextJson(routeIr) {
     const lastSegment = routeIr.pathname.at(-1);
     assert(lastSegment);
     if (lastSegment.catchAll)
@@ -49,7 +51,7 @@ export function getRoutePageContextJson(routeIr) {
             ...routeIr.pathname.slice(0, -1),
             {
                 ...lastSegment,
-                value: `${lastSegment.value}.pageContext.json`,
+                value: lastSegment.value + pageContextJsonFileExtension,
             },
         ],
     };

package/dist/node/vite/plugins/pluginUniversalDeploy/getServerConfig.d.ts

@@ -0,0 +1,11 @@
+export { getServerConfig };
+export { isUniversalDeployVitePreview };
+import type { ResolvedConfig } from 'vite';
+import type { VikeConfigInternal } from '../../shared/resolveVikeConfigInternal.js';
+import '../../assertEnvVite.js';
+declare function getServerConfig(vikeConfig: VikeConfigInternal): {
+    serverEntryId: string;
+    serverEntryVike: string;
+    serverFilePath: string | null;
+} | undefined;
+declare function isUniversalDeployVitePreview(vikeConfig: VikeConfigInternal, viteConfigResolved: ResolvedConfig): boolean;

package/dist/node/vite/plugins/pluginUniversalDeploy/{getServerInfo.js → getServerConfig.js}

@@ -1,7 +1,9 @@
-import { assert } from '../../../../utils/assert.js';
+export { getServerConfig };
+export { isUniversalDeployVitePreview };
 import { catchAllEntry } from '@universal-deploy/store';
+import { assert } from '../../../../utils/assert.js';
 import '../../assertEnvVite.js';
-export function getServerInfo(vikeConfig) {
+function getServerConfig(vikeConfig) {
     let serverEntryId;
     let serverFilePath = null;
     let serverEntryVike;
@@ -36,3 +38,12 @@ export function getServerInfo(vikeConfig) {
         serverFilePath,
     };
 }
+function isUniversalDeployVitePreview(vikeConfig, viteConfigResolved) {
+    const isServerConfig = getServerConfig(vikeConfig);
+    if (!isServerConfig)
+        return false;
+    // @universal-deploy/node -> real preview
+    // else -> vite preview
+    const udNodePlugin = viteConfigResolved.plugins.find((p) => p.name.startsWith('ud:node:emit'));
+    return !udNodePlugin;
+}

package/dist/node/vite/plugins/pluginUniversalDeploy/pluginResolvePlusServer.d.ts

@@ -1,6 +1,7 @@
+export { pluginResolvePlusServer };
 import type { Plugin } from 'vite';
 import '../../assertEnvVite.js';
 /**
  * If +server.js is defined, make virtual:ud:catch-all resolve to +server.js absolute path
  */
-export declare function pluginServerEntryInject(serverFilePath: string): Plugin;
+declare function pluginResolvePlusServer(serverFilePath: string): Plugin;

package/dist/node/vite/plugins/pluginUniversalDeploy/pluginResolvePlusServer.js

@@ -1,10 +1,11 @@
+export { pluginResolvePlusServer };
 import { pluginCommon } from './common.js';
 import { escapeRegex } from '../../../../utils/escapeRegex.js';
 import '../../assertEnvVite.js';
 /**
  * If +server.js is defined, make virtual:ud:catch-all resolve to +server.js absolute path
  */
-export function pluginServerEntryInject(serverFilePath) {
+function pluginResolvePlusServer(serverFilePath) {
     return {
         name: 'vike:pluginUniversalDeploy:server',
         resolveId: {

package/dist/node/vite/plugins/pluginUniversalDeploy/pluginServerEntryAlias.d.ts

@@ -1,4 +1,5 @@
 export { pluginServerEntryAlias };
 import type { Plugin } from 'vite';
 import '../../assertEnvVite.js';
-declare function pluginServerEntryAlias(): Plugin;
+/** Alias for virtual:ud:catch if no userland server entry */
+declare function pluginServerEntryAlias(serverFilePath?: string | null): Plugin;

package/dist/node/vite/plugins/pluginUniversalDeploy/pluginServerEntryAlias.js

@@ -1,18 +1,40 @@
 export { pluginServerEntryAlias };
+import { catchAllEntry } from '@universal-deploy/store';
 import { pluginCommon } from './common.js';
 import { escapeRegex } from '../../../../utils/escapeRegex.js';
-import { catchAllEntry } from '@universal-deploy/store';
+import { assert } from '../../../../utils/assert.js';
 import '../../assertEnvVite.js';
-function pluginServerEntryAlias() {
+const serverEntryAlias = 'vike:server-entry';
+const virtualFileId = '\0' + serverEntryAlias;
+// === Rolldown filter
+const filterRolldown = {
+    id: {
+        include: [new RegExp(escapeRegex(serverEntryAlias)), new RegExp(escapeRegex(virtualFileId))],
+    },
+};
+// ===
+/** Alias for virtual:ud:catch if no userland server entry */
+function pluginServerEntryAlias(serverFilePath) {
     return {
         name: 'vike:pluginUniversalDeploy:alias',
         resolveId: {
-            filter: {
-                // User facing alias for virtual:ud:catch-all
-                id: new RegExp(escapeRegex('vike:server-entry')),
+            filter: filterRolldown,
+            handler() {
+                if (!serverFilePath)
+                    return catchAllEntry;
+                return virtualFileId;
             },
+        },
+        load: {
+            filter: filterRolldown,
             handler() {
-                return this.resolve(catchAllEntry);
+                assert(serverFilePath);
+                // Also re-export non-default exports, to support Durable Objects
+                return `import mod from ${JSON.stringify(catchAllEntry)};
+
+export * from ${JSON.stringify(serverFilePath)};
+export default mod;
+`;
             },
         },
         ...pluginCommon,

package/dist/node/vite/plugins/pluginUniversalDeploy/pluginServerEntryInject.d.ts

@@ -1,3 +1,4 @@
+export { pluginServerEntryInject };
 import type { Plugin } from 'vite';
 import '../../assertEnvVite.js';
-export declare function pluginServerEntryInject(serverEntryId: string): Plugin;
+declare function pluginServerEntryInject(serverEntryId: string): Plugin;

package/dist/node/vite/plugins/pluginUniversalDeploy/pluginServerEntryInject.js

@@ -1,9 +1,10 @@
+export { pluginServerEntryInject };
 import { getMagicString } from '../../shared/getMagicString.js';
 import { serverEntryVirtualId } from '@brillout/vite-plugin-server-entry/plugin';
 import { pluginCommon } from './common.js';
 import '../../assertEnvVite.js';
 import { escapeRegex } from '../../../../utils/escapeRegex.js';
-export function pluginServerEntryInject(serverEntryId) {
+function pluginServerEntryInject(serverEntryId) {
     return {
         name: 'vike:pluginUniversalDeploy:serverEntry',
         apply: 'build',

package/dist/node/vite/plugins/pluginUniversalDeploy/pluginUnwrapProdOptions.d.ts

@@ -1,3 +1,4 @@
+export { pluginUnwrapProdOptions };
 import type { Plugin } from 'vite';
 import '../../assertEnvVite.js';
-export declare function pluginUnwrapProdOptions(serverFilePath: string): Plugin;
+declare function pluginUnwrapProdOptions(serverFilePath: string): Plugin;

package/dist/node/vite/plugins/pluginUniversalDeploy/pluginUnwrapProdOptions.js

@@ -1,7 +1,8 @@
+export { pluginUnwrapProdOptions };
 import { wrapper } from 'vite-plugin-wrapper';
 import { escapeRegex } from '../../../../utils/escapeRegex.js';
 import '../../assertEnvVite.js';
-export function pluginUnwrapProdOptions(serverFilePath) {
+function pluginUnwrapProdOptions(serverFilePath) {
     return wrapper({
         resolveId: {
             filter: {
@@ -12,6 +13,8 @@ export function pluginUnwrapProdOptions(serverFilePath) {
         load(id) {
             return `
 import mod from ${JSON.stringify(id)};
+
+export * from ${JSON.stringify(id)};
 export default { ...mod, ...mod?.prod };
 `;
         },

package/dist/node/vite/plugins/pluginUniversalDeploy.js

@@ -2,12 +2,11 @@ export { pluginUniversalDeploy };
 import { toRou3 } from 'convert-route';
 import { addEntry } from '@universal-deploy/store';
 import universalDeploy, { resolveTargets } from '@universal-deploy/vite';
-import { fromVike } from 'convert-route/vike';
 import { pluginServerEntryInject } from './pluginUniversalDeploy/pluginServerEntryInject.js';
-import { getDeployConfigs, getRoutePageContextJson } from './pluginUniversalDeploy/getDeployConfigs.js';
+import { getDeployConfig } from './pluginUniversalDeploy/getDeployConfig.js';
 import { pluginCommon } from './pluginUniversalDeploy/common.js';
 import { hasVikeServerOrVikePhoton } from './pluginUniversalDeploy/detectDeprecated.js';
-import { getServerInfo } from './pluginUniversalDeploy/getServerInfo.js';
+import { getServerConfig } from './pluginUniversalDeploy/getServerConfig.js';
 import { pluginServerEntryAlias } from './pluginUniversalDeploy/pluginServerEntryAlias.js';
 import { pluginUnwrapProdOptions } from './pluginUniversalDeploy/pluginUnwrapProdOptions.js';
 import { unique } from '../../../utils/unique.js';
@@ -16,16 +15,16 @@ import '../assertEnvVite.js';
 function pluginUniversalDeploy(vikeConfig) {
     if (hasVikeServerOrVikePhoton(vikeConfig))
         return [];
-    const serverInfo = getServerInfo(vikeConfig);
-    if (!serverInfo)
+    const serverConfig = getServerConfig(vikeConfig);
+    if (!serverConfig)
         return [
-            resolveTargets(({ vercel, node, netlify }) => {
+            resolveTargets((targets) => {
                 // Cloudflare is supported even without universal-deploy
-                const target = vercel ? 'Vercel' : node ? 'Node.js' : netlify ? 'Netlify' : null;
-                assertUsage(target === null, `Cannot target ${target} without a server entry. Either set \`server: true\` in +config.js or create a \`+server.js\` file.`);
+                const target = targets.filter((t) => t !== '@cloudflare/vite-plugin')[0];
+                assertUsage(target === undefined, `${target} requires +server — see https://vike.dev/server`);
             }),
         ];
-    const { serverEntryVike, serverEntryId, serverFilePath } = serverInfo;
+    const { serverEntryVike, serverEntryId, serverFilePath } = serverConfig;
     return [
         ...universalDeploy(),
         {
@@ -33,17 +32,15 @@ function pluginUniversalDeploy(vikeConfig) {
             config() {
                 // Map each Vike route to universal-deploy
                 for (const [pageId, page] of Object.entries(vikeConfig.pages)) {
-                    const deployConfigs = getDeployConfigs(pageId, page);
-                    // Skip pages without deploy configs, as they will be handled by the catch-all route
-                    if (deployConfigs !== null) {
-                        const { route, ...additionalConfigs } = deployConfigs;
-                        const routeIr = fromVike(route);
-                        const routeIrPageContextJson = getRoutePageContextJson(routeIr);
+                    const deployConfig = getDeployConfig(pageId, page);
+                    // Skip pages without a deploy configuration, as they will be handled by the catch-all route
+                    if (deployConfig) {
+                        const { route, ...config } = deployConfig;
                         addEntry({
-                            ...additionalConfigs,
+                            ...config,
                             id: serverEntryVike,
                             // Map Vike routes to rou3 format
-                            route: unique([...toRou3(routeIr), ...(routeIrPageContextJson ? toRou3(routeIrPageContextJson) : [])]),
+                            route: unique(route.map(toRou3).flat()),
                         });
                     }
                 }
@@ -56,7 +53,7 @@ function pluginUniversalDeploy(vikeConfig) {
             ...pluginCommon,
         },
         pluginServerEntryInject(serverFilePath ?? serverEntryId),
-        pluginServerEntryAlias(),
+        pluginServerEntryAlias(serverFilePath),
         !serverFilePath ? null : pluginUnwrapProdOptions(serverFilePath),
     ].filter((p) => p !== null);
 }

package/dist/node/vite/plugins/pluginWorkaroundVite6HmrRegression.js

@@ -11,7 +11,8 @@ function pluginWorkaroundVite6HmrRegression() {
             enforce: 'post',
             hotUpdate: {
                 order: 'post',
-                handler({ modules, server, timestamp }) {
+                async handler(ctx) {
+                    const { modules, server, timestamp } = ctx;
                     if (this.environment.name !== 'ssr')
                         return;
                     let hasSsrOnlyModules = false;

package/dist/node/vite/shared/resolveVikeConfigInternal/configDefinitionsBuiltIn.d.ts

@@ -34,7 +34,11 @@ type ConfigDefinition_ = {
      */
     effect?: ConfigEffect;
     /**
-     * Always load the configuration value, and as soon as possible.
+     * Load the configuration of *all* pages (regardless of what page is being rendered).
+     *
+     * WARNING: this might bloat server- and client-side KBs.
+     *
+     * By default, to save server- and client-side KBs, the configuration of a page is only loaded when rendering that page.
      *
      * @default false
      *

package/dist/node/vite/shared/resolveVikeConfigInternal/configDefinitionsBuiltIn.js

@@ -310,10 +310,8 @@ const configDefinitionsBuiltIn = {
         env: { config: true },
         global: true,
     },
-    // -- Vercel --
     vercel: {
-        env: { server: true, config: true },
-        eager: true,
+        env: { config: true },
     },
 };
 function getConfigEnv(pageConfig, configName) {

package/dist/node/vite/shared/resolveVikeConfigInternal/pointerImports.d.ts

@@ -17,10 +17,13 @@ declare function transformPointerImports(code: string, filePathToShowToUser2: st
  * We discard the import name `someImport` because we don't need it.
  */
 type PointerImportData = {
+    importStringWasGenerated: boolean;
+    /** For example: `import:./some-file:someExport` */
+    importString: string;
+    /** For example: `./some-file` */
     importPath: string;
+    /** For example: `someExport` */
     exportName: string;
-    importString: string;
-    importStringWasGenerated: boolean;
 };
 declare function parsePointerImportData(importString: string): null | PointerImportData;
 declare function assertPointerImportPath(importPath: string): boolean;

package/dist/node/vite/shared/resolveVikeConfigInternal/resolvePointerImport.js

@@ -78,7 +78,15 @@ function resolveImportPathWithNode(pointerImportData, importerFilePath, userRoot
         userRootDir,
     });
     if (!filePathAbsoluteFilesystem) {
-        assert(!isImportPathRelative(pointerImportData.importPath));
+        if (isImportPathRelative(pointerImportData.importPath)) {
+            const { importPath, importStringWasGenerated, importString } = pointerImportData;
+            const { filePathToShowToUserResolved } = importerFilePath;
+            assert(filePathToShowToUserResolved);
+            const errIntro = importStringWasGenerated
+                ? `The import path ${pc.cyan(importPath)} in ${filePathToShowToUserResolved}`
+                : `The import ${pc.cyan(importString)} defined by ${filePathToShowToUserResolved}`;
+            assertUsage(false, `${errIntro} couldn't be resolved: does ${pc.cyan(importPath)} point to an existing file?`);
+        }
         /* This assertion fails if the npm package has a wrongly defined package.json#exports
         // Libraries don't use path aliases => filePathAbsoluteFilesystem should be defined
         assert(!importerFilePathAbsolute.includes('node_modules'))

package/dist/server/runtime/globalContext.js

@@ -43,6 +43,7 @@ import { getGlobalObject } from '../../utils/getGlobalObject.js';
 import { hasProp } from '../../utils/hasProp.js';
 import { isObject } from '../../utils/isObject.js';
 import { objectAssign } from '../../utils/objectAssign.js';
+import { isCloudflareWorkers } from '../../utils/isCloudflareWorkers.js';
 import { importServerProductionEntry } from '@brillout/vite-plugin-server-entry/runtime';
 import { virtualFileIdGlobalEntryServer } from '../../shared-server-node/virtualFileId.js';
 import pc from '@brillout/picocolors';
@@ -229,7 +230,7 @@ async function initGlobalContext() {
         await globalObject.waitForUserFilesUpdate;
     }
     else {
-        await loadProdBuildEntry(globalObject.viteConfigRuntime?.build.outDir);
+        await loadProdBuildEntry(false, globalObject.viteConfigRuntime?.build.outDir);
     }
     assertGlobalContextIsDefined();
     globalObject.isInitialized = true;
@@ -247,7 +248,9 @@ function assertViteManifest(manifest) {
       })
     */
 }
-async function loadProdBuildEntry(outDir) {
+async function loadProdBuildEntry(
+// Whether loadProdBuildEntry() is called at module initialization (when JavaScript modules are loaded), e.g. it's `false` when loadProdBuildEntry() was triggered by renderPage()
+isModuleInit, outDir) {
     debug('loadProdBuildEntry()');
     if (globalObject.globalContext) {
         debug('loadProdBuildEntry() - already done');
@@ -274,7 +277,11 @@ async function loadProdBuildEntry(outDir) {
     assertProdBuildEntry(prodBuildEntry);
     globalObject.assetsManifest = prodBuildEntry.assetsManifest;
     globalObject.buildInfo = prodBuildEntry.buildInfo;
-    await createGlobalContext(prodBuildEntry.virtualFileExportsGlobalEntry);
+    // Don't call +onCreateGlobalContext() during module initialization in Cloudflare Workers, to avoid the error "Disallowed operation called within global scope", see https://github.com/vikejs/vike/pull/3106#issuecomment-4209583465
+    const skipGlobalContextInit = isCloudflareWorkers() && isModuleInit;
+    if (!skipGlobalContextInit) {
+        await createGlobalContext(prodBuildEntry.virtualFileExportsGlobalEntry);
+    }
 }
 // This is the production entry, see:
 // https://github.com/vikejs/vike/blob/8c350e8105a626469e87594d983090919e82099b/packages/vike/node/vite/plugins/pluginBuild/pluginProdBuildEntry.ts#L47
@@ -286,8 +293,7 @@ async function setGlobalContext_prodBuildEntry(prodBuildEntry) {
     globalObject.prodBuildEntry = prodBuildEntry;
     globalObject.prodBuildEntryPrevious = prodBuildEntry;
     assert(globalObject.prodBuildEntry); // ensure no infinite loop
-    await loadProdBuildEntry();
-    assertGlobalContextIsDefined();
+    await loadProdBuildEntry(true);
     debug('setGlobalContext_prodBuildEntry() - done');
 }
 function assertProdBuildEntry(prodBuildEntry) {

package/dist/server/runtime/renderPageServer/createPageContextServer.d.ts

@@ -3,10 +3,10 @@ export { createPageContextServerWithoutGlobalContext };
 export type { PageContextCreatedServer };
 export type { PageContextCreatedServerWithoutGlobalContext };
 import type { GlobalContextServerInternal } from '../globalContext.js';
-import type { PageContextInit, PageContextInternalInit } from '../renderPageServer.js';
+import type { PageContextInit, PageContextInitInternal } from '../renderPageServer.js';
 import '../../assertEnvServer.js';
 type PageContextCreatedServer = Awaited<ReturnType<typeof createPageContextServer>>;
-declare function createPageContextServer(pageContextInit: PageContextInternalInit & {
+declare function createPageContextServer(pageContextInit: PageContextInitInternal & {
     headers?: Record<string, unknown>;
 }, globalContext: GlobalContextServerInternal, args: {
     requestId: number;

package/dist/server/runtime/renderPageServer.d.ts

@@ -1,21 +1,21 @@
 export { renderPageServer };
 export { getRequestTag };
 export type { PageContextInit };
-export type { PageContextInternalInit };
+export type { PageContextInitInternal };
 export type { PageContextBegin };
 export type { RequestTag };
 import { type PageContextAborted } from '../../shared-server-client/route/abort.js';
 import { type GlobalContextServerInternal } from './globalContext.js';
 import { type HttpResponse } from './renderPageServer/createHttpResponse.js';
 import type { PageContextServer } from '../../types/index.js';
-import type { PageContextInit, PageContextInternalInit } from '../../types/PageContext.js';
+import type { PageContextInit, PageContextInitInternal } from '../../types/PageContext.js';
 import { type AsyncStore } from './asyncHook.js';
 import '../assertEnvServer.js';
 type PageContextBegin = ReturnType<typeof getPageContextBegin>;
-declare function renderPageServer<PageContextUserAdded extends {}, PageContextInitUser extends PageContextInternalInit>(pageContextInit: PageContextInitUser): Promise<PageContextInitUser & {
+declare function renderPageServer<PageContextUserAdded extends {}, PageContextInitUser extends PageContextInitInternal>(pageContextInit: PageContextInitUser): Promise<PageContextInitUser & {
     httpResponse: HttpResponse;
 } & Partial<PageContextServer & PageContextUserAdded>>;
-declare function getPageContextBegin(pageContextInit: PageContextInternalInit, globalContext: GlobalContextServerInternal, requestId: number, asyncStore: AsyncStore): {
+declare function getPageContextBegin(pageContextInit: PageContextInitInternal, globalContext: GlobalContextServerInternal, requestId: number, asyncStore: AsyncStore): {
     _isOriginalObject: true;
     isPageContext: true;
 } & {

package/dist/shared-server-client/page-configs/assertPlusFileExport.js

@@ -8,7 +8,9 @@ const SIDE_EXPORTS_TOLERATE = [
     '_rerender_only',
 ];
 // Tolerate `export { frontmatter }` in .mdx files
+// Tolerate any exports from `+server.ts` for Cloudflare Durable Object
 const SIDE_EXPORTS_DO_NOT_CHECK = ['.md', '.mdx'];
+const SIDE_EXPORTS_DO_NOT_CHECK_CONFIG = ['server'];
 function assertPlusFileExport(fileExports, filePathToShowToUser, configName) {
     const exportNames = Object.keys(fileExports);
     const isValid = (exportName) => exportName === 'default' || exportName === configName;
@@ -24,10 +26,12 @@ function assertPlusFileExport(fileExports, filePathToShowToUser, configName) {
     }
     assert(exportNamesValid.length === 1);
     // Warn upon side exports
-    const exportNamesInvalid = exportNames
-        .filter((e) => !isValid(e))
-        .filter((exportName) => !SIDE_EXPORTS_TOLERATE.includes(exportName));
-    if (!SIDE_EXPORTS_DO_NOT_CHECK.some((ext) => filePathToShowToUser.endsWith(ext))) {
+    const skip = SIDE_EXPORTS_DO_NOT_CHECK_CONFIG.includes(configName) ||
+        SIDE_EXPORTS_DO_NOT_CHECK.some((ext) => filePathToShowToUser.endsWith(ext));
+    if (!skip) {
+        const exportNamesInvalid = exportNames
+            .filter((e) => !isValid(e))
+            .filter((exportName) => !SIDE_EXPORTS_TOLERATE.includes(exportName));
         exportNamesInvalid.forEach((exportInvalid) => {
             assertWarning(false, `${filePathToShowToUser} unexpected ${pc.cyan(`export { ${exportInvalid} }`)}, see https://vike.dev/no-side-exports`, {
                 onlyOnce: true,

package/dist/types/Config.d.ts

@@ -10,6 +10,7 @@ export type { HookNamePage };
 export type { HookNameGlobal };
 export type { Route };
 export type { KeepScrollPosition };
+export type { Vercel };
 export type { DataAsync };
 export type { DataSync };
 export type { GuardAsync };
@@ -557,21 +558,26 @@ type ConfigBuiltIn = {
     license?: string;
     /**
      * Vercel options
+     *
+     * https://vike.dev/vercel
      */
-    vercel?: {
-        /** Incremental Static Regeneration (ISR).
-         *
-         * https://vike.dev/vercel#isr
-         */
-        isr?: {
-            expiration: number;
-        };
-        /** Deploy on Vercel Edge.
-         *
-         * https://vike.dev/vercel
-         */
-        edge?: boolean;
+    vercel?: Vercel;
+};
+type Vercel = {
+    /**
+     * Incremental Static Regeneration (ISR).
+     *
+     * https://vike.dev/vercel#isr
+     */
+    isr?: {
+        expiration: number;
     };
+    /**
+     * Deploy on Vercel Edge.
+     *
+     * https://vike.dev/vercel#edge
+     */
+    edge?: boolean;
 };
 type PrerenderSetting = boolean | {
     /**

package/dist/types/FilePath.d.ts

@@ -15,11 +15,11 @@ type FilePathResolved = FilePathCommon & {
      */
     filePathAbsoluteFilesystem: string;
     /**
-     * The file's path, shown to the user in logs.
+     * The file path shown to the user in logs.
      *
-     * Resolved: it always shows a file path. (It never shows an import path such as `vike-react/config`.)
+     * Its value is: `filePath.filePathAbsoluteUserRootDir ?? filePath.filePathAbsoluteFilesystem`.
      *
-     * Its value is equivalent to `filePath.filePathAbsoluteUserRootDir ?? filePath.filePathAbsoluteFilesystem`.
+     * Note that it always shows a file path. (It never shows an import path such as `vike-react/config`.)
      */
     filePathToShowToUserResolved: string;
     /**
@@ -52,11 +52,11 @@ type FilePathAbsoluteUserRootDir = {
 };
 type FilePathCommon = {
     /**
-     * The file's path, shown to the user in logs.
+     * The file or import path shown to the user in logs.
      *
-     * Unresolved: it may show an import path instead of a file path such as `vike-react/config`.
+     * Its value is: `filePath.filePathAbsoluteUserRootDir ?? filePath.importPathAbsolute`.
      *
-     * Its value is equivalent to `filePath.filePathAbsoluteUserRootDir ?? filePath.importPathAbsolute`.
+     * Note that if `filePath.filePathAbsoluteUserRootDir` isn't defined then it shows the import path (e.g. `vike-react/config`) instead of a file path.
      */
     filePathToShowToUser: string;
     /**

package/dist/types/PageContext.d.ts

@@ -8,11 +8,12 @@ export type { PageContextInternalServer };
 export type { PageContextInternalClient };
 export type { PageContextInternalClient_ServerRouting };
 export type { PageContextInternalClient_ClientRouting };
-export type { PageContextInternalInit };
+export type { PageContextInitInternal };
 export type { PageContextInit };
 export type { PageContextBuiltInServer_deprecated as PageContextBuiltInServer };
 export type { PageContextBuiltInClientWithClientRouting_deprecated as PageContextBuiltInClientWithClientRouting };
 export type { PageContextBuiltInClientWithServerRouting_deprecated as PageContextBuiltInClientWithServerRouting };
+import type { RuntimeAdapterTarget } from '@universal-middleware/core';
 import type { PageContextUrlInternal, PageContextUrlClient, PageContextUrlServer } from '../shared-server-client/getPageContextUrlComputed.js';
 import type { From, PageContextConfig, Source, Sources } from '../shared-server-client/page-configs/resolveVikeConfigPublic.js';
 import type { Config } from './Config.js';
@@ -26,7 +27,11 @@ import type { PageContextPublicProxyClient } from '../client/runtime-client-rout
 type PageContextServer<Data = unknown> = PageContextBuiltInServer<Data> & {
     /** https://vike.dev/warning/internals */
     dangerouslyUseInternals: DangerouslyUseInternals<PageContextInternalServer & PageContextAfterRender & PageContextPublicServer>;
-} & Vike.PageContext & Vike.PageContextServer;
+} & Vike.PageContext & Vike.PageContextServer & (Vike.Server extends {
+    server: string;
+} ? {
+    runtime: RuntimeAdapterTarget<Vike.Server['server']>;
+} : {});
 type PageContext<Data = unknown> = PageContextClient<Data> | PageContextServer<Data>;
 type PageContextClient<Data = unknown> = PageContextBuiltInClientWithClientRouting<Data> & {
     /** https://vike.dev/warning/internals */
@@ -134,7 +139,7 @@ type PageContextInit = {
     headersOriginal?: unknown;
     /** @deprecated Set `pageContextInit.urlOriginal` instead  */ url?: string;
 };
-type PageContextInternalInit = PageContextInit & {
+type PageContextInitInternal = PageContextInit & {
     _reqDev?: IncomingMessage;
     _reqWeb?: Request;
 };
@@ -294,7 +299,7 @@ type PageContextInternalClient_ServerRouting = Omit<PageContextBuiltInClientWith
  *   ```
  * With:
  *   ```
- *   import { PageContextServer } from 'vike/types'
+ *   import type { PageContextServer } from 'vike/types'
  *   ```
  *
  * See https://vike.dev/pageContext#typescript
@@ -307,7 +312,7 @@ type PageContextBuiltInServer_deprecated<_Page = never> = PageContextBuiltInServ
  *   ```
  * With:
  *   ```
- *   import { PageContextClient } from 'vike/types'
+ *   import type { PageContextClient } from 'vike/types'
  *   ```
  *
  * See https://vike.dev/pageContext#typescript
@@ -320,7 +325,7 @@ type PageContextBuiltInClientWithClientRouting_deprecated<_Page = never> = PageC
  *   ```
  * With:
  *   ```
- *   import { PageContextClientWithServerRouting as PageContextClient } from 'vike/types'
+ *   import type { PageContextClientWithServerRouting as PageContextClient } from 'vike/types'
  *   ```
  *
  * See https://vike.dev/pageContext#typescript

package/dist/types/VikeNamespace.d.ts

@@ -60,5 +60,12 @@ declare global {
         interface GlobalContextServer {
             _interfaceIsNotAny?: never;
         }
+        /** Defines the type of `pageContext.runtime`.
+         *
+         *  https://vike.dev/server#pagecontext-runtime
+         */
+        interface Server {
+            _interfaceIsNotAny?: never;
+        }
     }
 }

package/dist/utils/PROJECT_VERSION.d.ts

@@ -1 +1 @@
-export declare const PROJECT_VERSION: "0.4.256-commit-85a5a9e";
+export declare const PROJECT_VERSION: "0.4.257-commit-c6e29ea";

package/dist/utils/PROJECT_VERSION.js

@@ -1,2 +1,2 @@
 // Automatically updated by @brillout/release-me
-export const PROJECT_VERSION = '0.4.256-commit-85a5a9e';
+export const PROJECT_VERSION = '0.4.257-commit-c6e29ea';

package/dist/utils/isCloudflareWorkers.d.ts

@@ -0,0 +1 @@
+export declare function isCloudflareWorkers(): boolean;

package/dist/utils/isCloudflareWorkers.js

@@ -0,0 +1,4 @@
+// https://github.com/cloudflare/workers-sdk/issues/1481#issuecomment-2550929035
+export function isCloudflareWorkers() {
+    return typeof navigator !== 'undefined' && navigator?.userAgent === 'Cloudflare-Workers';
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vike",
-  "version": "0.4.256-commit-85a5a9e",
+  "version": "0.4.257-commit-c6e29ea",
   "repository": "https://github.com/vikejs/vike",
   "exports": {
     "./server": {
@@ -133,7 +133,7 @@
     "@brillout/picocolors": "^1.0.30",
     "@brillout/vite-plugin-server-entry": "0.7.18",
     "@universal-deploy/store": "^0.2.1",
-    "@universal-deploy/vite": "^0.1.3",
+    "@universal-deploy/vite": "^0.1.6",
     "@universal-middleware/core": "^0.4.17",
     "@universal-middleware/node": "^0.1.0",
     "cac": "^6.0.0",
@@ -146,7 +146,7 @@
     "semver": "^7.7.4",
     "sirv": "^3.0.2",
     "source-map-support": "^0.5.0",
-    "tinyglobby": "^0.2.10",
+    "tinyglobby": "^0.2.16",
     "vite": ">=6.3.0",
     "vite-plugin-wrapper": "^0.1.0"
   },

package/dist/node/vite/plugins/pluginUniversalDeploy/getDeployConfigs.d.ts

@@ -1,27 +0,0 @@
-export { getDeployConfigs };
-import type { fromVike } from 'convert-route';
-import type { PageConfigPublicWithRoute } from '../../../../shared-server-client/page-configs/resolveVikeConfigPublic.js';
-import '../../assertEnvVite.js';
-declare function getDeployConfigs(pageId: string, page: PageConfigPublicWithRoute): {
-    route: string;
-    vercel: {
-        isr: {
-            expiration: number;
-        } | undefined;
-        edge: boolean | undefined;
-    };
-} | null;
-export declare function getRoutePageContextJson(routeIr: ReturnType<typeof fromVike>): {
-    pathname: ({
-        optional: boolean;
-    } & ({
-        value: string;
-        catchAll?: never;
-    } | {
-        value?: never;
-        catchAll: {
-            name?: string;
-            greedy: boolean;
-        };
-    }))[];
-} | undefined;

package/dist/node/vite/plugins/pluginUniversalDeploy/getServerInfo.d.ts

@@ -1,7 +0,0 @@
-import type { VikeConfigInternal } from '../../shared/resolveVikeConfigInternal.js';
-import '../../assertEnvVite.js';
-export declare function getServerInfo(vikeConfig: VikeConfigInternal): {
-    serverEntryId: string;
-    serverEntryVike: string;
-    serverFilePath: string | null;
-} | undefined;