vike 0.4.167 → 0.4.168-commit-7678a7d

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

@@ -1,13 +1,13 @@
 export { transpileAndExecuteFile };
 export { getConfigBuildErrorFormatted };
 export { getConfigExecutionErrorIntroMsg };
-export { isTmpFile };
+export { isTemporaryBuildFile };
 import { build, formatMessages } from 'esbuild';
 import fs from 'fs';
 import path from 'path';
 import pc from '@brillout/picocolors';
 import { import_ } from '@brillout/import';
-import { assertPosixPath, getRandomId, assertIsNotProductionRuntime, assert, assertWarning, isObject, toPosixPath, assertUsage, isJavaScriptFile, createDebugger } from '../../../../utils.js';
+import { assertPosixPath, getRandomId, assertIsNotProductionRuntime, assert, assertWarning, isObject, toPosixPath, assertUsage, isJavaScriptFile, createDebugger, assertPathIsFilesystemAbsolute } from '../../../../utils.js';
 import { transformFileImports } from './transformFileImports.js';
 import { vikeConfigDependencies } from '../getVikeConfig.js';
 import 'source-map-support/register.js';
@@ -79,87 +79,96 @@ async function transpileWithEsbuild(filePath, userRootDir, transformImports) {
         // Esbuild still sometimes removes unused imports because of TypeScript: https://github.com/evanw/esbuild/issues/3034
         treeShaking: false,
         minify: false,
-        metafile: transformImports !== 'all',
-        bundle: transformImports !== 'all'
+        metafile: true,
+        bundle: true
     };
