vike 0.4.162 → 0.4.163-commit-407cb5c

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

@@ -1,3 +1,7 @@
+// Public use
+export { getGlobalContextSync };
+export { getGlobalContextAsync };
+// Internal use
 export { initGlobalContext };
 export { getGlobalContext };
 export { getViteDevServer };
@@ -5,18 +9,56 @@ export { getViteConfig };
 export { setGlobalContext_viteDevServer };
 export { setGlobalContext_prerender };
 export { getRuntimeManifest };
-import { assert, assertUsage, getGlobalObject, getNodeEnv, getNodeEnvDesc, isNodeEnvDev, isPlainObject, objectAssign } from './utils.js';
+import { assert, assertUsage, assertWarning, getGlobalObject, getNodeEnv, getNodeEnvDesc, isNodeEnvDev, isPlainObject, objectAssign, objectKeys } from './utils.js';
 import { loadImportBuild } from './globalContext/loadImportBuild.js';
 import { setPageFiles } from '../../shared/getPageFiles.js';
 import { assertPluginManifest } from '../shared/assertPluginManifest.js';
 import { getConfigVike } from '../shared/getConfigVike.js';
 import { assertRuntimeManifest } from '../shared/assertRuntimeManifest.js';
 import pc from '@brillout/picocolors';
-const globalObject = getGlobalObject('globalContext.ts', {});
+let resolveGlobalContext;
+const globalObject = getGlobalObject('globalContext.ts', {
+    globalContextPromise: new Promise((r) => (resolveGlobalContext = r))
+});
 function getGlobalContext() {
     assert(globalObject.globalContext);
     return globalObject.globalContext;
 }
