vike 0.4.150 → 0.4.151-commit-19bc995

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

@@ -0,0 +1,101 @@
+export { assertFileEnv };
+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() {
+    let config;
+    let isDev = false;
+    return {
+        name: 'vike:assertFileEnv',
+        // - 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) {
+                // 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 modulePath = resolved.id.split('?')[0];
+                // `.server.js` and `.client.js` should only apply to user files
+                if (modulePath.includes('/node_modules/'))
+                    return;
+                // TODO/v1-release: remove
+                if (modulePath.endsWith('.css'))
+                    return;
+                const isServerSide = options?.ssr;
+                const envActual = isServerSide ? 'server' : 'client';
+                const envExpect = isServerSide ? 'client' : 'server';
+                const suffix = `.${envExpect}.`;
+                // Everything nonimal
+                if (!modulePath.includes(suffix))
+                    return;
+                // Show error message
+                let errMsg;
+                let modulePathPretty = getFilePathRelativeToUserRootDir(modulePath, config.root);
+                modulePathPretty = modulePathPretty.replaceAll(suffix, pc.bold(suffix));
+                errMsg = `${capitalizeFirstLetter(envExpect)}-only module ${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 = getFilePathRelativeToUserRootDir(importer.split('?')[0], config.root);
+                    errMsg += ` by ${importerPath}`;
+                }
+                if (isDev) {
+                    errMsg += ' (building your app for production will be prevented and an error will be thrown)';
+                }
+                errMsg += '.';
+                if (isDev) {
+                    assertWarning(false, errMsg, { onlyOnce: true });
+                }
+                else {
+                    assertUsage(false, errMsg);
+                }
+            }
+        },
+        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}.`));
+        }
+    };
+}

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

