vike 0.4.267-commit-83049a4 → 0.4.268-commit-45c1759

package/RenderErrorPage.js

@@ -1,3 +1,3 @@
 // Some tools still need this as of January 2025
-export * from './dist/shared/RenderErrorPage.js'
-export { default } from './dist/shared/RenderErrorPage.js'
+export * from './dist/shared-server-client/RenderErrorPage.js'
+export { default } from './dist/shared-server-client/RenderErrorPage.js'

package/abort.js

@@ -1,3 +1,3 @@
 // Some tools still need this as of January 2025
-export * from './dist/shared/abort.js'
-export { default } from './dist/shared/abort.js'
+export * from './dist/shared-server-client/abort.js'
+export { default } from './dist/shared-server-client/abort.js'

package/dist/client/__internal/index.d.ts

@@ -0,0 +1,2 @@
+export { readPageContextJson } from '../runtime-client-routing/streamedValues.js';
+import '../assertEnvClient.js';

package/dist/client/__internal/index.js

@@ -0,0 +1,3 @@
+// Used by vike-react-rsc
+export { readPageContextJson } from '../runtime-client-routing/streamedValues.js';
+import '../assertEnvClient.js';

package/dist/client/runtime-client-routing/renderPageClient.d.ts

@@ -790,7 +790,7 @@ declare function getPageContextBegin(isForErrorPage: boolean, { urlOriginal, isB
 declare global {
     var _vike: VikeGlobalInternal;
 }
-declare function disableClientRouting(err: unknown, log: boolean): void;
+declare function disableClientRouting(err: unknown, logError: boolean): void;
 declare function getRenderCount(): number;
 /**
  * Get the `pageContext` object on the client-side.

package/dist/client/runtime-client-routing/renderPageClient.js

@@ -526,21 +526,12 @@ function stampFinished(urlOriginal) {
     window._vike ?? (window._vike = {});
     window._vike.fullyRenderedUrl = urlOriginal;
 }
-function disableClientRouting(err, log) {
+function disableClientRouting(err, logError) {
     globalObject.clientRoutingIsDisabled = true;
     assert(isErrorFetchingStaticAssets(err));
-    if (log) {
-        // We purposely don't use console.error() to avoid flooding error trackers such as Sentry
-        console.log(err);
-    }
-    assertInfo(false, [
-        'Failed to fetch static asset.',
-        import.meta.env.PROD ? 'This usually happens when a new frontend is deployed.' : null,
-        'Falling back to Server Routing.',
-        '(The next page navigation will use Server Routing instead of Client Routing.)',
-    ]
-        .filter(Boolean)
-        .join(' '), { onlyOnce: true });
+    if (logError)
+        console.log(err); // We purposely don't use console.error() to avoid flooding error trackers such as Sentry
+    assertInfo(false, 'Failed to fetch static asset (due to a connection issue, or a new deployment) — falling back to Server Routing', { onlyOnce: true });
 }
 function getIsRenderOutdated() {
     const renderNumber = ++globalObject.renderCounter;
@@ -627,17 +618,14 @@ async function loadPageConfigsLazyClientSideAndExecHook(pageContext, isFirstRend
     catch (err_) {
         err = err_;
         hasErr = true;
-        if (handleErrorFetchingStaticAssets(err, pageContext, isFirstRender)) {
-            return { skip: true };
-        }
-        else {
-            // Syntax error in user file
-        }
     }
     if (isRenderOutdated())
         return { skip: true };
-    if (hasErr)
+    if (hasErr) {
+        if (await handleErrorFetchingStaticAssets(err, pageContext, isFirstRender))
+            return { skip: true };
         return { err };
+    }
     objectAssign(pageContext, pageContextAddendum);
     try {
         await execHook('onCreatePageContext', pageContext, getPageContextPublicClient);
@@ -652,21 +640,109 @@ async function loadPageConfigsLazyClientSideAndExecHook(pageContext, isFirstRend
         return { err };
     return { pageContext };
 }
-function handleErrorFetchingStaticAssets(err, pageContext, isFirstRender) {
-    if (!isErrorFetchingStaticAssets(err)) {
+async function handleErrorFetchingStaticAssets(err, pageContext, isFirstRender) {
+    if (import.meta.env.DEV)
         return false;
-    }
-    if (isFirstRender) {
+    if (!isErrorFetchingStaticAssets(err))
+        return false; // Syntax error in user file
+    // *******************************************
+    // ******* The three possible actions ********
+    // *******************************************
+    /** Show Vike's error page */
+    const showErrorPage = () => {
         disableClientRouting(err, false);
-        // This may happen if the frontend was newly deployed during hydration.
-        // Ideally: re-try a couple of times by reloading the page (not entirely trivial to implement since `localStorage` is needed.)
+        // Vike handles the error like any other error: Vike logs it with `console.error()` and renders Vike's error page
+        return false;
+    };
+    /** Show the rendered HTML (with broken hydration) */
+    const showCurrentBrokenPage = () => {
+        disableClientRouting(err, false);
+        // Abort rendering (and don't show error page), not gracefully: the error throws (i.e. the error is handled by the browser and shown in the browser's developer console)
         throw err;
+    };
+    /** Do a full (re-)load of the page */
+    const hardReload = (url) => {
+        disableClientRouting(err, true);
+        if (url) {
+            redirectHard(url);
+        }
+        else {
+            // We use `location.reload()` instead of redirectHard(): navigating with `location.href = url` creates a `type: 'navigate'` entry, which would lead to an infinite reload loop — see isPageReload()
+            window.location.reload();
+        }
+        // Abort rendering (and don't show error page), gracefully (i.e. without throwing nor logging any error)
+        return true;
+    };
+    // **************************
+    // ******* The logic ********
+    // **************************
+    // Possible causes that lead to this point:
+    // - New deployment
+    // - Connection problem
+    // === Client-side navigation ===
+    // We hard load the next page:
+    // - New deployment => fully reloading the website is exactly what we want
+    // - Connection problem => next page isn't shown => only useful action is to try again with a hard reload
+    //   - It's usually better to show the browser's offline page than to leave the user stuck on the old page. (This way, the user knows there's a connection problem instead of wondering whether the website is broken.)
+    if (!isFirstRender) {
+        return hardReload(pageContext.urlOriginal);
+    }
+    // === First render ===
+    // Avoid infinite reload loop: we don't reload a page that was itself loaded by a reload
+    if (isPageReload()) {
+        if (isBlankPage()) {
+            return showErrorPage();
+        }
+        else {
+            return showCurrentBrokenPage();
+        }
+    }
+    if (isBlankPage()) {
+        return hardReload();
     }
     else {
-        disableClientRouting(err, true);
+        globalObject.clientRoutingIsDisabled = true; // Eagerly disable before connection check
+        if (!(await isConnectionDown())) {
+            // Most likely a new deployment (or the connection is back): either way, reloading fixes the page
+            return hardReload();
+        }
+        else {
+            // - Reloading is counterproductive since it would likely get another connection error, resulting in either: the browser's offline page, or repeating this asset loading failure.
+            // - Handling flaky connections is the browser's job (e.g. the user reloads the page)
+            // - Showing the rendered HTML is usually more useful to the user (even when unhydrated thus broken) than showing Vike's error page
+            return showCurrentBrokenPage();
+        }
     }
-    redirectHard(pageContext.urlOriginal);
-    return true;
+}
+// Whether fetching static assets fails because of the connection. (The error thrown by `import()` doesn't tell: it's the same whether a new frontend was deployed, i.e. the static assets don't exist anymore, or the connection is down.)
+async function isConnectionDown() {
+    try {
+        await fetch(window.location.href, {
+            method: 'HEAD',
+            cache: 'no-store',
+            // On a flaky connection, the request may hang and succeed much later: we don't want to reload the page long after it was shown (e.g. while the user is filling a form)
+            signal: AbortSignal.timeout(4000),
+        });
+        // The server responds
+        return false;
+    }
+    catch {
+        return true;
+    }
+}
+// The page shows nothing (e.g. SPA)
+function isBlankPage() {
+    return !document.body.innerText.trim();
+}
+// Whether the current page was loaded by a page reload
+function isPageReload() {
+    // The browser records how the current document was loaded (Navigation Timing API)
+    const navigation = performance.getEntriesByType('navigation')[0];
+    return (
+    // Cannot be determined (e.g. older browsers)
+    !navigation ||
+        // A document loaded by `location.reload()` has `type: 'reload'`
+        navigation.type === 'reload');
 }
 // [HMR] If error page is shown => re-render whole page
 if (import.meta.env.DEV && import.meta.hot)

package/dist/client/shared/loadPageConfigsLazyClientSide.js

@@ -53,10 +53,6 @@ function isFetchError(err) {
         'error loading dynamically imported module',
         // safari
         'Importing a module script failed',
-        // ??
-        'error resolving module specifier',
-        // ??
-        'failed to resolve module',
     ];
     return FAILED_TO_FETCH_MESSAGES.some((s) => err.message.toLowerCase().includes(s.toLowerCase()));
 }

