vike 0.4.152 → 0.4.153-commit-01ab602

package/dist/esm/client/server-routing-runtime/getPageContext.d.ts

@@ -1,11 +1,11 @@
 export { getPageContext };
 declare function getPageContext(): Promise<{
     _pageId: string;
-    _hasPageContextFromServer: true;
 } & {
     isHydration: true;
     isBackwardNavigation: null;
-    _hasPageContextFromClient: boolean;
+    _hasPageContextFromServer: true;
+    _hasPageContextFromClient: false;
 } & {
     _pageFilesAll: import("../../shared/getPageFiles/getPageFileObject.js").PageFile[];
     _pageConfigs: import("../../shared/page-configs/PageConfig.js").PageConfigRuntime[];

package/dist/esm/client/server-routing-runtime/getPageContext.js

@@ -1,7 +1,7 @@
 import { assertUsage, assertWarning, getCurrentUrl, objectAssign } from './utils.js';
 import { getPageContextSerializedInHtml } from '../shared/getPageContextSerializedInHtml.js';
 import { getPageFilesAll } from '../../shared/getPageFiles.js';
-import { loadPageFilesClientSide } from '../shared/loadPageFilesClientSide.js';
+import { loadUserFilesClientSide } from '../shared/loadUserFilesClientSide.js';
 export { getPageContext };
 const urlFirst = getCurrentUrl({ withoutHash: true });
 async function getPageContext() {
@@ -9,9 +9,10 @@ async function getPageContext() {
     objectAssign(pageContext, {
         isHydration: true,
         isBackwardNavigation: null,
+        _hasPageContextFromServer: true,
         _hasPageContextFromClient: false
     });
-    objectAssign(pageContext, await loadPageFiles(pageContext._pageId));
+    objectAssign(pageContext, await loadPageUserFiles(pageContext._pageId));
     assertPristineUrl();
     return pageContext;
 }
@@ -19,14 +20,14 @@ function assertPristineUrl() {
     const urlCurrent = getCurrentUrl({ withoutHash: true });
     assertUsage(urlFirst === urlCurrent, `The URL was manipulated before the hydration finished ('${urlFirst}' to '${urlCurrent}'). Ensure the hydration has finished before manipulating the URL. Consider using the onHydrationEnd() hook.`);
 }
-async function loadPageFiles(pageId) {
+async function loadPageUserFiles(pageId) {
     const pageContextAddendum = {};
     const { pageFilesAll, pageConfigs } = await getPageFilesAll(true);
     objectAssign(pageContextAddendum, {
         _pageFilesAll: pageFilesAll,
         _pageConfigs: pageConfigs
     });
-    objectAssign(pageContextAddendum, await loadPageFilesClientSide(pageId, pageContextAddendum));
+    objectAssign(pageContextAddendum, await loadUserFilesClientSide(pageId, pageContextAddendum._pageFilesAll, pageContextAddendum._pageConfigs));
     pageFilesAll
         .filter((p) => p.fileType !== '.page.server')
         .forEach((p) => {

package/dist/esm/client/shared/executeOnRenderClientHook.d.ts

@@ -1,11 +1,13 @@
 export { executeOnRenderClientHook };
+export type { PageContextBeforeRenderClient };
 import type { PageFile, PageContextExports } from '../../shared/getPageFiles.js';
 import { type PageContextForUserConsumptionClientSide } from './preparePageContextForUserConsumptionClientSide.js';
 import type { PageConfigRuntime } from '../../shared/page-configs/PageConfig.js';
-declare function executeOnRenderClientHook<PC extends {
+type PageContextBeforeRenderClient = {
     _pageFilesLoaded: PageFile[];
     urlOriginal?: string;
     urlPathname?: string;
     _pageId: string;
     _pageConfigs: PageConfigRuntime[];
-} & PageContextExports & PageContextForUserConsumptionClientSide>(pageContext: PC, isClientRouting: boolean): Promise<void>;
+} & PageContextExports & PageContextForUserConsumptionClientSide;
+declare function executeOnRenderClientHook<PC extends PageContextBeforeRenderClient>(pageContext: PC, isClientRouting: boolean): Promise<void>;

package/dist/esm/client/shared/getPageContextSerializedInHtml.d.ts

@@ -1,5 +1,4 @@
 export { getPageContextSerializedInHtml };
 declare function getPageContextSerializedInHtml(): {
     _pageId: string;
-    _hasPageContextFromServer: true;
 };

package/dist/esm/client/shared/getPageContextSerializedInHtml.js

@@ -1,5 +1,5 @@
 import { parse } from '@brillout/json-serializer/parse';
-import { hasProp, assert, assertUsage, objectAssign } from '../server-routing-runtime/utils.js';
+import { hasProp, assert, assertUsage } from '../server-routing-runtime/utils.js';
 export { getPageContextSerializedInHtml };
 function getPageContextSerializedInHtml() {
     // elem should exist because:
@@ -15,8 +15,5 @@ function getPageContextSerializedInHtml() {
     assert(pageContextJson);
     const pageContextSerializedInHtml = parse(pageContextJson);
     assert(hasProp(pageContextSerializedInHtml, '_pageId', 'string'));
-    objectAssign(pageContextSerializedInHtml, {
-        _hasPageContextFromServer: true
-    });
     return pageContextSerializedInHtml;
 }

package/dist/esm/client/shared/{loadPageFilesClientSide.d.ts → loadUserFilesClientSide.d.ts}

@@ -1,13 +1,14 @@
-export { loadPageFilesClientSide };
+export { loadUserFilesClientSide };
 export { isErrorFetchingStaticAssets };
-export type { PageContextPageFiles };
+export type { PageContextUserFiles };
 import { type PageFile, type PageContextExports } from '../../shared/getPageFiles.js';
 import type { PageConfigRuntime } from '../../shared/page-configs/PageConfig.js';
-type PageContextPageFiles = {
+type PageContextUserFilesLoaded = PageContextExports & {
+    _pageFilesLoaded: PageFile[];
+};
+type PageContextUserFiles = {
     _pageFilesAll: PageFile[];
     _pageConfigs: PageConfigRuntime[];
 };
-declare function loadPageFilesClientSide(pageId: string, pageContext: PageContextPageFiles): Promise<PageContextExports & {
-    _pageFilesLoaded: PageFile[];
-}>;
+declare function loadUserFilesClientSide(pageId: string, pageFilesAll: PageFile[], pageConfigs: PageConfigRuntime[]): Promise<PageContextUserFilesLoaded>;
 declare function isErrorFetchingStaticAssets(err: unknown): boolean;

package/dist/esm/client/shared/{loadPageFilesClientSide.js → loadUserFilesClientSide.js}

@@ -1,12 +1,12 @@
-export { loadPageFilesClientSide };
+export { loadUserFilesClientSide };
 export { isErrorFetchingStaticAssets };
 import { getPageFilesClientSide, getExports } from '../../shared/getPageFiles.js';
 import { findPageConfig } from '../../shared/page-configs/findPageConfig.js';
 import { loadConfigValues } from '../../shared/page-configs/loadConfigValues.js';
 const stamp = '__whileFetchingAssets';
-async function loadPageFilesClientSide(pageId, pageContext) {
-    const pageFilesClientSide = getPageFilesClientSide(pageContext._pageFilesAll, pageId);
-    const pageConfig = findPageConfig(pageContext._pageConfigs, pageId);
+async function loadUserFilesClientSide(pageId, pageFilesAll, pageConfigs) {
+    const pageFilesClientSide = getPageFilesClientSide(pageFilesAll, pageId);
+    const pageConfig = findPageConfig(pageConfigs, pageId);
     let pageConfigLoaded;
     // @ts-ignore Since dist/cjs/client/ is never used, we can ignore this error.
     const isDev = import.meta.env.DEV;

package/dist/esm/node/cli/bin.js

@@ -1,6 +1,6 @@
 import { cac } from 'cac';
 import { resolve } from 'path';
-import { prerenderFromCLI, prerenderForceExit } from '../prerender/runPrerender.js';
+import { runPrerenderFromCLI, runPrerender_forceExit } from '../prerender/runPrerender.js';
 import { projectInfo, assertUsage } from './utils.js';
 const cli = cac(projectInfo.projectName);
 cli
@@ -10,8 +10,8 @@ cli
     assertOptions();
     const { partial, noExtraDir, base, parallel, outDir, configFile } = options;
     const root = options.root && resolve(options.root);
-    await prerenderFromCLI({ partial, noExtraDir, base, root, parallel, outDir, configFile });
-    prerenderForceExit();
+    await runPrerenderFromCLI({ partial, noExtraDir, base, root, parallel, outDir, configFile });
+    runPrerender_forceExit();
 });
 function assertOptions() {
     // Using process.argv because cac convert names to camelCase

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

@@ -23,7 +23,7 @@ import { extensionsAssets } from './plugins/extensionsAssets.js';
 import { baseUrls } from './plugins/baseUrls.js';
 import { envVarsPlugin } from './plugins/envVars.js';
 import pc from '@brillout/picocolors';
-import { assertFileEnv } from './plugins/assertFileEnv.js';
+import { fileEnv } from './plugins/fileEnv.js';
 markEnvAsVite();
 // Return as `any` to avoid Plugin type mismatches when there are multiple Vite versions installed
 function plugin(vikeConfig) {
@@ -46,7 +46,7 @@ function plugin(vikeConfig) {
         extensionsAssets(),
         baseUrls(vikeConfig),
         envVarsPlugin(),
-        assertFileEnv()
+        fileEnv()
     ];
     return plugins;
 }

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

@@ -1,7 +1,7 @@
 export { autoFullBuild };
 import { build } from 'vite';
 import { assertWarning } from '../utils.js';
-import { prerenderFromAutoFullBuild, prerenderForceExit } from '../../prerender/runPrerender.js';
+import { runPrerenderFromAutoFullBuild, runPrerender_forceExit } from '../../prerender/runPrerender.js';
 import { getConfigVike } from '../../shared/getConfigVike.js';
 import { isViteCliCall, getViteConfigFromCli } from '../shared/isViteCliCall.js';
 import pc from '@brillout/picocolors';
@@ -45,7 +45,7 @@ function autoFullBuild() {
                 order: 'post',
                 handler() {
                     if (forceExit) {
-                        prerenderForceExit();
+                        runPrerender_forceExit();
                     }
                 }
             }
@@ -78,7 +78,7 @@ async function triggerFullBuild(config, configVike, bundle) {
         }
     });
     if (configVike.prerender && !configVike.prerender.disableAutoRun) {
-        await prerenderFromAutoFullBuild({ viteConfig: configInline });
+        await runPrerenderFromAutoFullBuild({ viteConfig: configInline });
         forceExit = true;
     }
 }

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

@@ -7,7 +7,7 @@ function envVarsPlugin() {
     let envsAll;
     let config;
     return {
-        name: 'vike:env',
+        name: 'vike:envVars',
         enforce: 'post',
         configResolved(config_) {
             config = config_;

package/dist/esm/node/plugin/plugins/fileEnv.d.ts

@@ -0,0 +1,3 @@
+export { fileEnv };
+import type { Plugin } from 'vite';
+declare function fileEnv(): Plugin;

package/dist/esm/node/plugin/plugins/{assertFileEnv.js → fileEnv.js}

@@ -1,13 +1,13 @@
-export { assertFileEnv };
+export { fileEnv };
 import { assert, assertUsage, assertWarning, capitalizeFirstLetter, getFilePathRelativeToUserRootDir } from '../utils.js';
 import { extractAssetsRE } from './extractAssetsPlugin.js';
 import { extractExportNamesRE } from './extractExportNamesPlugin.js';
 import pc from '@brillout/picocolors';
-function assertFileEnv() {
+function fileEnv() {
     let config;
     let isDev = false;
     return {
-        name: 'vike:assertFileEnv',
+        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.

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

@@ -45,7 +45,7 @@ function getEntryCode(config, configVike) {
         '  setImportBuildGetters({',
         `    pageFiles: () => pageFiles,`,
         // TODO: rename clientManifest -> assetManifest
-        `    clientManifest: () => { return ${ASSETS_MAP} },`,
+        `    clientManifest: () => (${ASSETS_MAP}),`,
         // TODO: rename pluginManifest -> vikeManifest
         `    pluginManifest: () => (${JSON.stringify(vikeManifest, null, 2)}),`,
         '  });',

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

@@ -829,7 +829,7 @@ function getConfigName(filePath) {
     if (isTmpFile(filePath))
         return null;
     const fileName = path.posix.basename(filePath);
-    assertNoUnexpectedPlusSign(filePath, fileName);
+    // assertNoUnexpectedPlusSign(filePath, fileName)
     const basename = fileName.split('.')[0];
     if (!basename.startsWith('+')) {
         return null;
@@ -839,14 +839,6 @@ function getConfigName(filePath) {
         return configName;
     }
 }
-function assertNoUnexpectedPlusSign(filePath, fileName) {
-    const dirs = path.posix.dirname(filePath).split('/');
-    dirs.forEach((dir, i) => {
-        const dirPath = dirs.slice(0, i + 1).join('/');
-        assertUsage(!dir.includes('+'), `Character '+' is a reserved character: remove '+' from the directory name ${dirPath}/`);
-    });
-    assertUsage(!fileName.slice(1).includes('+'), `Character '+' is only allowed at the beginning of filenames: make sure ${filePath} doesn't contain any '+' in its filename other than its first letter`);
-}
 async function loadConfigFile(configFilePath, userRootDir, visited) {
     const { filePathAbsoluteFilesystem } = configFilePath;
     assertNoInfiniteLoop(visited, filePathAbsoluteFilesystem);

package/dist/esm/node/prerender/index.d.ts

@@ -1 +1 @@
-export { prerenderFromAPI as prerender } from './runPrerender.js';
+export { runPrerenderFromAPI as prerender } from './runPrerender.js';

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

@@ -1 +1 @@
-export { prerenderFromAPI as prerender } from './runPrerender.js';
+export { runPrerenderFromAPI as prerender } from './runPrerender.js';

package/dist/esm/node/prerender/runPrerender.d.ts

@@ -1,7 +1,7 @@
-export { prerenderFromAPI };
-export { prerenderFromCLI };
-export { prerenderFromAutoFullBuild };
-export { prerenderForceExit };
+export { runPrerenderFromAPI };
+export { runPrerenderFromCLI };
+export { runPrerenderFromAutoFullBuild };
+export { runPrerender_forceExit };
 export type { PrerenderOptions };
 import '../runtime/page-files/setup.js';
 import type { InlineConfig } from 'vite';
@@ -47,7 +47,7 @@ type PrerenderOptions = {
     /** @deprecated */
     base?: string;
 };
-declare function prerenderFromAPI(options?: PrerenderOptions): Promise<void>;
-declare function prerenderFromCLI(options: PrerenderOptions): Promise<void>;
-declare function prerenderFromAutoFullBuild(options: PrerenderOptions): Promise<void>;
-declare function prerenderForceExit(): void;
+declare function runPrerenderFromAPI(options?: PrerenderOptions): Promise<void>;
+declare function runPrerenderFromCLI(options: PrerenderOptions): Promise<void>;
+declare function runPrerenderFromAutoFullBuild(options: PrerenderOptions): Promise<void>;
+declare function runPrerender_forceExit(): void;

package/dist/esm/node/prerender/runPrerender.js

@@ -1,11 +1,11 @@
-export { prerenderFromAPI };
-export { prerenderFromCLI };
-export { prerenderFromAutoFullBuild };
-export { prerenderForceExit };
+export { runPrerenderFromAPI };
+export { runPrerenderFromCLI };
+export { runPrerenderFromAutoFullBuild };
+export { runPrerender_forceExit };
 import '../runtime/page-files/setup.js';
 import path from 'path';
 import { route } from '../../shared/route/index.js';
-import { assert, assertUsage, assertWarning, hasProp, projectInfo, objectAssign, isObjectWithKeys, isCallable, getOutDirs, isPropertyGetter, assertPosixPath, urlToFile, executeHook, isPlainObject, setNodeEnvToProduction } from './utils.js';
+import { assert, assertUsage, assertWarning, hasProp, projectInfo, objectAssign, isObjectWithKeys, isCallable, getOutDirs, isPropertyGetter, assertPosixPath, urlToFile, executeHook, isPlainObject, setNodeEnvToProduction, isUserHookError } from './utils.js';
 import { pLimit } from '../../utils/pLimit.js';
 import { prerenderPage, prerender404Page, getRenderContext, getPageContextInitEnhanced } from '../runtime/renderPage/renderPageAlreadyRouted.js';
 import pc from '@brillout/picocolors';
@@ -22,21 +22,22 @@ import { isErrorPage } from '../../shared/error-page.js';
 import { addUrlComputedProps } from '../../shared/addUrlComputedProps.js';
 import { assertPathIsFilesystemAbsolute } from '../../utils/assertPathIsFilesystemAbsolute.js';
 import { isAbortError } from '../../shared/route/abort.js';
-import { loadPageFilesServerSide } from '../runtime/renderPage/loadPageFilesServerSide.js';
-import { getHookFromPageConfig, getHookFromPageConfigGlobal, getHookTimeoutDefault } from '../../shared/hooks/getHook.js';
+import { loadUserFilesServerSide } from '../runtime/renderPage/loadUserFilesServerSide.js';
+import { getHookFromPageConfig, getHookFromPageConfigGlobal, getHookTimeoutDefault, setIsPrerenderering } from '../../shared/hooks/getHook.js';
 import { noRouteMatch } from '../../shared/route/noRouteMatch.js';
 import { getVikeConfig } from '../plugin/plugins/importUserCode/v1-design/getVikeConfig.js';
-async function prerenderFromAPI(options = {}) {
+async function runPrerenderFromAPI(options = {}) {
     await runPrerender(options, 'prerender()');
 }
-async function prerenderFromCLI(options) {
+async function runPrerenderFromCLI(options) {
     await runPrerender(options, '$ vike prerender');
 }
-async function prerenderFromAutoFullBuild(options) {
+async function runPrerenderFromAutoFullBuild(options) {
     await runPrerender(options, null);
 }
 async function runPrerender(options, manuallyTriggered) {
     checkOutdatedOptions(options);
+    setIsPrerenderering();
     const logLevel = !!options.onPagePrerender ? 'warn' : 'info';
     if (logLevel === 'info') {
         console.log(`${pc.cyan(`vike v${projectInfo.projectVersion}`)} ${pc.green('pre-rendering HTML...')}`);
@@ -269,7 +270,7 @@ async function handlePagesWithStaticRoutes(prerenderContext, renderContext, doNo
                 }
             ]
         });
-        objectAssign(pageContext, await loadPageFilesServerSide(pageContext));
+        objectAssign(pageContext, await loadUserFilesServerSide(pageContext));
         prerenderContext.pageContexts.push(pageContext);
     })));
 }
@@ -449,7 +450,7 @@ async function routeAndPrerender(prerenderContext, concurrencyLimit, onComplete)
         assert(pageContextFromRoute._pageId);
         objectAssign(pageContext, pageContextFromRoute);
         const { _pageId: pageId } = pageContext;
-        objectAssign(pageContext, await loadPageFilesServerSide(pageContext));
+        objectAssign(pageContext, await loadUserFilesServerSide(pageContext));
         let usesClientRouter;
         {
             if (pageContext._pageConfigs.length > 0) {
@@ -672,7 +673,7 @@ function isSameUrl(url1, url2) {
 function normalizeUrl(url) {
     return '/' + url.split('/').filter(Boolean).join('/');
 }
-function prerenderForceExit() {
+function runPrerender_forceExit() {
     // Force exit; known situations where pre-rendering is hanging:
     //  - https://github.com/vikejs/vike/discussions/774#discussioncomment-5584551
     //  - https://github.com/vikejs/vike/issues/807#issuecomment-1519010902
@@ -686,5 +687,12 @@ function assertIsNotAbort(err, urlOr404) {
     if (!isAbortError(err))
         return;
     const pageContextAbort = err._pageContextAbort;
-    assertUsage(false, `${pc.cyan(pageContextAbort._abortCall)} intercepted while pre-rendering ${urlOr404} but ${pc.cyan(pageContextAbort._abortCaller)} isn't supported for pre-rendered pages`);
+    const hookLoc = isUserHookError(err);
+    assert(hookLoc);
+    const thrownBy = ` by ${pc.cyan(`${hookLoc.hookName}()`)} hook defined at ${hookLoc.hookFilePath}`;
+    const abortCaller = pageContextAbort._abortCaller;
+    assert(abortCaller);
+    const abortCall = pageContextAbort._abortCall;
+    assert(abortCall);
+    assertUsage(false, `${pc.cyan(abortCall)} thrown${thrownBy} while pre-rendering ${urlOr404} but ${pc.cyan(abortCaller)} isn't supported for pre-rendered pages`);
 }

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

@@ -9,7 +9,6 @@ type PageContextSerialization = {
     _pageConfigs: PageConfigRuntime[];
     is404: null | boolean;
     pageProps?: Record<string, unknown>;
-    _isError?: true;
     _pageContextInit: Record<string, unknown>;
 };
 declare function serializePageContextClientSide(pageContext: PageContextSerialization): string;

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

@@ -6,6 +6,8 @@ import { isErrorPage } from '../../../shared/error-page.js';
 import { addIs404ToPageProps } from '../../../shared/addIs404ToPageProps.js';
 import pc from '@brillout/picocolors';
 import { notSerializable } from '../../../shared/notSerializable.js';
+import { pageContextInitIsPassedToClient } from '../../../shared/misc/pageContextInitIsPassedToClient.js';
+import { isRenderFailure } from '../../../shared/misc/isRenderFailure.js';
 const PASS_TO_CLIENT = [
     'abortReason',
     '_urlRewrite',
@@ -15,11 +17,11 @@ const PASS_TO_CLIENT = [
     /* Not needed on the client-side
     '_abortCaller',
     */
-    '_pageContextInitHasClientData',
+    pageContextInitIsPassedToClient,
     '_pageId',
     'data' // for data() hook
 ];
-const PASS_TO_CLIENT_ERROR_PAGE = ['pageProps', 'is404', '_isError'];
+const PASS_TO_CLIENT_ERROR_PAGE = ['pageProps', 'is404', isRenderFailure];
 function serializePageContextClientSide(pageContext) {
     const passToClient = getPassToClient(pageContext);
     const pageContextClient = {};
@@ -28,7 +30,7 @@ function serializePageContextClientSide(pageContext) {
         pageContextClient[prop] = pageContext[prop];
     });
     if (Object.keys(pageContext._pageContextInit).some((p) => passToClient.includes(p))) {
-        pageContextClient._pageContextInitHasClientData = true;
+        pageContextClient._pageContextInitIsPassedToClient = true;
     }
     let pageContextSerialized;
     try {

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

@@ -19,8 +19,9 @@ export { streamReadableWebToString };
 export { streamPipeNodeToString };
 export { isStreamWritableWeb };
 export { isStreamWritableNode };
-import { assert, assertUsage, checkType, isObject, hasProp, objectAssign, capitalizeFirstLetter, assertWarning, isCallable, createDebugger, dynamicImport, isBug } from '../utils.js';
+import { assert, assertUsage, checkType, isObject, hasProp, objectAssign, capitalizeFirstLetter, assertWarning, isCallable, createDebugger, isBug } from '../utils.js';
 import { getStreamFromReactStreaming, isStreamReactStreaming, streamReactStreamingToString } from './stream/react-streaming.js';
+import { import_ } from '@brillout/import';
 import pc from '@brillout/picocolors';
 const debug = createDebugger('vike:stream');
 function isStreamReadableWeb(thing) {
@@ -753,7 +754,7 @@ function encodeForWebStream(thing) {
 }
 // Because of Cloudflare Workers, we cannot statically import the `stream` module, instead we dynamically import it.
 async function loadStreamNodeModule() {
-    const streamModule = await dynamicImport('stream');
+    const streamModule = (await import_('stream')).default;
     const { Readable, Writable } = streamModule;
     return { Readable, Writable };
 }

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

@@ -43,7 +43,8 @@ function collectCss(mod, styleUrls, visitedModules, importer) {
             //    - 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)}`);
+            //  - https://github.com/vikejs/vike/issues/479#issuecomment-1870043943
+            styleUrls.add(`/@id/__x00__${mod.url.substring(1)}`);
         }
         else {
             // Is this useful? Maybe for virtual modules that don't respect the \0 virtual module convention?

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

@@ -1,12 +1,12 @@
 export { isNewError };
 export { setAlreadyLogged };
-import { getGlobalObject, isObject, isEquivalentError, warnIfErrorIsNotObject } from '../utils.js';
+import { getGlobalObject, isObject, isSameErrorMessage, warnIfErrorIsNotObject } from '../utils.js';
 const globalObject = getGlobalObject('runtime/renderPage/isNewError.ts', {
     wasAlreadyLogged: new WeakSet()
 });
 function isNewError(errErrorPage, errNominalPage) {
     warnIfErrorIsNotObject(errErrorPage);
-    return !isEquivalentError(errNominalPage, errErrorPage) || !hasAlreadyLogged(errNominalPage);
+    return !isSameErrorMessage(errNominalPage, errErrorPage) || !hasAlreadyLogged(errNominalPage);
 }
 function hasAlreadyLogged(err) {
     if (!isObject(err))

package/dist/esm/node/runtime/renderPage/{loadPageFilesServerSide.d.ts → loadUserFilesServerSide.d.ts}

@@ -1,20 +1,20 @@
-export { loadPageFilesServerSide };
+export { loadUserFilesServerSide };
 export type { PageFiles };
-export type { PageContext_loadPageFilesServerSide };
+export type { PageContext_loadUserFilesServerSide };
 import { type PageFile } from '../../../shared/getPageFiles.js';
 import { PromiseType } from '../utils.js';
 import { PageContextGetPageAssets, type PageAsset } from './getPageAssets.js';
 import { type PageContextDebugRouteMatches } from './debugPageFiles.js';
 import type { PageConfigRuntime } from '../../../shared/page-configs/PageConfig.js';
-type PageContext_loadPageFilesServerSide = PageContextGetPageAssets & PageContextDebugRouteMatches & {
+type PageContext_loadUserFilesServerSide = PageContextGetPageAssets & PageContextDebugRouteMatches & {
     urlOriginal: string;
     _pageFilesAll: PageFile[];
     _pageConfigs: PageConfigRuntime[];
 };
-type PageFiles = PromiseType<ReturnType<typeof loadPageFilesServerSide>>;
-declare function loadPageFilesServerSide(pageContext: {
+type PageFiles = PromiseType<ReturnType<typeof loadUserFilesServerSide>>;
+declare function loadUserFilesServerSide(pageContext: {
     _pageId: string;
-} & PageContext_loadPageFilesServerSide): Promise<{
+} & PageContext_loadUserFilesServerSide): Promise<{
     config: Record<string, unknown>;
     configEntries: import("../../../shared/getPageFiles/getExports.js").ConfigEntries;
     exports: Record<string, unknown>;

package/dist/esm/node/runtime/renderPage/{loadPageFilesServerSide.js → loadUserFilesServerSide.js}

@@ -1,4 +1,4 @@
-export { loadPageFilesServerSide };
+export { loadUserFilesServerSide };
 import { getExportUnion, getPageFilesServerSide, getExports } from '../../../shared/getPageFiles.js';
 import { analyzePageClientSideInit } from '../../../shared/getPageFiles/analyzePageClientSide.js';
 import { assertWarning, objectAssign } from '../utils.js';
@@ -8,10 +8,10 @@ import { findPageConfig } from '../../../shared/page-configs/findPageConfig.js';
 import { analyzePage } from './analyzePage.js';
 import { getGlobalContext } from '../globalContext.js';
 import { loadConfigValues } from '../../../shared/page-configs/loadConfigValues.js';
-async function loadPageFilesServerSide(pageContext) {
+async function loadUserFilesServerSide(pageContext) {
     const pageConfig = findPageConfig(pageContext._pageConfigs, pageContext._pageId); // Make pageConfig globally available as pageContext._pageConfig?
     const [{ config, configEntries, exports, exportsAll, pageExports, pageFilesLoaded, pageConfigLoaded }] = await Promise.all([
-        loadPageFiles(pageContext._pageFilesAll, pageConfig, pageContext._pageId, !getGlobalContext().isProduction),
+        loadPageUserFiles(pageContext._pageFilesAll, pageConfig, pageContext._pageId, !getGlobalContext().isProduction),
         analyzePageClientSideInit(pageContext._pageFilesAll, pageContext._pageId, { sharedPageFilesAlreadyLoaded: true })
     ]);
     const { isHtmlOnly, isClientRouting, clientEntries, clientDependencies, pageFilesClientSide, pageFilesServerSide } = analyzePage(pageContext._pageFilesAll, pageConfig, pageContext._pageId);
@@ -80,7 +80,7 @@ async function loadPageFilesServerSide(pageContext) {
     }
     return pageContextAddendum;
 }
-async function loadPageFiles(pageFilesAll, pageConfig, pageId, isDev) {
+async function loadPageUserFiles(pageFilesAll, pageConfig, pageId, isDev) {
     const pageFilesServerSide = getPageFilesServerSide(pageFilesAll, pageId);
     const pageConfigLoaded = !pageConfig ? null : await loadConfigValues(pageConfig, isDev);
     await Promise.all(pageFilesServerSide.map((p) => p.loadFile?.()));

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

@@ -9,7 +9,7 @@ export type { PageContextInitEnhanced };
 import { type PageFile } from '../../../shared/getPageFiles.js';
 import { type PageContextUrlComputedPropsInternal } from '../../../shared/addUrlComputedProps.js';
 import { HttpResponse } from './createHttpResponseObject.js';
-import { PageContext_loadPageFilesServerSide, type PageFiles } from './loadPageFilesServerSide.js';
+import { PageContext_loadUserFilesServerSide, type PageFiles } from './loadUserFilesServerSide.js';
 import type { PageConfigRuntime, PageConfigGlobalRuntime } from '../../../shared/page-configs/PageConfig.js';
 import { type PageRoutes } from '../../../shared/route/loadPageRoutes.js';
 import type { Hook } from '../../../shared/hooks/getHook.js';
@@ -24,7 +24,7 @@ declare function renderPageAlreadyRouted<PageContext extends {
     routeParams: Record<string, string>;
     errorWhileRendering: null | Error;
     _httpRequestId: number;
-} & PageContextInitEnhanced & PageContextUrlComputedPropsInternal & PageContext_loadPageFilesServerSide>(pageContext: PageContext): Promise<PageContext & PageContextAfterRender>;
+} & PageContextInitEnhanced & PageContextUrlComputedPropsInternal & PageContext_loadUserFilesServerSide>(pageContext: PageContext): Promise<PageContext & PageContextAfterRender>;
 declare function prerenderPage(pageContext: PageContextInitEnhanced & PageFiles & {
     routeParams: Record<string, string>;
     _pageId: string;

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

@@ -11,7 +11,7 @@ import { serializePageContextClientSide } from '../html/serializePageContextClie
 import { addUrlComputedProps } from '../../../shared/addUrlComputedProps.js';
 import { getGlobalContext } from '../globalContext.js';
 import { createHttpResponseObject, createHttpResponsePageContextJson } from './createHttpResponseObject.js';
-import { loadPageFilesServerSide } from './loadPageFilesServerSide.js';
+import { loadUserFilesServerSide } from './loadUserFilesServerSide.js';
 import { executeOnRenderHtmlHook } from './executeOnRenderHtmlHook.js';
 import { executeOnBeforeRenderAndDataHooks } from './executeOnBeforeRenderAndDataHooks.js';
 import { logRuntimeError } from './loggerRuntime.js';
@@ -21,6 +21,7 @@ import { executeGuardHook } from '../../../shared/route/executeGuardHook.js';
 import { loadPageRoutes } from '../../../shared/route/loadPageRoutes.js';
 import pc from '@brillout/picocolors';
 import { getConfigValueFilePathToShowToUser } from '../../../shared/page-configs/helpers.js';
+import { isRenderFailure } from '../../../shared/misc/isRenderFailure.js';
 async function renderPageAlreadyRouted(pageContext) {
     // pageContext._pageId can either be the:
     //  - ID of the page matching the routing, or the
@@ -28,7 +29,7 @@ async function renderPageAlreadyRouted(pageContext) {
     assert(hasProp(pageContext, '_pageId', 'string'));
     const isError = pageContext.is404 || !!pageContext.errorWhileRendering;
     assert(isError === (pageContext._pageId === getErrorPageId(pageContext._pageFilesAll, pageContext._pageConfigs)));
-    objectAssign(pageContext, await loadPageFilesServerSide(pageContext));
+    objectAssign(pageContext, await loadUserFilesServerSide(pageContext));
     if (!isError) {
         await executeGuardHook(pageContext, (pageContext) => preparePageContextForUserConsumptionServerSide(pageContext));
     }
@@ -47,7 +48,7 @@ async function renderPageAlreadyRouted(pageContext) {
     }
     if (pageContext.isClientSideNavigation) {
         if (isError) {
-            objectAssign(pageContext, { _isError: true });
+            objectAssign(pageContext, { [isRenderFailure]: true });
         }
         const pageContextSerialized = serializePageContextClientSide(pageContext);
         const httpResponse = await createHttpResponsePageContextJson(pageContextSerialized);
@@ -112,7 +113,7 @@ async function prerender404Page(renderContext, pageContextInit_) {
         const pageContextInitEnhanced = getPageContextInitEnhanced(pageContextInit, renderContext);
         objectAssign(pageContext, pageContextInitEnhanced);
     }
-    objectAssign(pageContext, await loadPageFilesServerSide(pageContext));
+    objectAssign(pageContext, await loadUserFilesServerSide(pageContext));
     return prerenderPage(pageContext);
 }
 function getPageContextInitEnhanced(pageContextInit, renderContext, { urlComputedPropsNonEnumerable = false, ssr: { urlRewrite, urlHandler, isClientSideNavigation } = {

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

@@ -16,7 +16,7 @@ import pc from '@brillout/picocolors';
 import { serializePageContextAbort, serializePageContextClientSide } from './html/serializePageContextClientSide.js';
 import { getErrorPageId } from '../../shared/error-page.js';
 import { handleErrorWithoutErrorPage } from './renderPage/handleErrorWithoutErrorPage.js';
-import { loadPageFilesServerSide } from './renderPage/loadPageFilesServerSide.js';
+import { loadUserFilesServerSide } from './renderPage/loadUserFilesServerSide.js';
 import { resolveRedirects } from '../../shared/route/resolveRedirects.js';
 const globalObject = getGlobalObject('runtime/renderPage.ts', {
     httpRequestsCount: 0,
@@ -384,7 +384,7 @@ async function handleAbortError(errAbort, pageContextsFromRewrite, pageContextIn
                 ...pageContextErrorPageInit,
                 ...renderContext
             };
-            objectAssign(pageContext, await loadPageFilesServerSide(pageContext));
+            objectAssign(pageContext, await loadUserFilesServerSide(pageContext));
             // We include pageContextInit: we don't only serialize pageContextAbort because the error page may need to access pageContextInit
             pageContextSerialized = serializePageContextClientSide(pageContext);
         }