vike 0.4.231-commit-e1c3295 → 0.4.232-commit-134207d

package/dist/esm/node/runtime/renderPage/loggerProd.js

@@ -1,5 +1,5 @@
 // Logger used for the production server.
-// Any other environement (dev, preview, build, and pre-rendering) uses loggerNotProd.ts instead.
+// Any other environment (dev, preview, build, and pre-rendering) uses loggerNotProd.ts instead.
 export { logErrorProd };
 export { onRuntimeError };
 import { isAbortError } from '../../../shared/route/abort.js';
@@ -7,7 +7,7 @@ import { setAlreadyLogged } from './isNewError.js';
 import { isObject, warnIfErrorIsNotObject } from '../utils.js';
 import pc from '@brillout/picocolors';
 import { logErrorHint } from './logErrorHint.js';
-function logErrorProd(err, _httpRquestId) {
+function logErrorProd(err, _httpRequestId) {
     warnIfErrorIsNotObject(err);
     setAlreadyLogged(err);
     if (isAbortError(err)) {
@@ -22,7 +22,7 @@ function logErrorProd(err, _httpRquestId) {
 // Every server-side runtime error is expected to go through `onRuntimeError()`.
 //  - onRuntimeError(err) should always be called after `console.error(err)`.
 //    - Because the error hint of logErrorHint(err) should be shown *after* the error.
-//  - In principle, any runtime error is (or at least should) be catched by Vike, otherwise Vike couldn't render the error page.
+//  - In principle, any runtime error is (or at least should) be caught by Vike, otherwise Vike couldn't render the error page.
 function onRuntimeError(err) {
     // The more runtime errors we pass to logErrorHint() the better.
     logErrorHint(err);

package/dist/esm/node/runtime/renderPage/preparePageContextForPublicUsageServer.js

@@ -1,5 +1,5 @@
 export { preparePageContextForPublicUsageServer };
-import { assertPropertyGetters, preparePageContextForPublicUsage } from '../../../shared/preparePageContextForPublicUsage.js';
+import { assertPropertyGetters, preparePageContextForPublicUsage, } from '../../../shared/preparePageContextForPublicUsage.js';
 function preparePageContextForPublicUsageServer(pageContext) {
     // TODO/next-major-release: after we remove supportVueReactiviy() we can call this later inside the agnostic preparePageContextForPublicUsage()
     assertPropertyGetters(pageContext);

package/dist/esm/node/runtime/renderPage/renderPageAlreadyRouted.js

@@ -5,7 +5,7 @@ import { getHtmlString } from '../html/renderHtml.js';
 import { assert, assertUsage, hasProp, objectAssign } from '../utils.js';
 import { getPageContextClientSerialized } from '../html/serializeContext.js';
 import { createHttpResponsePage, createHttpResponsePageContextJson } from './createHttpResponse.js';
-import { loadPageConfigsLazyServerSide } from './loadPageConfigsLazyServerSide.js';
+import { loadPageConfigsLazyServerSide, } from './loadPageConfigsLazyServerSide.js';
 import { executeOnRenderHtmlHook } from './executeOnRenderHtmlHook.js';
 import { executeOnBeforeRenderAndDataHooks } from './executeOnBeforeRenderAndDataHooks.js';
 import { logRuntimeError } from '../loggerRuntime.js';
@@ -58,7 +58,7 @@ async function renderPageAlreadyRouted(pageContext) {
 async function prerenderPage(pageContext) {
     objectAssign(pageContext, {
         isClientSideNavigation: false,
-        _urlHandler: null
+        _urlHandler: null,
     });
     /* Should we execute the guard() hook upon pre-rendering? Is there a use case for this?
      *  - It isn't trivial to implement, as it requires to duplicate / factor out the isAbortError() handling

package/dist/esm/node/runtime/renderPage/resolveRedirects.d.ts

@@ -1,4 +1,6 @@
 export { resolveRedirects };
+export { getStaticRedirectsForPrerender };
 export { resolveRouteStringRedirect };
 declare function resolveRedirects(redirectsAll: Record<string, string>[], urlPathname: string): null | string;
+declare function getStaticRedirectsForPrerender(redirectsAll: Record<string, string>[], showWarningUponDynamicRedirects: boolean): Record<string, string>;
 declare function resolveRouteStringRedirect(urlSource: string, urlTarget: string, urlPathname: string): null | string;

package/dist/esm/node/runtime/renderPage/resolveRedirects.js

@@ -1,10 +1,11 @@
 export { resolveRedirects };
+export { getStaticRedirectsForPrerender };
 // For ./resolveRedirects.spec.ts
 export { resolveRouteStringRedirect };
 import { assertIsNotBrowser } from '../../../utils/assertIsNotBrowser.js';
-import { assert, assertUsage, assertUsageUrlRedirectTarget, isUrlRedirectTarget } from '../../../shared/utils.js';
+import { assert, assertUsage, assertUsageUrlRedirectTarget, assertWarning, isUrlRedirectTarget, } from '../../../shared/utils.js';
 import { resolveUrlPathname } from '../../../shared/route/resolveUrlPathname.js';
-import { assertRouteString, resolveRouteString } from '../../../shared/route/resolveRouteString.js';
+import { assertRouteString, isStaticRouteString, resolveRouteString } from '../../../shared/route/resolveRouteString.js';
 import pc from '@brillout/picocolors';
 assertIsNotBrowser(); // Don't bloat the client
 const redirectsErrPrefix = '[+redirects]';
@@ -17,11 +18,22 @@ function resolveRedirects(redirectsAll, urlPathname) {
     }
     return null;
 }
+function getStaticRedirectsForPrerender(redirectsAll, showWarningUponDynamicRedirects) {
+    const redirects = merge(redirectsAll);
+    const redirectsStatic = {};
+    for (const [urlSource, urlTarget] of Object.entries(redirects)) {
+        assertRedirect(urlSource, urlTarget);
+        if (isStaticRouteString(urlSource)) {
+            redirectsStatic[urlSource] = urlTarget;
+        }
+        else if (showWarningUponDynamicRedirects) {
+            assertWarning(false, `Dynamic redirect ${pc.cyan(urlSource)} -> ${pc.cyan(urlTarget)} cannot be pre-rendered. You can remove this warning by setting +prerender.partial to true (https://vike.dev/prerender#partial).`, { onlyOnce: true });
+        }
+    }
+    return redirectsStatic;
+}
 function resolveRouteStringRedirect(urlSource, urlTarget, urlPathname) {
-    assertRouteString(urlSource, `${redirectsErrPrefix} Invalid`);
-    // Is allowing any protocol a safety issue? https://github.com/vikejs/vike/pull/1292#issuecomment-1828043917
-    assertUsageUrlRedirectTarget(urlTarget, `${redirectsErrPrefix} The URL redirection target`, true);
-    assertParams(urlSource, urlTarget);
+    assertRedirect(urlSource, urlTarget);
     const match = resolveRouteString(urlSource, urlPathname);
     if (!match)
         return null;
@@ -31,6 +43,12 @@ function resolveRouteStringRedirect(urlSource, urlTarget, urlPathname) {
     assert(isUrlRedirectTarget(urlResolved));
     return urlResolved;
 }
+function assertRedirect(urlSource, urlTarget) {
+    assertRouteString(urlSource, `${redirectsErrPrefix} Invalid`);
+    // Is allowing any protocol a safety issue? https://github.com/vikejs/vike/pull/1292#issuecomment-1828043917
+    assertUsageUrlRedirectTarget(urlTarget, `${redirectsErrPrefix} The URL redirection target`, true);
+    assertParams(urlSource, urlTarget);
+}
 function assertParams(urlSource, urlTarget) {
     const routeSegments = urlTarget.split('/');
     routeSegments.forEach((routeSegment) => {

package/dist/esm/node/runtime/renderPage.d.ts

@@ -1,7 +1,5 @@
 export { renderPage };
 export { renderPage_addAsyncHookwrapper };
-export { renderPage_vikeConfigHasError };
-export { vikeConfigHasError };
 export type { PageContextInit };
 export type { PageContextBegin };
 import { type GlobalContextServerInternal } from './globalContext.js';
@@ -135,12 +133,3 @@ declare function getPageContextBegin(pageContextInit: PageContextInit, globalCon
 } & {
     _httpRequestId: number;
 }>;
-type VikeConfigHasError = false | {
-    err: unknown;
-};
-declare function renderPage_vikeConfigHasError(val: {
-    hasRuntimeError: VikeConfigHasError;
-} | {
-    hasBuildError: VikeConfigHasError;
-}): void;
-declare function vikeConfigHasError(): boolean;

package/dist/esm/node/runtime/renderPage.js

@@ -1,15 +1,13 @@
 export { renderPage };
 export { renderPage_addAsyncHookwrapper };
-export { renderPage_vikeConfigHasError };
-export { vikeConfigHasError };
 import { renderPageAlreadyRouted } from './renderPage/renderPageAlreadyRouted.js';
-import { createPageContextServerSide, createPageContextServerSideWithoutGlobalContext } from './renderPage/createPageContextServerSide.js';
+import { createPageContextServerSide, createPageContextServerSideWithoutGlobalContext, } from './renderPage/createPageContextServerSide.js';
 import { route } from '../../shared/route/index.js';
-import { assert, hasProp, objectAssign, isUrl, parseUrl, onSetupRuntime, assertWarning, getGlobalObject, checkType, assertUsage, normalizeUrlPathname, removeBaseServer, modifyUrlPathname, prependBase, removeUrlOrigin, setUrlOrigin, isUri, getUrlPretty } from './utils.js';
-import { assertNoInfiniteAbortLoop, getPageContextFromAllRewrites, isAbortError, logAbortErrorHandled } from '../../shared/route/abort.js';
-import { getGlobalContextServerInternal, initGlobalContext_renderPage } from './globalContext.js';
+import { assert, hasProp, objectAssign, isUrl, parseUrl, onSetupRuntime, assertWarning, getGlobalObject, checkType, assertUsage, normalizeUrlPathname, removeBaseServer, modifyUrlPathname, prependBase, removeUrlOrigin, setUrlOrigin, isUri, getUrlPretty, } from './utils.js';
+import { assertNoInfiniteAbortLoop, getPageContextFromAllRewrites, isAbortError, logAbortErrorHandled, } from '../../shared/route/abort.js';
+import { getGlobalContextServerInternal, initGlobalContext_renderPage, } from './globalContext.js';
 import { handlePageContextRequestUrl } from './renderPage/handlePageContextRequestUrl.js';
-import { createHttpResponse404, createHttpResponseRedirect, createHttpResponsePageContextJson, createHttpResponseError, createHttpResponseErrorWithoutGlobalContext, createHttpResponseBaseIsMissing } from './renderPage/createHttpResponse.js';
+import { createHttpResponse404, createHttpResponseRedirect, createHttpResponsePageContextJson, createHttpResponseError, createHttpResponseErrorWithoutGlobalContext, createHttpResponseBaseIsMissing, } from './renderPage/createHttpResponse.js';
 import { logRuntimeError, logRuntimeInfo } from './loggerRuntime.js';
 import { isNewError } from './renderPage/isNewError.js';
 import { assertArguments } from './renderPage/assertArguments.js';
@@ -20,11 +18,8 @@ import { getErrorPageId } from '../../shared/error-page.js';
 import { handleErrorWithoutErrorPage } from './renderPage/handleErrorWithoutErrorPage.js';
 import { loadPageConfigsLazyServerSide } from './renderPage/loadPageConfigsLazyServerSide.js';
 import { resolveRedirects } from './renderPage/resolveRedirects.js';
-const globalObject = getGlobalObject('runtime/renderPage.ts', {
-    httpRequestsCount: 0,
-    vikeConfigHasRuntimeError: false,
-    vikeConfigHasBuildError: false
-});
+import { getVikeConfigError } from '../shared/getVikeConfigError.js';
+const globalObject = getGlobalObject('runtime/renderPage.ts', { httpRequestsCount: 0 });
 // `renderPage()` calls `renderPageNominal()` while ensuring that errors are `console.error(err)` instead of `throw err`, so that Vike never triggers a server shut down. (Throwing an error in an Express.js middleware shuts down the whole Express.js server.)
 async function renderPage(pageContextInit) {
     assertArguments(...arguments);
@@ -45,7 +40,7 @@ async function renderPage(pageContextInit) {
 }
 // Fallback wrapper if node:async_hooks isn't available
 let asyncHookWrapper = async (_httpRequestId, ret) => ({
-    pageContextReturn: await ret()
+    pageContextReturn: await ret(),
 });
 // Add node:async_hooks wrapper
 function renderPage_addAsyncHookwrapper(wrapper) {
@@ -68,7 +63,7 @@ async function renderPagePrepare(pageContextInit, httpRequestId) {
         // ```bash
         // Re-build your app (you're using 1.2.3 but your app was built with 1.2.2)
         // ```
-        // initGlobalContext_renderPage() doens't call any user hook => err isn't thrown from user code.
+        // initGlobalContext_renderPage() doesn't call any user hook => err isn't thrown from user code.
         assert(!isAbortError(err));
         logRuntimeError(err, httpRequestId);
         const pageContextWithError = getPageContextHttpResponseErrorWithoutGlobalContext(err, pageContextInit);
@@ -218,7 +213,7 @@ function logHttpResponse(urlOriginalPretty, httpRequestId, pageContextReturn) {
             //   - Maybe we can/should make the error available at pageContext.errorWhileRendering
             assert(errorWhileRendering === null || errorWhileRendering === undefined);
             msg = `HTTP response ${prettyUrl(urlOriginalPretty)} ${pc.dim('null')}`;
-            // Erroneous value (it shoud sometimes be `false`) but it's fine as it doesn't seem to have much of an impact.
+            // Erroneous value (it should sometimes be `false`) but it's fine as it doesn't seem to have much of an impact.
             isNominal = true;
         }
         else {
@@ -256,7 +251,7 @@ function getPageContextHttpResponseError(err, pageContextBegin) {
     const httpResponse = createHttpResponseError(pageContextBegin);
     objectAssign(pageContextWithError, {
         httpResponse,
-        errorWhileRendering: err
+        errorWhileRendering: err,
     });
     return pageContextWithError;
 }
@@ -265,7 +260,7 @@ function getPageContextHttpResponseErrorWithoutGlobalContext(err, pageContextIni
     const httpResponse = createHttpResponseErrorWithoutGlobalContext();
     objectAssign(pageContextWithError, {
         httpResponse,
-        errorWhileRendering: err
+        errorWhileRendering: err,
     });
     return pageContextWithError;
 }
@@ -298,10 +293,10 @@ async function getPageContextErrorPageInit(pageContextBegin, errNominalPage, pag
     objectAssign(pageContext, {
         is404: false,
         errorWhileRendering: errNominalPage,
-        routeParams: {}
+        routeParams: {},
     });
     objectAssign(pageContext, {
-        _debugRouteMatches: pageContextNominalPagePartial._debugRouteMatches || 'ROUTING_ERROR'
+        _debugRouteMatches: pageContextNominalPagePartial._debugRouteMatches || 'ROUTING_ERROR',
     });
     assert(pageContext.errorWhileRendering);
     return pageContext;
@@ -312,8 +307,8 @@ async function getPageContextBegin(pageContextInit, globalContext, httpRequestId
         isPrerendering: false,
         ssr: {
             urlHandler: _urlHandler,
-            isClientSideNavigation
-        }
+            isClientSideNavigation,
+        },
     });
     objectAssign(pageContextBegin, { _httpRequestId: httpRequestId });
     return pageContextBegin;
@@ -322,7 +317,7 @@ function handlePageContextUrl(urlOriginal) {
     const { isPageContextRequest } = handlePageContextRequestUrl(urlOriginal);
     return {
         isClientSideNavigation: isPageContextRequest,
-        _urlHandler: (url) => handlePageContextRequestUrl(url).urlWithoutPageContextRequestSuffix
+        _urlHandler: (url) => handlePageContextRequestUrl(url).urlWithoutPageContextRequestSuffix,
     };
 }
 function getRequestId() {
@@ -431,7 +426,7 @@ pageContextNominalPageBegin, httpRequestId, pageContextErrorPageInit, globalCont
     if (pageContextAbort._urlRewrite) {
         const pageContextReturn = await renderPageAlreadyPrepared(pageContextBegin, globalContext, httpRequestId, [
             ...pageContextsFromRewrite,
-            pageContextAbort
+            pageContextAbort,
         ]);
         Object.assign(pageContextReturn, pageContextAbort);
         return { pageContextReturn };
@@ -456,7 +451,7 @@ async function checkBaseUrl(pageContextBegin, globalContext) {
     const httpResponse = createHttpResponseBaseIsMissing(urlOriginal, baseServer);
     objectAssign(pageContext, {
         httpResponse,
-        isBaseMissing: true
+        isBaseMissing: true,
     });
     checkType(pageContext);
     return pageContext;
@@ -471,7 +466,7 @@ function getPageContextSkipRequest(pageContextInit) {
     if (urlPathnameWithBase.endsWith('.well-known/appspecific/com.chrome.devtools.json')) {
         // https://chromium.googlesource.com/devtools/devtools-frontend/+/main/docs/ecosystem/automatic_workspace_folders.md
         // https://www.reddit.com/r/node/comments/1kcr0wh/odd_request_coming_into_my_localhost_server_from/
-        errMsg404 = 'Not spported';
+        errMsg404 = 'Not supported';
     }
     if (!errMsg404)
         return;
@@ -492,15 +487,3 @@ function forkPageContext(pageContextBegin) {
     objectAssign(pageContext, pageContextBegin, true);
     return pageContext;
 }
-function renderPage_vikeConfigHasError(val) {
-    if ('hasRuntimeError' in val)
-        globalObject.vikeConfigHasRuntimeError = val.hasRuntimeError;
-    if ('hasBuildError' in val)
-        globalObject.vikeConfigHasBuildError = val.hasBuildError;
-}
-function getVikeConfigError() {
-    return globalObject.vikeConfigHasBuildError || globalObject.vikeConfigHasRuntimeError;
-}
-function vikeConfigHasError() {
-    return !!getVikeConfigError();
-}

package/dist/esm/node/runtime/universal-middleware.js

@@ -5,13 +5,13 @@ export default async function universalVikeHandler(request, context, runtime) {
         ...runtime,
         runtime,
         urlOriginal: request.url,
-        headersOriginal: request.headers
+        headersOriginal: request.headers,
     };
     const pageContext = await renderPage(pageContextInit);
     const response = pageContext.httpResponse;
     const readable = response.getReadableWebStream();
     return new Response(readable, {
         status: response.statusCode,
-        headers: response.headers
+        headers: response.headers,
     });
 }

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

@@ -33,7 +33,7 @@ export * from '../../utils/freezePartial.js';
 export * from '../../utils/parseNpmPackage.js';
 export * from '../../utils/isNullish.js';
 export * from '../../utils/isScriptFile.js';
-export * from '../../utils/removeFileExtention.js';
+export * from '../../utils/removeFileExtension.js';
 export * from '../../utils/objectKeys.js';
 export * from '../../utils/objectEntries.js';
 export * from '../../utils/objectFromEntries.js';

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

@@ -37,7 +37,7 @@ export * from '../../utils/freezePartial.js';
 export * from '../../utils/parseNpmPackage.js';
 export * from '../../utils/isNullish.js';
 export * from '../../utils/isScriptFile.js';
-export * from '../../utils/removeFileExtention.js';
+export * from '../../utils/removeFileExtension.js';
 export * from '../../utils/objectKeys.js';
 export * from '../../utils/objectEntries.js';
 export * from '../../utils/objectFromEntries.js';

package/dist/esm/node/runtime-dev/createDevMiddleware.js

@@ -16,9 +16,9 @@ async function createDevMiddleware(options = {}) {
             root: options.root ?? options.viteConfig?.root,
             server: {
                 ...options.viteConfig?.server,
-                middlewareMode: options.viteConfig?.server?.middlewareMode ?? true
-            }
-        }
+                middlewareMode: options.viteConfig?.server?.middlewareMode ?? true,
+            },
+        },
     };
     const { viteConfigFromUserEnhanced } = await prepareViteApiCall(optionsMod, 'dev');
     const server = await createServer(viteConfigFromUserEnhanced);

package/dist/esm/node/shared/extractAssetsQuery.js

@@ -1,6 +1,6 @@
 export { extractAssetsAddQuery };
 export { extractAssetsRemoveQuery };
-// We import from node/utils.ts insead of node/vite/utils.ts because this file is loaded by the server runtime
+// We import from node/utils.ts instead of node/vite/utils.ts because this file is loaded by the server runtime
 import { assert, getFileExtension } from './utils.js';
 const query = 'extractAssets';
 function extractAssetsAddQuery(id) {

package/dist/esm/node/shared/getVikeConfigError.d.ts

@@ -0,0 +1,13 @@
+export { getVikeConfigError };
+export { getVikeConfigErrorBuild };
+export { setVikeConfigError };
+type VikeConfigHasError = false | {
+    err: unknown;
+};
+declare function setVikeConfigError(val: {
+    errorRuntime: VikeConfigHasError;
+} | {
+    errorBuild: VikeConfigHasError;
+}): void;
+declare function getVikeConfigError(): VikeConfigHasError;
+declare function getVikeConfigErrorBuild(): VikeConfigHasError;

package/dist/esm/node/shared/getVikeConfigError.js

@@ -0,0 +1,20 @@
+export { getVikeConfigError };
+export { getVikeConfigErrorBuild };
+export { setVikeConfigError };
+import { getGlobalObject } from './utils.js';
+const globalObject = getGlobalObject('node/shared/getVikeConfigError.ts', {
+    errorRuntime: false,
+    errorBuild: false,
+});
+function setVikeConfigError(val) {
+    if ('errorRuntime' in val)
+        globalObject.errorRuntime = val.errorRuntime;
+    if ('errorBuild' in val)
+        globalObject.errorBuild = val.errorBuild;
+}
+function getVikeConfigError() {
+    return globalObject.errorBuild || globalObject.errorRuntime;
+}
+function getVikeConfigErrorBuild() {
+    return globalObject.errorBuild;
+}

package/dist/esm/node/shared/resolveBase.js

@@ -25,6 +25,6 @@ function resolveBase(baseViteOriginal, baseServerUnresolved, baseAssetsUnresolve
     assert(isBaseServer(baseServer));
     return {
         baseServer,
-        baseAssets
+        baseAssets,
     };
 }

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

@@ -1,5 +1,6 @@
 export * from '../../utils/assert.js';
 export * from '../../utils/getFileExtension.js';
+export * from '../../utils/getGlobalObject.js';
 export * from '../../utils/isPlainObject.js';
 export * from '../../utils/checkType.js';
 export * from '../../utils/hasProp.js';

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

@@ -2,6 +2,7 @@ import { assertIsNotBrowser } from '../../utils/assertIsNotBrowser.js';
 assertIsNotBrowser();
 export * from '../../utils/assert.js';
 export * from '../../utils/getFileExtension.js';
+export * from '../../utils/getGlobalObject.js';
 export * from '../../utils/isPlainObject.js';
 export * from '../../utils/checkType.js';
 export * from '../../utils/hasProp.js';

package/dist/esm/node/shared/virtualFiles/virtualFilePageConfigLazy.js

@@ -23,14 +23,14 @@ function isVirtualFileIdPageConfigLazy(id) {
         return {
             pageId: id.slice(idBaseClient.length),
             isForClientSide: true,
-            isExtractAssets
+            isExtractAssets,
         };
     }
     if (id.startsWith(idBaseServer)) {
         return {
             pageId: id.slice(idBaseServer.length),
             isForClientSide: false,
-            isExtractAssets
+            isExtractAssets,
         };
     }
     assert(false);

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

@@ -40,7 +40,7 @@ function plugin(vikeVitePluginOptions = {}) {
         pluginFileEnv(),
         pluginWorkaroundCssModuleHmr(),
         pluginWorkaroundVite6HmrRegression(),
-        pluginReplaceConstants()
+        pluginReplaceConstants(),
     ];
     Object.assign(plugins, { _vikeVitePluginOptions: vikeVitePluginOptions });
     return plugins;
@@ -50,7 +50,7 @@ Object.defineProperty(plugin, 'apply', {
     enumerable: true,
     get: () => {
         assertUsage(false, `Add ${pc.cyan('vike()')} instead of ${pc.cyan('vike')} to vite.config.js#plugins (i.e. call the function and add the return value instead of adding the function itself)`, { showStackTrace: true });
-    }
+    },
 });
 // CJS default export `const vike = require('vike/plugin')`
 //  - It needs to live at the end of this file, in order to ensure we do it after all assignments to `exports`.

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

@@ -20,10 +20,10 @@ function pluginBaseUrls() {
                 envPrefix: [
                     'VITE_', // Vite doesn't seem to merge in its default, see https://github.com/vikejs/vike/issues/554
                     'BASE_SERVER',
-                    'BASE_ASSETS'
+                    'BASE_ASSETS',
                 ],
                 base: basesResolved.baseAssets, // Make Vite inject baseAssets to imports e.g. `import logoUrl from './logo.svg.js'`
-                _baseViteOriginal: baseViteOriginal
+                _baseViteOriginal: baseViteOriginal,
             };
         },
         async configResolved(config) {
@@ -36,7 +36,7 @@ function pluginBaseUrls() {
              *  - Instead of having an internal Vike assertion fail, we let the user discover Vite's buggy behavior.
             assert(config.base === baseAssets)
             */
-        }
+        },
     };
 }
 function resolveBaseFromResolvedConfig(baseServer, baseAssets, config) {

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

@@ -5,7 +5,6 @@ export { handleAssetsManifest_assertUsageCssCodeSplit };
 export { handleAssetsManifest_assertUsageCssTarget };
 import type { Environment, ResolvedConfig, Rollup, UserConfig } from 'vite';
 type Bundle = Rollup.OutputBundle;
-type Options = Rollup.NormalizedOutputOptions;
 declare function handleAssetsManifest_isFixEnabled(config: ResolvedConfig | UserConfig): boolean;
 declare function handleAssetsManifest_assertUsageCssCodeSplit(config: ResolvedConfig): void;
 declare function handleAssetsManifest_assertUsageCssTarget(config: ResolvedConfig): void;
@@ -15,4 +14,6 @@ declare function handleAssetsManifest_getBuildConfig(config: UserConfig): Promis
     readonly manifest: "_temp_manifest.json";
     readonly copyPublicDir: boolean | undefined;
 }>;
-declare function handleAssetsManifest(config: ResolvedConfig, viteEnv: Environment | undefined, options: Options, bundle: Bundle): Promise<void>;
+declare function handleAssetsManifest(config: ResolvedConfig, viteEnv: Environment | undefined, options: {
+    dir: string | undefined;
+}, bundle: Bundle): Promise<void>;

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

@@ -3,11 +3,11 @@ export { handleAssetsManifest_getBuildConfig };
 export { handleAssetsManifest_isFixEnabled };
 export { handleAssetsManifest_assertUsageCssCodeSplit };
 export { handleAssetsManifest_assertUsageCssTarget };
-import fs from 'fs/promises';
-import fs_sync from 'fs';
-import path from 'path';
-import { existsSync } from 'fs';
-import { assert, assertIsSingleModuleInstance, assertWarning, isEqualStringList, isObject, pLimit, unique } from '../../utils.js';
+import fs from 'node:fs/promises';
+import fs_sync from 'node:fs';
+import path from 'node:path';
+import { existsSync } from 'node:fs';
+import { assert, assertIsSingleModuleInstance, assertWarning, isEqualStringList, isObject, pLimit, unique, } from '../../utils.js';
 import { isVirtualFileIdPageConfigLazy } from '../../../shared/virtualFiles/virtualFilePageConfigLazy.js';
 import { manifestTempFile } from './pluginBuildConfig.js';
 import { getAssetsDir } from '../../shared/getAssetsDir.js';
@@ -51,7 +51,7 @@ async function copyAssets(filesToMove, filesToRemove, config) {
         const filePath = path.posix.join(outDirServer, file);
         fs_sync.unlinkSync(filePath);
     });
-    /* We cannot do that because, with some edge case Rollup settings (outputing JavaScript chunks and static assets to the same directoy), this removes JavaScript chunks, see https://github.com/vikejs/vike/issues/1154#issuecomment-1975762404
+    /* We cannot do that because, with some edge case Rollup settings (outputting JavaScript chunks and static assets to the same directory), this removes JavaScript chunks, see https://github.com/vikejs/vike/issues/1154#issuecomment-1975762404
     await fs.rm(assetsDirServer, { recursive: true })
     */
     removeEmptyDirectories(assetsDirServer);
@@ -153,7 +153,7 @@ function addServerAssets(clientManifest, serverManifest) {
                     css,
                     assets,
                     dynamicImports: undefined,
-                    imports: undefined
+                    imports: undefined,
                 };
             }
         }
@@ -205,7 +205,7 @@ function collectResources(entryRoot, manifest) {
 // </head>
 // ```
 function getHash(src) {
-    // src is guarenteed to end with `.[hash][extname]`, see pluginDistFileNames.ts
+    // src is guaranteed to end with `.[hash][extname]`, see pluginDistFileNames.ts
     const hash = src.split('.').at(-2);
     assert(hash);
     return hash;
@@ -234,10 +234,10 @@ function handleAssetsManifest_assertUsageCssTarget(config) {
                 'The CSS browser target should be the same for both client and server, but we got:',
                 `Client: ${pc.cyan(JSON.stringify(targetCssResolvedClient))}`,
                 `Server: ${pc.cyan(JSON.stringify(targetCssResolvedServer))}`,
-                `Different targets lead to CSS duplication, see ${pc.underline('https://github.com/vikejs/vike/issues/1815#issuecomment-2507002979')} for more information.`
+                `Different targets lead to CSS duplication, see ${pc.underline('https://github.com/vikejs/vike/issues/1815#issuecomment-2507002979')} for more information.`,
             ].join('\n'), {
                 showStackTrace: true,
-                onlyOnce: 'different-css-target'
+                onlyOnce: 'different-css-target',
             });
         });
     });
