vike 0.4.146-commit-701e2e5 → 0.4.147-commit-2fa53b2

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

@@ -1,15 +1,11 @@
 export { getVirtualFilePageConfigs };
-export { getConfigValueSerialized };
-import { assert, assertUsage, getPropAccessNotation, objectEntries } from '../../../utils.js';
+import { assert, objectEntries } from '../../../utils.js';
 import { getVirtualFileIdPageConfigValuesAll } from '../../../../shared/virtual-files/virtualFilePageConfigValuesAll.js';
 import { debug } from './debug.js';
-import { isJsonSerializerError, stringify } from '@brillout/json-serializer/stringify';
-import { getConfigEnv } from './helpers.js';
-import pc from '@brillout/picocolors';
 import { getVikeConfig } from './getVikeConfig.js';
 import { isRuntimeEnvMatch } from './isRuntimeEnvMatch.js';
-import { getConfigValueFilePathToShowToUser } from '../../../../../shared/page-configs/helpers.js';
-import { serializeConfigValue, serializeConfigValueImported } from '../../../../../shared/page-configs/serialize/serializeConfigValue.js';
+import { serializeConfigValueImported } from '../../../../../shared/page-configs/serialize/serializeConfigValue.js';
+import { getConfigValuesSerialized } from './getConfigValuesSerialized.js';
 async function getVirtualFilePageConfigs(isForClientSide, isDev, id, isClientRouting, config) {
     const { pageConfigs, pageConfigGlobal } = await getVikeConfig(config, isDev, true);
     return getCode(pageConfigs, pageConfigGlobal, isForClientSide, isDev, id, isClientRouting);
@@ -18,15 +14,18 @@ function getCode(pageConfigs, pageConfigGlobal, isForClientSide, isDev, id, isCl
     const lines = [];
     const importStatements = [];
     const varCounterContainer = { varCounter: 0 };
+    lines.push('export const pageConfigsSerialized = [');
     lines.push(getCodePageConfigsSerialized(pageConfigs, isForClientSide, isClientRouting, importStatements, varCounterContainer));
+    lines.push('];');
+    lines.push('export const pageConfigGlobalSerialized = {');
     lines.push(getCodePageConfigGlobalSerialized(pageConfigGlobal, isForClientSide, isDev, importStatements, varCounterContainer));
+    lines.push('};');
     const code = [...importStatements, ...lines].join('\n');
     debug(id, isForClientSide ? 'CLIENT-SIDE' : 'SERVER-SIDE', code);
     return code;
 }
 function getCodePageConfigsSerialized(pageConfigs, isForClientSide, isClientRouting, importStatements, varCounterContainer) {
     const lines = [];
-    lines.push('export const pageConfigsSerialized = [');
     pageConfigs.forEach((pageConfig) => {
         const { pageId, routeFilesystem, isErrorPage } = pageConfig;
         const virtualFileIdPageConfigValuesAll = getVirtualFileIdPageConfigValuesAll(pageId, isForClientSide);
@@ -34,35 +33,13 @@ function getCodePageConfigsSerialized(pageConfigs, isForClientSide, isClientRout
         lines.push(`    pageId: ${JSON.stringify(pageId)},`);
         lines.push(`    isErrorPage: ${JSON.stringify(isErrorPage)},`);
         lines.push(`    routeFilesystem: ${JSON.stringify(routeFilesystem)},`);
-        lines.push(`    loadConfigValuesAll: async () => (await import(${JSON.stringify(virtualFileIdPageConfigValuesAll)})).default,`);
+        lines.push(`    loadConfigValuesAll: () => import(${JSON.stringify(virtualFileIdPageConfigValuesAll)}),`);
+        // Serialized config values
         lines.push(`    configValuesSerialized: {`);
-        Object.entries(pageConfig.configValuesComputed).forEach(([configName, configValuesComputed]) => {
-            const { value, configEnv } = configValuesComputed;
-            if (!isRuntimeEnvMatch(configEnv, { isForClientSide, isClientRouting, isEager: true }))
-                return;
-            if (pageConfig.configValueSources[configName])
-                return;
-            const configValue = pageConfig.configValues[configName];
-            assert(configValue);
-            const { definedAt } = configValue;
-            const valueSerialized = getConfigValueSerialized(value, configName, definedAt);
-            serializeConfigValue(lines, configName, { definedAt, valueSerialized });
-        });
-        Object.entries(pageConfig.configValueSources).forEach(([configName]) => {
-            const configValue = pageConfig.configValues[configName];
-            if (configValue) {
-                const configEnv = getConfigEnv(pageConfig.configValueSources, configName);
-                assert(configEnv, configName);
-                const isEnvMatch = isRuntimeEnvMatch(configEnv, { isForClientSide, isClientRouting, isEager: true });
-                if (!isEnvMatch)
-                    return;
-                const { value, definedAt } = configValue;
-                const valueSerialized = getConfigValueSerialized(value, configName, definedAt);
-                serializeConfigValue(lines, configName, { definedAt, valueSerialized });
-            }
-        });
+        lines.push(getConfigValuesSerialized(pageConfig, (configEnv) => isRuntimeEnvMatch(configEnv, { isForClientSide, isClientRouting, isEager: true })));
         lines.push(`    },`);
-        let whitespace = '    ';
+        // Imported config values
+        const whitespace = '    ';
         lines.push(`${whitespace}configValuesImported: [`);
         Object.entries(pageConfig.configValueSources).forEach(([configName, sources]) => {
             const configValue = pageConfig.configValues[configName];
@@ -70,21 +47,18 @@ function getCodePageConfigsSerialized(pageConfigs, isForClientSide, isClientRout
                 return;
             const configValueSource = sources[0];
             assert(configValueSource);
-            if (configValueSource.configEnv !== '_routing-eager')
+            if (!configValueSource.configEnv.eager)
                 return;
             lines.push(...serializeConfigValueImported(configValueSource, configName, whitespace, varCounterContainer, importStatements));
         });
         lines.push(`${whitespace}],`);
-        // pageConfig end
         lines.push(`  },`);
     });
-    lines.push('];');
     const code = lines.join('\n');
     return code;
 }
 function getCodePageConfigGlobalSerialized(pageConfigGlobal, isForClientSide, isDev, importStatements, varCounterContainer) {
     const lines = [];
-    lines.push('export const pageConfigGlobalSerialized = {');
     /* Nothing (yet)
     lines.push(`  configValuesSerialized: {`)
     lines.push(`  },`)
@@ -109,35 +83,6 @@ function getCodePageConfigGlobalSerialized(pageConfigGlobal, isForClientSide, is
         lines.push(...serializeConfigValueImported(configValueSource, configName, whitespace, varCounterContainer, importStatements));
     });
     lines.push(`  ],`);
-    lines.push('};');
     const code = lines.join('\n');
     return code;
 }
-function getConfigValueSerialized(value, configName, definedAt) {
-    const valueName = `config${getPropAccessNotation(configName)}`;
-    let configValueSerialized;
-    try {
-        configValueSerialized = stringify(value, { valueName, forbidReactElements: true });
-    }
-    catch (err) {
-        let serializationErrMsg = '';
-        if (isJsonSerializerError(err)) {
-            serializationErrMsg = err.messageCore;
-        }
-        else {
-            // When a property getter throws an error
-            console.error('Serialization error:');
-            console.error(err);
-            serializationErrMsg = 'see serialization error printed above';
-        }
-        const configValueFilePathToShowToUser = getConfigValueFilePathToShowToUser({ definedAt });
-        assert(configValueFilePathToShowToUser);
-        assertUsage(false, [
-            `The value of the config ${pc.cyan(configName)} cannot be defined inside the file ${configValueFilePathToShowToUser}:`,
-            `its value must be defined in an another file and then imported by ${configValueFilePathToShowToUser}. (Because its value isn't serializable: ${serializationErrMsg}.)`,
-            `Only serializable config values can be defined inside +config.h.js files, see https://vike.dev/header-file.`
-        ].join(' '));
-    }
-    configValueSerialized = JSON.stringify(configValueSerialized);
-    return configValueSerialized;
-}

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

@@ -1,15 +1,18 @@
 export { isRuntimeEnvMatch };
 function isRuntimeEnvMatch(configEnv, runtime) {
-    const { isForClientSide, isClientRouting, isEager } = runtime;
-    if (configEnv === 'config-only')
-        return false;
-    if (configEnv === (isForClientSide ? 'server-only' : 'client-only'))
-        return false;
-    if (configEnv === '_routing-eager' || configEnv === '_routing-lazy') {
-        if (isForClientSide && !isClientRouting)
+    // Runtime
+    if (!runtime.isForClientSide) {
+        if (!configEnv.server)
             return false;
-        if (isEager !== (configEnv === '_routing-eager'))
+    }
+    else {
+        if (!configEnv.client)
+            return false;
+        if (configEnv.client === 'if-client-routing' && !runtime.isClientRouting)
             return false;
     }
+    // Eager
+    if (runtime.isEager !== !!configEnv.eager)
+        return false;
     return true;
 }

package/dist/esm/node/plugin/shared/getConfigValueSourcesNotOverriden.d.ts

@@ -0,0 +1,5 @@
+export { getConfigValueSourcesNotOverriden };
+import type { ConfigValueSource, PageConfigBuildTime } from '../../../shared/page-configs/PageConfig.js';
+declare function getConfigValueSourcesNotOverriden(pageConfig: PageConfigBuildTime): (ConfigValueSource & {
+    configName: string;
+})[];

package/dist/esm/node/plugin/shared/{getConfigValueSourcesRelevant.js → getConfigValueSourcesNotOverriden.js}

@@ -1,7 +1,7 @@
-export { getConfigValueSourcesRelevant };
+export { getConfigValueSourcesNotOverriden };
 import { assert, assertIsNotBrowser } from '../../shared/utils.js';
 assertIsNotBrowser();
-function getConfigValueSourcesRelevant(pageConfig) {
+function getConfigValueSourcesNotOverriden(pageConfig) {
     const configValueSourcesRelevant = Object.entries(pageConfig.configValueSources).map(([configName, sources]) => {
         const configValueSource = sources[0];
         assert(configValueSource);

package/dist/esm/node/plugin/utils.d.ts

@@ -16,3 +16,5 @@ export * from '../../utils/removeEmptyLines.js';
 export * from '../../utils/findUserPackageJsonPath.js';
 export * from '../../utils/getPropAccessNotation.js';
 export * from '../../utils/mergeCumulativeValues.js';
+export * from '../../utils/deepEqual.js';
+export * from '../../utils/assertKeys.js';

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

@@ -22,3 +22,5 @@ export * from '../../utils/removeEmptyLines.js';
 export * from '../../utils/findUserPackageJsonPath.js';
 export * from '../../utils/getPropAccessNotation.js';
 export * from '../../utils/mergeCumulativeValues.js';
+export * from '../../utils/deepEqual.js';
+export * from '../../utils/assertKeys.js';

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

@@ -71,19 +71,25 @@ async function runPrerender(options, manuallyTriggered) {
     const doNotPrerenderList = [];
     const vikeConfig = await getVikeConfig(viteConfig, false);
     await collectDoNoPrerenderList(renderContext, vikeConfig.pageConfigs, doNotPrerenderList, concurrencyLimit);
-    await callOnBeforePrerenderStartHooks(prerenderContext, renderContext, concurrencyLimit);
+    await callOnBeforePrerenderStartHooks(prerenderContext, renderContext, concurrencyLimit, doNotPrerenderList);
     await handlePagesWithStaticRoutes(prerenderContext, renderContext, doNotPrerenderList, concurrencyLimit);
     await callOnPrerenderStartHook(prerenderContext, renderContext);
-    const prerenderPageIds = {};
-    const htmlFiles = [];
-    await routeAndPrerender(prerenderContext, htmlFiles, prerenderPageIds, concurrencyLimit);
-    warnContradictoryNoPrerenderList(prerenderPageIds, doNotPrerenderList);
-    await prerender404(htmlFiles, renderContext, prerenderContext);
+    const prerenderedPageContexts = {};
+    let prerenderedCount = 0;
+    const onComplete = async (htmlFile) => {
+        prerenderedCount++;
+        if (htmlFile.pageId) {
+            prerenderedPageContexts[htmlFile.pageId] = htmlFile.pageContext;
+        }
+        await writeFiles(htmlFile, root, outDirClient, options.onPagePrerender, logLevel);
+    };
+    await routeAndPrerender(prerenderContext, concurrencyLimit, onComplete);
+    warnContradictoryNoPrerenderList(prerenderedPageContexts, doNotPrerenderList);
+    await prerender404(prerenderedPageContexts, renderContext, prerenderContext, onComplete);
     if (logLevel === 'info') {
-        console.log(`${pc.green(`✓`)} ${htmlFiles.length} HTML documents pre-rendered.`);
+        console.log(`${pc.green(`✓`)} ${prerenderedCount} HTML documents pre-rendered.`);
     }
-    await Promise.all(htmlFiles.map((htmlFile) => writeHtmlFile(htmlFile, root, outDirClient, concurrencyLimit, options.onPagePrerender, logLevel)));
-    warnMissingPages(prerenderPageIds, doNotPrerenderList, renderContext, partial);
+    warnMissingPages(prerenderedPageContexts, doNotPrerenderList, renderContext, partial);
 }
 async function collectDoNoPrerenderList(renderContext, pageConfigs, doNotPrerenderList, concurrencyLimit) {
     // V1 design
@@ -145,7 +151,7 @@ function assertExportNames(pageFile) {
     const { exportNames, fileType } = pageFile;
     assert(exportNames || fileType === '.page.route' || fileType === '.css', pageFile.filePath);
 }
-async function callOnBeforePrerenderStartHooks(prerenderContext, renderContext, concurrencyLimit) {
+async function callOnBeforePrerenderStartHooks(prerenderContext, renderContext, concurrencyLimit, doNotPrerenderList) {
     const onBeforePrerenderStartHooks = [];
     // V1 design
     await Promise.all(renderContext.pageConfigs.map((pageConfig) => concurrencyLimit(async () => {
@@ -161,7 +167,8 @@ async function callOnBeforePrerenderStartHooks(prerenderContext, renderContext,
         onBeforePrerenderStartHooks.push({
             hookFn,
             hookName: 'onBeforePrerenderStart',
-            hookFilePath
+            hookFilePath,
+            pageId: pageConfig.pageId
         });
     })));
     // 0.4 design
@@ -184,10 +191,14 @@ async function callOnBeforePrerenderStartHooks(prerenderContext, renderContext,
         onBeforePrerenderStartHooks.push({
             hookFn,
             hookName: 'prerender',
-            hookFilePath
+            hookFilePath,
+            pageId: p.pageId
         });
     })));
-    await Promise.all(onBeforePrerenderStartHooks.map(({ hookFn, hookName, hookFilePath }) => concurrencyLimit(async () => {
+    await Promise.all(onBeforePrerenderStartHooks.map(({ hookFn, hookName, hookFilePath, pageId }) => concurrencyLimit(async () => {
+        if (doNotPrerenderList.find((p) => p.pageId === pageId)) {
+            return;
+        }
         const prerenderResult = await hookFn();
         const result = normalizeOnPrerenderHookResult(prerenderResult, hookFilePath, hookName);
         result.forEach(({ url, pageContext }) => {
@@ -406,7 +417,7 @@ async function callOnPrerenderStartHook(prerenderContext, renderContext) {
         addUrlComputedProps(pageContext);
     });
 }
-async function routeAndPrerender(prerenderContext, htmlFiles, prerenderPageIds, concurrencyLimit) {
+async function routeAndPrerender(prerenderContext, concurrencyLimit, onComplete) {
     const globalContext = getGlobalContext();
     assert(globalContext.isPrerendering);
     // Route all URLs
@@ -466,7 +477,7 @@ async function routeAndPrerender(prerenderContext, htmlFiles, prerenderPageIds,
             throw err;
         }
         const { documentHtml, pageContextSerialized } = res;
-        htmlFiles.push({
+        await onComplete({
             urlOriginal,
             pageContext,
             htmlString: documentHtml,
@@ -474,11 +485,10 @@ async function routeAndPrerender(prerenderContext, htmlFiles, prerenderPageIds,
             doNotCreateExtraDirectory: prerenderContext._noExtraDir,
             pageId
         });
-        prerenderPageIds[pageId] = pageContext;
     })));
 }
-function warnContradictoryNoPrerenderList(prerenderPageIds, doNotPrerenderList) {
-    Object.entries(prerenderPageIds).forEach(([pageId, pageContext]) => {
+function warnContradictoryNoPrerenderList(prerenderedPageContexts, doNotPrerenderList) {
+    Object.entries(prerenderedPageContexts).forEach(([pageId, pageContext]) => {
         const doNotPrerenderListEntry = doNotPrerenderList.find((p) => p.pageId === pageId);
         const { urlOriginal, _providedByHook: providedByHook } = pageContext;
         {
@@ -490,7 +500,7 @@ function warnContradictoryNoPrerenderList(prerenderPageIds, doNotPrerenderList)
         assertWarning(false, `The ${providedByHook.hookName}() hook defined by ${providedByHook.hookFilePath} returns the URL ${pc.cyan(urlOriginal)}, while ${setByConfigFile} sets the config ${pc.cyan(setByConfigName)} to ${pc.cyan(String(setByConfigValue))}. This is contradictory: either don't set the config ${pc.cyan(setByConfigName)} to ${pc.cyan(String(setByConfigValue))} or remove the URL ${pc.cyan(urlOriginal)} from the list of URLs to be pre-rendered.`, { onlyOnce: true });
     });
 }
-function warnMissingPages(prerenderPageIds, doNotPrerenderList, renderContext, partial) {
+function warnMissingPages(prerenderedPageContexts, doNotPrerenderList, renderContext, partial) {
     const isV1 = renderContext.pageConfigs.length > 0;
     const hookName = isV1 ? 'onBeforePrerenderStart' : 'prerender';
     /* TODO/after-v1-design-release: document setting `prerender: false` as an alternative to using prerender.partial (both in the warnings and the docs)
@@ -498,7 +508,7 @@ function warnMissingPages(prerenderPageIds, doNotPrerenderList, renderContext, p
     const msgAddendum = `Explicitly opt-out by setting the config ${optOutName} to ${isV1 ? 'false' : 'true'} or use the option prerender.partial`
     */
     renderContext.allPageIds
-        .filter((pageId) => !prerenderPageIds[pageId])
+        .filter((pageId) => !prerenderedPageContexts[pageId])
         .filter((pageId) => !doNotPrerenderList.find((p) => p.pageId === pageId))
         .filter((pageId) => !isErrorPage(pageId, renderContext.pageConfigs))
         .forEach((pageId) => {
@@ -506,8 +516,8 @@ function warnMissingPages(prerenderPageIds, doNotPrerenderList, renderContext, p
         assertWarning(partial, `Cannot pre-render page ${pageAt} because it has a non-static route, while no ${hookName}() hook returned any URL matching the page's route. You need to use a ${hookName}() hook (https://vike.dev/${hookName}) providing a list of URLs for ${pageAt} that should be pre-rendered. If you don't want to pre-render ${pageAt} then use the option prerender.partial (https://vike.dev/prerender-config#partial) to suppress this warning.`, { onlyOnce: true });
     });
 }
-async function prerender404(htmlFiles, renderContext, prerenderContext) {
-    if (!htmlFiles.find(({ urlOriginal }) => urlOriginal === '/404')) {
+async function prerender404(prerenderedPageContexts, renderContext, prerenderContext, onComplete) {
+    if (!Object.values(prerenderedPageContexts).find(({ urlOriginal }) => urlOriginal === '/404')) {
         let result;
         try {
             result = await prerender404Page(renderContext, prerenderContext.pageContextInit);
@@ -519,7 +529,7 @@ async function prerender404(htmlFiles, renderContext, prerenderContext) {
         if (result) {
             const urlOriginal = '/404';
             const { documentHtml, pageContext } = result;
-            htmlFiles.push({
+            await onComplete({
                 urlOriginal,
                 pageContext,
                 htmlString: documentHtml,
@@ -530,59 +540,57 @@ async function prerender404(htmlFiles, renderContext, prerenderContext) {
         }
     }
 }
-async function writeHtmlFile({ urlOriginal, pageContext, htmlString, pageContextSerialized, doNotCreateExtraDirectory }, root, outDirClient, concurrencyLimit, onPagePrerender, logLevel) {
+async function writeFiles({ urlOriginal, pageContext, htmlString, pageContextSerialized, doNotCreateExtraDirectory }, root, outDirClient, onPagePrerender, logLevel) {
     assert(urlOriginal.startsWith('/'));
     const writeJobs = [
-        write(urlOriginal, pageContext, '.html', htmlString, root, outDirClient, doNotCreateExtraDirectory, concurrencyLimit, onPagePrerender, logLevel)
+        write(urlOriginal, pageContext, '.html', htmlString, root, outDirClient, doNotCreateExtraDirectory, onPagePrerender, logLevel)
     ];
     if (pageContextSerialized !== null) {
-        writeJobs.push(write(urlOriginal, pageContext, '.pageContext.json', pageContextSerialized, root, outDirClient, doNotCreateExtraDirectory, concurrencyLimit, onPagePrerender, logLevel));
+        writeJobs.push(write(urlOriginal, pageContext, '.pageContext.json', pageContextSerialized, root, outDirClient, doNotCreateExtraDirectory, onPagePrerender, logLevel));
     }
     await Promise.all(writeJobs);
 }
-function write(urlOriginal, pageContext, fileExtension, fileContent, root, outDirClient, doNotCreateExtraDirectory, concurrencyLimit, onPagePrerender, logLevel) {
-    return concurrencyLimit(async () => {
-        let fileUrl;
-        if (fileExtension === '.html') {
-            fileUrl = urlToFile(urlOriginal, '.html', doNotCreateExtraDirectory);
-        }
-        else {
-            fileUrl = getPageContextRequestUrl(urlOriginal);
-        }
-        assertPosixPath(fileUrl);
-        assert(fileUrl.startsWith('/'));
-        const filePathRelative = fileUrl.slice(1);
-        assert(!filePathRelative.startsWith('/'));
-        assertPosixPath(outDirClient);
-        assertPosixPath(filePathRelative);
-        const filePath = path.posix.join(outDirClient, filePathRelative);
-        if (onPagePrerender) {
-            const prerenderPageContext = {};
-            objectAssign(prerenderPageContext, pageContext);
-            objectAssign(prerenderPageContext, {
-                _prerenderResult: {
-                    filePath,
-                    fileContent
-                }
-            });
-            await onPagePrerender(prerenderPageContext);
-        }
-        else {
-            const { promises } = await import('fs');
-            const { writeFile, mkdir } = promises;
-            await mkdir(path.posix.dirname(filePath), { recursive: true });
-            await writeFile(filePath, fileContent);
-            if (logLevel === 'info') {
-                assertPosixPath(root);
-                assertPosixPath(outDirClient);
-                let outDirClientRelative = path.posix.relative(root, outDirClient);
-                if (!outDirClientRelative.endsWith('/')) {
-                    outDirClientRelative = outDirClientRelative + '/';
-                }
-                console.log(`${pc.dim(outDirClientRelative)}${pc.blue(filePathRelative)}`);
+async function write(urlOriginal, pageContext, fileExtension, fileContent, root, outDirClient, doNotCreateExtraDirectory, onPagePrerender, logLevel) {
+    let fileUrl;
+    if (fileExtension === '.html') {
+        fileUrl = urlToFile(urlOriginal, '.html', doNotCreateExtraDirectory);
+    }
+    else {
+        fileUrl = getPageContextRequestUrl(urlOriginal);
+    }
+    assertPosixPath(fileUrl);
+    assert(fileUrl.startsWith('/'));
+    const filePathRelative = fileUrl.slice(1);
+    assert(!filePathRelative.startsWith('/'));
+    assertPosixPath(outDirClient);
+    assertPosixPath(filePathRelative);
+    const filePath = path.posix.join(outDirClient, filePathRelative);
+    if (onPagePrerender) {
+        const prerenderPageContext = {};
+        objectAssign(prerenderPageContext, pageContext);
+        objectAssign(prerenderPageContext, {
+            _prerenderResult: {
+                filePath,
+                fileContent
             }
+        });
+        await onPagePrerender(prerenderPageContext);
+    }
+    else {
+        const { promises } = await import('fs');
+        const { writeFile, mkdir } = promises;
+        await mkdir(path.posix.dirname(filePath), { recursive: true });
+        await writeFile(filePath, fileContent);
+        if (logLevel === 'info') {
+            assertPosixPath(root);
+            assertPosixPath(outDirClient);
+            let outDirClientRelative = path.posix.relative(root, outDirClient);
+            if (!outDirClientRelative.endsWith('/')) {
+                outDirClientRelative = outDirClientRelative + '/';
+            }
+            console.log(`${pc.dim(outDirClientRelative)}${pc.blue(filePathRelative)}`);
         }
-    });
+    }
 }
 function normalizeOnPrerenderHookResult(prerenderResult, prerenderHookFile, hookName) {
     if (Array.isArray(prerenderResult)) {

package/dist/esm/node/runtime/html/injectAssets/injectAssets__public.js

@@ -1,7 +1,7 @@
 export { injectAssets__public };
 import { assertUsage, assertWarning, castProp, hasProp } from '../../utils.js';
 import { injectHtmlTagsToString } from '../injectAssets.js';
-// TODO: remove this on next semver major
+// TODO/v1-release: remove
 async function injectAssets__public(htmlString, pageContext) {
     assertWarning(false, '`_injectAssets()` is deprecated and will be removed.', { onlyOnce: true, showStackTrace: true });
     assertUsage(typeof htmlString === 'string', '[injectAssets(htmlString, pageContext)]: Argument `htmlString` should be a string.', { showStackTrace: true });

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

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

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

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

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

@@ -29,8 +29,8 @@ function analyzePage(pageFilesAll, pageConfig, pageId) {
           if (configElement.importPath) {
             const { env } = configElement
             assert(env)
-            const onlyAssets = env === 'server-only'
-            const eagerlyImported = env === '_routing-eager'
+            const onlyAssets = env === { server: true }
+            const eagerlyImported = env === { server: true, client: 'if-client-routing', eager: true }
             if (onlyAssets || eagerlyImported) {
               clientDependencies.push({
                 id: configElement.importPath,

package/dist/esm/node/runtime/renderPage/createHttpResponseObject/assertNoInfiniteHttpRedirect.d.ts

@@ -1,2 +1,2 @@
 export { assertNoInfiniteHttpRedirect };
-declare function assertNoInfiniteHttpRedirect(urlRedirectOriginal: string, urlRedirectPathnameLogical: string): void;
+declare function assertNoInfiniteHttpRedirect(urlRedirectTarget: string, urlLogical: string): void;

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

@@ -4,21 +4,21 @@ import pc from '@brillout/picocolors';
 const globalObject = getGlobalObject('assertNoInfiniteHttpRedirect.ts', {
     redirectGraph: {}
 });
-function assertNoInfiniteHttpRedirect(urlRedirectOriginal, urlRedirectPathnameLogical) {
-    if (urlRedirectOriginal.startsWith('http')) {
-        // We assume that the redirect points to an external origin, and we can therefore assume that the app doesn't define an infinite loop (in itself).
-        //  - There isn't a reliable way to check whether the redirect points to an external origin or the same origin: the user usually passes the URL without origin.
+function assertNoInfiniteHttpRedirect(urlRedirectTarget, urlLogical) {
+    if (urlRedirectTarget.startsWith('http')) {
+        // We assume that urlRedirectTarget points to an origin that is external (not the same origin), and we can therefore assume that the app doesn't define an infinite loop (in itself).
+        //  - There isn't a reliable way to check whether the redirect points to an external origin or the same origin. For same origins, we assume/hope the user to pass the URL without origin.
         //    ```js
-        //    // URL origin is usually missing
+        //    // For same-origin, the user usually/hopefully passes a URL without origin
         //    renderPage({ urlOriginal: '/some/pathname' })
         //    ```
         return;
     }
-    assert(urlRedirectOriginal.startsWith('/'));
-    assert(urlRedirectPathnameLogical.startsWith('/'));
+    assert(urlRedirectTarget.startsWith('/'));
+    assert(urlLogical.startsWith('/'));
     const graph = copy(globalObject.redirectGraph);
-    graph[urlRedirectOriginal] ?? (graph[urlRedirectOriginal] = new Set());
-    graph[urlRedirectOriginal].add(urlRedirectPathnameLogical);
+    graph[urlRedirectTarget] ?? (graph[urlRedirectTarget] = new Set());
+    graph[urlRedirectTarget].add(urlLogical);
     validate(graph);
     globalObject.redirectGraph = graph;
 }
@@ -26,6 +26,9 @@ function copy(G) {
     return Object.fromEntries(Object.entries(G).map(([key, val]) => [key, new Set(val)]));
 }
 // Adapted from: https://stackoverflow.com/questions/60904464/detect-cycle-in-directed-graph/60907076#60907076
+function validate(G) {
+    Object.keys(G).forEach((n) => check(G, n, []));
+}
 function check(G, n, path) {
     if (path.includes(n)) {
         const cycle = path.slice(path.indexOf(n)).concat(n);
@@ -33,6 +36,3 @@ function check(G, n, path) {
     }
     G[n]?.forEach((node) => check(G, node, [...path, n]));
 }
-function validate(G) {
-    Object.keys(G).forEach((n) => check(G, n, []));
-}

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

@@ -25,4 +25,4 @@ declare function createHttpResponseObject(htmlRender: null | HtmlRender, renderH
     abortStatusCode?: AbortStatusCode;
 }): Promise<HttpResponse | null>;
 declare function createHttpResponsePageContextJson(pageContextSerialized: string): Promise<HttpResponse>;
-declare function createHttpResponseObjectRedirect({ url, statusCode }: UrlRedirect, urlPathnameLogical: string): HttpResponse;
+declare function createHttpResponseObjectRedirect({ url, statusCode }: UrlRedirect, urlLogical: string): HttpResponse;

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

@@ -33,9 +33,9 @@ async function createHttpResponsePageContextJson(pageContextSerialized) {
     return httpResponse;
 }
 function createHttpResponseObjectRedirect({ url, statusCode }, 
-// The URL pathname we assume the redirect to be logically based on
-urlPathnameLogical) {
-    assertNoInfiniteHttpRedirect(url, urlPathnameLogical);
+// The URL we assume the redirect to be logically based on
+urlLogical) {
+    assertNoInfiniteHttpRedirect(url, urlLogical);
     assert(url);
     assert(statusCode);
     assert(300 <= statusCode && statusCode <= 399);

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

@@ -9,8 +9,7 @@ import { assertHookReturnedObject } from '../../../shared/assertHookReturnedObje
 import { logRuntimeError } from './loggerRuntime.js';
 import pc from '@brillout/picocolors';
 async function executeOnRenderHtmlHook(pageContext) {
-    const hookFound = getRenderHook(pageContext);
-    const { renderHook, hookFn } = hookFound;
+    const { renderHook, hookFn } = getRenderHook(pageContext);
     objectAssign(pageContext, { _renderHook: renderHook });
     preparePageContextForUserConsumptionServerSide(pageContext);
     const hookReturnValue = await executeHook(() => hookFn(pageContext), renderHook.hookName, renderHook.hookFilePath);

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

@@ -7,7 +7,7 @@ import pc from '@brillout/picocolors';
 const streamDocs = 'See https://vike.dev/stream for more information.';
 function getHttpResponseBody(htmlRender, renderHook) {
     if (typeof htmlRender !== 'string') {
-        assertUsage(false, getErrMsg(htmlRender, renderHook, 'body', `Use ${pc.cyan('pageContext.httpResponse.pipe()')} or ${pc.cyan('pageContext.httpResponse.getBody()')} instead`));
+        assertUsage(false, getErrMsg(htmlRender, renderHook, 'body', `Use ${pc.cyan('pageContext.httpResponse.pipe()')} instead`));
     }
     const body = htmlRender;
     return body;

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

@@ -2,7 +2,7 @@ export { renderPage };
 export { renderPage_addWrapper };
 import { getRenderContext, getPageContextInitEnhanced, renderPageAlreadyRouted } from './renderPage/renderPageAlreadyRouted.js';
 import { route } from '../../shared/route/index.js';
-import { assert, hasProp, objectAssign, isParsable, parseUrl, assertEnv, assertWarning, getGlobalObject, checkType, assertUsage, normalizeUrlPathname, removeBaseServer, modifyUrlPathname, prependBase, removeUrlOrigin, addUrlOrigin } from './utils.js';
+import { assert, hasProp, objectAssign, isParsable, parseUrl, assertEnv, assertWarning, getGlobalObject, checkType, assertUsage, normalizeUrlPathname, removeBaseServer, modifyUrlPathname, prependBase, removeUrlOrigin, addUrlOrigin, createUrlFromComponents } from './utils.js';
 import { assertNoInfiniteAbortLoop, getPageContextFromAllRewrites, isAbortError, logAbortErrorHandled } from '../../shared/route/abort.js';
 import { getGlobalContext, initGlobalContext } from './globalContext.js';
 import { handlePageContextRequestUrl } from './renderPage/handlePageContextRequestUrl.js';
@@ -327,10 +327,8 @@ function normalizeUrl(pageContextInit, httpRequestId) {
 function getPermanentRedirect(pageContextInit, httpRequestId) {
     const { redirects, baseServer } = getGlobalContext();
     const urlWithoutBase = removeBaseServer(pageContextInit.urlOriginal, baseServer);
-    let urlOriginalPathnameWithouBase;
     let origin = null;
     let urlTarget = modifyUrlPathname(urlWithoutBase, (urlPathname) => {
-        urlOriginalPathnameWithouBase = urlPathname;
         const urlTargetWithOrigin = resolveRedirects(redirects, urlPathname);
         if (urlTargetWithOrigin === null)
             return null;
@@ -340,13 +338,12 @@ function getPermanentRedirect(pageContextInit, httpRequestId) {
     });
     if (origin)
         urlTarget = addUrlOrigin(urlTarget, origin);
-    assert(urlOriginalPathnameWithouBase);
     if (urlTarget === urlWithoutBase)
         return null;
     logRuntimeInfo?.(`Permanent redirect defined by your config.redirects (https://vike.dev/redirects)`, httpRequestId, 'info');
     urlTarget = prependBase(urlTarget, baseServer);
     assert(urlTarget !== pageContextInit.urlOriginal);
-    const httpResponse = createHttpResponseObjectRedirect({ url: urlTarget, statusCode: 301 }, urlOriginalPathnameWithouBase);
+    const httpResponse = createHttpResponseObjectRedirect({ url: urlTarget, statusCode: 301 }, urlWithoutBase);
     const pageContextHttpResponse = { ...pageContextInit, httpResponse };
     return pageContextHttpResponse;
 }
@@ -390,7 +387,13 @@ async function handleAbortError(errAbort, pageContextsFromRewrite, pageContextIn
             ...pageContextInit,
             ...pageContextAbort
         };
-        const httpResponse = createHttpResponseObjectRedirect(pageContextAbort._urlRedirect, pageContextNominalPageInit.urlPathname);
+        const httpResponse = createHttpResponseObjectRedirect(pageContextAbort._urlRedirect, (() => {
+            const { pathname, searchOriginal } = pageContextNominalPageInit.urlParsed;
+            const urlLogical = createUrlFromComponents(null, pathname, searchOriginal, 
+            // The server-side doesn't have access to the hash
+            null);
+            return urlLogical;
+        })());
         objectAssign(pageContextReturn, { httpResponse });
         return { pageContextReturn };
     }

package/dist/esm/shared/getPageFiles/analyzePageClientSide/determineClientEntry.js

@@ -1,3 +1,4 @@
+// TODO/v1-release: remove
 export { determineClientEntry };
 export { getVikeClientEntry };
 function determineClientEntry({ pageFilesClientSide, pageFilesServerSide, isHtmlOnly, isClientRouting }) {