+/** @experimental https://vike.dev/getGlobalContext */
+function getGlobalContextSync() {
+    assertUsage(globalObject.globalContext, "The global context isn't set yet, call getGlobalContextSync() later or use getGlobalContextAsync() instead.");
+    return makePublic(globalObject.globalContext);
+}
+/** @experimental https://vike.dev/getGlobalContext */
+async function getGlobalContextAsync() {
+    await globalObject.globalContextPromise;
+    assert(globalObject.globalContext);
+    return makePublic(globalObject.globalContext);
+}
+function makePublic(globalContext) {
+    const globalContextPublic = {
+        assetsManifest: globalContext.assetsManifest
+    };
+    // Add internals (and prepended _ prefix to their keys)
+    {
+        const publicKeys = Object.keys(globalContextPublic);
+        objectKeys(globalContext)
+            .filter((key) => !publicKeys.includes(key))
+            .forEach((key) => {
+            const keyPublic = `_${key}`;
+            Object.defineProperty(globalContextPublic, keyPublic, {
+                enumerable: true,
+                get() {
+                    assertWarning(false, `Using internal globalContext.${keyPublic} which is discouraged: it may break in any minor version update. Instead, reach out on GitHub and elaborate your use case.`, {
+                        onlyOnce: true
+                    });
+                    return globalContext[key];
+                }
+            });
+        });
+    }
+    return globalContextPublic;
+}
 function setGlobalContext_viteDevServer(viteDevServer) {
     if (globalObject.viteDevServer)
         return;
@@ -51,7 +93,7 @@ async function initGlobalContext(isPrerendering = false, outDir) {
         globalObject.globalContext = {
             isProduction: false,
             isPrerendering: false,
-            clientManifest: null,
+            assetsManifest: null,
             pluginManifest: null,
             viteDevServer,
             viteConfig,
@@ -66,13 +108,13 @@ async function initGlobalContext(isPrerendering = false, outDir) {
     else {
         const buildEntries = await loadImportBuild(outDir);
         assertBuildEntries(buildEntries, isPrerendering ?? false);
-        const { pageFiles, clientManifest, pluginManifest } = buildEntries;
+        const { pageFiles, assetsManifest, pluginManifest } = buildEntries;
         setPageFiles(pageFiles);
-        assertViteManifest(clientManifest);
+        assertViteManifest(assetsManifest);
         assertPluginManifest(pluginManifest);
         const globalContext = {
             isProduction: true,
-            clientManifest,
+            assetsManifest,
             pluginManifest,
             viteDevServer: null,
             baseServer: pluginManifest.baseServer,
@@ -100,6 +142,7 @@ async function initGlobalContext(isPrerendering = false, outDir) {
             globalObject.globalContext = globalContext;
         }
     }
+    resolveGlobalContext(globalObject.globalContext);
 }
 function getRuntimeManifest(configVike) {
     const { includeAssetsImportedByServer, baseServer, baseAssets, redirects, trailingSlash, disableUrlNormalization } = configVike;

package/dist/esm/node/runtime/index-common.d.ts

@@ -2,6 +2,7 @@ export { renderPage } from './renderPage.js';
 export { escapeInject, dangerouslySkipEscape } from './html/renderHtml.js';
 export { pipeWebStream, pipeNodeStream, pipeStream, stampPipe } from './html/stream.js';
 export { PROJECT_VERSION as version } from './utils.js';
+export { getGlobalContextSync, getGlobalContextAsync } from './globalContext.js';
 export { injectAssets__public as _injectAssets } from './html/injectAssets/injectAssets__public.js';
 export { createPageRenderer } from '../createPageRenderer.js';
 declare global {

package/dist/esm/node/runtime/index-common.js

@@ -2,6 +2,7 @@ export { renderPage } from './renderPage.js';
 export { escapeInject, dangerouslySkipEscape } from './html/renderHtml.js';
 export { pipeWebStream, pipeNodeStream, pipeStream, stampPipe } from './html/stream.js';
 export { PROJECT_VERSION as version } from './utils.js';
+export { getGlobalContextSync, getGlobalContextAsync } from './globalContext.js';
 // TODO/v1-release: remove
 export { injectAssets__public as _injectAssets } from './html/injectAssets/injectAssets__public.js';
 // TODO/v1-release: remove

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

@@ -1,6 +1,6 @@
 export { getManifestEntry };
 import type { ViteManifest, ViteManifestEntry } from '../../../shared/ViteManifest.js';
-declare function getManifestEntry(id: string, clientManifest: ViteManifest): {
+declare function getManifestEntry(id: string, assetsManifest: ViteManifest): {
     manifestKey: string;
     manifestEntry: ViteManifestEntry;
 };

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

@@ -3,13 +3,13 @@ import { assert, slice, isNpmPackageImport } from '../../utils.js';
 import { assertClientEntryId } from './assertClientEntryId.js';
 import { isVirtualFileIdPageConfigValuesAll } from '../../../shared/virtual-files/virtualFilePageConfigValuesAll.js';
 import { prependEntriesDir } from '../../../shared/prependEntriesDir.js';
-function getManifestEntry(id, clientManifest) {
+function getManifestEntry(id, assetsManifest) {
     assertClientEntryId(id);
-    const debugInfo = getDebugInfo(id, clientManifest);
+    const debugInfo = getDebugInfo(id, assetsManifest);
     // Vike client entry
     if (id.startsWith('@@vike/')) {
         const manifestKeyEnd = slice(id, '@@vike'.length, 0);
-        const { manifestKey, manifestEntry } = findEntryWithKeyEnd(manifestKeyEnd, clientManifest, id);
+        const { manifestKey, manifestEntry } = findEntryWithKeyEnd(manifestKeyEnd, assetsManifest, id);
         assert(manifestEntry && manifestKey, debugInfo);
         return { manifestEntry, manifestKey };
     }
@@ -17,7 +17,7 @@ function getManifestEntry(id, clientManifest) {
     if (isVirtualFileIdPageConfigValuesAll(id)) {
         {
             const manifestKey = id;
-            const manifestEntry = clientManifest[manifestKey];
+            const manifestEntry = assetsManifest[manifestKey];
             if (manifestEntry) {
                 return { manifestEntry, manifestKey };
             }
@@ -30,20 +30,20 @@ function getManifestEntry(id, clientManifest) {
         //  - This workaround was implemented to support Vitest runnung /tests/*
         //    - I don't know whether end users actually need this workaround? (I'm not sure what the bug actually is.)
         const manifestKeyEnd = id;
-        const { manifestKey, manifestEntry } = getEntryWithKeyEnd(manifestKeyEnd, clientManifest, id);
+        const { manifestKey, manifestEntry } = getEntryWithKeyEnd(manifestKeyEnd, assetsManifest, id);
         assert(manifestEntry, debugInfo);
         return { manifestEntry, manifestKey };
     }
     // User files
     if (id.startsWith('/')) {
         const manifestKey = id.slice(1);
-        let manifestEntry = clientManifest[manifestKey];
+        let manifestEntry = assetsManifest[manifestKey];
         assert(manifestEntry, debugInfo);
         return { manifestEntry, manifestKey };
     }
     // npm package import
     if (isNpmPackageImport(id)) {
-        const found = Object.entries(clientManifest).find(([, e]) => e.name === prependEntriesDir(id));
+        const found = Object.entries(assetsManifest).find(([, e]) => e.name === prependEntriesDir(id));
         assert(found);
         const [manifestKey, manifestEntry] = found;
         return { manifestEntry, manifestKey };
@@ -55,7 +55,7 @@ function getManifestEntry(id, clientManifest) {
         assert(!manifestKeyEnd.startsWith('/'), debugInfo);
         manifestKeyEnd = '/' + manifestKeyEnd;
         {
-            const { manifestEntry, manifestKey } = findEntryWithKeyEnd(manifestKeyEnd, clientManifest, id);
+            const { manifestEntry, manifestKey } = findEntryWithKeyEnd(manifestKeyEnd, assetsManifest, id);
             if (manifestEntry) {
                 assert(manifestKey, debugInfo);
                 return { manifestEntry, manifestKey };
@@ -69,7 +69,7 @@ function getManifestEntry(id, clientManifest) {
             assert(manifestKeyEnd.startsWith('/'), debugInfo);
         }
         {
-            const { manifestEntry, manifestKey } = findEntryWithKeyEnd(manifestKeyEnd, clientManifest, id);
+            const { manifestEntry, manifestKey } = findEntryWithKeyEnd(manifestKeyEnd, assetsManifest, id);
             if (manifestEntry) {
                 assert(manifestKey, debugInfo);
                 return { manifestEntry, manifestKey };
@@ -79,11 +79,11 @@ function getManifestEntry(id, clientManifest) {
     }
     assert(false, debugInfo);
 }
-function findEntryWithKeyEnd(manifestKeyEnd, clientManifest, id) {
-    const debugInfo = getDebugInfo(id, clientManifest, manifestKeyEnd);
+function findEntryWithKeyEnd(manifestKeyEnd, assetsManifest, id) {
+    const debugInfo = getDebugInfo(id, assetsManifest, manifestKeyEnd);
     assert(manifestKeyEnd.startsWith('/'), debugInfo);
     const manifestKeys = [];
-    for (const manifestKey in clientManifest) {
+    for (const manifestKey in assetsManifest) {
         if (manifestKey.endsWith(manifestKeyEnd)) {
             manifestKeys.push(manifestKey);
         }
@@ -94,13 +94,13 @@ function findEntryWithKeyEnd(manifestKeyEnd, clientManifest, id) {
     if (!manifestKey) {
         return { manifestEntry: null, manifestKey: null };
     }
-    const manifestEntry = clientManifest[manifestKey];
+    const manifestEntry = assetsManifest[manifestKey];
     return { manifestEntry, manifestKey };
 }
-function getEntryWithKeyEnd(manifestKeyEnd, clientManifest, id) {
-    const debugInfo = getDebugInfo(id, clientManifest, manifestKeyEnd);
+function getEntryWithKeyEnd(manifestKeyEnd, assetsManifest, id) {
+    const debugInfo = getDebugInfo(id, assetsManifest, manifestKeyEnd);
     const manifestKeys = [];
-    for (const manifestKey in clientManifest) {
+    for (const manifestKey in assetsManifest) {
         if (manifestKey.endsWith(manifestKeyEnd)) {
             manifestKeys.push(manifestKey);
         }
@@ -110,11 +110,11 @@ function getEntryWithKeyEnd(manifestKeyEnd, clientManifest, id) {
     if (!manifestKey) {
         return { manifestEntry: null, manifestKey: null };
     }
-    const manifestEntry = clientManifest[manifestKey];
+    const manifestEntry = assetsManifest[manifestKey];
     return { manifestEntry, manifestKey };
 }
-function getDebugInfo(id, clientManifest, manifestKeyEnd) {
-    const manifestKeys = Object.keys(clientManifest);
+function getDebugInfo(id, assetsManifest, manifestKeyEnd) {
+    const manifestKeys = Object.keys(assetsManifest);
     if (manifestKeyEnd === undefined) {
         return { manifestKeys, id };
     }

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

@@ -1,4 +1,4 @@
 export { retrieveAssetsProd };
 import type { ViteManifest } from '../../../shared/ViteManifest.js';
 import type { ClientDependency } from '../../../../shared/getPageFiles/analyzePageClientSide/ClientDependency.js';
-declare function retrieveAssetsProd(clientDependencies: ClientDependency[], clientManifest: ViteManifest, includeAssetsImportedByServer: boolean): string[];
+declare function retrieveAssetsProd(clientDependencies: ClientDependency[], assetsManifest: ViteManifest, includeAssetsImportedByServer: boolean): string[];

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

@@ -2,9 +2,9 @@ export { retrieveAssetsProd };
 import { assert, isNpmPackageImport } from '../../utils.js';
 import { getManifestEntry } from './getManifestEntry.js';
 import { extractAssetsAddQuery } from '../../../shared/extractAssetsQuery.js';
-function retrieveAssetsProd(clientDependencies, clientManifest, includeAssetsImportedByServer) {
+function retrieveAssetsProd(clientDependencies, assetsManifest, includeAssetsImportedByServer) {
     let assetUrls = new Set();
-    assert(clientManifest);
+    assert(assetsManifest);
     const visistedAssets = new Set();
     clientDependencies.forEach(({ id, onlyAssets, eagerlyImported }) => {
         if (eagerlyImported)
@@ -19,17 +19,17 @@ function retrieveAssetsProd(clientDependencies, clientManifest, includeAssetsImp
                 id = extractAssetsAddQuery(id);
             }
         }
-        const { manifestKey } = getManifestEntry(id, clientManifest);
-        collectAssets(manifestKey, assetUrls, visistedAssets, clientManifest, onlyAssets);
+        const { manifestKey } = getManifestEntry(id, assetsManifest);
+        collectAssets(manifestKey, assetUrls, visistedAssets, assetsManifest, onlyAssets);
     });
-    collectSingleStyle(assetUrls, clientManifest);
+    collectSingleStyle(assetUrls, assetsManifest);
     return Array.from(assetUrls);
 }
-function collectAssets(manifestKey, assetUrls, visistedAssets, manifest, onlyCollectStaticAssets) {
+function collectAssets(manifestKey, assetUrls, visistedAssets, assetsManifest, onlyCollectStaticAssets) {
     if (visistedAssets.has(manifestKey))
         return;
     visistedAssets.add(manifestKey);
-    const manifestEntry = manifest[manifestKey];
+    const manifestEntry = assetsManifest[manifestKey];
     assert(manifestEntry, { manifestKey });
     const { file } = manifestEntry;
     if (!onlyCollectStaticAssets) {
@@ -37,9 +37,9 @@ function collectAssets(manifestKey, assetUrls, visistedAssets, manifest, onlyCol
     }
     const { imports = [], assets = [], css = [] } = manifestEntry;
     for (const manifestKey of imports) {
-        const importManifestEntry = manifest[manifestKey];
+        const importManifestEntry = assetsManifest[manifestKey];
         assert(importManifestEntry);
-        collectAssets(manifestKey, assetUrls, visistedAssets, manifest, onlyCollectStaticAssets);
+        collectAssets(manifestKey, assetUrls, visistedAssets, assetsManifest, onlyCollectStaticAssets);
     }
     for (const cssAsset of css) {
         assetUrls.add(`/${cssAsset}`);
@@ -49,9 +49,9 @@ function collectAssets(manifestKey, assetUrls, visistedAssets, manifest, onlyCol
     }
 }
 // Support `config.build.cssCodeSplit: false`, see https://github.com/vikejs/vike/issues/644
-function collectSingleStyle(assetUrls, manifest) {
-    const style = manifest['style.css'];
-    if (style && Object.values(manifest).filter((asset) => asset.file.endsWith('.css')).length === 1) {
+function collectSingleStyle(assetUrls, assetsManifest) {
+    const style = assetsManifest['style.css'];
+    if (style && Object.values(assetsManifest).filter((asset) => asset.file.endsWith('.css')).length === 1) {
         assetUrls.add(`/${style.file}`);
     }
 }

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

@@ -19,9 +19,9 @@ async function getPageAssets(pageContext, clientDependencies, clientEntries) {
         assetUrls = await retrieveAssetsDev(clientDependencies, viteDevServer);
     }
     else {
-        const { clientManifest } = globalContext;
-        clientEntriesSrc = clientEntries.map((clientEntry) => resolveClientEntriesProd(clientEntry, clientManifest));
-        assetUrls = retrieveAssetsProd(clientDependencies, clientManifest, pageContext._includeAssetsImportedByServer);
+        const { assetsManifest } = globalContext;
+        clientEntriesSrc = clientEntries.map((clientEntry) => resolveClientEntriesProd(clientEntry, assetsManifest));
+        assetUrls = retrieveAssetsProd(clientDependencies, assetsManifest, pageContext._includeAssetsImportedByServer);
     }
     let pageAssets = [];
     unique([...clientEntriesSrc, ...assetUrls]).forEach((src) => {
@@ -116,8 +116,8 @@ async function resolveClientEntriesDev(clientEntry, viteDevServer) {
     assertPosixPath(filePath);
     return filePath;
 }
-function resolveClientEntriesProd(clientEntry, clientManifest) {
-    const { manifestEntry } = getManifestEntry(clientEntry, clientManifest);
+function resolveClientEntriesProd(clientEntry, assetsManifest) {
+    const { manifestEntry } = getManifestEntry(clientEntry, assetsManifest);
     assert(manifestEntry.isEntry || manifestEntry.isDynamicEntry || clientEntry.endsWith('.css'), { clientEntry });
     let { file } = manifestEntry;
     assert(!file.startsWith('/'));

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

@@ -3,8 +3,7 @@ export { logErrorHint };
 export { isCjsEsmError };
 export { isKnownError };
 export { getHint };
-import pc from '@brillout/picocolors';
-import { assert, formatHintLog, isNotNullish, isObject, unique, joinEnglish } from '../utils.js';
+import { assert, formatHintLog, isNotNullish, isObject, unique } from '../utils.js';
 const knownErrors = [
     {
         errMsg: 'jsxDEV is not a function',
@@ -13,6 +12,13 @@ const knownErrors = [
     {
         errMsg: 'Element type is invalid: expected a string (for built-in components) or a class/function (for composite components)',
         link: 'https://vike.dev/broken-npm-package#react-invalid-component'
+    },
+    {
+        // ```
+        // Error [RollupError]: Could not resolve "../dist/client/assets.json" from "renderer/+onRenderHtml.tsx"
+        // ```
+        errMsg: 'assets.json',
+        link: 'https://vike.dev/getGlobalContext'
     }
 ];
 function logErrorHint(error) {
@@ -31,15 +37,7 @@ function getHint(error) {
     }
     const res = isCjsEsmError(error);
     if (res) {
-        const packageNames = res === true ? null : res;
-        const hint = [
-            'Error could be a CJS/ESM issue, consider ',
-            !packageNames || packageNames.length === 0
-                ? 'using'
-                : `adding ${joinEnglish(packageNames.map((p) => pc.cyan(p)), 'or')} to`,
-            ` ${pc.cyan('ssr.noExternal')}`,
-            ', see https://vike.dev/broken-npm-package'
-        ].join('');
+        const hint = 'The error seems to be a CJS/ESM issue, see https://vike.dev/broken-npm-package';
         return hint;
     }
     return null;
@@ -70,6 +68,7 @@ function isCjsEsmError(error) {
     packageNames.forEach((packageName) => {
         assert(!['vite', 'vike'].includes(packageName));
     });
+    // We don't use this anymore: we could return `true` instead. Shall we remove returning a list of npm packages?
     return packageNames;
 }
 function normalizeRes(res) {

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

@@ -321,6 +321,9 @@ function normalizeUrl(pageContextInit, httpRequestId) {
     if (disableUrlNormalization)
         return null;
     const { urlOriginal } = pageContextInit;
+    const { isPageContextRequest } = handlePageContextRequestUrl(urlOriginal);
+    if (isPageContextRequest)
+        return null;
     const urlNormalized = normalizeUrlPathname(urlOriginal, trailingSlash, baseServer);
     if (!urlNormalized)
         return null;

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

@@ -75,6 +75,7 @@ type ConfigValueSource = {
     valueIsImportedAtRuntime: boolean;
     /** Whether the config value is a file path, for example config.client */
     valueIsFilePath?: true;
+    valueIsDefinedByValueFile: boolean;
 };
 type DefinedAtFileFullInfo = DefinedAtFile & FilePath & {
     fileExportName?: string;

package/dist/esm/shared/page-configs/serialize/serializeConfigValue.js

@@ -6,8 +6,7 @@ export { serializeConfigValueImported };
 // Both parsePageConfigs() parseConfigValuesImported() and are loaded on the client-side and server-side
 import { assertIsNotProductionRuntime } from '../../../utils/assertIsNotProductionRuntime.js';
 assertIsNotProductionRuntime();
-import path from 'path';
-import { assert, assertPosixPath } from '../../utils.js';
+import { assert } from '../../utils.js';
 import { generateEagerImport } from '../../../node/plugin/plugins/importUserCode/generateEagerImport.js';
 function serializeConfigValue(lines, configName, configValueSerialized) {
     let whitespace = '      ';
@@ -23,13 +22,10 @@ function serializeConfigValue(lines, configName, configValueSerialized) {
 function serializeConfigValueImported(configValueSource, configName, whitespace, varCounterContainer, importStatements) {
     assert(!configValueSource.valueIsFilePath);
     assert(whitespace.replaceAll(' ', '').length === 0);
-    const { valueIsImportedAtRuntime, definedAt } = configValueSource;
+    const { valueIsImportedAtRuntime, valueIsDefinedByValueFile, definedAt } = configValueSource;
     assert(valueIsImportedAtRuntime);
     const { filePathAbsoluteVite, fileExportName } = definedAt;
-    assertPosixPath(filePathAbsoluteVite);
-    const fileName = path.posix.basename(filePathAbsoluteVite);
-    const isValueFile = fileName.startsWith('+');
-    if (isValueFile)
+    if (valueIsDefinedByValueFile)
         assert(fileExportName === undefined);
     const { importName, importStatement } = generateEagerImport(filePathAbsoluteVite, varCounterContainer.varCounter++, fileExportName);
     importStatements.push(importStatement);
@@ -37,8 +33,8 @@ function serializeConfigValueImported(configValueSource, configName, whitespace,
     lines.push(`  {`);
     lines.push(`    configName: '${configName}',`);
     lines.push(`    importPath: '${filePathAbsoluteVite}',`);
-    lines.push(`    isValueFile: ${JSON.stringify(isValueFile)},`);
-    if (isValueFile) {
+    lines.push(`    isValueFile: ${JSON.stringify(valueIsDefinedByValueFile)},`);
+    if (valueIsDefinedByValueFile) {
         lines.push(`    exportValues: ${importName},`);
     }
     else {

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

@@ -1,7 +1,7 @@
 export { projectInfo };
 export { PROJECT_VERSION };
-declare const PROJECT_VERSION: "0.4.162";
+declare const PROJECT_VERSION: "0.4.163-commit-407cb5c";
 declare const projectInfo: {
     projectName: "Vike";
-    projectVersion: "0.4.162";
+    projectVersion: "0.4.163-commit-407cb5c";
 };

package/dist/esm/utils/projectInfo.js

@@ -1,7 +1,7 @@
 export { projectInfo };
 export { PROJECT_VERSION };
 import { onProjectInfo } from './assertSingleInstance.js';
-const PROJECT_VERSION = '0.4.162';
+const PROJECT_VERSION = '0.4.163-commit-407cb5c';
 const projectInfo = {
     projectName: 'Vike',
     projectVersion: PROJECT_VERSION

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vike",
-  "version": "0.4.162",
+  "version": "0.4.163-commit-407cb5c",
   "scripts": {
     "dev": "tsc --watch",
     "build": "rimraf dist/ && pnpm run build:esm && pnpm run build:cjs",
@@ -169,6 +169,7 @@
     "vike": "./node/cli/bin-entry.js"
   },
   "devDependencies": {
+    "@biomejs/biome": "^1.5.3",
     "@brillout/import": "^0.2.3",
     "@brillout/json-serializer": "^0.5.8",
     "@brillout/picocolors": "^1.0.10",