vike 0.4.149 → 0.4.150-commit-d9acc70

package/dist/cjs/node/plugin/plugins/commonConfig/assertResolveAlias.js

@@ -40,6 +40,9 @@ function assertResolveAlias(config) {
             // Allow un-distinguishable aliases set by @preact/preset-vite
             if (find.startsWith('react'))
                 return;
+            // Allow un-distinguishable aliases set by @vitejs/plugin-vue2 https://github.com/vikejs/vike/issues/1329
+            if (find === 'vue')
+                return;
             {
                 const msg = `${errPrefix} defines an invalid ${picocolors_1.default.cyan('resolve.alias')}: a path alias cannot be the empty string ${picocolors_1.default.cyan("''")}`;
                 (0, utils_js_1.assertUsage)(find !== '', msg);

package/dist/cjs/node/plugin/plugins/importBuild/index.js

@@ -32,19 +32,17 @@ function importBuild() {
 }
 exports.importBuild = importBuild;
 function getImporterCode(config, pageFilesEntry) {
-    const filePathAbsolute = (0, utils_js_1.toPosixPath)(
-    // [RELATIVE_PATH_FROM_DIST] Current file: node_modules/vike/dist/esm/node/plugin/plugins/importBuild/index.js
-    require_.resolve(`../../../../../../dist/esm/node/runtime/globalContext/loadImportBuild.js`));
-    const { outDirServer } = (0, utils_js_1.getOutDirs)(config);
-    const filePathRelative = path_1.default.posix.relative(outDirServer, filePathAbsolute);
+    const importPath = getImportPath(config);
     // The only reason we went for using CJS require() instead of ESM import() is because import() doesn't support .json files
     const importerCode = [
         '(async () => {',
-        `  const { setImportBuildGetters } = await import('${filePathRelative}');`,
+        `  const { setImportBuildGetters } = await import('${importPath}');`,
         '  setImportBuildGetters({',
         `    pageFiles: () => import('./${pageFilesEntry}'),`,
-        "    clientManifest: () => require('../assets.json'),",
+        // TODO: rename clientManifest -> assetManifest
+        // TODO: rename PluginManifest -> vikeManifest
         // TODO: use virtual file instead of generating vike.json
+        "    clientManifest: () => require('../assets.json'),",
         "    pluginManifest: () => require('../client/vike.json'),",
         '  });',
         '})()',
@@ -52,3 +50,11 @@ function getImporterCode(config, pageFilesEntry) {
     ].join('\n');
     return importerCode;
 }
+function getImportPath(config) {
+    const filePathAbsolute = (0, utils_js_1.toPosixPath)(
+    // [RELATIVE_PATH_FROM_DIST] Current file: node_modules/vike/dist/esm/node/plugin/plugins/importBuild/index.js
+    require_.resolve(`../../../../../../dist/esm/node/runtime/globalContext/loadImportBuild.js`));
+    const { outDirServer } = (0, utils_js_1.getOutDirs)(config);
+    const filePathRelative = path_1.default.posix.relative(outDirServer, filePathAbsolute);
+    return filePathRelative;
+}

package/dist/cjs/node/plugin/plugins/importUserCode/index.js

@@ -111,7 +111,9 @@ function handleHotUpdate(ctx, config, configVike) {
         return;
     }
     if (isVikeConfig) {
-        (0, utils_js_1.assert)(!isViteModule);
+        /* Tailwind breaks this assertion, see https://github.com/vikejs/vike/discussions/1330#discussioncomment-7787238
+        assert(!isViteModule)
+        */
         reloadConfig(file, config, configVike, 'modified');
         const virtualModules = getVirtualModules(server);
         return virtualModules;

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

@@ -126,5 +126,5 @@ async function isUsingGit(userRootDir) {
 async function runCmd(cmd, cwd) {
     const res = await execA(cmd, { cwd });
     (0, utils_js_1.assert)(res.stderr === '');
-    return res.stdout.toString().trim().split('\n');
+    return res.stdout.toString().split('\n').filter(Boolean);
 }

package/dist/cjs/node/runtime/html/stream.js

@@ -200,7 +200,9 @@ exports.pipeToStreamWritableNode = pipeToStreamWritableNode;
 async function processStream(streamOriginal, { injectStringAtBegin, injectStringAtEnd, onErrorWhileStreaming, enableEagerStreaming }) {
     const buffer = [];
     let streamOriginalHasStartedEmitting = false;
-    let streamEnded = false;
+    let streamOriginalEnded = false;
+    let streamClosed = false;
+    let onEndWasCalled = false;
     let isReadyToWrite = false;
     let wrapperCreated = false;
     let shouldFlushStream = false;
@@ -224,6 +226,14 @@ async function processStream(streamOriginal, { injectStringAtBegin, injectString
         writeStream(injectionBegin); // Adds injectionBegin to buffer
         flushStream(); // Sets shouldFlushStream to true
     }
+    // We call onStreamEvent() also when the stream ends in order to properly handle the situation when the stream didn't emit any data
+    const onStreamDataOrEnd = (cb) => {
+        (0, utils_js_1.assert)(streamOriginalEnded === false);
+        streamOriginalHasStartedEmitting = true;
+        cb();
+        if (wrapperCreated)
+            resolvePromise();
+    };
     const { streamWrapper, streamWrapperOperations } = await createStreamWrapper({
         streamOriginal,
         onReadyToWrite() {
@@ -241,19 +251,21 @@ async function processStream(streamOriginal, { injectStringAtBegin, injectString
             }
         },
         onData(chunk) {
-            (0, utils_js_1.assert)(streamEnded === false);
-            streamOriginalHasStartedEmitting = true;
-            writeStream(chunk);
-            if (wrapperCreated)
-                resolvePromise();
+            onStreamDataOrEnd(() => {
+                writeStream(chunk);
+            });
         },
-        async onEnd() {
+        async onEnd(
+        // Should we use this `isCancel`? Maybe we can skip `injectStringAtEnd()`?
+        isCancel) {
             try {
+                (0, utils_js_1.assert)(!onEndWasCalled);
+                onEndWasCalled = true;
                 debug('stream end');
-                streamEnded = true;
-                streamOriginalHasStartedEmitting = true; // In case original stream (stream provided by user) emits no data
-                if (wrapperCreated)
-                    resolvePromise(); //    In case original stream (stream provided by user) emits no data
+                // We call onStreamEvent() also here in case the stream didn't emit any data
+                onStreamDataOrEnd(() => {
+                    streamOriginalEnded = true;
+                });
                 if (injectStringAtEnd) {
                     const injectEnd = await injectStringAtEnd();
                     writeStream(injectEnd);
@@ -261,10 +273,12 @@ async function processStream(streamOriginal, { injectStringAtBegin, injectString
                 await promiseReadyToWrite; // E.g. if the user calls the pipe wrapper after the original writable has ended
                 (0, utils_js_1.assert)(isReady());
                 flushBuffer();
+                streamClosed = true;
                 debug('stream ended');
             }
             catch (err) {
-                // We should catch and gracefully handle user land errors, as any error thrown here kills the server
+                // Ideally, we should catch and gracefully handle user land errors, as any error thrown here kills the server. (I assume that the fact it kills the server is a Node.js bug?)
+                // Show "[vike][Bug] You stumbled upon a bug in Vike's source code" to user while printing original error
                 if (!(0, utils_js_1.isBug)(err)) {
                     console.error(err);
                     (0, utils_js_1.assert)(false);
@@ -288,6 +302,7 @@ async function processStream(streamOriginal, { injectStringAtBegin, injectString
     function flushBuffer() {
         if (!isReady())
             return;
+        (0, utils_js_1.assert)(!streamClosed);
         buffer.forEach((chunk) => {
             streamWrapperOperations.writeChunk(chunk);
         });
@@ -485,6 +500,17 @@ async function createStreamWrapper({ streamOriginal, onError, onData, onEnd, onF
     if (isStreamReadableWeb(streamOriginal)) {
         debug('onRenderHtml() hook returned Web Readable');
         const readableOriginal = streamOriginal;
+        let controllerProxyIsClosed = false;
+        let isClosed = false;
+        let isCancel = false;
+        const closeStream = async () => {
+            if (isClosed)
+                return;
+            isClosed = true;
+            await onEnd(isCancel);
+            controllerProxy.close();
+            controllerProxyIsClosed = true;
+        };
         let controllerProxy;
         assertReadableStreamConstructor();
         const readableProxy = new ReadableStream({
@@ -498,16 +524,30 @@ async function createStreamWrapper({ streamOriginal, onError, onData, onEnd, onF
                         controllerProxy.close();
                     },
                     async onEnd() {
-                        await onEnd();
-                        controllerProxy.close();
+                        await closeStream();
                     }
                 });
+            },
+            async cancel(...args) {
+                isCancel = true;
+                await readableOriginal.cancel(...args);
+                // If readableOriginal has implemented readableOriginal.cancel() then the onEnd() callback and therfore closeStream() may already have been called at this point
+                await closeStream();
             }
         });
         const writeChunk = (chunk) => {
-            controllerProxy.enqueue(encodeForWebStream(chunk));
-            if (debug.isEnabled) {
-                debug('data written (Web Readable)', String(chunk));
+            if (
+            // If readableOriginal doesn't implement readableOriginal.cancel() then it may still emit data after we close the stream. We therefore need to check whether we closed `controllerProxy`.
+            !controllerProxyIsClosed) {
+                controllerProxy.enqueue(encodeForWebStream(chunk));
+                if (debug.isEnabled) {
+                    debug('data written (Web Readable)', String(chunk));
+                }
+            }
+            else {
+                if (debug.isEnabled) {
+                    debug('data emitted but not written (Web Readable)', String(chunk));
+                }
             }
         };
         // Readables don't have the notion of flushing

package/dist/cjs/node/runtime/index-deprecated.js

@@ -20,6 +20,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RenderErrorPage = void 0;
+const isBrowser_js_1 = require("../../utils/isBrowser.js");
+const assert_js_1 = require("../../utils/assert.js");
+(0, assert_js_1.assertUsage)(!(0, isBrowser_js_1.isBrowser)(), "It's forbidden to `import { something } from 'vike'` on the client-side: the module 'vike' is a server-only module.", { showStackTrace: true });
 __exportStar(require("./index-common.js"), exports);
 __exportStar(require("../../types/index-dreprecated.js"), exports);
 const utils_js_1 = require("./utils.js");
@@ -57,5 +60,3 @@ exports.RenderErrorPage = RenderErrorPage;
     picocolors_1.default.green("  import type { something } from 'vike/types'"),
     "Make sure to import renderPage(), escapeInject, html, dangerouslySkipEscape(), pipeWebStream(), pipeNodeStream(), pipeStream(), stampPipe() from 'vike/server'. (Or inspect the error stack below to find the import causing this warning.)"
 ].join('\n'), { showStackTrace: true, onlyOnce: true });
-const utils_js_2 = require("./utils.js");
-(0, utils_js_2.assertUsage)(!(0, utils_js_2.isBrowser)(), "It's forbidden to `import { something } from 'vike'` in code loaded in the browser: the module 'vike' is a server-only module.", { showStackTrace: true });

package/dist/cjs/node/runtime/index.js

@@ -14,6 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+const isBrowser_js_1 = require("../../utils/isBrowser.js");
+const assert_js_1 = require("../../utils/assert.js");
+(0, assert_js_1.assertUsage)(!(0, isBrowser_js_1.isBrowser)(), "It's forbidden to `import { something } from 'vike/server'` on the client-side: the module 'vike/server' is a server-only module.", { showStackTrace: true });
 __exportStar(require("./index-common.js"), exports);
-const utils_js_1 = require("./utils.js");
-(0, utils_js_1.assertUsage)(!(0, utils_js_1.isBrowser)(), "It's forbidden to `import { something } from 'vike/server'` in code loaded on the client-side: the module 'vike/server' is a server-only module.", { showStackTrace: true });

package/dist/cjs/node/runtime/renderPage/getHttpResponseBody.js

@@ -76,7 +76,7 @@ function getHttpResponseBodyStreamHandlers(htmlRender, renderHook) {
                     return;
                 }
                 else {
-                    (0, utils_js_1.assert)((0, stream_js_1.isStreamReadableWeb)(htmlRender) || (0, stream_js_1.isStreamPipeWeb)(htmlRender));
+                    (0, utils_js_1.assert)((0, stream_js_1.isStreamReadableNode)(htmlRender) || (0, stream_js_1.isStreamPipeNode)(htmlRender));
                     (0, utils_js_1.assertUsage)(false, getErrMsgMixingStreamTypes('Web Writable'));
                 }
             }
@@ -86,7 +86,7 @@ function getHttpResponseBodyStreamHandlers(htmlRender, renderHook) {
                     return;
                 }
                 else {
-                    (0, utils_js_1.assert)((0, stream_js_1.isStreamReadableNode)(htmlRender) || (0, stream_js_1.isStreamPipeNode)(htmlRender));
+                    (0, utils_js_1.assert)((0, stream_js_1.isStreamReadableWeb)(htmlRender) || (0, stream_js_1.isStreamPipeWeb)(htmlRender));
                     (0, utils_js_1.assertUsage)(false, getErrMsgMixingStreamTypes('Node.js Writable'));
                 }
             }

package/dist/cjs/node/runtime/renderPage/getPageAssets/retrieveAssetsDev.js

@@ -40,13 +40,21 @@ function collectCss(mod, styleUrls, visitedModules, importer) {
         if (mod.url.startsWith('/')) {
             styleUrls.add(mod.url);
         }
+        else if (mod.url.startsWith('\0')) {
+            // Virtual modules
+            //  - https://vitejs.dev/guide/api-plugin.html#virtual-modules-convention
+            //    - I believe some Vite plugins don't respect the \0 virtual module convention. What should we do then?
+            //  - https://github.com/vikejs/vike/issues/1327
+            //  - https://github.com/vikejs/vike/commit/3f7b9916dddc84e29e2c20d2b0df7211b6f1acbd
+            styleUrls.add(`/@id/${mod.url.substring(1)}`);
+        }
         else {
-            // Vuetify uses virtual SCSS modules which we skip
-            //  - We skip because `<link rel="stylesheet" type="text/css" href="virtual-module.css">` doesn't work
-            //  - Reproduction: https://github.com/vikejs/vike/issues/479
-            //  - Possible workaround: `<script>import 'virtual-module.css'</script>`
-            // logModule(mod)
+            // Is this useful? Maybe for virtual modules that don't respect the \0 virtual module convention?
+            styleUrls.add(`/@id/${mod.url}`);
         }
+        /* Debug:
+        logModule(mod)
+        //*/
     }
     mod.importedModules.forEach((dep) => {
         collectCss(dep, styleUrls, visitedModules, mod);

package/dist/cjs/node/runtime/renderPage/getPageAssets/sortPageAssetsForEarlyHintsHeader.js

@@ -22,6 +22,12 @@ function sortPageAssetsForEarlyHintsHeader(pageAssets) {
         if (assetType === 'image')
             return priority;
         priority--;
+        if (assetType === 'video')
+            return priority;
+        priority--;
+        if (assetType === 'audio')
+            return priority;
+        priority--;
         // Others
         if (assetType !== 'script')
             return priority;

package/dist/cjs/node/runtime/renderPage/inferMediaType.js

@@ -36,6 +36,44 @@ function inferMediaType(href) {
     if (href.endsWith('.woff2')) {
         return { assetType: 'font', mediaType: 'font/woff2' };
     }
+    // Videos
+    if (href.endsWith('.mp4')) {
+        return { assetType: 'video', mediaType: 'video/mp4' };
+    }
+    if (href.endsWith('.webm')) {
+        return { assetType: 'video', mediaType: 'video/webm' };
+    }
+    if (href.endsWith('.ogv')) {
+        return { assetType: 'video', mediaType: 'video/ogg' };
+    }
+    if (href.endsWith('.mpeg') || href.endsWith('.mpg')) {
+        return { assetType: 'video', mediaType: 'video/mpeg' };
+    }
+    if (href.endsWith('.avi')) {
+        return { assetType: 'video', mediaType: 'video/x-msvideo' };
+    }
+    if (href.endsWith('.mov') || href.endsWith('.qt')) {
+        return { assetType: 'video', mediaType: 'video/quicktime' };
+    }
+    // Audios
+    if (href.endsWith('.mp3')) {
+        return { assetType: 'audio', mediaType: 'audio/mpeg' };
+    }
+    if (href.endsWith('.wav')) {
+        return { assetType: 'audio', mediaType: 'audio/wav' };
+    }
+    if (href.endsWith('.ogg')) {
+        return { assetType: 'audio', mediaType: 'audio/ogg' };
+    }
+    if (href.endsWith('.m4a')) {
+        return { assetType: 'audio', mediaType: 'audio/aac' };
+    }
+    if (href.endsWith('midi') || href.endsWith('.mid')) {
+        return { assetType: 'audio', mediaType: 'audio/midi' };
+    }
+    if (href.endsWith('.flac')) {
+        return { assetType: 'audio', mediaType: 'audio/flac' };
+    }
     return null;
 }
 exports.inferMediaType = inferMediaType;

package/dist/cjs/shared/page-configs/assertExports.js

@@ -34,13 +34,20 @@ function assertExports(fileExports, filePathToShowToUser, configName) {
         if (exportsRelevant.length === 1) {
             return;
         }
-        else {
-            (0, utils_js_1.assert)(exportsRelevant.length === 0);
-            let errMsg = `${filePathToShowToUser} doesn't export any value, but it should have a ${picocolors_1.default.cyan('export default')}`;
+        const exportDefault = picocolors_1.default.cyan('export default');
+        const exportConfigName = picocolors_1.default.cyan(`export { ${configName} }`);
+        if (exportsRelevant.length === 0) {
+            let errMsg = `${filePathToShowToUser} doesn't export any value, but it should have a ${exportDefault}`;
             if (configName)
-                errMsg += ` or ${picocolors_1.default.cyan(`export { ${configName} }`)}`;
+                errMsg += ` or ${exportConfigName}`;
             (0, utils_js_1.assertUsage)(false, errMsg);
         }
+        else {
+            (0, utils_js_1.assert)(exportsRelevant.length === 2);
+            (0, utils_js_1.assertWarning)(false, `${filePathToShowToUser} remove ${exportConfigName} or ${exportDefault}`, {
+                onlyOnce: true
+            });
+        }
     }
     else {
         // !configName => isConfigFile

package/dist/cjs/shared/route/resolveRedirects.js

@@ -7,6 +7,7 @@ exports.resolveRouteStringRedirect = exports.resolveRedirects = void 0;
 const assertIsNotBrowser_js_1 = require("../../utils/assertIsNotBrowser.js");
 const parseUrl_extras_js_1 = require("../../utils/parseUrl-extras.js");
 const utils_js_1 = require("../utils.js");
+const resolveUrlPathname_js_1 = require("./resolveUrlPathname.js");
 const resolveRouteString_js_1 = require("./resolveRouteString.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 (0, assertIsNotBrowser_js_1.assertIsNotBrowser)(); // Don't bloat the client
@@ -31,16 +32,7 @@ function resolveRouteStringRedirect(urlSource, urlTarget, urlPathname) {
     const match = (0, resolveRouteString_js_1.resolveRouteString)(urlSource, urlPathname);
     if (!match)
         return null;
-    let urlResolved = urlTarget;
-    Object.entries(match.routeParams).forEach(([key, val]) => {
-        if (key !== '*') {
-            key = `@${key}`;
-        }
-        urlResolved = urlResolved.replaceAll(key, val);
-    });
-    if (!urlResolved.startsWith('mailto:')) {
-        (0, utils_js_1.assertUsage)(!urlResolved.includes('@'), 'URL should not contain "@" unless it is a mailto link.');
-    }
+    const urlResolved = (0, resolveUrlPathname_js_1.resolveUrlPathname)(urlTarget, match.routeParams);
     if (urlResolved === urlPathname)
         return null;
     (0, utils_js_1.assert)(urlResolved.startsWith('/') || (0, parseUrl_extras_js_1.isUriWithProtocol)(urlResolved));

package/dist/cjs/shared/route/resolveUrlPathname.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveUrlPathname = void 0;
+const assertIsNotBrowser_js_1 = require("../../utils/assertIsNotBrowser.js");
+const utils_js_1 = require("../utils.js");
+(0, assertIsNotBrowser_js_1.assertIsNotBrowser)(); // Don't bloat the client
+/** Given a `routeString` and `routeParams`, resolve `urlPathname`.
+ *
+ * Basically, the correct implementation of following:
+ * ```js
+ * let urlPathname = routeString
+ * Object.entries(routeParams).forEach(([key, val]) => {
+ *   urlPathname = urlPathname.replaceAll(key, val)
+ * })
+ * ```
+ */
+function resolveUrlPathname(routeString, routeParams) {
+    let parts = [{ val: routeString, type: 'ROUTE_STRING' }];
+    Object.entries(routeParams).forEach(([key, val]) => {
+        if (key.startsWith('*')) {
+            (0, utils_js_1.assert)(key === '*' || /\d+/.test(key.slice(1)));
+            (0, utils_js_1.assertUsage)(key === '*', "Resolving URL with multiple globs isn't implemented yet");
+        }
+        else {
+            key = `@${key}`;
+        }
+        parts = parts
+            .map((part) => {
+            if (part.type === 'URL') {
+                return part;
+            }
+            else {
+                return part.val
+                    .split(key)
+                    .map((rest, i) => {
+                    const partURL = { val, type: 'URL' };
+                    const partRouteString = { val: rest, type: 'ROUTE_STRING' };
+                    return i === 0 ? [partRouteString] : [partURL, partRouteString];
+                })
+                    .flat();
+            }
+        })
+            .flat();
+    });
+    const urlPathname = parts.map((p) => p.val).join('');
+    return urlPathname;
+}
+exports.resolveUrlPathname = resolveUrlPathname;

package/dist/cjs/utils/debug.js

@@ -12,22 +12,10 @@ const getTerminWidth_js_1 = require("./getTerminWidth.js");
 globalThis.__brillout_debug_createDebugger = createDebugger;
 function createDebugger(namespace, optionsGlobal) {
     (0, checkType_js_1.checkType)(namespace);
-    const debugWithOptions = (options) => {
+    const debugWithOptions = (optionsLocal) => {
         return (...msgs) => {
-            if (!isDebugEnabled(namespace))
-                return;
-            let [msgFirst, ...msgsRest] = msgs;
-            const padding = ' '.repeat(namespace.length + 1);
-            const optionsResolved = { ...optionsGlobal, ...options };
-            msgFirst = formatMsg(msgFirst, optionsResolved, padding, 'FIRST');
-            msgsRest = msgsRest.map((msg, i) => {
-                const position = i === msgsRest.length - 1 ? 'LAST' : 'MIDDLE';
-                return formatMsg(msg, optionsResolved, padding, position);
-            });
-            console.log('\x1b[1m%s\x1b[0m', namespace, msgFirst);
-            msgsRest.forEach((msg) => {
-                console.log(msg);
-            });
+            const options = { ...optionsGlobal, ...optionsLocal };
+            debug_(namespace, options, ...msgs);
         };
     };
     const debug = (...msgs) => debugWithOptions({})(...msgs);
@@ -35,6 +23,32 @@ function createDebugger(namespace, optionsGlobal) {
     return debug;
 }
 exports.createDebugger = createDebugger;
+function debug_(namespace, options, ...msgs) {
+    if (!isDebugEnabled(namespace))
+        return;
+    let [msgFirst, ...msgsRest] = msgs;
+    const padding = ' '.repeat(namespace.length + 1);
+    msgFirst = formatMsg(msgFirst, options, padding, 'FIRST');
+    msgsRest = msgsRest.map((msg, i) => {
+        const position = i === msgsRest.length - 1 ? 'LAST' : 'MIDDLE';
+        return formatMsg(msg, options, padding, position);
+    });
+    let logFirst;
+    let logsRest;
+    const noNewLine = msgsRest.length <= 1 && [msgFirst, ...msgsRest].every((m) => typeof m === 'string' && !m.includes('\n'));
+    if (noNewLine) {
+        logFirst = [msgFirst, ...msgsRest].map((m) => String(m).trim());
+        logsRest = [];
+    }
+    else {
+        logFirst = [msgFirst];
+        logsRest = msgsRest;
+    }
+    console.log('\x1b[1m%s\x1b[0m', namespace, ...logFirst);
+    logsRest.forEach((msg) => {
+        console.log(msg);
+    });
+}
 function isDebugEnabled(namespace) {
     (0, checkType_js_1.checkType)(namespace);
     let DEBUG;

package/dist/cjs/utils/getOutDirs.js

@@ -9,7 +9,10 @@ const assert_js_1 = require("./assert.js");
 const path_shim_js_1 = require("./path-shim.js");
 const filesystemPathHandling_js_1 = require("./filesystemPathHandling.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+const debug_js_1 = require("./debug.js");
+const debug = (0, debug_js_1.createDebugger)('vike:outDir');
 function getOutDirs(config) {
+    debug('getOutDirs()', new Error().stack);
     let outDirRoot;
     {
         const outDir = getOutDirFromViteResolvedConfig(config);
@@ -23,12 +26,17 @@ function getOutDirs(config) {
             outDirRoot = outDir.slice(0, -1 * '/client'.length);
         }
     }
-    return getOutDirsAll(outDirRoot, config.root);
+    const outDirs = getOutDirsAll(outDirRoot, config.root);
+    debug('outDirRoot', outDirRoot);
+    debug('outDirs', outDirs);
+    return outDirs;
 }
 exports.getOutDirs = getOutDirs;
 /** Appends `client/` or `server/` to `config.build.outDir` */
 function resolveOutDir(config) {
+    debug('resolveOutDir()', new Error().stack);
     const outDir = getOutDirFromViteUserConfig(config) || 'dist';
+    debug('outDir', 'outDir');
     // outDir may already be resolved when using Telefunc + vike (because both Telefunc and vike use this logic)
     if (!isOutDirRoot(outDir)) {
         assertOutDirResolved(outDir, config);
@@ -37,9 +45,11 @@ function resolveOutDir(config) {
     else {
         const { outDirClient, outDirServer } = determineOutDirs(outDir);
         if ((0, viteIsSSR_js_1.viteIsSSR)(config)) {
+            debug('outDirServer', 'outDirServer');
             return outDirServer;
         }
         else {
+            debug('outDirClient', 'outDirClient');
             return outDirClient;
         }
     }

package/dist/cjs/utils/projectInfo.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PROJECT_VERSION = exports.projectInfo = void 0;
 const assertSingleInstance_js_1 = require("./assertSingleInstance.js");
-const PROJECT_VERSION = '0.4.149';
+const PROJECT_VERSION = '0.4.150-commit-d9acc70';
 exports.PROJECT_VERSION = PROJECT_VERSION;
 const projectInfo = {
     projectName: 'Vike',

package/dist/esm/node/plugin/plugins/commonConfig/assertResolveAlias.js

@@ -35,6 +35,9 @@ function assertResolveAlias(config) {
             // Allow un-distinguishable aliases set by @preact/preset-vite
             if (find.startsWith('react'))
                 return;
+            // Allow un-distinguishable aliases set by @vitejs/plugin-vue2 https://github.com/vikejs/vike/issues/1329
+            if (find === 'vue')
+                return;
             {
                 const msg = `${errPrefix} defines an invalid ${pc.cyan('resolve.alias')}: a path alias cannot be the empty string ${pc.cyan("''")}`;
                 assertUsage(find !== '', msg);

package/dist/esm/node/plugin/plugins/importBuild/index.js

@@ -26,19 +26,17 @@ function importBuild() {
     ];
 }
 function getImporterCode(config, pageFilesEntry) {
-    const filePathAbsolute = toPosixPath(
-    // [RELATIVE_PATH_FROM_DIST] Current file: node_modules/vike/dist/esm/node/plugin/plugins/importBuild/index.js
-    require_.resolve(`../../../../../../dist/esm/node/runtime/globalContext/loadImportBuild.js`));
-    const { outDirServer } = getOutDirs(config);
-    const filePathRelative = path.posix.relative(outDirServer, filePathAbsolute);
+    const importPath = getImportPath(config);
     // The only reason we went for using CJS require() instead of ESM import() is because import() doesn't support .json files
     const importerCode = [
         '(async () => {',
-        `  const { setImportBuildGetters } = await import('${filePathRelative}');`,
+        `  const { setImportBuildGetters } = await import('${importPath}');`,
         '  setImportBuildGetters({',
         `    pageFiles: () => import('./${pageFilesEntry}'),`,
-        "    clientManifest: () => require('../assets.json'),",
+        // TODO: rename clientManifest -> assetManifest
+        // TODO: rename PluginManifest -> vikeManifest
         // TODO: use virtual file instead of generating vike.json
+        "    clientManifest: () => require('../assets.json'),",
         "    pluginManifest: () => require('../client/vike.json'),",
         '  });',
         '})()',
@@ -46,3 +44,11 @@ function getImporterCode(config, pageFilesEntry) {
     ].join('\n');
     return importerCode;
 }
+function getImportPath(config) {
+    const filePathAbsolute = toPosixPath(
+    // [RELATIVE_PATH_FROM_DIST] Current file: node_modules/vike/dist/esm/node/plugin/plugins/importBuild/index.js
+    require_.resolve(`../../../../../../dist/esm/node/runtime/globalContext/loadImportBuild.js`));
+    const { outDirServer } = getOutDirs(config);
+    const filePathRelative = path.posix.relative(outDirServer, filePathAbsolute);
+    return filePathRelative;
+}

package/dist/esm/node/plugin/plugins/importUserCode/index.js

@@ -105,7 +105,9 @@ function handleHotUpdate(ctx, config, configVike) {
         return;
     }
     if (isVikeConfig) {
-        assert(!isViteModule);
+        /* Tailwind breaks this assertion, see https://github.com/vikejs/vike/discussions/1330#discussioncomment-7787238
+        assert(!isViteModule)
+        */
         reloadConfig(file, config, configVike, 'modified');
         const virtualModules = getVirtualModules(server);
         return virtualModules;

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

@@ -1,5 +1,5 @@
 export declare const debug: ((...msgs: unknown[]) => void) & {
-    options: (options: {
+    options: (optionsLocal: {
         serialization?: {
             emptyArray?: string | undefined;
         } | undefined;

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

@@ -120,5 +120,5 @@ async function isUsingGit(userRootDir) {
 async function runCmd(cmd, cwd) {
     const res = await execA(cmd, { cwd });
     assert(res.stderr === '');
-    return res.stdout.toString().trim().split('\n');
+    return res.stdout.toString().split('\n').filter(Boolean);
 }

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

@@ -205,7 +205,9 @@ function pipeToStreamWritableNode(htmlRender, writable) {
 async function processStream(streamOriginal, { injectStringAtBegin, injectStringAtEnd, onErrorWhileStreaming, enableEagerStreaming }) {
     const buffer = [];
     let streamOriginalHasStartedEmitting = false;
-    let streamEnded = false;
+    let streamOriginalEnded = false;
+    let streamClosed = false;
+    let onEndWasCalled = false;
     let isReadyToWrite = false;
     let wrapperCreated = false;
     let shouldFlushStream = false;
@@ -229,6 +231,14 @@ async function processStream(streamOriginal, { injectStringAtBegin, injectString
         writeStream(injectionBegin); // Adds injectionBegin to buffer
         flushStream(); // Sets shouldFlushStream to true
     }
+    // We call onStreamEvent() also when the stream ends in order to properly handle the situation when the stream didn't emit any data
+    const onStreamDataOrEnd = (cb) => {
+        assert(streamOriginalEnded === false);
+        streamOriginalHasStartedEmitting = true;
+        cb();
+        if (wrapperCreated)
+            resolvePromise();
+    };
     const { streamWrapper, streamWrapperOperations } = await createStreamWrapper({
         streamOriginal,
         onReadyToWrite() {
@@ -246,19 +256,21 @@ async function processStream(streamOriginal, { injectStringAtBegin, injectString
             }
         },
         onData(chunk) {
-            assert(streamEnded === false);
-            streamOriginalHasStartedEmitting = true;
-            writeStream(chunk);
-            if (wrapperCreated)
-                resolvePromise();
+            onStreamDataOrEnd(() => {
+                writeStream(chunk);
+            });
         },
-        async onEnd() {
+        async onEnd(
+        // Should we use this `isCancel`? Maybe we can skip `injectStringAtEnd()`?
+        isCancel) {
             try {
+                assert(!onEndWasCalled);
+                onEndWasCalled = true;
                 debug('stream end');
-                streamEnded = true;
-                streamOriginalHasStartedEmitting = true; // In case original stream (stream provided by user) emits no data
-                if (wrapperCreated)
-                    resolvePromise(); //    In case original stream (stream provided by user) emits no data
+                // We call onStreamEvent() also here in case the stream didn't emit any data
+                onStreamDataOrEnd(() => {
+                    streamOriginalEnded = true;
+                });
                 if (injectStringAtEnd) {
                     const injectEnd = await injectStringAtEnd();
                     writeStream(injectEnd);
@@ -266,10 +278,12 @@ async function processStream(streamOriginal, { injectStringAtBegin, injectString
                 await promiseReadyToWrite; // E.g. if the user calls the pipe wrapper after the original writable has ended
                 assert(isReady());
                 flushBuffer();
+                streamClosed = true;
                 debug('stream ended');
             }
             catch (err) {
-                // We should catch and gracefully handle user land errors, as any error thrown here kills the server
+                // Ideally, we should catch and gracefully handle user land errors, as any error thrown here kills the server. (I assume that the fact it kills the server is a Node.js bug?)
+                // Show "[vike][Bug] You stumbled upon a bug in Vike's source code" to user while printing original error
                 if (!isBug(err)) {
                     console.error(err);
                     assert(false);
@@ -293,6 +307,7 @@ async function processStream(streamOriginal, { injectStringAtBegin, injectString
     function flushBuffer() {
         if (!isReady())
             return;
+        assert(!streamClosed);
         buffer.forEach((chunk) => {
             streamWrapperOperations.writeChunk(chunk);
         });
@@ -489,6 +504,17 @@ async function createStreamWrapper({ streamOriginal, onError, onData, onEnd, onF
     if (isStreamReadableWeb(streamOriginal)) {
         debug('onRenderHtml() hook returned Web Readable');
         const readableOriginal = streamOriginal;
+        let controllerProxyIsClosed = false;
+        let isClosed = false;
+        let isCancel = false;
+        const closeStream = async () => {
+            if (isClosed)
+                return;
+            isClosed = true;
+            await onEnd(isCancel);
+            controllerProxy.close();
+            controllerProxyIsClosed = true;
+        };
         let controllerProxy;
         assertReadableStreamConstructor();
         const readableProxy = new ReadableStream({
@@ -502,16 +528,30 @@ async function createStreamWrapper({ streamOriginal, onError, onData, onEnd, onF
                         controllerProxy.close();
                     },
                     async onEnd() {
-                        await onEnd();
-                        controllerProxy.close();
+                        await closeStream();
                     }
                 });
+            },
+            async cancel(...args) {
+                isCancel = true;
+                await readableOriginal.cancel(...args);
+                // If readableOriginal has implemented readableOriginal.cancel() then the onEnd() callback and therfore closeStream() may already have been called at this point
+                await closeStream();
             }
         });
         const writeChunk = (chunk) => {
-            controllerProxy.enqueue(encodeForWebStream(chunk));
-            if (debug.isEnabled) {
-                debug('data written (Web Readable)', String(chunk));
+            if (
+            // If readableOriginal doesn't implement readableOriginal.cancel() then it may still emit data after we close the stream. We therefore need to check whether we closed `controllerProxy`.
+            !controllerProxyIsClosed) {
+                controllerProxy.enqueue(encodeForWebStream(chunk));
+                if (debug.isEnabled) {
+                    debug('data written (Web Readable)', String(chunk));
+                }
+            }
+            else {
+                if (debug.isEnabled) {
+                    debug('data emitted but not written (Web Readable)', String(chunk));
+                }
             }
         };
         // Readables don't have the notion of flushing

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

@@ -1,5 +1,8 @@
 // TODO/v1-release: replace this with:
 // assertUsage(false, "`import { something } from 'vike'` doesn't exist: instead import from 'vike/server', 'vike/client', 'vike/plugin', ...")
+import { isBrowser } from '../../utils/isBrowser.js';
+import { assertUsage } from '../../utils/assert.js';
+assertUsage(!isBrowser(), "It's forbidden to `import { something } from 'vike'` on the client-side: the module 'vike' is a server-only module.", { showStackTrace: true });
 export * from './index-common.js';
 export * from '../../types/index-dreprecated.js';
 import { assertWarning } from './utils.js';
@@ -36,5 +39,3 @@ assertWarning(false, [
     pc.green("  import type { something } from 'vike/types'"),
     "Make sure to import renderPage(), escapeInject, html, dangerouslySkipEscape(), pipeWebStream(), pipeNodeStream(), pipeStream(), stampPipe() from 'vike/server'. (Or inspect the error stack below to find the import causing this warning.)"
 ].join('\n'), { showStackTrace: true, onlyOnce: true });
-import { isBrowser, assertUsage } from './utils.js';
-assertUsage(!isBrowser(), "It's forbidden to `import { something } from 'vike'` in code loaded in the browser: the module 'vike' is a server-only module.", { showStackTrace: true });

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

@@ -1,3 +1,4 @@
+import { isBrowser } from '../../utils/isBrowser.js';
+import { assertUsage } from '../../utils/assert.js';
+assertUsage(!isBrowser(), "It's forbidden to `import { something } from 'vike/server'` on the client-side: the module 'vike/server' is a server-only module.", { showStackTrace: true });
 export * from './index-common.js';
-import { isBrowser, assertUsage } from './utils.js';
-assertUsage(!isBrowser(), "It's forbidden to `import { something } from 'vike/server'` in code loaded on the client-side: the module 'vike/server' is a server-only module.", { showStackTrace: true });

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

@@ -71,7 +71,7 @@ function getHttpResponseBodyStreamHandlers(htmlRender, renderHook) {
                     return;
                 }
                 else {
-                    assert(isStreamReadableWeb(htmlRender) || isStreamPipeWeb(htmlRender));
+                    assert(isStreamReadableNode(htmlRender) || isStreamPipeNode(htmlRender));
                     assertUsage(false, getErrMsgMixingStreamTypes('Web Writable'));
                 }
             }
@@ -81,7 +81,7 @@ function getHttpResponseBodyStreamHandlers(htmlRender, renderHook) {
                     return;
                 }
                 else {
-                    assert(isStreamReadableNode(htmlRender) || isStreamPipeNode(htmlRender));
+                    assert(isStreamReadableWeb(htmlRender) || isStreamPipeWeb(htmlRender));
                     assertUsage(false, getErrMsgMixingStreamTypes('Node.js Writable'));
                 }
             }

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

@@ -37,13 +37,21 @@ function collectCss(mod, styleUrls, visitedModules, importer) {
         if (mod.url.startsWith('/')) {
             styleUrls.add(mod.url);
         }
+        else if (mod.url.startsWith('\0')) {
+            // Virtual modules
+            //  - https://vitejs.dev/guide/api-plugin.html#virtual-modules-convention
+            //    - I believe some Vite plugins don't respect the \0 virtual module convention. What should we do then?
+            //  - https://github.com/vikejs/vike/issues/1327
+            //  - https://github.com/vikejs/vike/commit/3f7b9916dddc84e29e2c20d2b0df7211b6f1acbd
+            styleUrls.add(`/@id/${mod.url.substring(1)}`);
+        }
         else {
-            // Vuetify uses virtual SCSS modules which we skip
-            //  - We skip because `<link rel="stylesheet" type="text/css" href="virtual-module.css">` doesn't work
-            //  - Reproduction: https://github.com/vikejs/vike/issues/479
-            //  - Possible workaround: `<script>import 'virtual-module.css'</script>`
-            // logModule(mod)
+            // Is this useful? Maybe for virtual modules that don't respect the \0 virtual module convention?
+            styleUrls.add(`/@id/${mod.url}`);
         }
+        /* Debug:
+        logModule(mod)
+        //*/
     }
     mod.importedModules.forEach((dep) => {
         collectCss(dep, styleUrls, visitedModules, mod);

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

@@ -20,6 +20,12 @@ function sortPageAssetsForEarlyHintsHeader(pageAssets) {
         if (assetType === 'image')
             return priority;
         priority--;
+        if (assetType === 'video')
+            return priority;
+        priority--;
+        if (assetType === 'audio')
+            return priority;
+        priority--;
         // Others
         if (assetType !== 'script')
             return priority;

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

@@ -1,7 +1,7 @@
 export { inferMediaType };
 export type { MediaType };
 type MediaType = null | {
-    assetType: 'image' | 'script' | 'font' | 'style';
-    mediaType: 'text/javascript' | 'text/css' | 'image/jpeg' | 'image/png' | 'image/webp' | 'image/gif' | 'image/svg+xml' | 'font/ttf' | 'font/woff' | 'font/woff2';
+    assetType: 'image' | 'script' | 'font' | 'style' | 'audio' | 'video' | 'document' | 'fetch' | 'track' | 'worker' | 'embed' | 'object';
+    mediaType: 'text/javascript' | 'text/css' | 'image/jpeg' | 'image/png' | 'image/webp' | 'image/gif' | 'image/svg+xml' | 'font/ttf' | 'font/woff' | 'font/woff2' | 'video/mp4' | 'video/webm' | 'video/ogg' | 'video/mpeg' | 'video/x-msvideo' | 'video/quicktime' | 'audio/mpeg' | 'audio/wav' | 'audio/ogg' | 'audio/aac' | 'audio/midi' | 'audio/flac';
 };
 declare function inferMediaType(href: string): MediaType;

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

@@ -34,5 +34,43 @@ function inferMediaType(href) {
     if (href.endsWith('.woff2')) {
         return { assetType: 'font', mediaType: 'font/woff2' };
     }
+    // Videos
+    if (href.endsWith('.mp4')) {
+        return { assetType: 'video', mediaType: 'video/mp4' };
+    }
+    if (href.endsWith('.webm')) {
+        return { assetType: 'video', mediaType: 'video/webm' };
+    }
+    if (href.endsWith('.ogv')) {
+        return { assetType: 'video', mediaType: 'video/ogg' };
+    }
+    if (href.endsWith('.mpeg') || href.endsWith('.mpg')) {
+        return { assetType: 'video', mediaType: 'video/mpeg' };
+    }
+    if (href.endsWith('.avi')) {
+        return { assetType: 'video', mediaType: 'video/x-msvideo' };
+    }
+    if (href.endsWith('.mov') || href.endsWith('.qt')) {
+        return { assetType: 'video', mediaType: 'video/quicktime' };
+    }
+    // Audios
+    if (href.endsWith('.mp3')) {
+        return { assetType: 'audio', mediaType: 'audio/mpeg' };
+    }
+    if (href.endsWith('.wav')) {
+        return { assetType: 'audio', mediaType: 'audio/wav' };
+    }
+    if (href.endsWith('.ogg')) {
+        return { assetType: 'audio', mediaType: 'audio/ogg' };
+    }
+    if (href.endsWith('.m4a')) {
+        return { assetType: 'audio', mediaType: 'audio/aac' };
+    }
+    if (href.endsWith('midi') || href.endsWith('.mid')) {
+        return { assetType: 'audio', mediaType: 'audio/midi' };
+    }
+    if (href.endsWith('.flac')) {
+        return { assetType: 'audio', mediaType: 'audio/flac' };
+    }
     return null;
 }

package/dist/esm/shared/page-configs/assertExports.js

@@ -28,13 +28,20 @@ function assertExports(fileExports, filePathToShowToUser, configName) {
         if (exportsRelevant.length === 1) {
             return;
         }
-        else {
-            assert(exportsRelevant.length === 0);
-            let errMsg = `${filePathToShowToUser} doesn't export any value, but it should have a ${pc.cyan('export default')}`;
+        const exportDefault = pc.cyan('export default');
+        const exportConfigName = pc.cyan(`export { ${configName} }`);
+        if (exportsRelevant.length === 0) {
+            let errMsg = `${filePathToShowToUser} doesn't export any value, but it should have a ${exportDefault}`;
             if (configName)
-                errMsg += ` or ${pc.cyan(`export { ${configName} }`)}`;
+                errMsg += ` or ${exportConfigName}`;
             assertUsage(false, errMsg);
         }
+        else {
+            assert(exportsRelevant.length === 2);
+            assertWarning(false, `${filePathToShowToUser} remove ${exportConfigName} or ${exportDefault}`, {
+                onlyOnce: true
+            });
+        }
     }
     else {
         // !configName => isConfigFile

package/dist/esm/shared/route/resolveRedirects.js

@@ -4,6 +4,7 @@ export { resolveRouteStringRedirect };
 import { assertIsNotBrowser } from '../../utils/assertIsNotBrowser.js';
 import { isUriWithProtocol } from '../../utils/parseUrl-extras.js';
 import { assert, assertUsage } from '../utils.js';
+import { resolveUrlPathname } from './resolveUrlPathname.js';
 import { assertRouteString, resolveRouteString } from './resolveRouteString.js';
 import pc from '@brillout/picocolors';
 assertIsNotBrowser(); // Don't bloat the client
@@ -27,16 +28,7 @@ function resolveRouteStringRedirect(urlSource, urlTarget, urlPathname) {
     const match = resolveRouteString(urlSource, urlPathname);
     if (!match)
         return null;
-    let urlResolved = urlTarget;
-    Object.entries(match.routeParams).forEach(([key, val]) => {
-        if (key !== '*') {
-            key = `@${key}`;
-        }
-        urlResolved = urlResolved.replaceAll(key, val);
-    });
-    if (!urlResolved.startsWith('mailto:')) {
-        assertUsage(!urlResolved.includes('@'), 'URL should not contain "@" unless it is a mailto link.');
-    }
+    const urlResolved = resolveUrlPathname(urlTarget, match.routeParams);
     if (urlResolved === urlPathname)
         return null;
     assert(urlResolved.startsWith('/') || isUriWithProtocol(urlResolved));

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

@@ -0,0 +1,12 @@
+export { resolveUrlPathname };
+/** Given a `routeString` and `routeParams`, resolve `urlPathname`.
+ *
+ * Basically, the correct implementation of following:
+ * ```js
+ * let urlPathname = routeString
+ * Object.entries(routeParams).forEach(([key, val]) => {
+ *   urlPathname = urlPathname.replaceAll(key, val)
+ * })
+ * ```
+ */
+declare function resolveUrlPathname(routeString: string, routeParams: Record<string, string>): string;

package/dist/esm/shared/route/resolveUrlPathname.js

@@ -0,0 +1,45 @@
+export { resolveUrlPathname };
+import { assertIsNotBrowser } from '../../utils/assertIsNotBrowser.js';
+import { assert, assertUsage } from '../utils.js';
+assertIsNotBrowser(); // Don't bloat the client
+/** Given a `routeString` and `routeParams`, resolve `urlPathname`.
+ *
+ * Basically, the correct implementation of following:
+ * ```js
+ * let urlPathname = routeString
+ * Object.entries(routeParams).forEach(([key, val]) => {
+ *   urlPathname = urlPathname.replaceAll(key, val)
+ * })
+ * ```
+ */
+function resolveUrlPathname(routeString, routeParams) {
+    let parts = [{ val: routeString, type: 'ROUTE_STRING' }];
+    Object.entries(routeParams).forEach(([key, val]) => {
+        if (key.startsWith('*')) {
+            assert(key === '*' || /\d+/.test(key.slice(1)));
+            assertUsage(key === '*', "Resolving URL with multiple globs isn't implemented yet");
+        }
+        else {
+            key = `@${key}`;
+        }
+        parts = parts
+            .map((part) => {
+            if (part.type === 'URL') {
+                return part;
+            }
+            else {
+                return part.val
+                    .split(key)
+                    .map((rest, i) => {
+                    const partURL = { val, type: 'URL' };
+                    const partRouteString = { val: rest, type: 'ROUTE_STRING' };
+                    return i === 0 ? [partRouteString] : [partURL, partRouteString];
+                })
+                    .flat();
+            }
+        })
+            .flat();
+    });
+    const urlPathname = parts.map((p) => p.val).join('');
+    return urlPathname;
+}

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

@@ -1,7 +1,7 @@
 export { createDebugger };
 export { isDebugEnabled };
 export type { Debug };
-type Namespace = 'vike:error' | 'vike:extractAssets' | 'vike:extractExportNames' | 'vike:glob' | 'vike:pageFiles' | 'vike:log' | 'vike:routing' | 'vike:virtual-files' | 'vike:stem' | 'vike:stream';
+type Namespace = 'vike:error' | 'vike:extractAssets' | 'vike:extractExportNames' | 'vike:glob' | 'vike:pageFiles' | 'vike:log' | 'vike:routing' | 'vike:virtual-files' | 'vike:stem' | 'vike:stream' | 'vike:outDir';
 type Debug = ReturnType<typeof createDebugger>;
 type Options = {
     serialization?: {
@@ -9,7 +9,7 @@ type Options = {
     };
 };
 declare function createDebugger(namespace: Namespace, optionsGlobal?: Options): ((...msgs: unknown[]) => void) & {
-    options: (options: Options) => (...msgs: unknown[]) => void;
+    options: (optionsLocal: Options) => (...msgs: unknown[]) => void;
     isEnabled: boolean;
 };
 declare function isDebugEnabled(namespace: Namespace): boolean;

package/dist/esm/utils/debug.js

@@ -11,28 +11,42 @@ assert(!isBrowser());
 globalThis.__brillout_debug_createDebugger = createDebugger;
 function createDebugger(namespace, optionsGlobal) {
     checkType(namespace);
-    const debugWithOptions = (options) => {
+    const debugWithOptions = (optionsLocal) => {
         return (...msgs) => {
-            if (!isDebugEnabled(namespace))
-                return;
-            let [msgFirst, ...msgsRest] = msgs;
-            const padding = ' '.repeat(namespace.length + 1);
-            const optionsResolved = { ...optionsGlobal, ...options };
-            msgFirst = formatMsg(msgFirst, optionsResolved, padding, 'FIRST');
-            msgsRest = msgsRest.map((msg, i) => {
-                const position = i === msgsRest.length - 1 ? 'LAST' : 'MIDDLE';
-                return formatMsg(msg, optionsResolved, padding, position);
-            });
-            console.log('\x1b[1m%s\x1b[0m', namespace, msgFirst);
-            msgsRest.forEach((msg) => {
-                console.log(msg);
-            });
+            const options = { ...optionsGlobal, ...optionsLocal };
+            debug_(namespace, options, ...msgs);
         };
     };
     const debug = (...msgs) => debugWithOptions({})(...msgs);
     objectAssign(debug, { options: debugWithOptions, isEnabled: isDebugEnabled(namespace) });
     return debug;
 }
+function debug_(namespace, options, ...msgs) {
+    if (!isDebugEnabled(namespace))
+        return;
+    let [msgFirst, ...msgsRest] = msgs;
+    const padding = ' '.repeat(namespace.length + 1);
+    msgFirst = formatMsg(msgFirst, options, padding, 'FIRST');
+    msgsRest = msgsRest.map((msg, i) => {
+        const position = i === msgsRest.length - 1 ? 'LAST' : 'MIDDLE';
+        return formatMsg(msg, options, padding, position);
+    });
+    let logFirst;
+    let logsRest;
+    const noNewLine = msgsRest.length <= 1 && [msgFirst, ...msgsRest].every((m) => typeof m === 'string' && !m.includes('\n'));
+    if (noNewLine) {
+        logFirst = [msgFirst, ...msgsRest].map((m) => String(m).trim());
+        logsRest = [];
+    }
+    else {
+        logFirst = [msgFirst];
+        logsRest = msgsRest;
+    }
+    console.log('\x1b[1m%s\x1b[0m', namespace, ...logFirst);
+    logsRest.forEach((msg) => {
+        console.log(msg);
+    });
+}
 function isDebugEnabled(namespace) {
     checkType(namespace);
     let DEBUG;

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

@@ -1,5 +1,5 @@
 export declare const debugGlob: ((...msgs: unknown[]) => void) & {
-    options: (options: {
+    options: (optionsLocal: {
         serialization?: {
             emptyArray?: string | undefined;
         } | undefined;

package/dist/esm/utils/getOutDirs.js

@@ -5,7 +5,10 @@ import { assert, assertUsage } from './assert.js';
 import { pathJoin } from './path-shim.js';
 import { assertPosixPath, toPosixPath } from './filesystemPathHandling.js';
 import pc from '@brillout/picocolors';
+import { createDebugger } from './debug.js';
+const debug = createDebugger('vike:outDir');
 function getOutDirs(config) {
+    debug('getOutDirs()', new Error().stack);
     let outDirRoot;
     {
         const outDir = getOutDirFromViteResolvedConfig(config);
@@ -19,11 +22,16 @@ function getOutDirs(config) {
             outDirRoot = outDir.slice(0, -1 * '/client'.length);
         }
     }
-    return getOutDirsAll(outDirRoot, config.root);
+    const outDirs = getOutDirsAll(outDirRoot, config.root);
+    debug('outDirRoot', outDirRoot);
+    debug('outDirs', outDirs);
+    return outDirs;
 }
 /** Appends `client/` or `server/` to `config.build.outDir` */
 function resolveOutDir(config) {
+    debug('resolveOutDir()', new Error().stack);
     const outDir = getOutDirFromViteUserConfig(config) || 'dist';
+    debug('outDir', 'outDir');
     // outDir may already be resolved when using Telefunc + vike (because both Telefunc and vike use this logic)
     if (!isOutDirRoot(outDir)) {
         assertOutDirResolved(outDir, config);
@@ -32,9 +40,11 @@ function resolveOutDir(config) {
     else {
         const { outDirClient, outDirServer } = determineOutDirs(outDir);
         if (viteIsSSR(config)) {
+            debug('outDirServer', 'outDirServer');
             return outDirServer;
         }
         else {
+            debug('outDirClient', 'outDirClient');
             return outDirClient;
         }
     }

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

@@ -1,13 +1,13 @@
 export { projectInfo };
 export type { ProjectTag };
 export { PROJECT_VERSION };
-declare const PROJECT_VERSION: "0.4.149";
+declare const PROJECT_VERSION: "0.4.150-commit-d9acc70";
 type PackageName = typeof projectInfo.npmPackageName;
 type ProjectVersion = typeof projectInfo.projectVersion;
 type ProjectTag = `[${PackageName}]` | `[${PackageName}@${ProjectVersion}]`;
 declare const projectInfo: {
     projectName: "Vike";
-    projectVersion: "0.4.149";
+    projectVersion: "0.4.150-commit-d9acc70";
     npmPackageName: "vike";
     githubRepository: "https://github.com/vikejs/vike";
 };

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.149';
+const PROJECT_VERSION = '0.4.150-commit-d9acc70';
 const projectInfo = {
     projectName: 'Vike',
     projectVersion: PROJECT_VERSION,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vike",
-  "version": "0.4.149",
+  "version": "0.4.150-commit-d9acc70",
   "scripts": {
     "dev": "tsc --watch",
     "build": "rimraf dist/ && pnpm run build:esm && pnpm run build:cjs",
@@ -162,7 +162,7 @@
     "vike": "./node/cli/bin-entry.js"
   },
   "devDependencies": {
-    "@brillout/release-me": "^0.1.10",
+    "@brillout/release-me": "^0.1.11",
     "@types/estree": "^1.0.0",
     "@types/jest": "^27.4.1",
     "@types/node": "^20.1.0",