vike 0.4.220 → 0.4.221-commit-8577456

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

@@ -4,7 +4,7 @@ import { getPageContextInitEnhanced, renderPageAlreadyRouted } from './renderPag
 import { route } from '../../shared/route/index.js';
 import { assert, hasProp, objectAssign, isUrl, parseUrl, onSetupRuntime, assertWarning, getGlobalObject, checkType, assertUsage, normalizeUrlPathname, removeBaseServer, modifyUrlPathname, prependBase, removeUrlOrigin, setUrlOrigin, createUrlFromComponents, isUri, getUrlPretty } from './utils.js';
 import { assertNoInfiniteAbortLoop, getPageContextFromAllRewrites, isAbortError, logAbortErrorHandled } from '../../shared/route/abort.js';
-import { getGlobalContext, initGlobalContext_renderPage } from './globalContext.js';
+import { getGlobalContextInternal, initGlobalContext_renderPage } from './globalContext.js';
 import { handlePageContextRequestUrl } from './renderPage/handlePageContextRequestUrl.js';
 import { createHttpResponseFavicon404, createHttpResponseRedirect, createHttpResponsePageContextJson, createHttpResponseError } from './renderPage/createHttpResponse.js';
 import { logRuntimeError, logRuntimeInfo } from './renderPage/loggerRuntime.js';
@@ -18,6 +18,7 @@ import { getErrorPageId } from '../../shared/error-page.js';
 import { handleErrorWithoutErrorPage } from './renderPage/handleErrorWithoutErrorPage.js';
 import { loadUserFilesServerSide } from './renderPage/loadUserFilesServerSide.js';
 import { resolveRedirects } from './renderPage/resolveRedirects.js';
+import { resolveBaseRuntime } from '../shared/resolveBase.js';
 const globalObject = getGlobalObject('runtime/renderPage.ts', {
     httpRequestsCount: 0
 });
@@ -75,25 +76,26 @@ async function renderPageAndPrepare(pageContextInit, httpRequestId) {
         return handleInvalidConfig(isConfigInvalid.err);
     }
     else {
-        // From now on, gloablContext contains all the configuration data; getVikeConfig() isn't called anymore for this request
+        // From now on, globalContext contains all the configuration data; getVikeConfig() isn't called anymore for this request
     }
+    const globalContext = await getGlobalContextInternal();
     // Check Base URL
-    assertBaseUrl(pageContextInit);
+    await assertBaseUrl(pageContextInit, globalContext);
     // Normalize URL
     {
-        const pageContextHttpResponse = normalizeUrl(pageContextInit, httpRequestId);
+        const pageContextHttpResponse = await normalizeUrl(pageContextInit, globalContext, httpRequestId);
         if (pageContextHttpResponse)
             return pageContextHttpResponse;
     }
     // Permanent redirects (HTTP status code `301`)
     {
-        const pageContextHttpResponse = getPermanentRedirect(pageContextInit, httpRequestId);
+        const pageContextHttpResponse = await getPermanentRedirect(pageContextInit, globalContext, httpRequestId);
         if (pageContextHttpResponse)
             return pageContextHttpResponse;
     }
-    return await renderPageAlreadyPrepared(pageContextInit, httpRequestId, []);
+    return await renderPageAlreadyPrepared(pageContextInit, globalContext, httpRequestId, []);
 }