package/dist/node/api/serverEntryDev.js

@@ -61,6 +61,7 @@ async function startServerEntry_child(viteServer, serverEntryFilePath) {
     restartOnFileChange(viteServer, (filePath) => isImportedBy(ssr.moduleGraph.getModulesByFile(filePath), serverEntryFilePath));
     // The user's server uses the current Vite development server (e.g. `app.use(devMiddleware)`) => we restart the process instead of letting Vite restart itself (e.g. upon vite.config.js changes)
     viteServer.restart = async () => restart('Vite needs to restart');
+    closeOnSignal(viteServer);
     try {
         // Same module runner as the one Vike uses to load pages (`ssrLoadModule()`) => a module imported by both +serverEntry.js and a page is instantiated only once (like in production)
         await viteServer.ssrLoadModule(serverEntryFilePath);
@@ -80,6 +81,17 @@ function restartOnFileChange(viteServer, isRestartNeeded) {
     viteServer.watcher.on('change', onFileChange);
     viteServer.watcher.on('unlink', onFileChange);
 }
+// The user's server may handle SIGINT/SIGTERM without exiting the process (e.g. graceful shutdown: close the server and let the process exit once it's idle) => close Vite's development server, otherwise it keeps the process alive
+function closeOnSignal(viteServer) {
+    for (const signal of ['SIGINT', 'SIGTERM']) {
+        process.once(signal, () => {
+            void viteServer.close();
+            // Listening to a signal disables Node.js's default behavior of terminating the process => if the user's server doesn't listen to it, then we terminate the process ourselves
+            if (process.listenerCount(signal) === 0)
+                process.kill(process.pid, signal);
+        });
+    }
+}
 function restart(reason) {
     assertInfo(false, `${reason}, restarting server...`, { onlyOnce: false });
     process.exit(EXIT_CODE_RESTART);

package/dist/node/vite/plugins/pluginDev/optimizeDeps.d.ts

@@ -4,7 +4,7 @@ import type { ResolvedConfig } from 'vite';
 import '../../assertEnvVite.js';
 declare const optimizeDeps: {
     readonly optimizeDeps: {
-        readonly exclude: ["vike/client", "vike/client/router"];
+        readonly exclude: ["vike/client", "vike/client/router", "vike/__internal/client"];
         readonly include: ["vike > @brillout/json-serializer/parse", "vike > @brillout/json-serializer/stringify", "vike > @brillout/picocolors"];
     };
     readonly ssr: {

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

@@ -43,6 +43,8 @@ const optimizeDeps = {
             // We must exclude Vike's client runtime so it can import virtual modules
             'vike/client',
             'vike/client/router',
+            // Also all entries of Vike's client runtime, otherwise pre-bundling an entry would load a second copy of Vike's client code (also problematic as it duplicates module-level variables that don't use `getGlobalObject()`)
+            'vike/__internal/client',
         ],
         include: [
             // Avoid:

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

@@ -30,14 +30,14 @@ function getServerConfig(vikeConfig) {
     }
     else {
         serverEntryId = catchAllEntry;
-        serverEntryVike = 'vike/fetch';
+        serverEntryVike = 'vike/__internal/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.
+        // It either points to the default fetchable endpoint (vike/__internal/fetch), or one defined by the user through +server.
         serverEntryVike,
         serverFilePath,
         // +serverEntry.js => it's the production server entry dist/server/index.mjs (instead of @universal-deploy/node's)

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

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

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

@@ -0,0 +1,29 @@
+export { pluginWrapServerFile };
+import { wrapper } from 'vite-plugin-wrapper';
+import { escapeRegex } from '../../../../utils/escapeRegex.js';
+import '../../assertEnvVite.js';
+function pluginWrapServerFile(serverFilePath) {
+    return wrapper({
+        resolveId: {
+            filter: {
+                id: new RegExp(`${escapeRegex(serverFilePath)}$`),
+            },
+        },
+        load(id) {
+            return [
+                // === Side exports
+                `export * from ${JSON.stringify(id)};`,
+                '',
+                // === Default export
+                // `vikeFetch` acts as fallback if the user's +server.js doesn't export `fetch`
+                // - Example: https://vike.dev/cloudflare#durable-objects
+                // - Bloat (when `vikeFetch` isn't used) is negligible
+                "import vikeFetch from 'vike/__internal/fetch';",
+                `import * as mod from ${JSON.stringify(id)};`,
+                // Destructured because mod.default makes Rolldown warn when +server.js has no default export
+                'const { default: server } = mod;',
+                'export default { ...server, ...server?.prod, fetch: server?.fetch ?? vikeFetch.fetch };',
+            ].join('\n');
+        },
+    });
+}

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

@@ -8,7 +8,7 @@ import { pluginCommon } from './pluginUniversalDeploy/common.js';
 import { hasVikeServerOrVikePhoton } from './pluginUniversalDeploy/detectDeprecated.js';
 import { getServerConfig, getServerEntryFilePath_ifDev } from './pluginUniversalDeploy/getServerConfig.js';
 import { pluginServerEntryAlias } from './pluginUniversalDeploy/pluginServerEntryAlias.js';
-import { pluginUnwrapProdOptions } from './pluginUniversalDeploy/pluginUnwrapProdOptions.js';
+import { pluginWrapServerFile } from './pluginUniversalDeploy/pluginWrapServerFile.js';
 import { getViteCliCommand } from '../shared/isViteCli.js';
 import { unique } from '../../../utils/unique.js';
 import { assertUsage } from '../../../utils/assert.js';
@@ -79,6 +79,6 @@ function pluginUniversalDeploy(vikeConfig) {
         },
         pluginServerEntryInject(serverFilePath ?? serverEntryId),
         pluginServerEntryAlias(serverFilePath),
-        !serverFilePath ? null : pluginUnwrapProdOptions(serverFilePath),
+        !serverFilePath ? null : pluginWrapServerFile(serverFilePath),
     ].filter((p) => p !== null);
 }

package/dist/server/__internal/fetch-deprecated.d.ts

@@ -0,0 +1,2 @@
+export { default } from './fetch.js';
+import '../assertEnvServer.js';

package/dist/server/__internal/fetch-deprecated.js

@@ -0,0 +1,6 @@
+export { default } from './fetch.js';
+// TO-DO/next-major-release: remove this export (the entire file)
+import { assertWarning } from '../../utils/assert.js';
+import pc from '@brillout/picocolors';
+import '../assertEnvServer.js';
+assertWarning(false, `${pc.cyan("import vike from 'vike/fetch'")} is deprecated, see ${pc.underline('https://vike.dev/migration/vike-fetch')}`, { onlyOnce: true });

package/dist/server/__internal/fetch.js

@@ -0,0 +1,5 @@
+import '../assertEnvServer.js';
+import { vikeUniversalMiddleware } from '../runtime/universal-middleware/vikeUniversalMiddleware.js';
+export default {
+    fetch: vikeUniversalMiddleware,
+};

package/dist/server/__internal/index.d.ts

@@ -1,10 +1,12 @@
 export { setGlobalContext_prodBuildEntry } from '../runtime/globalContext.js';
 export { getMiddlewaresPipe_nonHandlers, getMiddlewaresPipe_handlers, } from '../runtime/universal-middleware/getMiddlewaresPipe.js';
+export { getPageContextJson };
 export { route, getPagesAndRoutes };
 export type { PageRoutes, PageFile, PageConfigRuntime as PageConfig };
 import { route as routeInternal, type PageRoutes } from '../../shared-server-client/route/index.js';
 import type { PageFile } from '../../shared-server-client/getPageFiles/getPageFileObject.js';
 import { PageConfigRuntime } from '../../types/PageConfig.js';
+import type { PageContextServer } from '../../types/PageContext.js';
 import '../assertEnvServer.js';
 /**
  * Used by {@link https://github.com/magne4000/vite-plugin-vercel|vite-plugin-vercel} to compute some rewrite rules and extract { isr } configs.
@@ -20,3 +22,4 @@ declare function getPagesAndRoutes(): Promise<{
 declare function route(pageContext: Parameters<typeof routeInternal>[0]): Promise<{
     pageContextAddendum: import("../../shared-server-client/route/index.js").PageContextAfterRoute;
 }>;
+declare function getPageContextJson(pageContext: PageContextServer): string | ReadableStream<Uint8Array<ArrayBufferLike>>;

package/dist/server/__internal/index.js

@@ -2,11 +2,14 @@
 export { setGlobalContext_prodBuildEntry } from '../runtime/globalContext.js';
 // Used by the vike(app) of the @vikejs/* server adapters
 export { getMiddlewaresPipe_nonHandlers, getMiddlewaresPipe_handlers, } from '../runtime/universal-middleware/getMiddlewaresPipe.js';
+// Used by vike-react-rsc
+export { getPageContextJson };
 // Used by vite-plugin-vercel
 export { route, getPagesAndRoutes };
 import { route as routeInternal } from '../../shared-server-client/route/index.js';
 import { getGlobalContextServerInternal, initGlobalContext_getPagesAndRoutes } from '../runtime/globalContext.js';
 import { setNodeEnvProductionIfUndefined } from '../../utils/assertSetup.js';
+import { getPageContextJson as getPageContextJsonInternal } from '../runtime/renderPageServer/getPageContextJson.js';
 import '../assertEnvServer.js';
 /**
  * Used by {@link https://github.com/magne4000/vite-plugin-vercel|vite-plugin-vercel} to compute some rewrite rules and extract { isr } configs.
@@ -32,3 +35,6 @@ async function route(pageContext) {
     // Old interface
     return { pageContextAddendum: pageContextFromRoute };
 }
+function getPageContextJson(pageContext) {
+    return getPageContextJsonInternal(pageContext);
+}

package/dist/server/runtime/renderPageServer/execHookOnRenderHtml.js

@@ -79,10 +79,6 @@ function processHookReturnValue(hookReturnValue, renderHook) {
     let pageContextPromise = null;
     let pageContextProvidedByRenderHook = null;
     let injectFilter = null;
-    if (isDocumentHtml(hookReturnValue)) {
-        documentHtml = hookReturnValue;
-        return { documentHtml, pageContextProvidedByRenderHook, pageContextPromise, injectFilter };
-    }
     const errPrefix = `The ${renderHook.hookName}() hook defined at ${renderHook.hookFilePath}`;
     const errSuffix = `a string generated with ${pc.cyan('escapeInject`<html>...</html>`')} or the value returned by ${pc.cyan('dangerouslySkipEscape()')}, see https://vike.dev/escapeInject`;
     if (typeof hookReturnValue === 'string') {
@@ -93,6 +89,10 @@ function processHookReturnValue(hookReturnValue, renderHook) {
         ].join(' '), { onlyOnce: true });
         hookReturnValue = dangerouslySkipEscape(hookReturnValue);
     }
+    if (isDocumentHtml(hookReturnValue)) {
+        documentHtml = hookReturnValue;
+        return { documentHtml, pageContextProvidedByRenderHook, pageContextPromise, injectFilter };
+    }
     const wrongReturnValue = `should return the value ${pc.cyan('documentHtml')} or an object ${pc.cyan('{ documentHtml }')} where ${pc.cyan('documentHtml')} is ${errSuffix}`;
     assertUsage(isObject(hookReturnValue), `${errPrefix} ${wrongReturnValue}`);
     assertHookReturnedObject(hookReturnValue, ['documentHtml', 'pageContext', 'injectFilter'], errPrefix);

package/dist/server/runtime/renderPageServer.js

@@ -422,7 +422,7 @@ async function getPermanentRedirect(pageContextBegin, globalContext) {
         if (normalize(urlTarget) === normalize(urlWithoutBase))
             return null;
         if (!originChanged)
-            urlTarget = prependBase(urlTarget, globalContext.baseServer);
+            urlTarget = modifyUrlPathname(urlTarget, (urlPathname) => prependBase(urlPathname, globalContext.baseServer));
         assert(urlTarget !== pageContext.urlOriginal);
     }
     logRuntimeInfo?.(`Permanent redirection defined by config.redirects (https://vike.dev/redirects)`, pageContext, 'info');
@@ -454,6 +454,8 @@ pageContextNominalPageBegin, requestId, pageContextErrorPageInit, globalContext)
             assertUsage(errorPageId, `You called ${pc.cyan(abortCall)} but you didn't define an error page, make sure to define one https://vike.dev/error-page`);
             objectAssign(pageContext, { pageId: errorPageId });
             objectAssign(pageContext, pageContextErrorPageInit, true);
+            // Overrides `is404: false` of pageContextErrorPageInit, e.g. `throw render(404)` => `is404: true`
+            objectAssign(pageContext, pageContextAbort);
             updateType(pageContext, await loadPageConfigsLazyServerSide(pageContext));
             // We include pageContextInit: we don't only serialize pageContextAbort because the error page may need to access pageContextInit
             pageContextJson = getPageContextJson(pageContext);

package/dist/types/Config.d.ts

@@ -542,7 +542,7 @@ type ConfigBuiltIn = {
      *
      * https://vike.dev/middleware
      */
-    middleware?: EnhancedMiddleware | EnhancedMiddleware[];
+    middleware?: EnhancedMiddleware | EnhancedMiddleware[] | ImportStringList;
     /**
      * Set to `false` to disable Vike's automatic server integration mechanism (e.g. for integrating a JavaScript server manually via `renderPage()`).
      *

package/dist/types/Server.d.ts

@@ -5,7 +5,7 @@ import type { Fetchable, ServerOptions } from '@universal-deploy/store';
  *
  * https://vike.dev/server
  */
-interface Server extends Fetchable {
+interface Server extends Partial<Fetchable> {
     prod?: Omit<ServerOptions, 'fetch'> & {
         static?: boolean | string;
     };

package/dist/types/VikeNamespace.d.ts

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

package/dist/utils/PROJECT_VERSION.d.ts

@@ -1 +1 @@
-export declare const PROJECT_VERSION: '0.4.267-commit-83049a4';
+export declare const PROJECT_VERSION: '0.4.268-commit-45c1759';

package/dist/utils/PROJECT_VERSION.js

@@ -1,2 +1,2 @@
 // Automatically updated by @brillout/release-me
-export const PROJECT_VERSION = '0.4.267-commit-83049a4';
+export const PROJECT_VERSION = '0.4.268-commit-45c1759';

package/fetch.js

@@ -1,3 +1,3 @@
 // Some tools still need this as of January 2025
-export * from './dist/server/runtime/fetch.js'
-export { default } from './dist/server/runtime/fetch.js'
+export * from './dist/server/__internal/fetch-deprecated.js'
+export { default } from './dist/server/__internal/fetch-deprecated.js'

package/modifyUrl.js

@@ -1,3 +1,3 @@
 // Some tools still need this as of January 2025
-export * from './dist/shared/modifyUrl.js'
-export { default } from './dist/shared/modifyUrl.js'
+export * from './dist/shared-server-client/modifyUrl.js'
+export { default } from './dist/shared-server-client/modifyUrl.js'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vike",
-  "version": "0.4.267-commit-83049a4",
+  "version": "0.4.268-commit-45c1759",
   "repository": "https://github.com/vikejs/vike",
   "exports": {
     "./server": {
@@ -95,18 +95,27 @@
       "default": "./dist/server/runtime/universal-middleware/deprecated-export.js"
     },
     "./fetch": {
-      "types": "./dist/server/runtime/fetch.d.ts",
-      "worker": "./dist/server/runtime/fetch.js",
-      "workerd": "./dist/server/runtime/fetch.js",
-      "node": "./dist/server/runtime/fetch.js",
+      "types": "./dist/server/__internal/fetch-deprecated.d.ts",
+      "worker": "./dist/server/__internal/fetch-deprecated.js",
+      "workerd": "./dist/server/__internal/fetch-deprecated.js",
+      "node": "./dist/server/__internal/fetch-deprecated.js",
       "browser": "./dist/client/node.js",
-      "default": "./dist/server/runtime/fetch.js"
+      "default": "./dist/server/__internal/fetch-deprecated.js"
     },
     "./__internal": {
       "types": "./dist/server/__internal/index.d.ts",
       "node": "./dist/server/__internal/index.js",
       "default": "./dist/server/__internal/index.js"
     },
+    "./__internal/client": {
+      "types": "./dist/client/__internal/index.d.ts",
+      "default": "./dist/client/__internal/index.js"
+    },
+    "./__internal/fetch": {
+      "types": "./dist/server/__internal/fetch.d.ts",
+      "node": "./dist/server/__internal/fetch.js",
+      "default": "./dist/server/__internal/fetch.js"
+    },
     "./__internal/setup": {
       "types": "./dist/server/runtime/page-files/setup.d.ts",
       "node": "./dist/server/runtime/page-files/setup.js",
@@ -130,7 +139,7 @@
     "@brillout/vite-plugin-server-entry": "^0.7.23",
     "@universal-deploy/store": "^0.3.0",
     "@universal-deploy/vite": "^0.2.2",
-    "@universal-middleware/core": "^0.7.0",
+    "@universal-middleware/core": "^0.7.1",
     "@universal-middleware/node": "^0.2.9",
     "cac": "^6.0.0",
     "convert-route": "^2.0.0",
@@ -219,11 +228,17 @@
         "./dist/server/runtime/universal-middleware/deprecated-export.d.ts"
       ],
       "fetch": [
-        "./dist/server/runtime/fetch.d.ts"
+        "./dist/server/__internal/fetch-deprecated.d.ts"
       ],
       "__internal": [
         "./dist/server/__internal/index.d.ts"
       ],
+      "__internal/client": [
+        "./dist/client/__internal/index.d.ts"
+      ],
+      "__internal/fetch": [
+        "./dist/server/__internal/fetch.d.ts"
+      ],
       "__internal/setup": [
         "./dist/server/runtime/page-files/setup.d.ts"
       ]

package/routing.js

@@ -1,3 +1,3 @@
 // Some tools still need this as of January 2025
-export * from './dist/shared/route/routing.js'
-export { default } from './dist/shared/route/routing.js'
+export * from './dist/shared-server-client/route/routing.js'
+export { default } from './dist/shared-server-client/route/routing.js'

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

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

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

@@ -1,22 +0,0 @@
-export { pluginUnwrapProdOptions };
-import { wrapper } from 'vite-plugin-wrapper';
-import { escapeRegex } from '../../../../utils/escapeRegex.js';
-import '../../assertEnvVite.js';
-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 * from ${JSON.stringify(id)};
-export default { ...mod, ...mod?.prod };
-`;
-        },
-    });
-}

package/dist/server/runtime/fetch.js

@@ -1,5 +0,0 @@
-import '../assertEnvServer.js';
-import { vikeUniversalMiddleware } from './universal-middleware/vikeUniversalMiddleware.js';
-export default {
-    fetch: vikeUniversalMiddleware,
-};