vike 0.4.195 → 0.4.196

package/dist/cjs/utils/throttle.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.throttle = void 0;
+exports.throttle = throttle;
 function throttle(func, waitTime) {
     let isQueued = false;
     return () => {
@@ -13,4 +13,3 @@ function throttle(func, waitTime) {
         }
     };
 }
-exports.throttle = throttle;

package/dist/cjs/utils/trimWithAnsi.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.trimWithAnsiTrailOnly = exports.trimWithAnsi = void 0;
+exports.trimWithAnsi = trimWithAnsi;
+exports.trimWithAnsiTrailOnly = trimWithAnsiTrailOnly;
 const assert_js_1 = require("./assert.js");
 const stripAnsi_js_1 = require("./stripAnsi.js");
 const whitespaceRegex = /(\s+)/; // Capturing parathesis so that split preserves seperator
@@ -10,14 +11,12 @@ function trimWithAnsi(str) {
     str = trimWithAnsiTrailOnly(str);
     return str;
 }
-exports.trimWithAnsi = trimWithAnsi;
 function trimWithAnsiHead(str) {
     return trim(str, false);
 }
 function trimWithAnsiTrailOnly(str) {
     return trim(str, true);
 }
-exports.trimWithAnsiTrailOnly = trimWithAnsiTrailOnly;
 function trim(str, trail) {
     let parts = str.split(whitespaceRegex);
     if (trail)

package/dist/cjs/utils/truncateString.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.truncateString = void 0;
+exports.truncateString = truncateString;
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const assert_js_1 = require("./assert.js");
 function truncateString(str, lenMax) {
@@ -21,4 +21,3 @@ function truncateString(str, lenMax) {
         return str;
     }
 }
-exports.truncateString = truncateString;

package/dist/cjs/utils/unique.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.unique = void 0;
+exports.unique = unique;
 function unique(arr) {
     return Array.from(new Set(arr));
 }
-exports.unique = unique;

package/dist/cjs/utils/urlToFile.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.baseServer = exports.urlToFile = void 0;
+exports.baseServer = void 0;
+exports.urlToFile = urlToFile;
 const assert_js_1 = require("./assert.js");
 const parseUrl_js_1 = require("./parseUrl.js");
 const slice_js_1 = require("./slice.js");
@@ -33,4 +34,3 @@ function urlToFile(url, fileExtension, doNotCreateExtraDirectory) {
     const fileUrl = `${pathnameModified}${searchOriginal || ''}${hashOriginal || ''}`;
     return fileUrl;
 }
-exports.urlToFile = urlToFile;

package/dist/cjs/utils/virtual-files.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveVirtualFileId = exports.getVirtualFileId = exports.isVirtualFileId = void 0;
+exports.isVirtualFileId = isVirtualFileId;
+exports.getVirtualFileId = getVirtualFileId;
+exports.resolveVirtualFileId = resolveVirtualFileId;
 const assert_js_1 = require("./assert.js");
 const idBase = 'virtual:vike:';
 // https://vitejs.dev/guide/api-plugin.html#virtual-modules-convention
@@ -13,7 +15,6 @@ function isVirtualFileId(id) {
     (0, assert_js_1.assert)(!id.includes(idBase));
     return false;
 }
-exports.isVirtualFileId = isVirtualFileId;
 function getVirtualFileId(id) {
     if (id.startsWith(tag)) {
         id = id.slice(tag.length);
@@ -21,7 +22,6 @@ function getVirtualFileId(id) {
     (0, assert_js_1.assert)(!id.startsWith(tag));
     return id;
 }
-exports.getVirtualFileId = getVirtualFileId;
 function resolveVirtualFileId(id) {
     (0, assert_js_1.assert)(isVirtualFileId(id));
     if (!id.startsWith(tag)) {
@@ -30,4 +30,3 @@ function resolveVirtualFileId(id) {
     (0, assert_js_1.assert)(id.startsWith(tag));
     return id;
 }
-exports.resolveVirtualFileId = resolveVirtualFileId;

package/dist/cjs/utils/viteIsSSR.js

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.viteIsSSR_options = exports.viteIsSSR = void 0;
+exports.viteIsSSR = viteIsSSR;
+exports.viteIsSSR_options = viteIsSSR_options;
 const assert_js_1 = require("./assert.js");
 const isObject_js_1 = require("./isObject.js");
 function viteIsSSR(config) {
     return !!config?.build?.ssr;
 }
-exports.viteIsSSR = viteIsSSR;
 // https://github.com/vitejs/vite/discussions/5109#discussioncomment-1450726
 function viteIsSSR_options(options) {
     if (options === undefined) {
@@ -20,4 +20,3 @@ function viteIsSSR_options(options) {
     }
     (0, assert_js_1.assert)(false);
 }
-exports.viteIsSSR_options = viteIsSSR_options;

package/dist/cjs/utils/warnIfErrorIsNotObject.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.warnIfErrorIsNotObject = void 0;
+exports.warnIfErrorIsNotObject = warnIfErrorIsNotObject;
 const assert_js_1 = require("./assert.js");
 const assertIsNotBrowser_js_1 = require("./assertIsNotBrowser.js");
 const isObject_js_1 = require("./isObject.js");
@@ -21,4 +21,3 @@ function warnIfErrorIsNotObject(err) {
         (0, assert_js_1.assertWarning)(false, `One of your hooks threw an error ${picocolors_1.default.cyan('throw someValue')} but ${picocolors_1.default.cyan('someValue')} isn't an object (it's ${picocolors_1.default.cyan(`typeof someValue === ${typeof err}`)} instead). Make sure thrown values are always wrapped with ${picocolors_1.default.cyan('new Error()')}, in other words: ${picocolors_1.default.cyan('throw someValue')} should be replaced with ${picocolors_1.default.cyan('throw new Error(someValue)')}. The thrown value is printed above.`, { onlyOnce: false });
     }
 }
-exports.warnIfErrorIsNotObject = warnIfErrorIsNotObject;

package/dist/esm/client/client-routing-runtime/installClientRouter.js

@@ -16,15 +16,13 @@ async function installClientRouter() {
     // Preserve stack track
     await renderPromise;
 }
-function render() {
+async function render() {
     assert(getRenderCount() === 0);
-    const renderPromise = renderPageClientSide({
+    await renderPageClientSide({
         scrollTarget: { preserveScroll: true },
         isBackwardNavigation: null,
         isClientSideNavigation: false
     });
-    assert(getRenderCount() === 1);
-    return renderPromise;
 }
 function initHistoryAndScroll() {
     setupNativeScrollRestoration();

package/dist/esm/client/client-routing-runtime/isClientSideRoutable.js

@@ -7,6 +7,6 @@ async function isClientSideRoutable(pageId, pageContext) {
         sharedPageFilesAlreadyLoaded: false
     });
     const pageConfig = findPageConfig(pageContext._pageConfigs, pageId);
-    const { clientEntryLoaded, isClientRouting } = analyzeClientSide(pageConfig, pageContext._pageFilesAll, pageId);
-    return clientEntryLoaded && isClientRouting;
+    const { isClientRuntimeLoaded, isClientRouting } = analyzeClientSide(pageConfig, pageContext._pageFilesAll, pageId);
+    return isClientRuntimeLoaded && isClientRouting;
 }

package/dist/esm/client/client-routing-runtime/navigate.js

@@ -1,6 +1,6 @@
 export { navigate };
 export { reload };
-import { renderPageClientSide } from './renderPageClientSide.js';
+import { firstRenderStartPromise, renderPageClientSide } from './renderPageClientSide.js';
 import { assertClientRouting, assertUsageUrlPathname, getCurrentUrl } from './utils.js';
 assertClientRouting();
 /** Programmatically navigate to a new page.
@@ -13,6 +13,8 @@ assertClientRouting();
  */
 async function navigate(url, { keepScrollPosition = false, overwriteLastHistoryEntry = false } = {}) {
     assertUsageUrlPathname(url, '[navigate(url)] url');
+    // If `hydrationCanBeAborted === false` (e.g. Vue) then we can apply navigate() only after hydration is done
+    await firstRenderStartPromise;
     const scrollTarget = { preserveScroll: keepScrollPosition };
     await renderPageClientSide({
         scrollTarget,

package/dist/esm/client/client-routing-runtime/renderPageClientSide.d.ts

@@ -1,8 +1,10 @@
 export { renderPageClientSide };
 export { getRenderCount };
 export { disableClientRouting };
+export { firstRenderStartPromise };
 import { type PageContextFromRewrite } from '../../shared/route/abort.js';
 import { type ScrollTarget } from './setScrollPosition.js';
+declare const firstRenderStartPromise: Promise<void>;
 type RenderArgs = {
     scrollTarget: ScrollTarget;
     isBackwardNavigation: boolean | null;

package/dist/esm/client/client-routing-runtime/renderPageClientSide.js

@@ -1,7 +1,8 @@
 export { renderPageClientSide };
 export { getRenderCount };
 export { disableClientRouting };
-import { assert, getCurrentUrl, isSameErrorMessage, objectAssign, redirectHard, getGlobalObject, executeHook, hasProp, augmentType } from './utils.js';
+export { firstRenderStartPromise };
+import { assert, getCurrentUrl, isSameErrorMessage, objectAssign, redirectHard, getGlobalObject, executeHook, hasProp, augmentType, genPromise } from './utils.js';
 import { getPageContextFromHooks_isHydration, getPageContextFromHooks_isNotHydration, getPageContextFromHooks_serialized } from './getPageContextFromHooks.js';
 import { createPageContext } from './createPageContext.js';
 import { addLinkPrefetchHandlers } from './prefetch.js';
@@ -17,7 +18,15 @@ import { setScrollPosition } from './setScrollPosition.js';
 import { updateState } from './onBrowserHistoryNavigation.js';
 import { browserNativeScrollRestoration_disable, setInitialRenderIsDone } from './scrollRestoration.js';
 import { getErrorPageId } from '../../shared/error-page.js';
-const globalObject = getGlobalObject('renderPageClientSide.ts', { renderCounter: 0 });
+const globalObject = getGlobalObject('renderPageClientSide.ts', (() => {
+    const { promise: firstRenderStartPromise, resolve: firstRenderStartPromiseResolve } = genPromise();
+    return {
+        renderCounter: 0,
+        firstRenderStartPromise,
+        firstRenderStartPromiseResolve
+    };
+})());
+const { firstRenderStartPromise } = globalObject;
 async function renderPageClientSide(renderArgs) {
     const { scrollTarget, urlOriginal = getCurrentUrl(), overwriteLastHistoryEntry = false, isBackwardNavigation, pageContextsFromRewrite = [], redirectCount = 0, isUserLandPushStateNavigation, isClientSideNavigation = true } = renderArgs;
     const { previousPageContext } = globalObject;
@@ -31,6 +40,9 @@ async function renderPageClientSide(renderArgs) {
         redirectHard(urlOriginal);
         return;
     }
+    globalObject.firstRenderStartPromiseResolve();
+    if (isRenderOutdated())
+        return;
     await renderPageNominal();
     return;
     async function renderPageNominal() {
@@ -81,20 +93,27 @@ async function renderPageClientSide(renderArgs) {
             }
             if (isRenderOutdated())
                 return;
-            let isClientRoutable;
             if (!pageContextFromRoute._pageId) {
-                isClientRoutable = false;
-            }
-            else {
-                isClientRoutable = await isClientSideRoutable(pageContextFromRoute._pageId, pageContext);
-                if (isRenderOutdated())
-                    return;
+                /*
+                // We don't use the client router to render the 404 page:
+                //  - So that the +redirects setting (https://vike.dev/redirects) can be applied.
+                //    - This is the main argument.
+                //    - See also failed CI: https://github.com/vikejs/vike/pull/1871
+                //  - So that server-side error tracking can track 404 links?
+                //    - We do use the client router for rendering the error page, so I don't think this is much of an argument.
+                await renderErrorPage({ is404: true })
+                */
+                redirectHard(urlOriginal);
+                return;
             }
+            assert(hasProp(pageContextFromRoute, '_pageId', 'string')); // Help TS
+            const isClientRoutable = await isClientSideRoutable(pageContextFromRoute._pageId, pageContext);
+            if (isRenderOutdated())
+                return;
             if (!isClientRoutable) {
                 redirectHard(urlOriginal);
                 return;
             }
-            assert(hasProp(pageContextFromRoute, '_pageId', 'string')); // Help TS
             const isSamePage = pageContextFromRoute._pageId &&
                 previousPageContext?._pageId &&
                 pageContextFromRoute._pageId === previousPageContext._pageId;
@@ -208,9 +227,10 @@ async function renderPageClientSide(renderArgs) {
         const pageContext = await getPageContextBegin();
         if (isRenderOutdated())
             return;
-        if (args.pageContextError) {
+        if (args.is404)
+            objectAssign(pageContext, { is404: true });
+        if (args.pageContextError)
             objectAssign(pageContext, args.pageContextError);
-        }
         if ('err' in args) {
             const { err } = args;
             assert(!('errorWhileRendering' in pageContext));
@@ -266,6 +286,13 @@ async function renderPageClientSide(renderArgs) {
         objectAssign(pageContext, {
             _pageId: errorPageId
         });
+        const isClientRoutable = await isClientSideRoutable(pageContext._pageId, pageContext);
+        if (isRenderOutdated())
+            return;
+        if (!isClientRoutable) {
+            redirectHard(urlOriginal);
+            return;
+        }
         try {
             objectAssign(pageContext, await loadUserFilesClientSide(pageContext._pageId, pageContext._pageFilesAll, pageContext._pageConfigs));
         }

package/dist/esm/client/client-routing-runtime/skipLink.js

@@ -34,7 +34,7 @@ function isHashUrl(url) {
         return true;
     }
     const removeHash = (url) => url.split('#')[0];
-    if (url.includes('#') && removeHash(url) === removeHash(window.location.href)) {
+    if (url.includes('#') && removeHash(url) === removeHash(window.location.pathname)) {
         return true;
     }
     return false;

package/dist/esm/client/client-routing-runtime/utils.d.ts

@@ -22,3 +22,4 @@ export * from '../../utils/assertRoutingType.js';
 export * from '../../utils/onPageVisibilityChange.js';
 export * from '../../utils/augmentType.js';
 export * from '../../utils/PROJECT_VERSION.js';
+export * from '../../utils/genPromise.js';

package/dist/esm/client/client-routing-runtime/utils.js

@@ -28,3 +28,4 @@ export * from '../../utils/assertRoutingType.js';
 export * from '../../utils/onPageVisibilityChange.js';
 export * from '../../utils/augmentType.js';
 export * from '../../utils/PROJECT_VERSION.js';
+export * from '../../utils/genPromise.js';

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

@@ -1,105 +1,127 @@
 export { fileEnv };
-import { assert, assertUsage, assertWarning, capitalizeFirstLetter } from '../utils.js';
+import { assert, assertUsage, assertWarning, capitalizeFirstLetter, joinEnglish } from '../utils.js';
 import { extractAssetsRE } from './extractAssetsPlugin.js';
 import { extractExportNamesRE } from './extractExportNamesPlugin.js';
 import pc from '@brillout/picocolors';
 import { getModuleFilePathAbsolute } from '../shared/getFilePath.js';
+import { sourceMapRemove } from '../shared/rollupSourceMap.js';
+import { getExportNames } from '../shared/parseEsModule.js';
 function fileEnv() {
     let config;
-    let isDev = false;
+    let viteDevServer;
     return {
         name: 'vike:fileEnv',
-        // - We need to set `enforce: 'pre'` because, otherwise, the resolvedId() hook of Vite's internal plugin `vite:resolve` is called before and it doesn't seem to call `this.resolve()` which means that the resolveId() hook below is never called.
-        //   - Vite's `vite:resolve` plugin: https://github.com/vitejs/vite/blob/d649daba7682791178b711d9a3e44a6b5d00990c/packages/vite/src/node/plugins/resolve.ts#L105
-        // - It's actually a good thing if the resolveId() hook below is the first one to be called because it doesn't actually resolve any ID, so all other resolveId() hooks will be called as normal. And with `this.resolve()` we get the information we want from all other resolvedId() hooks.
-        // - Path aliases are already resolved, even when using `enforce: 'pre'`. For example:
-        //   ```js
-        //   // /pages/index/+Page.tsx
-        //
-        //   // The value of `source` is `/home/rom/code/vike/examples/path-aliases/components/Counter` (instead of `#root/components/Counter`)
-        //   // The value of `importer` is `/home/rom/code/vike/examples/path-aliases/pages/index/+Page.tsx`
-        //   import { Counter } from '#root/components/Counter'
-        //   ```
-        enforce: 'pre',
-        resolveId: {
-            /* I don't know why, but path aliases aren't resolved anymore when setting `order: 'pre'`. (In principle, I'd assume that `this.resolve()` would resolve the alias but it doesn't.)
-            order: 'pre',
-            */
-            async handler(source, importer, options) {
-                // It seems like Vite's scan doesn't apply transformers. (We need the `.telefunc.js` transformer to apply for our analysis to be correct.)
-                // @ts-expect-error Vite's type is wrong
-                if (options.scan)
-                    return;
-                // TODO/v1-release: remove
-                if (extractAssetsRE.test(source) || extractExportNamesRE.test(source))
-                    return;
-                // Seems like Vite is doing some funky stuff here.
-                if (importer?.endsWith('.html'))
-                    return;
-                const resolved = await this.resolve(source, importer, {
-                    // Needed for old Vite plugins: https://vitejs.dev/guide/migration#rollup-4:~:text=For%20Vite%20plugins%2C%20this.resolve%20skipSelf%20option%20is%20now%20true%20by%20default.
-                    skipSelf: true,
-                    ...options
-                });
-                // resolved is null when import path is erroneous and doesn't actually point to a file
-                if (!resolved)
-                    return;
-                const moduleId = resolved.id;
-                const modulePath = moduleId.split('?')[0];
-                // `.server.js` and `.client.js` should only apply to user files
-                if (modulePath.includes('/node_modules/'))
-                    return;
-                // TODO/v1-release: remove
-                // - I don't remember exactly, but I think I've added `TODO/v1-release: remove` because I vaguely remember that we can remove this after we remove the 0.4 design.
-                if (modulePath.endsWith('.css'))
-                    return;
-                const isServerSide = options?.ssr;
-                const envActual = isServerSide ? 'server' : 'client';
-                const envExpect = isServerSide ? 'client' : 'server';
-                const suffix = `.${envExpect}.`;
-                // Everything is good
-                if (!modulePath.includes(suffix))
+        load(id, options) {
+            // In build, we use generateBundle() instead of the load() hook. Using load() works for dynamic imports in dev thanks to Vite's lazy transpiling, but it doesn't work in build because Rollup transpiles any dynamically imported module even if it's never actually imported.
+            if (!viteDevServer)
+                return;
+            if (skip(id))
+                return;
+            const moduleInfo = viteDevServer.moduleGraph.getModuleById(id);
+            assert(moduleInfo);
+            const importers = Array.from(moduleInfo.importers)
+                .map((m) => m.id)
+                .filter((id) => id !== null);
+            assertFileEnv(id, !!options?.ssr, importers, 
+            // In dev, we only show a warning because we don't want to disrupt when the user plays with settings such as [ssr](https://vike.dev/ssr).
+            true);
+        },
+        // In production, we have to use transform() to replace modules with a runtime error because generateBundle() doesn't work for dynamic imports. In production, dynamic imports can only be verified at runtime.
+        async transform(code, id, options) {
+            // In dev, only using load() is enough as it also works for dynamic imports (see sibling comment).
+            if (viteDevServer)
+                return;
+            if (skip(id))
+                return;
+            const isServerSide = !!options?.ssr;
+            if (!isWrongEnv(id, isServerSide))
+                return;
+            const { importers } = this.getModuleInfo(id);
+            // Throwing a verbose error doesn't waste client-side KBs as dynamic imports are code splitted.
+            const errMsg = getErrorMessage(id, isServerSide, importers, false, true);
+            // We have to inject empty exports to avoid Rollup complaining about missing exports, see https://gist.github.com/brillout/5ea45776e65bd65100a52ecd7bfda3ff
+            const { exportNames } = await getExportNames(code);
+            return sourceMapRemove([
+                `throw new Error(${JSON.stringify(errMsg)});`,
+                ...exportNames.map((name) => name === 'default' ? 'export default undefined;' : `export const ${name} = undefined;`)
+            ].join('\n'));
+        },
+        generateBundle() {
+            Array.from(this.getModuleIds())
+                .filter((id) => !skip(id))
+                .forEach((moduleId) => {
+                const { importers, dynamicImporters } = this.getModuleInfo(moduleId);
+                if (importers.length === 0) {
+                    // Dynamic imports can only be verified at runtime
+                    assert(dynamicImporters.length > 0);
                     return;
-                // Show error message
-                let errMsg;
-                let modulePathPretty = getModuleFilePathAbsolute(moduleId, config);
-                modulePathPretty = modulePathPretty.replaceAll(suffix, pc.bold(suffix));
-                errMsg = `${capitalizeFirstLetter(envExpect)}-only file ${modulePathPretty} (https://vike.dev/file-env) imported on the ${envActual}-side`;
-                if (importer &&
-                    // Don't show Vike's virtual modules that import the entry plus files such as /pages/about/+Page.js
-                    !importer.includes('virtual:vike:') &&
-                    // I don't know why and who sets importer to '<stdin>' (I guess Vite?)
-                    importer !== '<stdin>') {
-                    const importerPath = getModuleFilePathAbsolute(importer, config);
-                    errMsg += ` by ${importerPath}`;
-                }
-                if (isDev) {
-                    errMsg += ' and, therefore, Vike will prevent building your app for production.';
-                    assertWarning(false, errMsg, { onlyOnce: true });
-                }
-                else {
-                    assertUsage(false, errMsg);
                 }
-            }
+                assertFileEnv(moduleId, !!config.build.ssr, importers, false);
+            });
         },
         configResolved(config_) {
             config = config_;
         },
-        configureServer() {
-            isDev = true;
-        },
-        // Ensure this plugin works
-        transform(_code, id, options) {
-            if (isDev)
-                return;
-            // TODO/v1-release: remove
-            if (extractAssetsRE.test(id) || extractExportNamesRE.test(id))
-                return;
-            if (id.split('?')[0].endsWith('.css'))
-                return;
-            const isServerSide = options?.ssr;
-            const envWrong = isServerSide ? 'client' : 'server';
-            assert(!id.includes(`.${envWrong}.`));
+        configureServer(viteDevServer_) {
+            viteDevServer = viteDevServer_;
         }
     };
+    function assertFileEnv(moduleId, isServerSide, importers, onlyWarn) {
+        if (!isWrongEnv(moduleId, isServerSide))
+            return;
+        const errMsg = getErrorMessage(moduleId, isServerSide, importers, onlyWarn, false);
+        if (onlyWarn) {
+            assertWarning(false, errMsg, { onlyOnce: true });
+        }
+        else {
+            assertUsage(false, errMsg);
+        }
+    }
+    function getErrorMessage(moduleId, isServerSide, importers, onlyWarn, noColor) {
+        const modulePath = getModulePath(moduleId);
+        const envActual = isServerSide ? 'server' : 'client';
+        const envExpect = isServerSide ? 'client' : 'server';
+        let errMsg;
+        let modulePathPretty = getModuleFilePathAbsolute(modulePath, config);
+        if (!noColor) {
+            const suffix = getSuffix(envExpect);
+            modulePathPretty = modulePathPretty.replaceAll(suffix, pc.bold(suffix));
+        }
+        errMsg = `${capitalizeFirstLetter(envExpect)}-only file ${modulePathPretty} (https://vike.dev/file-env) imported on the ${envActual}-side`;
+        if (importers.length > 0) {
+            const importPaths = importers.map((importer) => getModuleFilePathAbsolute(importer, config));
+            errMsg += ` by ${joinEnglish(importPaths, 'and')}`;
+        }
+        if (onlyWarn) {
+            errMsg += ' and, therefore, Vike will prevent building your app for production.';
+        }
+        return errMsg;
+    }
+    function isWrongEnv(moduleId, isServerSide) {
+        const modulePath = getModulePath(moduleId);
+        const suffixWrong = getSuffix(isServerSide ? 'client' : 'server');
+        return modulePath.includes(suffixWrong);
+    }
+    function skip(id) {
+        // TODO/v1-release: remove
+        if (extractAssetsRE.test(id) || extractExportNamesRE.test(id))
+            return true;
+        if (!id.includes(getSuffix('client')) && !id.includes(getSuffix('server')))
+            return true;
+        if (getModulePath(id).endsWith('.css'))
+            return true;
+        // Apply `.server.js` and `.client.js` only to user files
+        if (id.includes('/node_modules/'))
+            return true;
+        // Only user files
+        if (!id.startsWith(config.root))
+            return true;
+        return false;
+    }
+    function getSuffix(env) {
+        return `.${env}.`;
+    }
+    function getModulePath(moduleId) {
+        return moduleId.split('?')[0];
+    }
 }

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

@@ -72,7 +72,6 @@ ${await getVirtualFilePageConfigs(isForClientSide, isDev, id, isClientRouting, c
     fileTypes
         .filter((fileType) => fileType !== '.css')
         .forEach((fileType) => {
-        assert(fileType !== '.css');
         const { includeImport, includeExportNames } = determineInjection({
             fileType,
             isForClientSide,

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

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

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

@@ -28,7 +28,7 @@ const configDefinitionsBuiltIn = {
         env: { server: true, client: true }
     },
     passToClient: {
-        env: { server: true, config: true },
+        env: { server: true },
         cumulative: true
     },
     route: {
@@ -76,7 +76,11 @@ const configDefinitionsBuiltIn = {
     meta: {
         env: { config: true }
     },
-    clientEntryLoaded: {
+    // Whether the page loads:
+    //  - Vike's client runtime
+    //  - User's client hooks
+    // In other words, whether the page is "HTML-only" (https://vike.dev/render-modes). HTML-only pages shouldn't load the client runtime nor client hooks.
+    isClientRuntimeLoaded: {
         env: { server: true, client: true },
         eager: true,
         _computed: (configValueSources) => {

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

@@ -176,12 +176,11 @@ async function transpileWithEsbuild(filePath, userRootDir, transformImports) {
                     }
                     if (debug.isActivated)
                         debug('onResolved()', { args, resolved, importPathTranspiled, isPointerImport, isExternal });
-                    pointerImports[importPathTranspiled] = isPointerImport;
                     if (isExternal) {
+                        pointerImports[importPathTranspiled] = isPointerImport;
                         return { external: true, path: importPathTranspiled };
                     }
                     else {
-                        resolved.path = importPathTranspiled;
                         return resolved;
                     }
                 });

package/dist/esm/node/runtime/html/stream.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" resolution-mode="require"/>
 export { processStream };
 export { streamToString };
 export { stampPipe };

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

@@ -13,5 +13,5 @@ export * from '../../types/index-dreprecated.js';
  * See https://vike.dev/render
  */
 export declare const RenderErrorPage: (args_0?: {
-    pageContext?: Record<string, unknown> | undefined;
+    pageContext?: Record<string, unknown>;
 } | undefined) => Error;