-async function renderPageAlreadyPrepared(pageContextInit, httpRequestId, pageContextsFromRewrite) {
+async function renderPageAlreadyPrepared(pageContextInit, globalContext, httpRequestId, pageContextsFromRewrite) {
     assertNoInfiniteAbortLoop(pageContextsFromRewrite.length, 
     // There doesn't seem to be a way to count the number of HTTP redirects (vike don't have access to the HTTP request headers/cookies)
     // https://stackoverflow.com/questions/9683007/detect-infinite-http-redirect-loop-on-server-side
@@ -105,7 +107,7 @@ async function renderPageAlreadyPrepared(pageContextInit, httpRequestId, pageCon
         objectAssign(pageContextNominalPageInit, pageContextFromAllRewrites);
     }
     {
-        const pageContextInitEnhanced = getPageContextInitEnhancedSSR(pageContextInit, pageContextNominalPageInit._urlRewrite, httpRequestId);
+        const pageContextInitEnhanced = await getPageContextInitEnhancedSSR(pageContextInit, globalContext, pageContextNominalPageInit._urlRewrite, httpRequestId);
         objectAssign(pageContextNominalPageInit, pageContextInitEnhanced);
     }
     let errNominalPage;
@@ -137,10 +139,10 @@ async function renderPageAlreadyPrepared(pageContextInit, httpRequestId, pageCon
         assert(pageContextNominalPageSuccess === undefined);
         assert(pageContextNominalPageInit);
         assert(hasProp(pageContextNominalPageInit, 'urlOriginal', 'string'));
-        const pageContextErrorPageInit = await getPageContextErrorPageInit(pageContextInit, errNominalPage, pageContextNominalPageInit, httpRequestId);
+        const pageContextErrorPageInit = await getPageContextErrorPageInit(pageContextInit, globalContext, errNominalPage, pageContextNominalPageInit, httpRequestId);
         // Handle `throw redirect()` and `throw render()` while rendering nominal page
         if (isAbortError(errNominalPage)) {
-            const handled = await handleAbortError(errNominalPage, pageContextsFromRewrite, pageContextInit, pageContextNominalPageInit, httpRequestId, pageContextErrorPageInit);
+            const handled = await handleAbortError(errNominalPage, pageContextsFromRewrite, pageContextInit, pageContextNominalPageInit, httpRequestId, pageContextErrorPageInit, globalContext);
             if (handled.pageContextReturn) {
                 // - throw redirect()
                 // - throw render(url)
@@ -153,7 +155,6 @@ async function renderPageAlreadyPrepared(pageContextInit, httpRequestId, pageCon
             Object.assign(pageContextErrorPageInit, handled.pageContextAbort);
         }
         {
-            const globalContext = getGlobalContext();
             const errorPageId = getErrorPageId(globalContext.pageFilesAll, globalContext.pageConfigs);
             if (!errorPageId) {
                 objectAssign(pageContextErrorPageInit, { pageId: null });
@@ -170,7 +171,7 @@ async function renderPageAlreadyPrepared(pageContextInit, httpRequestId, pageCon
         catch (errErrorPage) {
             // Handle `throw redirect()` and `throw render()` while rendering error page
             if (isAbortError(errErrorPage)) {
-                const handled = await handleAbortError(errErrorPage, pageContextsFromRewrite, pageContextInit, pageContextNominalPageInit, httpRequestId, pageContextErrorPageInit);
+                const handled = await handleAbortError(errErrorPage, pageContextsFromRewrite, pageContextInit, pageContextNominalPageInit, httpRequestId, pageContextErrorPageInit, globalContext);
                 // throw render(abortStatusCode)
                 if (!handled.pageContextReturn) {
                     const pageContextAbort = errErrorPage._pageContextAbort;
@@ -286,8 +287,8 @@ async function renderPageNominal(pageContext) {
     assert(pageContext === pageContextAfterRender);
     return pageContextAfterRender;
 }
-async function getPageContextErrorPageInit(pageContextInit, errNominalPage, pageContextNominalPagePartial, httpRequestId) {
-    const pageContextInitEnhanced = getPageContextInitEnhancedSSR(pageContextInit, null, httpRequestId);
+async function getPageContextErrorPageInit(pageContextInit, globalContext, errNominalPage, pageContextNominalPagePartial, httpRequestId) {
+    const pageContextInitEnhanced = await getPageContextInitEnhancedSSR(pageContextInit, globalContext, null, httpRequestId);
     assert(errNominalPage);
     const pageContext = {};
     objectAssign(pageContext, pageContextInitEnhanced);
@@ -302,9 +303,9 @@ async function getPageContextErrorPageInit(pageContextInit, errNominalPage, page
     assert(pageContext.errorWhileRendering);
     return pageContext;
 }
-function getPageContextInitEnhancedSSR(pageContextInit, urlRewrite, httpRequestId) {
+async function getPageContextInitEnhancedSSR(pageContextInit, globalContext, urlRewrite, httpRequestId) {
     const { isClientSideNavigation, _urlHandler } = handlePageContextUrl(pageContextInit.urlOriginal);
-    const pageContextInitEnhanced = getPageContextInitEnhanced(pageContextInit, {
+    const pageContextInitEnhanced = await getPageContextInitEnhanced(pageContextInit, globalContext, {
         ssr: {
             urlRewrite,
             urlHandler: _urlHandler,
@@ -335,15 +336,16 @@ function assertIsNotViteRequest(urlPathname, urlOriginal) {
         return;
     assertUsage(false, `${pc.code('renderPage(pageContextInit)')} called with ${pc.code(`pageContextInit.urlOriginal===${JSON.stringify(urlOriginal)}`)} which is unexpected because the URL ${pc.bold(urlOriginal)} should have already been handled by the development middleware: make sure the ${pc.cyan('createDevMiddleware()')} middleware is executed *before* the ${pc.cyan('renderPage()')} middleware, see ${pc.underline('https://vike.dev/renderPage')}`);
 }
-function normalizeUrl(pageContextInit, httpRequestId) {
-    const { trailingSlash, disableUrlNormalization, baseServer } = getGlobalContext();
+async function normalizeUrl(pageContextInit, globalContext, httpRequestId) {
+    const { baseServer } = resolveBaseRuntime(globalContext);
+    const { trailingSlash, disableUrlNormalization } = globalContext.config;
     if (disableUrlNormalization)
         return null;
     const { urlOriginal } = pageContextInit;
     const { isPageContextRequest } = handlePageContextRequestUrl(urlOriginal);
     if (isPageContextRequest)
         return null;
-    const urlNormalized = normalizeUrlPathname(urlOriginal, trailingSlash, baseServer);
+    const urlNormalized = normalizeUrlPathname(urlOriginal, trailingSlash ?? false, baseServer);
     if (!urlNormalized)
         return null;
     logRuntimeInfo?.(`URL normalized from ${pc.cyan(urlOriginal)} to ${pc.cyan(urlNormalized)} (https://vike.dev/url-normalization)`, httpRequestId, 'info');
@@ -352,13 +354,13 @@ function normalizeUrl(pageContextInit, httpRequestId) {
     objectAssign(pageContextHttpResponse, { httpResponse });
     return pageContextHttpResponse;
 }
-function getPermanentRedirect(pageContextInit, httpRequestId) {
-    const globalContext = getGlobalContext();
-    const urlWithoutBase = removeBaseServer(pageContextInit.urlOriginal, globalContext.baseServer);
+async function getPermanentRedirect(pageContextInit, globalContext, httpRequestId) {
+    const { baseServer } = resolveBaseRuntime(globalContext);
+    const urlWithoutBase = removeBaseServer(pageContextInit.urlOriginal, baseServer);
     let origin = null;
     let urlTargetExternal = null;
     let urlTarget = modifyUrlPathname(urlWithoutBase, (urlPathname) => {
-        const urlTarget = resolveRedirects(globalContext.vikeConfig.global.config.redirects ?? [], urlPathname);
+        const urlTarget = resolveRedirects(globalContext.config.redirects ?? [], urlPathname);
         if (urlTarget === null)
             return null;
         if (!isUrl(urlTarget)) {
@@ -385,8 +387,9 @@ function getPermanentRedirect(pageContextInit, httpRequestId) {
         }
         if (normalize(urlTarget) === normalize(urlWithoutBase))
             return null;
+        const { baseServer } = resolveBaseRuntime(globalContext);
         if (!originChanged)
-            urlTarget = prependBase(urlTarget, globalContext.baseServer);
+            urlTarget = prependBase(urlTarget, baseServer);
         assert(urlTarget !== pageContextInit.urlOriginal);
     }
     logRuntimeInfo?.(`Permanent redirection defined by config.redirects (https://vike.dev/redirects)`, httpRequestId, 'info');
@@ -400,13 +403,12 @@ function normalize(url) {
 }
 async function handleAbortError(errAbort, pageContextsFromRewrite, pageContextInit, 
 // handleAbortError() creates a new pageContext object and we don't merge pageContextNominalPageInit to it: we only use some pageContextNominalPageInit information.
-pageContextNominalPageInit, httpRequestId, pageContextErrorPageInit) {
-    logAbortErrorHandled(errAbort, getGlobalContext().isProduction, pageContextNominalPageInit);
+pageContextNominalPageInit, httpRequestId, pageContextErrorPageInit, globalContext) {
+    logAbortErrorHandled(errAbort, globalContext.isProduction, pageContextNominalPageInit);
     const pageContextAbort = errAbort._pageContextAbort;
     let pageContextSerialized;
     if (pageContextNominalPageInit.isClientSideNavigation) {
         if (pageContextAbort.abortStatusCode) {
-            const globalContext = getGlobalContext();
             const errorPageId = getErrorPageId(globalContext.pageFilesAll, globalContext.pageConfigs);
             const abortCall = pageContextAbort._abortCall;
             assert(abortCall);
@@ -427,7 +429,7 @@ pageContextNominalPageInit, httpRequestId, pageContextErrorPageInit) {
         return { pageContextReturn };
     }
     if (pageContextAbort._urlRewrite) {
-        const pageContextReturn = await renderPageAlreadyPrepared(pageContextInit, httpRequestId, [
+        const pageContextReturn = await renderPageAlreadyPrepared(pageContextInit, globalContext, httpRequestId, [
             ...pageContextsFromRewrite,
             pageContextAbort
         ]);
@@ -450,8 +452,8 @@ pageContextNominalPageInit, httpRequestId, pageContextErrorPageInit) {
     assert(pageContextAbort.abortStatusCode);
     return { pageContextAbort };
 }
-function assertBaseUrl(pageContextInit) {
-    const { baseServer } = getGlobalContext();
+async function assertBaseUrl(pageContextInit, globalContext) {
+    const { baseServer } = resolveBaseRuntime(globalContext);
     const { urlOriginal } = pageContextInit;
     const { urlWithoutPageContextRequestSuffix } = handlePageContextRequestUrl(urlOriginal);
     const { hasBaseServer } = parseUrl(urlWithoutPageContextRequestSuffix, baseServer);

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

@@ -15,14 +15,13 @@ export * from '../../utils/projectInfo.js';
 export * from '../../utils/isArray.js';
 export * from '../../utils/isObject.js';
 export * from '../../utils/objectAssign.js';
+export * from '../../utils/objectAssignSafe.js';
 export * from '../../utils/objectReplace.js';
 export * from '../../utils/PromiseType.js';
 export * from '../../utils/compareString.js';
 export * from '../../utils/isObjectWithKeys.js';
 export * from '../../utils/stringifyStringArray.js';
 export * from '../../utils/unique.js';
-export * from '../../utils/filesystemPathHandling.js';
-export * from '../../utils/getOutDirs.js';
 export * from '../../utils/capitalizeFirstLetter.js';
 export * from '../../utils/debugGlob.js';
 export * from '../../utils/isSameErrorMessage.js';
@@ -41,7 +40,7 @@ export * from '../../utils/objectEntries.js';
 export * from '../../utils/objectFromEntries.js';
 export * from '../../utils/getFileExtension.js';
 export * from '../../utils/assertSetup.js';
-export * from '../../utils/path-shim.js';
+export * from '../../utils/path.js';
 export * from '../../utils/isHtml.js';
 export * from '../../utils/warnIfErrorIsNotObject.js';
 export * from '../../utils/stripAnsi.js';
@@ -56,3 +55,4 @@ export * from '../../utils/isVikeReactApp.js';
 export * from '../../utils/getPropAccessNotation.js';
 export * from '../../utils/PROJECT_VERSION.js';
 export * from '../../utils/genPromise.js';
+export * from '../../utils/makePublicCopy.js';

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

@@ -19,14 +19,13 @@ export * from '../../utils/projectInfo.js';
 export * from '../../utils/isArray.js';
 export * from '../../utils/isObject.js';
 export * from '../../utils/objectAssign.js';
+export * from '../../utils/objectAssignSafe.js';
 export * from '../../utils/objectReplace.js';
 export * from '../../utils/PromiseType.js';
 export * from '../../utils/compareString.js';
 export * from '../../utils/isObjectWithKeys.js';
 export * from '../../utils/stringifyStringArray.js';
 export * from '../../utils/unique.js';
-export * from '../../utils/filesystemPathHandling.js';
-export * from '../../utils/getOutDirs.js';
 export * from '../../utils/capitalizeFirstLetter.js';
 export * from '../../utils/debugGlob.js';
 export * from '../../utils/isSameErrorMessage.js';
@@ -45,7 +44,7 @@ export * from '../../utils/objectEntries.js';
 export * from '../../utils/objectFromEntries.js';
 export * from '../../utils/getFileExtension.js';
 export * from '../../utils/assertSetup.js';
-export * from '../../utils/path-shim.js';
+export * from '../../utils/path.js';
 export * from '../../utils/isHtml.js';
 export * from '../../utils/warnIfErrorIsNotObject.js';
 export * from '../../utils/stripAnsi.js';
@@ -60,3 +59,4 @@ export * from '../../utils/isVikeReactApp.js';
 export * from '../../utils/getPropAccessNotation.js';
 export * from '../../utils/PROJECT_VERSION.js';
 export * from '../../utils/genPromise.js';
+export * from '../../utils/makePublicCopy.js';

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

@@ -1,13 +1,15 @@
 export { createDevMiddleware };
 import { createServer } from 'vite';
 import { prepareViteApiCall } from '../api/prepareViteApiCall.js';
+import { setGlobalContext_isProduction } from '../runtime/globalContext.js';
 /*
  * Create server middleware for development with HMR and lazy-transpiling.
  *
  * https://vike.dev/createDevMiddleware
  */
 async function createDevMiddleware(options = {}) {
-    const viteConfig = {
+    setGlobalContext_isProduction(false);
+    const viteConfigFromOptions = {
         ...options.viteConfig,
         server: {
             ...options.viteConfig?.server,
@@ -15,8 +17,8 @@ async function createDevMiddleware(options = {}) {
         }
     };
     if (options.root)
-        viteConfig.root = options.root;
-    const { viteConfigEnhanced } = await prepareViteApiCall(viteConfig, 'dev');
+        viteConfigFromOptions.root = options.root;
+    const { viteConfigEnhanced } = await prepareViteApiCall(viteConfigFromOptions, 'dev');
     const server = await createServer(viteConfigEnhanced);
     const devMiddleware = server.middlewares;
     return { devMiddleware, viteServer: server, viteConfig: server.config };

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

@@ -1,11 +1,15 @@
 export { resolveBase };
+export { resolveBaseRuntime };
 export { resolveBaseFromResolvedConfig };
 import type { ResolvedConfig } from 'vite';
+import type { GlobalContext } from '../runtime/globalContext.js';
 declare function resolveBaseFromResolvedConfig(baseServer: string | null, baseAssets: string | null, config: ResolvedConfig): {
     baseServer: string;
     baseAssets: string;
 };
-declare function resolveBase(baseViteOriginal: string | null, baseServerUnresolved: string | null, baseAssetsUnresolved: string | null): {
+type BaseUrlsResolved = {
     baseServer: string;
     baseAssets: string;
 };
+declare function resolveBaseRuntime(globalContext: GlobalContext): BaseUrlsResolved;
+declare function resolveBase(baseViteOriginal: string | null, baseServerUnresolved: string | null, baseAssetsUnresolved: string | null): BaseUrlsResolved;

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

@@ -1,4 +1,5 @@
 export { resolveBase };
+export { resolveBaseRuntime };
 export { resolveBaseFromResolvedConfig };
 import { assert, assertUsage, isBaseServer, isBaseAssets } from './utils.js';
 import pc from '@brillout/picocolors';
@@ -7,6 +8,12 @@ function resolveBaseFromResolvedConfig(baseServer, baseAssets, config) {
     assert(baseViteOriginal === null || typeof baseViteOriginal == 'string');
     return resolveBase(baseViteOriginal, baseServer, baseAssets);
 }
+function resolveBaseRuntime(globalContext) {
+    const baseViteOriginal = globalContext.viteConfigRuntime._baseViteOriginal;
+    const baseServerUnresolved = globalContext.config.baseServer ?? null;
+    const baseAssetsUnresolved = globalContext.config.baseAssets ?? null;
+    return resolveBase(baseViteOriginal, baseServerUnresolved, baseAssetsUnresolved);
+}
 function resolveBase(baseViteOriginal, baseServerUnresolved, baseAssetsUnresolved) {
     if (baseViteOriginal === '/__UNSET__')
         baseViteOriginal = null;

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

@@ -0,0 +1,13 @@
+export { getPageConfigsRuntime };
+export { getAllPageIds };
+import type { PageFile } from './getPageFiles.js';
+import { type ConfigUserFriendly } from './page-configs/getPageConfigUserFriendly.js';
+import type { PageConfigGlobalRuntime, PageConfigRuntime } from './page-configs/PageConfig.js';
+declare function getPageConfigsRuntime(virtualFileExports: unknown): {
+    pageFilesAll: PageFile[];
+    allPageIds: string[];
+    pageConfigs: PageConfigRuntime[];
+    pageConfigGlobal: PageConfigGlobalRuntime;
+    globalConfig: ConfigUserFriendly;
+};
+declare function getAllPageIds(pageFilesAll: PageFile[], pageConfigs: PageConfigRuntime[]): string[];

package/dist/esm/shared/getPageConfigsRuntime.js

@@ -0,0 +1,18 @@
+export { getPageConfigsRuntime };
+export { getAllPageIds };
+import { parseGlobResults } from './getPageFiles/parseGlobResults.js';
+import { getPageConfigUserFriendlyNew } from './page-configs/getPageConfigUserFriendly.js';
+import { unique } from './utils.js';
+function getPageConfigsRuntime(virtualFileExports) {
+    const { pageFilesAll, pageConfigs, pageConfigGlobal } = parseGlobResults(virtualFileExports);
+    const allPageIds = getAllPageIds(pageFilesAll, pageConfigs);
+    // TODO/now: re-use this call, instead of calling it twice
+    const globalConfig = getPageConfigUserFriendlyNew(pageConfigGlobal);
+    return { pageFilesAll, allPageIds, pageConfigs, pageConfigGlobal, globalConfig };
+}
+function getAllPageIds(pageFilesAll, pageConfigs) {
+    const fileIds = pageFilesAll.filter(({ isDefaultPageFile }) => !isDefaultPageFile).map(({ pageId }) => pageId);
+    const allPageIds = unique(fileIds);
+    const allPageIds2 = pageConfigs.map((p) => p.pageId);
+    return [...allPageIds, ...allPageIds2];
+}

package/dist/esm/shared/getPageContextUrlComputed.js

@@ -37,24 +37,29 @@ function getUrlParsed(pageContext) {
     //  6. The value of pageContext.urlPathname is now '/login': the pathname of `pageContext.urlLogical`. (While pageContext.urlOriginal is still '/fr-FR/admin'.)
     // Reproduction: https://github.com/vikejs/vike/discussions/1436#discussioncomment-8142023
     // Determine logical URL
+    // TODO/soon: revert https://github.com/vikejs/vike/issues/2138#issuecomment-2631713411
+    const assertUrlResolved = (src) => assert(urlResolved && typeof urlResolved === 'string', { src, urlResolved });
     let urlResolved;
     let baseToBeRemoved;
     if (pageContext.urlLogical) {
         // Set by onBeforeRoute()
         urlResolved = pageContext.urlLogical;
         baseToBeRemoved = false;
+        assertUrlResolved(1);
     }
     else if (pageContext._urlRewrite) {
         // Set by `throw render()`
         urlResolved = pageContext._urlRewrite;
         baseToBeRemoved = false;
+        assertUrlResolved(2);
     }
     else {
         // Set by renderPage()
         urlResolved = pageContext.urlOriginal;
         baseToBeRemoved = true;
+        assertUrlResolved(3);
     }
-    assert(urlResolved && typeof urlResolved === 'string');
+    assertUrlResolved(4);
     // Remove .pageContext.json
     let urlHandler = pageContext._urlHandler;
     if (!urlHandler)

package/dist/esm/shared/getPageFiles/fileTypes.js

@@ -2,7 +2,7 @@
 export { fileTypes };
 export { isValidFileType };
 export { determineFileType };
-import { assert, assertPosixPath } from '../utils.js';
+import { assert } from '../utils.js';
 import { isScriptFile } from '../../utils/isScriptFile.js';
 const fileTypes = [
     '.page',
@@ -18,7 +18,6 @@ function isValidFileType(filePath) {
     return ['.js', '.mjs', '.cjs', '.css'].some((ext) => filePath.endsWith(ext));
 }
 function determineFileType(filePath) {
-    assertPosixPath(filePath);
     {
         const isCSS = filePath.endsWith('.css');
         if (isCSS) {

package/dist/esm/shared/getPageFiles/getAllPageIdFiles.js

@@ -2,7 +2,6 @@
 export { getPageFilesClientSide };
 export { getPageFilesServerSide };
 import { assert, assertUsage, isNotNullish } from '../utils.js';
-import { assertPageFilePath } from '../assertPageFilePath.js';
 function getPageFilesClientSide(pageFilesAll, pageId) {
     return determine(pageFilesAll, pageId, true);
 }
@@ -86,8 +85,6 @@ function getPageFilesSorter(envIsClient, pageId) {
     };
 }
 function getPathDistance(pathA, pathB) {
-    assertPageFilePath(pathA);
-    assertPageFilePath(pathB);
     // Index of first different character
     let idx = 0;
     for (; idx < pathA.length && idx < pathB.length; idx++) {

package/dist/esm/shared/getPageFiles/getPageFileObject.js

@@ -1,7 +1,6 @@
 // TODO/v1-release: remove
 export { getPageFileObject };
 import { determinePageIdOld } from '../determinePageIdOld.js';
-import { assertPageFilePath } from '../assertPageFilePath.js';
 import { isErrorPageId } from '../error-page.js';
 import { assert, slice } from '../utils.js';
 import { determineFileType } from './fileTypes.js';
@@ -36,19 +35,15 @@ function getPageFileObject(filePath) {
     return pageFile;
 }
 function isDefaultFilePath(filePath) {
-    assertPageFilePath(filePath);
     if (isErrorPageId(filePath, false)) {
         return false;
     }
     return filePath.includes('/_default');
 }
 function isRendererFilePath(filePath) {
-    assertPageFilePath(filePath);
     return filePath.includes('/renderer/');
 }
 function isAncestorDefaultPage(pageId, defaultPageFilePath) {
-    assertPageFilePath(pageId);
-    assertPageFilePath(defaultPageFilePath);
     assert(!pageId.endsWith('/'));
     assert(!defaultPageFilePath.endsWith('/'));
     assert(isDefaultFilePath(defaultPageFilePath));

package/dist/esm/shared/getPageFiles/parseGlobResults.d.ts

@@ -2,7 +2,7 @@ export { parseGlobResults };
 import { type PageFile } from './getPageFileObject.js';
 import type { PageConfigRuntime, PageConfigGlobalRuntime } from '../page-configs/PageConfig.js';
 declare function parseGlobResults(pageFilesExports: unknown): {
-    pageFiles: PageFile[];
+    pageFilesAll: PageFile[];
     pageConfigs: PageConfigRuntime[];
     pageConfigGlobal: PageConfigGlobalRuntime;
 };

package/dist/esm/shared/getPageFiles/parseGlobResults.js

@@ -5,6 +5,7 @@ import { assertExportValues } from './assert_exports_old_design.js';
 import { getPageFileObject } from './getPageFileObject.js';
 import { fileTypes } from './fileTypes.js';
 import { parsePageConfigs } from '../page-configs/serialize/parsePageConfigs.js';
+// TODO/now: rename
 function parseGlobResults(pageFilesExports) {
     assert(hasProp(pageFilesExports, 'pageFilesLazy', 'object'));
     assert(hasProp(pageFilesExports, 'pageFilesEager', 'object'));
@@ -60,11 +61,11 @@ function parseGlobResults(pageFilesExports) {
     pageFilesExports.pageFilesList.forEach((filePath) => {
         pageFilesMap[filePath] = pageFilesMap[filePath] ?? getPageFileObject(filePath);
     });
-    const pageFiles = Object.values(pageFilesMap);
-    pageFiles.forEach(({ filePath }) => {
+    const pageFilesAll = Object.values(pageFilesMap);
+    pageFilesAll.forEach(({ filePath }) => {
         assert(!filePath.includes('\\'));
     });
-    return { pageFiles, pageConfigs, pageConfigGlobal };
+    return { pageFilesAll, pageConfigs, pageConfigGlobal };
 }
 function parseGlobResult(globObject) {
     const ret = [];

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

@@ -2,4 +2,3 @@ export type { PageFile } from './getPageFiles/getPageFileObject.js';
 export type { ExportsAll, PageConfigUserFriendly } from './page-configs/getPageConfigUserFriendly.js';
 export { getPageFilesClientSide } from './getPageFiles/getAllPageIdFiles.js';
 export { getPageFilesServerSide } from './getPageFiles/getAllPageIdFiles.js';
-export { getPageConfigUserFriendly } from './page-configs/getPageConfigUserFriendly.js';

package/dist/esm/shared/getPageFiles.js

@@ -1,3 +1,2 @@
 export { getPageFilesClientSide } from './getPageFiles/getAllPageIdFiles.js';
 export { getPageFilesServerSide } from './getPageFiles/getAllPageIdFiles.js';
-export { getPageConfigUserFriendly } from './page-configs/getPageConfigUserFriendly.js';

package/dist/esm/shared/page-configs/Config.d.ts

@@ -37,7 +37,7 @@ import type { PrefetchSetting, PrefetchStaticAssets } from '../../client/client-
 import type { ConfigDefinition } from '../../node/plugin/plugins/importUserCode/v1-design/getVikeConfig/configDefinitionsBuiltIn.js';
 import type { DocumentHtml } from '../../node/runtime/html/renderHtml.js';
 import type { InjectFilterEntry } from '../../types/index.js';
-import type { VikeVitePluginOptions } from '../../node/plugin/plugins/importUserCode/v1-design/getVikeConfig.js';
+import type { VikeVitePluginOptions } from '../../node/plugin/index.js';
 import type { Vike, VikePackages } from '../VikeNamespace.js';
 import type { HooksTimeoutProvidedByUser } from '../hooks/getHook.js';
 import type { PageContextClient, PageContextServer } from '../types.js';
@@ -246,11 +246,55 @@ type ConfigBuiltIn = {
      */
     guard?: GuardAsync | GuardSync | ImportString;
     /**
-     * Whether to pre-render the page(s).
+     * Pre-render page(s).
      *
      * https://vike.dev/pre-rendering
+     * https://vike.dev/prerender
+     *
+     * @default false
      */
-    prerender?: boolean | ImportString;
+    prerender?: boolean | ImportString | {
+        /**
+         * Allow only some of your pages to be pre-rendered.
+         *
+         * This setting doesn't affect the pre-rendering process: it merely suppresses the warnings when some of your pages cannot be pre-rendered.
+         *
+         * https://vike.dev/prerender#partial
+         *
+         * @default false
+         */
+        partial?: boolean;
+        /**
+         * Don't create a new directory for each HTML file.
+         *
+         * For example, generate `dist/client/about.html` instead of `dist/client/about/index.html`.
+         *
+         * https://vike.dev/prerender#noextradir
+         *
+         * @default false
+         */
+        noExtraDir?: boolean;
+        /**
+         * Number of concurrent pre-render jobs.
+         *
+         * Set to `false` to disable concurrency.
+         *
+         * https://vike.dev/prerender#parallel
+         *
+         * @default os.cpus().length
+         */
+        parallel?: boolean | number;
+        /**
+         * Disable the automatic initiation of the pre-rendering process when running `$ vike build`.
+         *
+         * Use this if you want to programmatically initiate the pre-rendering process instead.
+         *
+         * https://vike.dev/prerender#disableautorun
+         *
+         * @default false
+         */
+        disableAutoRun?: boolean;
+    };
     /**
      * Install Vike extensions.
      *
@@ -358,6 +402,38 @@ type ConfigBuiltIn = {
      * https://vike.dev/redirects
      */
     redirects?: Record<string, string>;
+    /** Whether URLs should end with a trailing slash.
+     *
+     * https://vike.dev/url-normalization
+     *
+     * @default false
+     */
+    trailingSlash?: boolean;
+    /** Disable automatic URL normalization.
+     *
+     * https://vike.dev/url-normalization
+     *
+     * @default false
+     */
+    disableUrlNormalization?: boolean;
+    /** @deprecated It's now `true` by default. You can remove this option. */
+    includeAssetsImportedByServer?: boolean;
+    /** @deprecated See https://vike.dev/disableAutoFullBuild */
+    disableAutoFullBuild?: boolean | 'prerender';
+    /** Use Vite Environment API to orchestrate the build process.
+     * @experimental
+     */
+    viteEnvironmentAPI?: boolean;
+    /** The Base URL of your server.
+     *
+     * https://vike.dev/base-url
+     */
+    baseServer?: string;
+    /** The Base URL of your static assets.
+     *
+     * https://vike.dev/base-url
+     */
+    baseAssets?: string;
     /**
      * @experimental DON'T USE: the API *will* have breaking changes upon any minor version release.
      *
@@ -403,10 +479,14 @@ type ConfigBuiltIn = {
      * https://vike.dev/keepScrollPosition
      */
     keepScrollPosition?: KeepScrollPosition;
+    /** @experimental */
+    middleware?: Function;
 };
 type ConfigBuiltInResolved = {
     passToClient?: string[][];
     redirects?: Record<string, string>[];
+    prerender?: Exclude<Config['prerender'], ImportString | undefined>[];
+    middleware?: Function[];
 };
 type ConfigMeta = Record<string, ConfigDefinition>;
 type ImportString = `import:${string}`;