@@ -291,7 +291,7 @@ async function handleAssetsManifest_getBuildConfig(config) {
         copyPublicDir: vikeConfig.config.vite6BuilderApp
             ? // Already set by vike:build:pluginBuildApp
                 undefined
-            : !isViteServerBuild(config)
+            : !isViteServerBuild(config),
     };
 }
 async function handleAssetsManifest(config, viteEnv, options, bundle) {
@@ -303,11 +303,13 @@ async function handleAssetsManifest(config, viteEnv, options, bundle) {
         await writeAssetsManifestFile(outDirs, assetsJsonFilePath, config);
     }
     if (isViteServerBuild(config, viteEnv)) {
+        const outDir = options.dir;
+        assert(outDir);
         // Replace __VITE_ASSETS_MANIFEST__ in server builds
         // - Always replace it in dist/server/
         // - Also in some other server builds such as dist/vercel/ from vike-vercel
         // - Don't replace it in dist/rsc/ from vike-react-rsc since __VITE_ASSETS_MANIFEST__ doesn't exist there
-        const noop = await set_macro_ASSETS_MANIFEST(options, bundle, assetsJsonFilePath);
+        const noop = await set_macro_ASSETS_MANIFEST(assetsJsonFilePath, bundle, outDir);
         if (isSsREnv)
             assert(!noop); // dist/server should always contain __VITE_ASSETS_MANIFEST__
     }

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

@@ -43,8 +43,8 @@ function pluginAutoFullBuild() {
                         logErrorHint(err);
                         process.exit(1);
                     }
-                }
-            }
+                },
+            },
         },
         {
             name: 'vike:build:pluginAutoFullBuild:post',
@@ -63,9 +63,9 @@ function pluginAutoFullBuild() {
                         runPrerender_forceExit();
                         assert(false);
                     }
-                }
-            }
-        }
+                },
+            },
+        },
     ];
 }
 async function triggerFullBuild(config, viteEnv, bundle) {
@@ -89,7 +89,7 @@ async function triggerFullBuild(config, viteEnv, bundle) {
         await build(setSSR(configInline));
     }
     else {
-        // The server bulid is already called by builder.buildApp()
+        // The server build is already called by builder.buildApp()
     }
     if (isPrerenderAutoRunEnabled(vikeConfig)) {
         const res = await runPrerenderFromAutoRun(configInline);
@@ -102,8 +102,8 @@ function setSSR(configInline) {
         ...configInline,
         build: {
             ...configInline.build,
-            ssr: true
-        }
+            ssr: true,
+        },
     };
 }
 async function abortViteBuildSsr() {
@@ -137,8 +137,8 @@ function getFullBuildInlineConfig(config) {
             configFile: configFromCli?.configFile || config.configFile,
             root: config.root,
             build: {
-                ...configFromCli?.build
-            }
+                ...configFromCli?.build,
+            },
         };
     }
 }