vike 0.4.255-commit-05a7b95 → 0.4.256-commit-414bdc0

package/dist/node/prerender/runPrerender.js

@@ -239,17 +239,6 @@ async function callOnBeforePrerenderStartHooks(prerenderContext, globalContext,
         const result = normalizeOnPrerenderHookResult(prerenderResult, hookFilePath, hookName);
         // Handle result
         await Promise.all(result.map(async ({ url, pageContext }) => {
-            // Assert no duplication
-            {
-                const pageContextFound = prerenderContext.pageContexts.find((pageContext) => isSameUrl(pageContext.urlOriginal, url));
-                if (pageContextFound) {
-                    assert(pageContextFound._providedByHook);
-                    const providedTwice = hookFilePath === pageContextFound._providedByHook.hookFilePath
-                        ? `twice by the ${hookName}() hook (${hookFilePath})`
-                        : `twice: by the ${hookName}() hook (${hookFilePath}) as well as by the hook ${pageContextFound._providedByHook.hookFilePath}() (${pageContextFound._providedByHook.hookName})`;
-                    assertUsage(false, `URL ${pc.cyan(url)} provided ${providedTwice}. Make sure to provide the URL only once instead.`);
-                }
-            }
             // Add result
             const providedByHook = { hookFilePath, hookName };
             const pageContextNew = await createPageContextPrerendering(url, prerenderContext, globalContext, false, undefined, providedByHook);
@@ -260,6 +249,23 @@ async function callOnBeforePrerenderStartHooks(prerenderContext, globalContext,
             }
         }));
     })));
