vike 0.4.172 → 0.4.173

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVikeConfig/configDefinitionsBuiltIn.js

@@ -1,6 +1,7 @@
 export { configDefinitionsBuiltIn };
 export { configDefinitionsBuiltInGlobal };
-import { assert } from '../../../../utils.js';
+import { assert, assertUsage } from '../../../../utils.js';
+import { getConfigDefinedAt } from '../../../../../../shared/page-configs/getConfigDefinedAt.js';
 const configDefinitionsBuiltIn = {
     onRenderHtml: {
         env: { server: true }
@@ -54,6 +55,9 @@ const configDefinitionsBuiltIn = {
         // We could make it { client: false } but we don't yet because of some legacy V0.4 design code
         env: { server: true, client: true, config: true, eager: true }
     },
+    clientHooks: {
+        env: { config: true }
+    },
     prerender: {
         env: { config: true }
     },
@@ -69,11 +73,22 @@ const configDefinitionsBuiltIn = {
     meta: {
         env: { config: true }
     },
-    isClientSideRenderable: {
+    clientEntryLoaded: {
         env: { server: true, client: true, eager: true },
-        _computed: (configValueSources) => isConfigSet(configValueSources, 'onRenderClient') &&
-            isConfigSet(configValueSources, 'Page') &&
-            !!getConfigEnv(configValueSources, 'Page')?.client
+        _computed: (configValueSources) => {
+            {
+                const source = getConfigValueSource(configValueSources, 'clientHooks');
+                if (source && source.value !== null) {
+                    const { value } = source;
+                    const definedAt = getConfigDefinedAt('Config', 'clientHooks', source.definedAtFilePath);
+                    assertUsage(typeof value === 'boolean', `${definedAt} should be a boolean`);
+                    return value;
+                }
+            }
+            return (isConfigSet(configValueSources, 'onRenderClient') &&
+                isConfigSet(configValueSources, 'Page') &&
+                !!getConfigEnv(configValueSources, 'Page')?.client);
+        }
     },
     onBeforeRenderEnv: {
         env: { client: true },
@@ -91,6 +106,9 @@ const configDefinitionsBuiltIn = {
     },
     name: {
         env: { config: true }
+    },
+    require: {
+        env: { config: true }
     }
 };
 const configDefinitionsBuiltInGlobal = {

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVikeConfig/crawlPlusFiles.d.ts

@@ -1,4 +1,4 @@
 export { crawlPlusFiles };
-declare function crawlPlusFiles(userRootDir: string, outDirAbsoluteFilesystem: string, isDev: boolean): Promise<{
+declare function crawlPlusFiles(userRootDir: string, outDirAbsoluteFilesystem: string, isDev: boolean, crawlWithGit: null | boolean): Promise<{
     filePathAbsoluteUserRootDir: string;
 }[]>;

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVikeConfig/crawlPlusFiles.js

@@ -1,5 +1,5 @@
 export { crawlPlusFiles };
-import { assertPosixPath, assert, toPosixPath, assertWarning, scriptFileExtensionList, scriptFileExtensions, humanizeTime, assertIsSingleModuleInstance, assertIsNotProductionRuntime, isVersionOrAbove } from '../../../../utils.js';
+import { assertPosixPath, assert, assertWarning, scriptFileExtensionList, scriptFileExtensions, humanizeTime, assertIsSingleModuleInstance, assertIsNotProductionRuntime, isVersionOrAbove } from '../../../../utils.js';
 import path from 'path';
 import glob from 'fast-glob';
 import { exec } from 'child_process';
@@ -10,7 +10,7 @@ const execA = promisify(exec);
 assertIsNotProductionRuntime();
 assertIsSingleModuleInstance('crawlPlusFiles.ts');
 let gitIsNotUsable = false;
-async function crawlPlusFiles(userRootDir, outDirAbsoluteFilesystem, isDev) {
+async function crawlPlusFiles(userRootDir, outDirAbsoluteFilesystem, isDev, crawlWithGit) {
     assertPosixPath(userRootDir);
     assertPosixPath(outDirAbsoluteFilesystem);
     let outDirRelativeFromUserRootDir = path.posix.relative(userRootDir, outDirAbsoluteFilesystem);
@@ -26,8 +26,9 @@ async function crawlPlusFiles(userRootDir, outDirAbsoluteFilesystem, isDev) {
             //
             !outDirRelativeFromUserRootDir.startsWith('../')));
     const timeBefore = new Date().getTime();
+    // Crawl
     let files = [];
-    const res = await gitLsFiles(userRootDir, outDirRelativeFromUserRootDir);
+    const res = crawlWithGit !== false && (await gitLsFiles(userRootDir, outDirRelativeFromUserRootDir));
     if (res &&
         // Fallback to fast-glob for users that dynamically generate plus files. (Assuming all (generetad) plus files to be skipped because users usually included them in `.gitignore`.)
         res.length > 0) {
@@ -36,7 +37,9 @@ async function crawlPlusFiles(userRootDir, outDirAbsoluteFilesystem, isDev) {
     else {
         files = await fastGlob(userRootDir, outDirRelativeFromUserRootDir);
     }
+    // Filter build files
     files = files.filter((file) => !isTemporaryBuildFile(file));
+    // Check performance
     {
         const timeAfter = new Date().getTime();
         const timeSpent = timeAfter - timeBefore;
@@ -48,10 +51,12 @@ async function crawlPlusFiles(userRootDir, outDirAbsoluteFilesystem, isDev) {
             });
         }
     }
-    const plusFiles = files.map((p) => {
-        p = toPosixPath(p);
-        assert(!p.startsWith(userRootDir));
-        const filePathAbsoluteUserRootDir = path.posix.join('/', p);
+    // Normalize
+    const plusFiles = files.map((filePath) => {
+        // Both `$ git-ls files` and fast-glob return posix paths
+        assertPosixPath(filePath);
+        assert(!filePath.startsWith(userRootDir));
+        const filePathAbsoluteUserRootDir = path.posix.join('/', filePath);
         return { filePathAbsoluteUserRootDir };
     });
     return plusFiles;
@@ -60,10 +65,17 @@ async function crawlPlusFiles(userRootDir, outDirAbsoluteFilesystem, isDev) {
 async function gitLsFiles(userRootDir, outDirRelativeFromUserRootDir) {
     if (gitIsNotUsable)
         return null;
+    // Preserve UTF-8 file paths.
+    // https://github.com/vikejs/vike/issues/1658
+    // https://stackoverflow.com/questions/22827239/how-to-make-git-properly-display-utf-8-encoded-pathnames-in-the-console-window/22828826#22828826
+    // https://stackoverflow.com/questions/15884180/how-do-i-override-git-configuration-options-by-command-line-parameters/15884261#15884261
+    const preserveUTF8 = '-c core.quotepath=off';
     const ignoreAsPatterns = getIgnoreAsPatterns(outDirRelativeFromUserRootDir);
     const ignoreAsFilterFn = getIgnoreAsFilterFn(outDirRelativeFromUserRootDir);
     const cmd = [
-        'git ls-files',
+        'git',
+        preserveUTF8,
+        'ls-files',
         ...scriptFileExtensionList.map((ext) => `"**/+*.${ext}"`),
         ...ignoreAsPatterns.map((pattern) => `--exclude="${pattern}"`),
         // --others lists untracked files only (but using .gitignore because --exclude-standard)

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVikeConfig.d.ts

@@ -3,12 +3,15 @@ export { reloadVikeConfig };
 export { vikeConfigDependencies };
 export { isVikeConfigFile };
 export { isV1Design };
+export { getConfigValueInterfaceFile };
 export type { VikeConfigObject };
 export type { InterfaceValueFile };
+export type { InterfaceFile };
 import type { PageConfigGlobalBuildTime, PageConfigBuildTime } from '../../../../../shared/page-configs/PageConfig.js';
 import { type LocationId } from './getVikeConfig/filesystemRouting.js';
 import type { ResolvedConfig } from 'vite';
 import type { FilePathResolved } from '../../../../../shared/page-configs/FilePath.js';
+type InterfaceFile = InterfaceConfigFile | InterfaceValueFile;
 type InterfaceFileCommons = {
     locationId: LocationId;
     filePath: FilePathResolved;
@@ -16,6 +19,12 @@ type InterfaceFileCommons = {
         configValue?: unknown;
     }>;
 };
+type InterfaceConfigFile = InterfaceFileCommons & {
+    isConfigFile: true;
+    isValueFile: false;
+    extendsFilePaths: string[];
+    isConfigExtend: boolean;
+};
 type InterfaceValueFile = InterfaceFileCommons & {
     isConfigFile: false;
     isValueFile: true;
@@ -29,6 +38,10 @@ type VikeConfigObject = {
 };
 declare const vikeConfigDependencies: Set<string>;
 declare function reloadVikeConfig(userRootDir: string, outDirRoot: string): void;
-declare function getVikeConfig(config: ResolvedConfig, isDev: boolean, tolerateInvalidConfig?: true): Promise<VikeConfigObject>;
+declare function getVikeConfig(config: ResolvedConfig, isDev: boolean, { crawlWithGit, tolerateInvalidConfig }?: {
+    crawlWithGit?: null | boolean;
+    tolerateInvalidConfig?: true;
+}): Promise<VikeConfigObject>;
 declare function isV1Design(config: ResolvedConfig, isDev: boolean): Promise<boolean>;
 declare function isVikeConfigFile(filePath: string): boolean;
+declare function getConfigValueInterfaceFile(interfaceFile: InterfaceFile, configName: string): unknown;

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVikeConfig.js

@@ -3,6 +3,7 @@ export { reloadVikeConfig };
 export { vikeConfigDependencies };
 export { isVikeConfigFile };
 export { isV1Design };
+export { getConfigValueInterfaceFile };
 import { assertPosixPath, assert, isObject, assertUsage, assertWarning, objectEntries, hasProp, arrayIncludes, assertIsNotProductionRuntime, getMostSimilar, joinEnglish, lowerFirst, getOutDirs, assertKeys, objectKeys, objectFromEntries, makeFirst, isNpmPackageImport, reverse } from '../../../utils.js';
 import path from 'path';
 import { configDefinitionsBuiltIn, configDefinitionsBuiltInGlobal } from './getVikeConfig/configDefinitionsBuiltIn.js';
@@ -20,6 +21,8 @@ import { loadConfigFile, loadImportedFile, loadValueFile } from './getVikeConfig
 import { clearFilesEnvMap, resolvePointerImportOfConfig } from './getVikeConfig/resolvePointerImport.js';
 import { getFilePathResolved } from '../../../shared/getFilePath.js';
 import { getConfigValueBuildTime } from '../../../../../shared/page-configs/getConfigValueBuildTime.js';
+import { getConfigVike } from '../../../../shared/getConfigVike.js';
+import { assertExtensionsPeerDependencies, assertExtensionsConventions } from './assertExtensions.js';
 assertIsNotProductionRuntime();
 let devServerIsCorrupt = false;
 let wasConfigInvalid = null;
@@ -62,11 +65,12 @@ async function handleReloadSideEffects() {
         }
     }
 }
-async function getVikeConfig(config, isDev, tolerateInvalidConfig) {
+async function getVikeConfig(config, isDev, { crawlWithGit, tolerateInvalidConfig } = {}) {
     const { outDirRoot } = getOutDirs(config);
     const userRootDir = config.root;
     if (!vikeConfigPromise) {
-        vikeConfigPromise = loadVikeConfig_withErrorHandling(userRootDir, outDirRoot, isDev, tolerateInvalidConfig);
+        const crawlWithGit_ = crawlWithGit !== undefined ? crawlWithGit : (await getConfigVike(config)).crawl.git;
+        vikeConfigPromise = loadVikeConfig_withErrorHandling(userRootDir, outDirRoot, isDev, crawlWithGit_, tolerateInvalidConfig);
     }
     return await vikeConfigPromise;
 }
@@ -76,8 +80,8 @@ async function isV1Design(config, isDev) {
     const isV1Design = pageConfigs.length > 0;
     return isV1Design;
 }
-async function loadInterfaceFiles(userRootDir, outDirRoot, isDev) {
-    const plusFiles = await findPlusFiles(userRootDir, outDirRoot, isDev);
+async function loadInterfaceFiles(userRootDir, outDirRoot, isDev, crawlWithGit) {
+    const plusFiles = await findPlusFiles(userRootDir, outDirRoot, isDev, crawlWithGit);
     const configFiles = [];
     const valueFiles = [];
     plusFiles.forEach((f) => {
@@ -118,29 +122,7 @@ async function loadInterfaceFiles(userRootDir, outDirRoot, isDev) {
                 ```
                 */
                 const interfaceFile = getInterfaceFileFromConfigFile(extendsConfig, true, locationId);
-                {
-                    const alreadyMigrated = [
-                        'vike-react',
-                        'vike-react-query',
-                        'vike-react-zustand',
-                        'vike-vue',
-                        'vike-pinia',
-                        'vike-solid'
-                    ];
-                    assert(extendsConfig.filePath.importPathAbsolute);
-                    const extensionName = extendsConfig.filePath.importPathAbsolute.split('/')[0];
-                    const warnMsg = alreadyMigrated.includes(extensionName)
-                        ? `You're using a deprecated version of the Vike extension ${extensionName}, update ${extensionName} to its latest version.`
-                        : `The config of the Vike extension ${extensionName} should set a ${pc.cyan('name')} value`;
-                    const isNameDefined = interfaceFile.fileExportsByConfigName.name?.configValue;
-                    if (alreadyMigrated) {
-                        // Eventually always make it a assertUsage()
-                        assertWarning(isNameDefined, warnMsg, { onlyOnce: true });
-                    }
-                    else {
-                        assertUsage(isNameDefined, warnMsg);
-                    }
-                }
+                assertExtensionsConventions(interfaceFile);
                 interfaceFilesByLocationId[locationId].push(interfaceFile);
             });
         }),
@@ -208,12 +190,12 @@ function assertAllConfigsAreKnown(interfaceFilesByLocationId) {
         });
     });
 }
-async function loadVikeConfig_withErrorHandling(userRootDir, outDirRoot, isDev, tolerateInvalidConfig) {
+async function loadVikeConfig_withErrorHandling(userRootDir, outDirRoot, isDev, crawlWithGit, tolerateInvalidConfig) {
     let hasError = false;
     let ret;
     let err;
     try {
-        ret = await loadVikeConfig(userRootDir, outDirRoot, isDev);
+        ret = await loadVikeConfig(userRootDir, outDirRoot, isDev, crawlWithGit);
     }
     catch (err_) {
         hasError = true;
@@ -250,17 +232,19 @@ async function loadVikeConfig_withErrorHandling(userRootDir, outDirRoot, isDev,
         }
     }
 }
-async function loadVikeConfig(userRootDir, outDirRoot, isDev) {
-    const interfaceFilesByLocationId = await loadInterfaceFiles(userRootDir, outDirRoot, isDev);
+async function loadVikeConfig(userRootDir, outDirRoot, isDev, crawlWithGit) {
+    const interfaceFilesByLocationId = await loadInterfaceFiles(userRootDir, outDirRoot, isDev, crawlWithGit);
     const importedFilesLoaded = {};
     const { globalVikeConfig, pageConfigGlobal } = await getGlobalConfigs(interfaceFilesByLocationId, userRootDir, importedFilesLoaded);
     const pageConfigs = await Promise.all(objectEntries(interfaceFilesByLocationId)
         .filter(([_pageId, interfaceFiles]) => isDefiningPage(interfaceFiles))
         .map(async ([locationId]) => {
         const interfaceFilesRelevant = getInterfaceFilesRelevant(interfaceFilesByLocationId, locationId);
+        const interfaceFilesRelevantList = Object.values(interfaceFilesByLocationId).flat(1);
+        assertExtensionsPeerDependencies(interfaceFilesRelevantList);
         const configDefinitions = getConfigDefinitions(interfaceFilesRelevant);
         // Load value files of custom config-only configs
-        await Promise.all(getInterfaceFileList(interfaceFilesRelevant).map(async (interfaceFile) => {
+        await Promise.all(interfaceFilesRelevantList.map(async (interfaceFile) => {
             if (!interfaceFile.isValueFile)
                 return;
             const { configName } = interfaceFile;
@@ -348,13 +332,6 @@ function getInterfaceFilesRelevant(interfaceFilesByLocationId, locationIdPage) {
         .sort(([locationId1], [locationId2]) => sortAfterInheritanceOrder(locationId1, locationId2, locationIdPage)));
     return interfaceFilesRelevant;
 }
-function getInterfaceFileList(interfaceFilesByLocationId) {
-    const interfaceFiles = [];
-    Object.values(interfaceFilesByLocationId).forEach((interfaceFiles_) => {
-        interfaceFiles.push(...interfaceFiles_);
-    });
-    return interfaceFiles;
-}
 async function getGlobalConfigs(interfaceFilesByLocationId, userRootDir, importedFilesLoaded) {
     const locationIds = objectKeys(interfaceFilesByLocationId);
     const interfaceFilesGlobal = objectFromEntries(objectEntries(interfaceFilesByLocationId).filter(([locationId]) => {
@@ -765,8 +742,8 @@ function getComputed(configValueSources, configDefinitions) {
     });
     return configValuesComputed;
 }
-async function findPlusFiles(userRootDir, outDirRoot, isDev) {
-    const files = await crawlPlusFiles(userRootDir, outDirRoot, isDev);
+async function findPlusFiles(userRootDir, outDirRoot, isDev, crawlWithGit) {
+    const files = await crawlPlusFiles(userRootDir, outDirRoot, isDev, crawlWithGit);
     const plusFiles = files.map(({ filePathAbsoluteUserRootDir }) => getFilePathResolved({ filePathAbsoluteUserRootDir, userRootDir }));
     return plusFiles;
 }
@@ -967,3 +944,6 @@ function sortConfigValueSources(configValueSources, locationIdPage) {
         // Sort after the filesystem inheritance of the config value
         .sort(([, [source1]], [, [source2]]) => reverse(sortAfterInheritanceOrder(source1.locationId, source2.locationId, locationIdPage))));
 }
+function getConfigValueInterfaceFile(interfaceFile, configName) {
+    return interfaceFile.fileExportsByConfigName[configName]?.configValue;
+}

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVirtualFilePageConfigValuesAll.js

@@ -19,7 +19,7 @@ async function getVirtualFilePageConfigValuesAll(id, isDev, config) {
     }
     */
     const { pageId, isForClientSide } = result;
-    const { pageConfigs } = await getVikeConfig(config, isDev, true);
+    const { pageConfigs } = await getVikeConfig(config, isDev, { tolerateInvalidConfig: true });
     const pageConfig = pageConfigs.find((pageConfig) => pageConfig.pageId === pageId);
     assert(pageConfig);
     const configVike = await getConfigVike(config);

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVirtualFilePageConfigs.js

@@ -5,7 +5,7 @@ import { getVikeConfig } from './getVikeConfig.js';
 import { isRuntimeEnvMatch } from './isRuntimeEnvMatch.js';
 import { serializeConfigValues } from '../../../../../shared/page-configs/serialize/serializeConfigValues.js';
 async function getVirtualFilePageConfigs(isForClientSide, isDev, id, isClientRouting, config) {
-    const { pageConfigs, pageConfigGlobal } = await getVikeConfig(config, isDev, true);
+    const { pageConfigs, pageConfigGlobal } = await getVikeConfig(config, isDev, { tolerateInvalidConfig: true });
     return getCode(pageConfigs, pageConfigGlobal, isForClientSide, isDev, id, isClientRouting);
 }
 function getCode(pageConfigs, pageConfigGlobal, isForClientSide, isDev, id, isClientRouting) {

package/dist/esm/node/plugin/plugins/previewConfig.js

@@ -33,10 +33,10 @@ function previewConfig() {
                 assertDist();
                 /* We don't use this condition (we wrongfully always use the SSR middleware) because of the regression introduced by https://github.com/vitejs/vite/pull/14756 which stops servering .html files when `appType: 'custom'`.
                 if (!configVike.prerender || configVike.prerender.partial) {
-                  addSsrMiddleware(server.middlewares)
+                  addSsrMiddleware(server.middlewares, config, true)
                 }
                 /*/
-                addSsrMiddleware(server.middlewares);
+                addSsrMiddleware(server.middlewares, config, true);
                 //*/
                 addStatic404Middleware(server.middlewares);
             };

package/dist/esm/node/plugin/resolveClientEntriesDev.d.ts

@@ -0,0 +1,4 @@
+export { resolveClientEntriesDev };
+export type ResolveClientEntriesDev = typeof resolveClientEntriesDev;
+import type { ViteDevServer } from 'vite';
+declare function resolveClientEntriesDev(clientEntry: string, viteDevServer: ViteDevServer): Promise<string>;

package/dist/esm/node/plugin/resolveClientEntriesDev.js

@@ -0,0 +1,56 @@
+export { resolveClientEntriesDev };
+import { assert, assertPosixPath, toPosixPath, pathJoin, assertIsNpmPackageImport, assertIsNotProductionRuntime } from './utils.js';
+import { createRequire } from 'module';
+import { dirname } from 'path';
+import { fileURLToPath } from 'url';
+// @ts-ignore Shimmed by dist-cjs-fixup.js for CJS build.
+const importMetaUrl = import.meta.url;
+const require_ = createRequire(importMetaUrl);
+const __dirname_ = dirname(fileURLToPath(importMetaUrl));
+assertIsNotProductionRuntime();
+async function resolveClientEntriesDev(clientEntry, viteDevServer) {
+    let root = viteDevServer.config.root;
+    assert(root);
+    root = toPosixPath(root);
+    // The `?import` suffix is needed for MDX to be transpiled:
+    //   - Not transpiled: `/pages/markdown.page.mdx`
+    //   - Transpiled: `/pages/markdown.page.mdx?import`
+    // But `?import` doesn't work with `/@fs/`:
+    //   - Not transpiled: /@fs/home/runner/work/vike/vike/examples/react-full/pages/markdown.page.mdx
+    //   - Not transpiled: /@fs/home/runner/work/vike/vike/examples/react-full/pages/markdown.page.mdx?import
+    if (clientEntry.endsWith('?import')) {
+        assert(clientEntry.startsWith('/'));
+        return clientEntry;
+    }
+    assertPosixPath(clientEntry);
+    let filePath;
+    if (clientEntry.startsWith('/')) {
+        filePath = pathJoin(root, clientEntry);
+    }
+    else {
+        if (clientEntry.startsWith('@@vike/')) {
+            assert(clientEntry.endsWith('.js'));
+            try {
+                // For Vitest (which doesn't resolve vike to its dist but to its source files)
+                // [RELATIVE_PATH_FROM_DIST] Current file: node_modules/vike/node/plugin/resolveClientEntriesDev.js
+                filePath = toPosixPath(require_.resolve(clientEntry.replace('@@vike/dist/esm/client/', '../../client/').replace('.js', '.ts')));
+            }
+            catch {
+                // For users
+                // [RELATIVE_PATH_FROM_DIST] Current file: node_modules/vike/dist/esm/node/plugin/resolveClientEntriesDev.js
+                filePath = toPosixPath(require_.resolve(clientEntry.replace('@@vike/dist/esm/client/', '../../../../dist/esm/client/')));
+            }
+        }
+        else {
+            assertIsNpmPackageImport(clientEntry);
+            filePath = require_.resolve(clientEntry);
+        }
+    }
+    if (!filePath.startsWith('/')) {
+        assert(process.platform === 'win32');
+        filePath = '/' + filePath;
+    }
+    filePath = '/@fs' + filePath;
+    assertPosixPath(filePath);
+    return filePath;
+}

package/dist/esm/node/plugin/shared/addSsrMiddleware.d.ts

@@ -1,4 +1,4 @@
 export { addSsrMiddleware };
-import type { ViteDevServer } from 'vite';
+import type { ResolvedConfig, ViteDevServer } from 'vite';
 type ConnectServer = ViteDevServer['middlewares'];
-declare function addSsrMiddleware(middlewares: ConnectServer): void;
+declare function addSsrMiddleware(middlewares: ConnectServer, config: ResolvedConfig, isPreview: boolean): void;

package/dist/esm/node/plugin/shared/addSsrMiddleware.js

@@ -2,7 +2,7 @@ export { addSsrMiddleware };
 import { renderPage } from '../../runtime/renderPage.js';
 import { assertWarning } from '../utils.js';
 import pc from '@brillout/picocolors';
-function addSsrMiddleware(middlewares) {
+function addSsrMiddleware(middlewares, config, isPreview) {
     middlewares.use(async (req, res, next) => {
         if (res.headersSent)
             return next();
@@ -37,6 +37,12 @@ function addSsrMiddleware(middlewares) {
             // - We purposely don't use next(err) to align behavior: we use our own/copied implementation of buildErrorMessage() regardless of whether the user uses Vite's dev middleware or Vite's standalone dev server
             return next();
         }
+        const configHeaders = (isPreview && config?.preview?.headers) || config?.server?.headers;
+        if (configHeaders) {
+            for (const [name, value] of Object.entries(configHeaders))
+                if (value)
+                    res.setHeader(name, value);
+        }
         if (!pageContext.httpResponse) {
             return next();
         }

package/dist/esm/node/plugin/shared/loggerNotProd/log.js

@@ -7,7 +7,7 @@ export { screenHasErrors };
 export { applyViteSourceMapToStackTrace };
 import { assert, projectInfo, stripAnsi, hasProp, assertIsNotProductionRuntime } from '../../utils.js';
 import pc from '@brillout/picocolors';
-import { isErrorDebug } from '../isErrorDebug.js';
+import { isErrorDebug } from '../../../shared/isErrorDebug.js';
 import { getViteDevServer } from '../../../runtime/globalContext.js';
 assertIsNotProductionRuntime();
 let isFirstLog = true;

package/dist/esm/node/plugin/shared/loggerNotProd.js

@@ -16,7 +16,7 @@ import { getViteConfig } from '../../runtime/globalContext.js';
 import { overwriteRuntimeProductionLogger } from '../../runtime/renderPage/loggerRuntime.js';
 import { assert, assertIsNotProductionRuntime, formatHintLog, getAssertErrMsg, overwriteAssertProductionLogger, stripAnsi, warnIfErrorIsNotObject } from '../utils.js';
 import { getHttpRequestAsyncStore } from './getHttpRequestAsyncStore.js';
-import { isErrorDebug } from './isErrorDebug.js';
+import { isErrorDebug } from '../../shared/isErrorDebug.js';
 import { isErrorWithCodeSnippet, getPrettyErrorWithCodeSnippet } from './loggerNotProd/errorWithCodeSnippet.js';
 import { getConfigExecutionErrorIntroMsg, getConfigBuildErrorFormatted } from '../plugins/importUserCode/v1-design/getVikeConfig/transpileAndExecuteFile.js';
 import { logWithVikeTag, logWithViteTag, logDirectly, isFirstLog, screenHasErrors, clearScreen, applyViteSourceMapToStackTrace } from './loggerNotProd/log.js';

package/dist/esm/node/plugin/shared/loggerVite.js

@@ -3,7 +3,7 @@ import { assert, removeEmptyLines, trimWithAnsi, trimWithAnsiTrailOnly } from '.
 import { logViteError, logViteAny, clearLogs } from './loggerNotProd.js';
 import { getHttpRequestAsyncStore } from './getHttpRequestAsyncStore.js';
 import { removeSuperfluousViteLog } from './loggerVite/removeSuperfluousViteLog.js';
-import { isErrorDebug } from './isErrorDebug.js';
+import { isErrorDebug } from '../../shared/isErrorDebug.js';
 function improveViteLogs(config) {
     intercept('info', config);
     intercept('warn', config);

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

@@ -10,7 +10,7 @@ export * from '../../utils/escapeRegex.js';
 export * from '../../utils/stripAnsi.js';
 export * from '../../utils/trimWithAnsi.js';
 export * from '../../utils/removeEmptyLines.js';
-export * from '../../utils/findFile.js';
+export * from '../../utils/findPackageJson.js';
 export * from '../../utils/getPropAccessNotation.js';
 export * from '../../utils/deepEqual.js';
 export * from '../../utils/assertKeys.js';

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

@@ -16,7 +16,7 @@ export * from '../../utils/escapeRegex.js';
 export * from '../../utils/stripAnsi.js';
 export * from '../../utils/trimWithAnsi.js';
 export * from '../../utils/removeEmptyLines.js';
-export * from '../../utils/findFile.js';
+export * from '../../utils/findPackageJson.js';
 export * from '../../utils/getPropAccessNotation.js';
 export * from '../../utils/deepEqual.js';
 export * from '../../utils/assertKeys.js';

package/dist/esm/node/runtime/html/serializePageContextClientSide.js

@@ -31,7 +31,7 @@ function serializePageContextClientSide(pageContext) {
         pageContextClient[prop] = pageContext[prop];
     });
     if (Object.keys(pageContext._pageContextInit).some((p) => passToClient.includes(p))) {
-        pageContextClient._pageContextInitIsPassedToClient = true;
+        pageContextClient[pageContextInitIsPassedToClient] = true;
     }
     let pageContextSerialized;
     try {

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

@@ -2,8 +2,12 @@ export { onLoad };
 import { assertIsNotBrowser } from '../../utils/assertIsNotBrowser.js';
 import { assertNodeVersion } from '../../utils/assertNodeVersion.js';
 import { installRequireShim } from '@brillout/require-shim';
+import { setAlwaysShowStackTrace } from './utils.js';
+import { isErrorDebug } from '../shared/isErrorDebug.js';
 function onLoad() {
     assertIsNotBrowser();
     assertNodeVersion();
     installRequireShim();
+    if (isErrorDebug())
+        setAlwaysShowStackTrace();
 }

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

@@ -7,17 +7,17 @@ import { getGlobalContext } from '../globalContext.js';
 import { getConfigValueRuntime } from '../../../shared/page-configs/getConfigValue.js';
 function analyzePage(pageFilesAll, pageConfig, pageId) {
     if (pageConfig) {
-        const { isClientSideRenderable, isClientRouting } = analyzeClientSide(pageConfig, pageFilesAll, pageId);
+        const { clientEntryLoaded, isClientRouting } = analyzeClientSide(pageConfig, pageFilesAll, pageId);
         const clientEntries = [];
         const clientFilePath = getConfigValueRuntime(pageConfig, 'client', 'string')?.value ?? null;
         if (clientFilePath)
             clientEntries.push(clientFilePath);
-        if (isClientSideRenderable)
+        if (clientEntryLoaded)
             clientEntries.push(getVikeClientEntry(isClientRouting));
         const clientDependencies = [];
         clientDependencies.push({
             id: getVirtualFileIdPageConfigValuesAll(pageConfig.pageId, true),
-            onlyAssets: isClientSideRenderable ? false : true,
+            onlyAssets: clientEntryLoaded ? false : true,
             eagerlyImported: false
         });
         // In production we inject the import of the server virtual module with ?extractAssets inside the client virtual module
@@ -53,7 +53,7 @@ function analyzePage(pageFilesAll, pageConfig, pageId) {
             });
         });
         return {
-            isHtmlOnly: !isClientSideRenderable,
+            isHtmlOnly: !clientEntryLoaded,
             isClientRouting,
             clientEntries,
             clientDependencies,

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

@@ -1,9 +1,11 @@
 export { getPageAssets };
+export { setResolveClientEntriesDev };
 export type { PageAsset };
 export type { GetPageAssets };
 export type { PageContextGetPageAssets };
 import { type MediaType } from './inferMediaType.js';
 import type { ClientDependency } from '../../../shared/getPageFiles/analyzePageClientSide/ClientDependency.js';
+import type { ResolveClientEntriesDev } from '../../plugin/resolveClientEntriesDev.js';
 type PageAsset = {
     src: string;
     assetType: null | NonNullable<MediaType>['assetType'];
@@ -17,3 +19,4 @@ type PageContextGetPageAssets = {
     _includeAssetsImportedByServer: boolean;
 };
 declare function getPageAssets(pageContext: PageContextGetPageAssets, clientDependencies: ClientDependency[], clientEntries: string[]): Promise<PageAsset[]>;
+declare function setResolveClientEntriesDev(resolveClientEntriesDev: ResolveClientEntriesDev): void;