vike 0.4.239 → 0.4.240

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

@@ -11,37 +11,45 @@ import { getVikeConfigInternal } from '../shared/resolveVikeConfigInternal.js';
 function pluginPreview() {
     let config;
     let vikeConfig;
-    return {
-        name: 'vike:pluginPreview',
-        apply: applyPreview,
-        config() {
-            return {
-                appType: 'custom',
-            };
+    return [
+        {
+            name: 'vike:pluginPreview',
+            apply: applyPreview,
+            config: {
+                handler() {
+                    return {
+                        appType: 'custom',
+                    };
+                },
+            },
+            configResolved: {
+                async handler(config_) {
+                    config = config_;
+                    vikeConfig = await getVikeConfigInternal();
+                    logDockerHint(config.preview.host);
+                    // vikeConfig = await getVikeConfig(config)
+                },
+            },
+            configurePreviewServer: {
+                handler(server) {
+                    /* - Couldn't make `appType: 'mpa'` work as of npm:@brillout/vite@5.0.0-beta.14.0426910c
+                   - This ugly hack to set appType for preview won't be need once https://github.com/vitejs/vite/pull/14855 is merged.
+                config.appType = 'mpa'
+                */
+                    return () => {
+                        const { isPrerenderingEnabledForAllPages, isPrerenderingEnabled } = vikeConfig.prerenderContext;
+                        assertDist(isPrerenderingEnabledForAllPages);
+                        // We cannot re-use Vite's static middleware: https://github.com/vitejs/vite/pull/14836#issuecomment-1788540300
+                        addStaticAssetsMiddleware(server.middlewares);
+                        if (!isPrerenderingEnabledForAllPages) {
+                            addSsrMiddleware(server.middlewares, config, true, isPrerenderingEnabled);
+                        }
+                        addStatic404Middleware(server.middlewares);
+                    };
+                },
+            },
         },
-        async configResolved(config_) {
-            config = config_;
-            vikeConfig = await getVikeConfigInternal();
-            logDockerHint(config.preview.host);
-            // vikeConfig = await getVikeConfig(config)
-        },
-        configurePreviewServer(server) {
-            /* - Couldn't make `appType: 'mpa'` work as of npm:@brillout/vite@5.0.0-beta.14.0426910c
-               - This ugly hack to set appType for preview won't be need once https://github.com/vitejs/vite/pull/14855 is merged.
-            config.appType = 'mpa'
-            */
-            return () => {
-                const { isPrerenderingEnabledForAllPages, isPrerenderingEnabled } = vikeConfig.prerenderContext;
-                assertDist(isPrerenderingEnabledForAllPages);
-                // We cannot re-use Vite's static middleware: https://github.com/vitejs/vite/pull/14836#issuecomment-1788540300
-                addStaticAssetsMiddleware(server.middlewares);
-                if (!isPrerenderingEnabledForAllPages) {
-                    addSsrMiddleware(server.middlewares, config, true, isPrerenderingEnabled);
-                }
-                addStatic404Middleware(server.middlewares);
-            };
-        },
-    };
+    ];
     function assertDist(isPrerenderingEnabledForAllPages) {
         const { outDirRoot, outDirClient, outDirServer } = getOutDirs(config, undefined);
         const dirS = [outDirRoot, outDirClient];

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

@@ -0,0 +1,9 @@
+export { pluginReplaceGlobalThisConstants };
+import type { Plugin } from 'vite';
+declare global {
+    /** Like `import.meta.env.DEV` but works inside `node_modules/` (even if package is `ssr.external`). The value `undefined` is to be interpreted as `false`. */
+    var __VIKE__IS_DEV: boolean | undefined;
+    /** Like `import.meta.env.SSR` but works inside `node_modules/` (even if package is `ssr.external`). The value `undefined` is to be interpreted as `false`. */
+    var __VIKE__IS_CLIENT: boolean | undefined;
+}
+declare function pluginReplaceGlobalThisConstants(): Plugin[];

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

@@ -0,0 +1,45 @@
+export { pluginReplaceGlobalThisConstants };
+import { assert } from '../utils.js';
+// === Explanation: globalThis.__VIKE__IS_DEV
+// If client-side => always noExternal => globalThis.__VIKE__IS_DEV is set by the `define` config below.
+// If server-side:
+//   If ssr.noExternal => globalThis.__VIKE__IS_DEV is set by the `define` config below.
+//   If `ssr.external`:
+//     If not RunnableDevEnvironment (e.g. `@cloudflare/vite-plugin`) => always ssr.noExternal => globalThis.__VIKE__IS_DEV is set by the `define` config below.
+//     If RunnableDevEnvironment (the default setup):
+//       If dev/preview/pre-rendering => Vite is loaded, and server and Vite run inside the same process (because RunnableDevEnvironment) => globalThis.__VIKE__IS_DEV is set by the assignment below.
+//       If production => Vite isn't loaded => globalThis.__VIKE__IS_DEV is `undefined` (it's never set) => value `undefined` is to be interpreted as `false`.
+// === Explanation: globalThis.__VIKE__IS_CLIENT
+// If client-side => always noExternal => globalThis.__VIKE__IS_CLIENT is set to `true` by the `define` config below.
+// If server-side => globalThis.__VIKE__IS_CLIENT is either `false` or `undefined` (the value `undefined` is to be interpreted as `false`).
+globalThis.__VIKE__IS_CLIENT = false;
+function pluginReplaceGlobalThisConstants() {
+    return [
+        {
+            name: 'vike:pluginReplaceGlobalThisConstants',
+            config: {
+                handler(config) {
+                    const isDev = config._isDev;
+                    assert(typeof isDev === 'boolean');
+                    globalThis.__VIKE__IS_DEV = isDev;
+                    return {
+                        define: {
+                            'globalThis.__VIKE__IS_DEV': JSON.stringify(isDev),
+                        },
+                    };
+                },
+            },
+            configEnvironment: {
+                handler(name, config) {
+                    const consumer = config.consumer ?? (name === 'client' ? 'client' : 'server');
+                    const isClientSide = consumer === 'client';
+                    return {
+                        define: {
+                            'globalThis.__VIKE__IS_CLIENT': JSON.stringify(isClientSide),
+                        },
+                    };
+                },
+            },
+        },
+    ];
+}

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

@@ -0,0 +1,3 @@
+export { pluginReplaceIsClientSide };
+import type { Plugin } from 'vite';
+declare function pluginReplaceIsClientSide(): Plugin[];

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

@@ -0,0 +1,87 @@
+export { pluginReplaceIsClientSide };
+import { assert, assertPosixPath } from '../utils.js';
+import { normalizeId } from '../shared/normalizeId.js';
+import { isViteServerSide_extraSafe } from '../shared/isViteServerSide.js';
+import { getMagicString } from '../shared/getMagicString.js';
+const constantsIsClientSide = [
+    //
+    'pageContext.isClientSide',
+    'globalContext.isClientSide',
+    'pageContext.globalContext.isClientSide',
+];
+const skipNodeModules = '/node_modules/';
+const skipIrrelevant = 'Context.isClientSide';
+assert(constantsIsClientSide.every((constant) => constant.endsWith(skipIrrelevant)));
+const filterRolldown = {
+    id: {
+        exclude: `**${skipNodeModules}**`,
+    },
+    code: {
+        include: skipIrrelevant,
+    },
+};
+const filterFunction = (id, code) => {
+    if (id.includes(skipNodeModules))
+        return false;
+    if (!code.includes(skipIrrelevant))
+        return false;
+    return true;
+};
+function pluginReplaceIsClientSide() {
+    let config;
+    return [
+        {
+            name: 'vike:pluginReplaceIsClientSide',
+            enforce: 'post',
+            apply: 'build',
+            configResolved: {
+                handler(config_) {
+                    config = config_;
+                },
+            },
+            transform: {
+                filter: filterRolldown,
+                handler(code, id, options) {
+                    id = normalizeId(id);
+                    assertPosixPath(id);
+                    assertPosixPath(config.root);
+                    if (!id.startsWith(config.root))
+                        return; // skip linked dependencies
+                    assert(filterFunction(id, code));
+                    const isBuild = config.command === 'build';
+                    assert(isBuild);
+                    // Used by vike.dev
+                    // https://github.com/vikejs/vike/blob/08a1ff55c80ddca64ca6d4417fefd45fefeb4ffb/docs/vite.config.ts#L12
+                    // @ts-expect-error
+                    if (config._skipVikeReplaceConstants?.(id))
+                        return;
+                    const { magicString, getMagicStringResult } = getMagicString(code, id);
+                    if (constantsIsClientSide.some((c) => code.includes(c))) {
+                        const replacement = !isViteServerSide_extraSafe(config, this.environment, options);
+                        const regExp = getConstantRegExp(constantsIsClientSide);
+                        magicString.replaceAll(regExp, JSON.stringify(replacement));
+                    }
+                    return getMagicStringResult();
+                },
+            },
+        },
+    ];
+}
+// Copied & adapted from:
+// https://github.com/rollup/plugins/blob/e1a5ef99f1578eb38a8c87563cb9651db228f3bd/packages/replace/src/index.js#L57-L67
+function getConstantRegExp(constants) {
+    const keys = Object.values(constants).sort(longest).map(escape);
+    // const delimiters = ['\\b', '\\b(?!\\.)']
+    const delimiters = ['(?<!\\.)\\b', '\\b(?!\\.)']; // Improved version, to avoid replacing `globalContext.pageContext.isClientSide` with `globalContext.false`
+    const preventAssignment = false; // Let's try without it first, let's see if a user complains
+    const lookbehind = preventAssignment ? '(?<!\\b(?:const|let|var)\\s*)' : '';
+    const lookahead = preventAssignment ? '(?!\\s*=[^=])' : '';
+    const pattern = new RegExp(`${lookbehind}${delimiters[0]}(${keys.join('|')})${delimiters[1]}${lookahead}`, 'g');
+    return pattern;
+}
+function escape(str) {
+    return str.replace(/[-[\]/{}()*+?.\\^$|]/g, '\\$&');
+}
+function longest(a, b) {
+    return b.length - a.length;
+}

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

@@ -20,8 +20,10 @@ function pluginSetGlobalContext() {
                     markSetup_viteDevServer();
                 },
             },
-            configurePreviewServer() {
-                markSetup_vitePreviewServer();
+            configurePreviewServer: {
+                handler() {
+                    markSetup_vitePreviewServer();
+                },
             },
             config: {
                 order: 'pre',

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

@@ -5,7 +5,7 @@ import { getVikeConfigInternal } from '../../shared/resolveVikeConfigInternal.js
 import { extractAssetsAddQuery } from '../../../shared/extractAssetsQuery.js';
 import { debug } from './debug.js';
 import { serializeConfigValues } from '../../../../shared/page-configs/serialize/serializeConfigValues.js';
-import { handleAssetsManifest_isFixEnabled } from '../pluginBuild/handleAssetsManifest.js';
+import { handleAssetsManifest_isFixEnabled } from '../build/handleAssetsManifest.js';
 import { getConfigValueBuildTime } from '../../../../shared/page-configs/getConfigValueBuildTime.js';
 import { resolveIncludeAssetsImportedByServer } from '../../../runtime/renderPage/getPageAssets/retrievePageAssetsProd.js';
 async function generateVirtualFilePageEntry(id, isDev) {

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

@@ -1,3 +1,3 @@
 export { pluginVirtualFiles };
 import type { Plugin } from 'vite';
-declare function pluginVirtualFiles(): Plugin;
+declare function pluginVirtualFiles(): Plugin[];

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

@@ -2,63 +2,81 @@ export { pluginVirtualFiles };
 import { normalizePath } from 'vite';
 import { generateVirtualFilePageEntry } from './pluginVirtualFiles/generateVirtualFilePageEntry.js';
 import { generateVirtualFileGlobalEntryWithOldDesign } from './pluginVirtualFiles/generateVirtualFileGlobalEntryWithOldDesign.js';
-import { assert, assertPosixPath, isScriptFile, addVirtualFileIdPrefix, isVirtualFileId, removeVirtualFileIdPrefix, } from '../utils.js';
+import { assert, assertPosixPath, isScriptFile, addVirtualFileIdPrefix, isVirtualFileId, removeVirtualFileIdPrefix, escapeRegex, virtualFileIdPrefix1, virtualFileIdPrefix2, } from '../utils.js';
 import { parseVirtualFileId } from '../../shared/virtualFileId.js';
 import { reloadVikeConfig, isV1Design, getVikeConfigInternalOptional } from '../shared/resolveVikeConfigInternal.js';
 import pc from '@brillout/picocolors';
 import { logConfigInfo } from '../shared/loggerNotProd.js';
 import { getModuleFilePathAbsolute } from '../shared/getFilePath.js';
-import { updateUserFiles } from '../../runtime/globalContext.js';
+import { isRunnable, updateUserFiles } from '../../runtime/globalContext.js';
 import { isPlusFile } from '../shared/resolveVikeConfigInternal/crawlPlusFiles.js';
 import { isTemporaryBuildFile } from '../shared/resolveVikeConfigInternal/transpileAndExecuteFile.js';
 import { getVikeConfigError } from '../../shared/getVikeConfigError.js';
+const filterRolldown = {
+    id: {
+        include: new RegExp(`^(${escapeRegex(virtualFileIdPrefix1)}|${escapeRegex(virtualFileIdPrefix2)})`),
+    },
+};
+const filterFunction = (id) => isVirtualFileId(id);
 function pluginVirtualFiles() {
     let config;
-    return {
-        name: 'vike:pluginVirtualFiles',
-        async configResolved(config_) {
-            config = config_;
-            // TO-DO/next-major-release: remove
-            if (!isV1Design())
-                config.experimental.importGlobRestoreExtension = true;
+    return [
+        {
+            name: 'vike:pluginVirtualFiles',
+            configResolved: {
+                async handler(config_) {
+                    config = config_;
+                    // TO-DO/next-major-release: remove
+                    if (!isV1Design())
+                        config.experimental.importGlobRestoreExtension = true;
+                },
+            },
+            resolveId: {
+                filter: filterRolldown,
+                handler(id) {
+                    assert(filterFunction(id));
+                    return addVirtualFileIdPrefix(id);
+                },
+            },
+            handleHotUpdate: {
+                async handler(ctx) {
+                    try {
+                        return await handleHotUpdate(ctx, config);
+                    }
+                    catch (err) {
+                        // Vite swallows errors thrown by handleHotUpdate()
+                        console.error(err);
+                        throw err;
+                    }
+                },
+            },
+            load: {
+                filter: filterRolldown,
+                async handler(id, options) {
+                    assert(filterFunction(id));
+                    id = removeVirtualFileIdPrefix(id);
+                    const isDev = config._isDev;
+                    assert(typeof isDev === 'boolean');
+                    const idParsed = parseVirtualFileId(id);
+                    if (idParsed) {
+                        if (idParsed.type === 'page-entry') {
+                            const code = await generateVirtualFilePageEntry(id, isDev);
+                            return code;
+                        }
+                        if (idParsed.type === 'global-entry') {
+                            const code = await generateVirtualFileGlobalEntryWithOldDesign(id, options, config, this.environment, isDev);
+                            return code;
+                        }
+                    }
+                },
+            },
+            configureServer: {
+                handler(server) {
+                    handleFileAddRemove(server, config);
+                },
+            },
         },
-        resolveId(id) {
-            if (isVirtualFileId(id)) {
-                return addVirtualFileIdPrefix(id);
-            }
-        },
-        async handleHotUpdate(ctx) {
-            try {
-                return await handleHotUpdate(ctx, config);
-            }
-            catch (err) {
-                // Vite swallows errors thrown by handleHotUpdate()
-                console.error(err);
-                throw err;
-            }
-        },
-        async load(id, options) {
-            if (!isVirtualFileId(id))
-                return undefined;
-            id = removeVirtualFileIdPrefix(id);
-            const isDev = config._isDev;
-            assert(typeof isDev === 'boolean');
-            const idParsed = parseVirtualFileId(id);
-            if (idParsed) {
-                if (idParsed.type === 'page-entry') {
-                    const code = await generateVirtualFilePageEntry(id, isDev);
-                    return code;
-                }
-                if (idParsed.type === 'global-entry') {
-                    const code = await generateVirtualFileGlobalEntryWithOldDesign(id, options, config, this.environment, isDev);
-                    return code;
-                }
-            }
-        },
-        configureServer(server) {
-            handleFileAddRemove(server, config);
-        },
-    };
+    ];
 }
 function handleFileAddRemove(server, config) {
     server.watcher.prependListener('add', (f) => listener(f, false));
@@ -125,7 +143,9 @@ async function handleHotUpdate(ctx, config) {
             // Ensure we invalidate `file` *before* server.ssrLoadModule() in updateUserFiles()
             // Vite already invalidates it, but *after* handleHotUpdate() and thus after server.ssrLoadModule()
             ctx.modules.forEach((mod) => server.moduleGraph.invalidateModule(mod));
-            updateUserFiles();
+            if (isRunnable(server)) {
+                await updateUserFiles();
+            }
         }
     }
 }

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

@@ -1,3 +1,3 @@
 export { pluginWorkaroundCssModuleHmr };
 import type { Plugin } from 'vite';
-declare function pluginWorkaroundCssModuleHmr(): Plugin;
+declare function pluginWorkaroundCssModuleHmr(): Plugin[];

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

@@ -1,13 +1,17 @@
 export { pluginWorkaroundCssModuleHmr };
 function pluginWorkaroundCssModuleHmr() {
-    return {
-        name: 'vike:pluginWorkaroundCssModuleHmr',
-        handleHotUpdate(ctx) {
-            // prevent full reload due to non self-accepting css module.
-            // here only "?direct" module should be filtered out as it doesn't have a parent module.
-            if (ctx.file.includes('module.css')) {
-                return ctx.modules.filter((m) => !m.id?.includes('?direct'));
-            }
+    return [
+        {
+            name: 'vike:pluginWorkaroundCssModuleHmr',
+            handleHotUpdate: {
+                handler(ctx) {
+                    // prevent full reload due to non self-accepting css module.
+                    // here only "?direct" module should be filtered out as it doesn't have a parent module.
+                    if (ctx.file.includes('module.css')) {
+                        return ctx.modules.filter((m) => !m.id?.includes('?direct'));
+                    }
+                },
+            },
         },
-    };
+    ];
 }

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

@@ -1,3 +1,3 @@
 export { pluginWorkaroundVite6HmrRegression };
 import type { Plugin } from 'vite';
-declare function pluginWorkaroundVite6HmrRegression(): Plugin;
+declare function pluginWorkaroundVite6HmrRegression(): Plugin[];

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

@@ -4,30 +4,32 @@ export { pluginWorkaroundVite6HmrRegression };
 // Workaround seems to work for docs page /banner (which is HTML-only)
 // But doesn't seem to work for /examples/render-modes/ (see https://github.com/vikejs/vike/pull/2069 commit `renable HMR test for HTML-only`)
 function pluginWorkaroundVite6HmrRegression() {
-    return {
-        name: 'vike:pluginWorkaroundVite6HmrRegression',
-        enforce: 'post',
-        hotUpdate: {
-            order: 'post',
-            handler({ modules, server, timestamp }) {
-                if (this.environment.name !== 'ssr')
-                    return;
-                let hasSsrOnlyModules = false;
-                const invalidatedModules = new Set();
-                for (const mod of modules) {
-                    if (mod.id == null)
-                        continue;
-                    const clientModule = server.environments.client.moduleGraph.getModuleById(mod.id);
-                    if (clientModule != null)
-                        continue;
-                    this.environment.moduleGraph.invalidateModule(mod, invalidatedModules, timestamp, true);
-                    hasSsrOnlyModules = true;
-                }
-                if (hasSsrOnlyModules) {
-                    server.ws.send({ type: 'full-reload' });
-                    return [];
-                }
+    return [
+        {
+            name: 'vike:pluginWorkaroundVite6HmrRegression',
+            enforce: 'post',
+            hotUpdate: {
+                order: 'post',
+                handler({ modules, server, timestamp }) {
+                    if (this.environment.name !== 'ssr')
+                        return;
+                    let hasSsrOnlyModules = false;
+                    const invalidatedModules = new Set();
+                    for (const mod of modules) {
+                        if (mod.id == null)
+                            continue;
+                        const clientModule = server.environments.client.moduleGraph.getModuleById(mod.id);
+                        if (clientModule != null)
+                            continue;
+                        this.environment.moduleGraph.invalidateModule(mod, invalidatedModules, timestamp, true);
+                        hasSsrOnlyModules = true;
+                    }
+                    if (hasSsrOnlyModules) {
+                        server.ws.send({ type: 'full-reload' });
+                        return [];
+                    }
+                },
             },
         },
-    };
+    ];
 }

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

@@ -5,5 +5,5 @@ declare function getMagicString(code: string, id: string): {
     getMagicStringResult: () => {
         code: string;
         map: import("magic-string").SourceMap;
-    };
+    } | undefined;
 };

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

@@ -4,6 +4,8 @@ import MagicString from 'magic-string';
 function getMagicString(code, id) {
     const magicString = new MagicString(code);
     const getMagicStringResult = () => {
+        if (!magicString.hasChanged())
+            return undefined;
         return {
             code: magicString.toString(),
             map: magicString.generateMap({ hires: true, source: id }),

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

@@ -6,11 +6,11 @@ export type GlobalContextInternal = GlobalContextServerInternal | GlobalContextC
 import type { PageFile } from './getPageFiles.js';
 import type { PageConfigRuntime } from '../types/PageConfig.js';
 import type { GlobalContextServerInternal } from '../node/runtime/globalContext.js';
-import type { GlobalContextClientInternal } from '../client/runtime-client-routing/globalContext.js';
+import type { GlobalContextClientInternal } from '../client/runtime-client-routing/getGlobalContextClientInternal.js';
 import { type Hook } from './hooks/getHook.js';
 declare const getGlobalContextSyncErrMsg = "The global context isn't set yet, call getGlobalContextSync() later or use getGlobalContext() instead.";
-declare function createGlobalContextShared<GlobalContextAdded extends Record<string, any>, GlobalContextAddedAsync extends Record<string, any>>(virtualFileExportsGlobalEntry: unknown, globalObject: {
-    globalContext?: Record<string, unknown>;
+declare function createGlobalContextShared<GlobalContextAdded extends {}, GlobalContextAddedAsync extends {}>(virtualFileExportsGlobalEntry: unknown, globalObject: {
+    globalContext?: {};
     onCreateGlobalContextHooks?: Hook[];
     previousCreateGlobalContextPromise?: Promise<void>;
 }, addGlobalContext?: (globalContext: GlobalContextBase) => GlobalContextAdded, addGlobalContextTmp?: (globalContext: GlobalContextBase) => Promise<GlobalContextAdded>, addGlobalContextAsync?: (globalContext: GlobalContextBase) => Promise<GlobalContextAddedAsync>): Promise<{
@@ -64,7 +64,7 @@ declare function createGlobalContextShared<GlobalContextAdded extends Record<str
     _pageConfigs: PageConfigRuntime[];
     _pageConfigGlobal: import("../types/PageConfig.js").PageConfigGlobalRuntime;
     _allPageIds: string[];
-} & GlobalContextAdded & GlobalContextAddedAsync>;
+} & GlobalContextAdded & Awaited<GlobalContextAddedAsync>>;
 type GlobalContextBasePublic = Pick<GlobalContextBase, 'config' | 'pages' | 'isGlobalContext'>;
 type GlobalContextBase = ReturnType<typeof createGlobalContextBase>;
 declare function createGlobalContextBase(virtualFileExportsGlobalEntry: unknown): {

package/dist/esm/shared/route/abort.d.ts

@@ -13,7 +13,7 @@ export type { ErrorAbort };
 export type { PageContextFromRewrite };
 export type { UrlRedirect };
 type RedirectStatusCode = number & Parameters<typeof redirect>[1];
-type AbortStatusCode = number & Parameters<typeof render>[0];
+type AbortStatusCode = number & Parameters<InferTwoOverloads<typeof render>[0]>[0];
 type UrlRedirect = {
     url: string;
     statusCode: RedirectStatusCode;
@@ -36,16 +36,23 @@ declare function redirect(url: string, statusCode?: 301 | 302): AbortRedirect;
  *
  * https://vike.dev/render
  *
- * @param abortStatusCode
- * One of the following:
- *   `401` Unauthorized (user isn't logged in)
- *   `403` Forbidden (user is logged in but isn't allowed)
- *   `404` Not Found
- *   `410` Gone (use this instead of `404` if the page existed in the past, see https://github.com/vikejs/vike/issues/1097#issuecomment-1695260887)
- *   `429` Too Many Requests (rate limiting)
- *   `500` Internal Server Error (your client or server has a bug)
- *   `503` Service Unavailable (server is overloaded, or a third-party API isn't responding)
- * @param abortReason Sets `pageContext.abortReason` which is usually used by the error page to show a message to the user, see https://vike.dev/error-page
+ *
+ * **Recommended** status codes:
+ *   `401` — Unauthorized (user isn't logged in)
+ *   `403` — Forbidden (user is logged in but isn't allowed)
+ *   `404` — Not Found
+ *   `410` — Gone (use this instead of `404` if the page existed in the past, see https://github.com/vikejs/vike/issues/1097#issuecomment-1695260887)
+ *   `429` — Too Many Requests (rate limiting)
+ *   `500` — Internal Server Error (your client or server has a bug)
+ *   `503` — Service Unavailable (server is overloaded, or a third-party API isn't responding)
+ *
+ * **Not recommended** status codes:
+ *   `400` — See https://github.com/vikejs/vike/issues/1008#issuecomment-3270894445
+ *   Other status codes — See https://github.com/vikejs/vike/issues/1008
+ *
+ * @param abortStatusCode - One of the recommended status codes listed above.
+ *
+ * @param abortReason - Sets `pageContext.abortReason` which is usually used by the error page to show a message to the user, see https://vike.dev/error-page
  */
 declare function render(abortStatusCode: 401 | 403 | 404 | 410 | 429 | 500 | 503, abortReason?: AbortReason): Error;
 /**
@@ -106,3 +113,7 @@ type PageContextFromAllRewrites = {
 };
 declare function getPageContextFromAllRewrites(pageContextsFromRewrite: PageContextFromRewrite[]): PageContextFromAllRewrites;
 declare function assertNoInfiniteAbortLoop(rewriteCount: number, redirectCount: number): void;
+type InferTwoOverloads<F extends Function> = F extends {
+    (...a1: infer A1): infer R1;
+    (...a0: infer A0): infer R0;
+} ? [(...a1: A1) => R1, (...a0: A0) => R0] : never;