+    // Assert no duplicate URLs
+    // If duplicate URL is found an error will be issued
+    const pageContextsByUrl = {};
+    for (const pageContext of prerenderContext.pageContexts) {
+        assert(pageContext._providedByHook);
+        const urlNormalized = normalizeUrl(pageContext.urlOriginal);
+        const pageContextSameUrl = pageContextsByUrl[urlNormalized];
+        if (pageContextSameUrl) {
+            assert(pageContextSameUrl._providedByHook);
+            const { hookName, hookFilePath } = pageContext._providedByHook;
+            const providedTwice = hookFilePath === pageContextSameUrl._providedByHook.hookFilePath
+                ? `twice by the ${hookName}() hook (${hookFilePath})`
+                : `twice: by the ${hookName}() hook (${hookFilePath}) as well as by the hook ${pageContextSameUrl._providedByHook.hookFilePath}() (${pageContextSameUrl._providedByHook.hookName})`;
+            assertUsage(false, `URL ${pc.cyan(urlNormalized)} provided ${providedTwice}. Make sure to provide the URL only once instead.`);
+        }
+        pageContextsByUrl[urlNormalized] = pageContext;
+    }
 }
 function getUrlListFromPagesWithStaticRoute(globalContext, doNotPrerenderList) {
     const urlList = [];

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

@@ -41,6 +41,8 @@ const filterFunction = (id) => extractAssetsRE.test(id);
 function pluginExtractAssets() {
     let config;
     let vikeConfig;
+    if (handleAssetsManifest_isFixEnabled())
+        return [];
     let isFixEnabled;
     return [
         // This plugin removes all JavaScript from server-side only code, so that only CSS imports remains. (And also static files imports e.g. `import logoURL from './logo.svg.js'`).

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

@@ -0,0 +1,20 @@
+import type { Plugin } from 'vite';
+import '../../assertEnvVite.js';
+export declare const pluginCommon: {
+    applyToEnvironment(env: {
+        name: string;
+        getTopLevelConfig(): import("vite").ResolvedConfig;
+        config: import("vite").ResolvedConfig & {
+            define?: Record<string, any>;
+            resolve: Required<import("vite").ResolveOptions>;
+            consumer: "client" | "server";
+            keepProcessEnv?: boolean;
+            optimizeDeps: import("vite").DepOptimizationOptions;
+            dev: import("vite").ResolvedDevEnvironmentOptions;
+            build: import("vite").ResolvedBuildEnvironmentOptions;
+            plugins: readonly Plugin[];
+        };
+        logger: import("vite").Logger;
+    }): boolean;
+    sharedDuringBuild: true;
+};

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

@@ -0,0 +1,7 @@
+import '../../assertEnvVite.js';
+export const pluginCommon = {
+    applyToEnvironment(env) {
+        return env.config.consumer === 'server';
+    },
+    sharedDuringBuild: true,
+};

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

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

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

@@ -0,0 +1,15 @@
+import { 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')
+        ? 'vike-server'
+        : vikeExtendsNames.has('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 });
+        return true;
+    }
+}

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

@@ -1,8 +1,9 @@
 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[];
+    route: string;
     vercel: {
         isr: {
             expiration: number;
@@ -10,3 +11,17 @@ declare function getDeployConfigs(pageId: string, page: PageConfigPublicWithRout
         edge: boolean;
     };
 } | null;
+export declare function getPageContextRoute(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/getDeployConfigs.js

@@ -1,11 +1,10 @@
 import pc from '@brillout/picocolors';
 export { getDeployConfigs };
-import { fromVike, toRou3 } from 'convert-route';
 import { assert, assertUsage, assertWarning } from '../../../../utils/assert.js';
+import { isObject } from '../../../../utils/isObject.js';
 import '../../assertEnvVite.js';
 function getDeployConfigs(pageId, page) {
-    // Convert Vike's routes to rou3 format
-    const routeIr = typeof page.route === 'string' ? fromVike(page.route) : null;
+    const route = typeof page.route === 'string' ? page.route : null;
     // Vercel specific configs
     const rawIsr = extractIsr(page.config);
     let isr = assertIsr(rawIsr);
@@ -18,9 +17,11 @@ function getDeployConfigs(pageId, page) {
     if (edge && rawIsr !== null && typeof rawIsr === 'object') {
         assertUsage(false, `Page ${pageId}: ISR cannot be enabled for edge functions. Remove ${pc.cyan('isr')} config or set \`{ edge: false }\`.`);
     }
-    if (isrOrEdge && routeIr) {
+    if (isrOrEdge && route) {
         return {
-            route: [...new Set([...toRou3(routeIr), ...getPageContextRoute(routeIr)])],
+            route,
+            // route: [...new Set([...toRou3(routeIr), ...getPageContextRoute(routeIr)])],
+            // Supported by vite-plugin-vercel@11
             vercel: {
                 isr: isr ? { expiration: isr } : undefined,
                 edge: Boolean(edge),
@@ -29,13 +30,11 @@ function getDeployConfigs(pageId, page) {
     }
     return null;
 }
-function extractIsr(exports) {
-    if (exports === null || typeof exports !== 'object')
-        return null;
-    if (!('isr' in exports))
+function extractIsr(pageConfig) {
+    if (!pageConfig.isr)
         return null;
-    const isr = exports.isr;
-    assertUsage(typeof isr === 'object' &&
+    const isr = pageConfig.isr;
+    assertUsage(isObject(isr) &&
         typeof isr.expiration === 'number' &&
         isr.expiration > 0, ' `{ expiration }` must be a positive number');
     return isr;
@@ -54,20 +53,18 @@ function extractEdge(exports) {
     assertUsage(typeof edge === 'boolean', ' `{ edge }` must be a boolean');
     return edge;
 }
-function getPageContextRoute(routeIr) {
+export function getPageContextRoute(routeIr) {
     const lastSegment = routeIr.pathname.at(-1);
     assert(lastSegment);
-    if (!lastSegment.catchAll) {
-        const pageContextIr = {
-            pathname: [
-                ...routeIr.pathname.slice(0, -1),
-                {
-                    ...lastSegment,
-                    value: `${lastSegment.value}.pageContext.json`,
-                },
-            ],
-        };
-        return toRou3(pageContextIr);
-    }
-    return [];
+    if (lastSegment.catchAll)
+        return;
+    return {
+        pathname: [
+            ...routeIr.pathname.slice(0, -1),
+            {
+                ...lastSegment,
+                value: `${lastSegment.value}.pageContext.json`,
+            },
+        ],
+    };
 }

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

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

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

@@ -0,0 +1,33 @@
+import { assert } from '../../../../utils/assert.js';
+import { catchAllEntry } from '@universal-deploy/store';
+import '../../assertEnvVite.js';
+export function getServerInfo(vikeConfig) {
+    let serverEntryId;
+    let serverFilePath = null;
+    const serverConfig = vikeConfig.config.server;
+    // universal-deploy support manually disabled by user
+    if (serverConfig === false)
+        return;
+    const serverPlusFile = vikeConfig._pageConfigGlobal.configValueSources.server?.[0];
+    if (serverPlusFile) {
+        assert('filePathAbsoluteFilesystem' in serverPlusFile.definedAt);
+        serverFilePath = serverPlusFile.definedAt.filePathAbsoluteFilesystem;
+        assert(serverFilePath);
+        serverEntryId = serverFilePath;
+    }
+    else {
+        serverEntryId = catchAllEntry;
+    }
+    if (serverConfig !== true && !serverFilePath)
+        return;
+    const serverEntryVike = serverFilePath ?? 'vike/fetch';
+    return {
+        // Used to filter which module ID to transform.
+        // It points to a fully resolved server entry or the virtual universal-deploy catchAll entry.
+        serverEntryId,
+        // This entry will be pushed to universal-deploy via `addEntry`.
+        // It either points to the default fetchable endpoint (vike/fetch), or one defined by the user through +server.
+        serverEntryVike,
+        serverFilePath,
+    };
+}

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

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

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

@@ -0,0 +1,19 @@
+import { pluginCommon } from './common.js';
+import { escapeRegex } from '../../../../utils/escapeRegex.js';
+import { catchAllEntry } from '@universal-deploy/store';
+import '../../assertEnvVite.js';
+export function pluginResolveAlias() {
+    return {
+        name: 'vike:pluginUniversalDeploy:alias',
+        resolveId: {
+            filter: {
+                // User facing alias for virtual:ud:catch-all
+                id: new RegExp(escapeRegex('vike:server-entry')),
+            },
+            handler() {
+                return this.resolve(catchAllEntry);
+            },
+        },
+        ...pluginCommon,
+    };
+}

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

@@ -0,0 +1,6 @@
+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 pluginVikeVirtualEntry(serverFilePath: string): Plugin;

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

@@ -0,0 +1,22 @@
+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 pluginVikeVirtualEntry(serverFilePath) {
+    return {
+        name: 'vike:pluginUniversalDeploy:server',
+        resolveId: {
+            order: 'pre',
+            filter: {
+                id: new RegExp(escapeRegex(serverFilePath)),
+            },
+            handler() {
+                // Will resolve the entry from the users project root
+                return this.resolve(serverFilePath);
+            },
+        },
+        ...pluginCommon,
+    };
+}

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

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

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

@@ -0,0 +1,19 @@
+import { wrapper } from 'vite-plugin-wrapper';
+import { escapeRegex } from '../../../../utils/escapeRegex.js';
+import '../../assertEnvVite.js';
+export function pluginUnwrapProdOptions(serverFilePath) {
+    return wrapper({
+        resolveId: {
+            filter: {
+                id: new RegExp(escapeRegex(serverFilePath)),
+            },
+        },
+        // Unwrap all prod.* options
+        load(id) {
+            return `
+import mod from ${JSON.stringify(id)};
+export default { ...mod, ...mod?.prod };
+`;
+        },
+    });
+}

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

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

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

@@ -0,0 +1,25 @@
+import { getMagicString } from '../../shared/getMagicString.js';
+import { serverEntryVirtualId as vikeVirtualEntry } from '@brillout/vite-plugin-server-entry/plugin';
+import { pluginCommon } from './common.js';
+import '../../assertEnvVite.js';
+export function pluginVikeVirtualEntry(serverEntryId) {
+    return {
+        name: 'vike:pluginUniversalDeploy:serverEntry',
+        apply: 'build',
+        transform: {
+            order: 'post',
+            filter: {
+                id: {
+                    include: [serverEntryId],
+                },
+            },
+            handler(code, id) {
+                const { magicString, getMagicStringResult } = getMagicString(code, id);
+                // Inject Vike virtual server entry
+                magicString.prepend(`import "${vikeVirtualEntry}";\n`);
+                return getMagicStringResult();
+            },
+        },
+        ...pluginCommon,
+    };
+}

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

@@ -1,155 +1,58 @@
+import { toRou3 } from 'convert-route';
 export { pluginUniversalDeploy };
 import { addEntry } from '@universal-deploy/store';
-import { node } from '@universal-deploy/node/vite';
-import { catchAll, devServer } from '@universal-deploy/store/vite';
-import { serverEntryVirtualId as vikeEntryId } from '@brillout/vite-plugin-server-entry/plugin';
-import { getMagicString } from '../shared/getMagicString.js';
-import { escapeRegex } from '../../../utils/escapeRegex.js';
-import { getDeployConfigs } from './pluginUniversalDeploy/getDeployConfigs.js';
-import { assert, assertUsage, assertWarning } from '../../../utils/assert.js';
-import { asyncFlatten } from '../../../utils/asyncFlatten.js';
+import universalDeploy from '@universal-deploy/vite';
+import { fromVike } from 'convert-route/vike';
+import { pluginVikeVirtualEntry } from './pluginUniversalDeploy/pluginVikeVirtualEntry.js';
+import { getDeployConfigs, getPageContextRoute } from './pluginUniversalDeploy/getDeployConfigs.js';
+import { pluginCommon } from './pluginUniversalDeploy/common.js';
+import { hasVikeServerOrVikePhoton } from './pluginUniversalDeploy/detectDeprecated.js';
+import { getServerInfo } from './pluginUniversalDeploy/getServerInfo.js';
+import { pluginResolveAlias } from './pluginUniversalDeploy/pluginResolveAlias.js';
+import { pluginUnwrapProdOptions } from './pluginUniversalDeploy/pluginUnwrapProdOptions.js';
 import '../assertEnvVite.js';
-import pc from '@brillout/picocolors';
-const virtualFileIdCatchAll = /^virtual:ud:catch-all$/;
+import { unique } from '../../../utils/unique.js';
 function pluginUniversalDeploy(vikeConfig) {
     if (hasVikeServerOrVikePhoton(vikeConfig))
         return [];
-    let serverEntryId = virtualFileIdCatchAll;
-    let serverFilePath = null;
-    const serverConfig = vikeConfig.config.server;
-    if (serverConfig === false)
-        return [];
-    const serverPlusFile = vikeConfig._pageConfigGlobal.configValueSources.server?.[0];
-    if (serverPlusFile) {
-        assert('filePathAbsoluteFilesystem' in serverPlusFile.definedAt);
-        serverFilePath = serverPlusFile.definedAt.filePathAbsoluteFilesystem;
-        assert(serverFilePath);
-        serverEntryId = new RegExp(escapeRegex(serverFilePath));
-    }
-    if (serverConfig !== true && !serverFilePath)
+    const serverInfo = getServerInfo(vikeConfig);
+    if (!serverInfo)
         return [];
+    const { serverEntryVike, serverEntryId, serverFilePath } = serverInfo;
     const plugins = [
-        catchAll(),
-        devServer(),
-        // Enable node adapter only if +server is defined and no other deployment target has been found
-        ...node({ importer: 'vike' }).map((p) => 
-        // Disable node() plugin later when Vite's config() hook runs, because noDeploymentTargetFound() requires `config`
-        enablePluginIf((config) => noDeploymentTargetFound(config), p)),
+        ...universalDeploy(),
         {
             name: 'vike:pluginUniversalDeploy:entries',
             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 pageContextRouteIr = getPageContextRoute(routeIr);
                         addEntry({
-                            id: serverFilePath ?? 'vike/fetch',
-                            ...deployConfigs,
+                            ...additionalConfigs,
+                            id: serverEntryVike,
+                            // Map Vike routes to rou3 format
+                            route: unique([...toRou3(routeIr), ...(pageContextRouteIr ? toRou3(pageContextRouteIr) : [])]),
                         });
                     }
                 }
                 // Default catch-all route
                 addEntry({
-                    id: serverFilePath ?? 'vike/fetch',
+                    id: serverEntryVike,
                     route: '/**',
                 });
             },
-            ...pluginOptions,
-        },
-        {
-            name: 'vike:pluginUniversalDeploy:serverEntry',
-            apply: 'build',
-            transform: {
-                order: 'post',
-                filter: {
-                    id: {
-                        include: [serverEntryId],
-                    },
-                },
-                handler(code, id) {
-                    const { magicString, getMagicStringResult } = getMagicString(code, id);
-                    // Inject Vike virtual server entry
-                    magicString.prepend(`import "${vikeEntryId}";\n`);
-                    return getMagicStringResult();
-                },
-            },
-            ...pluginOptions,
+            ...pluginCommon,
         },
+        pluginVikeVirtualEntry(serverFilePath ?? serverEntryId),
+        pluginResolveAlias(),
     ];
     if (serverFilePath) {
-        plugins.push(
-        // If +server.js is defined, make virtual:ud:catch-all resolve to +server.js absolute path
-        {
-            name: 'vike:pluginUniversalDeploy:server',
-            resolveId: {
-                order: 'pre',
-                filter: {
-                    id: virtualFileIdCatchAll,
-                },
-                handler() {
-                    // Will resolve the entry from the users project root
-                    return this.resolve(serverFilePath);
-                },
-            },
-            ...pluginOptions,
-        });
+        plugins.push(pluginUnwrapProdOptions(serverFilePath));
     }
     return plugins;
 }
-const pluginOptions = {
-    applyToEnvironment(env) {
-        return env.config.consumer === 'server';
-    },
-    sharedDuringBuild: true,
-};
-/**
- * Enables a plugin based on a specified condition callback which will be executed in the `config` hook.
- */
-function enablePluginIf(condition, originalPlugin) {
-    const originalConfig = originalPlugin.config;
-    originalPlugin.config = {
-        order: originalConfig && 'order' in originalConfig ? originalConfig.order : 'pre',
-        async handler(c, e) {
-            const enabled = await condition.call(this, c, e);
-            if (!enabled) {
-                const keysToDelete = Object.keys(originalPlugin).filter((k) => k !== 'name');
-                originalPlugin.name += ':disabled';
-                for (const key of keysToDelete) {
-                    // @ts-expect-error
-                    delete originalPlugin[key];
-                }
-            }
-            else if (originalConfig) {
-                if (typeof originalConfig === 'function') {
-                    return originalConfig.call(this, c, e);
-                }
-                return originalConfig.handler.call(this, c, e);
-            }
-        },
-    };
-    return originalPlugin;
-}
-// Disable a plugin if one of the following plugin is present
-//  - vite-plugin-vercel
-//  - @cloudflare/vite-plugin
-async function noDeploymentTargetFound(c) {
-    const plugins = (await asyncFlatten((c.plugins ?? []))).filter((p) => Boolean(p));
-    assertUsage(!plugins.some((p) => p.name.startsWith('photon:target-loader:vercel')), 'Replace `@photonjs/vercel` by `vite-plugin-vercel@11`, see https://vike.dev/migration/universal-deploy');
-    assertUsage(!plugins.some((p) => p.name.startsWith('photon:target-loader:cloudflare')), 'Replace `@photonjs/cloudflare` by `@cloudflare/vite-plugin`, see https://vike.dev/migration/universal-deploy');
-    // vite-plugin-vercel
-    const vitePluginVercel = plugins.some((p) => p.name.match(/^vite-plugin-vercel:(?!.*:disabled$)/));
-    // @cloudflare/vite-plugin
-    const cloudflareVitePlugin = plugins.some((p) => p.name.match(/^vite-plugin-cloudflare:(?!.*:disabled$)/));
-    return !vitePluginVercel && !cloudflareVitePlugin;
-}
-function hasVikeServerOrVikePhoton(vikeConfig) {
-    const vikeExtendsNames = new Set(vikeConfig._extensions.map((plusFile) => ('fileExportsByConfigName' in plusFile ? plusFile.fileExportsByConfigName : {}).name));
-    const vikeServerOrVikePhoton = vikeExtendsNames.has('vike-server')
-        ? 'vike-server'
-        : vikeExtendsNames.has('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 });
-        return true;
-    }
-}

package/dist/types/Config.d.ts

@@ -528,7 +528,7 @@ type ConfigBuiltIn = {
      *
      * https://vike.dev/server
      */
-    server?: boolean;
+    server?: boolean | ImportStringList;
     cli?: {
         /** @experimental
          *

package/dist/types/Server.d.ts

@@ -0,0 +1,8 @@
+import type { Fetchable, ServerOptions } from '@universal-deploy/store';
+/** Server options.
+ *
+ * https://vike.dev/server
+ */
+export interface Server extends Fetchable {
+    prod?: Omit<ServerOptions, 'fetch'>;
+}

package/dist/types/Server.js

@@ -0,0 +1 @@
+export {};

package/dist/types/index.d.ts

@@ -51,3 +51,4 @@ import { PageContextBuiltInServer } from './PageContext.js';
  */
 type PageContextBuiltIn<Page = any> = PageContextBuiltInServer<Page>;
 export type { PageContextBuiltIn };
+export type { Server } from './Server.js';

package/dist/utils/PROJECT_VERSION.d.ts

@@ -1 +1 @@
-export declare const PROJECT_VERSION: "0.4.255-commit-05a7b95";
+export declare const PROJECT_VERSION: "0.4.256-commit-414bdc0";

package/dist/utils/PROJECT_VERSION.js

@@ -1,2 +1,2 @@
 // Automatically updated by @brillout/release-me
-export const PROJECT_VERSION = '0.4.255-commit-05a7b95';
+export const PROJECT_VERSION = '0.4.256-commit-414bdc0';

package/dist/utils/assertKeys.js

@@ -14,9 +14,9 @@ function assertKeys(obj, keysExpected, errPrefix) {
         assertUsage(false, [
             errPrefix,
             `unknown key${keysUnknown.length === 1 ? '' : 's'}`,
-            joinEnglish(keysUnknown, 'and', pc.cyan) + '.',
+            joinEnglish(keysUnknown, 'and', { color: pc.cyan }) + '.',
             'Only following keys are allowed:',
-            joinEnglish(keysExpected, 'and', pc.cyan) + '.',
+            joinEnglish(keysExpected, 'and', { color: pc.cyan }) + '.',
         ].join(' '));
     }
 }

package/dist/utils/assertNodeVersion.js

@@ -8,5 +8,5 @@ function assertNodeVersion() {
     const version = process.versions.node;
     assertVersion('Node.js', version, 
     // https://gist.github.com/brillout/8e0133716e169b981b6c4e8a938b0134
-    ['20.19.0', '22.12.0', '23.0.0']);
+    ['20.19.0', '22.12.0']);
 }

package/dist/utils/assertVersion.js

@@ -6,7 +6,7 @@ import { assertIsNotBrowser } from './assertIsNotBrowser.js';
 import { joinEnglish } from './joinEnglish.js';
 assertIsNotBrowser();
 function assertVersion(dependencyName, versionActual, versionExpectedList) {
-    assertUsage(isVersionMatch(versionActual, versionExpectedList), `${pc.bold(dependencyName)} ${pc.red(pc.bold(versionActual))} isn't supported, use ${pc.bold(dependencyName)} ${joinEnglish([...versionExpectedList, 'above'].map((v) => pc.green(pc.bold(v))), 'or')}.`);
+    assertUsage(isVersionMatch(versionActual, versionExpectedList), `${pc.bold(dependencyName)} ${pc.red(pc.bold(versionActual))} isn't supported, use ${pc.bold(dependencyName)} ${joinEnglish([...versionExpectedList, 'above'].map((v) => pc.green(pc.bold(v))), 'or', { trailingComma: false })}.`);
 }
 function isVersionMatch(versionActual, versionExpectedList) {
     assert(versionActual);

package/dist/utils/joinEnglish.d.ts

@@ -1,2 +1,5 @@
 export { joinEnglish };
-declare function joinEnglish(arr: string[] | readonly string[], conjunction: 'or' | 'and', colorizer?: (s: string) => string): string;
+declare function joinEnglish(arr: string[] | readonly string[], conjunction: 'or' | 'and', { color, trailingComma }?: {
+    color?: (s: string) => string;
+    trailingComma?: boolean;
+}): string;

package/dist/utils/joinEnglish.js

@@ -1,12 +1,12 @@
 export { joinEnglish };
 import { assert } from './assert.js';
 // https://stackoverflow.com/questions/53879088/join-an-array-by-commas-and-and/53879103#53879103
-function joinEnglish(arr, conjunction, colorizer = (s) => s) {
+function joinEnglish(arr, conjunction, { color = (s) => s, trailingComma = true } = {}) {
     assert(arr.length > 0);
     if (arr.length === 1)
-        return colorizer(arr[0]);
+        return color(arr[0]);
     const firsts = arr.slice(0, arr.length - 1);
     const last = arr[arr.length - 1];
-    const lastComma = arr.length > 2 ? ',' : '';
-    return firsts.map(colorizer).join(', ') + `${lastComma} ${conjunction} ` + colorizer(last);
+    const lastComma = trailingComma && arr.length > 2 ? ',' : '';
+    return firsts.map(color).join(', ') + `${lastComma} ${conjunction} ` + color(last);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vike",
-  "version": "0.4.255-commit-05a7b95",
+  "version": "0.4.256-commit-414bdc0",
   "repository": "https://github.com/vikejs/vike",
   "exports": {
     "./server": {
@@ -132,8 +132,8 @@
     "@brillout/json-serializer": "^0.5.22",
     "@brillout/picocolors": "^1.0.30",
     "@brillout/vite-plugin-server-entry": "0.7.18",
-    "@universal-deploy/node": "^0.1.2",
-    "@universal-deploy/store": "^0.1.4",
+    "@universal-deploy/store": "^0.2.1",
+    "@universal-deploy/vite": "^0.1.1",
     "@universal-middleware/core": "^0.4.17",
     "@universal-middleware/node": "^0.1.0",
     "cac": "^6.0.0",
@@ -142,12 +142,13 @@
     "esbuild": ">=0.19.0",
     "json5": "^2.0.0",
     "magic-string": "^0.30.17",
-    "picomatch": "^4.0.2",
-    "semver": "^7.0.0",
-    "sirv": "^3.0.1",
+    "picomatch": "^4.0.4",
+    "semver": "^7.7.4",
+    "sirv": "^3.0.2",
     "source-map-support": "^0.5.0",
     "tinyglobby": "^0.2.10",
-    "vite": ">=6.3.0"
+    "vite": ">=6.3.0",
+    "vite-plugin-wrapper": "^0.1.0"
   },
   "peerDependencies": {
     "react-streaming": ">=0.3.42",
@@ -265,11 +266,11 @@
     "@types/babel__core": "^7.20.5",
     "@types/estree": "^1.0.5",
     "@types/node": "^20.10.5",
-    "@types/picomatch": "^3.0.2",
-    "@types/semver": "^7.5.8",
+    "@types/picomatch": "^4.0.2",
+    "@types/semver": "^7.7.1",
     "@types/source-map-support": "^0.5.10",
-    "react-streaming": "^0.4.16",
-    "rimraf": "^5.0.5",
+    "react-streaming": "^0.4.17",
+    "rimraf": "^6.1.3",
     "typescript": "^5.9.3",
     "vite": "^7.2.6"
   },

package/dist/utils/asyncFlatten.d.ts

@@ -1,4 +0,0 @@
-export { asyncFlatten };
-export type { AsyncFlatten };
-type AsyncFlatten<T extends unknown[]> = T extends (infer U)[] ? Exclude<Awaited<U>, U[]>[] : never;
-declare function asyncFlatten<T extends unknown[]>(arr: T): Promise<AsyncFlatten<T>>;

package/dist/utils/asyncFlatten.js

@@ -1,7 +0,0 @@
-export { asyncFlatten };
-async function asyncFlatten(arr) {
-    do {
-        arr = (await Promise.all(arr)).flat(Infinity);
-    } while (arr.some((v) => v?.then));
-    return arr;
-}