-    let pointerImports;
-    if (transformImports === 'all') {
-        pointerImports = 'all';
-        options.packages = 'external';
-    }
-    else {
-        const pointerImports_ = (pointerImports = {});
-        options.plugins = [
-            // Determine what import should be externalized (and then transformed to a pointer/fake import)
-            {
-                name: 'vike:externalize-heuristic',
-                setup(build) {
-                    // https://github.com/evanw/esbuild/issues/3095#issuecomment-1546916366
+    let pointerImports = {};
+    options.plugins = [
+        // Determine whether an import should be:
+        //  - A pointer import
+        //  - Externalized
+        {
+            name: 'vike-esbuild',
+            setup(build) {
+                // https://github.com/brillout/esbuild-playground
+                build.onResolve({ filter: /.*/ }, async (args) => {
+                    if (args.kind !== 'import-statement')
+                        return;
+                    // Avoid infinite loop: https://github.com/evanw/esbuild/issues/3095#issuecomment-1546916366
                     const useEsbuildResolver = 'useEsbuildResolver';
-                    // https://github.com/brillout/esbuild-playground
-                    build.onResolve({ filter: /.*/ }, async (args) => {
-                        if (args.kind !== 'import-statement')
-                            return;
-                        if (args.pluginData?.[useEsbuildResolver])
-                            return;
-                        const { path, ...opts } = args;
-                        opts.pluginData = { [useEsbuildResolver]: true };
-                        const resolved = await build.resolve(path, opts);
-                        resolved.path = toPosixPath(resolved.path);
-                        // vike-{react,vue,solid} follow the convention that their config export resolves to a file named +config.js
-                        //  - This is temporary, see comment below.
-                        const isVikeExtensionConfigImport = resolved.path.endsWith('+config.js');
-                        const isPointerImport = 
+                    if (args.pluginData?.[useEsbuildResolver])
+                        return;
+                    const { path, ...opts } = args;
+                    opts.pluginData = { [useEsbuildResolver]: true };
+                    const resolved = await build.resolve(path, opts);
+                    if (resolved.errors.length > 0) {
+                        /* We could do the following to let Node.js throw the error, but we don't because the error shown by esbuild is prettier: the Node.js error refers to the transpiled [build-f7i251e0iwnw]+config.ts.mjs file which isn't that nice, whereas esbuild refers to the source +config.ts file.
+                        pointerImports[args.path] = false
+                        return { external: true }
+                        */
+                        // Let esbuild throw the error. (It throws a nice & pretty error.)
+                        cleanEsbuildErrors(resolved.errors);
+                        return resolved;
+                    }
+                    assert(resolved.path);
+                    resolved.path = toPosixPath(resolved.path);
+                    // vike-{react,vue,solid} follow the convention that their config export resolves to a file named +config.js
+                    //  - This is temporary, see comment below.
+                    const isVikeExtensionConfigImport = resolved.path.endsWith('+config.js');
+                    const isPointerImport = transformImports === 'all' ||
                         // .jsx, .vue, .svg, ... => obviously not config code
                         !isJavaScriptFile(resolved.path) ||
-                            // Import of a Vike extension config => make it a pointer import because we want to show nice error messages (that can display whether a configas been set by the user or by a Vike extension).
-                            //  - We should have Node.js directly load vike-{react,vue,solid} while enforcing Vike extensions to set 'name' in their +config.js file.
-                            //    - vike@0.4.162 already started soft-requiring Vike extensions to set the name config
-                            isVikeExtensionConfigImport ||
-                            // Cannot be resolved by esbuild => take a leap of faith and make it a pointer import.
-                            //  - For example if esbuild cannot resolve a path alias while Vite can.
-                            //    - When tsconfig.js#compilerOptions.paths is set, then esbuild is able to resolve the path alias.
-                            resolved.errors.length > 0;
-                        pointerImports_[resolved.path] = isPointerImport;
-                        assertPosixPath(resolved.path);
-                        const isExternal = isPointerImport ||
-                            // npm package imports that aren't pointer imports (e.g. importing a Vite plugin)
-                            resolved.path.includes('/node_modules/');
-                        if (debug.isActivated)
-                            debug('onResolved()', { args, resolved, isPointerImport, isExternal });
-                        if (isExternal) {
-                            return { external: true, path: resolved.path };
-                        }
-                        else {
-                            return resolved;
-                        }
-                    });
-                }
-            },
-            // Track dependencies
-            {
-                name: 'vike:dependency-tracker',
-                setup(b) {
-                    b.onLoad({ filter: /./ }, (args) => {
-                        // We collect the dependency `args.path` in case the bulid fails (upon build error => error is thrown => no metafile)
-                        let { path } = args;
-                        path = toPosixPath(path);
-                        vikeConfigDependencies.add(path);
-                        return undefined;
-                    });
-                    /* To exhaustively collect all dependencies upon build failure, we would also need to use onResolve().
-                     *  - Because onLoad() isn't call if the config dependency can't be resolved.
-                     *  - For example, the following breaks auto-reload (the config is stuck in its error state and the user needs to touch the importer for the config to reload):
-                     *    ```bash
-                     *    mv ./some-config-dependency.js /tmp/ && mv /tmp/some-config-dependency.js .
-                     *    ```
-                     *  - But implementing a fix is complex and isn't worth it.
-                    b.onResolve(...)
-                    */
-                }
+                        // Import of a Vike extension config => make it a pointer import because we want to show nice error messages (that can display whether a configas been set by the user or by a Vike extension).
+                        //  - We should have Node.js directly load vike-{react,vue,solid} while enforcing Vike extensions to set 'name' in their +config.js file.
+                        //    - vike@0.4.162 already started soft-requiring Vike extensions to set the name config
+                        isVikeExtensionConfigImport ||
+                        // Cannot be resolved by esbuild => take a leap of faith and make it a pointer import.
+                        //  - For example if esbuild cannot resolve a path alias while Vite can.
+                        //    - When tsconfig.js#compilerOptions.paths is set, then esbuild is able to resolve the path alias.
+                        resolved.errors.length > 0;
+                    pointerImports[resolved.path] = isPointerImport;
+                    assertPosixPath(resolved.path);
+                    const isExternal = isPointerImport ||
+                        // Performance: npm package imports that aren't pointer imports can be externalized. For example, if Vike eventually adds support for setting Vite configs in the vike.config.js file, then the user may import a Vite plugin in his vike.config.js file. (We could as well let esbuild always transpile /node_modules/ code but it would be useless and would unnecessarily slow down transpilation.)
+                        resolved.path.includes('/node_modules/');
+                    if (debug.isActivated)
+                        debug('onResolved()', { args, resolved, isPointerImport, isExternal });
+                    // We need esbuild to resolve path aliases so that we can use:
+                    //   isNpmPackageImport(str, { cannotBePathAlias: true })
+                    //   assertIsNpmPackageImport()
+                    assertPathIsFilesystemAbsolute(resolved.path);
+                    if (isExternal) {
+                        return { external: true, path: resolved.path };
+                    }
+                    else {
+                        return resolved;
+                    }
+                });
             }
-        ];
-    }
+        },
+        // Track dependencies
+        {
+            name: 'vike:dependency-tracker',
+            setup(b) {
+                b.onLoad({ filter: /./ }, (args) => {
+                    // We collect the dependency `args.path` in case the bulid fails (upon build error => error is thrown => no metafile)
+                    let { path } = args;
+                    path = toPosixPath(path);
+                    vikeConfigDependencies.add(path);
+                    return undefined;
+                });
+                /* To exhaustively collect all dependencies upon build failure, we would also need to use onResolve().
+                 *  - Because onLoad() isn't call if the config dependency can't be resolved.
+                 *  - For example, the following breaks auto-reload (the config is stuck in its error state and the user needs to touch the importer for the config to reload):
+                 *    ```bash
+                 *    mv ./some-config-dependency.js /tmp/ && mv /tmp/some-config-dependency.js .
+                 *    ```
+                 *  - But implementing a fix is complex and isn't worth it.
+                b.onResolve(...)
+                */
+            }
+        }
+    ];
     let result;
     try {
         result = await build(options);
@@ -169,15 +178,13 @@ async function transpileWithEsbuild(filePath, userRootDir, transformImports) {
         throw err;
     }
     // Track dependencies
-    if (transformImports !== 'all') {
-        assert(result.metafile);
-        Object.keys(result.metafile.inputs).forEach((filePathRelative) => {
-            filePathRelative = toPosixPath(filePathRelative);
-            assertPosixPath(userRootDir);
-            const filePathAbsoluteFilesystem = path.posix.join(userRootDir, filePathRelative);
-            vikeConfigDependencies.add(filePathAbsoluteFilesystem);
-        });
-    }
+    assert(result.metafile);
+    Object.keys(result.metafile.inputs).forEach((filePathRelative) => {
+        filePathRelative = toPosixPath(filePathRelative);
+        assertPosixPath(userRootDir);
+        const filePathAbsoluteFilesystem = path.posix.join(userRootDir, filePathRelative);
+        vikeConfigDependencies.add(filePathAbsoluteFilesystem);
+    });
     const code = result.outputFiles[0].text;
     assert(typeof code === 'string');
     return { code, pointerImports };
@@ -186,7 +193,7 @@ async function executeTranspiledFile(filePath, code) {
     const { filePathAbsoluteFilesystem } = filePath;
     // Alternative to using a temporary file: https://github.com/vitejs/vite/pull/13269
     //  - But seems to break source maps, so I don't think it's worth it
-    const filePathTmp = getFilePathTmp(filePathAbsoluteFilesystem);
+    const filePathTmp = getTemporaryBuildFilePath(filePathAbsoluteFilesystem);
     fs.writeFileSync(filePathTmp, code);
     const clean = () => fs.unlinkSync(filePathTmp);
     let fileExports = {};
@@ -243,20 +250,19 @@ function getConfigExecutionErrorIntroMsg(err) {
     const errIntroMsg = execErrIntroMsg.get(err);
     return errIntroMsg ?? null;
 }
-const tmpPrefix = `[build-`;
-function getFilePathTmp(filePathAbsoluteFilesystem) {
+function getTemporaryBuildFilePath(filePathAbsoluteFilesystem) {
     assertPosixPath(filePathAbsoluteFilesystem);
     const dirname = path.posix.dirname(filePathAbsoluteFilesystem);
     const filename = path.posix.basename(filePathAbsoluteFilesystem);
-    // Syntax with semicolon `[build:${/*...*/}]` doesn't work on Windows: https://github.com/vikejs/vike/issues/800#issuecomment-1517329455
-    const tag = `${tmpPrefix}${getRandomId(12)}]`;
-    const filePathTmp = path.posix.join(dirname, `${tag}${filename}.mjs`);
+    // Syntax with semicolon `build:${/*...*/}` doesn't work on Windows: https://github.com/vikejs/vike/issues/800#issuecomment-1517329455
+    const filePathTmp = path.posix.join(dirname, `${filename}.build-${getRandomId(12)}.mjs`);
+    assert(isTemporaryBuildFile(filePathTmp));
     return filePathTmp;
 }
-function isTmpFile(filePath) {
+function isTemporaryBuildFile(filePath) {
     assertPosixPath(filePath);
     const fileName = path.posix.basename(filePath);
-    return fileName.startsWith(tmpPrefix);
+    return /\.build-[a-z0-9]{12}\.mjs$/.test(fileName);
 }
 function isHeaderFile(filePath) {
     assertPosixPath(filePath);
@@ -300,3 +306,23 @@ function getErrIntroMsg(operation, filePath) {
     ].join(' ');
     return msg;
 }
+function cleanEsbuildErrors(errors) {
+    errors.forEach((e) => (e.notes = e.notes.filter((note) => 
+    // Remove note:
+    // ```shell
+    // You can mark the path "#root/renderer/onRenderHtml_typo" as external to exclude it from the bundle, which will remove this error and leave the unresolved path in the bundle.
+    // ```
+    //
+    // From error:
+    // ```shell
+    // ✘ [ERROR] Could not resolve "#root/renderer/onRenderHtml_typo" [plugin vike-esbuild]
+    //
+    //    renderer/+config.h.js:1:29:
+    //      1 │ import { onRenderHtml } from "#root/renderer/onRenderHtml_typo"
+    //        ╵                              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    //
+    //  You can mark the path "#root/renderer/onRenderHtml_typo" as external to exclude it from the bundle, which will remove this error and leave the unresolved path in the bundle.
+    //
+    // ```
+    !note.text.includes('as external to exclude it from the bundle'))));
+}

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

@@ -7,7 +7,7 @@ import { assertPosixPath, assert, isObject, assertUsage, assertWarning, objectEn
 import path from 'path';
 import { configDefinitionsBuiltIn, configDefinitionsBuiltInGlobal } from './getVikeConfig/configDefinitionsBuiltIn.js';
 import { getLocationId, getFilesystemRouteString, getFilesystemRouteDefinedBy, isInherited, sortAfterInheritanceOrder, isGlobalLocation, applyFilesystemRoutingRootEffect } from './getVikeConfig/filesystemRouting.js';
-import { isTmpFile } from './getVikeConfig/transpileAndExecuteFile.js';
+import { isTemporaryBuildFile } from './getVikeConfig/transpileAndExecuteFile.js';
 import { isConfigInvalid, isConfigInvalid_set } from '../../../../runtime/renderPage/isConfigInvalid.js';
 import { getViteDevServer } from '../../../../runtime/globalContext.js';
 import { logConfigError, logConfigErrorRecover } from '../../../shared/loggerNotProd.js';
@@ -745,7 +745,7 @@ async function findPlusFiles(userRootDir, outDirRoot, isDev) {
 }
 function getConfigName(filePath) {
     assertPosixPath(filePath);
-    if (isTmpFile(filePath))
+    if (isTemporaryBuildFile(filePath))
         return null;
     const fileName = path.posix.basename(filePath);
     // assertNoUnexpectedPlusSign(filePath, fileName)
@@ -776,7 +776,30 @@ function assertNoUnexpectedPlusSign(filePath: string, fileName: string) {
 }
 */
 function handleUnknownConfig(configName, configNames, filePathToShowToUser) {
-    let errMsg = `${filePathToShowToUser} defines an unknown config ${pc.cyan(configName)}`;
+    {
+        const ui = ['vike-react', 'vike-vue', 'vike-solid'];
+        const knownVikeExntensionConfigs = {
+            description: ui,
+            favicon: ui,
+            Head: ui,
+            Layout: ui,
+            onCreateApp: ['vike-vue'],
+            title: ui,
+            ssr: ui,
+            stream: ui,
+            Wrapper: ui
+        };
+        if (configName in knownVikeExntensionConfigs) {
+            const requiredVikeExtension = knownVikeExntensionConfigs[configName];
+            assertUsage(false, [
+                `${filePathToShowToUser} uses the config ${pc.cyan(configName)} (https://vike.dev/${configName})`,
+                `which requires the Vike extension ${requiredVikeExtension.map((e) => pc.bold(e)).join('/')}.`,
+                `Make sure to install the Vike extension,`,
+                `and make sure it applies to ${filePathToShowToUser} as explained at https://vike.dev/extends#inheritance.`
+            ].join(' '));
+        }
+    }
+    let errMsg = `${filePathToShowToUser} sets an unknown config ${pc.cyan(configName)}`;
     let configNameSimilar = null;
     if (configName === 'page') {
         configNameSimilar = 'Page';
@@ -784,17 +807,13 @@ function handleUnknownConfig(configName, configNames, filePathToShowToUser) {
     else {
         configNameSimilar = getMostSimilar(configName, configNames);
     }
-    if (configNameSimilar || configName === 'page') {
-        assert(configNameSimilar);
+    if (configNameSimilar) {
         assert(configNameSimilar !== configName);
-        errMsg += `, did you mean to define ${pc.cyan(configNameSimilar)} instead?`;
+        errMsg += `, did you mean to set ${pc.cyan(configNameSimilar)} instead?`;
         if (configName === 'page') {
             errMsg += ` (The name of the config ${pc.cyan('Page')} starts with a capital letter ${pc.cyan('P')} because it usually defines a UI component: a ubiquitous JavaScript convention is to start the name of UI components with a capital letter.)`;
         }
     }
-    else {
-        errMsg += `, you need to define the config ${pc.cyan(configName)} by using ${pc.cyan('config.meta')} https://vike.dev/meta`;
-    }
     assertUsage(false, errMsg);
 }
 function determineRouteFilesystem(locationId, configValueSources) {

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

@@ -87,7 +87,12 @@ function getFilePathAbsoluteUserRootDir({ filePathAbsoluteFilesystem, userRootDi
         assert(filePathRelative.startsWith('../'));
         return null;
     }
-    assert(!filePathRelative.startsWith('.') && !filePathRelative.startsWith('/'));
+    assert(!filePathRelative.startsWith('/') &&
+        /* Not true if filePathRelative starts with a hidden directory  (i.e. a directory with a name that starts with `.`)
+        !filePathRelative.startsWith('.') &&
+        */
+        !filePathRelative.startsWith('./') &&
+        !filePathRelative.startsWith('../'));
     const filePathAbsoluteUserRootDir = `/${filePathRelative}`;
     assert(filePathAbsoluteUserRootDir === getFilePathAbsoluteUserRootDir2(filePathAbsoluteFilesystem, userRootDir));
     return filePathAbsoluteUserRootDir;

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

@@ -13,7 +13,7 @@ function analyzePage(pageFilesAll, pageConfig, pageId) {
         const clientDependencies = [];
         clientDependencies.push({
             id: getVirtualFileIdPageConfigValuesAll(pageConfig.pageId, true),
-            onlyAssets: false,
+            onlyAssets: isClientSideRenderable ? false : true,
             eagerlyImported: false
         });
         // In production we inject the import of the server virtual module with ?extractAssets inside the client virtual module

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

@@ -20,6 +20,10 @@ const knownErrors = [
         // ```
         errMsg: 'assets.json',
         link: 'https://vike.dev/getGlobalContext'
+    },
+    {
+        errMsg: /Named export.*not found/i,
+        link: 'https://vike.dev/broken-npm-package#named-export-not-found'
     }
 ];
 function logErrorHint(error) {
@@ -285,7 +289,15 @@ function extractFromNodeModulesPath(str) {
     return packageName;
 }
 function includes(str1, str2) {
-    return !!str1 && str1.toLowerCase().includes(str2.toLowerCase());
+    if (!str1)
+        return false;
+    if (str2 instanceof RegExp) {
+        return str2.test(str1.toLowerCase());
+    }
+    if (typeof str2 === 'string') {
+        return str1.toLowerCase().includes(str2.toLowerCase());
+    }
+    return false;
 }
 function includesNodeModules(str) {
     if (!str)

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

@@ -5,6 +5,7 @@ function prependEntriesDir(entryName) {
         entryName = entryName.slice(1);
     }
     assert(!entryName.startsWith('/'));
+    assert(entryName);
     entryName = `entries/${entryName}`;
     return entryName;
 }

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

@@ -18,14 +18,14 @@ type Url = {
     searchAll: Record<string, string[]>;
     /** The URL search parameterer string, e.g. `?details=yes` of `https://example.com/product/42?details=yes#reviews` */
     searchOriginal: null | string;
-    /** @deprecated */
-    searchString: null | string;
     /** The URL hash, e.g. `reviews` of `https://example.com/product/42?details=yes#reviews` */
     hash: string;
     /** The URL hash string, e.g. `#reviews` of `https://example.com/product/42?details=yes#reviews` */
     hashOriginal: null | string;
     /** @deprecated */
     hashString: null | string;
+    /** @deprecated */
+    searchString: null | string;
 };
 type PageContextUrlComputedPropsClient = {
     /** @deprecated */

package/dist/esm/utils/assertPathIsFilesystemAbsolute.js

@@ -6,10 +6,10 @@ import { assertPosixPath } from './filesystemPathHandling.js';
 function assertPathIsFilesystemAbsolute(p) {
     assertPosixPath(p);
     assert(!p.startsWith('/@fs/'));
-    if (process.platform === 'win32') {
-        assert(path.win32.isAbsolute(p));
+    if (process.platform !== 'win32') {
+        assert(p.startsWith('/'));
     }
     else {
-        assert(p.startsWith('/'));
+        assert(path.win32.isAbsolute(p));
     }
 }

package/dist/esm/utils/isDev.d.ts

@@ -1,6 +1,9 @@
 export { isDev1 };
 export { isDev1_onConfigureServer };
 export { isDev2 };
+export { isDev3 };
+import type { ConfigEnv } from 'vite';
+declare function isDev3(configEnv: ConfigEnv): null | boolean;
 declare function isDev1(): boolean;
 declare function isDev1_onConfigureServer(): void | undefined;
 import type { ResolvedConfig } from 'vite';

package/dist/esm/utils/isDev.js

@@ -1,10 +1,18 @@
 export { isDev1 };
 export { isDev1_onConfigureServer };
 export { isDev2 };
-// There isn't any reliable way to test whether Vite is ran as dev/build/preview/optimizeDep
-//  - Failed attempt to make a PR: https://github.com/brillout/vite/tree/fix/config-operation
+export { isDev3 };
+function isDev3(configEnv) {
+    const { isPreview, command } = configEnv;
+    if (command !== 'serve')
+        return false;
+    if (typeof isPreview === 'boolean')
+        return !isPreview;
+    // isPreview is undefined in older Vite versions, see https://github.com/vitejs/vite/commit/93fce55
+    return null;
+}
 // ********
-// Method 1 - most reliable
+// Method 1 - reliable
 // ********
 import { assert } from './assert.js';
 import { getGlobalObject } from './getGlobalObject.js';

package/dist/esm/utils/projectInfo.d.ts

@@ -1,7 +1,7 @@
 export { projectInfo };
 export { PROJECT_VERSION };
-declare const PROJECT_VERSION: "0.4.167";
+declare const PROJECT_VERSION: "0.4.168-commit-7678a7d";
 declare const projectInfo: {
     projectName: "Vike";
-    projectVersion: "0.4.167";
+    projectVersion: "0.4.168-commit-7678a7d";
 };

package/dist/esm/utils/projectInfo.js

@@ -1,6 +1,6 @@
 export { projectInfo };
 export { PROJECT_VERSION };
-const PROJECT_VERSION = '0.4.167';
+const PROJECT_VERSION = '0.4.168-commit-7678a7d';
 const projectInfo = {
     projectName: 'Vike',
     projectVersion: PROJECT_VERSION

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vike",
-  "version": "0.4.167",
+  "version": "0.4.168-commit-7678a7d",
   "scripts": {
     "dev": "tsc --watch",
     "build": "rimraf dist/ && pnpm run build:esm && pnpm run build:cjs",
@@ -16,7 +16,7 @@
     "@brillout/json-serializer": "^0.5.8",
     "@brillout/picocolors": "^1.0.10",
     "@brillout/require-shim": "^0.1.2",
-    "@brillout/vite-plugin-server-entry": "^0.4.4",
+    "@brillout/vite-plugin-server-entry": "^0.4.5",
     "acorn": "^8.0.0",
     "cac": "^6.0.0",
     "es-module-lexer": "^1.0.0",