@@ -57,9 +57,10 @@ async function triggerFullBuild(config, configVike, bundle) {
         return; // already triggered
     if (isDisabled(configVike))
         return;
+    /* Is this @vitejs/plugin-legacy workaround still needed? Should we re-implement it?
     // vike.json missing => it isn't a `$ vite build` call (e.g. @vitejs/plugin-legacy calls Vite's build() API) => skip
-    if (!bundle['vike.json'])
-        return;
+    if (!bundle['vike.json']) return
+    */
     const configFromCli = !isViteCliCall() ? null : getViteConfigFromCli();
     const configInline = {
         ...configFromCli,

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

@@ -17,11 +17,11 @@ function baseUrls(configVike) {
             process.env.BASE_ASSETS = baseAssets;
             return {
                 envPrefix: [
-                    'VITE_',
+                    'VITE_', // Vite doesn't seem to merge in its default, see https://github.com/vikejs/vike/issues/554
                     'BASE_SERVER',
                     'BASE_ASSETS'
                 ],
-                base: baseAssets,
+                base: baseAssets, // Make Vite inject baseAssets to imports e.g. `import logoUrl from './logo.svg.js'`
                 _baseOriginal: config.base ?? '/__UNSET__' // Vite resolves `_baseOriginal: null` to `undefined`
             };
         },

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

@@ -1,8 +1,7 @@
 export { buildConfig };
 export { assertRollupInput };
 export { analyzeClientEntries };
-import { assert, resolveOutDir, isObject, viteIsSSR, getFilePathAbsolute, addOnBeforeLogHook, removeFileExtention, unique, assertPosixPath, assertUsage } from '../utils.js';
-import { virtualFileIdImportUserCodeServer } from '../../shared/virtual-files/virtualFileImportUserCode.js';
+import { assert, resolveOutDir, viteIsSSR, getFilePathAbsolute, addOnBeforeLogHook, removeFileExtention, unique, assertPosixPath, assertUsage, injectRollupInputs, normalizeRollupInput } from '../utils.js';
 import { getVikeConfig } from './importUserCode/v1-design/getVikeConfig.js';
 import { getConfigValue } from '../../../shared/page-configs/helpers.js';
 import { findPageFiles } from '../shared/findPageFiles.js';
@@ -13,7 +12,7 @@ import { createRequire } from 'module';
 import { getClientEntryFilePath } from '../../shared/getClientEntryFilePath.js';
 import fs from 'fs/promises';
 import path from 'path';
-// @ts-ignore Shimed by dist-cjs-fixup.js for CJS build.
+// @ts-ignore Shimmed by dist-cjs-fixup.js for CJS build.
 const importMetaUrl = import.meta.url;
 const require_ = createRequire(importMetaUrl);
 const manifestTempFile = '_temp_manifest.json';
@@ -27,14 +26,9 @@ function buildConfig() {
             order: 'post',
             async handler(config) {
                 assertRollupInput(config);
-                const userInputs = normalizeRollupInput(config.build.rollupOptions.input);
                 const entries = await getEntries(config);
                 assert(Object.keys(entries).length > 0);
-                const input = {
-                    ...entries,
-                    ...userInputs
-                };
-                config.build.rollupOptions.input = input;
+                config.build.rollupOptions.input = injectRollupInputs(entries, config);
                 addLogHook();
             }
         },
@@ -72,12 +66,12 @@ async function getEntries(config) {
     const { pageConfigs } = await getVikeConfig(config, false);
     assertUsage(Object.keys(pageFileEntries).length !== 0 || pageConfigs.length !== 0, 'At least one page should be defined, see https://vike.dev/add');
     if (viteIsSSR(config)) {
-        const serverEntries = analyzeServerEntries(pageConfigs);
+        const pageEntries = getPageEntries(pageConfigs);
         const entries = {
-            pageFiles: virtualFileIdImportUserCodeServer,
-            importBuild: resolve('dist/esm/node/importBuild.js'),
+            // importBuild: resolve('dist/esm/node/importBuild.js'), // TODO/next-major-release: remove
             ...pageFileEntries,
-            ...serverEntries
+            // Ensure Rollup generates a bundle per page: https://github.com/vikejs/vike/issues/349#issuecomment-1166247275
+            ...pageEntries
         };
         return entries;
     }
@@ -102,6 +96,14 @@ async function getEntries(config) {
         return entries;
     }
 }
+function getPageEntries(pageConfigs) {
+    const pageEntries = {};
+    pageConfigs.forEach((pageConfig) => {
+        const { entryName, entryTarget } = getEntryFromPageConfig(pageConfig, false);
+        pageEntries[entryName] = entryTarget;
+    });
+    return pageEntries;
+}
 function analyzeClientEntries(pageConfigs, config) {
     let hasClientRouting = false;
     let hasServerRouting = false;
@@ -116,6 +118,7 @@ function analyzeClientEntries(pageConfigs, config) {
             hasServerRouting = true;
         }
         {
+            // Ensure Rollup generates a bundle per page: https://github.com/vikejs/vike/issues/349#issuecomment-1166247275
             const { entryName, entryTarget } = getEntryFromPageConfig(pageConfig, true);
             clientEntries[entryName] = entryTarget;
         }
@@ -133,14 +136,6 @@ function analyzeClientEntries(pageConfigs, config) {
     });
     return { hasClientRouting, hasServerRouting, clientEntries };
 }
-function analyzeServerEntries(pageConfigs) {
-    const serverEntries = {};
-    pageConfigs.forEach((pageConfig) => {
-        const { entryName, entryTarget } = getEntryFromPageConfig(pageConfig, false);
-        serverEntries[entryName] = entryTarget;
-    });
-    return serverEntries;
-}
 // Ensure Rollup creates entries for each page file, see https://github.com/vikejs/vike/issues/350
 // (Otherwise the page files may be missing in the client manifest.json)
 async function getPageFileEntries(config, includeAssetsImportedByServer) {
@@ -196,20 +191,6 @@ function resolve(filePath) {
     // [RELATIVE_PATH_FROM_DIST] Current directory: node_modules/vike/dist/esm/node/plugin/plugins/
     return require_.resolve(`../../../../../${filePath}`);
 }
-function normalizeRollupInput(input) {
-    if (!input) {
-        return {};
-    }
-    // Usually `input` is an oject, but the user can set it as a `string` or `string[]`
-    if (typeof input === 'string') {
-        input = [input];
-    }
-    if (Array.isArray(input)) {
-        return Object.fromEntries(input.map((input) => [input, input]));
-    }
-    assert(isObject(input));
-    return input;
-}
 function addLogHook() {
     const tty = process.stdout.isTTY && !process.env.CI; // Equals https://github.com/vitejs/vite/blob/193d55c7b9cbfec5b79ebfca276d4a721e7de14d/packages/vite/src/node/plugins/reporter.ts#L27
     if (!tty)
@@ -241,5 +222,5 @@ function assertRollupInput(config) {
     const userInputs = normalizeRollupInput(config.build.rollupOptions.input);
     const htmlInputs = Object.values(userInputs).filter((entry) => entry.endsWith('.html') || entry.endsWith('.htm'));
     const htmlInput = htmlInputs[0];
-    assertUsage(htmlInput === undefined, `The entry ${htmlInput} of config build.rollupOptions.input is an HTML entry which is forbidden when using vike, instead follow https://vike.dev/add`);
+    assertUsage(htmlInput === undefined, `The entry ${htmlInput} of config build.rollupOptions.input is an HTML entry which is forbidden when using Vike, instead follow https://vike.dev/add`);
 }

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

@@ -6,7 +6,7 @@ import pc from '@brillout/picocolors';
 import path from 'path';
 import { createRequire } from 'module';
 import { assertResolveAlias } from './commonConfig/assertResolveAlias.js';
-// @ts-ignore Shimed by dist-cjs-fixup.js for CJS build.
+// @ts-ignore Shimmed by dist-cjs-fixup.js for CJS build.
 const importMetaUrl = import.meta.url;
 const require_ = createRequire(importMetaUrl);
 function commonConfig() {

package/dist/esm/node/plugin/plugins/config/resolveExtensions.js

@@ -5,7 +5,7 @@ import fs from 'fs';
 import { isValidFileType } from '../../../../shared/getPageFiles/fileTypes.js';
 import { createRequire } from 'module';
 import pc from '@brillout/picocolors';
-// @ts-ignore Shimed by dist-cjs-fixup.js for CJS build.
+// @ts-ignore Shimmed by dist-cjs-fixup.js for CJS build.
 const importMetaUrl = import.meta.url;
 const require_ = createRequire(importMetaUrl);
 function resolveExtensions(configs, config) {

package/dist/esm/node/plugin/plugins/config/stemUtils.js

@@ -4,7 +4,7 @@ import path from 'path';
 import { assert, assertUsage, assertWarning, toPosixPath, assertPosixPath, getDependencyRootDir, findUserPackageJsonPath } from '../../utils.js';
 import { import_ } from '@brillout/import';
 import { createRequire } from 'module';
-// @ts-ignore Shimed by dist-cjs-fixup.js for CJS build.
+// @ts-ignore Shimmed by dist-cjs-fixup.js for CJS build.
 const importMetaUrl = import.meta.url;
 const require_ = createRequire(importMetaUrl);
 async function getStemPackages(userAppRootDir) {

package/dist/esm/node/plugin/plugins/devConfig/determineFsAllowList.js

@@ -6,7 +6,7 @@ import { assert } from '../../utils.js';
 import { createRequire } from 'module';
 import { dirname } from 'path';
 import { fileURLToPath } from 'url';
-// @ts-ignore Shimed by dist-cjs-fixup.js for CJS build.
+// @ts-ignore Shimmed by dist-cjs-fixup.js for CJS build.
 const importMetaUrl = import.meta.url;
 const require_ = createRequire(importMetaUrl);
 const __dirname_ = dirname(fileURLToPath(importMetaUrl));

package/dist/esm/node/plugin/plugins/importBuild/getVikeManifest.d.ts

@@ -0,0 +1,5 @@
+export { getVikeManifest };
+import { ResolvedConfig } from 'vite';
+import { type PluginManifest } from '../../../shared/assertPluginManifest.js';
+import type { ConfigVikeResolved } from '../../../../shared/ConfigVike.js';
+declare function getVikeManifest(config: ResolvedConfig, configVike: ConfigVikeResolved): PluginManifest;

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

@@ -0,0 +1,32 @@
+export { getVikeManifest };
+import { projectInfo, toPosixPath, assertPosixPath, isNotNullish } from '../../utils.js';
+import { assertPluginManifest } from '../../../shared/assertPluginManifest.js';
+import { isUsingClientRouter } from '../extractExportNamesPlugin.js';
+import path from 'path';
+import { getRuntimeManifest } from '../../../runtime/globalContext.js';
+function getVikeManifest(config, configVike) {
+    const runtimeManifest = getRuntimeManifest(configVike);
+    const manifest = {
+        version: projectInfo.projectVersion,
+        usesClientRouter: isUsingClientRouter(), // TODO/v1-release: remove
+        manifestKeyMap: getManifestKeyMap(configVike, config),
+        ...runtimeManifest
+    };
+    assertPluginManifest(manifest);
+    return manifest;
+}
+function getManifestKeyMap(configVike, config) {
+    const manifestKeyMap = {};
+    configVike.extensions
+        .map(({ pageConfigsDistFiles }) => pageConfigsDistFiles)
+        .flat()
+        .filter(isNotNullish)
+        .forEach(({ importPath, filePath }) => {
+        // Recreating https://github.com/vitejs/vite/blob/8158ece72b66307e7b607b98496891610ca70ea2/packages/vite/src/node/plugins/manifest.ts#L38
+        const filePathRelative = path.posix.relative(config.root, toPosixPath(filePath));
+        assertPosixPath(filePathRelative);
+        assertPosixPath(importPath);
+        manifestKeyMap[importPath] = filePathRelative;
+    });
+    return manifestKeyMap;
+}

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

@@ -1,48 +1,86 @@
 export { importBuild };
-import { importBuild as importBuild_ } from '@brillout/vite-plugin-import-build/plugin.js';
-import { getOutDirs, projectInfo, toPosixPath } from '../../utils.js';
+import { importBuild as importBuild_, findImportBuildBundleEntry } from '@brillout/vite-plugin-import-build/plugin.js';
+import { assert, getOutDirs, projectInfo, toPosixPath, viteIsSSR } from '../../utils.js';
 import path from 'path';
 import { createRequire } from 'module';
-// @ts-ignore Shimed by dist-cjs-fixup.js for CJS build.
+import { getConfigVike } from '../../../shared/getConfigVike.js';
+import { getVikeManifest } from './getVikeManifest.js';
+import fs from 'fs/promises';
+import { virtualFileIdImportUserCodeServer } from '../../../shared/virtual-files/virtualFileImportUserCode.js';
+// @ts-ignore Shimmed by dist-cjs-fixup.js for CJS build.
 const importMetaUrl = import.meta.url;
 const require_ = createRequire(importMetaUrl);
+const ASSETS_MAP = '__VITE_ASSETS_MAP__';
 function importBuild() {
     let config;
+    let configVike;
     return [
         {
             name: 'vike:importBuild:config',
             enforce: 'post',
-            configResolved(config_) {
+            async configResolved(config_) {
                 config = config_;
+                configVike = await getConfigVike(config);
+            },
+            async writeBundle(options, bundle) {
+                if (!viteIsSSR(config))
+                    return;
+                await replace_ASSETS_MAP(options, bundle);
             }
         },
         importBuild_({
-            getImporterCode: ({ findBuildEntry }) => {
-                const pageFilesEntry = findBuildEntry('pageFiles');
-                return getImporterCode(config, pageFilesEntry);
+            getImporterCode: () => {
+                return getEntryCode(config, configVike);
             },
             libraryName: projectInfo.projectName
         })
     ];
 }
-function getImporterCode(config, pageFilesEntry) {
-    const filePathAbsolute = toPosixPath(
-    // [RELATIVE_PATH_FROM_DIST] Current file: node_modules/vike/dist/esm/node/plugin/plugins/importBuild/index.js
-    require_.resolve(`../../../../../../dist/esm/node/runtime/globalContext/loadImportBuild.js`));
-    const { outDirServer } = getOutDirs(config);
-    const filePathRelative = path.posix.relative(outDirServer, filePathAbsolute);
-    // The only reason we went for using CJS require() instead of ESM import() is because import() doesn't support .json files
+function getEntryCode(config, configVike) {
+    const importPath = getImportPath(config);
+    const vikeManifest = getVikeManifest(config, configVike);
     const importerCode = [
-        '(async () => {',
-        `  const { setImportBuildGetters } = await import('${filePathRelative}');`,
+        `  import { setImportBuildGetters } from '${importPath}';`,
+        `  import * as pageFiles from '${virtualFileIdImportUserCodeServer}';`,
         '  setImportBuildGetters({',
-        `    pageFiles: () => import('./${pageFilesEntry}'),`,
-        "    clientManifest: () => require('../assets.json'),",
-        // TODO: use virtual file instead of generating vike.json
-        "    pluginManifest: () => require('../client/vike.json'),",
+        `    pageFiles: () => pageFiles,`,
+        // TODO: rename clientManifest -> assetManifest
+        `    clientManifest: () => { return ${ASSETS_MAP} },`,
+        // TODO: rename pluginManifest -> vikeManifest
+        `    pluginManifest: () => (${JSON.stringify(vikeManifest, null, 2)}),`,
         '  });',
-        '})()',
         ''
     ].join('\n');
     return importerCode;
 }
+async function replace_ASSETS_MAP(options, bundle) {
+    const { dir } = options;
+    assert(dir);
+    // I guess importBuild won't be found in the bundle when using @vitejs/plugin-legacy
+    const importBuildEntry = findImportBuildBundleEntry(bundle);
+    const importBuildFilePath = path.join(dir, importBuildEntry.fileName);
+    const assetsJsonFilePath = path.join(dir, '..', 'assets.json');
+    const [assetsJsonString, importBuildFileContent] = await Promise.all([
+        await fs.readFile(assetsJsonFilePath, 'utf8'),
+        await fs.readFile(importBuildFilePath, 'utf8')
+    ]);
+    const importBuildFileContentFixed = importBuildFileContent.replace(ASSETS_MAP, assetsJsonString);
+    assert(importBuildFileContentFixed !== importBuildFileContent);
+    await fs.writeFile(importBuildFilePath, importBuildFileContentFixed);
+}
+function getImportPath(config) {
+    // We resolve filePathAbsolute even if we don't use it: we use require.resolve() as an assertion that the relative path is correct
+    const filePathAbsolute = toPosixPath(
+    // [RELATIVE_PATH_FROM_DIST] Current file: node_modules/vike/dist/esm/node/plugin/plugins/importBuild/index.js
+    require_.resolve(`../../../../../../dist/esm/node/runtime/globalContext/loadImportBuild.js`));
+    if (
+    // Let's implement a new config if a user needs the import to be a relative path instead of 'vike/__internal/loadImportBuild' (AFAIK a relative path is needed only if a framework has npm package 'vike' as direct dependency instead of a peer dependency and if the user of that framework uses pnpm)
+    true) {
+        return 'vike/__internal/loadImportBuild';
+    }
+    else {
+        const { outDirServer } = getOutDirs(config);
+        const filePathRelative = path.posix.relative(outDirServer, filePathAbsolute);
+        return filePathRelative;
+    }
+}

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

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

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

@@ -36,6 +36,9 @@ const configDefinitionsBuiltIn = {
     guard: {
         env: { server: true, client: 'if-client-routing' }
     },
+    data: {
+        env: { server: true }
+    },
     iKnowThePerformanceRisksOfAsyncRouteFunctions: {
         env: { server: true, client: 'if-client-routing', eager: true }
     },
@@ -76,8 +79,15 @@ const configDefinitionsBuiltIn = {
         env: { client: true },
         _computed: (configValueSources) => !isConfigSet(configValueSources, 'onBeforeRender') ? null : getConfigEnv(configValueSources, 'onBeforeRender')
     },
+    dataEnv: {
+        env: { client: true },
+        _computed: (configValueSources) => !isConfigSet(configValueSources, 'data') ? null : getConfigEnv(configValueSources, 'data')
+    },
     hooksTimeout: {
         env: { server: true, client: true }
+    },
+    cacheControl: {
+        env: { server: true }
     }
 };
 const configDefinitionsBuiltInGlobal = {

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

@@ -1,26 +1,27 @@
 export { crawlPlusFiles };
-import { assertPosixPath, assert, toPosixPath, assertWarning, scriptFileExtensionList, scriptFileExtensions } from '../../../../utils.js';
+import { assertPosixPath, assert, toPosixPath, assertWarning, scriptFileExtensionList, scriptFileExtensions, getGlobalObject } from '../../../../utils.js';
 import path from 'path';
 import glob from 'fast-glob';
 import { exec } from 'child_process';
 import { promisify } from 'util';
 const execA = promisify(exec);
+const globalObject = getGlobalObject('crawlPlusFiles.ts', {
+    gitIsMissing: false
+});
 async function crawlPlusFiles(userRootDir, outDirAbsoluteFilesystem, isDev) {
     assertPosixPath(userRootDir);
     assertPosixPath(outDirAbsoluteFilesystem);
-    // Vike prepends userRootDir without resolving, e.g. outDirRelativeFromUserRootDir can be /home/rom/my-monorepo/my-app/../my-build/dist/ while userRootDir is /home/rom/my-monorepo/my-app/
-    assert(outDirAbsoluteFilesystem.startsWith(userRootDir));
     let outDirRelativeFromUserRootDir = path.posix.relative(userRootDir, outDirAbsoluteFilesystem);
     if (outDirRelativeFromUserRootDir.startsWith('../')) {
         // config.outDir is outside of config.root => it's going to be ignored anyways
         outDirRelativeFromUserRootDir = null;
     }
     assert(outDirRelativeFromUserRootDir === null || !outDirRelativeFromUserRootDir.startsWith('.'));
-    const timeBase = new Date().getTime();
+    const timeBefore = new Date().getTime();
     let files = [];
     const res = await gitLsFiles(userRootDir, outDirRelativeFromUserRootDir);
     if (res &&
-        // Fallback to fast-glob for users that dynamically generate plus files (we assume generetad plus files to be skipped because they are usually included in .gitignore)
+        // Fallback to fast-glob for users that dynamically generate plus files. (Assuming all (generetad) plus files to be skipped because users usually included them in `.gitignore`.)
         res.length > 0) {
         files = res;
     }
@@ -28,10 +29,11 @@ async function crawlPlusFiles(userRootDir, outDirAbsoluteFilesystem, isDev) {
         files = await fastGlob(userRootDir, outDirRelativeFromUserRootDir);
     }
     {
-        const time = new Date().getTime() - timeBase;
+        const timeAfter = new Date().getTime();
+        const timeSpent = timeAfter - timeBefore;
         if (isDev) {
-            // We only warn in dev, because while building it's expected to take a long time as fast-glob is competing for resources with other tasks
-            assertWarning(time < 2 * 1000, `Crawling your user files took an unexpected long time (${time}ms). Create a new issue on Vike's GitHub.`, {
+            // We only warn in dev, because while building it's expected to take a long time as crawling is competing for resources with other tasks.
+            assertWarning(timeSpent < 2 * 1000, `Crawling your user files took an unexpected long time (${timeSpent}ms). Create a new issue on Vike's GitHub.`, {
                 onlyOnce: 'slow-page-files-search'
             });
         }
@@ -50,37 +52,54 @@ async function crawlPlusFiles(userRootDir, outDirAbsoluteFilesystem, isDev) {
 }
 // Same as fastGlob() but using `$ git ls-files`
 async function gitLsFiles(userRootDir, outDirRelativeFromUserRootDir) {
-    if (!(await isUsingGit(userRootDir)))
+    if (globalObject.gitIsMissing)
         return null;
+    const ignoreAsPatterns = getIgnoreAsPatterns(outDirRelativeFromUserRootDir);
+    const ignoreAsFilterFn = getIgnoreAsFilterFn(outDirRelativeFromUserRootDir);
     const cmd = [
         'git ls-files',
         ...scriptFileExtensionList.map((ext) => `"**/+*.${ext}"`),
-        ...getIgnorePatterns(outDirRelativeFromUserRootDir).map((pattern) => `--exclude="${pattern}"`),
+        ...ignoreAsPatterns.map((pattern) => `--exclude="${pattern}"`),
         // --others lists untracked files only (but using .gitignore because --exclude-standard)
         // --cached adds the tracked files to the output
         '--others --cached --exclude-standard'
     ].join(' ');
-    let files = await runCmd(cmd, userRootDir);
-    files = files.filter(
-    // We have to repeat the same exclusion logic here because the `git ls-files` option --exclude only applies to untracked files. (We use --exclude only to speed up the command.)
-    (file) => getIgnoreFilter(file, outDirRelativeFromUserRootDir));
-    // Remove tracked but deleted files
-    const filesIgnore = await runCmd('git ls-files --deleted', userRootDir);
-    files = files.filter((file) => !filesIgnore.includes(file));
+    let files;
+    let filesDeleted;
+    try {
+        ;
+        [files, filesDeleted] = await Promise.all([
+            // Main command
+            runCmd(cmd, userRootDir),
+            // Get tracked by deleted files
+            runCmd('git ls-files --deleted', userRootDir)
+        ]);
+    }
+    catch (err) {
+        if (await isGitMissing(userRootDir)) {
+            globalObject.gitIsMissing = true;
+            return null;
+        }
+        throw err;
+    }
+    files = files
+        // We have to repeat the same exclusion logic here because the `git ls-files` option --exclude only applies to untracked files. (We use --exclude only to speed up the command.)
+        .filter(ignoreAsFilterFn)
+        .filter((file) => !filesDeleted.includes(file));
     return files;
 }
 // Same as gitLsFiles() but using fast-glob
 async function fastGlob(userRootDir, outDirRelativeFromUserRootDir) {
     const files = await glob(`**/+*.${scriptFileExtensions}`, {
-        ignore: getIgnorePatterns(outDirRelativeFromUserRootDir),
+        ignore: getIgnoreAsPatterns(outDirRelativeFromUserRootDir),
         cwd: userRootDir,
         dot: false
     });
     return files;
 }
 // Same as getIgnoreFilter() but as glob pattern
-function getIgnorePatterns(outDirRelativeFromUserRootDir) {
-    const ignorePatterns = [
+function getIgnoreAsPatterns(outDirRelativeFromUserRootDir) {
+    const ignoreAsPatterns = [
         '**/node_modules/**',
         // Allow:
         // ```
@@ -91,31 +110,30 @@ function getIgnorePatterns(outDirRelativeFromUserRootDir) {
     ];
     if (outDirRelativeFromUserRootDir) {
         assert(!outDirRelativeFromUserRootDir.startsWith('/'));
-        ignorePatterns.push(`${outDirRelativeFromUserRootDir}/**`);
+        ignoreAsPatterns.push(`${outDirRelativeFromUserRootDir}/**`);
     }
-    return ignorePatterns;
+    return ignoreAsPatterns;
 }
 // Same as getIgnorePatterns() but for Array.filter()
-function getIgnoreFilter(file, outDirRelativeFromUserRootDir) {
-    assert(!file.startsWith('/'));
+function getIgnoreAsFilterFn(outDirRelativeFromUserRootDir) {
     assert(outDirRelativeFromUserRootDir === null || !outDirRelativeFromUserRootDir.startsWith('/'));
-    return (!file.includes('node_modules/') &&
+    return (file) => !file.includes('node_modules/') &&
         !file.includes('.telefunc.') &&
-        (!outDirRelativeFromUserRootDir || !file.startsWith(`${outDirRelativeFromUserRootDir}/`)));
+        (outDirRelativeFromUserRootDir === null || !file.startsWith(`${outDirRelativeFromUserRootDir}/`));
 }
 // Whether Git is installed and whether userRootDir is inside a Git repository
-async function isUsingGit(userRootDir) {
+async function isGitMissing(userRootDir) {
     let res;
     try {
         res = await execA('git rev-parse --is-inside-work-tree', { cwd: userRootDir });
     }
     catch {
-        return false;
+        return true;
     }
     const { stdout, stderr } = res;
     assert(stderr.toString().trim() === '');
     assert(stdout.toString().trim() === 'true');
-    return true;
+    return false;
 }
 async function runCmd(cmd, cwd) {
     const res = await execA(cmd, { cwd });